-
Notifications
You must be signed in to change notification settings - Fork 130
/
jpa_overview_why.xml
671 lines (668 loc) · 24.1 KB
/
jpa_overview_why.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2006 The Apache Software Foundation.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<chapter id="jpa_overview_why">
<title>
Why JPA?
</title>
<indexterm zone="jpa_overview_why">
<primary>
JPA
</primary>
<secondary>
why
</secondary>
</indexterm>
<para>
Java developers who need to store and retrieve persistent data already have
several options available to them: serialization, JDBC, JDO, proprietary
object-relational mapping tools, object databases, and EJB 2 entity beans. Why
introduce yet another persistence framework? The answer to this question is that
with the exception of JDO, each of the aforementioned persistence solutions has
severe limitations. JPA attempts to overcome these limitations, as illustrated
by the table below.
</para>
<table tocentry="1">
<title>
Persistence Mechanisms
</title>
<tgroup cols="8" align="left" colsep="1" rowsep="1">
<colspec colname="sup"/>
<colspec colname="ser"/>
<colspec colname="jdbc"/>
<colspec colname="or"/>
<colspec colname="objdb"/>
<colspec colname="ejb2"/>
<colspec colname="jdo"/>
<colspec colname="jpa"/>
<thead>
<row>
<entry colname="sup">
Supports:
</entry>
<entry colname="ser">
Serialization
</entry>
<entry colname="jdbc">
JDBC
</entry>
<entry colname="or">
ORM
</entry>
<entry colname="objdb">
ODB
</entry>
<entry colname="ejb2">
EJB 2
</entry>
<entry colname="jdo">
JDO
</entry>
<entry colname="jpa">
JPA
</entry>
</row>
</thead>
<tbody>
<row>
<entry colname="sup">
Java Objects
</entry>
<entry colname="ser">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdbc">
No
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Advanced OO Concepts
</entry>
<entry colname="ser">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdbc">
No
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
No
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Transactional Integrity
</entry>
<entry colname="ser">
No
</entry>
<entry colname="jdbc">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Concurrency
</entry>
<entry colname="ser">
No
</entry>
<entry colname="jdbc">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Large Data Sets
</entry>
<entry colname="ser">
No
</entry>
<entry colname="jdbc">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Existing Schema
</entry>
<entry colname="ser">
No
</entry>
<entry colname="jdbc">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
No
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Relational and Non-Relational Stores
</entry>
<entry colname="ser">
No
</entry>
<entry colname="jdbc">
No
</entry>
<entry colname="or">
No
</entry>
<entry colname="objdb">
No
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
No
</entry>
</row>
<row>
<entry colname="sup">
Queries
</entry>
<entry colname="ser">
No
</entry>
<entry colname="jdbc">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Strict Standards / Portability
</entry>
<entry colname="ser">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdbc">
No
</entry>
<entry colname="or">
No
</entry>
<entry colname="objdb">
No
</entry>
<entry colname="ejb2">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
<row>
<entry colname="sup">
Simplicity
</entry>
<entry colname="ser">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jdbc">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="or">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="objdb">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="ejb2">
No
</entry>
<entry colname="jdo">
<emphasis role="bold">
Yes
</emphasis>
</entry>
<entry colname="jpa">
<emphasis role="bold">
Yes
</emphasis>
</entry>
</row>
</tbody>
</tgroup>
</table>
<itemizedlist>
<listitem>
<para>
<indexterm>
<primary>
serialization
</primary>
</indexterm>
<indexterm>
<primary>
JPA
</primary>
<secondary>
vs serialization
</secondary>
</indexterm>
<emphasis>Serialization</emphasis> is Java's built-in mechanism for transforming
an object graph into a series of bytes, which can then be sent over the network
or stored in a file. Serialization is very easy to use, but it is also very
limited. It must store and retrieve the entire object graph at once, making it
unsuitable for dealing with large amounts of data. It cannot undo changes that
are made to objects if an error occurs while updating information, making it
unsuitable for applications that require strict data integrity. Multiple threads
or programs cannot read and write the same serialized data concurrently without
conflicting with each other. It provides no query capabilities. All these
factors make serialization useless for all but the most trivial persistence
needs.
</para>
</listitem>
<listitem>
<para>
<indexterm>
<primary>
Java Database Connectivity
</primary>
<see>
JDBC
</see>
</indexterm>
<indexterm>
<primary>
JDBC
</primary>
</indexterm>
<indexterm>
<primary>
JPA
</primary>
<secondary>
vs JDBC
</secondary>
</indexterm>
Many developers use the <emphasis>Java Database Connectivity</emphasis> (JDBC)
APIs to manipulate persistent data in relational databases. JDBC overcomes most
of the shortcomings of serialization: it can handle large amounts of data, has
mechanisms to ensure data integrity, supports concurrent access to information,
and has a sophisticated query language in SQL. Unfortunately, JDBC does not
duplicate serialization's ease of use. The relational paradigm used by JDBC was
not designed for storing objects, and therefore forces you to either abandon
object-oriented programming for the portions of your code that deal with
persistent data, or to find a way of mapping object-oriented concepts like
inheritance to relational databases yourself.
</para>
</listitem>
<listitem>
<para>
<indexterm>
<primary>
object-relational mapping
</primary>
<see>
ORM
</see>
</indexterm>
<indexterm>
<primary>
ORM
</primary>
</indexterm>
<indexterm>
<primary>
JPA
</primary>
<secondary>
vs ORM products
</secondary>
</indexterm>
There are many proprietary software products that can perform the mapping
between objects and relational database tables for you. These <emphasis>
object-relational mapping</emphasis> (ORM) frameworks allow you to focus on the
object model and not concern yourself with the mismatch between the
object-oriented and relational paradigms. Unfortunately, each of these product
has its own set of APIs. Your code becomes tied to the proprietary interfaces of
a single vendor. If the vendor raises prices, fails to fix show-stopping bugs,
or falls behind in features, you cannot switch to another product without
rewriting all of your persistence code. This is referred to as vendor lock-in.
</para>
</listitem>
<listitem>
<para>
<indexterm>
<primary>
object database
</primary>
<see>
ODB
</see>
</indexterm>
<indexterm>
<primary>
ODB
</primary>
</indexterm>
<indexterm>
<primary>
JPA
</primary>
<secondary>
vs ODBs
</secondary>
</indexterm>
<indexterm>
<primary>
ODBMG
</primary>
</indexterm>
Rather than map objects to relational databases, some software companies have
developed a form of database designed specifically to store objects. These
<emphasis>object databases</emphasis> (ODBs) are often much easier to use than
object-relational mapping software. The Object Database Management Group (ODMG)
was formed to create a standard API for accessing object databases; few object
database vendors, however, comply with the ODMG's recommendations. Thus, vendor
lock-in plagues object databases as well. Many companies are also hesitant to
switch from tried-and-true relational systems to the relatively unknown object
database technology. Fewer data-analysis tools are available for object database
systems, and there are vast quantities of data already stored in older
relational databases. For all of these reasons and more, object databases have
not caught on as well as their creators hoped.
</para>
</listitem>
<listitem>
<para>
<indexterm>
<primary>
Enterprise Java Beans
</primary>
<see>
EJB
</see>
</indexterm>
<indexterm>
<primary>
EJB
</primary>
</indexterm>
<indexterm>
<primary>
JPA
</primary>
<secondary>
vs EJB 2
</secondary>
</indexterm>
The Enterprise Edition of the Java platform introduced entity Enterprise Java
Beans (EJBs). EJB 2.x entities are components that represent persistent
information in a datastore. Like object-relational mapping solutions, EJB 2.x
entities provide an object-oriented view of persistent data. Unlike
object-relational software, however, EJB 2.x entities are not limited to
relational databases; the persistent information they represent may come from an
Enterprise Information System (EIS) or other storage device. Also, EJB 2.x
entities use a strict standard, making them portable across vendors.
Unfortunately, the EJB 2.x standard is somewhat limited in the object-oriented
concepts it can represent. Advanced features like inheritance, polymorphism, and
complex relations are absent. Additionally, EBJ 2.x entities are difficult to
code, and they require heavyweight and often expensive application servers to
run.
</para>
</listitem>
<listitem>
<para>
<indexterm>
<primary>
JDO
</primary>
</indexterm>
<indexterm>
<primary>
JPA
</primary>
<secondary>
vs JDO
</secondary>
</indexterm>
The JDO specification uses an API that is strikingly similar to JPA. JDO,
however, supports non-relational databases, a feature that some argue dilutes
the specification.
</para>
</listitem>
</itemizedlist>
<para>
<indexterm>
<primary>
JPA
</primary>
</indexterm>
JPA combines the best features from each of the persistence mechanisms listed
above. Creating entities under JPA is as simple as creating serializable
classes. JPA supports the large data sets, data consistency, concurrent use, and
query capabilities of JDBC. Like object-relational software and object
databases, JPA allows the use of advanced object-oriented concepts such as
inheritance. JPA avoids vendor lock-in by relying on a strict specification like
JDO and EJB 2.x entities. JPA focuses on relational databases. And like JDO, JPA
is extremely easy to use.
</para>
<note>
<para>
OpenJPA typically stores data in relational databases, but can be customized for
use with non-relational datastores as well.
</para>
</note>
<para>
JPA is not ideal for every application. For many applications, though, it
provides an exciting alternative to other persistence mechanisms.
</para>
</chapter>