What is eclipselink

For example, there is an embedded object class in a different JAR that you want to use in an entity in your persistence unit. You would list the fully qualified class in the class element in the persitence.

You would also need to ensure that the JAR or directory that contains the class is on the classpath of the deployed component by adding it to the manifest classpath of the deployment JAR, for example ;.

Even though the class may be annotated with the Entity annotation, you do not want it treated as an entity in this particular deployed context. For example, you may want to use this entity as a transfer object and it needs to be part of the deployment unit. In this case, in the Java EE environment, you have to use the exclude-unlisted-classes element of the persistence. For more information, see "mapping-file, jar-file, class, exclude-unlisted-classes" of the JPA Specification.

Additional JAR files of managed classes: the annotated classes in a named JAR file listed in a jar-file element in the persistence.

You have to ensure that any JAR file listed in the jar-file element is on the classpath of the deployment unit. Do so by manually adding the JAR file to the manifest classpath of the deployment unit. Note that you must list the JAR file in the jar-file element relative to the parent of the JAR file in which the persistence. This matches what you would put in the classpath entry in the manifest file.

You can achieve this in one of the following ways:. You can specify one or more directories or JAR files, separating them by spaces. This will make the JAR file available on the application classpath and accessible by all of the modules deployed within the EAR file. By default, this would be the lib directory of the EAR file, although you may configure it to be any directory in the EAR file using the library-directory element in the application.

Java EE allows for persistence support in a variety of packaging configurations. You can deploy your application to the following module types:. Web modules: you can use a WAR file to package your entities. In this case, place the persistence. Persistence archives: a persistence archive is a JAR that contains a persistence.

Use a persistence archive if you want to allow multiple components in different Java EE modules to share or access a persistence unit. Once you create a persistence archive, you can place it in either the root or the application library directory of the EAR.

This will make the persistence unit accessible only to the classes inside the WAR, but it enables the decoupling of the definition of the persistence unit from the web archive itself.

You can define any number of persistence units in single persistence. The following are the rules for using defined and packaged persistence units:. You can expose multiple persistence units each with unique sets of entity types as a single persistence context by using a composite persistence unit. Individual persistence units that are part of this composite persistence unit are called composite member persistence units.

Figure illustrates a simple composite persistence unit. EclipseLink processes the persistence. Class A is mapped by a persistence unit named memberPu1 located in the member1. Class B is mapped by a persistence unit named memberPu2 located in the member2. EclipseLink requires that classes must meet certain minimum requirements before they can become persistent. EclipseLink also provides alternatives to most requirements.

EclipseLink uses a nonintrusive approach by employing a metadata architecture that allows for minimal object model intrusions. When using JPA, you can specify persistence layer components using any combination of standard JPA annotations and persistence.

For more information, see Section 2. Persistence layer components can be coded or generated as Java. To use Java code, you must manually write code for each element of the project including: project, login, platform, descriptors, and mappings. This may be more efficient if your application is model-based and relies heavily on code generation. When to use method or direct field access depends on your application design.

Consider the following guidelines:. This is the natural public API of the class. Similarly, if you enable change tracking on a field for example, you decorate field phone with ChangeTracking , then EclipseLink tracks changes accordingly when a client modifies the field phone directly. If you choose to code in this style of field access within a class for performance and method access outside of a class, then be aware of this limitation. If you are using weaving, the ValueHolderInterface is not required.

For more information, see Section 3. The purpose of your application's persistence layer is to use a session at run time to associate mapping metadata and a data source see Chapter 7, "Understanding Data Access" to create, read, update, and delete persistent objects using the EclipseLink cache, queries and expressions, and transactions.

The EclipseLink application metadata model is based on the project. The project includes descriptors, mappings, and various policies that customize the run-time capabilities. You associate this mapping and configuration information with a particular data source and application by referencing the project from a session. By default, EclipseLink sessions provide an object-level cache that guarantees object identity and enhances performance by reducing the number of times the application needs to access the data source.

EclipseLink provides a variety of cache options, including locking, refresh, invalidation, isolation, and coordination. Using cache coordination, you can configure EclipseLink to synchronize changes with other instances of the deployed application.

You configure most cache options at the persistence unit or entity level. You can also configure cache options on a per-query basis or on a descriptor to apply to all queries on the reference class.

For Object-relational architectures, EclipseLink provides several object and data query types, and offers flexible options for query selection criteria, including the following:. With these options, you can build any type of query. Oracle recommends using named queries to define application queries.

Named queries are held in the project metadata and referenced by name. This simplifies application development and encapsulates the queries to reduce maintenance costs.

For Object-relational architectures, you are free to use any of the query options regardless of the persistent entity type. This section includes a brief description of relational mapping and provides information and restrictions to guide object and relational modeling.

This information is useful when building applications. Object modeling refers to the design of the Java classes that represent your application objects. Any class that registers a descriptor with EclipseLink database sessions is called a persistent class. EclipseLink does not require that persistent classes provide public accessor methods for any private or protected attributes stored in the database. Refer to Section 3. Your data storage schema refers to the design that you implement to organize the persistent data in your application.

This schema refers to the data itself—not the actual data source such as a relational database or nonrelational legacy system. During the design phase of the application development process, you should decide how to implement the classes in the data source. When integrating existing data source information, you must determine how the classes relate to the existing data. If no legacy information exists to integrate, decide how you will store each class, then create the necessary schema.

When making objects persistent, each object requires an identity to uniquely identify it for storage and retrieval. Keys can be a single field or a combination of fields.

JPA allows to auto-generate the primary key in the database via the GeneratedValue annotation. By default, the table name corresponds to the class name. The fields of the Entity will be saved in the database. JPA can use either your instance variables fields or the corresponding getters and setters to access the fields. You are not allowed to mix both methods. If you want to use the setter and getter methods the Java class must follow the Java Bean naming conventions.

JPA persists per default all fields of an Entity, if fields should not be saved they must be marked with Transient. By default each field is mapped to a column with the name of the field. Together with an ID this annotation defines that this value is generated automatically. JPA allows to define relationships between classes, e. Classes can have one to one, one to many, many to one, and many to many relationships with other classes. A relationship can be bidirectional or unidirectional, e.

Within a bidirectional relationship you need to specify the owning side of this relationship in the other class with the attribute "mappedBy", e. The entity manager javax. EntityManager provides the operations from and to the database, e. In a JavaEE application the entity manager is automatically inserted in the web application. Outside JavaEE you need to manage the entity manager yourself.

Entities which are managed by an Entity Manager will automatically propagate these changes to the database if this happens within a commit statement. If the Entity Manager is closed via close then the managed entities are in a detached state.

If synchronize them again with the database a Entity Manager provides the merge method. The EntityManager is created by the EntityManagerFactory which is configured by the persistence unit. The persistence unit is described via the persistence. A set of entities which are logical connected will be grouped via a persistence unit. The persistence. EclipseLink supports several Java standards:. The example later will be using Apache Derby as a database.

For details on Derby which is not required for this tutorial please see Apache Derby. Create a Java project "de. Create a folder "lib" and place the required JPA jars and derby. Add the libs to the project classpath. This examples uses EclipseLink specific flags for example via the parameter "eclipselink. The database specified via "javax. The Table annotation specifies the database table to which the entity is mapped.

The persistence. In this file we define persistence units which define a set of all entity classes that are managed by entity manager instances in an application. EntityManager is a class that manages the persistent state of entities. The first example is a Java command line program, which retrieves all rows from the Cars table.

We create a new NetBeans Java Maven project. In the pom. To create the persistence. There is a Persistence unit option. In the persistence. We define a persistence provider, which is a Derby database. With this property set, EclipseLink will drop and create a database table.

The Cars table is created from the provided metadata. This is a Java console application, which retrieves all rows from the Cars table with the help of the entity manager. The factory is created with the Persistence. The created EntityManager is an application-managed entity manager. This looks like SQL code but it is not.