Wednesday Mar 30, 2016

Last Interactive Online Java Webinar with Q&A

The Virtual Technology Summit (VTS) delivers interactive Java technical content from Java Champions and Oracle experts to your desk.  

The interactive, online event, is sponsored by the Oracle Technology Network (OTN). The April 5 event is the last one in this VTS series. It features six Java technical sessions about Java EE, cloud, and Java SE API. Register now

The Java Track includes three code-heavy sessions:

Java on Mobile: Thanks to innovations in mobile JVM's and the availability of JavaFX on iOS and Android, it is now possible to write applications once (in Java) and deploy them on the major mobile platforms. In this session, we will show how easy it is to create a highly-polished Material Design Java application, and to deploy it on an Android device and an iOS device with exactly the same code used in both deployments.

Asynchronous programming in Java 8: how to use CompletableFuture: This presentation aims to explain how the patterns introduced by this interface and its implementing class are new to the Java platform, and how they fill the gap in the old Future patterns.The different models are precisely presented: how to create complex asynchronous processing pipelines, how to deal with exceptions, how to test complex code. 

Down-to-Earth Microservices with Java EE: the session explores microservices using a simple but representative example using Java EE. You'll see how the Java EE programming model and APIs like JAX-RS, WebSocket, JSON-P, Bean Validation, CDI, JPA, EJB 3, JMS 2 and JTA aligns with the concept of microservices.

Java SE 8 for Java EE Developers: Java SE 8 brings a bounty of improvements. In this session, you will learn about Lambda expressions, a new Date and Time API, the Streams API, Completable Futures, Nashorn, Repeatable Annotations, String joiners, etc.

Thinking Beyond ORM in JPA:  This session discusses native-query support in JPA along with stored procedures and result set mappings in JPA 2.1. The presented code samples illustrate the details of the API, highlighting their strengths and weaknesses. Our analysis reveals applicable use cases and most popular approaches. The summary provides guidelines on how and when to utilize native queries.

Visualizing Data in the Cloud with Oracle JET: Oracle JET is a free and open source toolkit, providing a solid basis for enterprise JavaScript applications, including built-in solutions for accessibility, modularity, and data visualization. In this code-driven session, you will learn everything you need to know to create maintainable enterprise applications in JavaScript!

Tuesday Feb 16, 2016

Down to Earth Microservices and Java EE!

Not sure whether microservices make sense for your project? Will a microservices architecture improve the performance and scalability of your project? In the Down to Earth Microservices with Java EE session, Reza Rahman looks beyond the buzz and gives you a concrete approach to microservices that will help you think about how to implement them.   

Reza will explain the ins-and-outs of microservices within the well-established context of SOA and takes a close look at when it makes sense to implement them. He will walk you through an example showing how to use the lightweight Java EE programming model with Java EE. The Java EE programming model and APIs are aligned with microservices. You’ll learn how APIs such as JAX-RS, WebSocket, JSON-P, Bean Validation, CDI, JPA, EJB 3, JMS 2, and JTA can help you build microservices. The microservices architecture style fits well within the Java EE framework and taps into Java knowledge that you currently have.  

This presentation is part of the next Virtual Technology Summit sponsored by the Oracle Technology Network. Register, it's free! For your convenience, we offer the event in three time zones as follows: 
  • Americas - March 8th- 9:30am to 1:00 PST - Register
  • APAC - March 15th - 9:30am to 1:00pm IST - Register
  • EMEA - April 5th - 9:30am to 1:00pm BST - Register
This VTS provides two tracks on Java SE and Java EE with six hands-on sessions. Check out the full VTS agenda here

Friday Mar 30, 2012

Spring to Java EE, Part Three - new tech article on otn/java

In a new article up on otn/java, Java EE expert David Heffelfinger continues his series exploring the relative strengths and weaknesses of Java EE and Spring. Here, he demonstrates how easy it is to develop the data layer of an application using Java EE, JPA, and the NetBeans IDE instead of the Spring Framework.

In the first two parts of the series, he generated a complete Java EE application by using JavaServer Faces (JSF) 2.0, Enterprise JavaBeans (EJB) 3.1, and Java Persistence API (JPA) 2.0 from Spring’s Pet Clinic MySQL schema, thus showing how easy it is to develop an application whose functionality equaled that of the Spring sample application.

In his new article, Heffelfinger tweaks the application to make it more user friendly.

From the article:
“The generated application displays primary keys on some of the pages, and these keys are surrogate primary keys—meaning that they have no business value and are used strictly as a unique identifier—so there is no reason why they should be visible to the user. In addition, we will modify some of the generated labels to make them more user-friendly.”

He concludes the article with a summary:
“The Java EE version of the application is not a straight port of the Spring version. For example, the Java EE version enables us to create, update, and delete veterinarians as well as veterinary specialties, whereas the Spring version of the application enables us only to view veterinarians and specialties. Additionally, the Spring version has a single page for managing/viewing owners, pets, and visits, whereas the Java EE version of the application has separate pages for each of these entities.
The other thing we should keep in mind is that we didn’t actually write a lot of the code and markup for the Java EE version of the application, because the bulk of it was generated by the NetBeans wizard.”

Have a look at the complete article here.

Tuesday Mar 13, 2012

Key to the Java EE 6 Platform: NetBeans IDE 7.1

Oracle’s Geertjan Wielenga has a new article up on otn/java, titled “Key to the Java EE 6 Platform: NetBeans IDE 7.1,” in which he shows how the NetBeans IDE provides the tools, templates, and code generators to support Java EE 6 and its main specifications.

He initially observes that, “When you begin to grasp the breadth and ambition of the Java EE 6 Platform, which covers everything from the model (JPA and Bean Validation), to the controller (EJB and Servlets), to the view (JavaServer Faces), a simple entry point is difficult to find. Enter NetBeans IDE 7.1, which is Oracle’s IDE for the Java Platform, created by the same group of developers who created the Java EE 6 Platform. Here you find tools, templates, and code generators intended to be used in combination with the set of specifications that the Java EE 6 Platform encompasses.”

After offering a tour of the NetBeans IDE 7.1 tools that support Java EE 6, Wielenga ends on a cautionary note:

“While code generators and tools such as those described here are great to help you get your feet wet, a danger is that a lot of code is generated that you don't understand and that you therefore do not know how to debug and maintain. The good news is that far less code needs to be generated in Java EE 6 than before, making it far easier to understand and maintain.

Nevertheless, it is advisable to use tools of this kind intelligently. Start small, focusing on specific APIs. Get to know them via the generated code and then slowly extend the application as you become more familiar with the Java EE 6 Platform. Once you are comfortable with the spec, the tools aim to help you become more productive: combining the leanness of the Java EE 6 Platform with the tools in the IDE, you'll be rapidly creating the core of your application.”

Check out the article.


Friday Dec 16, 2011

Spring to Java EE Migration, Part 2 (technical article)

In part two of a four-part article series on otn/java, “Spring to Java EE Migration, Part 2,” CTO and Java EE expert David Heffelfinger elaborates further on how easy it is to develop the data layer of an application using Java EE, JPA, and the NetBeans IDE instead of the Spring Framework.

Part 1 began with a Java EE rewrite of Spring's Pet Clinic sample application and developed the persistence layer of the application using Java Persistence API (JPA) 2.0, using NetBeans to generate most of the persistence layer from an existing database schema. Heffelfinger analyzed the generated code, which employed advanced JPA features.

In part 2, he continues this process by developing Enterprise JavaBeans (EJB) 3.1 session beans that act as Data Access Objects (DAOs), as well as JavaServer Faces (JSF) 2.0 managed beans and pages. Readers get to see the generated code in action and are given a look under the hood to see what’s going on.

Heffelfinger concludes Part 2 with a look ahead to Part 3:

“In the next installment of this series, we will modify the generated code to make it a bit more user friendly and we will compare the Java EE and Spring versions of the Pet Clinic application.”

Read the complete article here.

Wednesday Nov 02, 2011

Spring to Java EE Migration

In a new article up on otn/java, the first of a series, titled “Spring to Java EE Migration, Part 1,” CTO and Java EE expert David Heffelfinger demonstrates how easy it is to develop the data layer of an application using Java EE, JPA, and the NetBeans IDE instead of the Spring Framework.

Heffelfinger observes that, “Every time I work on a Spring project, I start mumbling under my breath. I know I will have to go through long and convoluted XML files to determine what is going on with the project. I also know that my project will have approximately 10,000 dependencies and that the generated WAR file is going to be a monster.”

He contrasts this with Java EE, where most of the needed services are required by the application server, reducing the number of required dependencies, and typically Java EE provides configuration by exception, meaning there is little configuration necessary. When configuration is needed, it is usually done through annotations, which allows the developers to get the whole picture from the source code. Also, with Java EE, the advanced tooling from NetBeans is available.

Again, from the article itself:

“In this series of articles, we will rewrite the sample Pet Clinic application provided with Spring using Java EE. In this first article, I illustrate how we can quickly develop an application that has equivalent functionality to the Spring version by taking advantage of the excellent Java EE tooling provided by NetBeans. The Java EE version employs JavaServer Faces (JSF) for the user interface, Data Access Objects (DAOs) are implemented using Enterprise JavaBeans (EJB) 3.1 session beans, and data access is provided by Java Persistence API (JPA) 2.0.”

Read the article in full here.
About

Insider News from the Java Team at Oracle!

duke
Links


Search

Archives
« May 2016
SunMonTueWedThuFriSat
1
2
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
    
       
Today