Indic threads pune12-java ee 7 platformsimplification html5

The Java EE 7 Platform:
Simplicity, Productivity and HTML 5
Sivakumar Thyagarajan
Oracle India

Disclaimer

The following 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.

Java EE 6 Platform
December 10, 2009

Java EE 6 – Key Statistics
40+ Million Java EE 6 Component Downloads
#1 Choice for Enterprise Developers
#1 Application Development Platform
Fastest implementation of a Java EE release

Top Ten Features in Java EE 6
1. EJB packaging in a WAR
2. Type-safe dependency injection
3. Optional deployment descriptors (web.xml, faces-config.xml)
4. JSF standardizing on Facelets
5. One class per EJB
6. Servlet and CDI extension points
7. CDI Events
8. EJBContainer API
9. Cron-based @Schedule
10. Web Profile

Java EE 7 Revised Scope
Productivity and HTML5
• Higher Productivity
– Less Boilerplate
– Richer Functionality
– More Defaults
• HTML5 Support
– WebSocket
– JSON
– HTML5 Forms

Java EE 7 – Candidate JSRs

JAX-RS Java Caching API
Portable JSP 2.2 JSF 2.2 2.0
EL 3.0 (JSR 107)
Extension

Bean Validation 1.1
s Concurrency Utilities
Servlet 3.1 (JSR 236)

Common Batch Applications
Interceptors 1.1 CDI 1.1 (JSR 352)
Annotations 1.1
Java API for JSON
Managed Beans 1.0 EJB 3.2 (JSR 353)

Connector Java API for WebSocket
JPA 2.1 JTA 1.2 JMS 2.0 (JSR 356)
1.7

New Major Updated
Release

Java API for RESTful Web Services 2.0
• Client API
• Message Filters & Entity Interceptors
• Asynchronous Processing – Server & Client
• Hypermedia Support
• Common Configuration

Client API - Before
String address = String.format("http://…/orders/%0$s/customer?shipped=%1$b",
"10", true);

URL url = new URL(address);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setDoInput(true);
conn.setDoOutput(false);

BufferedReader br = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
//. . .
}

Client API - Now
// Get instance of Client
Client client = ClientFactory.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);

Filters
@Provider
class LoggingFilter implements ContainerRequestFilter {
@Override
public void filter(ContainerRequestContext context) {
logRequest(ctx.getRequest());
// non-wrapping => returns without invoking next filter
}
}

Client-side Async
Client client = ClientFactory.newClient();
Future<String> future = client.target("http://.../atm/{card}/balance")
.pathParam("card", "1111222233334444")
.queryParam("pin", "1234")
.request("text/plain")
.async()
.get(
new InvocationCallback<String>() {
public void completed(String result) {
}

public void failed(InvocationException e) {
}
}
);

Java Message Service 2.0
Simplify the existing API
• Less verbose
• Reduce boilerplate code
• Resource injection
• Connection, Session, and other objects are AutoCloseable
• Requires Resource Adapter for Java EE containers
• Simplified API in both Java SE and EE

Sending message using JMS 1.1
@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); 13 lines of
messageProducer.send(textMessage); code just
} finally { to send a
connection.close(); message
}
} catch (JMSException ex) {
Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
}
}

Sending message using JMS 1.1 must create several
intermediate objects

Queue demoQueue;

try {
try {
TextMessage textMessage = session.createTextMessage(payload);
messageProducer.send(textMessage);
} finally {
connection.close();
}
}
}

ConnectionFactory connectionFactory; redundant and
misleading
@Resource(lookup = "java:global/jms/demoQueue") arguments
Queue demoQueue;

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


Queue demoQueue;
boilerplate
code
try {
try {
} finally {
connection.close();
}
}
}


Queue demoQueue;

try {
try {
messageProducer.send(textMessage); must close
} finally { resources
connection.close();
after use!
}
}
}


Queue demoQueue;

try {
try {
TextMessage textMessage = session.createTextMessage(payload); all methods
messageProducer.send(textMessage); throw checked
} finally { exceptions
connection.close();
}
}
}

pre-create app-
@Resource(lookup = "java:global/jms/demoQueue") server specific
Queue demoQueue; resources
try {
try {
} finally {
connection.close();
}
}
}

Simpler API to close JMS objects Create closeable
resources in a try-
@Resource(lookup = "jms/connFactory")
with-resources block
ConnectionFactory cf;
@Resource(lookup="jms/inboundQueue")
Destination dest;

public void sendMessage (String payload) throws JMSException {
try ( Connection conn = connectionFactory.createConnection();
Session session = conn.createSession();
MessageProducer producer = session.createProducer(dest);
){
Message mess = sess.createTextMessage(payload);
producer.send(mess);
} catch(JMSException e){ close() is called
// exception handling automatically
} at end of block
}

Introducing JMSContext and JMSProducer JMSContext
combines
Connection
and Session
Payload
@Resource(lookup = "java:global/jms/demoQueue") can be sent
Queue demoQueue; directly
public void sendMessage (String payload) {
try (JMSContext context = connectionFactory.createContext();){
context.createProducer().send(demoQueue, payload);
} catch (JMSRuntimeException ex) {
// exception handling
} close() is called
} automatically
No checked at end of block
exceptions
thrown

Default resource definition
Default resource definition Or
@JmsConnectionFactory
@Inject
JMSContext context;

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

context.createProducer().send(demoQueue, payload);
}
13 lines 1 line

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
– Simple, easy-to-use high-level API
– Implemented on top of Streaming API
• Binding JSON to Java objects forthcoming

Streaming API – JsonParser and JsonGenerator
• JsonParser
• Parses JSON in a streaming way from input sources
• Similar to StaX’s XMLStreamReader, a pull parser
• Created using
• Json.createParser(…)
• Json.createParserFactory().createParser(…)
• Parser state events
• START_ARRAY, END_ARRAY, START_OBJECT, END_OBJECT, ...

Streaming API – JsonParser and JsonGenerator
• JsonGenerator
• Generates JSON in a streaming way to output sources
• Similar to StaX’s XMLStreamWriter
• Created using
• Json.createGenerator(…)
• Json.createGeneratorFactory().createGenerator(…)
• Optionally, configured with features
• E.g. for pretty printing

Streaming API – JsonGenerator
JsonGenerator jg = Json.createGenerator(…);

jg.
"phoneNumber": [ .beginArray("phoneNumber")
{ .beginObject()
"type": "home", .add("type", "home")
"number": ”408-123-4567” .add("number", "408-123-4567")
}, .endObject()
{ .beginObject()
"type": ”work", .add("type", ”work")
"number": ”408-987-6543” .add("number", "408-987-6543")
} .endObject()
] .endArray();
jg.close();

Object Model API
• JsonObject/JsonArray – JSON object and array
structures
• JsonString and JsonNumber for string and number values
• JsonBuilder – Builds JsonObject and JsonArray
• JsonReader – Reads JsonObject and JsonArray from
input source
• JsonWriter – Writes JsonObject and JsonArray to output
source

DOM API – JsonReader
• Reads JsonObject and JsonArray from input source
– I/O Reader, InputStream (+ encoding)
• Optionally, configured with features
• Uses pluggable JsonParser

// Reads a JSON object
try(JsonReader reader = new JsonReader(io)) {
JsonObject obj = reader.readObject();
}

Java API for WebSocket 1.0

• Create WebSocket Client/Endpoints
• Annotation-driven (@WebSocketEndpoint)
• Interface-driven (Endpoint)
• Integration with Java EE Web container

Hello World – POJO/Annotation-driven
import javax.net.websocket.annotations.*;

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

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

WebSocket Annotations
Annotation Level Purpose

@WebSocketEndpoint class Turns a POJO into a WebSocket Endpoint

@WebSocketOpen method Intercepts WebSocket Open events

@WebSocketClose method Intercepts WebSocket Close events

@WebSocketMessage method Intercepts WebSocket Message events

method
@WebSocketPathParam parameter
Flags a matched path segment of a URI-template

@WebSocketError method Intercepts errors during a conversation


@WebSocketEndpoint Attributes
Relative URI or URI template
value e.g. “/hello” or “/chat/{subscriber-level}”

decoders list of message decoder classnames

encoders list of message encoder classnames

subprotocols list of the names of the supported subprotocols

Bean Validation 1.1
Open: Spec, Reference Implementation, TCK
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,
Custom @Customer String customer) {
//. . .
}

@Future
public Date getAppointment() {
//. . .
}

Batch Applications for the Java Platform 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

Concepts
• Job: Entire batch process
– Put together through a Job Specification Language (XML)
• Step: Independent, sequential phase of a job
– ItemReader: Retrieval of input for a step, one at a time
– ItemProcessor: Business processing of an item
– ItemWriter: Output of an item, chunks of items at a time
• JobOperator: Manage batch processing
• JobRepository: Metadata for jobs

Job Specification Language – Simple Job
<job id=“myJob”>
<step id=“init”>
<chunk reader=“R” writer=W” processor=“P” />
<next on=“initialized” to=“process”/>
<fail on=“initError”/>
</step>
<step id=“process”>
<batchlet ref=“ProcessAndEmail”/>
<end on=”success”/>
<fail on=”*” exit-status=“FAILURE”/>
</step>
</job>

Java Temporary Caching API 1.0
• API and semantics for temporary, in-memory caching of
Java objects
• SPI for implementers
• Designed to support “local” and “distributed” caching
• Caching strategies supported
By value (default)
By reference (not suitable for “distributed” caching)

• javax.cache.*
• Delivered as part of Java EE 7
• Immediately usable by Java EE 6, Spring and Guice
• Immediately usable by any Java app
• Not a Data Grid specification
• JSR 107 does not mandate a topology
• JSR 347 does: builds on JSR 107

Key Concepts
Cache Manager =>Caches
Cache => Entries
Entry => Key,Value

• CacheManager acquired via CacheManagerFactory
• CacheManagerFactory acquired via Service Provider
META-INF/services/javax.cache.spi.CachingProvider

Code Sample – Blog
public class BlogManager {
@CachePut(cacheName=”blogManager”)
public void createEntry(
@CacheKeyParam String title,
@CacheValue Blog blog) {...}

...

Code Sample – Blog
...

@CacheResult(cacheName="blogManager")
public Blog getBlogEntry(String title) {...}

@CacheResult(cacheName="blogManager")
public Blog getEntryCached(
String randomArg,
@CacheKeyParam String title) {...}

...

Annotations – Blog Sample
...

@CacheRemoveEntry(cacheName="blogManager")
public void removeBlogEntry(String title) {...}

@CacheRemoveAll(cacheName="blogManager")
public void removeAllBlogs() {...}
}

Java Persistence API 2.1
Schema Generation
Unsynchronized Persistence Contexts
Converters
Bulk update/delete using Criteria
User-defined functions using FUNCTION
Stored Procedure Query

Enterprise JavaBeans 3.2
EJBs Today
• @Singleton
• @Asynchronous
• @Schedule
• Portable JNDI Name
• EJBContainer.createEJBContainer
• EJB 3.1 Lite

Updates: Opt-out passivation of Stateful Session Beans
@Stateful(passivationCapable=false)
public class HelloBean {
private NonSerializableType ref = …;

…
}

Updates: Simplified Rules for Local/Remote Client Views
@Stateless
public class Bean implements Foo, Bar {
}
Local

@Local @Stateless
}
Remote

@Remote @Stateless
}

Updates: Simplified Rules for Local/Remote Client Views

@Remote
public interface Foo { . . . }

public interface Bar { . . . ] Remote

@Stateless
}

Servlet 3.1

Non-blocking I/O
Protocol Upgrade
Security Enhancements

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

Servlet 3.1
Non-blocking I/O: MyListener Code Sample
...
@Override
public void onAllDataRead() {
context.complete();
}

@Override
public void onError(Throwable t) {
t.printStackTrace();
context.complete();
}

Concurrency Utilities for Java EE 1.0
Goals
• Provide concurrency capabilities to Java EE application
components
• Without compromising container integrity
• Support simple (common) and advanced concurrency
patterns
• Provide consistency between Java SE and Java EE
concurrency programming model
• Extend the Concurrency Utilities API (JSR 166)

ManagedExecutorService
• Manageable version of
java.util.concurrent.ExecutorService
• Lookup using JNDI
• Java EE components create task classes
• Implement java.lang.Runnable or java.util.concurrent.Callable
• Submitted using submit or invoke methods
• Multiple (configurable) executors are permitted

Defining ManagedExecutorService using JNDI
• Recommended to bind in java:comp/env/concurrent
subcontext
<resource-env-ref>
<resource-env-ref-name>
concurrent/BatchExecutor
</resource-env-ref-name>
<resource-env-ref-type>
javax.enterprise.concurrent.ManagedExecutorService
</resource-env-ref-type>
</resource-env-ref>

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 Transaction API 1.2

• Declarative transactions outside EJB
• Based on CDI interceptors
• Adds annotation and standard values to
javax.transaction package


public @interface Transactional {
TxType value() default TxType.REQUIRED
}
public enum TxType {
REQUIRED,
REQUIRED_NEW,
MANDATORY,
SUPPORTS,
NOT_SUPPORTED,
NEVER
}


public class ShoppingCart {
...
@Transactional
public void checkOut() {...}
...
}

JavaServer Faces 2.2

HTML5 Friendly Markup Support
Pass through attributes and elements
Faces Flows
Cross Site Request Forgery Protection
Loading Facelets via ResourceHandler
File Upload Component
Multi-templating

Contexts & Dependency Injection 1.1

Embedded mode to startup outside Java EE container
Global ordering of interceptors and decorators
API for managing built-in contexts
Send Servlet events as CDI events
...

Java EE 7 – Implementation Status

4.0

http://download.java.net/glassfish/4.0/promoted/

Java EE 8 and Beyond
Standards-based cloud programming model

• Deliver cloud architecture Storage
NoSQL

• Multi tenancy for SaaS JSON-B
Multitenancy
Java EE 7
applications Concurrency
Cloud

• Incremental delivery of JSRs
PaaS
Enablement Thin Server
Architecture

• Modularity based on Jigsaw

Call to Action

• Java EE 7 Expert Group
– javaee-spec.java.net
• Java EE 7 Reference Implementation
– glassfish.org
• The Aquarium
– blogs.oracle.com/theaquarium
• Adopt-a-JSR
– glassfish.org/adoptajsr

Transparency

• Oracle’s Java EE 7 JSRs are run in the open on java.net
• http://javaee-spec.java.net
• One project per spec – e.g., jpa-spec, jax-rs-spec, jms-spec,
connector-spec …
• Publicly viewable Expert Group mail archive
• Users observer list gets copies of all Expert Group emails
• Publicly viewable download area
• Publicly viewable issue tracker
• Commitment to update to JCP 2.8 Process

Status and Schedule

• All JSRs up and running
• All Early Drafts, and several Public Drafts
• Final release target: Q2 2013

GlassFish Roadmap

GlassFish v3 GlassFish Server 3.1 GlassFish Server 3.1.2
• Java EE 6 support • Centralized administration • Bug Fixes
• Single instance • Clustering / HA
• GlassFish Server Control
• Incremental features
• GlassFish Enterprise Mgr

2009 2010 2011 2012 2013

GlassFish Server 3.0.1 GlassFish Server 3.1.1 GlassFish Server 4
• Oracle branding • Bug fixes • Java EE 7
• Oracle platform support • Multitenancy
• Oracle interoperability
• Updated components
• Incremental features • PaaS-enablement

Indic threads pune12-java ee 7 platformsimplification html5

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (6)

Semelhante a Indic threads pune12-java ee 7 platformsimplification html5

Semelhante a Indic threads pune12-java ee 7 platformsimplification html5 (20)

Mais de IndicThreads

Mais de IndicThreads (20)

Indic threads pune12-java ee 7 platformsimplification html5