Java SE 8 and Java EE 7
Overview
Peter Doschkinow
Senior Java Architect
The following is intended to outline our general product direction. It is intended
for information purposes only, and may ...
Agenda
 Java SE 8 New Features
– Language
– Libraries
– Platform and JVM
 Java EE 7 Overview
– Focus on HTML5 support
 New functionality
– JSR 308: Annotations on types
– JSR 310: Date and Time API
– JSR 335: Lambda expressions
 Updated f...
 Biggest changes to the Java language since Java SE 5
 Significant enhancements in the class libraries
 The main goals ...
 Lambda expressions provide anonymous function types to Java
– Replace use of anonymous inner classes
– Provide more func...
class Person {
String name;
int age;
String getName() { return name; }
int getAge() { return age; }
}
List<Person> list = ...
List<Person> list = ... ;
class ComparePersonsByName implements Comparator<Person> {
@Override
public int compare(Person p...
List<Person> list = ... ;
Collections.sort(list,
(p1, p2) -> p1.getName().compareTo(p2.getName())
Collections.sort(list, C...
List<Person> list = ... ;
Collections.sort(list,
(p1, p2) -> p1.getName().compareTo(p2.getName())
Collections.sort(list, C...
 Provide a mechanism to add new methods to existing interfaces
– Without breaking backwards compatability
– Gives Java mu...
 Annotations can currently only be used on type declarations
– Classes, methods, variable definitions
 Extension for pla...
 Mechanism to retrieve parameter names of methods and constructors
– At runtime via core reflection
 Improved code reada...
 Repeating annotations
Multiple annotations with the same type applied to a single program element
 No more apt tool and...
 No small task!
– Java SE 7 has 4024 standard classes
 Modernize general library APIs
 Improve performance
– Gains from...
 java.util.function package
– Function, Predicate, Consumer, Supplier interfaces
 java.util.stream package
– Stream, Col...
List<Person> persons = ...
int oldestPeter = persons.stream()
.filter(p -> p.getName() == “Peter”)
.map(p -> p.getAge())
....
List<Person> persons = ...
int oldestPeter = persons.parallelStream()
.filter(p -> p.getName() == “Peter”)
.map(p -> p.get...
 A new date, time, and calendar API for the Java SE platform
 Supports standard time concepts
– Partial, duration, perio...
 Currently developers are forced to use non-public APIs
– sun.misc.BASE64Encoder
– sun.misc.BASE64Decoder
 Java SE 8 now...
 New Modern Theme: Modena
 JavaFX 3D
 Rich Text
 New widgets: TreeTableView, DatePicker
 Public API for CSS structure...
 Optimize java.text.DecimalFormat.format
– Improve performance of common DecimalFormat usages
 Statically Linked JNI Lib...
Approximate static footprint goals
Compact Profiles
Compact1 Profile
Compact2 Profile
Compact3 Profile
Full JRE 140Mb
24Mb...
 Fix some assumptions about classloaders
 Use ServiceLoader rather than proprietary SPI code
– E.g. JAXP does not use Se...
 Improve performance, quality, and portability of method handles and
invokedynamic
 Reduce the amount of assembly code i...
 Lightweight, high-performance JavaScript engine
– Integrated into JRE
 Use existing javax.script API
 ECMAScript-262 E...
 Rarely used
– DefNew + CMS
– ParNew + SerialOld
– Incremental CMS
 Large testing effort for little return
 Will genera...
 Part of the HotSpot, JRockit convergence
 Current objects moved to Java heap or native memory
– Interned strings, class...
 Autoconf based build system
– ./configure style build setup
 Enhance javac to improve build speed
– Run on all availabl...
The Java EE Journey
Java EE 7
2005-2012
Ease of
Development
Lightweight
Developer Productivity & HTML5
1998-2004
Enterpris...
Java EE 7 Themes
 Batch
 Concurrency
 Simplified JMS
 More annotated POJOs
 Less boilerplate code
 Cohesive integrat...
Java EE 7 JSRs
 TCP based, bi-directional, full-duplex
messaging
 Originally proposed as part of HTML5
 IETF-defined Protocol: RFC 645...
 Starts with HTTP handshake
– Supports HTTP proxies, filtering, authentication and intermediaries
 Data transfer
– Text/...
 Create WebSocket Endpoints
– Annotation-driven (@ServerEndpoint)
– Interface-driven (Endpoint)
 SPI for extensions and ...
Server Side Object Model
WebSocket
@ServerEndpoint(path="/chat")
public class ChatBean {
Set<Session> peers = Collections.synchronizedSet(…);
@OnOpen
public ...
@ServerEndpoint(
value = "/websockets/{id}",
decoders = ShapeCoding.class,
encoders = ShapeCoding.class)
public class Draw...
 Standard Java API to help building of RESTful web services and clients
 Annotation driven: a DSL for HTTP
 POJO-Based ...
 Serializar and Deserializer
– MessageBodyReader, MessageBodyWriter
 Response object for complex responses
 ExceptionMa...
public class AtmService {
public String balance(String card, String pin) {
return Double.toString (getBalance(card, pin));...
@Path("/atm/{cardId}")
public class AtmService {
@GET @Path ("/balance")
public String balance(String card, String pin) {
...
@Path("/atm/{cardId}")
public class AtmService {
@GET @Path ("/balance")
@Produces("text/plain")
public String balance(@Pa...
 New features
– Client API
– Client and Server Configuration
– Asynchronous processing
– Filters and Interceptors
– Hyper...
HTML5 Architectural Implications
 HTML5 is the new UI across devices
– Applications == HTML5 + JavaScript + CSS3 + Server...
Thin Server Architecture (TSA) Diagram
JavaScript
HTML
CSS
HTML5DOMAPI
UserInterface
Browser
WebSocket
Server Push
Static
...
 Improved performance
– Caching, no presentation data transmitted again and again
 Scalability
– Less data to transfer, ...
With Java EE
Thin Server Architecture
Data Sources
HTTP/S
Web
Sockets
SSE
Clients
JAX-RS
Data Services
JMS
JPA
JAXB
POJO/E...
 Collaborative drawing
 Two-page application
– List of drawings
– Drawing
 Demonstrating
– Server-side: JAX-RS, JSON, W...
TSA - Architecture
Drawing Board Demo
HTTP/S
Web
Sockets
SSE
Clients
JAX-RS/SSE
Jersey
Data Service
GlassFish 4.0
JSON
JSO...
 JSON 1.0: Java API for JSON parsing/processing, similar to JAXP
 Concurrency Utilities for Java EE 1.0
 Java Batch API...
 Java EE 7 SDK
– With GUI installer for Windows, Linux and Mac OS X
– Web and full profile, english and multi-language
– ...
https://java.net/downloads/javaee-spec/JavaEE8_Community_Survey_Results.pdf
Java EE Next
JCACHESSEConfiguration
HTML5 ++Cl...
https://blogs.oracle.com/ldemichiel/entry/results_from_the_java_ee
Java EE 8 Survey Results
 Modular end-to-end TSA-framework for HTML5 applications
 Service complonents implemented in JavaScript
– Using a JavaSc...
Summary
 Java SE 8 adds plenty of new features
– At the language, libraries and JVM level
 Java SE continues to evolve
–...
Java SE 8 & EE 7 Launch
Java SE 8 & EE 7 Launch
Java SE 8 & EE 7 Launch
Upcoming SlideShare
Loading in...5
×

Java SE 8 & EE 7 Launch

688

Published on

Peter Doschkinow, langjähriger Java-Experte und Mitarbeiter bei Oracle, gab in seiner Präsentation einen Überblick über die interessantesten und spannendsten Neuerungen in der neusten Java Standard- und Enterprise Edition.

Published in: Technology, Education
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
688
On Slideshare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
15
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Transcript of "Java SE 8 & EE 7 Launch"

  1. 1. Java SE 8 and Java EE 7 Overview Peter Doschkinow Senior Java Architect
  2. 2. 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.
  3. 3. Agenda  Java SE 8 New Features – Language – Libraries – Platform and JVM  Java EE 7 Overview – Focus on HTML5 support
  4. 4.  New functionality – JSR 308: Annotations on types – JSR 310: Date and Time API – JSR 335: Lambda expressions  Updated functionality – JSR 114: JDBC Rowsets – JSR 160: JMX Remote API – JSR 199: Java Compiler API – JSR 173: Streaming API for XML – JSR 206: Java API for XML Processing – JSR 221: JDBC 4.0 – JSR 269: Pluggable Annotation-Processing API Component JSRs Java SE 8 (JSR 337)
  5. 5.  Biggest changes to the Java language since Java SE 5  Significant enhancements in the class libraries  The main goals of these changes are: – Better developer productivity – More reliable code – Better utilisation of multi-core and multi-processor systems  Code is no longer inherently serial or parallel Java SE 8
  6. 6.  Lambda expressions provide anonymous function types to Java – Replace use of anonymous inner classes – Provide more functional style of programming in Java Closures and Functional Programming Lambda Expressions doSomething(new DoStuff() { public boolean isGood(int value) { return value == 42; } }); doSomething(answer -> answer == 42); Simplified to:
  7. 7. class Person { String name; int age; String getName() { return name; } int getAge() { return age; } } List<Person> list = ... ; Collections.sort(list, ???); Sorting a list of objects Lambda Expressions Example
  8. 8. List<Person> list = ... ; class ComparePersonsByName implements Comparator<Person> { @Override public int compare(Person p1, Person p2) { return p1.getName().compareTo(p2.getName()); } } Collections.sort(list, new ComparePersonsByName()); Sorting a list of objects traditionally Lambda Expressions Example
  9. 9. List<Person> list = ... ; Collections.sort(list, (p1, p2) -> p1.getName().compareTo(p2.getName()) Collections.sort(list, Comparator.comparing(p -> p.getName()) Sorting a list of objects with lambdas Lambda Expressions Example
  10. 10. List<Person> list = ... ; Collections.sort(list, (p1, p2) -> p1.getName().compareTo(p2.getName()) Collections.sort(list, Comparator.comparing(p -> p.getName()) Collections.sort(list, Comparator.comparing(Person::getName) Sorting a list of objects with lambdas and method references Lambda Expressions Example
  11. 11.  Provide a mechanism to add new methods to existing interfaces – Without breaking backwards compatability – Gives Java multiple inheritance of behaviour, as well as types (but not state!) Bringing Multiple Inheritance (of Functionality) to Java Extension Methods public interface Set<T> extends Collection<T> { public int size(); ... // The rest of the existing Set methods public T reduce(Reducer<T> r) default Collections.<T>setReducer; }
  12. 12.  Annotations can currently only be used on type declarations – Classes, methods, variable definitions  Extension for places where types are used – e.g. parameters  Permits error detection by pluggable type checkers – e.g. null pointer errors, race conditions, etc Annotations On Java Types public void process(@notnull List data) {…}
  13. 13.  Mechanism to retrieve parameter names of methods and constructors – At runtime via core reflection  Improved code readability – Eliminate redundant annotations  Improve IDE capabilities – Auto-generate template code  Method and Constructor now inherit from new Executable class – getParameters() returns array of Parameter objects – Name, type, annotations for each parameter Access To Parameter Names At Runtime
  14. 14.  Repeating annotations Multiple annotations with the same type applied to a single program element  No more apt tool and associated API – Complete the transition to the JSR 269 implementation  DocTree API – Provide access to the syntactic elements of a javadoc comment  DocLint tool – Use DocTree API to identify basic errors in javadoc comments Small Things @OneToOne @JoinColumn(name=“PARTNUM”) @JoinColumn(name=“PARTREV”) public Part getPart() { return part; }
  15. 15.  No small task! – Java SE 7 has 4024 standard classes  Modernize general library APIs  Improve performance – Gains from use of invokedynamic to implement Lambdas  Demonstrate best practices for extension methods Enhance Core Libraries With Lambdas
  16. 16.  java.util.function package – Function, Predicate, Consumer, Supplier interfaces  java.util.stream package – Stream, Collector interfaces  Hidden implicit iteration  Serial and parallel implementations – Generally expressed with Lambda statements  Parallel implementation builds on Fork-Join framework  Lazy evaluation Filter, Map, Reduce for Java Bulk Data Operations For Collections
  17. 17. List<Person> persons = ... int oldestPeter = persons.stream() .filter(p -> p.getName() == “Peter”) .map(p -> p.getAge()) .max(); Java Streams API Source Stream Intermediate Stream Result Intermediate Stream filter map max  Higher abstraction view on Collections  Uses the Unix concept of fipes and filters  No storage  Functional in nature  Seeks laziness
  18. 18. List<Person> persons = ... int oldestPeter = persons.parallelStream() .filter(p -> p.getName() == “Peter”) .map(p -> p.getAge()) .max(); Java Streams API Source Stream Intermediate Stream Result Intermediate Stream filter map max  Higher abstraction view on Collections  Uses the Unix concept of fipes and filters  No storage  Functional in nature  Seeks laziness  Support parallel execution using Fork-and-Join framework
  19. 19.  A new date, time, and calendar API for the Java SE platform  Supports standard time concepts – Partial, duration, period, intervals – date, time, instant, and time-zone  Provides a limited set of calendar systems and be extensible to others  Uses relevant standards, including ISO-8601, CLDR, and BCP47  Based on an explicit time-scale with a connection to UTC Date And Time APIs
  20. 20.  Currently developers are forced to use non-public APIs – sun.misc.BASE64Encoder – sun.misc.BASE64Decoder  Java SE 8 now has a standard way – java.util.Base64.Encoder – java.util.Base64.Decoder – encode, encodeToString, decode, wrap methods Base64 Encoding and Decoding
  21. 21.  New Modern Theme: Modena  JavaFX 3D  Rich Text  New widgets: TreeTableView, DatePicker  Public API for CSS structure  WebView Enhancements  Embedded Support  Support the direct launching of JavaFX applications – Enhancement to the java command line launcher JavaFX 8 New Features
  22. 22.  Optimize java.text.DecimalFormat.format – Improve performance of common DecimalFormat usages  Statically Linked JNI Libraries – Needed for embedded applications – Currently only dynamically linked supported  Handle frequent HashMap collisions with balanced trees – Hash bucket switches from linked list to balanced tree at certain threshold to improve performance Small Things
  23. 23. Approximate static footprint goals Compact Profiles Compact1 Profile Compact2 Profile Compact3 Profile Full JRE 140Mb 24Mb 17Mb 10Mb
  24. 24.  Fix some assumptions about classloaders  Use ServiceLoader rather than proprietary SPI code – E.g. JAXP does not use ServiceLoader  JDK tool to analyse application code dependencies: jdeps  Deprecate APIs that will impede modularisation – e.g. java.util.logging.LogManager.addPropertyChangeListener Getting Ready For Jigsaw Modularisation Preparation
  25. 25.  Improve performance, quality, and portability of method handles and invokedynamic  Reduce the amount of assembly code in the JVM  Reduce native calls during method handle processing  Better reference implementation of JSR 292 (invokedynamic) Assembly language code re-written in Java Lambda-Form Representation For Method Handles
  26. 26.  Lightweight, high-performance JavaScript engine – Integrated into JRE  Use existing javax.script API  ECMAScript-262 Edition 5.1 language specification compliance  New command-line tool, jjs to run JavaScript  Internationalised error messages and documentation Nashorn JavaScript Engine
  27. 27.  Rarely used – DefNew + CMS – ParNew + SerialOld – Incremental CMS  Large testing effort for little return  Will generate deprecated option messages – Won’t disappear just yet Retire Rarely-Used GC Combinations
  28. 28.  Part of the HotSpot, JRockit convergence  Current objects moved to Java heap or native memory – Interned strings, class metadata, class static variables  Metaspace – for native allocation – Limited only by process address space – To force a limit use -XX:MaxMetaspaceSize=<size>  Class Data Sharing – Experimental feature – Available on all platforms, -Xshare:<flag> – Reduce footprint and startup by sharing JDK classes between processes Permanently Remove The Permanent Generation
  29. 29.  Autoconf based build system – ./configure style build setup  Enhance javac to improve build speed – Run on all available cores – Track package and class dependences between builds – Automatically generate header files for native methods – Clean up class and header files that are no longer needed Increased Build Speed, Simplified Setup The JDK
  30. 30. The Java EE Journey Java EE 7 2005-2012 Ease of Development Lightweight Developer Productivity & HTML5 1998-2004 Enterprise Java Platform Robustness Web Services 2013 - Future
  31. 31. Java EE 7 Themes  Batch  Concurrency  Simplified JMS  More annotated POJOs  Less boilerplate code  Cohesive integrated platform DEVELOPER PRODUCTIVITY  JAX-RS  WebSockets  JSON  Servlet NIO MEETING ENTERPRISE DEMANDS Java EE 7
  32. 32. Java EE 7 JSRs
  33. 33.  TCP based, bi-directional, full-duplex messaging  Originally proposed as part of HTML5  IETF-defined Protocol: RFC 6455 – Handshake, data transfer  W3C defined JavaScript API – Candidate Recommendation  Supported by most browser already http://caniuse.com/websockets WebSocket
  34. 34.  Starts with HTTP handshake – Supports HTTP proxies, filtering, authentication and intermediaries  Data transfer – Text/Binary frames – Ping/Pong control frames for keep-alive – Data frames don’t have HTTP overhead  No headers/cookies/security/metadata – Close frame  Full duplex and bi-directional WebSocket Protocol Summary
  35. 35.  Create WebSocket Endpoints – Annotation-driven (@ServerEndpoint) – Interface-driven (Endpoint)  SPI for extensions and data frames  Integration with Java EE Web container  Client and server APIs Java API for WebSocket Features
  36. 36. Server Side Object Model WebSocket
  37. 37. @ServerEndpoint(path="/chat") public class ChatBean { 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) { for (Session peer : peers) { peer.getRemote().sendObject(message); } } } WebSocket Chat Sample
  38. 38. @ServerEndpoint( value = "/websockets/{id}", decoders = ShapeCoding.class, encoders = ShapeCoding.class) public class DrawingWebSocket { … } public class ShapeCoding implements Decoder.Text<Drawing.Shape>, Encoder.Text<Drawing.Shape> { ... @Override public boolean willDecode(String s) { return true; } @Override public Drawing.Shape decode(String s) throws DecodeException { … } ...} Custom Encoders and Decoders
  39. 39.  Standard Java API to help building of RESTful web services and clients  Annotation driven: a DSL for HTTP  POJO-Based Resource Classes  HTTP Centric Programming Model – Maps HTTP methods to java method invocations  Entity Format Independence Java API for RESTful Web Services JAX-RS
  40. 40.  Serializar and Deserializer – MessageBodyReader, MessageBodyWriter  Response object for complex responses  ExceptionMapper for Exception-Mapping  Container Independence  Included in Java EE – for Java EE 7 also in the web profile Java API for RESTful Web Services JAX-RS
  41. 41. public class AtmService { public String balance(String card, String pin) { return Double.toString (getBalance(card, pin)); } public Money withdraw(String card,String pin, String amount){ return getMoney(card, pin, amount); } ... } Converting a POJO in a REST Resource JAX-RS Concepts in an Example
  42. 42. @Path("/atm/{cardId}") public class AtmService { @GET @Path ("/balance") public String balance(String card, String pin) { return Double.toString (getBalance(card, pin)); } @POST @Path("/withdrawal") public Money withdraw(String card, String pin, String amount){ return getMoney(card, pin, amount); } ... } Converting a POJO in a REST Resource, HTTP method binding JAX-RS Concepts in an Example
  43. 43. @Path("/atm/{cardId}") public class AtmService { @GET @Path ("/balance") @Produces("text/plain") public String balance(@PathParam ("cardId") String card, @QueryParam("pin") String pin) { return Double.toString (getBalance(card, pin)); } @POST @Path("/withdrawal") @Produces("application/json") public Money withdraw((@PathParam ("cardId") String card, @QueryParam("pin") String pin, String amount){ return getMoney(card, pin, amount); } ... } URI Parameter injection, built-in and custom serialization JAX-RS Concepts in an Example GET http://[machine]:[port]/[web-context]/atm/3711/balance?pin=1234 POST http://[machine]:[port]/[web-context]/atm/3711/withdrawal?pin=1234
  44. 44.  New features – Client API – Client and Server Configuration – Asynchronous processing – Filters and Interceptors – Hypermedia support JAX-RS 2.0
  45. 45. HTML5 Architectural Implications  HTML5 is the new UI across devices – Applications == HTML5 + JavaScript + CSS3 + Server Resources  Requires a different programming approach  Servers no longer generating markup language  Clients responsible for presentation logic and execution  JavaScript is part of the domain model, JSON is the payload  Event-Driven  No need for browser plugin The Browser Is the Platform
  46. 46. Thin Server Architecture (TSA) Diagram JavaScript HTML CSS HTML5DOMAPI UserInterface Browser WebSocket Server Push Static Resource Services Data Access RESTful Data Services DB EIS Web Storage Runtime application presentation input display App download HTTP XHR WebSocket Server-Sent-Events App Server
  47. 47.  Improved performance – Caching, no presentation data transmitted again and again  Scalability – Less data to transfer, session state is on the client  Reduced complexity – UI control is not split bethween client and server, UI events stay on client  Improved user experience  Offline support only possible with TSA Advantages Thin Server Architecture
  48. 48. With Java EE Thin Server Architecture Data Sources HTTP/S Web Sockets SSE Clients JAX-RS Data Services JMS JPA JAXB POJO/EJB Java EE Server EIS JSON XML JCA WS Endpoint
  49. 49.  Collaborative drawing  Two-page application – List of drawings – Drawing  Demonstrating – Server-side: JAX-RS, JSON, WebSocket, SSE Java API – Client-side: JAX-RS, WebSocket, SSE Java and JavaScript API – JavaFX hybrid Java/HTML5 application http://github.com/jersey/hol-sse-websocket Drawing Board Demo
  50. 50. TSA - Architecture Drawing Board Demo HTTP/S Web Sockets SSE Clients JAX-RS/SSE Jersey Data Service GlassFish 4.0 JSON JSON DataProvider POJO WS Endpoint HTML5 Browser JavaFX WebView/WebKit webSocketSend.send(...) send(...) onEvent(...) DrawingService.query(...)
  51. 51.  JSON 1.0: Java API for JSON parsing/processing, similar to JAXP  Concurrency Utilities for Java EE 1.0  Java Batch API 1.0  JPA 2.1: Schema generation props, entity graphs and converters, …  Servlet 3.1: Non-blocking IO, Upgrade to WebSocket, …  JTA 1.2: Transactional CDI interceptors, …  CDI 1.1: Ordering of interceptors, Servlet events, …  EJB 3.2: Optional CMP/BMP, Ease-of-use, …  JSF 2.2: @FlowScoped, HTML5 data-* attributes, …  Bean Validation 1.1: method constraints, injectable artifacts, ... Many other Improvements
  52. 52.  Java EE 7 SDK – With GUI installer for Windows, Linux and Mac OS X – Web and full profile, english and multi-language – API docs, tutorial and samples  GlassFish 4.0 OSE with GUI installer or as Zip  Java EE 7 RI binaries and sources for the web and full profile  Maven dependencies and javadocs – javaee-api-7.0.jar, javaee-web-api-7.0.jar, javaee-api-7.0-javadoc.jar http://www.oracle.com/technetwork/java/javaee/downloads/index.html Java EE 7 Implementation Deliverables
  53. 53. https://java.net/downloads/javaee-spec/JavaEE8_Community_Survey_Results.pdf Java EE Next JCACHESSEConfiguration HTML5 ++Cloud / PaaS JSON Binding Java EE 8 and Beyond NoSQL
  54. 54. https://blogs.oracle.com/ldemichiel/entry/results_from_the_java_ee Java EE 8 Survey Results
  55. 55.  Modular end-to-end TSA-framework for HTML5 applications  Service complonents implemented in JavaScript – Using a JavaScript runtime based on Nashorn, NodeJS compatible  View components implemented in JavaScript – Using HTML5 + Widgets + Data Binding with EL – Minimal JavaScript code needed avatar.java.net Project Avatar
  56. 56. Summary  Java SE 8 adds plenty of new features – At the language, libraries and JVM level  Java SE continues to evolve – www.jcp.org – openjdk.java.net/jeps  Java EE continues to evolve – Java EE 7 is the most exciting of Java EE ever – GlassFish distributions for Java EE continue to be regularly updated with major releases of the Java EE specification – Work on Java EE 8 started
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×