Presentation that was done on Technical University in Olomouc (Apr-2008)

1. JavaEE Tour
Petr Blaha
Sun Microsystems, Inc
1

2. Agenda
• Java World introduction
• JavaEE (Why to use this technology, APIs)
• Dive in Enterprise Java Beans
• Demo
• Q&A
2

3. Java
• First implementation released in 1995 (1.1)
• Java compiled to bytecode -> JVM
• Basic Philosophy
> Object-oriented
> Platform independent
> Automatic memory management
• Current version 6
3

4. The Java™ Platform
multiple configurations built for different types
Java Technology Java Technology Workgroup High-End
Enabled Devices Enabled Desktop Server Server
4

5. The Java TM
Platform
Java 2 Platform Micro Edition
(JavaMETM)
Optional
Packages
Optional
Packages
Personal Personal
Java 2 Java 2 Basis Profile Profile
Enterprise Standard
Edition Edition Foundation Profile MIDP
(JavaEE) (JavaSE) Java
CDC CLDC Card
APIs
JVM KVM CardVM
* Under development in JCP
5

6. What Is the JavaEE?
 Open and standard based platform for
 developing, deploying and managing
 n-tier, Web-enabled, server-centric, and
component-based enterprise applications
6

7. Evolution of Enterprise Application
Development Frameworks
7

8. Single Tier (Mainframe-based)
• Dumb terminals are directly connected to mainframe
• Centralized model (as opposed distributed model)
• Presentation, business logic, and data access are
intertwined in one monolithic mainframe application
8

9. Single-Tier: Pros & Cons
• Pros:
> No client side management is required
> Data consistency is easy to achieve
• Cons:
> Functionality (presentation, data model, business
logic) intertwined, difficult for updates and
maintenance and code reuse
9

10. Two-Tier
SQL
request
Database
SQL
response
• Fat clients talking to back end
database
> SQL queries sent, raw data returned
• Presentation,Business logic and Data
Model processing logic in client
application
10

11. Two-Tier
• Pro:
> DB product independence (compared to single-tier model)
• Cons:
> Presentation, data model, business logic are intertwined (at
client side), difficult for updates and maintenance
> Data Model is “tightly coupled” to every client: If DB Schema
changes, all clients break
> Updates have to be deployed to all clients making System
maintenance nightmare
> DB connection for every client, thus difficult to scale
> Raw data transferred to client for processing causes high
network traffic
11

12. Three-Tier (RPC based)
SQL
RPC request request
Database
RPC response SQL
response
• Thinner client: business & data model separated from
presentation
> Business logic and data access logic reside in middle tier server
while client handles presentation
• Middle tier server is now required to handle system services
> Concurrency control, threading, transaction, security, persistence,
multiplexing, performance, etc.
12

13. Three-tier (RPC based): Pros & Cons
• Pro:
> Business logic can change more flexibly than 2-tier
model
> Most business logic reside in the middle-tier server
• Cons:
> Complexity is introduced in the middle-tier server
> Client and middle-tier server is more tightly-
coupled (than the three-tier object based model)
> Code is not really reusable (compared to object
model based)
13

14. Three-Tier (Web Server)
SQL
HTML request WEB request
Server Database
HTML response SQL
response
• Browser handles presentation logic
• Browser talks Web server via HTTP protocol
• Business logic and data model are handled by “dynamic
contents generation” technologies
14

15. Three-tier (Web Server based):
Pros & Cons
• Pro:
> Ubiquitous client types
> Zero client management
> Support various client devices
> J2ME-enabled cell-phones
• Cons:
> Complexity in the middle-tier still need to be
addressed
15

16. Trends
• Moving from single-tier or two-tier to multi-
tier architecture
• Moving from monolithic model to object-
based application model
• Moving from application-based client to
HTML-based client
16

17. Outstanding Issues & Solution
• Complexity at the middle tier server still remains
• Duplicate system services still need to be provided for the
majority of enterprise applications
> Concurrency control, Transactions
> Load-balancing, Security
> Resource management, Connection pooling
• How to solve this problem?
> Commonly shared container that handles the above system
services
> Proprietary versus Open-standard based
17

18. Proprietary Solution
• Use "component and container" model
> Components captures business logic
> Container provides system services
• The contract between components and container
is defined in a well-defined but with proprietary
manner
• Problem of proprietary solution: Vendor lock-in
• Example: Tuxedo, .NET
18

19. Open and Standard Solution
J2EE
• Use "component and container" model in which
container provides system services in a well-
defined and as industry standard
• JavaEE is that standard that also provides
portability of code because it is based on Java
technology and standard-based Java programming
APIs
19

20. J2EE is End-to-End Solution
Firewall
J2EE
Application
Client Server
Enterprise
Enterprise Information
JavaBeans™
Client Systems (EIS):
Client Relational
Database,
Web Enterprise Legacy
Client Server JavaBeans Applications,
JSP,
ERP Systems
Servlets
Client
HTML/XML
Other Services:
JNDI, JMS, Enterprise
Client Middle JavaMail™ Information
Tier Tier Tier
20

21. J2EE Application DEMO
21

22. J2EE 1.4 APIs and Technologies
• J2SE 1.4 • Servlet 2.4
• JAX-RPC • JSP 2.0
• Web Service for J2EE • EJB 2.1
• J2EE Management • JAXR
• J2EE Deployment • Connector 1.5
• JMX 1.1 • JACC
• JMS 1.1 • JAXP 1.2
• JTA 1.0 • JavaMail 1.3
• JAF 1.0
22

23. The J2EE Challenge
TM
• J2EE is enormously powerful
> The industry standard for robust enterprise apps
• But that power sometimes gets in the way
> Too difficult to get started
> Even simple apps need boring boilerplate
• Can we keep the power, but make typical
development tasks simpler?
• YES: and that is the focus of Java EE 5!
23

24. EoD Improvements in Java EE 5 TM
• POJO-based programming
> More freedom, fewer requirements
• Extensive use of annotations
> Reduced need for deployment descriptors
• Resource Injection
> Inversion of control
• New APIs and frameworks
24

25. Annotations in Java EE 5 TM
• Making extensive use of annotations
> For defining and using web services
> To map Java classes to XML
> To greatly simplify EJB development
> To map Java classes to databases
> To specify external dependencies
> To reduce need for deployment descriptors
25

26. Java EE 5 Major Features
TM
• Simplified web services support
• More web service standards support
• Greatly simplified EJBTM development
• New persistence API
• Easy web applications with JavaServerTM Faces
26

27. Java EE 5 Platform
• JSR 220 (EJB 3.0)
• JSR 224 (JAX-WS 2.0)
• JSR 222 (JAXB 2.0)
• JSR 252 (JavaServer Faces 1.2)
• JSR 52 (JSTL 1.1)
• JSR 181 (WS Annotations)
• JSR 245 (JSP 2.1)
27

28. EJB (Enterprise Java Beans)
28

29. What is EJB Technology?
• A server-side component technology
• Easy development and deployment of Java
technology-based application that are:
> Transactional, distributed, multi-tier, portable,
scalable, secure, …
29

30. Why EJB Technology?
• Leverages the benefits of component-model on the
server side
• Separates business logic from system code
> Container provides system services
• Provides framework for portable components
> Over different J2EE-compliant servers
> Over different operational environments
• Enables deployment-time configuration
> Deployment descriptor
30

31. EJB Architecture
31

32. Enterprise JavaBeans
Enterprise JavaBeans
Synchronous communication Asynchronous communication
Session Bean Entity Bean Message-Driven Bean
Stateless Stateful
32

33. EJB 2.1 Example
// EJB 2.1
public class PayrollBean
implements javax.ejb.SessionBean {
SessionContext ctx;
DataSource empDB;
public void setSessionContext(SessionContext ctx) {
this.ctx = ctx;
}
public void ejbCreate() {
Context initialContext = new InitialContext();
empDB = (DataSource)initialContext.lookup(
“java:comp/env/jdbc/empDB”);
}
33

34. EJB 2.1 Example
// EJB 2.1 (cont.)
public void ejbActivate() {}
public void ejbPassivate() {}
public void ejbRemove() {}
public void setBenefitsDeduction (int empId, double
deduction) {
...
Connection conn = empDB.getConnection();
...
}
...
}
// NOTE deployment descriptor needed
34

35. EJB 2.1 Example
<session>
<ejb-name>PayrollBean</ejb-name>
<local-home>PayrollHome</local-home>
<local>Payroll</local>
<ejb-class>com.example.PayrollBean</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
<resource-ref>
<res-ref-name>jdbc/empDB</res-ref-name>
<res-ref-type>javax.sql.DataSource</res-ref-type>
<res-auth>Container</res-auth>
</resource-ref>
</session>
...
<assembly-descriptor>
...
</assembly-descriptor>
35

36. Bean Classes
• In EJB 3.0, session beans, message-driven beans
are ordinary Java classes
> Container interface requirements removed
> Bean type specified by annotation or XML
• Annotations
> @Stateless, @Stateful, @MessageDriven
> Specified on bean class
36

37. EJB 3.0 Example
// Same example, EJB 3.0
@Stateless public class PayrollBean
implements Payroll {
@Resource DataSource empDB;
public void setBenefitsDeduction (int empId, double
deduction) {
...
Connection conn = empDB.getConnection();
...
}
...
}
37

38. Dependency Injection
• Annotations
> @EJB
> References to EJB business interfaces
> References to Home interfaces (when accessing
EJB 2.1 components)
> @Resource
> Almost everything else
> Number of annotations is simplified from EJB 3
specification early draft
• Injection can also be specified using deployment
descriptor elements
38

39. EJB 3.0 Client Example
// EJB 3.0 client view
@EJB ShoppingCart myCart;
...
Collection widgets = myCart.startToShop(“widgets”);
...
39

40. EJB 3.0 & Persistence
40

41. Persistence Model in EJB 3.0
• Entities are simple Java classes
> Concrete classes—support use of new
> Getter/setter “property” methods or persistent
instance variables
> No required bean interfaces
> No required callback interfaces
• Usable as “detached” objects in other application
tiers
> No more need for DTOs
• Single API in JavaEE, Java SE
41

42. EntityManager
• EntityManager serves as untyped “home”
for entity operations
> Methods for lifecycle operations
> Persist, remove, merge, flush, refresh, etc.
> Similar in functionality to Hibernate Session,
JDO PersistenceManager, etc.
> Manages persistence context
> Both transaction-scoped and extended persistence contexts
42

43. Persistence Focus: O/R Mapping
• Ease-of-use facility for Java developers mapping
domain object model to a relational database
• Developer is aware of mapping between
DB schema and domain object model
> Developer is in control of mapping
> Developer can rely on mapping and its semantics
• Mappings may be expressed using metadata
annotations or XML
> Default mappings provided
43

44. JPA – Entity Class
import javax.persistence.*;
@Entity
public class Person {
@Id private String name;
private int visits;
public Person() { }
public Person(String name) {
this.name = name;
}
public int incrementVisit() {
return visits++;
}
}
44

45. Persistence Entity Example (Contd.)
...
// Relationship between Customer and Orders
@OneToMany
public Collection<Order> getOrders() {
return orders;
}
public void setOrders(Collection<Order> orders) {
this.orders = orders;
}
45

46. Persist Operation
public Order createNewOrder(Customer customer) {
// Create new object instance – transient state
Order order = new Order(customer);
// Transitions new instances to managed. On the
// next flush or commit, the newly persisted
// instances will be inserted into the database table.
entityManager.persist(order);
return order;
46

47. Find and Remove Operations
public void removeOrder(Long orderId) {
Order order =
entityManager.find(Order.class, orderId);
// The instances will be deleted from the table
// on the next flush or commit. Accessing a
// removed entity has undefined results.
entityManager.remove(order);
}
47

48. Persistence DEMO
48

49. JavaEE Tour
Petr Blaha
Sun Microsystems, Inc
49