Java EE 7 overview

Java EE 7:

What’s New in the Java EE Platform
Masoud Kalali
@MasoudKalali
ORACLE

JDays 2013

Agenda
A look at some of the important
new features of Java EE 7

2

Copyright © 2012, Oracle and/or its affiliates. All rights reserved.

Java EE 7 Themes

MEETING
ENTERPRISE
DEMANDS

DEVELOPER
PRODUCTIVITY
Java EE 7

§  More annotated POJOs
§  Less boilerplate code
§  Cohesive integrated
platform

3


§ 
§ 
§ 
§ 

WebSockets
JSON
Servlet 3.1 NIO
REST

§  Batch
§  Concurrency
§  Simplified JMS

Java EE 7 JSRs
New or Updated
§  JPA 2.1

§  CDI 1.1

§  JAX-RS 2.0

§  Bean Validation 1.1

§  EJB 3.2

§  WebSocket 1.0

§  JMS 2.0

§  JSON 1.0

§  Servlet 3.1

§  Batch Applications 1.0

§  EL 3.0

§  Concurrency Utilities 1.0

§  JSF 2.2

4


Java EE 7 Maintenance Releases
§  Common Annotations 1.2
§  JTA 1.2
§  Interceptors 1.2
§  Connector 1.7
§  JSP 2.3
§  JASPIC 1.2
§  JACC 1.4
§  JavaMail 1.5
§  Web Services 1.4
5


JSON Processing 1.0

6


JSON Processing 1.0

§  API to parse and generate JSON
§  Streaming API (javax.json.stream)
–  Low-level, efficient way to parse/generate JSON
–  Similar to StAX API in XML world

§  Object model API (javax.json)
–  Simple, easy to use high-level API
–  Similar to DOM API in XML world

7


JSON Processing 1.0
Streaming API: Parsing
§  Created using
–  Json.createParser(…)
–  Json.createParserFactory().createParser(…)

§  Parses JSON in streaming way from input sources
Event event = parser.next(); //START_OBJECT
event = parser.next();

// KEY_NAME

event = parser.next();

// VALUE_STRING

§  Parser state events
–  START_OBJECT, END_OBJECT, START_ARRAY, END_ARRAY,

KEY_NAME, VALUE_STRING, VALUE_NUMBER, …
8


JSON Processing 1.0
Streaming Parser
{
“firstName”: “John”, “lastName”: “Smith”, “age”: 25,
“phoneNumber”: [
{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
]
}

9


JSON Processing 1.0
Streaming Parser
{

START_OBJECT

{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
]
}

10


JSON Processing 1.0
Streaming Parser
{

KEY_NAME

{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
]
}

11


JSON Processing 1.0
Streaming Parser
VALUE_STRING

{

{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
]
}

12


JSON Processing 1.0
Streaming Parser
VALUE_NUMBER

{

{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
]
}

13


JSON Processing 1.0
Streaming Parser
{
“phoneNumber”: [ START_ARRAY
{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
]
}

14


JSON Processing 1.0
Streaming Parser
{
{ “type”: “home”, “number”: “212 555-1234” },
{ “type”: “fax”, “number”: “646 555-4567” }
] END_ARRAY
}

15


JSON Processing 1.0
Using Streaming API to generate JSON
JsonGenerator gen = Json.createGenerator…
.writeStartObject()
.write("firstName", "John")
.write("lastName", "Smith")
.write("age", 25)
.writeStartArray(“phones”)
.writeStartObject()
.write(“type", “home")
.write(“number”, “222 555-1234”))
.writeEnd()
.writeStartObject() … .writeEnd()
.writeEnd()
.writeEnd();
16


{ "firstName": "John", "lastName": "Smith", "age": 25,
“phones" : [
{ “type”: “home”, “number”: “ 222 555-1234” },
{ “type”: “fax”, “number”: “ 646 555-4567” }
]
}

JSON Processing 1.0
Object Model API
§  JsonObject/JsonArray – JSON object and array structures
–  JsonString and JsonNumber for string and number values

§  JSON builders – build JsonObject and JsonArray
§  JsonReader – reads JsonObject and JsonArray
§  JsonWriter – writes JsonObject and JsonArray

17


JsonReader
§  Reads JsonObject and JsonArray from input source
§  Uses pluggable JsonParser

JsonReader reader = new JsonReader(io));
JsonObject obj = reader.readObject();

18


JsonWriter
§  Writes JsonObject and JsonArray to output source
§  Uses pluggable JsonGenerator

JsonWriter writer = new JsonWriter(io));
writer.writeObject(obj);

19


WebSockets 1.0

20


Java API for WebSocket 1.0
§  Bidirectional full-duplex messaging
–  Over a single TCP connection

§  Annotation-based or interface-based programming model
§  Server and Client WebSocket Endpoints
–  Annotated: @ServerEndpoint, @ClientEndpoint
–  Programmatic: Endpoint

§  Integrated with Java EE web container
§  Highly configurable
§  Simple packaging and deployment as wars or jars

21


Java API for WebSocket 1.0
Main API classes
§  Endpoint
–  intercepts websocket lifecycle events

§  MessageHandler
–  handles incoming messages for endpoint

§  Session
–  represents the active conversation

§  RemoteEndpoint
–  represents the other end of the conversation

22


WebSocket Endpoints
Programmatic API
public class MyClient extends Endpoint {
public void onOpen(Session session, EndpointConfig ec) {
session.addMessageHandler(new MessageHandler.Whole<String>() {
public void onMessage(String text) {
System.out.println("Message came from the server : " + message”);
}
}
session.getBasicRemote().sendText("Hello!");
}
public void onClose(Session session, CloseReason closeReason) {
super.onClose(session, closeReason);
}
}
23


WebSocket Endpoints as POJOs
Annotated client endpoint
@ClientEndpoint
public class MyClient {
@OnOpen public void onOpen(Session session) {
session.getBasicRemote().sendText(“Hello”);
}
@OnMessage public void onMessage(String text, Session session) {
System.out.println("Message came from the server : " + message);
}
}

24


WebSocket Endpoints as POJOs
Annotated server endpoint
@ServerEndpoint("/chat") public class ChatServer {
static Set<Session> peers = Collections.synchronizedSet(…);
@OnOpen public void onOpen(Session peer) {
peers.add(peer);
}
@OnMessage public void onMessage (String message, Session client) {
for (Session peer : peers) {
peer.getBasicRemote().sendObject(message);
}
}
@OnClose public void onClose(Session peer) {
peers.remove(peer);
}
25

}

JAX-RS 2.0

26


Java API for RESTful Web Services (JAX-RS) 2.0

§  Client API
§  Asynchronous Processing
§  Filters and Interceptors
§  Validation

27


JAX-RS 1.1
Previous Client API
URL url = new URL("http://. . ./atm/balance");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoInput(true);
conn.setDoOutput(false);
conn.setRequestMethod("GET");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
//. . .
}

28


JAX-RS 2.0
JAX-RS 2.0 Client API

Client client = ClientFactory.newClient();
WebTarget webTarget= client.target(new URI(TARGET_URI)) ;
webTarget.request().post(Entity.text(message));

29


JAX-RS 2.0
JAX-RS 2.0 Client API

Client client = ClientFactory.newClient();
String name= client.target("http://.../orders/{orderId}/customer")
.resolveTemplate(“orderId”, “10”)
.queryParam("pin", "9876")
.request()
.get(String.class);

30


Async Processing
§  Server API support
–  Off-load I/O container threads
§  Long-running operations
–  Efficient asynchronous event processing
§  Suspend while waiting for an event
§  Resume when event arrives
–  Leverage Servlet 3.x async support (if available)
§  Client API support
–  Asynchronous request invocation API
§  Future<RESPONSE>, InvocationCallback<RESPONSE>

31


Async Processing: Server-side
@Path("/async/longRunning")
public class MyResource {
@GET
public void longRunningOp(@Suspended AsyncResponse ar) {
ar.setTimeoutHandler(new MyTimoutHandler());
ar.setTimeout(15, SECONDS);

}

32

}

Executors.newSingleThreadExecutor().submit(new Runnable() {
public void run() {
…
ar.resume(result);
}
});


Async Processing: Client-side
WebTarget target = client.target("http://.../balance”)…
// Start async call and register callback
Future<?> handle = target.request().async().get(
new InvocationCallback<String>() {
void complete(String balance) { … }
void failed(InvocationException e) { … }
});
// After waiting for too long…
if (!handle.isDone()) handle.cancel(true);

33


Filters & Interceptors
Motivation

§  Customize JAX-RS request/response processing
–  Use Cases: Logging, Compression, Security, Etc.

§  Introduced for client and server APIs
§  Replace existing proprietary support
–  Provided by most JAX-RS 1.x implementations
§  All using slightly different types or semantics

34


Filter each incoming/outgoing message
§  Request è Request

§  Non-wrapping filter chain
–  Filters do not invoke next filter in

the chain directly
–  managed by the JAX-RS runtime

–  ContainerRequestFilter,

ClientRequestFilter

§  Response è Response
–  ContainerResponseFilter,

ClientResponseFilter
§  Each filter decides to proceed or

break the chain

§  Server-side specialties
–  @PreMatching,
DynamicFeature

35


A Logging Filter Example

public class RequestLoggingFilter implements ContainerRequestFilter {
@Override
public void filter(ContainerRequestContext requestContext) {
log(requestContext);
}
}

36

// non-wrapping => returns without invoking the next filter

...


Intercept entity providers
§  Invoked ONLY when/if entity

reading/writing occurs

§  MessageBodyReader interceptor
–  ReaderInterceptor interface

–  Performance boost

§  Wrapping interceptor chain
–  Each interceptor invokes the next

one in the chain via
context.proceed()

37


§  MessageBodyWriter interceptor
–  WriterInterceptor interface

A GZip Reader Interceptor Example

public class GzipInterceptor implements ReaderInterceptor {
@Override
Object aroundReadFrom(ReaderInterceptorContext ctx) {
InputStream old = ctx.getInputStream();
ctx.setInputStream(new GZIPInputStream(old));
// wrapping => invokes the next interceptor
Object entity = ctx.proceed();

}

38

}

ctx.setInputStream(old);
return entity;


JAX-RS 2.0
Bean Validation
@Path("/")
class MyResourceClass {
@POST
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public void registerUser(
@NotNull @FormParam("firstName") String firstName,
@NotNull @FormParam("lastName") String lastName,
@Email @FormParam("email") String email) {
... }
…
}
39


CDI 1.1

40


CDI: Default enabling
Finer scanning control
§  Possible values: all, annotated, none
§  The annotated is set as the default, scan @*Scoped annotated
§  all behaves like in Java EE 6 (default if not set)

<beans ... version="1.1" bean-discovery-mode="all">!
<alternatives>!
<class>org.agoncal.book.MockGenerator</class>!
</alternatives>!
</beans>!

41


CDI: @Vetoed
Veto the processing of the class or package
@Vetoed!
public class NonProcessedBean { 
...!
}!
!
package-info.java
@Vetoed!
package com.non.processed.package;!
42


Interceptor 1.2

43


Interceptors: AroundConstruct
Interceptor associated with a constructor

public class LoggingInterceptor {!
!
@AroundConstruct!
private void init(InvocationContext ic) throws Exception{
logger.fine("Entering constructor");!
ic.proceed();!
logger.fine("Exiting constructor");!
}!
!
@AroundInvoke!
public Object logMethod(InvocationContext ic) ... {!
// ...!
}!
}!
44


Interceptors: @Priority
Prioritizing interceptor bindings
§  PLATFORM_BEFORE (0), LIBRARY_BEFORE (1000), APPLICATION

(2000), LIBRARY_AFTER (3000), PLATFORM_AFTER (4000)
§  Lower the priority, earlier the invocation!

@Interceptor!
@Loggable!
@Priority(Interceptor.Priority.LIBRARY_BEFORE + 10)!
public class LoggingInterceptor {!
!
@AroundInvoke!
...!
}!
45


Default Resources

46


Resource Definition Metadata

§  Specifies resources needed by application
–  Enhances configurability in Java EE 7 apps
–  Facilitates provisioning in cloud environments
–  Java EE 6 introduced DataSourceDefinition
@DataSourceDefinition (
name=“java:app/jdbc/myDB”,
className=“oracle.jdbc.pool.OracleDataSource”,
isolationLevel=TRANSACTION_REPEATABLE_READ,
initialPoolSize=5)
@Stateless public class MySessionBean {
@Resource(lookup=“java:app/jdbc/myDB”) DataSource my DB;
…
}
47


Resource Definition Metadata

§  Java EE 7 adds:
–  JMSConnectionFactoryDefinition
–  JMSDestinationDefinition
–  MailSessionDefinition
–  ConnectionFactoryDefinition
–  AdministeredObjectDefinition

48


Default Resources
Preconfigured resources for use by application
§  JDBC/JPA: java:comp/DefaultDataSource
§  JMS: java:comp/DefaultJMSConnectionFactory
§  Concurrency Utilities:
–  java: comp/DefaultManagedExecutorService
–  java: comp/DefaultManagedScheduledExecutorService
–  java: comp/DefaultManagedThreadFactory
–  java: comp/DefaultManagedContextService

49


JMS 2.0

50


Java Message Service 2.0
New JMS Simplified API targeted at ease of development
§  Less code, less boilerplate
§  Fewer objects to manage
§  Increased developer productivity
§  “Classic API” has also been improved

51


JMS 2.0
Simplifications include….
§  New JMSContext interface
§  Use of CDI injection; new TransactionScope
§  AutoCloseable JMSContext, Connection, Session, …
§  Use of runtime exceptions
§  Method chaining on JMSProducer
§  Simplified message sending

52


JMS 1.1: Sending a message
@Resource(lookup = "java:global/jms/demoConnectionFactory")
ConnectionFactory connectionFactory;
@Resource(lookup = "java:global/jms/demoQueue")
Queue demoQueue;
public void sendMessage(String payload) {
try {
Connection connection = connectionFactory.createConnection();
try {
Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
MessageProducer messageProducer = session.createProducer(demoQueue);
TextMessage textMessage = session.createTextMessage(payload);
messageProducer.send(textMessage);
13 lines of
} finally {
code just
connection.close();
to send a
}
message
} catch (JMSException ex) {
Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
}
}
53


must create
Queue demoQueue;

several
intermediate
objects

try {
try {
} finally {
connection.close();
}
}
}
54


Queue demoQueue;

boilerplate
code

try {
try {
} finally {
connection.close();
}
}
}
55


Queue demoQueue;
try {
try {
must
} finally {
close
connection.close();
resources
}
after use!
}
}
56


Queue demoQueue;
try {
try {
all
} finally {
methods
connection.close();
throw
}
checked
exceptions
}
}
57


Simplifying the JMS API
Strategy
§  Simplify existing JMS 1.1 API where it won't break compatibility
§  Define new simplified API requiring fewer objects
–  JMSContext, JMSProducer, JMSConsumer

§  In Java EE, allow JMSContext to be injected and managed by the

container

58


JMS 2.0
Sending a message using Simplified API and JMSContext
@Resource(lookup = “java:global/jms/myConnectionFactory”)
@Resource(lookup = “java:global/jms/myQueue”)
Queue queue;
public void sendMessage(String text) {
try (JMSContext context = connectionFactory.createContext();) {
context.createProducer().send(queue, text);
} catch (JMSRuntimeException ex) {
…
}
}

59


JMS 2.0
Even simpler….
@Inject
@JMSConnectionFactory(““java:global/jms/myConnectionFactory”)
JMSContext context;
Queue queue;
}

60


JMS 2.0
Even simpler still….
@Inject
JMSContext context;
Queue queue;
}

61


JMS 2.0:
New API features

62


Delivery delay
§  Allows a JMS client to schedule the future delivery of a message
§  New method on old MessageProducer

public void setDeliveryDelay(long deliveryDelay)
§  New method on the new JMSProducer

public JMSProducer setDeliveryDelay(long deliveryDelay)
§  Sets minimum time in ms from that a message should be retained by

the messaging system before delivery to a consumer
§  Why? If the business requires deferred processing, e.g. end of day

63


Async send
§  Send a message and return immediately without blocking until an

acknowledgement has been received from the server.
§  Instead, when the acknowledgement is received, an asynchronous callback will be
invoked
§  New methods on MessageProducer

messageProducer.send(message,completionListener)
§  Feature also available on JMSProducer
§  Why? Allows thread to do other work whilst waiting for the acknowledgement

64


Async send

§  Application specifies a CompletionListener instance
public interface CompletionListener {
void onCompletion(Message message);
void onException(Message message, Exception exception);
}

65


Better handling of "poison" messages
Make JMSMXDeliveryCount mandatory
§  JMS 1.1 defines an optional JMS defined message property

JMSXDeliveryCount.
–  When used, this is set by the JMS provider when a message is received,

and is set to the number of times this message has been delivered
(including the first time). The first time is 1, the second time 2, etc
§  JMS 2.0 will make this mandatory
§  Why? Allows app servers and applications to handle "poisonous"

messages better
66


Multiple consumers on a topic subscription
§  Allows scalable consumption of messages from a topic subscription
–  multiple threads, multiple JVMs

§  New methods needed for non-durable subscriptions
MessageConsumer messageConsumer=
session.createSharedConsumer(topic,sharedSubscriptionName);

§  Existing methods used for durable subscriptions
MessageConsumer messageConsumer=
session.createDurableConsumer(topic,durableSubscriptionName);

§  Also available on JMSContext

67


Concurrency Utilities for Java EE 1.0

68


Concurrency Utilities for Java EE 1.0
Provides asynchronous capabilities to Java EE components
§  Extension of Java SE Concurrency Utilities API
§  Provides managed objects for submitting tasks and obtaining managed

threads
–  ManagedExecutorService
–  ManagedScheduledExecutorService
–  ManagedThreadFactory
–  ContextService

69


Concurrency: ManagedExecutor
Default ManagedExectuor
@Resource 
ManagedExecutorService executor; 
!
 
ManagedExecutorService executor =
(ManagedExecutorService) ctx 
.lookup("java:comp/DefaultManagedExecutorService");!

70


Concurrency: ManagedExecutor
Specify in web.xml
<web-app … version="3.1">!
<resource-env-ref>!
<resource-env-ref-name>!
concurrent/myExecutor!
</resource-env-ref-name>!
<resource-env-ref-type>!
javax.enterprise.concurrent.ManagedExecutorService!
</resource-env-ref-type>!
</resource-env-ref>!
</web-app>!

71


Concurrency: ManagedScheduledExecutor

§  Managed version of ScheduledExecutorService!
§  Submit delayed or periodic tasks

@Resource 
ManagedScheduledExecutorService executor;!

72


Access using JNDI
InitialContext ctx = new InitialContext();  
 
ManagedScheduledExecutorService executor =
(ManagedScheduledExecutorService)ctx.lookup( 
"java:comp/DefaultManagedScheduledExecutorService"); 
!
§  Can be defined in web.xml as well

73



§  executor.schedule(new MyCallableTask(), 5,

TimeUnit.SECONDS);!
§  executor.scheduleAtFixedRate(new MyRunnableTask(),

2, 3, TimeUnit.SECONDS);!
§  executor.scheduleWithFixedDelay(new
MyRunnableTask(), 2, 3, TimeUnit.SECONDS);!

74


Concurrency: ManagedThreadFactory

§  Extends ThreadFactory

@Resource(name = "DefaultManagedThreadFactory") 
ManagedThreadFactory factory;

ManagedThreadFactory factory =
(ManagedThreadFactory) ctx.lookup("java:comp/
DefaultManagedThreadFactory"); 

75


Concurrency: ManagedThreadFactory

§  Thread thread = factory.newThread(new MyTask());

§  ((ManageableThread)thread).isShutdown(); 

76


Concurrency: DynamicProxy

§  Create dynamic proxy objects, adds contextual information available

for applications running in Java EE environment
§  Classloading, JNDI, Security, …

77


Concurrency: DynamicProxy

@Resource 
ContextService service; 
 
 
Runnable proxy = service.createContextualProxy(new
MyRunnable(), Runnable.class); 
 
 
Future f = executor.submit(proxy);!

78


Batch Applications for the Java Platform 1.0

79


Batch Applications for the Java Platform 1.0

§  Designed for non-interactive, bulk-oriented and long-running tasks
§  Sequential, parallel, and/or decision-based batch execution
§  Processing styles
–  Item-oriented: ItemReader, ItemProcessor, ItemWriter interfaces
–  Task-oriented: Batchlet interfaces

80


Batch 1.0
Key concepts
§  Job: entire batch process
–  Defined through XML Job Specification Language

§  Step: independent, sequential phase of a job
§  JobOperator: interface for managing job processing
§  JobRepository: information about past and present jobs
Job Operator

Job

Step

ItemReader
ItemWriter

Job Repository
81


ItemProcessor

Batch 1.0
Job steps
§  Chunked step: Item-oriented processing
–  ItemReader/ItemProcessor/ItemWriter pattern
–  Configurable checkpointing and transactions

§  Batchlet: Task-oriented processing
–  Roll-your-own batch pattern
–  Runs to completion and exits

§  Job can include both types of steps

82


Batch 1.0
Job specification language
<job id="myJob" xmlns="http://xmlns.jcp.org/xml/ns/javaee" version="1.0">
<step id="step1" next="step2">
<chunk item-count="3">
<reader ref="myItemReader"></reader>
<processor ref="myItemProcessor"></processor>
<writer ref="myItemWriter"></writer>
</chunk>
</step>
<step id="step2" next=“step3”>
<batchlet ref="myBatchlet"/>
</step>
<step id="step3" >
<chunk item-count="3">
<reader ref="myOtherItemReader"></reader>
<processor ref="myOtherItemProcessor"></processor>
<writer ref="myOtherItemWriter"></writer>
</chunk>
</step>
</job>

83


EJB 3.2

84


EJB 3.2 new features and improvments

§ Singleton Session Beans
§ EJB 3.1 Lite:
§  Includes non-persisted TimerService
§  Local asynchronous invocation of session beans

85


Java Persistence API 2.1

86


Java Persistence API 2.1
Schema generation
§  Generation of database tables, indexes, constraints, etc.
§  Designed for flexibility
–  Scenarios: (iterative) prototyping; production; provisioning environments
–  Generate from object/relational metadata (annotations and/or XML)
–  Generate from bundled SQL DDL scripts; also SQL load scripts
–  Generate directly into database
–  Generate into SQL DDL scripts

§  Process controlled by metadata or runtime properties

87


JPA 2.1
Schema generation into scripts
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/
ns/persistence/persistence_2_1.xsd">
<persistence-unit name=“samplePU" transaction-type="JTA">
<jta-data-source>jdbc/mypu</jta-data-source>
<properties>
<property name="javax.persistence.schema-generation.database.action" value="none" />
<property name="javax.persistence.schema-generation.scripts.action" value=“drop-and-create"/>
<property name="javax.persistence.schema-generation.scripts.create-target" value=”//temp/create.sql"/
>
<property name="javax.persistence.schema-generation.scripts.drop-target" value=“/temp/drop.sql"/>
</properties>
</persistence-unit>
</persistence>

88


JPA 2.1
Schema generation from scripts
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/
persistence/persistence_2_1.xsd">
<persistence-unit name=“samplePU" transaction-type="JTA">
<jta-data-source>jdbc/mypu</jta-data-source>
<properties>
<property name="javax.persistence.schema-generation.database.action" value="drop-and-create"/>
<property name="javax.persistence.schema-generation.create-source" value="script"/>
<property name="javax.persistence.schema-generation.drop-source" value="script"/>
<property name="javax.persistence.schema-generation.create-script-source" value="META-INF/create.sql"/>
<property name="javax.persistence.schema-generation.drop-script-source" value="META-INF/drop.sql"/>
<property name="javax.persistence.sql-load-script-source" value="META-INF/load.sql"/>
</properties>
</persistence-unit>
</persistence>

89


JPA 2.1
Some more features
§  Stored procedure support: @NamedStoredProcedureQuery
§  Dynamically Defining Named Queries
§  Enhancements To Queries
§  @Converter and @Convert(…)

90


Java EE 7 Summary

MEETING
ENTERPRISE
DEMANDS

DEVELOPER
PRODUCTIVITY
Java EE 7

§  More annotated POJOs
§  Less boilerplate code
§  Cohesive integrated
platform

91


§ 
§ 
§ 
§ 

WebSockets
JSON
Servlet 3.1 NIO
REST

§  Batch
§  Concurrency
§  Simplified JMS

DOWNLOAD
Java EE 7 SDK

oracle.com/javaee
GlassFish 4.0
Full Platform or Web Profile

glassfish.org

92


Questions…

?
93


Java EE 7 overview

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (17)

Semelhante a Java EE 7 overview

Semelhante a Java EE 7 overview (20)

Mais de Masoud Kalali

Mais de Masoud Kalali (13)

Último

Último (20)

Java EE 7 overview