java EE - Taner ERKAN

Kaster Nurmukan

AGENDA About Me About Java Why J2ee Coming to world ? J2ee vs .Net & Open source framework J2ee Architecture What is the usfull ?

ABOUT ME

Intraduction h_hans51@sdu.edu.kz Office: EN-block, 4th floor , . 10 years software Engineer (Before). Java/J2ee, C# , php , UML , JAVASCRIPT,VB etc ERP , Software Outsoursing , Campus Management system . Bank's Financial System development . China ,TianJin, Beijing ,ShenZhen

JAVA LANGUE FEATURE JVM(JAVA Virtual Machine ) Platform independent “Write Once Run Everywhere ” features Microsoft learned form Java Developed .Net and CLR(common

Language Runtime) Pure OOP Language Widely used by in business and accepted by developer

Free Runtime(JVM is free) free Development kit a lot of free java tools support Widely usage area

WHAT CAN DO WITH JAVA JavaSE JavaME JavaEE JavaFX JavaCard

WHY J2EE COMING TO WORLD History of the Programing Langues & tools C/S Desktop Appliction , Hard to maintain B/S Web Application

CGI less performance , bottleneck Scripting Language : php ,Asp

People Challenging the productivity of the tools and Method

Design Architecture : multi Layer , Most popular is MVC Possible to improve the performance in separate layer

DB layer , connection Pool , some resource Cluster : web application , business application Server

OPEN SOURCE PROJECT IN JAVA MVC framework in Java struts, Spring: J2ee open source framework Hibernate: OR-Map Framework Junit : Open Source Testing Tools in Java : Log4J :Open Source Logging Tools JFreeChart: Open Source Charting & Reporting Tools in

Java Eclipse: Open Source IDEs in Java

J2EE It is standard : API Standard jdbc , RMI , Email ,JMS ,

webservice API , Also include component standard : serverlet , EJB,

Connector , JSP (java service page ) , webservice

J2EE ARCHINECTURE

ALL PUT THOGETHER UNDERSTANDING THE JAVA TECHNICAL MARKET IN THE WORLD

ADEVANTAGE For big project ( at last more then 10 people/Month) , Performance(because Architecture multi tier layer, every layer memory

can be cache , can be separate to deferent platform , example : web application server , EJB Container ,

Database connection pool and database , can separate rule let the specialist easy to involve,

REFERENCE

http://www.georgehernandez.com/h/xComputers/Programming/Languages.asp

http://www.oracle.com http://www.fullstackdevelopment.com

Topic : Servlet & JSP Kaster Nurmukan

J2EE It is standard : API Standard jdbc , RMI , Email ,JMS ,

webservice API , Also include component standard : serverlet , EJB,

Connector , JSP (java service page ) , webservice

J2EE ARCHINECTURE

SERVELET Java Servlets/JSP are part of the Sun’s J2EE Enterprise

Architecture The web development part Request controller , Filter , Adeppter Javax.Servelt

Process or store data that was submitted from an HTML form

Provide dynamic content such as the results of a database query

Manage state information Latest Servlet Spec is 3.0 (JSR 315 )

JSP Java Server Pages (JSP)

A simplified, fast way to create dynamic web content HTML or XML pages with embedded Java Code or Java Beans Can be a mix of template data in HTML/XML with some

dynamic content A JSP is a complied to a Java Servlet automatically by the

Servlet container, it is then cached Latest JSP Spec is 2.2 (JSR 245)

LIFE CYCLE OF SERVLET

init(ServletConfig); service(ServletRequest, ServletResponse);

destroy();

servlet

GenericServlet HttpServlet

doGet(HttpServletRequest, HttpServletResponse);

doPost(HttpServletRequest, HttpServletResponse); …….

EXAMPLE OF SERVLET package kz.edu; import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class Servlet extends HttpServlet { public init(ServletConfig) throws IOException, ServletException { //...... To do } public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException { res.setContentType("text/html"); PrintWriter out = res.getWriter(); out.println("<html><head><title>Sample Servlet"); out.println("</title></head><body>"); out.println("<h1>Hello World at " + req.getRequestURI() + " !</h1>"); out.println(”<p>Key is " + req.getParameter("KEY")); out.println(”</p></body></html>"); } }

USING SERVLET A catalog of servlet methods:

init(config) service(req, res)

doGet(req, res) doPut(req, res) doDelete(req, res) Destry()…

A catalog of request methods: getParameter(name) getParameterNames(), getParameterValues(name) getCookies()

A catalog of response methods: sendRedirect(url), sendError(errCode, errStr) setContentType(mimeType) addCookie(cookieObj)

J2EE WEB APPLICATION COMPONENTS Java Servlets

Extend off of HttpServlet

JSP pages, normally for Presentation Java Beans

Normally used as value objects, pass to data to JSPs

Tag Libraries – XML based JSP elements Web Deployment Descriptor

/web-inf/web.xml

May 13th, 2003

WEB DEPLOYMENT DESCRIPTOR /web-inf/web.xml

Part of the standard Defines servlets used in the web application Maps servlets to URLs A servlet can map to many URLs

Defines resources available to the web app Defines security constraints Defines other stuff like

Welcome file list Session timeout Error page mapping

May 13th, 2003

J2EE WEB DIRECTORY STRUCTURE 1 Top Directory is normally the context Path

/tomcat/webapps/testServlet Normally, the URL would be http://localhost:8080/testServlet Contains JSP and other static content plus the web-inf directory

/web-inf directory This is a protected directory, can not point browser to any file in this

directory /classes – unpacked web application classes, auto-magically

added to CLASS_PATH /lib – web application JAR files /taglib – tag library descriptor files

May 13th, 2003

J2EE WEB DIRECTORY /web-inf/web.xml /web-inf/*

Would normally put any static or JSP files here Protects them from Direct Invocation Always best to call a JSP through a servlet first

May 13th, 2003

JSP CONSTRUCTS Used in JSP pages, pages that end *.jsp Comment <%-- Comment --%> Declaration <%! int x = 0; %> Expression <%= expression %>

Outputs to the Response stream Like a “printf” to the browser Do NOT use semi-colon to terminate the line

Scriplets - contains Java Code <% code fragments %>

May 13th, 2003

JSP CONSTRUCTS

<% if (value.getName().length != 0) { %> <H2>The value is: <%= value.getName() %></H2> <% } else { %> <H2>Value is empty</H2> <% } %>

Implicit objects always available in the JSP Page “request” – Browser’s Request Object

Use to get HTTP headers, length etc.. “response” - HttpResponse Object

May 13th, 2003

JSP CONSTRUCTS “session” – internal HttpSession Object “pageContext” “application” “out”, same as <%= %> “config” – servlet configuration “page” “exception”

JSP Directives Are messages or instructions to the JSP container

May 13th, 2003

JSP CONSTRUCTS Do not produce any output “page” directive

<%@ page import=“com.lucek.*” %> Commonly used for importing class paths

“include” directive <%@ include file=“header.htm” %> Good for including static content

“taglib” – lists the tag library descriptor location Required when using tab libraries

May 13th, 2003

JAVA BEANS AS USED IN WEB APPS Normally used for all data transfers and business

components Similar to how Java Beans are used in Swing and AWT

But do not need the full implementation

Must have no constructor or no-arg constructor Must have setter and getter methods for each property

value JSP constructs/tags use Java Beans

May 13th, 2003

JSP ACTIONS JSP actions are special tags that affect the output stream

and are normally used with Java beans Most commonly used:

<jsp:useBean>, <jsp:getProperty>, <jsp:setProperty> The code below will display the lastName property of the student bean

on the output stream <jsp:useBean id="student" scope="request"

class="com.lucek.dto.StudentValue" /> <jsp:getProperty name="student" property="lastName" />

May 13th, 2003

SERVLET CONTAINER/ENGINE Servlets/JSP require a Container Apache Tomcat is the reference implementation of the

Servlet/JSP Specs It is open source, small, install quickly,and is FREE Web Site: jakarta.apache.org/tomcat It include a simple HTTP 1.1 server, good enough for

development and small intranets. Other Servlet Engine

GlassFish IBM WebSphere Application Server Jetty (web server)

May 13th, 2003

TOMCAT INSTALL Requires a JDK, get lates verstion and install into c:\jdk or

$HOME/jdk Add JAVA_HOME to your environment and the “bin”

directory to your PATH Good practice to unpack into c:\tomcat or $HOME/tomcat Add CATALINA_HOME to your environment and the “bin”

directory to your PATH

May 13th, 2003

TOMCAT DIRECTORY STRUCTURE Everything is relative to $CATALINA_HOME /bin – Startup/shutdown scripts /conf

Server.xml – main configuration file /common – common class and jar files used by Tomcat

and web applications Put JDBC drivers here

/server – class and jar files used by Tomcat internally /shared – class and jar files for all web applications /webapps – This is where you put your web application in

a sub-directory or external context file.

May 13th, 2003

STARTING TOMCAT /bin/startup.bat or startup.sh Point Browers to http://localhost:8080, should see default

page All the Docs are there on the default page! Check out the examples pages, good tutorials

May 13th, 2003

OTHER DEVELOPMENT TOOLS 1 Ant Build Tool

Standard Java Build tool Basic on UNIX make, but much better download: http://ant.apache.org

Java IDE Try NetBeans, it is nice Tomcat is built in, but is an older version Includes full Servlet and JSP debugging download: www.netbeans.org

May 13th, 2003

OTHER DEVELOPMENT TOOLS 2 Junit

Standard Automated Unit Testing Tool Site: http://junit.sourceforge.net

Jedit Slick Programmer’s Editor Written in Java Site: jedit.org

May 13th, 2003

BEST PRACTICES/PATTERNS Always Separate out the logic from the presentation

Use servlets for the logic/controller and JSP’s for presentation Ideally should never have Java Code in the JSP page

Have a clean separation between your data access and controller layers (DAO)

Always use DTO or value object Use a Model-View-Controller Architecture

Do not write it, use Struts Site: jakarta.apache.org/struts/

Use Unit tests Junit Automation via Ant build tasks

May 13th, 2003

WHAT WE HAVE NOT TALKED ABOUT All the specific Servlet APIs Tag libraries Sessions, cookies JDBC service support from the container Container based authentication Lots of other stuff

May 13th, 2003

NEXT PRESENTATION? Create a data driven web site using MySql and

Servlets/JSP Setup Authentication Realm with declarative security Setup JDBC connection pooling Struts?

May 13th, 2003

REFERENCE http://www.oracle.com

Topic : JSF Kaster Nurmukan

AGENDA Overview of JSF Why JSF? JSF Features often case in web app JSF Life Cycle JSP vs Struts Vs JavaServer Faces

JAVASERVER FACES (JSF) is a “server side user interface component framework for Java™

technology-based web applications” is a specification and reference implementation for a web

application development framework Components Events Validators Back-end-data integration

is designed to be leveraged by tools NetBeans, RAD (Rational Application Developer), Eclipse,

JDeveloper, etc.

WHY JSF? MVC for web applications Easy to use Extensible Component and Rendering architecture Support for client device independence Standard Huge vendor and industry support Built-in UI component model (unlike JSP and Servlet)

JAVASERVER FACES – FEATURES

Page navigation specification

Standard user interface components like input fields, buttons, and links etc

Type conversion

User input validation

Easy error handling

Java bean management

Event handling

Internationalization support

PAGE NAVIGATION SPECIFICATION

JSF offers page navigation through page navigation rules in the Application Configuration file(faces-config.xml)

Page Navigation can be

Simple Page Navigation

Conditional Page Navigation

Simple page navigation <navigation-rule>

<from-tree-id>/page1.jsp</from-tree-id> <navigation-case> <to-tree-id>/page2.jsp</to-tree-id> </navigation-case> </navigation-rule>

Conditional Page Navigation <navigation-rule>

<from-tree-id>/login.jsp</from-tree-id> <navigation-case> <from-outcome>success</from-outcome> <to-tree-id>/welcome.jsp</to-tree-id>

</navigation-case> </navigation-case > </navigation-rule>

HOW NAVIGATION IS DONE When a button or hyperlink is clicked the component associated with it generates an

action event.

This event is handled by the default ActionListener instance, which calls the action method referenced by the component that triggered the event.

This action method is located in backing bean and is provided by application developer.

This action method returns a logical outcome String which describes the result of the processing.

The listener passes the outcome and a reference to the action method that produced the outcome to the default NavigationHandler.

The NavigationHandler selects the next page to be displayed by matching the outcome or the action method reference against the navigation rules in the application configuration resource file.

USER INPUT VALIDATION

If validation or type conversion is unsuccessful, a component specific FacesMessage instance is added to FacesContext. The message contains summary, detail and severity information

Validation can also be delegated to a

managed bean by adding a method binding in the validator attribute of an input tag.

This mechanism is particularly useful for

accomplishing form validation, where combinations of inputted values need to be evaluated to determine whether validation should succeed.

Standard/Built-in validation components <h:inputText id="age" value="#{UserRegistration.user.age}"> <f:validateLongRange maximum="150" minimum="0"/> </h:inputText>

Custom Component public class CodeValidator implements Validator{ public void validate(FacesContext context, UIComponent

component, Object value) throws ValidatorException

{ } } <validator> <validator-id>jcoe.codeValidator</validator-id> <validator-

class>com.jcoe.validation.CodeValidator</validator-class>

</validator> <h:inputText id="zipCode"

value="#{UserRegistration.user.zipCode}" <f:validator validatorId="jcoe.codeValidator"/> </h:inputText>

FEW IMPORTANT UI COMPONENTS

Few important UI components are:

UIForm: Encapsulates a group of controls that submit data to the application. This

component is analogous to the form tag in HTML. UIInput: Takes data input from a user. This class is a subclass of UIOutput

UICommand: Represents a control that fires actions when activated.

UIOutput: Displays data output on a page.

UIMessage: Displays a localized message.

STANDARD UI COMPONENTS

To use the HTML and Core custom tag libraries in a JSP page, you must include the taglib directives in the page.

The components are reusable

Taglib directives <%@ taglib uri="http://java.sun.com/jsf/html/"

prefix="h" %> <%@ taglib uri="http://java.sun.com/jsf/core/"

prefix="f" %>

Components <h:commandButton id="submit" action=“next"

value="Submit" /> <h:inputText id="userName"

value="#{GetStudent.userName}" required="true" >

<h:outputText value="#{Message.greeting_text}" />

TYPE CONVERSION

A JavaServer Faces application can optionally associate a component with server-side object data. This object is a JavaBeans component. An application gets and sets the object data for a component by calling the appropriate object properties for that component.

When a component is bound to an object, the application has two views of the component's data:

The model view, in which data is represented as data types, such as int or long.

The presentation view, in which data is represented in a manner that can be read or modified by the user. For example, a java.util.Date might be represented as a text string in the format mm/dd/yy or as a set of three text strings.

HOW CONVERSION IS DONE?

The JSF technology automatically converts the

component data between the model view and the presentation view.

You can create your own custom converter. To create a custom converter converter in your

application,three things must be done: 1. The application developer must

implement the Converter class. 2. The application architect must

register the Converter with the application.

3. The page author must refer to the Converter from the tag of the component whose data must be converted

The converter attribute on the component tag

<h:inputText value="#{student.Age}"

converter="javax.faces.convert.IntegerConverter" />

The method to convert the model value of the component

Integer age = 0; public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; }

ERROR HANDLING

The JSF core component set provide an HtmlMessages component, which simply outputs the summary message from all the FacesMessage instances added to the FacesContext during validation

Depending on the severity and type of error, the response to it may vary, but at least a sensible error message usually should be shown to the end user.

The JSF framework has several points within its page request processing lifecycle that can raise errors and display consistent error messages.

JAVA BEAN MANAGEMENT

The managed-bean element in the faces-

config.xml application configuration file manages the java beans.

Each managed-bean element registers a JavaBean that JSF will instantiate and store in the specified scope.

Faces-config.xml <!ELEMENT managed-bean

(description*, display-name*, icon*, managed-bean name, managed-bean-class, managed-bean-scope, (managed-property* | map-

entries | list-entries ))>

EVENT HANDLING JSF applications are event-driven. Handling events in JSF is surprisingly easy. Here are the

steps:

Write an event listener.

Deploy the event listener in the WEB-INF/classes or WEB-INF/lib directory under the application directory.

In the tag representing the component whose event is to be captured, use an action_listener or a valuechange_listener tag defined in the Core custom tag library.

Event objects

Must extend javax.faces .event.FacesEvent

FacesEvent is a subclass of the java.util.EventObject class

It adds the getComponent method, which returns the UIComponent component that fired the event.

The FacesEvent class has two subclasses: ActionEvent and ValueChangeEvent.

The ActionEvent class represents the activation of the UI component, such as a UICommand component.

The ValueChangeEvent class represents a notification that the local value of a UIInput component has been changed.

EVENT HANDLING (CONT.)

Event listeners

javax.faces.event.FacesListener interface

This interface extends the java.util.EventListener interface

The FacesListener interface has two subinterfaces: ActionListener and ValueChangeListener

OFTEN CASE IN WEB APP

1. Output dynamic text • Render data to the screen

2. Loop structures • Output collection or render tables

3. Optional rendering of components • Render some components based on state

4. Trigger Actions • User actions or data transmission

OUTPUT DYNAMIC TEXT

Uses the h:outputText tag Also h:outputLabel and h:outputFormat

Uses Expression Language Requires a bean

Defined in the faces-config or the template

Can set style and turn on/off escaping

<h:outputText value="#{JsfAppBean.currentItem.title}"/>

<h:outputText value="#{msgs.jsfapp_text}"/>

LOOP STRUCTURE

h:dataTable is the main loop structure Also h:panelGrid to a degree

Takes a collection as value Uses a variable (entry) to interact with collection

Uses h:column to define each column

<h:dataTable id="itemlist” value="#{JsfAppBean.allItems}” var="entry"> <h:column> <f:facet name="header"> <h:outputText value="#{msgs.jsfapp_text}"/> </f:facet> <h:outputText value="#{entry.item.title}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText value="#{msgs.jsfapp_hidden}"/> </f:facet> <h:selectBooleanCheckbox id="itemHidden" value="#{entry.item.hidden}" disabled="true" /> </h:column> </h:dataTable>

OPTIONAL RENDERING

Handled per h: tag with the rendered attribute (which takes EL) Can prefix with not to invert

Brings render logic into the template

<h:outputText value="#{entry.item.title}" rendered="#{not entry.canDelete}"/>

<h:commandLink id="updatelink" action="#{JsfAppBean.processActionUpdate}" rendered="#{entry.canDelete}"> <h:outputText value="#{entry.item.title}"/> </h:commandLink>

JSF LIFE CYCLE

MVC ARCHITECTURE IN JSF

JSP VS STRUTS VS JAVASERVER FACES JSF JSP JSP and Struts

Components Rich UI-data-bound components with events provided Custom components

Standard tags (JSTL) that are non-UI and very basic Custom components through tag libraries

Struts-specific tag library Only very basic, form-bean-bound components provided

Device independence Reader kits that provide device independence

Error handling and validation

Validation framework Many predefined validators

None Validation framework driven by an XML file (validation.xml)

Scripting

Scripts can be attached to events All components accessible from scripts

Embedded Java™ in the page

Scripts written in Java Action classes Form data but not components accessible

Page flow Simple navigation file (faces-config.xml)

None Sophisticated, flexible framework XML file based

Session and object management

Automatic Manual Manual

IndicThreads.com Java Meet June 2006

Topic : Hibernate 1 Kaster Nurmukan

HIBERNATE An ORM tool Used in data layer of applications Implements JPA

THE PROBLEM BEFORE THEN HIBERNATE id Name Age birthday

Id Name Age

Brithday

THE PROBLEM Mapping object variables to column Mapping relationship Inheritance : java have , RDBMS no. Associations :in java Reference ; in RBDMS foreign key Handling data Type Managing changes to object state

ORM What is ORM

ORM stands for Object-Relational Mapping (ORM) is a programming technique for converting data between relational databases and object oriented programming languages such as Java, C# etc

Advantages Lets business code access objects rather than DB tables. Hides details of SQL queries from OO logic No need deal with database implementation Entities based on business concept s rather then database structure Transaction management and automatic key generation Fast development of application

JAVA ORM FRAMEWORKS

Enterprise JavaBeans Entity Beans Java Data Object Castor TopLink Spring DAO Hibernate More

HIBERNATE Hibernate is an Object-Relational Mapping(ORM) solution for JAVA and it

raised as an open source persistent framework created by Gavin King in 2001. It is a powerful, high performance Object-Relational Persistence and Query service for any Java Application

NHibernate for .Net. opensource

HIBERNATE FEATURES O-R mapping using ordinary JavaBeans

Can set attributes using private fields or private setter methods

Lazy instantiation of collections (configurable)

Polymorphic queries, object-oriented query language

Cascading persist & retrieve for associations, including collections and many-to-many

Transaction management with rollback

Can integrate with other container-provided services

LEARN HIBERNATE WHAT YOU NEED Study path ,If JDBC way :

SQL Fundamentals

JDBC Fundamentals

Design and Code

IF use a framework

How to use Hibernate Configure a Database

IF use a stardard How to use JPA Configure a Database

APPLICATION ARCHITECTURE

User Interface

Application Logic

business Objects DAO

Hibernate

JDBC Foundation Classes

UI event

data request

Hibernate API business object

business object

Data object

JDBC API ResultSet, etc.

hibernate.cfg.xml

*.hbm.xml class mappings

SessionFactory

HIBERNATE.CFG.XML FOR MYSQL

<?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC ... remainder omitted > <hibernate-configuration> <session-factory> <property name="dialect"> org.hibernate.dialect.MySQLDialect </property> <property name="connection.driver_class"> com.mysql.jdbc.Driver </property> <property name="connection.username">student</property> <property name="connection.password">pw</property> <property name="connection.url"> jdbc:mysql://localhost:3306/dbtest</property>  <mapping resource="eventmgr/domain/Location.hbm.xml"/> ... other mappings omitted </session-factory> </hibernate-configuration>

HIBERNATE IN APPLICATION ARCHINECTURE

Source: Hibernate Reference Manual (online)

HIBERNATE BASICS

Session A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for Transaction. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier.

HIBERNATE BASICS

Persistent Objects and Collections Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) Session. As soon as the Session is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation).

HIBERNATE BASICS

Transient Objects and Collections Instances of persistent classes that are not currently associated with a Session. They may have been instantiated by the application and not (yet) persisted or they may have been instantiated by a closed Session.

HIBERNATE BASICS

Transaction (Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from underlying JDBC, JTA or CORBA transaction. Multiple transactions per Session.

HIBERNATE BASICS

ConnectionProvider (Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying Datasource or DriverManager. Not exposed to application, but can be extended/implemented by the developer. TransactionFactory (Optional) A factory for Transaction instances. Not exposed to the application, but can be extended/implemented by the developer.

SESSIONFACTRY try { configuration.configure(configFile); sessionFactory =

configuration.buildSessionFactory(); } catch (Exception e) { System.err .println("%%%% Error Creating SessionFactory

%%%%"); e.printStackTrace(); }

SESSION

public Session getSession() { return HibernateSessionFactory.getSession(); }

SAVE TO DB WITH HIBERNATE public void save(Answer answer) { log.debug("saving Answer instance"); try { getSession().save(answer); log.debug("save successful"); } catch (RuntimeException re) { log.error("save failed", re); throw re; } }

TAKE CARE WITH TRANSACTION private UserDAO uDao = new UserDAO(); …….. try { Transaction trans= uDao.getSession().beginTransaction(); trans.begin(); uDao.save(user); trans.commit(); } catch (RuntimeException e) { throw e; }

Topic : Hibernate 2: Object Persistence and ORM Kaster Nurmukan

AGENDA Overview of table relashionship with Object Goal & Purpose Analyzing An Example

OBJECT-RELATIONAL MAPPING Purpose save object as a row in a database table create object using data from table save and create associations between objects Design Goals separate O-R mapping service from our application localize the impact of change in database

Java Application

object

Persistent Storage

AN EXAMPLE An Seminar Topic Manager application with these classes:

OBJECT-RELATIONAL MAPPING Map between an object and a row in a database table.

LOCATIONS PK id INTEGER name VARCHAR(80) address VARCHAR(160)

Location id: int name: String address: String

Class should have an identifier attribute

Database Table identifier is usually the primary key of table

Object Mapper

Object Mapper convert object to table row data, convert data types, instantiates objects

MAPPING AN OBJECT

LOCATIONS id name address 01 SDU University Ablaihan ... 02 Seacon Square 120 street ...

ku : Location id = 01 name = “SDU University" address = “Ablaihan ..."

object diagram

save( )

O-R MAPPING CODE FOR LOCATION (1) Location loca = new Location( “SDU University" ); loca.setAddress( “No xx ablaihan Road" );

// save the location objectMapper.save(loca );

Issues:

• mapper should choose a unique ID for saved objects

• what happens if same data is already in the table?

FINDING AN OBJECT

// retrieve the location

Location localtion1 = objectMapper.find(“SDU University"); Location localtion1 = objectMapper.find(“SDU University");

what field does find( ) search for? id field? name field?

does mapper always return the same object?

(localtion1 == localtion2 ) => true or false?

FINDING AN OBJECT: SOLUTION

// retrieve the location Location sdu = objectMapper.find( 111 ); List sdu_list = objectMapper.query( "'SELECT WHERE name LIKE ‘SDU U%'");

Provide two kinds of "find".

find( key ) - find object by primary key

query( string ) - find objects using a flexible query language. May return many matches.

TRANSPARENT PERSISTENCE

Location sdu= new Location( “SDU University" ); sdu.setAddress( “xx ablaihan, … " ); // save the location objectMapper.save(sdu ); // change the address sdu.setAddress( “doctikh, xxxx" );

With transparent persistence, changes to a "managed" object are automatically propagated to the database.

LOCATIONS id name address 01 Sdu University xxx... 02 dd 120 strate...

O-R MAPPING OF N-TO-1 ASSOCIATIONS Seminar

id: int name: String startDate: Date location: Location …..

O-R MAPPING OF N-TO-1 ASSOCIATIONS Seminar

id: int name: String startDate: Date location: Location

LOCATIONS PK id INTEGER name VARCHAR address VARCHAR

Seminar PK id INTEGER name VARCHAR start_date TIMESTAMP FK location_id INTEGER

The ORM converts a n-to-1 association to a foreign key relation (persist) or foreign key to object (retrieve).

CASCADED SAVE

Seminar siminar = new Seminar( "JavaEE Days" ); Location lo = new Location( “SDU University" ); lo.setAddress( “xx Ablaihan; kaskelen" ); siminar.setLocation( ku ); siminar.setStartDate( new Date(11,Calendar.JULY, 1) ); // save the event objectMapper.save(siminar);

When we save the siminar, does it save the location, too?

Is this done automatically?

Save an Seminar...

DELETING AN SIMINAR

// delete the siminar Siminar siminar = objectMapper.find( "JavaEE Days" ); objectMapper.delete(siminar);

Does the dataMapper delete the Location, too?

What if other Siminars (in database) still refer to this Location?

FETCHING AN SIMINAR

// retrieve the siminar Siminar siminar = objectMapper.find( "JavaEE Days" ); Location location = room.getLocation( ); // null?

When we get the siminar , does the ORM fetch the location, too?

O-R MAPPING OF 1-TO-N ASSOCIATIONS Seminar

id: int name: String startDate: Date

Speaker id: int name: String telephone: String

speakers

O-R MAPPING OF 1-TO-N ASSOCIATIONS Seminar

SPEAKERS PK id INTEGER name VARCHAR telephone VARCHAR FK event_id INTEGER

Seminar PK id INTEGER name VARCHAR start_date TIMESTAMP FK location id INT

Siminar has a collection of Speakers. The ORM saves a collection as Speaker entries with FK reference to Event.

speakers

O-R MAPPING FOR COLLECTIONS (1) Siminar siminar = new Siminar ( "JavaEE Days" ); siminar.setLocation( location ); // add siminar speakers Speaker jhon= new Speaker( “Jhon Simith" ); Speaker hans = new Speaker( "Prof. K" ); siminar.getSpeakers().add( jhon); siminar.getSpeakers().add( hans); // save the siminar objectMapper.save( siminar);

Issues:

• same issues as many-to-1 association

HOW TO MAP COLLECTIONS?

// retrieve the room Siminar siminar= objectMapper.find("JavaEE Days"); Collection speakers = siminar.getSpeakers( );

What kind of collection does ORM return?

Can we use any collection we want?

ArrayList?

O-R MAPPING OF ORDERED COLLECTIONS Siminar

speakers {ordered}*

O-R MAPPING OF ORDERED COLLECTIONS Siminar

SPEAKERS PK id INTEGER name VARCHAR FK event_id INTEGER speaker_idx INT

Speaker id: int name: String

Siminar PK id INTEGER name VARCHAR start_date TIMESTAMP FK location_id INT

Siminar has a list or array of Speakers. The ORM must store a foreign key and a list index in the Speaker table.

sessions {ordered}*

O-R MAPPING OF M-TO-N ASSOCIATIONS Siminar

Attendee id: int name: String telephone: String

attendees *

Siminar *

O-R MAPPING OF M-TO-N ASSOCIATIONS Seminar

ATTENDEES PK id INTEGER name VARCHAR telephone VARCHAR

Attendee id: int name: String telephone: String

Seminar PK id INTEGER name VARCHAR start_date TIMESTAMP FK location_id INT

attendees *

Siminar *

SIMINAR_ATTENDEE PK id INTEGER FK siminar_id INTEGER FK attendee_id INTEGER

WHAT IS CASCADING?

When you save/update/delete an object in database... are associated objects also saved/updated/deleted?

e: SIMINAR

Attendee

attendees {set}

SIMINAR table

ATTENDEES table

save( e )

FRAMEWORKS PROVIDE CASCADING

In JPA, using annotations:

@Entity class Siminar { @OneToMany(mappedBy=“siminar", cascade=PERSIST) private List<Person> attendees;

NONE PERSIST REFRESH REMOVE ALL

CASCADING IN HIBERNATE

In Hibernate mapping file for Siminar:

cascade= "none" don't cascade operations "all" cascade all operations (be careful) "save-update" cascade save and updates "delete-orphan" cascade all, delete unreferenced orphan children

WHAT ARE EAGER AND LAZY FETCHING?

When you create an object from database... when are associated objects created? e: Room

Attendee

attendees {set}

Rooms table

ATTENDEE table

find( id )

WHY IS FETCHING IMPORTANT?

Example: get a Country from Country database. Country kz= orm.query( "SELECT c FROM Country c WHERE c.name=‘Kazakhstan'"); System.out.println( "Population is "+kz.getPopulation() );

Country cities: Set City

has 90 cities

How many objects are created? a) One - just the Country object

b) 91 - Country + all 90 cities

WHAT ARE EAGER AND LAZY FETCHING?

Eager: create all associated object immediately. Lazy: create associated objects only when they are

referenced.

Country kz = orm.query("SELECT c FROM ..."); System.out.println( "Population is "+kz.getPopulation() ); for(City c: kz.getCities() ) Sytem.out.println("has city: "+city);

PROBLEM WITH LAZY FETCHING

The query or connection object might be closed before the code accesses the cities.

// This code uses JPA em = entityManagerFactory.getEntityManager(); Query q = em.createQuery("SELECT c FROM ..."); Country kz = q.getSingleResult(); // close entity manager to free resources em.close( ); for(City c: kz.getCities() ) Sytem.out.println("has city: "+city);

ERROR: not attached to database

DESIGN MODEL FOR OBJECT MAPPER Object Mapper

find( id ) : T

query( query : String ): T[*]

findAll( ) : T[*]

save( object : T )

update( object : T )

delete( object : T )

A UML Type Parameter

The method to "find" an Object by its identifier maybe named:

load( id ) the Hibernate and Spring name

find( id, Class ) JPA

get( id ) similar to load but no exception if id is not found

OBJECT-RELATIONAL OPERATIONS: CRUD Common O-R operations are:

Create - save (persist) a new object in the database

Retrieve an object from the database

Update data for an object already saved in database

Delete object data from the database

OBJECT MAPPING FOR EVENT CLASS This class is generally called a

Data Access Object (DAO). Hibernate uses the term "data access object". Append "Dao" to the class name, e.g. EventDao.

EventDao

find( id: int ) : Event

query( query: String ) : Event[*]

save( evt: Event )

update( evt: Event )

delete( evt: Event )

LAYERED DESIGN

User Interface

Application Logic

Domain Objects DAO

O-R Mapping Framework Other Services

JDBC Foundation Classes

ui event

CRUD request

ORM API domain object

domain object

data xfer object

JDBC API ResultSet, etc.

WHEN NOT TO USE O-R MAPPING

In some applications, Object-Relational mapping is inefficient. Example: display a table of attendees

Name Telephone Email

Bill Gates 1-215-555-1212 gates@msn.com

B. Obama 1-212-111-1212 president@whitehouse

PersonDao

TableModel

RowSet

Person objects

4 APPROACHES TO ORM

1. No ORM -- JDBC in my code. No Layers! Put the JDBC right in your app code. 2. Do It Myself. Write your own DAO using JDBC. 3. Use a Framework. Hibernate, MyBatis, TopLink, or other. 4. Use a Standard. Java Persistence Architecture (JPA) or Java Data

Objects (JDO) provide a standard API that have many implementations.

PERSISTENCE FRAMEWORKS Hibernate - most popular open-source persistence

framework for Java. NHibernate for .Net. Uses POJOs and object-query language. Completely

decouple Java from database. Can reverse engineer.

MyBatis - simple, uses SQL maps. Database schema not transparent to Java code.

Cayenne - Apache project, has GUI modeler that eliminates need to write xml. Can reverse engineer database or generate database schema & Java code.

TopLink (Oracle) Torque (Apache DB) Castor, ...

PERSISTENCE STANDARDS Java Persistence API (JPA)

standard for persistence of plain java objects. Can be used with stand-alone or enterprise apps. Good IDE support. EclipseLink, TopLink Essentials (Glassfish project), OpenJPA.

DataNucleus, Hibernate Annotations.

Java Data Objects (JDO) transparent persistence of POJOs; can persist to LDAP, RDBMS, Excel, and other Kodo, DataNucleus

REFERENCE FOR FRAMEWORKS

Article: Adopting a Java Persistence Framework, http://today.java.net/pub/a/today/2007/12/18/adopting-java-persistence-framework.html

NO PERSISTENCE FRAMEWORK

Web4J (www.web4j.org) web + database in Java without O-R mapping. Interesting

& educational web site Presents arguments why not to use a framework (but

doesn't mention Hibernate).

REFERENCE http://www.hibernate.org/hib_docs/reference/en/html_single/ http://www.hibernate.org/78.html

http://www.oracle.com

Topic : Hibernate 3:Advanced ORM Kaster Nurmukan

AGENDA Advanced ORM Embedded class Collections Inheritance &Practice

BASIC OBJECT-RELATIONAL MAPPING

Class-level annotations @Entity and @Table

Id field @Id and @GeneratedValue

Fields of simple types @Basic (can be omitted) and @Column

Fields of class types @ManyToOne and @OneToOne

ADVANCED ORM Embedded class Collections Inheritance

EMBEDDED CLASS

public class Address { String street; String city; String state; String zip; }

id … street city state zip …

public class User { Integer id; String username String password; Address address; }

MAPPING EMBEDDED CLASS

@Embeddable public class Address { String street; String city; String state; String zip; }

@Entity public class User { @Id Integer id; String username String password; @Embedded Address address; }

COLLECTION OF SIMPLE TYPES

public class Customer { Integer id; String name; String address; Set<String> phones; }

MAPPING ELEMENT COLLECTION

customers Customer_phones

Customer_id phones

@ElementCollection Set<String> phones;

CUSTOMIZE COLLECTION TABLE

@ElementCollection @CollectionTable( name = “customer_phones”, joinColumns=@JoinColumn(name = “customer_id”) ) @Column(name=“phone”) Set<String> phones;

LIST OF SIMPLE TYPES

Order by property @OrderBy(“<property_name> ASC|DESC”) Simple types do not have properties

Order by a separate column

@ElementCollection @OrderBy(“asc”) List<String> phones;

@ElementCollection @OrderColumn(name = “phone_order”) List<String> phones;

ISSUES RELATED TO COLLECTIONS OF OBJECT TYPES Relationships (a.k.a. associations)

one-to-many many-to-many

Unidirectional vs. Bidirectional Set and List Cascading behaviors

TYPES OF RELATIONSHIPS Many-to-Many Many-to-One / One-to-Many One-to-One

MANY-TO-MANY RELATIONSHIP Each entity in E1 can

be related to many entities in E2

Each entity in E2 can be related to many entities in E1

MANY-TO-ONE RELATIONSHIP Each entity in E1 can

be related to one entities in E2

Each entity in E2 can be related to many entities in E1

ONE-TO-ONE RELATIONSHIP Each entity in E1 can

be related to one entities in E2

Each entity in E2 can be related to one entities in E1

RELATIONSHIP TYPE EXAMPLES Books and authors?? Books and editors??

ONE-TO-MANY EXAMPLE A customer may own multiple accounts An account only has one owner

BIDIRECTIONAL ASSOCIATION – OO DESIGN #1

public class Account { Integer id; Double balance; Date createdOn; Customer owner; }

public class Customer { Integer id; String name; String address; Set<String> phones; Set<Account> accounts; }

UNIDIRECTIONAL ASSOCIATION – OO DESIGN #2

public class Account { Integer id; Double balance; Date createdOn; }

public class Customer { Integer id; String name; String address; Set<String> phones; Set<Account> accounts; }

UNIDIRECTIONAL ASSOCIATION – OO DESIGN #3

public class Account { Integer id; Double balance; Date createdOn; Customer owner; }

public class Customer { Integer id; String name; String address; Set<String> phones; }

UNIDIRECTIONAL VS. BIDIRECTIONAL Do the three OO designs result in different database

schemas?? Does it make any difference on the application side?? Which one should we use??

MAPPING BIDIRECTIONAL ONE-TO-MANY

public class Account { Integer id; Double balance; Date createdOn; @ManyToOne Customer owner; }

public class Customer { Integer id; String name; String address; Set<String> phones; @OneToMany(mappedBy=“owner”) Set<Account> accounts; }

property

USING LIST

public class Customer { Integer id; String name; String address; Set<String> phones; @OneToMany(mappedBy=“owner”) @OrderBy( “createdOn asc” ) List<Account> accounts; }

MANY-TO-MANY EXAMPLE A customer may own multiple accounts An account may have multiple owners

MAPPING MANY-TO-MANY

public class Account { Integer id; Double balance; Date createdOn; @ManyToMany Set<Customer> owners; }

public class Customer { Integer id; String name; String address; Set<String> phones; @ManyToMany(mappedBy=“owners”) Set<Account> accounts; }

CUSTOMIZE JOIN TABLE

@ManyToMany @JoinTable( name = “account_owners”, joinColumns=@JoinColumn(name = “account_id”), inverseJoinColumns=@JoinColumn(name=“owner_id”) ) Set<Customer> owners;

CASCADING BEHAVIOR

Whether an operation on the parent object (e.g. Customer) should be applied to the children objects in a collection (e.g. List<Account>)

Customer c = new Customer(“cysun”); Account a1 = new Account(); Account a2 = new Account(); c.getAccounts().add( a1 ); c.getAccounts().add( a2 ); entityManager.persist(c); // will a1 and a2 be saved as well? entityManager.remove(c); // will a1 and a2 be deleted from db??

CASCADING TYPES IN JPA http://sun.calstatela.edu/~cysun/documentation/jpa-2.0-

api/javax/persistence/CascadeType.html

CASCADETYPE EXAMPLES

@OneToMany(mappedBy=“owner”, cascade=CascadeType.PERSIST) List<Account> accounts;

@OneToMany(mappedBy=“owner”, cascade={CascadeType.PERSIST, CascadeType.MERGE}) List<Account> accounts;

@OneToMany(mappedBy=“owner”, cascade=CascadeType.ALL) List<Account> accounts;

INHERITANCE

public class CDAccount extends Account { Integer term; }

EVERYTHING IN ONE TABLE

id account_type balance created_on term

accounts

Discriminator column

INHERITANCE TYPE – SINGLE_TABLE

@Entity @Table(name=“accounts”) @Inheritance(strategy=InheritanceType.SINGLE_TABLE) @DiscriminatorColumn(name=“account_type”) @DiscrimnatorValue(“CHECKING”) public class Account { … }

@Entity @DiscrimnatorValue(“CD”) public class CDAccount { … }

TABLE PER SUBCLASS

id balance created_on accounts

account_id term cd_accounts

foreign key

INHERITANCE TYPE – JOINED

@Entity @Table(name=“accounts”) @Inheritance(strategy=InheritanceType.JOINED) public class Account { … }

@Entity @Table(name=“cd_accounts”) public class CDAccount { … }

TABLE PER CONCRETE CLASS

id balance created_on

accounts

id balance created_on term

cd_accounts

INHERITANCE TYPE – TABLE_PER_CLASS

@Entity @Table(name=“accounts”) @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) public class Account { … }

@Entity @Table(name=“cd_accounts”) public class CDAccount { … }

TIPS FOR HIBERNATE MAPPING Understand relational design

Know what the database schema should looks like before doing the mapping

Understand OO design Make sure the application design is object-oriented

FURTHER READINGS TopLink JPA Annotation Reference –

http://www.oracle.com/technetwork/middleware/ias/toplink-jpa-annotations-096251.html

Pro JPA 2 by Mike Keith and Merrick Schincariol

HOMEWORK Reading online resouce JPQL / Criteria http://docs.oracle.com/javaee/6/tutorial/doc/gjitv.html http://www.objectdb.com/java/jpa/query http://en.wikipedia.org/wiki/Java_Persistence_Query_Lang

Topic : JPA Kaster Nurmukan

AGENDA Overview of JPA EntityManager

AGENDA O/R Mapping Primary entity annotations EntityManager Entity Relationships Practice

O/R MAPPING

Database Table

POJO Forward Engineering

Reverse Engineering

Java Persistence API

HIBERNATE AND JPA Java Persistence API (JPA)

Annotations for object-relational mapping Data access API An object-oriented query language JPQL

Hibernate The most popular Java ORM library An implementation of JPA

HIBERNATE USAGE

Hibernate without JPA API: SessionFactory, Session, Query, Transaction

More features Hibernate with JPA

API: EntityManagerFactory, EntityManager, Query, Transaction

Better portability Behaviors are better defined and documented

A HIBERNATE EXAMPLE

Java classes Employee.java

JPA configuration file persistence.xml

Code to access the persistent objects EmployeeTest.java

(Optional) Logging configuration files log4j.properties

JAVA CLASSES Plain Java classes (POJOs); however, it is recommended

that Each persistent class has an identity field Each persistent class implements the Serializable interface Each persistent field has a pair of getter and setter, which don’t

have to be public

PRIMARY ENTITY ANNOTATIONS @Entity. Mark class as an entity @Id. Define primary key @EmbeddedId. Define composite key @Table(name=“TABLE_NAME”). Define table name for

entity class. @Column. Define column property. @Transient. Ignored by persistence framework. @GeneratedValue,@SequenceGenerator. Autopopulate

column with sequence generator.

ENTITYMANAGER Maintains a cache of instances within a transactional

context (persistence context) We can acquire EntityManager instance using : Dependency Injection EntityManagerFactory JNDI Lookup

Operations : persist(), merge(), remove(), find(), createNamedQuery(), createQuery()

Persistence unit is declared in persistence.xml

ENTITY RELATIONSHIPS @OneToOne. One to One is represented by a

single-value entity reference at one or both ends of the relationship

@OneToMany. This annotation is added to a Collection relationship field.

@ManyToOne. Indicating that is an entity is part of a Collection

@ManyToMany. This annotation is assigned to a Collection relationship field to indicate the target entity also has a Collection of the source entity type.

Lazy vs Eager Binding Cascade (ALL, PERSIST, MERGE, REMOVE,

REFRESH)

v110912 Java Persistence: EntityManager 188

JAVAX.PERSISTENCE.ENTITYMANAGER Replaces much of the EJB 2.x “Home” functionality Handles O/R Mapping of Entities to the database Provides APIs

inserting objects into database getting objects from database synchronizing objects with database querying database

Provides caching Coordinates with transactional services (JTA) Tightly integrated with Java EE and EJB, but not

limited to that environment

JAVAX.PERSISTENCE.ENTITYMANAGER Replaces much of the EJB 2.x “Home” functionality Handles O/R Mapping of Entities to the database Provides APIs

inserting objects into database getting objects from database synchronizing objects with database querying database

Provides caching Coordinates with transactional services (JTA)

Tightly integrated with Java EE and EJB, but not limited to that environment

ENTITIES

(formerly and sometimes still called Entity Beans) are now Plain Old Java Objects (POJOs)

nothing special happens when calling new

Author author = new Author();

are not persistent until associated with an EntityManager em.persist(author);

EXAMPLE AUTHOR POJO ENTITY @javax.persistence.Entity public class Author { private long id; private long version=0; private String firstName; private String lastName; private String subject; private Date publishDate; public Author() {} public Author(long id) { this.id = id; } @Id @GeneratedValue public long getId() { return id;} private void setId(long id) { this.id = id; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } ... }

Warning: Using GeneratedValue without specifying a specific strategy should only be used when you have no intention of controlling how the provider manages primary keys for this object type. This would be rare.

CREATING ENTITY IN DATABASE Author author = new Author(); //primary key will be gen author.setFirstName("dr"); author.setLastName("seuss"); author.setSubject("children"); author.setPublishDate(new Date()); log_.info("creating author:" + author); em.persist(author); log_.info("created author:" + author); //output -creating author:id=0, fn=dr, ln=seuss, subject=children, pdate=Fri Sep 15 11:54:15 EDT 2006 -created author:id=50, fn=dr, ln=seuss, subject=children, pdate=Fri Sep 15 11:54:15 EDT 2006

MANAGED AND UNMANAGED ENTITIES Unmanaged state (detached)

instance not associated with an EntityManager state changes are not tracked can be serialized to client and returned to be

synchronized with database nothing equivalent to this state in EJB 2.1 entity beans

Managed state (attached) instance associated with an EntityManager state changes are tracked within a Persistence Context EJB 2.1 entity beans were always managed

client interfaced with data through a proxy or state transferred through a Data Transfer Object

PERSISTENCE CONTEXT A set of attached entity instances managed by an

EntityManager All entities become detached once closed Two types

Transaction-scoped Persistence Contexts begin/end at transaction boundaries only made available through container managed persistence

contexts Extended Persistence Contexts

live beyond any single transaction allow longer-lived interactions with database without lengthy

transactions tying up database resources

PERSISTENCE CONTEXT EXAMPLES Transaction-scoped (inside server container)

@PersistenceContext(unitName=”jpaDemo”) EntityManager em;

@TransactionAttribute(REQUIRED) public void update(long authorId, String type) {

Author author = em.find(Author.class, authorId); author.setType(type);

Extended (inside or outside server container) EntityManager em = Persistence.

createEntityManagerFactory(“jpaDemo”).createEntityManager();

tx.begin(); //tx 1 begins Author author = em.find(Author.class, authorId); tx.commit(); //tx 1 ends, but author remains managed ... tx.begin(); //tx 2 begins author.setType(type); tx.commit(); //tx 2 ends, and author is still managed

until close

PERSISTENCE UNIT

A set of classes that are mapped to the database defined in META-INF/persistence.xml must have an identity

“” is a valid identity Classes

may be named in persistence.xml file may be automatically scanned for in the classpath

orm.xml optionally provided to augment, provide, or replace class

persistence metadata (more on orm.xml in Core ORM topic)

EXAMPLE COMPONENT LAYOUT META-INF/ +---persistence.xml ejava + ---examples +---… +---DAOException.class +---AuthorDAO.class +---jpa | +---JPAAuthorDAO.class | +---JPADAOBase.class +--domain +---Author.class

EXAMPLE PERSISTENCE.XML <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0"> <persistence-unit name="jpaDemo"> <jta-data-source>java:/ejavaDS</jta-data-source> <properties> <property name="hibernate.hbm2ddl.auto" value="create"/> <property name="hibernate.show_sql" value="true"/ </properties> </persistence-unit> </persistence>

referenced by name

• global JNDI name by which provider references resource (will be used when deployed within server) • may use properties element in Java SE environments that lack JNDI

• vendor-specific way to configure persistence provider

ANOTHER EXAMPLE PERSISTENCE.XML <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0"> <persistence-unit name="jpaDemo"> <provider>org.hibernate.ejb.HibernatePersistence</provider> <properties> <property name="hibernate.cache.provider_class" value="net.sf.ehcache.hibernate.Provider"/> <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/> <property name="hibernate.connection.url" value="jdbc:hsqldb:hsql://localhost:9001"/> <property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/> <property name="hibernate.connection.password" value=""/> <property name="hibernate.connection.username" value="sa"/> <property name="hibernate.show_sql" value="false"/> <property name="hibernate.hbm2ddl.auto" value="create"/> </properties> </persistence-unit> </persistence

PERSISTENCE.XML ELEMENTS name – identity to reference Persistence Unit provider – fully qualified name of javax.persistence.PersistenceProvider

not needed if provider found in classpath acceptable mapping-file – resource path to optional mapping file

can be used to specify <class>es or specify/override @Annotation details

jta-data-source vendor-specific reference to data source using JTA transactions

non-jta-data-source vendor-specific reference to data source using RESOURCE_LOCAL

transactions jar-file

optional/additional jar file to scan for classes class

specifies entity classes not automatically scanned by provider exclude-unlisted-classes

if set, provider will not automatically scan archive for entity classes properties

may be used to provide vendor-specific properties to configure persistence providers

JAVA SE STEPS Startup

Get EntityManagerFactory Runtime

Create EntityManager Start Transaction Interact with Entity Manager Commit Transaction Close EntityManager

Shutdown Close EntityManagerFactory

UPDATING ENTITIES Updates to managed entities automatically get

propagated to database according to flush policy public Author update(Author author) { Author dbAuthor = em.find(Author.class,author.getId());

dbAuthor.setFirstName(author.getFirstName()); dbAuthor.setLastName(author.getLastName()); dbAuthor.setSubject(author.getSubject()); dbAuthor.setPublishDate(author.getPublishDate()); return dbAuthor; } Note that if author passed in was already managed...

the changes have already been queued the dbAuthor returned from the find() will be the same object as author the sets are unnecessarily changing the values of the Author to their

current values

(OPTIONAL!)POTENTIAL UTILTITY CLASS package ejava.examples.dao.jpa; import java.util.HashMap; import java.util.Map; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; public class JPAUtil { private static final Map<String, EntityManagerFactory> factories = new HashMap<String, EntityManagerFactory>(); public static EntityManagerFactory getEntityManagerFactory(String puName) { EntityManagerFactory emf = factories.get(puName); if (emf == null) { synchronized(factories) { emf = factories.get(puName); if (emf == null) { emf = Persistence.createEntityManagerFactory(puName); factories.put(puName, emf); } } } return emf; } public static void close() { synchronized(factories) { for(String puName : factories.keySet()) { factories.get(puName).close(); } factories.clear(); } } }

Topic : JavaMail API (1) Sending and Receiving Emails Kaster Nurmukan

AGENDA Overview of JavaMail API SMTP POP MIME javaMail API HTML Email Email With attachment

MAIL API Java Mail API is an easy and standard way of

sending and receiving emails Java Mail API supports following Protocols:

SMTP POP IMAP MIME

SMTP Simple Mail Transfer Protocol

Usually used for sending emails from clients Also used for relaying emails from one server to another

POP Post office protocol Currently Version 3 in use (Pop3 RFC1939) Used at client side to check the emails that are received in

the mailbox for a user

IMAP Stands for Internet Message Access Protocol Currently IMAP4 (RFC2060) in use More advanced protocol for email access that

allows multiple folder management on server, periodic backups and several other advanced features.

MIME Multi-purpose Internet Mail Extention Defines the contents that are to be transferred in an email

WHAT DO YOU NEED TO USE JAVA MAIL? You should have following two APIs

Java Mail API JavaBeans Activation Framework(JAF) JAF is included in JDK6

MAIL API As the name says, is used for sending and receiving

emails. Mail API requires JavaBeans Activation Framework

JAF JavaBeans Activation Framework

Helps programmers to Determine the type of an arbitrary piece of data

Encapsulates access to it Discovers operations that can be performed on it Get from

WHERE TO GET? Both APIs can be downloaded from http://www.oracle.com/technetwork/java/javaee/downloads

/ JAF Get from • http://www.oracle.com/technetwork/java/jaf11-

139815.html#download

• But you still need Email Server first : You can use existing server out site internet ,example: Gmail You can download local Mail server in your PC

http://james.apache.org/download.cgi#Apache_James_Server

HOW TO INSTALL? Un-zip the javamail.zip and jaf.zip into some folder Put mail.jar from javamail folder to the classpath Put activation.jar from jaf folder to classpath

JAVA MAIL CLASSES

You must know following classes before you start Session Message Address Transport Store Folder

JAVAX.MAIL.SESSION Defines a basic mail session Everything in mail api works due to this session

JAVAX.MAIL.MESSAGE

Represents an email message that is either created to be sent to the recipient or is received from someone.

Message is an Abstract class MimeMessage is the sub-class of message

that understands most MIME types and is most commonly used for email handling

JAVAX.MAIL.ADDRESS Represents an email addres Address is an abstract class javax.mail.Internet.InternetAddress is the sub-class of

Address

MESSAGE REPRESENTATION

MimeMessage

Headers

Session

Address[] To Address[] From

String subject Date sentDate

Message Content: String text

Properties

TRANSPORT This class speaks the protocol specific language to send

messages. (Usually SMTP)

STORE AND FOLDER When receiving email

We create a session Connect to a store with our username and password Get specific folders (usually inbox) And start receiving Message objects

SENDING AN EMAIL

//Create properties object Properties p = System.getProperties(); p.put("mail.smtp.host", "202.125.140.71"); // Get session Session s = Session.getDefaultInstance(p,null);

SENDING AN EMAIL (CONT)

Message m = new MimeMessage(s); InternetAddress to = new InternetAddress("bbb@edu.kz"); InternetAddress from = new InternetAddress("bill_gates@microsoft.com",

"Bill Gates"); m.setContent("yeah this is the body", "text/plain"); m.setFrom(from); m.setRecipient(Message.RecipientType.TO, to); m.setSubject("de subject"); Transport.send(m);

CHECKING MAILS Properties props = new Properties(); Session session = Session.getDefaultInstance(props,

null); Store store = session.getStore("pop3"); store.connect(host, username, password); Folder folder = store.getFolder("INBOX"); folder.open(Folder.READ_ONLY);

CHECKING MAILS(CONT) Message message[] = folder.getMessages(); for (int i=0, n=message.length; i<n; i++) { System.out.println(i + ": " +

message[i].getFrom()[0] + "\t\t" + message[i].getSubject());

} folder.close(false); store.close();

OUTPUT 0: Hans<hans@sdu.edu.kz> test 1 1: hans@sdu.edu.kz de subject 2: hans@sdu.edu.kz@microsoft.com de subject 3: bbb@dell.com de subject 4: bbb@hell.com de subject 5: Bill Gates <bill_gates@microsoft.com> de subject

LET’S TRY IT OUT!!! Send email using Gmail SMTP server Set Mail content type (text/plain)

HTML EMAIL

• You can also send HTML email with JavaMail. HTML email can be used to – Use different size fonts – imbed images into your email – Use different colored text, bold, italic, etc.

HTML EMAIL

• With HTML email, – you set the mime message content type to

"text/html" – call the setContent() method to set your

html content • It helps to know a little HTML!

MAIL SECURITY

Virtually all mail servers require a username and password to receive email Some mail servers require a username and password to send an email (by

default, James does not). This prevents spammers from hijacking the mail server to send

unauthorized email JavaMail supports this username/password authorization and authentication

To implement this, you get a transport object from the mail session and call the connect() method with the mail host, username, and password

See next slide for code example

HTML EMAIL EXAMPLE Example of sending html message with an imbedded image using username/password

authorization MimeMessage msg = new MimeMessage(mailSession); msg.setFrom(new InternetAddress("bill@msn.com")); msg.addRecipient(Message.RecipientType.TO, new InternetAddress(“tom@msn.com")); msg.setSubject(subject); String html = "<html><body><b>MY SPAM</b><br><img src='http://www.wrfportal.org/images/NOAA_logo.jpg'> </body></html>"; msg.setContent(html, "text/html"); Transport transport = mailSession.getTransport("smtp"); transport.connect("localhost","user", "passwd"); msg.saveChanges(); transport.sendMessage(msg, msg.getAllRecipients()); transport.close();

MULTIPART REPRESENTATION

MimeMessage Headers Session

Message Content: Multipart MimeBodyPart MimeBodyPart

String text

DataHandler

FileDataSource File

String fileName

JAVAX.ACTIVATION.DATASOURCE Interface that allows access to file type and to

streams that can manipulate the file public String getContentType() returns the name of

the MIME file type Implemented by javax.Activation.FileDataSource Used by JavaMail to create and retrieve e-mail

attachments Constructors

FileDataSource(File file) FileDataSource(String filename)

JAVAX.ACTIVATION.DATAHANDLER Wrapper for DataSource objects so that the user

does not need to manipulate the bytes for each file Constructors

DataHandler(DataSource ds) DataHandler(Object obj, String mimeType)

Public Object getContent() Returns the data as the object that represents its content type (ie runing this method on a text message returns a String)

JAVAX.MAIL.PART REVISITED Allows manipulation of DataHandlers

public void setDataHandler(DataHandler dh) public DataHandler getDataHandler()

Other methods abstract user away from need to directly manipulate DataHandler public void setContent(Object object, String

contentType) public Object getContent()

JAVAX.MAIL.MIMEBODYPART Implements the Part interface (indirectly through a few

abstract classes) Contains the content for a single part of an e-mail

message Uses several methods to manipulate content directly

or through DataHandler or streams Key Methods

public void setText(String text): for text/plain content, makes a String into the message content

public void setDataHandler(DataHandler dh) sets the content using a DataHandler (which may be text or any other permitted content)

public void setFileName(String filename) sets the filename associated with the content, if the content represents a file

JAVAX.MAIL.MULTIPART Container that holds multiple parts Each part is indexed, starting with 0 A Multipart object may be a part within another

Multipart object Key Methods

public void addBodyPart(BodyPart part) public void addBodyPart(BodyPart part, int index) public int getCount() returns the number of BodyPart objects

EMAIL ATTACHMENTS -1 To append an email attachment, you need to send a "multipart" message

Create your MimeMessage object as usual, setting the from address, to address, subject, etc...

Create a MimeBodyPart object for your main message and set its text (or content) to be your message

Create a MimeBodyPart object for your attachment and call its setContent() method to attach your file

Create a Multipart object and add both body parts to it. Call your MimeMessage's setContent() method, passing in your Multipart

object Call Transport.send() to send the message

Whew!!!

EMAIL ATTACHMENT EXAMPLE-1 MimeMessage msg = new MimeMessage(getMailSession()); msg.setFrom(new InternetAddress("bill.gates@msn.com")); msg.addRecipient(Message.RecipientType.TO, new InternetAddress("larry.ellison@oracle.com")); msg.setSubject("RE: Oracle vs SQL Server"); //Create the main message (body) part for text MimeBodyPart mainBodyPart = new MimeBodyPart(); mainBodyPart.setText("Here is my message");

EMAIL ATTACHMENT EXAMPLE-2 //Create attachment body part MimeBodyPart attachBodyPart = new MimeBodyPart(); DataSource source = new FileDataSource("1.jpg"); attachBodyPart.setDataHandler(new DataHandler(source)); attachBodyPart.setFileName("1.jpg"); //Now create the multipart and add the parts Multipart multipart = new MimeMultipart(); multipart.addBodyPart(mainBodyPart); multipart.addBodyPart(attachBodyPart); //add the multipart to the original Mime message msg.setContent(multipart); Transport.send(msg);

Topic : JavaMail API Kaster Nurmukan

AGENDA Overview of JavaMail API Javax.mail.Session Javax.mail.Authenticator and

PasswordAuthentication Javax.mail.Message Javax.mail.Part Javax.mail.Multipart and BodyPart Javax.mail.internet.MimePart • javax.mail.Service • javax.mail.Transport

JAVAMAIL API We are going to cover the following topics in JavaMail API:

• java.mail.Session • javax.mail.Authenticator and PasswordAuthentication • javax.mail.Message • javax.mail.Part • javax.mail.Multipart and BodyPart • javax.mail.internet.MimePart and MimeMessage • javax.mail.internet.MimeMultipart and MimeBodyPart • javax.mail.Service • javax.mail.Transport

JAVAX.MAIL.SESSION Acts as a factory for the installed Transport and

Store implementations. Responsible for managing a user’s mail

configuration settings and handling authentication for the individual services used during the session.

A way to associate providers with a particular set of user properties and an authentication mechanism.

JAVAX.MAIL.SESSION Can be stored as an object in the servlet’s session so

that the appropriate relationship can be maintained. The application will be retrieving the correct Transport

and Store objects based on the current user’s settings by interacting with the session.

Server-side applications will likely be creating a session for each connected client.

JAVAX.MAIL.SESSION CONSTRUCTING A SESSION JavaMail session class does not implement public

constructors. Potential clients are expected to use the one of the

following public static methods to acquire session reference:

• Static Session getInstance (Properties prope, Authenticator authenticator)

//constructs and returns a new unshared Session instance with the specified Properties and Authenticator.

• Static Session getDefaultInstance (Properties prope, Authenticator authenticator)

//returns the default (shared) Session instance.

JAVAX.MAIL.SESSION CONSTRUCTING A SESSION GetInstance () method returns a new instance with each

invocation. getDefaultInstance () repeatedly returns the same instance, as

long as the specified Authenticator is a reference to the same instance passed in when the default session was initially created. useful when developing single-user applications.

JAVAX.MAIL.SESSION CONSTRUCTING A SESSION Java.util.Properties object that is passed into both of

these two methods is usually obtained by invoking the system.getProperties method. JavaMail-specific properties can then be added:

Properties props = system.getProperties (); props.put (“mail.transport.protocol”, “smtp”); props.put (“mail.smtp.host”, “mail.foo.com”); Session session = Session.getInstance (props, null);

JAVAX.MAIL.SESSION SESSION PROPERTIES Mail.transport.protocol the default transport protocol,

implemented by Transport class returned from Session.getTransport ().

Mail.store.protocol the default store protocol, implemented by Store class returned from Session.getStore ().

Mail.host the default host for both Store and Transport protocol.

Mail.user the default user name for both Store and Transport protocol.

Mail.from the user’s return e-mail address Mail.protocol.host the host specific to a particular protocol. Mail.protocol.user the default user name specific to a

particular protocol. Mail. Debug the default debug setting for sessions. This can

be overridden with setDebug (boolean).

JAVAX.MAIL.SESSION SESSION PROPERTIES * Properties getProperties (); //return the properties collection specified when

constructing the session. * String getProperties (string name); //return the value of the specified property or null if it

does not exist. * void setDebug (boolean debug); //set the debug setting for this session. If it set true,

debug massage will be output to the console by both the session and its providers.

* boolean getDebug (); //return the debug setting for this session. Can be used to

determine whether debug message should be output.

PASSWORDAUTHENTICATION

* Javax.mail.passwordAuthentication getPasswordAuthentication ();

//Invoked by a Session when password authentication is needed. Any number of implementations is possible as long as a PasswordAuthentication instance is returned.

* PasswordAuthentication (String username, String password);

//Returning a PasswordAuthentication instance is simple a matter of invoking this constructor. This should be constructed and returned in the client’s implementation of getPasswordAuthentication. 257

JAVAX.MAIL.AUTHENTICATOR AND PASSWORDAUTHENTICATION The Authenicator class also includes several protected

methods that provide access to the typical properties that would enable building a reasonable explicit prompt for the user:

protected String getRequestingProtocol (); protected int getRequestingPort (); protected InetAddress getRequestingSite (); protected String getRequestingPrompt (); protected String getDefaultUserName ();

JAVAX.MAIL.AUTHENTICATOR AND PASSWORDAUTHENTICATION Fully functional Authenticator: Import javax.mail. *; Import javax.swing. *; Public class MyAuthenticator extends Authenticator { public PasswordAuthentication getPasswordAuthentication (); { string password = JOptionPane.showInputDialog ( “Connecting to” + getRequestingProtocol() + “mail service on host” + getRequestingSite() + “, port” + getRequestingPort() + “as user” + getDefaultUserName () + “.\n” + getRequestingPrompt (); if (password == null) return null; else return new PasswordAuthentication (getDefaultUsername(),

password); } }

JAVAX.MAIL.MESSAGE

<interface> Java.mail.part

Javax.mail.Message

Javax.mail.internet.MimeMessage

<interface> Javax.mail.internet.Mimepart

Javax.mail.multipart

Javax.mail.Bodypart

Javax.mail.internet.MimeMultipart

Java.mail.internet.MimeBodypart

JAVAX.MAIL.MESSAGE CONSTRUCTING A MESSAGE Two most common ways for a Message

implementation to be constructed:

• MimeMessage (Session session); //Constructs a new and empty (of headers, content, and

flags) MimeMessage in the specified session. • Message reply (boolean replyToAll); //Returns a new Message with headers suitable to be

used as a reply to this message. The subject is automatically prefixed with the string “Re:”. 261

JAVAX.MAIL.MESSAGE MASSAGE HEADER The source for an internet message: Message-ID: <…> Date: Mon, 29 May 2000 11:40:41 … From: jason@edu.kz To: xxx@edu.kz Subject: … Mime-Version: 1.0 Content-Type: text/plain; charset=ascii Content-Transfer-Encoding: 7bit I have several contact with the outside world… 262

JAVAX.MAIL.MESSAGE MESSAGE HEADERS Original standard for messages is problemetic in sending

arbitrarily sized binary attachments. MIME (Multipurpose Internet Mail Extensions) extends the

capabilities of Internet messages while maintaining compatibility with the previous standard.

JavaMail API exposes the headers as standard getters and setters.

In the most prevelent message formats, the documentation for the Message methods will often refer to the headers that are set or retrieved by its most common subclass, MimeMessage. The Message class, however, was designed as an abstract interface to any possible implementation. 263

JAVAX.MAIL.MESSAGE MESSAGE HEADERS The From: Header • Void setFrom (); //The no parameter form sets the From header to the address

specified in the Session’s mail.user property or if not present, user.name.

• Void setFrom (Address address); //Set the from header to the spedified address by passing an

Address object. • Void addFrom (Address [] addresses); //If multiple address • Address[] getFrom (); //Implemented by a getter, returns an array of the Addresses in

the From header. 264

JAVAX.MAIL.MESSAGE MESSAGE HEADERS The Reply-To: Header • Void setReplyTo (Address[] addresses); //Sets the Reply-To header to the specified addresses.

These addresses are automatically set as recipients when constructing a message using the reply () method.

• Address[] getReplyTo (); //Gets an array of addresses that replies should be sent

to or null if this can not be determined. • The MimeMessage implementation checks for the

existence of a Reply-To header first. 265

JAVAX.MAIL.MESSAGE MESSAGE HEADERS

The To:, Cc; and Bcc: Headers To: normal recipients cc: carbon copied recipients Bcc: blind carbon copied recipients Void setRecipient (Message.RecipientType type, Address address) Void setRecipients (Message.RecipientType type, Address[]

addresses) // Set the To, Cc, or Bcc header to the specified address(es). Void addRecipient (Message.RecipientType type, Address address) //Add the specified address to any of the existing To, Cc, or Bcc

headers. Address[] getRecipients (Message.RecipientType type) or Address[]

getRecipients () // Return the addresses of the recipients.

JAVAX.MAIL.MESSAGE MESSAGE HEADERS The Subject: Header In Message class: void setSubject (string subject) string getSubject () The Date: Header void setSentDate (Date date) Date getSentDate () Date getReceivedDate ()

JAVAX.MAIL.MESSAGE MESSAGE HEADERS Folder and Message Number • Messages that are persisted in some Store are organized into

folders. Each message within a folder is temporarily assigned a unique (within the Folder) number to help identify it to the Store provider.

• Folder getFolder (); //Gets the Folder that contains this Message or null if this is

either a new or nested Message. • Int getMessageNumber (); //Returns the message number corresponding to this message.

JAVAX.MAIL.MESSAGE MESSAGE FLAGS Why Flags? Not all providers support flagging messages but there is a

mechanism by which a client can determine what flags can be set. Some advanced implementations make it possible to set user-defined flags (usually represented as arbitrary strings of the user or user agent’s choosing )on a message.

JAVAX.MAIL.MESSAGE MESSAGE FLAGS Inorder to support both the typical flagging of messages using

the typical static final constants and the user defined flagging using strings, the JavaMail provides a fairly clever approch that centers on the Flags class:

Outer class:Flags acts like a container for these Flag instance as well as for arbitrary String instances.

Inner class:Flag Defines several static instances of itself to represent the standard set of flags.

JAVAX.MAIL.MESSAGE MESSAGE FLAGS In Flag class: Void add (flags.flag flag); //Add the specified system flag. Void add (string flag); //Add the specified user flag. Boolean contains (flags.flag flag); //Test for system flag (flag). Boolean contains (string flag); //Test for user flag (flag). Void remove (flags.flag flag); //… Void remove (string flag); Flag.flag[] getSystemFlags (); String[] getUserFlags (); In Message class: Void setFlag (flags.flag flag, boolean set); //Set or clear individual flag Void setFlags (Flags flag, boolean set); //Set or clear all of the

individual flags in specified flag object (inner class). Some system flags: ANSWERED DELETED DRAFT FLAGGED

RECENT SEEN USER

JAVAX.MAIL.PART This defines the methods used for storing and retrieving the

content of a message or part of one, as in Multipart and MimeMultipart classes.

It also defines the standard properties that both whole messages and body parts have in common.

JAVAX.MAIL.PART ACTIVATION JavaBeans Activation Framework (JAF) is a little known API.

The JavaMail API is one of the few products that make use of the JAF.

What is the main purpose of JAF? After the advent of the MIME extensions, JavaMail leverages

the functionality provided by the JAF in order to provide a simple and consistent interface to any number of disparate data sources. Javax.activation.DataHandler class provides this interface. It is simply a convenient wrapper around some implementation of the javax.activation.DataSource interface. Two useful such implementations, javax.activation.FileDataSource and URLDataSource, are provided by part of the JAF.

JAVAX.MAIL.PART ACTIVATION DataSource and its encapsulating DataHandler can

provide access to the raw bytes of a data type with their getInputStream (), and getOutputStream () methods.

The DataSource is responsible for providing the streams.

The Message implementation uses these streams to transmit and retrieve a part’s content, regardless of what type it really is.

JAVAX.MAIL.PART ACTIVATION A higher and more useful level of abstraction:

getContent () in DataHandler. 1. Return an actual Java instance that can be immediately

downcast to the appropriate Java class. 2. Can be used directly by programmers by invoking

whatever methods available in that class. 3. If the MIME type for the content has a registered

javax.activation.DataContentHandler implementation, an object specific to that type will be returned. Otherwise, in InputStream is returned.

JAVAX.MAIL.PART CONTENT Void setDataHandler (javax.activation.DataHandler dh) //Set the part’s

content to the specified DataHandler. Javax.activation.DataHandler getDataHandler (); //Return the DataHandler for the content. Void setContent (java.lang.object object, string type); //Set the content for this part based on the specified type. Void setText (string text); //Set the content for this part to the specified string with a content type

of ‘text/plain’. Void setContent (multipart mp); //Set the content for this part to the specified Multipart object. The

content will be set to multipart/mixed. Java.lang.Object getContent (); //Return the content for this part, which can be downcast to an

appropriate object based on the content type or InputStream if the content type does not have a registered DataContentHandler.

JAVAX.MAIL.PART CONTENT

One simple example: How to set a part’s content to some plain text: part.setDataHandler (new DataHandler (text, “text/plain”)); or part.setContent (text, “text/plain”); or part.setText (text); Retrieving a part’s content always uses the getContent ()

method. How to retrieve the plain text as a string object: String text = (String) part.getContent ();

JAVAX.MAIL.PART CONTENT If the part’s type were not registered content type, the resulting

object would have been an InputStream that can be used to retrieve the raw bytes of the content.

Example: save unregistered content to disk so that the user can use a separate application to process the data:

object content = part.getContent (); if (content instanceof InputStream) { InputStream is = (InputStream) content; OutputStream os = new FileOutputStream (“content”); int n; byte buffer[] = new byte [1024]; while ( ( n = is.read (buffer) ) > 0) { os.write(buffer, 0, n); } is.close (); }

JAVAX.MAIL.PART PART HEADERS The Part interface exposes the necessary functionality for setting

and retrieving any imaginable header’s value. Like the Message class, if the part is in a modifiable state, the

following methods can modify the part’s headers: void addHeader (String headerName, string headerValue); void setHeader (String headerName, string headerValue); void removeHeader (string headerName); String[] getHeader (string headerName); java.util.Enumeration getAllHeaders (); java.util.Enumeration getMatchingHeaders (sting [] headernames); java.util.Enumeration getNonMatchingHeaders (sting []

headernames); 279

JAVAX.MAIL.PART PART HEADERS A part’s description, disposition, and file name can be

specified using the following methods: void setDescription (string description); void setDisposition (string disposition); //User should use

either one of the Part interface constrains, ATTACHMENT or INLINE.

string getDisposition (); string setFilename (string filename); string getFilename (); Several other methods: int getLineCount (); int getSize (); //Return the size of the part’s content in bytes. void writeTo (OutputStream os); //Write this part to the

specified output stream.

JAVAX.MAIL.MULTIPART AND BODYPART

Multipart messages are composed of one or more body parts.

The abstract Multipart class defines the methods necessary for collecting these body parts.

Each component in a multipart message needs its own set of headers and content. Then BodyPart class needs the functionality exposed by the Part interface.

To, From, Date, Subject, etc, are specified at the message level, not on a part-by-part level.

JAVAX.MAIL.MULTIPART AND BODYPART

Some relative methods: Void addBodyPart (BodyPart part); Void addBodyPart (BodyPart part, int index); Boolean removeBodyPart (BodyPart part); Void removeBodyPart (int index); Int getCount (); //Return the number of body parts

comprising this multipart. BodyPart getBodyPart (int index); String getContentType (); Void setParent (Part parent); //set the parent part Part getParent ();

JAVAX.MAIL.INTERNET.MIMEPART The MimePart interface extends Part with several MIME-specific

methods including some that provide lower-level access to the message headers:

Void setText (string text, string charset) //Set the content for this part to the specified text and encode it using specified charset.

String getEncoding () //Return the value of the Content-Transfer-Encoding header. This header is appropriately set when saveChanged () is invoked on a message containing this part.

String getContentID () //Return the value of the Content-ID. Void setContentLanguage (string[] languages) Void setContentMD5 (string md5) //Set Content-MD5 header, to ensure

that a part’s content has not been altered during transit. 283

JAVAX.MAIL.INTERNET.MIMEPART Some other methods:

String getHeader (string headerName, string delimiter)

//Return all the values for a given header in a single string separated by the specified delimiter.

Enumeration getAllHeaderLines () //Return an enumeration of the raw header lines in the part.

Enumeration getMatchingHeaderLines (string[] names) Enumeration getNonMatchingHeaderLines (string[]

names)

JAVAX.MAIL.INTERNET.MIMEMESSAGE MimeMessage class is the only Sun-provided concrete

implementation of Message. MimeMessage implements all of the abstract methods

defined in Message as well as those defined in both Part and MimePart.

JAVAX.MAIL.INTERNET.MIMEMESSAGE An example: complete application that opens a session, constructs a message, and outputs it

to the screen: import java.io.*; import javax.activation.*; import javax.mail.*; import javax.mail.internet.*; public class MimeMessageExample { // starts here // create a new session instance; MimeMessage message = new MimeMessage (session); message.setFrom (new InternetAddress (jason@injektilo.org)); message.setRecipient (Message.RecipientType.To, new InternetAddress

(craigo@wrox.com)); message.setSubject (“No mail at all”); string text = “I have several contact with the outside world\r\n”+”I have food so don’t

worry\r\n”; message.setText (text); message.saveChanges (); message.writeTo(System.out); }

JAVAX.MAIL.INTERNET.MIMEMULTIPART AND MIMEBODYPART Like MimeMessage, MimeMultipart and MimeBodyPart are the

concrete implementations that most clients will be using when constructing multipart messages.

MimeMultipart introduces some methods as: void setSubType (string subtype); //Sets the subtype of this multipart to

the specified string. This defaults to ‘mixed’. BodyPart getBodypart (string contentID); //Returns the body part with

the specified content ID or null if not found.

JAVAX.MAIL.INTERNET.MIMEMULTIPART AND MIMEBODYPART An example: how a MimeMuiltipart is constructed and given two MimeBodyParts (analogous to ‘attaching’ a file to a message):

import java.io.* … // Import the same classes as previous one. public class MimeMultipartExample { //Start here //Create a new session instance. Message message = new MimeMessage (session); message.setFrom(new InternetAddress (“…@…”)); message.setRecipient (message.RecipientType.To, new InternetAddress

(“…@…”)); message.setSubject (fileName); //Text part BodyPart bodyPart1 = new MimeBodyPart (); bodyPart1.setText (“…”); //File part BodyPart bodyPart2 = new MimeBodyPart (); FileDataSource fileDataSource = new FileDataSource (fileName); //set DataHandler and Filename for bodyPart2

JAVAX.MAIL.INTERNET.MIMEMULTIPART AND MIMEBODYPART Example continued:

multipart multipart = new MimeMultipart (); multipart.addBodyPart (bodyPart1); multipart.addBodyPart (bodyPart2); message.setContent (multipart); message.saveChanges (); message.writeTo (system.out); } //End of the program.

JAVA.MAIL.SERVICE JavaMail API provides an abstraction for two types of services that

sessions can create, Transports and Stores. The behavior common to both was extracted out into an even higher abstraction, the Service.

Behavior common to Transport and Store: Require that a connection be established before messages can be

sent or retrieved . Support some optional authentication mechanism. Services can optionally be identified by a URLName, e.g, a URLName

designating a user’s POP3 account may look like: pop3://username:password@hostname:port. The URLName class represents a string that includes whatever

information necessary in order to make a connection to some server.

JAVA.MAIL.SERVICE Relative methods:

URLName getURLName() Void connect () //Connect to the service using any suitably

available default values for the host, port, and user. Void connect (string host, string user, string password)

//Using specified user and password for authentication. Boolean isConnected () Void close ()

JAVAX.MAIL.TRANSPORT Sending a message is achieved using a Transport. Sun’s

JavaMail implementation comes with a fully functional SMTP transport that could be the only transport provider we need.

Transport class contains two static methods that make sending a message simple:

Static Transport.send (Message message) //Send the message using an appropriate transport for each of the message’s recipients’ address type.

Static Transport.send (Message message, Address[] recipients) // Ignore the message’s recipients and instead sending it to the specified recipients. 292

JAVAX.MAIL.TRANSPORT An example capable of sending a message to any user on the internet: import java.util.*; import java.mail.*; import javax.mail.internet.*; public class TransportSendExample { //Start here // Initialize smtpHost, fromAddress, toAddress. Properties properties = system.getProperties (); properties.put (“mail.smtp.host”, smtpHost); Session session = Session.getInstance (properties, null); MimeMessage message = new MimeMessage (session); //Set From and Recipients for message as we did in the previous example message.setSubject (“Javemail example”); message.setText (“…”); Transport.send (message); }

JAVAX.MAIL.TRANSPORT Five different means by which the correct transport can be constructed and

returned to the user: Transport getTransport () // Return a transport that implements the protocol

specified in the session’s mail.transport protocol property. Transport getTransport (string protocol) // Return a transport implemented by

the specified protocol. Transport getTransport (Address address) // Return a transport capable of

sending a message to the specified address type. Transport getTransport (URLName url) //Return a transport that implements

the protocol as found in the ‘scheme’ part of the specified URL name. Transport getTransport (Provider provider) //Return a transport implemented

by the specified provider.

Topic : JPQL Java Persistence Query Language Kaster Nurmukan

INTRODUCTION • The Java Persistence API specifies a query

language that allows to define queries over entities and their persistent state

• JPQL is an extension of EJB QL • More robust flexible and object-oriented

than SQL • The persistence engine parse the query

string, transform the JPQL to the native SQL before executing it

CREATING QUERIES • Query instances are obtained using:

• EntityManager.createQuery (dynamic query) • EntityManager.createNamedQuery (static query)

• Query API: getResultList() – execute query returning multiple results getSingleResult() – execute query returning single result executeUpdate() – execute bulk update or delete setFirstResult() – set the first result to retrieve setMaxResults() – set the maximum number of results to retrieve setParameter() – bind a value to a named or positional parameter setHint() – apply a vendor-specific hint to the query setFlushMode()– apply a flush mode to the query when it gets run

STATIC (NAMED) QUERIES • Defined statically with the help of @NamedQuery

annotation together with the entity class • @NamedQuery elements:

• name - the name of the query that will be used with the createNamedQuery method

• query – query string

@NamedQuery(name="findAllCustomers",

query="SELECT c FROM Customer")

Query findAllQuery = entityManager.createNamedQuery(“findAllCustomers”); List customers = findAllQuery.getResultList();

MULTIPLE NAMED QUERIES • Multiple named queries can be logically defined with

the help of @NamedQueries annotation

@NamedQueries( {

@NamedQuery(name = “Mobile.selectAllQuery”

query = “SELECT M FROM MOBILEENTITY”),

@NamedQuery(name = “Mobile.deleteAllQuery”

query = “DELETE M FROM MOBILEENTITY”)

NAMED PARAMETERS • Named parameters are parameters in a query

that are prefixed with a colon (:) • To bound parameter to an argument use

method: • Query.setParameter(String name, Object value)

public List findWithName(String name) {

return em.createQuery(

"SELECT c FROM Customer c WHERE c.name LIKE :custName")

.setParameter("custName", name)

.getResultList();

POSITIONAL PARAMETERS • Positional parameters are prefixed with a

question mark (?) followed the numeric position of the parameter in the query

• To set parameter values use method: • Query.setParameter(integer position, Object value)

public List findWithName(String name) {

return em.createQuery(

“SELECT c FROM Customer c WHERE c.name LIKE ?1”)

.setParameter(1, name)

.getResultList();

DYNAMIC QUERIES • Dynamic queries are queries that are defined

directly within an application’s business logic

• Worse efficiency and slower query execution, as the persistence engine has to do all the parsing and validation stuffs, along with mapping the JPQL to the SQL at the run-time

public List findAll(String entityName){

return entityManager.createQuery(

"select e from " + entityName + " e")

.getResultList();

NATIVE QUERIES • Queries may be expressed in native SQL • Support for cases where it is necessary to

use the native SQL of the target database in use

Query q = em.createNativeQuery(

"SELECT o.id, o.quantity, o.item " +

"FROM Order o, Item i " +

"WHERE (o.item = i.id) AND (i.name = 'widget')",

com.acme.Order.class);

•@SqlResultSetMapping annotaton is used for more advanced cases

QUERY OPERATIONS – MULTIPLE RESULTS

• Query.getResultList() will execute a query and may return a List object containing multiple entity instances

• Will return a non-parameterized List object • Can only execute on select statements as

opposed to UPDATE or DELETE statements • For a statement other than SELECT run-time IllegalStateException will be thrown

Query query = entityManager.createQuery(“SELECT C FROM CUSTOMER”);

List<MobileEntity> mobiles = (List<MobileEntity>)query.getResultList();

QUERY OPERATIONS – SINGLE RESULT • A query that returns a single entity object

• If the match wasn’t successful, then EntityNotFoundException is returned

• If more than one matches occur during query execution a run-time exception NonUniqueResultException will be thrown

Query singleSelectQuery = entityManager.createQuery(

“SELECT C FROM CUSTOMER WHERE C.ID = ‘ABC-123’”);

Customer custObj = singleSelectQuery.getSingleResult();

PAGING QUERY RESULTS int maxRecords = 10; int startPosition = 0;

String queryString = “SELECT M FROM MOBILEENTITY”;

while(true){

Query selectQuery = entityManager.createQuery(queryString);

selectQuery.setMaxResults(maxRecords);

selectQuery.setFirstResult(startPosition);

List<MobileEntity> mobiles = entityManager.getResultList(queryString);

if (mobiles.isEmpty()){ break; }

process(mobiles); // process the mobile entities

entityManager.clear(); // detach the mobile objects

startPosition = startPosition + mobiles.size();

FLUSHING QUERY OBJECTS

• Two modes of flushing query objects • AUTO (default) and COMMIT

• AUTO - any changes made to entity objects will be reflected the very next time when a SELECT query is made

• COMMIT - the persistence engine may only update all the state of the entities during the database COMMIT

JPQL STATEMENT LANGUAGE • JPQL statement types:

• SELECT, UPDATE, DELETE • Supported clauses:

• FROM • WHERE • GROUP_BY • HAVING • ORDER BY • …

• Conditional expressions, aggregate functions,…

JPQL ENHANCEMENTS • Simplified query syntax • JOIN operations • Group By and Having Clause • Subqueries • Dynamic queries • Named parameters • Bulk update and delete

OO-STYLE VS. SQL-STYLE QUERIES • The main difference is that you query the

application model, i.e. the entities, rather than any database tables

• Productivity can be increased if OO-style quries, e.g.

employeeXYZ.getManager().getAddress()

are automatically translated by the ORM engine into correct SQL code, e.g.

SELECT t3.* FROM EMP t1, EMP t2, ADDR t3

WHERE t1.EMP_ID = “XYZ” AND t1.MGR_ID = t2.EMP_ID AND t2.ADDR_ID = t3.ADDR_ID

• Notice that the two-step object traversal was packed into a single DB query

RESOUCE

• JPQL Language Reference http://edocs.bea.com/kodo/docs41/full/html/ejb3_langref.html

• JPA Query API http://www.javabeat.net/javabeat/ejb3/articles/2007/04/introduction_to_java_persistence_api_jpa_ejb_3_0_6

• Standardizing Java Persistence with the EJB3 Java Persistence API – Query API http://www.onjava.com/pub/a/onjava/2006/05/17/standardizing-with-ejb3-java-persistence-api.html?page=last&x-showcontent=text

Topic : JPA Criteria API Kaster Nurmukan

AGENDA Powerful Query Capabilities HQL Prototypical Use of Query API Criteria Queries Prototypical Use of Criteria API How to use the JPA Criteria API Examples from simple to complex

POWERFUL QUERY CAPABILITIES ● HQL: The Hibernate Query Language ● object-oriented ● Criteria API ● powerful object model for constructing and executing queries ● Query by Example ● Not locked in: can perform SQL queries, including stored procedure invocations

HQL ● Powerful object-based query language ● Hibernate translates HQL to SQL ● HQL statements are shorter, more readable than their SQL counterparts

PROTOTYPICAL USE OF QUERY API String hql = "from Customer c where c.age > :age"; Query q = session.createQuery(); q.setInteger("age", 33); q.setFirstResult(20); q.setMaxResults(10); // fetch the third page List customers = q.list(hql);

CRITERIA QUERIES ● What makes the Criteria API powerful is that it allows queries to be specified by composition. ● This means that queries can be constructed dynamically.

PROTOTYPICAL USE OF CRITERIA API Criteria c = session.createCriteria(Customer.class); c.add( Restrictions.ilike("name", "Albert%") ); c.addOrder( Order.asc("age") ); c.setMaxResults(20); c.list(); // entire sequence of calls can also be chained, // like so: session.createCriteria(Customer.class). add( Restrictions.ilike("name", "Albert%") ). addOrder( Order.asc("age") ). setMaxResults(20). list();

THE NEW PROBLEM JPQL CAN’T,BUT JPA CRITERIA API CAN? JQL seems like a great way to leverage your existing

SQL knowledge no compile time checking JPA Criteria API quiet a productivity drain with

developers having to correct, compile and redeploy to continue.

HOW TO USE THE JPA CRITIERA API

CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery cqry = em.createQuery();

A SIMPLE CRITERIAQUERY EXAMPLE

CriteriaBuilder cb = em.getCriteriaBuilder(); //Step 1

CriteriaQuery cqry = em.createQuery(); //Step 1 //Interesting stuff happens here Root<MyEntity> root = cqry.from(MyEntity.class); //Step 2 cqry.select(root); Step 3 …. Query qry = em.createQuery(cqry); //Step 6 List<MyEnity> results = qry.getResultList(); //Step 6

EXAMPLE CONTINUE… Root<MyEntity> root = cqry.from(MyEntity.class); //Step 2 cqry.select(root); //Step 3 Predicate pGtAge = cb.gt(root.get("age"),10); //Step 4 cqry.where(pGtAge); //Step 5

Root<MyEnity> root = cqry.from(MyEntity.class); //Step 2 cqry.select(root); //Step 3 Predicate pGtAge = cb.gt(root.get("age"),10); //Step 4 Predicate pGtDateCreated= cb.greaterThan(root.get("dateCreated"),date); //Step 4 Predicate pAnd = cb.and(pGtDateCreated,pGtAge); //Step 4

cqry.where(pAnd); //Step 5

USING META MODEL CLASSES IN QUERY

//assume we have created a date object for 2011-07-01 //called date Root<MyEnity> root = cqry.from(MyEntity.class); //Step 2 cqry.select(root); //Step 3 Predicate pGtAge = cb.gt(root.get(MyEntity_.age),10); //Step 4 Predicate pGtDateCreated= cb.greaterThan(root.get(MyEntity_.dateCreated),date); //Step 4 Predicate pAnd = cb.and(pGtDateCreated,pGtAge); //Step 4 cqry.where(pAnd); //Step 5

CRITERIA QUERY USING JOINS Root<MyEnity> root = cqry.from(MyEntity.class); //Step 2 Join<MyEntity,AnotherEntity> join = root.join(MyEntity_.anotherEntity); //Step 2 //Join<MyEntity,AnotherEntity> join = root.join("anotherEntity"); //Step 2 cqry.select(root); //Step 3 Predicate pGtAge = cb.gt(root.get(MyEntity_.age),10); //Step 4 Predicate pGtDateCreated= cb.greaterThan(root.get(MyEntity_.dateCreated),date); //Step 4 Predicate pEqEnabled = cb.equals(join.get(AnotherEntity_.enabled),false); Predicate pAnd = cb.and(pGtDateCreated,pGtAge,pEqEnabled); //Step 4 cqry.where(pAnd); //Step 5

MORE COMPLEX SELECT CLAUSE Root<MyEnity> root = cqry.from(MyEntity.class); //Step 2 cqry.select(root.get(MyEntity_.dateCreated)); //Step 3 If we wanted to use an aggregate function and get the minimum dateCreated we

could use something like: Root<MyEnity> root = cqry.from(MyEntity.class); //Step 2 Expression min = cb.min(root.get(MyEntity_.dateCreated));//Step3 cqry.select(min); //Step 3

REFERENCE http://www.oracle.com http://www.jumpingbean.co.za/blogs/jpa2-criteria-api

Topic : JNDI Kaster Nurmukan

AGENDA What is JNDI? Naming and Directory Services Naming Concepts Issues JNDI Architecture Programming with JNDI Role of JNDI in J2EE

332 (c)CDAC(Formerly NCST)

Class.forName("com.microsoft.jdbc. sqlserver.SQLServerDriver");

cnn = DriverManager.getConnection ("jdbc:microsoft:sqlserver://siddh ant:1433",“username",“password");

Context ctx = new InitialContext(); DataSource ds = (DataSource)ctx.lookup(“myname”); Connection con = ds.getConnection(“abc”,”***”);

JNDI Java Naming and Directory Interface (JNDI) provides a

standard interface for Java applications to access naming and directory services.

NAMING SERVICE Naming Service performs: – Binding: Associating names with objects – Lookup: Find an object based on a name. • Examples: DNS and File systems Examples: – DNS – Filesystems

DIRECTORY SERVICE Directory is a naming service that stores objects with attributes. – Usernames and passwords etc stored in attrs. Tree like structure

NAMES Atomic name is a indivisible component of a name – in /etc/fstab, etc and fstab are atomic names. Compound name is zero or more atomic names put together. – /etc/fstab is a compound name

BINDING Binding is an association of a name with an

object. – Filename “autoexec.bat” has a binding to

some file data on the disk. – “c:\windows” foldername is bound to a

folder on your drive. Compound name such as

/usr/people/ed/.cshrc consists of multiple bindings, one to usr,

one to people, one to ed, and one to .cshrc.

CONTEXT Contains zero or more bindings. – Each binding has a distinct atomic name. /etc contains files named mtab and exports. The /etc folder is a context containing

bindings with atomic names mtab and exports.

mtab and exports are each bound to a file on the disk.

SUB-CONTEXT

/usr – CONTEXT – /usr/people – SUB-CONTEXT – /usr/bin – SUB-CONTEXT – /usr/local – SUB-CONTEXT Each atomic name is bound to a sub-context the

subfolder. Subcontext are full-fledged contexts Can contain more name-object bindings, such as

other files or other folders.

NAMING SYSTEM AND NAMESPACES Naming system: A connected set of contexts. Namespace: all the names contained within that naming system.

INITIALCONTEXT Starting point for exploring a namespace. Starting point for performing all naming and directory operations.

ISSUES Many naming and directory products. – Netscape Directory Server – MicrosoftActiveDirectory Various naming and directory protocols:

Each directory standard has a different protocol

for accessing the directory. – Lightweight Directory Access Protocol

(LDAP) – Network Information System (NIS) – Novell’s Network Directory System (NDS)

EDS h i’ API

INTRODUCING JNDI Standard interface to interact with naming and directory systems. For Java programs. Provides common interface to disparate directories: Same API for LDAP and NIS NDS. Used in EJB, RMI-IIOP, JDBC for operations

like locating entities i.e. Users, Machines (e.g.

printer), Objects, Services (e.g. datasource) etc.

JNDI ARCHITECTURE

The client API – Allow Java code to perform directory operations. The Service Provider: Driver The Service Provider Interface (SPI) – An interface to which naming and

directory service vendors can plug in.

JNDI PACKAGES The JNDI comprises of 5 packages javax.naming – Contains classes and

interfaces for accessing naming services javax.naming.directory – Extends

javax.naming and provides functionality to access directory services in addition to naming services

JNDI PACKAGES javax.naming.event – Classes and

interfaces for supporting event notification in naming and directory services

javax.naming.ldap – Classes and interfaces for using features that are specific to LDAP v3 that are not already covered by the more generic javax.naming.directory

javax.naming.spi – Vendors develop their naming/directory services conforming to SPI. Applications can then access these services through the JNDI API

INITIALCONTEXTFACTORY Used to acquire an initial context Implementation of the JNDI driver: Knows

the specific semantics of a particular directory structure. bootstrapping. Necessary information for JNDI to acquire

that initial context. – The IP address of the J2EE server – The port number that the J2EE server

accepts – Any username/password necessary to use

javax.naming.Context ctx = new javax.naming.InitialContext (System.getProperties()); java -Djava.naming.factory.initial= com.sun.jndi.fscontext.RefFSContextFactory -Djava.naming.provider.url= file:c:\examples.InitCtx class of the JNDI driver provider URL: URL that the service provider accepts for bootstrapping.

OTHER JNDI OPERATIONS Methods invoked on a Context list() - list of contents available at the

context. – names of objects bound to the JNDI tree – subcontexts. lookup() - look up objects bound to the JNDI

tree – Return type is driver specific • RMI-IIOP java.rmi.Remote • file system java.io.File

rename() - give a new name to a context – c:\temp to c:\tmp createSubcontext() - create a subcontext at the context – c:\foo\bar at the folder c:\foo. destroySubcontext() - destroy a subcontext of

the context – Destroy c:\foo\bar from the folder c:\foo. bind() – associates a name to a content and

stores it at the Context – JNDI drivers accept different parameters to

bind() rebind() - forces a bind even if some object is

BINDING import javax.naming.*; public class Startup { public static void main(String args[]) throws

Exception { AccountImpl acct_impl = new AccountImpl(); Context ctx = new InitialContext

(System.getProperties()); ctx.rebind(“myname", acct_impl); } }

LOOKING UP import javax.naming.*; import java.rmi.*; public class Client { public static void main (String[] args) throws

Exception { Context ctx = new InitialContext (System.getProperties());

Object remoteObject = ctx.lookup(“myname"); Account account = (Account) javax.rmi.PortableRemoteObject.narrow ( remoteObject, Account.class); int b = account.method1(5));}}

ROLE OF JNDI IN J2EE J2EE servers have a JNDI implementation. Used to Look up beans. Connect to resource factories – JDBC DataSource – Java Message Service (JMS) drivers Acquiring a reference to the Java Transaction API’s (JTA) UserTransaction interface.

REFERENCES Mastering Enterprise JavaBeans by Ed Roman et. al. (Wiley) JNDI Tutorial on java.sun.com Java Server Programming J2EE Edition – Volume 1 – Wrox. Java Enterprise in a nutshell – David Flanagan et. Al. – O’reilly

Topic : EJB Kaster Nurmukan

ENTERPRISE JAVA BEANS (EJB)

EJB GOALS Standard component architecture for building

distributed business applications in Java Interoperability between enterprise beans and

other Java Platform Enterprise Edition components, as well as non-Java applications

Compatible with other Java APIs and with CORBA protocols

Follow the Write Once, Run Anywhere philosophy of Java - an enterprise bean can be developed once and then deployed on multiple platforms without recompilation or source code modification

Define the “contracts” that enable tools from multiple vendors to develop and deploy components that can interoperate at runtime

REPRISE: 3-TIERED ARCHITECTURE

Client

Database

Component middleware

Application logic components

Back-end tier

Middle tier

Front-end tier

LDAP Database

Client

Database

Back-end tier

Middle tier

Front-end tier

LDAP Database

EJB 3-TIERED ARCHITECTURE

Client

Database

Back-end tier

Middle tier

Front-end tier

LDAP Database

Application server

JAVA EE 3-TIER ARCHITECTURE

EJBS AS COMPONENTS Enterprise Java Beans are components that provide

middle-tier business logic And interact heavily with the data layer of the

application EJB framework conforms to and at the same time

induces a 3-tier architecture for distributed applications

EJB AS COMPONENT MODEL FRAMEWORK

Programming model Standardized interfaces Runtime environment Built-in component services (persistence, transactions,

security, etc.) Meta-data Deployment facilities

EJB SPECIFICATION EJB is an open specification - any vendor can develop a

runtime environment that complies with the specification

EJB code intended to be portable across brands (assuming uses only services defined by the spec, not additional vendor facilities)

EJB specs have evolved: Originated with IBM 1997 Later adopted by Sun (1.0 1998, 1.1 1999) Enhanced under Java community process (2.0 2001,

2.1 2003, 3.0 2006) EJB 3.0 is a major departure from earlier versions, but

backwards compatible (old code works with 3.0 but not vice versa)

ENTERPRISE BEANS Body of code with fields and methods Encapsulates business data or business logic that

operates on the enterprise’s data Instances are created and managed at runtime by a

Container (application server) Client access is mediated by the bean instance’s

Container - isolates the bean from direct access by client applications (and other beans)

ENTERPRISE BEAN PORTABILITY If an enterprise bean uses only the services defined by the EJB specification (and not additional facilities peculiar to the vendor), the bean can be deployed in any compliant EJB Container

Can be included in an assembled application without requiring source code changes or recompilation

Component services information, such as a transaction and security attributes, are separate from the enterprise bean class - this allows the services information to be managed by tools during application assembly and deployment

Can be customized at deployment time by editing the bean’s environment entries and/or deployment descriptor

EJB CONTAINER Manages every aspect of an enterprise bean at runtime

and implements component services When a client application invokes a method on an

enterprise bean, the container first intercepts the invocation to ensure persistence, transactions and access control are applied properly to every operation a client performs on the bean

An enterprise bean cannot function outside of an EJB container

EJB CONTAINER

RESOURCE MANAGEMENT Containers manage many beans simultaneously To reduce memory consumption and processing,

containers pool resources When a bean is not being used, a container may

place it in a pool to be reused by another client Or evict it from memory (passivate) and only bring

it back (activate) when its needed While its reference on the client remains intact When the client invokes a method on the reference,

the container re-incarnates the bean to service the request

BUSINESS DATA AND METHODS An entity bean (aka persistence entity)

represents persistent business data stored in one row of a database table, and may add behavior specific to that data - but the methods are often just getters, setters and finders

Session beans implement business processes and interact with clients

Message-driven beans combine features of a session bean and a message listener, allowing a business component to receive messages (and event notifications) asynchronously

BUSINESS INTERFACES A “business interface” is required for both session and

message-driven beans (and for entities prior to EJB 3.0) The business interface of a message-driven bean is

defined by the messaging type used (typically MessageListener), not by the developer

MULTIPLE INTERFACES If a bean class implements only a single interface (not counting

standard interfaces such as java.io.Serializable or any of the javax.ejb interfaces), it is deemed the “business interface” and is by default a local interface unless designated by a @Remote annotation

A bean class may have multiple interfaces, but one or more must be designated as a business interface by either a @Local or @Remote annotation

Remote business interfaces support remote clients running on a different JVM or machine, to which the bean’s location is transparent

If there are only local interfaces, all clients must run in the same JVM as the bean, and the location of the bean is not transparent 375

EXAMPLE @Stateless @Remote public class CalculatorBean implements Calculator { public float add (int a, int b) { return a + b; } public float subtract (int a, int b) { return a - b; } } public interface Calculator { public float add (int a, int b); public float subtract (int a, int b); }

REMOTE AND LOCAL INTERFACES To allow remote access, must decorate the business interface with

the @Remote annotation @Remote public interface InterfaceName { ... }

OR decorate the bean class with @Remote, specifying the business interface(s) @Remote(InterfaceName.class) public class BeanName

implements InterfaceName { ... } To build an enterprise bean that allows only local access,

optionally annotate the business interface of the enterprise bean as @Local @Local public interface InterfaceName { ... }

OR specify the interface by decorating the bean class with @Local and specify the interface name @Local(InterfaceName.class) public class BeanName

implements InterfaceName { ... }

ENTERPRISE BEANS AS DISTRIBUTED OBJECTS Business interfaces are types of Java RMI

Remote interfaces The java.rmi.Remote interface is used by

distributed objects to represent the bean in a different address space (process or machine)

An enterprise bean class is instantiated and lives in its container but can be accessed by client applications that live in other address spaces, using skeletons and stubs implemented by the container

STUBS AND SKELETONS

September 16, 2010

S W4156

DECIDING ON LOCAL VS. REMOTE: COUPLING Tightly coupled beans depend on one another For example, if a session bean that processes sales

orders calls a session bean that emails a confirmation message to the customer, these beans are tightly coupled

Tightly coupled beans are good candidates for local access

Because they fit together as a logical unit, they typically call each other often and would benefit from the increased performance that is possible with local access

DECIDING ON LOCAL VS. REMOTE: TYPE OF CLIENT

If an enterprise bean is accessed by application clients, then it should allow remote access

In a production environment, these clients almost always run on different machines than the Application Server

If an enterprise bean’s clients are web components or other enterprise beans, then the type of access depends on how you want to distribute your components

DECIDING ON LOCAL VS. REMOTE: COMPONENT DISTRIBUTION

Java EE applications are scalable because their server-side components can be distributed across multiple machines

In a distributed application, the web components may run on a different server than do the enterprise beans they access

Then the enterprise beans should allow remote access

PERFORMANCE

Due to factors such as network latency, remote calls are often slower than local calls

On the other hand, if you distribute components among different servers, you may improve the application’s overall performance

Actual performance can vary in different operational environments

DECIDING ON LOCAL VS. REMOTE If you aren’t sure which type of access an

enterprise bean should have, choose remote access, which gives more flexibility

In the future you can distribute your components to accommodate the growing demands on your application

It is possible for an enterprise bean to allow both remote and local access through different interfaces (the same business interface cannot be both a local and remote business interface)

SESSION BEANS

SESSION BEAN Represents a single client (at a time) inside the

Application Server Client invokes the session bean’s methods to execute

business tasks When the client terminates, the session bean appears to

have terminated and is no longer associated with the client

STATEFUL VS. STATELESS There are two basic kinds of session bean:

Stateless and Stateful Stateful session beans encapsulate business

logic and state specific to a client Stateful beans are called "stateful" because they

maintain conversational state between method invocations

The state is held in instance variables (in memory) and is not persistent across executions

The state disappears when the client removes the bean or terminates

STATEFUL SESSION BEANS To conserve resources, stateful session beans may be

passivated when not in use by the client Passivation means the bean's conversational-state is

written to secondary storage (disk) and the instance is removed from memory

If the client removes the bean or terminates, the session ends and the state disappears

The client's reference to the bean is not affected by passivation: it remains alive and usable while the bean is passivated

When the client invokes a method on a bean that is passivated, the container will activate the bean by instantiating a new instance and populating its conversational-state with the state previously written to secondary storage

STATELESS VS. STATEFUL Stateless session beans are made up of

business methods that behave like functions: they operate only on the arguments passed to them when they are invoked (but can lookup state in a database or file)

Stateless beans are called "stateless" because they are transient - they do not maintain a conversational state between method invocations

The bean’s instance variables may contain a state specific to the client during a single method invocation, but not retained when the method is finished

STATELESS SESSION BEANS Each invocation of a stateless business method is

independent from previous invocations Because stateless session beans are "stateless" they

tend to process requests faster and use less resources All instances are equivalent – the EJB container can

assign a pooled stateless bean instance to any client, improving scalability

September 16, 2010

S W4156

SESSION BEAN INTERFACES A client can access a session bean only through

the methods in the bean’s business interface Can have more than one business interface A business interface can be either local or

remote (or web service) Not required to implement any lifecycle

methods, but may optionally do so and annotate as such (prior to EJB 3.0, all enterprise beans had to implement a “home” interface with lifecycle methods)

LIFECYCLE METHODS The actual methods can have any names @PostConstruct: The container immediately calls

the annotated method after a bean instance is instantiated

@Init: Designates initialization methods for a stateful session bean

@PrePassivate: Called before the container passivates a stateful bean instance

@PostActivate: Called when a re-activated stateful bean instance is ready

@Remove: Informs the container to remove the bean instance from the object pool after the method executes (not actually a callback)

@PreDestroy: Called before the container destroys an unused or expired bean instance from its object pool

LIFECYCLE OF A STATEFUL SESSION BEAN Client initiates the lifecycle by obtaining a reference Container invokes the @PostConstruct and @Init

methods, if any Now bean ready for client to invoke business methods

LIFECYCLE OF A STATEFUL SESSION BEAN While in ready state, container may passivate and

invoke the @PrePassivate method, if any If a client then invokes a business method, the

container invokes the @PostActivate method, if any, and it returns to ready stage

LIFECYCLE OF A STATEFUL SESSION BEAN At the end of the life cycle, the client invokes a method

annotated @Remove The container calls the @PreDestroy method, if any

LIFECYCLE OF A STATELESS SESSION BEAN A client initiates the life cycle by obtaining a reference The container invokes the @PostConstruct method, if

any The bean is now ready to have its business methods

invoked by clients

LIFECYCLE OF A STATELESS SESSION BEAN Because a stateless session bean is never passivated, its

life cycle has only two stages: nonexistent and ready for the invocation of business methods.

At the end of the life cycle, the container calls the @PreDestroy method, if any

ENTITY BEANS

ENTITY BEANS Called entity beans < EJB 3.0, persistence

entities (or just entities) >= EJB 3.0 Provides an object view of data in the database

An entity class represents a table in a relational database

An entity instance represents a row in that table Uses the Java Persistence API Annotated with @Entity

ENTITY BEANS An entity bean provides an object view of data in

the database Allows shared access from multiple users Can be long-lived (as long as data in the database) Persistent

The entity and its remote reference survive a crash of the EJB Container

If the state of an entity was being updated by a transaction at the time the container crashed, the entity’s state is automatically reset to the state of the last committed transaction

An application program can create an entity bean, then be stopped and restarted, and again find the entity bean it was working with - and continue using the same entity bean 400

INSTANCE VARIABLES Persistent instance variables can only be accessed

through the entity class’ methods Must only be serializable types (so they can be stored in

a database) Object/relational mapping must be defined An entity may include non-persistent instance

variables, annotated as @Transient

ENTITY BEANS ARE IDENTIFIED BY A PRIMARY KEY Entity Beans must have a primary key that

uniquely identifies it Used to locate the bean’s data in some

underlying database For example, an “employee” entity bean may

have a Social Security number as primary key You can only use entity beans when your

objects have a unique identifier field, or when you can add such a field (or set of fields)

PRIMARY KEYS May be either simple or composite Simple primary keys annotated @Id Composite primary keys defined by a primary

key class, annotated @IdClass The simple primary key, or each field of a

composite primary key, must be a Java primitive type, string or date

EntityManager.find method used to look up entities by primary key, returns reference to the one specific entity bean (exception if not found)

QUERIES Other finder methods defined using SQL-like queries in Java Persistence Query Language, return a collection of entities that match the request

EntityManager.createQuery method used to create dynamic queries defined within business logic public List findWithName(String name) { return em.createQuery( "SELECT c FROM Customer c WHERE c.name LIKE :custName")

.setParameter("custName", name) .setMaxResults(10) .getResultList(); }

QUERIES EntityManager.createNamedQuery method used to create static queries defined in annotation metadata @NamedQuery( name="findAllCustomersWithName", query="SELECT c FROM Customer c WHERE c.name LIKE :custName"

) customers = em.createNamedQuery("findAllCustomersWithName")

.setParameter("custName", "Smith") .getResultList();

MANAGING ENTITIES An Entity Manager is associated with a

persistence context corresponding to a particular data store

State of persistent entities automatically synchronized to the database when the associated transaction commits

But business logic for transactions resides in session or message-driven beans

Both Container-Managed Entity Managers (automatic) and Application-Managed Entity Managers

CONTAINER-MANAGED TRANSACTIONS Container sets the boundaries of transactions,

cannot use operations like commit or rollback within code

Container begins transaction immediately before enterprise bean method starts and commits just before method exits

Transaction types: Required, RequiresNew, Mandatory, NotSupported, Supports, Never

TRANSACTIONAL ATTRIBUTES Required - If the client is running within a transaction and invokes the

enterprise bean's method, the method executes within the client's transaction. If the client is not associated with a transaction, the container starts a new transaction before running the method.

RequiresNew - If the client is running within a transaction and invokes the enterprise bean's method, the container suspends the client's transaction, starts a new transaction, delegates the call to the method, resumes the client's transaction after the method completes; if the client is not associated with a transaction, the container starts a new transaction before running the method.

NotSupported - If the client is running within a transaction and invokes the enterprise bean's method, the container suspends the client's transaction before invoking the method; after the method has completed, the container resumes the client's transaction.

Supports - If the client is running within a transaction and invokes the enterprise bean's method, the method executes within the client's transaction; if the client is not associated with a transaction, the container does not start a new transaction before running the method

Mandatory - If the client is running within a transaction and invokes the enterprise bean's method, the method executes within the client's transaction; if the client is not associated with a transaction, the container throws the TransactionRequiredException.

Never - If the client is running within a transaction and invokes the enterprise bean's method, the container throws a RemoteException

APPLICATION-MANAGED TRANSACTIONS The code in the session or message-driven bean

explicitly marks the boundaries of the transaction Useful for implementing multiple transactions within a

single method or transactions than span multiple methods

Can use either Java Database Connectivity (JDBC) or the Java Transaction API (JTA)

A JTA transaction can span updates to multiple databases from different vendors managed by the Java Transaction Service, but cannot support nested transactions

JTA supplies begin, commit and rollback methods 409

USING TRANSACTIONS IN SESSION BEANS A stateless session bean with bean-managed

transactions must commit or rollback before returning

A stateful session bean using JTA transactions retains its association with a transaction across multiple client calls, even if the database connection is opened and closed

A stateful session bean using JDBC transactions loses its transaction association if the connection is closed

SAVING A SESSION BEAN’S STATE IN A DATABASE Transactions normally concerned with

synchronizing the state of persistent entities to databases

Optional for a stateful session bean to receive transaction synchronization notifications to also store its own data in a database

Then must implement the SessionSynchronization interface, supplying afterBegin, beforeCompletion and afterCompletion methods

MESSAGE-DRIVEN BEAN(MDB)

GOALS Be able to produce messages from the EJB server Be able to consume messages within the EJB

server Be able to define timers within EJB server

v131202

Asynchronous EJB

OBJECTIVES EJB JMS Producers EJB JMS Consumers (Message Driven Beans;

MDBs) Asynchronous Methods EJB Timers

v131202

Asynchronous EJB

EJB JMS PRODUCERS Obtain Resources

ConnectionFactory Destination

Create Session integrate with JTA transaction

Publish Message

v131202

Asynchronous EJB

OBTAINING A CONNECTIONFACTORY Using annotations

@Stateless

public class SellerEJB ... {

@Resource(mappedName=“java:/JmsXA")

private ConnectionFactory connFactory;

mappedName points to global JNDI name benefits

concise & simple

drawbacks mixes deployment concepts with Java code

v131202

Asynchronous EJB

OBTAINING A CONNECTIONFACTORY (CONT.) Using ejb-jar.xml

<ejb-name>SellerEJB</ejb-name>

<resource-ref>

<res-ref-name>jms/ConnectionFactory</res-ref-name>

<res-type>javax.jms.ConnectionFactory</res-type>

<mapped-name>java:/JmsXA</mapped-name>

<injection-target>

<injection-target-class>

ejava.examples.asyncmarket.ejb.SellerEJB

</injection-target-class>

<injection-target-name>

connFactory

</injection-target-name>

</injection-target>

</resource-ref>

mappedName moved away from code to DD factory injected into EJB ejb-jar xml is no longer vendor/deployment-neutral

v131202

Asynchronous EJB

OBTAINING A CONNECTIONFACTORY (CONT.) Using jboss-ejb3.xml

<ejb-name>SellerEJB</ejb-name>

<resource-ref>

<res-ref-name>jms/ConnectionFactory</res-ref-name>

<jndi-name>java:/JmsXA</jndi-name>

</resource-ref>

</session>

mappedName is now removed

replaced with vendor/deployment specific reference Required 3 files to complete

v131202

Asynchronous EJB

v111128 Asynchronous EJB 419

OBTAINING A DESTINATION Using annotations

@Stateless

public class SellerEJB implements SellerLocal, SellerRemote {

@Resource(mappedName="java:/topic/ejava/examples/asyncMarket/topic1",

type=Topic.class)

private Destination sellTopic;

mappedName points to global JNDI entry benefits

concise and simple drawbacks

mixes deployment properties with implementation

v131202

Asynchronous EJB

OBTAINING A DESTINATION (CONT.) Using ejb-jar.xml

<resource-env-ref>

<resource-env-ref-name>jms/sellTopic</resource-env-ref-name>

<resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>

<mapped-name>topic/ejava/examples/asyncMarket/topic</mapped-name>

<injection-target>

<injection-target-class>

ejava.examples.asyncmarket.ejb.SellerEJB

</injection-target-class>

<injection-target-name>sellTopic</injection-target-name>

</injection-target>

</resource-env-ref>

mappedName moved away from Java and to DD note resource-env-ref used for Destinations

v131202

Asynchronous EJB

GETTING A SESSION @TransactionAttribute(TransactionAttributeType.REQUIRED)

public long sellProduct(String sellerId, AuctionItem item)

throws MarketException {

Connection connection = null;

Session session = null;

connection = connFactory.createConnection();

session = connection.createSession(false,

Session.AUTO_ACKNOWLEDGE);

catch (JMSException ex) {

log.error("error publishing sell", ex);

ctx.setRollbackOnly();

throw new EJBException("error publishing sell:" + ex);

finally {

if (session != null) { session.close(); }

if (connection != null) { connection.close(); }

} catch (JMSException ex) {

v131202

Asynchronous EJB

INTEGRATING JMS INTO THE TRANSACTION Person seller = sellerDAO.getPersonByUserId(sellerId); seller.getItems().add(item);

item.setOwner(seller);

auctionItemDAO.createItem(item);

publishForSale(session, item);

return item.getId();

v131202

Asynchronous EJB

PUBLISHING THE MESSAGE protected void publishForSale(Session session, AuctionItem item) throws JMSException {

MessageProducer producer = null;

producer = session.createProducer(sellTopic);

MapMessage message = session.createMapMessage();

message.setJMSType("forSale");

message.setLong("id", item.getId());

message.setString("name", item.getName());

message.setString("seller", item.getOwner().getUserId());

message.setLong("startDate", item.getStartDate().getTime());

message.setLong("endDate", item.getEndDate().getTime());

message.setDouble("minBid", item.getMinBid());

message.setDouble("bids", item.getBids().size());

message.setDouble("highestBid",

(item.getHighestBid() == null ? 0.00 :

item.getHighestBid().getAmount()));

producer.send(message);

finally {

v131202

Asynchronous EJB

EJB JMS CONSUMERS; MDBS “Message Driven Bean” Introduced in EJB 2.0 to support JMS providers Extended in EJB 2.1 to support non-JMS

message providers using the Java EE Connector API

commonly called JCA EJB 3.0 added @Annotation support for

configuration Java EE Providers

must support a JMS provider must support external providers through JCA

Session and Entity Beans cannot be a MessageListener can poll for messages with

MessageConsumer receive()

v131202

Asynchronous EJB

MESSAGEDRIVEN BEAN CONFIGURATION Destination Type Destination Selector Message Acknowledgement ...

v131202

Asynchronous EJB

MDB CONFIGURATION Using annotations

@MessageDriven(name="BuyerMDB", activationConfig={

@ActivationConfigProperty(

propertyName="destinationType",

propertyValue="javax.jms.Topic"),

propertyName="destination",

propertyValue="topic/ejava/.../topic1"),

propertyName="messageSelector",

propertyValue=

"JMSType in ('forSale', 'saleUpdate')"),

propertyName="acknowledgeMode",

propertyValue="Auto-acknowledge")

public class BuyerMDB implements MessageListener {

v131202

Asynchronous EJB

MDB CONFIGURATION (CONT.) Using ejb-jar.xml

<message-driven>

<ejb-name>BuyerMDB</ejb-name>

<ejb-class>ejava.examples.asyncmarket.ejb.BuyerMDB</ejb-class>

<message-destination-type>

javax.jms.Topic

</message-destination-type>

<activation-config>

<activation-config-property>

<activation-config-property-name>

</activation-config-property-name>

<activation-config-property-value>

</activation-config-property-value>

</activation-config-property>

</activation-config>

v131202

Asynchronous EJB

MDB CONFIGURATION (CONT.) Using jboss.xml

<message-driven>

<ejb-name>BuyerMDB</ejb-name>

<destination-jndi-name>

topic/ejava/examples/asyncMarket/topic1

</destination-jndi-name>

Asynchronous EJB

v111128 429

MDB STRUCTURE @MessageDriven(name="BuyerMDB", activationConfig={ ... })

public class BuyerMDB implements MessageListener {

@PostConstruct

public void init() { ... }

public void onMessage(Message message) {

log.debug("onMessage:" + message.getJMSMessageID());

MapMessage auctionMsg = (MapMessage)message;

long itemId = auctionMsg.getLong("id");

processAuctionItem(itemId);

catch (Exception ex) {

log.error("error processing message", ex);

MDB AND TRANSACTIONS SUPPORTED

message receipt/acknowledgement integrated with overall transaction

NOT_SUPPORTED message receipt/acknowledgement independent of

transactions within processing

Asynchronous EJB

v111128 431

ASYNCHRONOUS METHODS • Scenario

– Task(s) may take considerable time to complete – Client need not wait for them to complete

• @javax.ejb.Asynchronous – Return control to the client before EJB is invoked – Any session bean business method may be made

@Asynchronous* (*see Serialization note below) • null return type

– Client and issued task fully decoupled from one another • java.util.concurrent.Future return type

– Allows task and client to coordinate a future return value – Client returns instance of javax.ejb.AsyncResult – Not Serializable (i.e., cannot use directly with RMI client)

SYNCHRONOUS EXAMPLE: CLIENT EJB @Stateless

public class AuctionMgmtEJB implements AuctionMgmtRemote, AuctionMgmtLocal { private @EJB AuctionMgmtActionEJB actions;

public void workSync(int count, long delay) {

DateFormat df = new SimpleDateFormat("HH:mm:ss.SSS");

long startTime = System.currentTimeMillis();

for (int i=0; i<count; i++) {

log.info(String.format("%s issuing sync request, delay=%d",

df.format(new Date()), delay));

Date date= actions.doWorkSync(delay);

log.info(String.format("sync waitTime=%d msecs",

System.currentTimeMillis()-startTime));

long syncTime = System.currentTimeMillis() - startTime;

log.info(String.format("workSync time=%d msecs", syncTime));

SYNCHRONOUS EXAMPLE: HELPER EJB @Stateless

public class AuctionMgmtActionEJB {

public Date doWorkSync(long delay) {

log.debug(String.format("sync method %d starting %d delay at %s",

Thread.currentThread().getId(), delay, df.format(new Date())));

try { Thread.sleep(delay); }

catch (Exception ex) { ... }

Date now = new Date();

log.debug(String.format("sync method %d completed %d delay at %s",

Thread.currentThread().getId(), delay, df.format(now)));

return now;

SYNCHRONOUS EXAMPLE: RESULTS 11:06:44,624 INFO [AuctionMgmtEJB:306] 11:06:44.612 issuing sync request, delay=3000 11:06:44,626 DEBUG [AuctionMgmtActionEJB:24] sync method 163 starting 3000 delay at 11:06:44.626 11:06:47,628 DEBUG [AuctionMgmtActionEJB:30] sync method 163 completed 3000 delay at 11:06:47,630 INFO [AuctionMgmtEJB:309] sync waitTime=3018 msecs 11:06:47,631 INFO [AuctionMgmtEJB:306] 11:06:47.631 issuing sync request, delay=3000 11:06:47,634 DEBUG [AuctionMgmtActionEJB:24] sync method 163 starting 3000 delay at 11:06:47.634 11:06:50,636 DEBUG [AuctionMgmtActionEJB:30] sync method 163 completed 3000 delay at 11:06:50,637 INFO [AuctionMgmtEJB:309] sync waitTime=6025 msecs 11:06:50,637 INFO [AuctionMgmtEJB:306] 11:06:50.637 issuing sync request, delay=3000 11:06:50,638 DEBUG [AuctionMgmtActionEJB:24] sync method 163 starting 3000 delay at 11:06:50.638 11:06:53,640 DEBUG [AuctionMgmtActionEJB:30] sync method 163 completed 3000 delay at 11:06:53.640 11:06:53,641 INFO [AuctionMgmtEJB:309] sync waitTime=9029 msecs 11:06:53 642 INFO [AuctionMgmtEJB:312] workSync time=9030 msecs

ASYNCHRONOUS EXAMPLE: CLIENT EJB @Stateless

public class AuctionMgmtEJB implements AuctionMgmtRemote, AuctionMgmtLocal {

public void workAsync(int count, long delay) {

long startTime = System.currentTimeMillis();

List<Future<Date>> results = new ArrayList<Future<Date>>();

for (int i=0; i<count; i++) {

log.info(String.format("%s issuing async request,

delay=%d", df.format(new Date()), delay));

Future<Date> date = actions.doWorkAsync(delay);

results.add(date);

log.info(String.format("async waitTime=%d msecs",

System.currentTimeMillis()-startTime));

for (Future<Date> f: results) {

log.info(String.format("%s getting async response",

df.format(new Date())));

try { Date date = f.get(); } catch (Exception ex) {

throw new EJBException("unexpected error in future get():"+ex);}

ASYNCHRONOUS EXAMPLE: HELPER EJB @Stateless

public class AuctionMgmtActionEJB {

@javax.ejb.Asynchronous

public java.util.concurrent.Future<Date> doWorkAsync(long delay) {

log.debug(String.format("async method %d starting %d delay at %s",

Thread.currentThread().getId(), delay, df.format(new Date())));

try { Thread.sleep(delay); }

catch (Exception ex) { ... }

Date now = new Date();

log.debug(String.format("async method %d completed %d delay at %s",

Thread.currentThread().getId(), delay, df.format(now)));

return new javax.ejb.AsyncResult<Date>(now);

ASYNCHRONOUS EXAMPLE: RESULTS 11:06:53,650 INFO [AuctionMgmtEJB:325] 11:06:53.650 issuing async request, delay=3000 11:06:53,658 INFO [AuctionMgmtEJB:328] async waitTime=8 msecs 11:06:53,659 INFO [AuctionMgmtEJB:325] 11:06:53.659 issuing async request, delay=3000 11:06:53,659 DEBUG [AuctionMgmtActionEJB:41] async method 166 starting 3000 delay at 11:06:53.659 11:06:53,668 DEBUG [AuctionMgmtActionEJB:41] async method 167 starting 3000 delay at 11:06:53.668 11:06:53,668 INFO [AuctionMgmtEJB:328] async waitTime=18 msecs 11:06:53,669 INFO [AuctionMgmtEJB:325] 11:06:53.669 issuing async request, delay=3000 11:06:53,670 INFO [AuctionMgmtEJB:328] async waitTime=20 msecs 11:06:53,670 DEBUG [AuctionMgmtActionEJB:41] async method 168 starting 3000 delay at 11:06:53.670 11:06:53,671 INFO [AuctionMgmtEJB:331] 11:06:53.671 getting async response 11:06:56,667 DEBUG [AuctionMgmtActionEJB:47] async method 166 completed 3000 delay at 11:06:56,669 DEBUG [AuctionMgmtActionEJB:47] async method 167 completed 3000 delay at 11:06:56,669 INFO [AuctionMgmtEJB:339] 11:06:56.669 got async response 11:06:56 670 INFO [AuctionMgmtEJB:331] 11:06:56 670 getting async response

EJB TIMERS Performs similar role of job schedulers

“cron” Two types

Single-action createTimer(Date expiration, Serializable info) fires once at or after a specific time in the future

createTimer(long duration, Serializable info) fires once after a specific delay period

Interval-timer createTimer(Date intialExpiration, long intervalDuration, Serializable info) continually fires every intervalDuration after the

initialExpiration time createTimer(long initialDuration, long intervalDuration, Serializable info) continually fires every intervalDuration after the

initialDuration delay

v131202

Asynchronous EJB

EJB TIMERS Original EJB Timer Service part of EJB 2.1 EJB 3.0 added annotation-based extensions that

eliminated inheritance-based solution requirements

EJB 3.1 provided an overhaul of the overall service Added declarative scheduling

@javax.ejb.ScheduleExpression @javax.ejb.Schedule

DECLARATIVE CALENDAR TIMER @Schedule(second="*/10", minute ="*", hour="*",

dayOfMonth="*", month="*", year="*”, persistent=false)

public void execute(Timer timer) {

log.info("timer fired:" + timer);

checkAuction();

log.error("error checking auction", ex);

PROGRAMMATIC CALENDAR TIMER ScheduleExpression schedule = new ScheduleExpression();

schedule.second("*/10");

schedule.minute("*");

schedule.hour("*");

schedule.dayOfMonth("*");

schedule.month("*");

schedule.year("*");

auctionMgmt.initTimers(schedule);

public void initTimers(ScheduleExpression schedule) {

cancelTimers();

log.debug("initializing timers, schedule="+schedule);

timerService.createCalendarTimer(schedule);

@Timeout

checkAuction();

PROGRAMMATIC INTERVAL TIMER auctionMgmt.initTimers(10*1000);

public void initTimers(long delay) {

cancelTimers();

log.debug("initializing timers, checkItemInterval="+delay);

timerService.createTimer(0,delay, "checkAuctionTimer");

@Timeout

checkAuction();

log.error("error checking auction", ex);

EJB TIMERS Accessing TimerService

Using Annotations @Resource private TimerService timerService;

Getting Timers timerService.getTimers()

Cancelling Timers for (Timer timer :

(Collection<Timer>)timerService.getTimers()) {

timer.cancel();

Timers associated with the EJB that created them are automatically integrated into JTA transaction 444

EJB TIMER CALLBACKS Using annotations

public class AuctionMgmtEJB ... @Timeout public void execute(Timer timer) { try { checkAuction(); } catch (Exception ex) { log.error("error checking auction", ex); } }

Using interfaces public class AuctionMgmtEJB implements TimedObject, ...

public void ejbTimeout(Timer timer) { ... } }

JAVAX.EJB.TIMERSERVICE public interface javax.ejb.TimerService{

javax.ejb.Timer createTimer(long, java.io.Serializable) throws ...;

javax.ejb.Timer createSingleActionTimer(long, javax.ejb.TimerConfig)

throws ...;

javax.ejb.Timer createTimer(long, long, java.io.Serializable) throws ...;

javax.ejb.Timer createIntervalTimer(long, long, javax.ejb.TimerConfig)

throws ...;

javax.ejb.Timer createTimer(java.util.Date, java.io.Serializable) throws ...;

javax.ejb.Timer createSingleActionTimer(java.util.Date, javax.ejb.TimerConfig)

throws ...;

javax.ejb.Timer createTimer(java.util.Date, long, java.io.Serializable)

throws ...;

javax.ejb.Timer createIntervalTimer(java.util.Date, long,javax.ejb.TimerConfig)

throws ...;

javax.ejb.Timer createCalendarTimer(javax.ejb.ScheduleExpression) throws ...;

javax.ejb.Timer createCalendarTimer(javax.ejb.ScheduleExpression,

javax.ejb.TimerConfig) throws ...;

java util Collection getTimers() throws ;

SUMMARY EJB JMS Publishers

integrates into Session and MDB processing EJB JMS Subscriber

implemented using MDB MDBs support more than JMS using JCA

Asynchronous Methods EJB Timers

schedule re-activation of Session Bean Single-action and interval

v131202

Asynchronous EJB

REFERENCES Java Messaging Service API

http://java.sun.com/javaee/5/docs/api/javax/jms/package-summary.html

“Enterprise JavaBeans 3.0, 5th Edition”; Burke & Monsen-Haefel; ISBN 0-596-00978-X; O'Reilly

java EE - Taner ERKAN

Documents

Erkan Konutları SATILIK

Alcohol Taner Clayton

Onur Erkan Architectural Portfolio

X-XIII yy Halep Taner Atmaca

DR. TANER ÇELİK UZMANLIK TEZİ

Airline View - THY - Erkan Arkay

Nejat Murat Erkan Dinamikler 2016

Taner Erkan Java 2 lecture Ders notları

Gorkem Erkan Hybrid Database Technology

Erkan Eğitim Kurumları

bir düşün insanı : Ahmet Taner Kışlalı

Sınavizyon 6 Designer: Taner Darılmaz

Etimolojik turkce sozluk erkan kiraz

BÖLÜM İÇ KONTROL Erkan KARAARSLAN

TANER AKYOL TRIO | DERYA’S SONGBOOK · Text und Musik: Taner Akyol (2015/2019) ... Prinzip des Remixes zu einem Pop-Song gekommen und Taner Akyol und Antonis Anissegos treuer an

Taner Džon

Parallel C3M1 Aylin Tokuç Erkan Okuyan Özlem Gür Aylin Tokuç Erkan Okuyan Özlem Gür

Taner Erkan Java 1 praktika Ders notları - Kopya

Taner Karaman 2007

MySQL Replikation - doag.org · MySQL Replikation Erkan Yanar erkan.yanar@linsenraum.de linsenraum.de linsenraum.de 19.11.2013 Erkan Yanar erkan.yanar@linsenraum.delinsenraum.de(linsenraum.deMySQL