Difference between revisions of "EclipseLink/Presentations/Abstracts"

From Eclipsepedia

Jump to: navigation, search
m (Full Abstract)
(EclipseLink: The Evolution of Java Persistence)
 
(32 intermediate revisions by 2 users not shown)
Line 1: Line 1:
This page is dedicated to collecting abstracts for talks and tutorials on EclipseLink. These abstracts are developed collaboratively by interested speakers and used to propose talks at upcoming conferences. Upcoming and past presentation information is available [[EclipseLink/Presentations | here]].
+
== Java Persistence API 2.0 with EclipseLink ==
  
== General Talks ==
+
JPA 2.0 defines the Java EE standard for relational persistence with open source EclipseLink providing the reference implementation along with a number of advanced features including clustered caching, dynamic persistence, and JAXB integration. This session will look at the JPA 2.0 specification and beyond to the advanced features EclipseLink provides to support building Java EE 6 applications.
  
=== Introducing EclipseLink--the Eclipse Persistence Services Project ===
+
==EclipseLink:  The Evolution of Java Persistence==
  
==== Full Abstract ====
+
Data access today isn’t just about reading and writing from relational databases anymore. It’s also about mapping your objects to XML and to JSON for use in RESTful web services.  It’s about being able to persist your objects in NoSQL databases and being able to cache them in data grids so you can scale out your application to hundreds of servers.   The EclipseLink project is well known as an object-relational mapping framework and as the JPA 2.0 reference implementation in Java EE 6, but it has evolved to provide a comprehensive set of data services for Java developers building enterprise and cloud applications in Java EE, Java SE, and in OSGi.  In this session we’ll dive into these new services and see how to build modern enterprise Java applications leveraging EclipseLink both in the back end for data persistence and on the front end to build RESTful services that support HTML5 clients.
The creation of EclipseLink, the Eclipse Persistence Services Project, signals the inauguration of a new generation of Java persistence where all of the dominant persistence standards are implemented and accessible from a single source. EclipseLink is composed of a set of separate runtime components that can be used in both clients and servers, and is the first open source project to offer a full suite of persistence technologies. By supporting all of the popular standards, including object-relational mapping using the Java Persistence API (JPA), object-to-XML mapping through the Java API for XML Binding (JAXB), and loosely bound Service Data Objects (SDO) that bridge the relational and XML worlds, EclipseLink will provide the most comprehensive persistence platform available. Equally compelling is the fact that these technologies are offered with a rich array of feature extensions and high-end performance options.
+
  
In this session, attendees will learn what EclipseLink is, the standard technologies it implements, and how these technologies can be used separately or together to meet advanced and diverse application requirements. We will show examples of how to use EclipseLink to map Java objects in object-relational and object-XML contexts, and how it can be used in any runtime environment, including Eclipse RCP, Java SE, Java EE, Spring and Tomcat.
+
Topics will include:
  
== Short Abstract ==
+
* EclipseLink “JSON-B”—provides Java/JSON binding similar to EclipseLink JAXB’s Java/XML binding. With JSON-B, developers can easily marshall their Java domain model to and from JSON which is the preferred format for HTML5/JavaScript clients.
 +
* EclipseLink JPA-RS—provides a service that exposes JPA mapped entities over REST either as XML with JAXB or JSON with EclipseLink JSON-B.  It supports a full CRUD API as well as named query invocation.
 +
* Resource Mapping—While JAXB and JSON-B provide a way to marshall to and from XML/JSON, RESTful services require a way to define what constitutes a resource.  A naive approach of entity==resource may be used but is likely inefficient.  With EclipseLink Resource Mapping the classes in a domain model can be declaratively mapped to a resource model which can be exposed using JPA-RS.
 +
* EclipseLink Dynamic Provisioning—provides persistence services to pure HTML5 applications without the need for Java classes.  With Dynamic Provisioning, HTML5 clients can dynamically define storage requirements for a set of classes (object types) and EclipseLink will instantiate a full JPA-RS CRUD service for those classes as well as JPQL query support.
 +
* Tenant Isolation—Allow each tenant’s data to be isolated by data source, schema, table, or at the row level including support for Oracle Database Virtual Private Database (VPD).  The isolation of entities carries through the persistence layers including caching.
  
EclipseLink, the Eclipse Persistence Services Project, provides a comprehensive set of persistence technologies including Java Persistence API (JPA), Java API for XML Binding (JAXB), and Service Data Objects (SDO). This session will introduce EclipseLink, the technologies it implements, and how these technologies can be used in various environments including Eclipse RCP, OSGi, Spring, and Tomcat.
+
== Cloud Enabled Persistence ==
  
=== Developing with JPA and JAXB ===
+
One of the major themes of Java EE 7 and JPA 2.1 is multi-tenancy and EclipseLink, the JPA 2.1 reference implementation, has blazed the trail by shipping support for JPA usage with multiple tenants and tenant specific extensions in the Eclipse Indigo release (June 2011).  EclipseLink enables the use of a single persistence unit by multiple tenants offering control over their tenant isolation strategy.  But to provide a SaaS platform EclipseLink also provides tenant specific extensions so that each tenant can augment JPA entities with the additional data they need to capture and maintain. 
  
====Full Abstract====
+
In this session we will:
Two important Java persistence standards that are relevant in modern enterprise applications are the Java Persistence API (JPA), which is part of Java EE, and the Java Architecture for XML Binding (JAXB), available separately in Java SE 5 and included within Java SE 6. Each of these standards has solved a similar problem that exists in different data domains. JPA offers developers a standard persistence solution for mapping and accessing relational data within a Java object model. JAXB offers them the ability to bind their Java model to XML documents based on XML schema mappings. Both of these solutions enable using Java domain objects to define and maintain business logic. Combining JPA usage with JAXB is an important domain-driven design solution where the mapping to an underlying relational schema and the ability to render the model in XML is very natural for today's service-based development.
+
* Look at the challenges presented developing to support multiple tenants
 +
* Explore the EclipseLink JPA tenant isolation and extensibility  features
 +
* Introduce the EclipseLink MOXy extensibility features that enable exposing tenant specific extended data over REST
 +
* Explore a complete Java EE application that supports dynamic tenant provisioning and customization
  
This session will demonstrate how these two persistence standards can be combined effectively to leverage a common domain model, while still offering the flexibility necessary to handle diverse data representation requirements. The shared domain model and the flexible mapping solutions eliminate costly transformation logic and embrace the rich domain model where application state and behaviour can be developed and shared across multiple application components and services.
+
== Simplifying REST in Java EE with Eclipse ==
 +
REST is a technique for providing light weight Web Services and in Java EE the Java API for RESTful Services (JAX-RS) provides the service framework. The Java Persistence API (JPA) provides the data access and Java Architecture for XML Binding (JAXB) handles marshalling the persistent entities into and out of XML. Sound great! There are a number of issues developers have to deal with when using them together. In this session we'll look at how to build RESTful services with Eclipse WTP using these standard technologies, their integration points and where the pain points are, and how to avoid them using EclipseLink's advanced REST/JAXB/JPA integrations features.
  
====Short Abstract====
+
== Building HTML5 Applications with EclipseLink: JSON, JAX-RS, JPA & JavaScript ==
The Java Persistence API (JPA) offers a standard for mapping and accessing relational data within a Java object model while the Java Architecture for XML Binding (JAXB) offers the ability to bind Java models to XML. This session will demonstrate how these two persistence standards can be combined in a common domain model while offering the flexibility to handle diverse data requirements.
+
  
== JPA Talks ==
+
In the Eclipse Juno release, EclipseLink is introducing a set of new features to support the development of HTML5 applications that interact with server side Java using REST. In this session we’ll look at the typical HTML5/Java EE REST stack and see how EclipseLink’s new features can be used to both simplify development through the use of declarative metadata as well as how it can enable the development of pure HTML5 applications that rely on database data. We’ll introduce each of the new features and see how they can be used, and combined, to build RESTful services. These features are:
  
=== Eclipse JPA: EclipseLink and Dali ===
+
* EclipseLink "JSON-B"—provides Java/JSON binding similar to EclipseLink JAXB’s Java/XML binding. With JSON-B, developers can easily marshall their Java domain model to and from JSON which is the preferred format for HTML5/JavaScript clients.
 
+
* EclipseLink JPA-RS—provides a service that expose JPA mapped entities over REST either as XML with JAXB or JSON with EclipseLink JSON-B. It supports a full CRUD API as well as named query invocation.
====Full Abstract====
+
* Resource Mapping—While JAXB and JSON-B provide a way to marshall to and from XML/JSON, RESTful services require a way to define what constitutes a resource. A naive approach of entity==resource may be used but is likely inefficient. With EclipseLink Resource Mapping the classes in a domain model can be declaratively mapped to a resource model which can be exposed using JPA-RS.
Eclipse has lived most of its life as an IDE, and most will agree that it has achieved a great deal of success along the way. However, Eclipse is now all grown up and has decided to establish itself in runtime-land as well. Counted in its runtime component arsenal is its Equinox OSGi layer, its Rich Client Platform (RCP) API, and now a full Java Persistence Platform that includes a deluxe Java Persistence API (JPA) implementation. In this talk we will learn how to use the Eclipse JPA runtime layer both inside and outside Eclipse. We will see how the Eclipse Dali tooling assists in developing a JPA application, and also see what configuration metadata might be needed to get the application running. As part of the discussion we will examine the difference between writing applications targeted for a full Java EE 5 container and those built to run in a standalone Java SE environment.
+
* EclipseLink Dynamic Provisioning—provides persistence services to pure HTML5 applications without the need for Java classes. With Dynamic Provisioning, HTML5 clients can dynamically define storage requirements for a set of classes (object types) and EclipseLink will instantiate a full JPA-RS CRUD service for those classes as well as JPQL query support.
 
+
Attendees are not required to have experience with JPA, but having some kind of Java persistence knowledge or object-relational mapping experience will help.
+
 
+
====Short Abstract====
+
Although well know for it's Java IDE, the Eclipse Foundation is also the home of a number of runtime frameworks including Equinox (OSGi), Rich Client Platform, and now the Eclipse Persistence Services Project (EclipseLink). In this session attendees will learn how to use the open source Eclipse JPA runtime and the Eclipse Dali project's tooling for building and deploying JPA applications.
+
 
+
=== Building JPA Applications with EclipseLink and Dali ===
+
 
+
With the release of Dali JPA Tools 1.0 and the availability of Eclipse JPA from the EclipseLink project, a complete JPA development platform and runtime environment are now available from Eclipse. In this talk we'll learn how to use the Eclipse JPA runtime but also see how the Dali tooling provides a platform for developing portable persistence applications across all compliant JPA providers. We'll look at JPA object-relational mappings and what configuration metadata is needed to get an application up and running. As part of the discussion we'll examine the difference between writing applications targeted for a full Java EE 5 container and those built to run in a standalone Java SE environment and how Dali's integration with the Web Tools Platform supports development for a variety of runtime environments.
+
 
+
=== TUTORIAL: JPA Development with Dali and EclipseLink ===
+
 
+
With the release of Dali Java Persistence Tools 1.0 and the availability of Eclipse Java Persistence API (JPA) implementation from the EclipseLink project, a complete JPA development platform and runtime environment are now available from Eclipse. In this tutorial attendees will learn how to productively develop and maintain high performance Java applications leveraging a relational database. Project Dali's JPA tooling included in WTP (Europa) offers an excellent environment for defining and managed the object-relational mappings and additional runtime metadata. This rich development environment coupled with the Eclipse Persistence Services Project (EclipseLink)'s JPA implementation and rich extensions to address performance, scalability, legacy databases, and leverage advanced features of the underlying database gives developers a winning combination.
+
<p>
+
This tutorial will walk through the development of a sample application illustrating the design-time features of Dali and the runtime capabilities of EclipseLink. Attendees will leave with a fully functioning example they can use to better understand these important technologies. </p>
+
 
+
=== Developing JPA Applications with NetBeans and EclipseLink ===
+
 
+
The NetBeans IDE offers developers a productive and feature-rich development environment for developing and maintaining enterprise Java applications and includes support for developing with the Java Persistence API (JPA). The Eclipse Persistence Services Project (EclipseLink) is a comprehensive open-source persistence solution including implementations of the Java Persistence API (JPA), Java Architecture for XML Binding (JAXB), and Service Data Objects (SDO)--all built on a common core infrastructure.  Bringing together a powerful runtime solution with a productive development environment enables developers to rapidly build and maintain their applications and services. This session will introduce developers to standard JPA development techniques and the ability to leverage provider specific extensions as illustrated through demonstrations using NetBeans.
+
 
+
Understanding your JPA provider's solution with respect to mapping, caching, querying, and transaction optimizations in a single node and a cluster is critical to harnessing its full capabilities. The many advanced capabilities of EclipseLink JPA will be discussed giving concrete examples of how these can be applied to address performance, scalability, and flexibility concerns. The ability to build and test EclipseLink JPA solutions in a variety of Java architectures (Java EE, Java SE, Web Containers, and Spring) will also be discussed along with their corresponding usage within the NetBeans environment.
+
 
+
Attendees are not required to have experience with JPA, but some knowledge of Java persistence or experience with object-relational mapping will be beneficial.
+
 
+
== MOXy Talks ==
+
 
+
=== EclipseLink MOXy: The Power of XML Binding ===
+
 
+
====Full Abstract====
+
The use of XML in Java applications is extensive and continues to grow. It's used everywhere from configuration files, JMS messaging, Web Services, and Ajax applications.  Developers are faced with a number of options when dealing with XML in their Java applications. The most important question is whether to work directly with the XML DOM or to use Object-XML Mapping (OXM, a.k.a. XML Binding).  Mapping XML to a domain object model simplifies Java development by allowing developers to work with rich objects instead of generic DOM elements.  OXM is gaining popularity in the Java community but not all OXM frameworks are equal. When selecting an OXM framework for a project it is important to consider performance, standards compliance, usability and flexibility. In this session attendees will be introduced to OXM and to how these issues are addressed by EclipseLink MOXy, a component of the the Eclipse Java Persistence Platform. EclipseLink provides a rich OXM solution that addresses a wide range of application requirements while also providing the benefit of integration with other EclipseLink persistence capabilities.
+
 
+
====Short Abstract====
+
The use of XML in Java applications is extensive and continues to grow. It's used everywhere from configuration files, JMS messaging, Web Services, and Ajax applications. In this session attendees will be introduced EclipseLink MOXy, a component of the Eclipse Java Persistence Platform, that provides a rich, standards based, and high performance XML binding solution.
+

Latest revision as of 14:44, 13 February 2012

Contents

[edit] Java Persistence API 2.0 with EclipseLink

JPA 2.0 defines the Java EE standard for relational persistence with open source EclipseLink providing the reference implementation along with a number of advanced features including clustered caching, dynamic persistence, and JAXB integration. This session will look at the JPA 2.0 specification and beyond to the advanced features EclipseLink provides to support building Java EE 6 applications.

[edit] EclipseLink: The Evolution of Java Persistence

Data access today isn’t just about reading and writing from relational databases anymore. It’s also about mapping your objects to XML and to JSON for use in RESTful web services. It’s about being able to persist your objects in NoSQL databases and being able to cache them in data grids so you can scale out your application to hundreds of servers. The EclipseLink project is well known as an object-relational mapping framework and as the JPA 2.0 reference implementation in Java EE 6, but it has evolved to provide a comprehensive set of data services for Java developers building enterprise and cloud applications in Java EE, Java SE, and in OSGi. In this session we’ll dive into these new services and see how to build modern enterprise Java applications leveraging EclipseLink both in the back end for data persistence and on the front end to build RESTful services that support HTML5 clients.

Topics will include:

  • EclipseLink “JSON-B”—provides Java/JSON binding similar to EclipseLink JAXB’s Java/XML binding. With JSON-B, developers can easily marshall their Java domain model to and from JSON which is the preferred format for HTML5/JavaScript clients.
  • EclipseLink JPA-RS—provides a service that exposes JPA mapped entities over REST either as XML with JAXB or JSON with EclipseLink JSON-B. It supports a full CRUD API as well as named query invocation.
  • Resource Mapping—While JAXB and JSON-B provide a way to marshall to and from XML/JSON, RESTful services require a way to define what constitutes a resource. A naive approach of entity==resource may be used but is likely inefficient. With EclipseLink Resource Mapping the classes in a domain model can be declaratively mapped to a resource model which can be exposed using JPA-RS.
  • EclipseLink Dynamic Provisioning—provides persistence services to pure HTML5 applications without the need for Java classes. With Dynamic Provisioning, HTML5 clients can dynamically define storage requirements for a set of classes (object types) and EclipseLink will instantiate a full JPA-RS CRUD service for those classes as well as JPQL query support.
  • Tenant Isolation—Allow each tenant’s data to be isolated by data source, schema, table, or at the row level including support for Oracle Database Virtual Private Database (VPD). The isolation of entities carries through the persistence layers including caching.

[edit] Cloud Enabled Persistence

One of the major themes of Java EE 7 and JPA 2.1 is multi-tenancy and EclipseLink, the JPA 2.1 reference implementation, has blazed the trail by shipping support for JPA usage with multiple tenants and tenant specific extensions in the Eclipse Indigo release (June 2011). EclipseLink enables the use of a single persistence unit by multiple tenants offering control over their tenant isolation strategy. But to provide a SaaS platform EclipseLink also provides tenant specific extensions so that each tenant can augment JPA entities with the additional data they need to capture and maintain.

In this session we will:

  • Look at the challenges presented developing to support multiple tenants
  • Explore the EclipseLink JPA tenant isolation and extensibility features
  • Introduce the EclipseLink MOXy extensibility features that enable exposing tenant specific extended data over REST
  • Explore a complete Java EE application that supports dynamic tenant provisioning and customization

[edit] Simplifying REST in Java EE with Eclipse

REST is a technique for providing light weight Web Services and in Java EE the Java API for RESTful Services (JAX-RS) provides the service framework. The Java Persistence API (JPA) provides the data access and Java Architecture for XML Binding (JAXB) handles marshalling the persistent entities into and out of XML. Sound great! There are a number of issues developers have to deal with when using them together. In this session we'll look at how to build RESTful services with Eclipse WTP using these standard technologies, their integration points and where the pain points are, and how to avoid them using EclipseLink's advanced REST/JAXB/JPA integrations features.

[edit] Building HTML5 Applications with EclipseLink: JSON, JAX-RS, JPA & JavaScript

In the Eclipse Juno release, EclipseLink is introducing a set of new features to support the development of HTML5 applications that interact with server side Java using REST. In this session we’ll look at the typical HTML5/Java EE REST stack and see how EclipseLink’s new features can be used to both simplify development through the use of declarative metadata as well as how it can enable the development of pure HTML5 applications that rely on database data. We’ll introduce each of the new features and see how they can be used, and combined, to build RESTful services. These features are:

  • EclipseLink "JSON-B"—provides Java/JSON binding similar to EclipseLink JAXB’s Java/XML binding. With JSON-B, developers can easily marshall their Java domain model to and from JSON which is the preferred format for HTML5/JavaScript clients.
  • EclipseLink JPA-RS—provides a service that expose JPA mapped entities over REST either as XML with JAXB or JSON with EclipseLink JSON-B. It supports a full CRUD API as well as named query invocation.
  • Resource Mapping—While JAXB and JSON-B provide a way to marshall to and from XML/JSON, RESTful services require a way to define what constitutes a resource. A naive approach of entity==resource may be used but is likely inefficient. With EclipseLink Resource Mapping the classes in a domain model can be declaratively mapped to a resource model which can be exposed using JPA-RS.
  • EclipseLink Dynamic Provisioning—provides persistence services to pure HTML5 applications without the need for Java classes. With Dynamic Provisioning, HTML5 clients can dynamically define storage requirements for a set of classes (object types) and EclipseLink will instantiate a full JPA-RS CRUD service for those classes as well as JPQL query support.