Presente e Futuro: Java EE.next()

Presente e Futuro: Java EE.next()

Bruno BorgesOracle Product Manager e Java Evangelistblogs.oracle.com/brunoborges@brunoborges

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

3

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.


4

Java EE 610 Dezembro, 2009


5

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


6

Top Ten Features in Java EE 6

1. EJB packaging in a WAR2. Type-safe dependency injection3. Optional deployment descriptors (web.xml, faces-config.xml)

4. JSF standardizing on Facelets5. One class per EJB6. Servlet and CDI extension points7. CDI Events8. EJBContainer API9. Cron-based @Schedule10. Web Profile


7

Java EE 7 Scope

Developer Productivity– Less Boilerplate

– Richer Functionality

– More Defaults

HTML5 Support– WebSocket

– JSON

– HTML5 Forms

JSR 342


8

Java EE 7 Themes

More annotated POJOs Less boilerplate code Cohesive integrated platform Default resources

Batch Applications Concurrency Utilities Simplified JMS and

Compatibility

WebSocket JSON Processing Servlet 3.1 NIO REST HTML5-Friendly

Markup


9

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

Web

So

cket

s


10

Java EE 7 for the Developer

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

110101011101010011000101001001010001

011001011010010011010010010100100001

001010100111010010110010101001011010

010010100100001001010100111010011101

010111010100110001010010010100010110

010110100100110100100101001000010010

101001110100101100101010010110100100

101001000010010101001110100100110101

PRODUCTIVITY


11

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


12

EJB 3.2

Servlet 3.1

CDIExtensions

Batch 1.0

Web Fragments

Java EE 7 JSRs

JCA 1.7JMS 2.0JPA 2.1

Managed Beans 1.0

Concurrency 1.0Common

Annotations 1.1Interceptors1.2, JTA 1.2✔

CDI 1.1

JSF 2.2,JSP 2.3,EL 3.0

JAX-RS 2.0,JAX-WS 2.2

JSON 1.0WebSocket

1.0

✔


13

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


15

Java API for WebSocket 1.0Annotated Endpointimport javax.websocket.*;

@ServerEndpoint("/hello")public class HelloBean {

@OnMessage public String sayHello(String name) { return “Hello “ + name; }}


16

Java API for WebSocket 1.0

@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);

}}

Chat Server


17

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


18

{

"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”

Java API for JSON Processing 1.0Streaming API – JsonParser


19

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


20


Job: Batch process Step: Independent, sequential phase of job

– Reader, Processor, Writer

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


21


<step id=”sendStatements”> <chunk reader ref=”accountReader” processor ref=”accountProcessor” writer ref=”emailWriter” chunk-size=”10” /></step>

…implements ItemReader {public Object readItem() { // read account using JPA}

…implements ItemProcessor {Public Object processItems(Object account) { // read Account, return Statement}

…implements ItemWriter {public void writeItems(List accounts) { // use JavaMail to send email}

Job Specification Language – Chunked Step


22

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


23


Provide 4 managed objects– ManagedExecutorService

– ManagedScheduledExecutorService

– ManagedThreadFactory

– ContextService

Context propagation Task event notifications Transactions


24


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 } }}

Submit Tasks to ManagedExecutorService using JNDI


25

Java API for RESTful Web Services 2.0

Client API Message Filters and Entity Interceptors Asynchronous Processing – Server and Client Common Configuration


26

Java API for RESTful Web Services 2.0Client API

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


27

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


28


@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) {

//. . . } } }}

Sending a Message using JMS 1.1

Application Server Specific Resources

Boilerplate Code

Exception Handling


29


@InjectJMSContext context;

@Resource(lookup = "java:global/jms/demoQueue”)Queue demoQueue;

public void sendMessage(String payload) { context.createProducer().send(demoQueue, payload);}

Sending message using JMS 2.0


30

Bean Validation 1.1

Alignment with Dependency Injection Method-level validation

– Constraints on parameters and return values

– Check pre-/post-conditions


31

Bean Validation 1.1Method Parameter and Result Validation

Built-in

Custom

@Futurepublic Date getAppointment() { //. . .}

public void placeOrder( @NotNull String productName, @NotNull @Max(“10”) Integer quantity, @Customer String customer) { //. . .}


32

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


33

Servlet 3.1

Non-blocking I/O Protocol Upgrade Security Enhancements

– <deny-uncovered-http-methods>: Deny request to HTTP methods not explicitly covered


34

Servlet 3.1

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) { . . . } }}

Non-blocking IO - Traditional


35

Servlet 3.1

AsyncContext context = request.startAsync();ServletInputStream input = request.getInputStream();input.setReadListener( new MyReadListener(input, context));

Non-blocking I/O: doGet Code Sample


36

Servlet 3.1

@Overridepublic 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) { . . . }}. . .

Non-blocking I/O: MyReadListener Code Sample


37

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


38

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


39

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


40

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


41

4.0Java EE 7 Implementation

glassfish.org


43

Java EE 8 and BeyondStandards-based cloud programming model

• Deliver cloud architecture

• Multi tenancy for SaaS applications

• Incremental delivery of JSRs

• Modularity based on Jigsaw

Java EE 7

PaaSEnablement

Multitenancy

NoSQL

JSON-B

ModularityCloud

Storage

Thin ServerArchitecture


46

Adopt-a-JSRParticipating JUGs


48

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


49

Perguntas?


50

OBRIGADO!

@brunoborgesblogs.oracle.com/brunoborges


51


52

Date post:	15-Jan-2015
Category:	Technology
Upload:	bruno-borges
View:	933 times
Download:	3 times

Presente e Futuro: Java EE.next()

Technology