Presente e Futuro: Java EE.next()

Presente e Futuro:
Java EE.next()
Bruno Borges
Oracle Product Manager e Java Evangelist
blogs.oracle.com/brunoborges
@brunoborges

The preceding is intended to outline our general product direction. It is
intended for information purposes only, and may not be incorporated
into any contract. It is not a commitment to deliver any material, code,
or functionality, and should not be relied upon in making purchasing
decisions. The development, release, and timing of any features or
functionality described for Oracle’s products remains at the sole
discretion of Oracle.

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

Java EE 6
10 Dezembro, 2009


Java EE 6 – Estatísticas

 50+ Milhões de Downloads de Componentes Java EE 6
 #1 Escolha para Desenvolvedores Enterprise
 #1 Plataforma de Desenvolvimento de Aplicações
 Implementação mais Rápida de uma versão do Java EE


Top Ten Features in Java EE 6

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

EJB packaging in a WAR
Type-safe dependency injection
Optional deployment descriptors (web.xml, faces-config.xml)
JSF standardizing on Facelets
One class per EJB
Servlet and CDI extension points
CDI Events
EJBContainer API
Cron-based @Schedule
Web Profile


Java EE 7 Scope
JSR 342
 Developer Productivity
– Less Boilerplate
– Richer Functionality
– More Defaults

 HTML5 Support
– WebSocket
– JSON
– HTML5 Forms


Java EE 7 Themes





 Batch Applications
 Concurrency Utilities
 Simplified JMS and
Compatibility


WebSocket
JSON Processing
Servlet 3.1 NIO
REST
HTML5-Friendly
Markup






More annotated POJOs
Less boilerplate code
Cohesive integrated platform
Default resources

WebSockets

Java EE 7 for Next Generation Applications

Deliver HTML5 Dynamic Scalable Apps

 Reduce response time with low latency data exchange using WebSockets
 Simplify data parsing for portable applications with standard JSON support
 Deliver asynchronous, scalable, high performance RESTful Services

Java EE 7 for the Developer
110101011101010011000101001001010001
PRODUCTIVITY
011001011010010011010010010100100001
001010100111010010110010101001011010
010010100100001001010100111010011101
010111010100110001010010010100010110
010110100100110100100101001000010010
101001110100101100101010010110100100
101001000010010101001110100100110101

Increased Developer Productivity

 Simplify application architecture with a cohesive integrated platform
 Increase efficiency with reduced boiler-plate code and broader use of annotations
 Enhance application portability with standard RESTful web service client support


Java EE 7 for the Enterprise
Scaling to the Most Demanding Requirements

 Break down batch jobs into manageable chunks for




uninterrupted OLTP performance
Easily define multithreaded concurrent tasks for
improved scalability
Simplify application integration with standard Java
Messaging Service interoperability

Java EE 7 JSRs
CDI
Extensions

JSF 2.2,
JSP 2.3,
EL 3.0

Web
Fragments

JAX-RS 2.0,
JAX-WS 2.2

JSON 1.0

WebSocket
1.0

Servlet 3.1

CDI 1.1

Interceptors
1.2, JTA 1.2

Common
Annotations 1.1

EJB 3.2

Managed Beans 1.0

JPA 2.1


JMS 2.0

Concurrency 1.0

JCA 1.7

Batch 1.0

Top 10 Features Java EE 7
 WebSocket client/server endpoints
 Batch Applications
 JSON Processing
 Concurrency Utilities
 Simplified JMS API
 @Transactional and @TransactionScoped!
 JAX-RS Client API
 Default Resources
 More annotated POJOs
 Faces Flow

Java API for WebSocket 1.0
Annotated Endpoint
import javax.websocket.*;
@ServerEndpoint("/hello")
public class HelloBean {
@OnMessage
public String sayHello(String name) {
return “Hello “ + name;
}
}


Java API for WebSocket 1.0
Chat Server
@ServerEndpoint("/chat")
public class ChatBean {
static Set<Session> peers = Collections.synchronizedSet(…);
@OnOpen
public void onOpen(Session peer) {peers.add(peer);}
@OnClose
public void onClose(Session peer) {peers.remove(peer);}
@OnMessage
public void message(String message, Session client) {
peers.forEach(peer -> peer.getRemote().sendObject(message);
}
}

Java API for JSON Processing 1.0
 API to parse and generate JSON
 Streaming API
– Low-level, efficient way to parse/generate JSON
– Provides pluggability for parsers/generators

 Object Model API
– Simple, easy-to-use high-level API
– Implemented on top of Streaming API

 Binding JSON to Java objects forthcoming

Java API for JSON Processing 1.0
Streaming API – JsonParser
{
"firstName": "John", "lastName": "Smith", "age": 25,
"phoneNumber": [
{ "type": "home", "number": "212 555-1234" },
{ "type": "fax", "number": "646 555-4567" }
]
}
Iterator<Event> it = parser.iterator();
Event event = it.next();

// START_OBJECT

event = it.next();

// KEY_NAME

event = it.next();

// VALUE_STRING

String name = parser.getString();

// "John”


Batch Applications 1.0
 Suited for non-interactive, bulk-oriented and

long-running tasks
 Computationally intensive
 Can execute sequentially/parallel
 May be initiated
– Adhoc
– Scheduled
 No scheduling APIs included


 Job: Batch process
 Step: Independent, sequential phase of job
– Reader, Processor, Writer

 Job Operator: Manage batch processing
 Job Repository: Metadata for jobs


Job Specification Language – Chunked Step
<step id=”sendStatements”>
…implements ItemReader {
<chunk reader ref=”accountReader” public Object readItem() {
processor ref=”accountProcessor”
// read account using JPA
writer ref=”emailWriter”
}
chunk-size=”10” />
</step>
…implements ItemProcessor {
Public Object processItems(Object account) {
// read Account, return Statement
}
…implements ItemWriter {
public void writeItems(List accounts) {
// use JavaMail to send email
}

Concurrency Utilities for Java EE 1.0
 Provide asynchronous capabilities to Java EE

application components
– Without compromising container integrity

 Extension of Java SE Concurrency Utilities API (JSR

166)
 Support simple (common) and advanced concurrency
patterns


 Provide 4 managed objects
– ManagedExecutorService
– ManagedScheduledExecutorService
– ManagedThreadFactory
– ContextService

 Context propagation
 Task event notifications
 Transactions

Submit Tasks to ManagedExecutorService using JNDI
public class TestServlet extends HTTPServlet {
@Resource(name=“concurrent/BatchExecutor”)
ManagedExecutorService executor;
Future future = executor.submit(new MyTask());
class MyTask implements Runnable {
public void run() {
. . . // task logic
}
}
}


Java API for RESTful Web Services 2.0
 Client API
 Message Filters and Entity Interceptors
 Asynchronous Processing – Server and Client
 Common Configuration


Java API for RESTful Web Services 2.0
Client API

// Get instance of Client
Client client = ClientBuilder.newClient();
// Get customer name for the shipped products
String name = client.target(“../orders/{orderId}/customer”)
.resolveTemplate(”orderId", ”10”)
.queryParam(”shipped", ”true”)
.request()
.get(String.class);


Java Message Service 2.0
 Simplified API
– Less verbose
– Reduced boilerplate code
– Resource injection
– Try-with-resources for Connection, Session, etc.

 Both in Java EE and SE



Sending a Message using JMS 1.1
@Resource(lookup = "myConnectionFactory”)
ConnectionFactory connectionFactory;
@Resource(lookup = "myQueue”)
Queue myQueue;
public void sendMessage (String payload) {
Connection connection = null;
try {
connection = connectionFactory.createConnection();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer messageProducer = session.createProducer(myQueue);
TextMessage textMessage = session.createTextMessage(payload);
messageProducer.send(textMessage);
} catch (JMSException ex) {
//. . .
} finally {
if (connection != null) {
try {
connection.close();
} catch (JMSException ex) {
//. . .
}
}
}
}


Application Server
Specific Resources

Boilerplate Code

Exception Handling


Sending message using JMS 2.0
@Inject
JMSContext context;
@Resource(lookup = "java:global/jms/demoQueue”)
Queue demoQueue;
public void sendMessage(String payload) {
context.createProducer().send(demoQueue, payload);
}


Bean Validation 1.1
 Alignment with Dependency Injection
 Method-level validation
– Constraints on parameters and return values
– Check pre-/post-conditions


Bean Validation 1.1

Method Parameter and Result Validation
public void placeOrder(
@NotNull String productName,
Built-in
@NotNull @Max(“10”) Integer quantity,
@Customer String customer) {
Custom
//. . .
}
@Future
public Date getAppointment() {
//. . .
}

Java Persistence API 2.1
 Schema Generation
– javax.persistence.schema-generation.* properties

 Unsynchronized Persistence Contexts
 Bulk update/delete using Criteria
 User-defined functions using FUNCTION
 Stored Procedure Query


Servlet 3.1
 Non-blocking I/O
 Protocol Upgrade
 Security Enhancements
– <deny-uncovered-http-methods>: Deny request to HTTP

methods not explicitly covered


Servlet 3.1
Non-blocking IO - Traditional
public class TestServlet extends HttpServlet
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
ServletInputStream input = request.getInputStream();
byte[] b = new byte[1024];
int len = -1;
while ((len = input.read(b)) != -1) {
. . .
}
}
}

Servlet 3.1
Non-blocking I/O: doGet Code Sample
AsyncContext context = request.startAsync();
ServletInputStream input = request.getInputStream();
input.setReadListener(
new MyReadListener(input, context));


Servlet 3.1
Non-blocking I/O: MyReadListener Code Sample
@Override
public void onDataAvailable() {
try {
StringBuilder sb = new StringBuilder();
int len = -1;
byte b[] = new byte[1024];
while (input.isReady() && (len = input.read(b)) != -1) {
String data = new String(b, 0, len);
System.out.println("--> " + data);
}
} catch (IOException ex) {
. . .
}
}
. . .

JavaServer Faces 2.2
 Faces Flow
 Resource Library Contracts
 HTML5 Friendly Markup Support
– Pass through attributes and elements

 Cross Site Request Forgery Protection
 Loading Facelets via ResourceHandler
 File Upload Component


Java Transaction API 1.2
 @Transactional: Define transaction boundaries on

CDI managed beans
 @TransactionScoped: CDI scope for bean instances
scoped to the current JTA transaction


Novas Possibilidades com Java EE 7
 Camada Web
 100% server-side
– JSF
 100% client-side
– JAX-RS + WebSockets + (Angular.JS)
 Híbrido
– Utilize o que achar conveniente, e melhor, para

cada caso da aplicação

Novas Possibilidades com Java EE 7
 Camada Back-end
 Java EE Web Profile
– EJB3 Lite + CDI + JTA + JPA
 Java EE Full Profile
– WebP + JMS + JCA + Batch


Java EE 7 Implementation

4.0

glassfish.org

Java EE 8 and Beyond

Standards-based cloud programming model
• Deliver cloud architecture
• Multi tenancy for SaaS
applications
• Incremental delivery of JSRs
• Modularity based on Jigsaw


NoSQL

Storage
JSON-B
Modularity

Multitenancy

Java EE 7
Cloud
PaaS
Enablement

Thin Server
Architecture

Adopt-a-JSR
Participating JUGs


Call to Action
•
•
•
•
•

Specs: javaee-spec.java.net
Implementation: glassfish.org
The Aquarium: blogs.oracle.com/theaquarium
Adopt a JSR: glassfish.org/adoptajsr
NetBeans: wiki.netbeans.org/JavaEE7


Perguntas?


OBRIGADO!
@brunoborges
blogs.oracle.com/brunoborges


Presente e Futuro: Java EE.next()

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (14)

Similar to Presente e Futuro: Java EE.next()

Similar to Presente e Futuro: Java EE.next() (20)

More from Bruno Borges

More from Bruno Borges (20)

Recently uploaded

Recently uploaded (20)

Presente e Futuro: Java EE.next()