►
From YouTube: JSON support in Jakarta EE Present and Future | JakartaOne Livestream - September 2019
Description
Speaker: Dmitry Kornilov
JSON support is an important part of Jakarta EE. This session provides a deep dive into JSON-P and JSON-B APIs, explains how they are connected and can be used together.
///GET SOCIAL!
Subscribe: https://www.youtube.com/user/EclipseFdn
Follow us on Twitter: https://twitter.com/JakartaEE
Follow the conference: https://twitter.com/JakartaOneConf
Like us on Facebook: https://www.facebook.com/JakartaEE/
Become a member of our Jakarta Tech Talks Meetup: https://www.meetup.com/jakartatechtal...
Join us on LinkedIn: https://www.linkedin.com/groups/13597...
Tag us: #JakartaEE #JakartaOneLivestream
A
So
hello
welcome
back
long
time
no
see
Dimitri
is
back
with
his
PowerPoint
and
a
new
speaker
Andy,
and
they
will
speak
about
JC
support
in
Jakarta
you
right
now
and
at
about
the
future,
so
I
hope,
Jason,
P,
Jason,
B
and
I'm
really
curious
about
that.
So
please
share
your
screen
and
I
would
just
disappear
right
now.
A
B
It
works
now:
okay,
Jason
support
in
Jakarta
he
present
and
future
a
little
bit
about
ourselves.
So
my
name
is
Dimitri
Kornilov
I'm
from
Oracle
I'm,
Jakarta,
Jason
brought
system
congestion,
binding
project
lead
I'm,
also,
a
clip
C
for
JP,
a
member
and
I
have
another
speaker,
ng
givers
he's
from
IBM,
and
he
is
Jakarta
Jason
for
like
a
transition.
Biden
project
leads
to
over
here
to
leads
in
Jakarta
Jason
binding
project
agenda.
For
today,
I
will
do
an
introduction
about
the
Jason.
What
Jason
is
after
that?
B
Next
is
Jason,
binding,
Hussein,
think
about
Jason
binding
and
at
the
end,
I
will
pass
to
Andy
and
Andy
will
present
new
features
of
Jason
binding,
which
we
are
planing
to
add
to
the
next
version
of
the
spec.
So
trust
free
bullet
is
actually
present
and
the
plans
is
the
future
start
their
play.
D,
let's
get
started
the
usual
safe,
harbor
statement.
You
should
not
make
critical
business
decision
based
on
this
session
and
come
into
their
introduction.
B
What
is
Jay
so
I
think
maybe
I
don't
need
to
explain
what
Jason
is,
but
we
are
talking
about
Jason.
So
let
me
do
that
so.
Javascript
object,
notation,
open
standard,
RFC,
7159
and
8259,
so
I
put
two
here
because
8259
is
the
latest
one
and
7159
is
actually
what
easy
used
in
the
spec
so,
which
is
what
we
actually
support.
We
don't
have
support
for
8259,
possibly
go
edits
to
the
new
version
of
the
spec.
B
Jason
is
text
based.
So
here
is
a
sample
here.
It's
language
independent,
it's
very
nicely
readable
by
the
humans
and
it's
supported
in
most
of
languages,
possibly
all
languages,
so
magic
makes
it
very
attractive
as
a
lightweight
data
interchange
format,
so
which
I
think
all
of
us
is
using
it
for
Jason
supports
free,
primitive
types,
link
number
in
to
structure
types,
which
is
a
real
object
and
null
so
in
this
sample.
You
can
find
all
of
them.
Source
drinks
are
here
drawn
and
orb
in
their
quotes.
Venus
drinks
number
without
quads,
which
is
age.
B
B
How
Jason
is
supported
in
Jakarta
II,
so
we
have
two
api's,
one
is
Jakarta
Jason
processing
and
another
one
is
Jakarta.
Jason,
pining
and
Jason
processing
is
a
low-level
API.
It's
basically
a
parser.
It's
used
to
parse
generate
transform
and
query
jason.
It
consists
of
two
EP
eyes
and
similar
to
DOM
and
stocks.
If
you
have
a
million
different
XML
world
and
Jakarta
Jason
Biden
is
a
higher
level
API
and
it's
used
to
bind
the
JSON
documents
to
Java
objects.
It
actually
uses
JSONP
itself
and
it's
if
we
started
to
compare
it
to
XML
Wars.
B
So
it's
similar
to
Jax
be
let's
talk
about
Jason
cross
here,
I
collected
some
useful
links,
so
when
you
browse
with
slides
offline,
you
can
connect
them
expected
means
I'll,
upload
of
slides
to
SlideShare
after
this
presentation,
immediately
after
that,
yeah
and
post
a
link
to
the
chat,
so
Jakarta
Jason
processes,
Jakarta
project,
so
it's
hosted
by
clips
foundation
it's
on
github,
so
our
website
is
actually
github
pages
of
our
repository.
So
you
see
keep
z4j
here.
B
B
Okay,
Jason
tink
has
to
API
streaming
API
and
object
model
API.
What's
the
difference
streaming
API
is
event
based,
so
it's
basically
mainly
used.
Then
you
have
some
stream
of
Jason
and
would
like
to
process
it.
You
can
have
access
to
only
one
element
at
a
time
that
it's
efficient
for
high
volume
of
data,
and
it's
has
it's
very
small
memory
footprint
so
are
similar
to
stocks
and
object.
B
To
classes
Jason
parcel
Jason
generator
start
with
parser
right,
so
JSON,
parser,
parses
Jason
in
a
streaming
grey
from
input
sources,
different
deeper
sources
supported
similar
to
stalks,
mentioned
it
already
XML
stream
reader
right.
So
this
is
what
is
similar
to
you:
can
create
it
using
a
factory
method,
Jason
create
parser
or
Jason,
create
parser
factory,
create
parser.
What's
the
difference?
First
of
all,
in
Jason
P
varies
adjacent
class,
which
contains
quite
a
lot
of
factory
methods
to
create
everything.
B
So
if
you
don't
know
what
to
do,
if
you
need
to
create
something,
you
don't
know
how
to
create.
The
easy
point
is
in
your
IDE
type:
Jason
dot.
Then
you
will.
Your
IDE
will
suggest
what
you
can
do
right.
Difference
between
these
two
is
create
parcel,
just
create
a
parser
with
all
overhead
of
creating
that.
But
if
you
want
to
take
advantage
of
caching,
then
or
reuse
in
your
instance,
then
you
should
use
the
second
one.
Great
parser
Factory
create
parser.
B
You
can
pass
actually
some
parameters
there
like
configuration,
configuration
is
limitation
dependence
and
then
you
created
the
parser
and
it
will
start
parsing
to
document
in
it.
Erases
events,
then
it
finds
a
token,
and
the
list
of
events
are
here.
So
start
array
start
object
key
when
you
string,
when
you
number
and
so
on,
I'll
have
a
nice
DMA
demonstrating
you.
So
you
understand
it
better.
B
Imagine
that
we
have
this
kind
of
document
and
when
we
start
parsing
of
this
document,
parser
first
of
all,
it
finds
the
curly
bracket
right
in
this
case,
it
raises
start
object
to
that
right.
It
goes
next.
Next
is
the
key,
so
key
name
event
is
raised
like
next
one
value
and
actually
value
string,
string
values.
So
will
your
string
event
is
raised?
New
key
in
this
case
here
is
a
number.
So
will
your
number
event
this
way?
So
basically,
the
kind
of
type
is
caught
it
inside
the
event.
B
Name
it
another
key
R,
and
here
we
meet
the
first
square
bracket.
So
it
starts
the
array.
So
start
array
index
raised
another
object,
another
type,
another
string,
another
type,
sorry
key,
of
course,
another
string
here
we
have
a
closed
curly
bracket,
so
it's
end
object
here.
We
have
closed
square
bracket
and
array
and
will
last
end
object.
So
this
is
basically
the
most
basic
concept
of
how
if
the
enter
agent
works,
how
it
looks
in
Java
in
Java.
B
It
looks
like
that,
so
you
create
your
parser
using
I
use
the
first
method
for
simplicity,
JSON
or
create
parser,
and
after
that
you
do
parcel
dot
next,
it
moves
your
pointer
to
the
next
talking
to
the
next
element
of
your
Jason.
So
basically,
if
then
is
start
object
in
this
case,
talking
is
here
right.
Parcel
next
jumps
to
the
key
key
name
is
raised
to
read
the
radio
of
the
key.
You
can
use
parcel,
don't
get
string,
so
name
will
be
returned
and
so
on
and
so
on,
and
so
on
so
forth.
B
B
B
There
are
two
ways
to
create:
it
again:
create
generator
the
pub
where
were
had,
which
caused
by
creation
of
the
object
or
create
generator
factory,
create
generator.
In
this
case,
please
use
it.
Then
you
want
to
reuse
way.
Instance,
you
can
pass
some
parameters
to
create
generator
through
a
second
method
like
pretty
printing
and
some
other
parameters
implementation-dependent,
and
it
uses
to
build
a
pattern
and
here
comes
to
sample.
So
this
code
generates
these
JSON
document.
So
it's
an
array
of
objects
right,
so
we
create
this
generator
and
after
that
Siva
Builder
pattern.
B
Nice
builder
button
is
here,
so
you
do
right,
start
array
which
writes
a
square
bracket
right,
star
object
which
writes
'carly
bracket
after
you
use
a
variety
of
right
methods
with
key
will
you
write
and
after
that
you
just
do
right
end
and
generator
automatically
puts
a
proper
bracket
there.
So
if
you
are
inside
the
object,
abuser
closing
curly
bracket,
if
you
are
inside
the
array
here,
it
puts
the
closing
square
bracket
and
close
it
at
the
end
very
easy.
B
That's
it
about
streaming
KPI
now,
let's
talk
about
object,
model
API
and
it's
similar
to
dome
as
I
was
saying
already,
and
it
has
a
builder
to
build
JSON
object
and
a
tional
array
from
scratch.
It's
type
safe.
So
you
can't
mix
array
in
object,
building
methods
and
you
are
actually
you
also
can
use
existing
JSON
object,
condition
erase
in
the
Builder.
So
you
build
something
and
you
want
to
include
another.
Existing
JSON
object
there.
B
B
Factory
method,
you
add
their
adjacent
object,
which
you
build
using
object
builder,
which
you
create
using
another
static
factory
methods
of
json
object.
Right,
you
add
your
key
values
there
and
after
that
you
build
the
second
one
and
so
on,
and
you
build
the
result
at
the
end
and
it
builds
it
in
memory.
Right
uses
atom
model.
This
is
how
it
works.
B
Another
thing
supported
by
JSONP,
and
here
we
are
coming
to
a
features:
Mishu
introduces
and
JSONP
1.1
spec
right.
So
all
previous
stop
was
a
part
of
Jason
p10
and
Jason
poor
intern
Jason
page
in
Jason,
norge,
page
I,
part
of
Jason
p1
that
one
so
Jason
pointer.
It's
an
open
standard,
RFC
6901
and
it's
just
the
syntax
of.
B
Identifying
a
specific
value
inside
the
adjacent
document,
something
similar
to
XPath
but
simpler,
so
it
always
starts
with
a
slash
means
root
and
after
that
you
put
a
property
and
if
it's
an
object
and
property
of
this
object.
So
it's
really
easy.
If
it's
array,
then
you
put
a
number
there
and
array
count
from
0.
B
So
0
is
the
first
element
of
array,
so
this
pointer
points
to
the
first
element
of
parent
Sri
and
special
characters
is
actually
slash
which
is
converted
to
tilde
1
and
tilde,
which
is
converted
to
to
0
it's
better
to
demonstrate
it
using
a
sample.
You
mentioned
that
we
have
this
kind
of
JSON
document
and
what
we
want
to
do
here.
We
want
to
take
the
second
element
from
the
list,
which
is
Jane
right
and
replace
your
last
name
doe.
It
doesn't
have
it
right.
B
So
what
are
we
doing?
We
are
creating
a
pointer
to
these
property,
how
to
do
it
from
the
root
we
take
a
second
one
min
second,
first
second
element
of
array
and
we
are
taking
last
name
property
from
there.
So
this
is
our
JSON
pointer
and
we
create
jason
pointer
again
using
our
favorite
factory
method
of
adjacent
class.
Here
now
to
replace
the
value
we
call
pointer,
replace,
pass
the
original
object
and
what
to
replace
it
with
we
replacing
it
with
string
dough
and
to
check
the
result.
B
We
read
it
back
right,
so
we
do
pointer,
get
value
and
passing
there
from
Beach
the
object.
We
want
to
get
this
value
and
it
should
return
the
new
update
20,
which
is
done
so
you
see
that
it's
very
easy
to
use
next
feature:
jacent
patch,
again
open
standard,
RFC,
69,
zero,
two
and
Jason
patch
is
used
to
modify
parks
on
JSON
document.
Imagine
that
you
have
a
big
JSON
document.
B
Then
you
have
a
patch
which
actually
a
JSON
document
itself,
and
it
has
a
special
defined
syntax,
which
consists
of
elements
and
each
element
has
operation
path
and
value
and
value
is
optional
because
of
some
operations
like
remove.
For
instance,
dozen
in
a
value,
so
operation
is
operation
from
this
list
and
replace
removed,
move
copy
test
and
path
is
adjacent
pointer
to
the
elements
to
process
right.
So
basically
inside
the
patch
we
can
code
whatever
operations
modifying
operations
we
want
I
have
a
sample
for
that.
B
If
we
have
this
original
document
again,
this
is
a
list
of
some
people,
so
have
John
Doe
here,
I
have
Jane
Doe
here
and
you
see
where
I
kept
John
Doe
duplicated
here
right.
So
this
patch
consists
of
two
operations
and
the
first
operation
is
a
replaces
Ville
last
name
of
a
second
element
with
dog.
Basically
the
same.
What
well
I
was
demonstrated
in
Jason,
pointer
and
well.
Second,
operation
is
a
removing
the
last
element-
the
third
one
which
we
don't
need.
So
look
to
change
your
value,
we're
using
the
replace
operation.
B
We
are
providing
path
to
our
property,
to
change
second
element
of
the
least
property
last
name
and
provided
a
new
venue
door.
This
is
what
I've
done
in
Jason
pointer
demonstration
and
the
second
operation
remove
and
we're
providing
a
path
to
the
element
pointer
to
element
to
remove,
which
is
third
element,
and
it
will
remove
goodies,
and
here
is
how
it
looks
in
Java.
B
So
we
can
create
Jason
patch
using
jason
punch
builder
in
java.
In
this
case,
we
don't
need
any
Jason
document,
we'll
just
build
it
and
we
can
build
it
using
create
page
builder
method.
Factory
method
in
Jason
class
operations
are
coded
by
method.
Names
over
is
a
replacement
for
easily
move
method,
add
and
so
on
and
provide
parameters
there
and
you
can
apply
patch
using
fetch
apply,
and
you
provide
an
object
to
apply
it
to
right.
B
B
Okay,
that's
just
about
jason
page
and
actually
we
support
another
page
called
jason,
merge
page,
it's
another
standard,
RFC,
73,
96
and
merge
page
is
different
from
the
previous
page.
I
advanced
rated,
because
this
is
like
a
gift
like
merging
right,
so
your
patch
is
adjacent
document
itself
having
the
same
structure
as
your
original
document,
you
just
provide
some
changes
there,
and
these
changes
are
merged
into
your
original
document.
Again,
it's
it
like
experience.
B
You
can
create
merge
page
using
the
same
patterns
like
effective
methods
in
JSON
class,
and
you
create
a
merge
patch
based
on
this
data,
and
you
apply
to
some
document
using
merge.
Patch
multiply
and
I
have
a
sample
for
better
understanding.
Your
one
jason
merge
veggies.
So
imagine
that
you
have
a
source
document.
It
has
free
fields,
first
name
last
name
and
address,
and
you
have
a
patch
right
which
you
want
to
merge,
then
what
this
patch
has
it
has.
B
A
new
value
for
last
name
is
empty
misc
as
though
it
has
a
new
property
age,
and
it
sets
address
to
null
which
is
equivalent
to
delete,
and
if
you
merge
that
with
this
one
you
will
get
this
result.
So
first
name
is
untouched.
A
last
name
is
changed,
H
is
added
and
address
is
deleted.
So
this
is
how
Jason
merge
patch
works,
but
set
about
Jason
processing,
so
Jason
proto
stick
is
very
small
and
easy
to
use
API
actually
in
the
lower
level
which
you
can
do
with
Jason.
Whatever
you
want
now.
B
B
When
we
create
adjacent
binding
specification,
we
tried
to
standardize
the
most
useful
features
of
another
binding
framers
like
Jackson,
Jensen
and
Jason.
So
we
took
some
heavily
used
functions
there
and
standardized
them.
Actually,
the
guys
from
Jensen
and
Jason
were
part
of
the
expert
group.
So
we
worked
together
on
the
standard.
So
there
are
two
features
of
Jason
Biden.
First
of
all,
we
try
to
make
it
nice
by
default,
so
it
supports
most
of
Internet.
B
B
B
B
Now
I
will
talk
about
default
mapping
and
the
next
section
is
customizations
right
so
default
mapping.
This
is
how
Jason
B
defaults
by
default
when
no
customization
is
present.
So
no
configurations,
no
annotations,
Jason
B
with
default
settings
can
be
created
with
one
string
corporation
Jason
B
builder,
create
that's
it
regulation
B.
If
you
want
to
reuse
it
cache
it
don't
use.
Jason
VB
will
create
again
because
this
is
expensive,
the
scope
of
default
mapping.
B
This
is
how
spec
says
right
so
I'm
talking
about
the
spec
in
spec
default
mapping
is
defined
for
basic
type,
specific
GDK
types
dates,
classes,
collections,
arrays,
enumerations
and
also
JSONP
model
classes
supported.
Let's
talk
about
this
a
little
bit
more,
but
before
that
you've
seen
here
that
Jason
B
engine
is
created.
So
here
I
explain
what
methods
Jason
B
has
it's
an
interface
which
has
a
variety
of
from
Jason
and
to
Jason
methods.
B
B
First
of
all,
you
create
a
model,
a
person
class
which
is
John
Doe,
put
properties
there
if
second
person,
Jane
Doe
or
putting
properties
there.
You
create
your
a
you.
Put
these
two
persons
into
the
array.
Then
here
actually
the
binding
parts
comes.
You
create
a
Jason
B
and
you
call
Jason
B,
Jason
and
pastor
this
array.
That's
it
it's
very
easy
and
it
will
produce
real
Jason.
So
this
is
a
preparation
part.
This
is
actually
binding.
Part
okay,
I
was
started.
Talking
about
the
scope
of
default
mapping.
B
Date/Time
here
is
a
table.
It's
gonna
be
small
for
you
right,
but
I
wanted
to
put
everything
into
one
slide.
So
these
are.
The
datum
class
is
supported
by
the
spec,
and
here
are
the
formats
used
by
this
datum
classes.
The
formats
looks
different,
but
if
you
see
all
of
them
are
ISO
format
and
it's
one
of
the
ideas
and
requirements
that
date
times
I
serialized,
deserialized
use
it
I
saw
four
months
so
Aug
night.
B
So
for
us
here,
if
I
use
it
calendar
and
the
time
portion
is
not
present
there,
then
it's
not
present
in
the
corresponding
Jason
Tucker.
Here
I
have
a
sample
so
Java
till
date.
Okay,
don't
use
it.
You
should
use
the
local
date
definitely,
but
for
some
reason
I
don't
have
it
here
so
Charu
till
date.
You
use
this
format
and
then
you
see
realize
it.
The
result
is
going
to
be
this
calendar
without
the
time
portion
result.
Is
this
ISO
format
right,
instant
duration,
pin
use?
All
of
these
are
ISO
for
a.
B
Recent
collections,
actually
spec
defines
all
erasing
collection
class.
It
supports
all
of
them
are
listed
here
for
some
reason,
when
we
created
the
spec,
we
miss
the
new
set
and
a
new
map
there
right,
so
we're
1882
the
Jason
bit.
Next,
there
is
nothing
more
to
say
about
collection,
just
supports
with
bread
and
JSONP
types,
so
these
JSONP
types
are
supported.
So
it's
value
point
of
string,
number
object,
array
and
structure,
and
this
is
a
sample
demonstrating
how
JSONP
times
the
processed.
B
B
Classes,
what
kind
of
classes
support
so
a
public
and
protected
nested
and
Static
nested
classes
supported
anonymous
classes
supported
only
for
serialization
inheritance
is
supported
and
default.
No
argument
constructor
is
required
for
default
deserialization.
So
if
you
don't
have
it,
the
process
will
fail.
B
What
kind
of
fields
are
support?
Final
fields
are
only
she
realized.
Static
fields
are
not
supported.
I
skipped,
transient
fields
are
skipped
now,
fields
are
skipped,
so
we're
not
serializing
fields
given
null
values
worsen
when
a
special
customization
for
that
called
Jason,
B
nillable
I'll
talk
about
it
later,
which
enables
serializing
methods
by
default.
B
The
field
order
is
lexicographical,
lexicographical
means
from
A
to
Z
and
in
case
of
heritance
parent
class
fields
are
serialized
before
which
share
class
fields
are
coded
that
Jason
B
respects
parents
here,
I
have
a
sample,
so
I
have
a
parent
class
with
two
properties.
Parent
B
and
Part
A
default
serialization
produces
finish
Jason
document.
You
see
that
parent
a
is
before
parent
B,
so
it's
sorted
out,
alphabetically,
lexicographical
or
more
complicated
case.
We
have
inheritance
here.
B
So
we
have
a
child
which
extends
parent,
has
two
fields:
she'll
be
chillin
a
if
we
serialize
it
will
produce
this
document.
No
without
the
empty
line.
All
right,
you
see
that
Jason
B
respects
parents,
so
it
puts
parent
properties
before
child
properties
and
inside
each
class
properties
are
sorted
from
A
to
Z
part,
eight,
better,
be
child
a
charity.
So
that's
the
default
behavior
it
can
be.
Customized
can
be
changed,
I'll
talk
about
it
in
the
customization
section,
now:
scope
and
field
access
strategy.
B
B
Jason
B
also
respects
visibility
of
fields.
So,
if
setter
or
getter
is
private,
then
this
property
is
going
to
be
skipped
right.
What
it
is
we're
trying
to
serialize
some
property,
she
has
a
private
setter,
it
won't
be
sharing
and
it
supports
properties
without
Gator
setters,
respecting
their
visibility
and
in
case
we
have
a
pair
getter
and
setter
without
the
corresponding
field.
It's
supported
here,
I,
have
some
sample
and
to
demonstrate
that
so
I
have
a
class
called
foo
with
kind
of
properties
with
self
described
names
right.
B
So
this
property
is
public,
final
right
fabric
final
field
and
when
they
serialize
this
class,
it
will
produce
this
JSON
document
and
summer
fields
are
not
going
to
be
supported.
So
let's
just
go
through
and
see
why
so
public
final
fields
is
supported
because
it's
public
and
final
fields
are
supported.
The
next
one
is
private.
Final
field
is
not
see,
realized
not
sterilized,
because
it's
private
and
Jason
min
expects
visibility.
B
Public
static
field,
not
sterilized
because
Jason
B
doesn't
support
static
public
with
no
Gator.
Just
a
public
field
is
fine,
no
Gator
and
public,
so
respect
visibility
public.
So
she
realized
public
with
private
theater.
This
is
kind
of
a
funny
situation.
They
have
a
public
property
with
private
theater,
but
it
won't
be
realized
because
Jason
B
respects
getters
and
setters
first
and
it
found
a
private
theater
and
it
skeeves
the
property.
B
This
property
skipped,
because
it's
now
and
with
no
gear
turn
again
Nazi
realized
because
Jason
B
looks
at
the
Gator
but
is
no
Gator.
Jason
B
looks
at
the
field,
it's
private
and
rigged,
and
it
expects
miscibility
private
republic
Gator,
which
is
stand
up.
He
case
see
realized,
and
this
is
a
pair
of
getting
getter
and
setter
without
extra
field,
and
because
theater
is
public,
that
this
property
is
serialized,
it
looks
a
little
bit
complicated,
but
at
the
end
it's
actually
very
easy,
which
is
how
Java
works.
B
Customizations,
so
there
are
two
ways
to
customize
your
binding:
you
can
customize
it
compile
time
using
annotations
and
you
can
customize
using
runtime
using
Jason
B
config
and
here
I
listed
all
Jason
B
config
method,
which
you
can
use
for
your
customizations
and
to
apply
your
customizations.
You
need
to
actually
build
a
customized
version
of
Jason
the
engine
and
in
order
to
do
that,
you
use
Jason
B
builder,
but
instead
of
create,
which
creates
a
default
configuration
use
new
builder
and
pass
their
configuration
you
just
created
for
right.
B
You
also
can
change
your
Jason
P
provider
here
so
which
builds
the
customize
Jason
B
engine
all
right.
So
what
customizations
are
supported?
Property
names,
property
order,
ignoring
properties,
now
handling
customers,
intonation
property
visibility,
quite
a
lot
of
stuff
right,
I'm
slightly
round
of
time,
so
I'll
just
skip
it
and
quickly
go
through
these
customizations.
Otherwise
anything
won't
have
enough
time
to
talk
about
future
plans.
Property
names,
the
standard
stuff.
You
do
you
don't
want
the
substandard
property
name.
You
want
to
use
something
different
right:
Jason,
be
property
annotation.
B
If
you
put
it
on
field,
it
affects
both
serialization
deserialization.
If
you
put
it
on
theater,
it
will
affect
only
serialization.
If
you
put
it
on
setter,
it
will
affect
on
the
digitization.
So
we
support
finding
use
cases
there.
You
can
realize
the
same
property
using
different
names.
You
see
the
allies
situation,
one
name
you
can
deserialize
it
using
another
name
again,
which
is
kind
of
like
stuff.
B
We
support
some
predefined
strategies
and
you
can
create
a
new
one
and
pass
it
at
runtime
to
Jace
in
the
config
right
here
is
example:
how
to
do
a
list
of
strategists
with
support,
please
quite
a
few
of
them
right
and
the
sample
actually
demonstrates
how
your
property
will
be
changed.
So
identity
is
default,
one.
It
means
no
change
to
the
property
lowercase
with
dashes
converts
my
property
to
these.
My
property
lowercase
F
underscores
that
camel
case
camel
case
of
spaces
case
insensitive,
basically
the
same
as
identity,
but
it
ignores
case
on
D
serialization.
B
You
can
change
property
order.
Strategy
to
default
is
lexicographical
free
to
other
are
supported
any
and
reviewers
any
means
that
property
is
not
defined.
In
the
most
cases,
it
will
be
how
your
property
is
appealing
in
your
class,
but
it's
not
guaranteed
and
the
reviewers
is
reviewers
to
lexicographical
from
z28.
We
have
a
special
annotation
recently
property
order.
Here's
a
sample
put
it
on
class
and
in
this
case
ie
is
used.
B
So
basically,
no
property
orderly,
find
which
can
give
you
a
little
bit
of
performance,
but
just
a
little
ignoring
product
easily
understand
that
use
case.
You
can
use.
Oh
sorry,
you
can
use
transient
keyword,
but
sometimes
you
don't
want
to
use
it.
So
Jason
be
transient,
annotation
put
it
on
field
and
it
will
be
ignored
on
serialization
and
deserialization
on
satyr.
It
will
ignore
it.
Use
it
during
this
realization
on
the
Gator.
It
will
be
ignoring
during
serialization.
B
Feasibility
so
I
explained
that
Jason
B
respects
Gator
setters
blah
blah
blah
this
kind
of
stuff.
Everything
can
be
changed
if
you
define
your
own
visibility
strategy,
but
have
a
special
interface
property
visibility
strategy.
You
implement
your
strategy
based
on
that
interface,
you
plug
it
in
using
Jason
B
visibility,
annotation
on
type
or
at
runtime,
using
Jason
B,
config,
Reef
property
visibility,
strategy
method.
B
Now,
Hedrick
by
default,
Jason
B
doesn't
protest
now
field.
If
it's
a
problem,
it
can
be
customized
huge
in
Jason
being
nillable
annotation
on
class.
In
this
case,
all
fields
will
be
null.
Fields
will
be
serialized.
You
will
have
in
jason
name
now
right
or
on
the
property
level.
You
should
use
a
should
be
property
with
new
label.
True,
so
it's
a
second
parameter
of
Jason
B
property
forces
when
you
name,
but
if
new
name
is
not
specified,
name
is
used
and
new
label.
B
B
So
in
order
to
switch
it
on,
you
put
Jason
B,
Creator
annotation,
only
your
constructor
and
you
define
your
parameters
using
JCB
property.
In
this
case,
the
values
of
constructed
parameters
will
be
read
from
your
JSON
document.
So
here's
the
sample
we
have
order,
which
is
a
customer
and
customer
using
constant
custom.
Association
Liberation
be
creator.
So
when
customer
is
created,
we
have
a
parameter
called
ID.
It's
here.
It's
5
6
2.
So
this
is
going
to
be
passed
to
the
constructor
to
create
a
customer.
B
B
Miss
exceptions
are
listed
here,
I'm
not
going
to
list
it
here
because
of
time
issues.
But
if
you
want
your
document,
you
want
to
switch
on
the
full
ingestion
compatibility
by
passing
with
strict
I
Jason
through
to
Jason
be
configured
in
this
case.
This
free
will
be
kind
of
checked
and
if
you
have
something
wrong
exception
would
erase.
B
Another
two
is
really
kind
of
hardcore,
customization,
stuff
adapters
and
serialize
and
deserialize
errs.
So
basically
it
will
allow
you
to
do
most.
Everything.
Adapter
is
a
special
interface,
where
you
call
your
conversion
rules
from
one
class
to
another.
If
you
don't
like
how
first
class
is
serialized,
you
create
an
adapter
to
another
class
which
you
like
how
this
will
be
type
adapter.
You
can
put.
You
can
switch
on
adapter
using
just
B
type,
adapter
annotation
on
your
field
or
globally,
using
Jason
beacon,
trick
with
adapters
in
your
paths,
adapter
instances
their.
B
Serialize
and
deserialize
even
more
hardcore
stuff,
actually
serialize
er,
it
uses
Jason
generator,
so
it
uses
JSONP
stuff
itself
right.
So
if
you
want
to
customize
serialization
on
deserialization
or
really
a
low
level,
you
can
create
serializable
deserialize
ur
for
some
of
your
types
and
access
Jason,
T
stuff
directly.
There
right,
which
is
quite
a
powerful
mechanism
internally,
for
instance,
on
implementation,
uses
that
so
to
enable
it
again,
we
have
a
couple
of
annotations.
B
We
type
serialization,
beatab,
deserialize,
err
on
the
field
or
we've
serializers,
with
DC
realizes
methods
of
Jason
B
config
to
do
runtime,
customization
that
you
pass
actually
instances
of
your
serialize
and
deserialize
right,
so
I
finished
so
now,
I'm
parsing
control,
2,
ND
and
ND.
We'll
talk
about
the
future
of
jason
by
dick
stop
sharing.
B
D
So
I've
kind
of
categorized,
the
new
features
into
a
couple
categories,
just
the
big
features
and
small
features,
and
this
what
I
have
on
the
screen
here
is
just
a
subset
of
what
we
have
planned
for
the
next
release
of
JSON
B.
So
I'll
jump
into
a
few
of
these,
along
with
code,
examples
and
mock-ups
of
what
we
have
what
we
think
the
features
will
commonly
look
like.
D
So
probably
the
number
one
most
requested
feature
that
we've
heard
of
at
least
I've
heard
of
for
JSON
B
is
the
ability
to
customize
third-party
classes,
so
JSON
B
is
essentially
broken
down
into
two
branches.
There's
the
default
mapping,
which
is
you
just
have
plain
old,
Java
objects
and
no
references
to
JSON
B
annotations
anywhere
in
your
code.
You
don't
even
need
to
add
the
JSON
B
dependency
in
your
palm
or
anything
but
for
customize.
D
A
custom
Asians
are
necessary
in
a
lot
of
cases,
especially
when
your
service
doesn't
necessarily
control
the
type
of
schema
that
you
are
coming
in
with
or
have
to
interchange
with,
and
in
some
cases
the
model
objects
might
not
be
under
your
control.
So
if,
if
the
object,
the
Java
class
that
you're
trying
to
convert
to
and
from
JSON
is
you
don't
have
edit
access
to
that
or
it
comes
from
binary
dependency?
We
call
that
a
third
party
class
so
taking
inspiration
from
Jackson,
which
is
another
library
that
does
JSON
mapping.
D
Although
it's
not
JSON
be
compatible.
We've
come
up
with
this
approach
here
to
basically
customize
everything
you
can
do
with
JSON
be
annotations,
except
to
do
it
in
a
programmatic
way.
So,
in
the
top
right
hand,
corner
I
have
a
dog
class
and
I
want
to
change
the
name
field
to
be
dog,
name
and
I
want
to
ignore
the
owner
field,
because
maybe
I
don't
want
that
information
in
my
JSON.
D
D
Sometimes
you
may
want
a
an
extra
attribute
added
in
your
JSON
data
to
indicate
what
concrete
objects
should
be
used
during
serialization
or
D
serialization,
and
to
accomplish
that
we've
proposed
an
extra
polymorphic
config
class,
which
will
allow
you
to
configure
the
concrete
implementation
classes,
such
as
dog
and
cat
and
then
optionally.
The
type
attribute
that
you
want
to
carry
the
the
name
of
the
implementation
class
so
that
that
will
be
an
optional
configuration,
I
think
it'll
default
to
something
like
Jakarta,
JSON,
B
class
or
something
equivalent.
D
D
Overhead
or
simply
in
all,
args
constructor,
which
is
what
I
have
shown
on
the
right-hand
side
here,
but
it's
not
always
necessary
to
instantiate
an
object
by
supplying
every
single
parameter
and
currently
JSON
b1
dot.
O
can
do
that,
for
example,
if
I
receive
the
the
JSON
on
the
bottom
left
here
with
just
first
name
and
last
name,
but
there's
no
middle
name
present.
Currently,
that
would
fail
in
the
future
we'd
like
to
define
some
sort
of
rules.
That
would
say
you
know
pass
in
a
null
for
the
middle
name,
for
example.
D
One
thing
is:
when
you
write
an
adapter
class,
it's
there
you've
written
it,
but
you
need
to
also
take
the
extra
step
to
register
it
with
your
JSON
B
config.
One
thing
we
can
do
when
CDI
is
present
is
we
can
add
an
annotation
to
the
adapter
class
and
automatically
register
that
adapter
with
the
JSON
B
config,
that's
being
used
so
another
one
here
is
called
the
must
ignore
policy.
D
You
might
want
the
behavior,
where,
if
you
have
to
see
an
unrecognized
field,
you
want
to
know
about
that.
Instead
of
silently
not
initializing
that
field,
maybe
your
JSON
schema
has
changed
and
you
want
to
be
able
to
catch
that
in
your
your
test
phase.
So
we
proposed
adding
this
new
configuration
option
for
rejecting
unrecognized
fields
and
when
that
happens,
when
you
try
to
convert
from
a
JSON
string
to
a
java
object-
and
there
are
unrecognized
properties
in
the
JSON,
then
error
would
be
raised
instead
of
simply
ignoring
it.
D
So
what
I
have
here
is
just
a
that's,
this
kind
of
a
preview,
a
subset
of
all
the
features
that
we
have
planned
for
the
next
version
of
JSON
B.
If
you
want
to
check
out
all
the
features
that
we
have,
you
can
go
to
this
link
and
I.
Think
mitri
will
make
those
slides
available,
but
we
have
all
of
the
features
big
and
small
planned
for
the
next
version
of
JSON
be
out
on
publicly
viewable
github
board.
D
You
can't
edit
it,
but
you
can
see
what
priority
things
for
issues
are
at
and
you
can
you
know
up,
vote
or
down
growth,
different
issues,
or
you
can
comment
on
issues
you
care
about
to
potentially
influence
the
design.
So
I
really
want
to
encourage
people
that
do
have
ideas
or
questions
about
potential
features
for
JSON.
Be
please
go
to
the
project
board
and
take
a
look
at
what
we
have
planned
and
give
us
your
comments.
D
D
So
first
question
is
from
Reza.
He
says:
is
it
too
early
to
evaluate
including
JSON
schema
support?
It's
not
an
RFC
yet,
but
it's
pretty
widely
widely
used,
so
Dmitry
I
see
I,
see
you
said,
that's
out
of
scope
for
1.0.
We
do
have
a
I
think
we
do
have
a
issue
open
for
schema
support
on
the
JSON
B
github
repo.
It's
I
think
it's
in
the
might
do
column,
but
certainly
the
what
we
do
and
don't
do
is
influenced
by
users
such
as
yourself.
D
B
D
So
when
you're
using
JSON,
you
use
JSON
B
for
JSON
data
and
you
use
Jack's
B
if
you're
working
with
XML
data,
so
the
question
of
whether
you're
using
JSON
or
XML
is
totally
up
to
your
business
and
what
the
especially
if
you're,
using
like
a
micro
service
architecture
or
some
sort
of
inter
process
communication,
you
need
to
work
that
out
with
the
other
services
to
kind
of
establish
a
you
know,
communication
format,
whether
you
want
to
use
XML,
JSON
or
some
other
format,
but
when
you're
using
JSON
JSON
B
is
the
ideal
solution.
I.
D
Think
we
already
answered
that
one
from
Werner,
so
let's
get
that
another
one
from
Werner.
So
the
question
about
Java
money,
support
into
cardi,
hibernate
validator
has
public
pluggable
support
for
data
types
like
money
and
currency.
We
could
you
imagine
something
similar
in
the
JSON
B
implementation.
D
Personally,
I
haven't
seen
much
demand
for
the
money
API.
There
are
the
adapters
that
Dimitri
mentioned
in
his
slides
that
you
can
certainly
write
for
adapting
between
JSON
B
and
the
money
objects.
Oh
yeah.
That
would
that
would
be
my
my
recommendation
for
now
and
we
don't
have
any
plans
to
make
explosive
support
for
the
money
API
in
the
future,
because
really
Jakarta
specs
can
only
depend
on
things
in
java,
SE
or
other
Jakarta
specs.