J2EE. Enterprise Architecture Styles: Two-Tier Architectures:

Transcription

1 J2EE J2EE is a unified standard for distributed applications through a component-based application model. It is a specification, not a product. There is a reference implementation available from Sun. We have a programming model, i. e. an API and an application infrastructure to support applications built using the APIs. Some design keywords for the J2EE specification: Programming productivity Reliability and Availability Security Scalability Integration Enterprise Architecture Styles: Two-Tier Architectures: The client do all work and the server just acts as a dataprovider. Application Db J2EE 21 February J2EE 21 February

2 Three-Tier architecture A three-tier application is described in the terms of presentation layer, business layer and data layer. The presentation layer is the user interface, i. e. usually some graphical presentation of the application. The middle tier (application logic) basically retrieves, processes and sends data. The data layer is the source of information. This can be database, an XML document a directory services like LDAP. User interface n-tier application An n-tier architecture is divided by function rather than physically. We can have a user interface, e. g. a browser that handles interaction, a presentation logic that defines what should be displayed, a business logic that models the data, an infrastructure services that supports the application with messagins, transaction etc and a datalayer that holds the data. The MVC-pattern is an n-tier architecture. An enterprise architecture is an n-tier application with multiple application objects. These communicate through a welldefined interface, also known as a contract. Application logic LDAP Db XML doc J2EE 21 February J2EE 21 February

3 So J2EE is A set of Java extension APIs to build applications. These APIs define a programming model for J2EE applications. A run-time infrastructure for hosting and managing applications. This is the server runtime in which your application reside. This is known as containers. The APIs in J2EE 1.4 are JDBC 2.0 Optional package Enterprise JavaBeans (EJB) 2.1 Java Servlets 2.4 JavaServer Pages (JSP) 2.0 Java Message Service (JMS) 1.0 Java Transaction API (JTA) 1.0 JavaMail 1.2 JavaBeans Activation Framework (JAF) 1.0 Java API for XML Parsing (JAXP) 1.1 The Java Connector Architecture (JCA) 1.0 Java Authentication and Authorization Service (JAAS) 1.0 In addition the following J2SE APIs are also needed Java Interface Definition Language (IDL) API JDBC Core API RMI/RMI-IIOP API JNDI API J2EE 21 February J2EE 21 February

4 An application is built from application components, each with its own deployment descriptor. An application component is built from servlets, JSP pages, EJB s etc. The deployment descriptor is an XML-file that describes the applications. The container provides: Component contracts. A set of APIs specified by the container that your application component extend or implement. Container service APIs. Additional services provided by the container, which are required for all application components. Declarative services. Services that the container interposes on your applications, based on the deployment descriptor, such as security, transactions etc. Other container services. Services related to component lifecycle, resource pooling, garbage collection etc. The J2EE container is conceptually remote to your client. Therefore you cannot directly access anything in the container. You have to use the contracts specified by J2EE. As an example a servlet is required to extend the javax.servlet.http.httpservlet class and to implement certain methods of this class, such as doget or dopost. An EJB have to have a javax.ejb.ejbhome and javax.ejb.ejbobject interfaces specified. J2EE 21 February J2EE 21 February

5 An application component can access container service APIs via special objects within the container. For example to send a message through JMS to a message queue, you use container methods to get access to the a connection and to a queue. Declarative services are things specified outside the application components. These are called deployment descriptors. It is the contract between the container and the application component. Typical examples are security. J2EE 21 February J2EE 21 February

6 Other container services: Lifecycle managment of application components. Resource pooling. Populating the JNDI namespace. Clustering of JVMs to enhance scalability. J2EE Technologies can be divided into Component technologies. These includes JSP, Servlets and EJBs Service Technologies. These includes JDBC, JNDI, JavaMail etc. Communication Technologies. These includes HTTP, TCP/IP, SSL/TSL RMI, RMI-IIOP and JavaIDL. J2EE 21 February J2EE 21 February

7 Directory Services and JNDI A Naming service is a service that enables the creation of a standard name for a given set of data. For example is given the name tomcat.it.uu.se. A directory service is a special type of database that is optimized for read access by using various indexing, caching, and disk access techniques. The information in a directory service is described using a hierachical information model. Examples of directory services are NIS/NIS+, Windows NT Domains, NDS These are different and cannot easily communicate. JNDI is a Java Naming and Directory service. By using Java, the system will be transportable and can communicate with other Java services. LDAP, Lightweight Directory Access Protocol is a standard directory developed in the early 1990 s. LDAP is widely spread and can be accessed using JNDI. In this way JNDI can access non-java LDAP directories. LDAP defines how clients should access data on the server. It does not, however, specify how the data should be stored on the server. J2EE 21 February J2EE 21 February

8 The JNDI API is part of standard Java but to use it we need a Service Provider. A service provider is a set of classes that allows us to communicate with a directory service. Its plays the same role as JDBC do in database connections. One example of a JNDI service provides is rmiregistry that we used to lookup RMI services. Another example are the DNS service provider. As an example of an JNDI usage we will use a DNS provider to search DNS for some features of a system. To use JNDI you first need to create an InitialDir- Context object that set up the search. It should have a parameter describing the service provider and another describing the server. Both should be stored as name/value pairs in a Hashtable. After doing that we can setup a query and perform a search. J2EE 21 February J2EE 21 February

9 import java.util.hashtable; import java.util.enumeration; import javax.naming.*; import javax.naming.directory.*; public class JNDISearchDNS { public static void main(string args[]) { //Hashtable for environmental information Hashtable env = new Hashtable(); //Specify which class to use for our JNDI provider env.put( java.naming.factory.initial, com.sun.jndi.dns.dnscontextfactory ); env.put( java.naming.provider.url, dns:// / ); String dns_attributes[] = { MX, A, HINFO ; //Get a reference to a directory context if (attrs1 == null) { System.out.println( host has none of the specified attributes\n ); else { for (int z = 0; z < dns_attributes.length; z++) { Attribute attr = attrs1.get(dns_attributes[z]); if (attr!= null) { System.out.print(dns_attributes[z]+ : ); for (Enumeration vals = attr.getall(); vals.hasmoreelements();) { System.out.println(vals.nextElement()); System.out.println( \n ); catch(exception e) { e.printstacktrace(); System.exit(1); DirContext ctx = new InitialDirContext(env); Attributes attrs1 = ctx.getattributes(args[0], dns_attributes); J2EE 21 February J2EE 21 February

10 Note that JNDI is used in J2EE but doesn t require J2EE. When I run this I get java JNDISearchDNS rackarberget.it.uu.se MX: 0 aun.it.uu.se. A: HINFO: Sun SunOS5 JavaMail Prerequisites for JavaMail is the JavaMail API, mail.jar, and the JavaBean Activation Framework (JAF), activation.jar. These are part of J2EE but can also be separately downloaded from To have them found automatically you can put them in the jre/lib/ext catalogue in your J2SE installation hierarchy. or java JNDISearchDNS MX: 10 mx10.gnu.org. 20 mx20.gnu.org. 30 mx30.gnu.org. A: J2EE 21 February J2EE 21 February

11 How mail works Sending client Receiving client Javamail is able to send mail via an SMTP-server and to read mail from a server via either POP3 or IMAP. It can handle attachments of different kind. SMTP POP or IMAP Sending server Receiving server J2EE 21 February J2EE 21 February

12 A simple example that sends a mail import javax.mail.*; import javax.mail.internet.*; import java.util.*; public class MailUtil { public static void sendmail(string to, String from, String subject, String messagetext) throws MessagingException { // get a mailsession, replace localhost // with your mail server, eg mail.it.uu.se Properties props = new Properties(); props.put( mail.smtp.host, localhost ); Session session = Session.getDefaultInstance(props); // create a message MimeMessage message = new MimeMessage(session); message.setsubject(subject); message.settext(messagetext); // address the message InternetAddress fromaddress = new InternetAddress(from); InternetAddress toaddress = new InternetAddress(to); message.setfrom(fromaddress); message.setrecipient( Message.RecipientType.TO, toaddress); // send the message Transport.send(message); public static void main(string [] args) { sendmail( olle, olle, testing, test ); catch (Exception e) { System.out.println(e); J2EE 21 February J2EE 21 February

13 javac -classpath.:/it/sw/java/j2sdkee/current/lib/j2ee.jar MailUtil.java java -classpath.:/it/sw/java/j2sdkee/current/lib/j2ee.jar MailUtil pine Date: Tue, 2 Mar :12: (MET) From: Olle Eriksson <olle@csd.uu.se> To: olle@csd.uu.se Subject: testing test The Java Messaging Service (JMS). The JMS API provides interfaces for applications to create, send, receive, and read messages using any implementation conforming to the API The service is asynchronous and reliable. We have either a point-to-point or publish/subscribe domain. A Point-to-Point is based on queues. Queues are persistent stores in the JMS domain. This means that we require the J2EE runtime support. Each message has a single consumer. There can be several consumers attached to a queue but one and only one consumer will consume a message. Sending and receiving is not time dependent. The consumer must acknowledge receipt of the message. A publish/subscribe model is based on messages that are published on a certain topic. A consumer can then subscribe to any topic. J2EE 21 February J2EE 21 February

14 JMS building blocks An example import javax.jms.*; import javax.naming.*; Connection factory Connection Message producer Session Message consumer Queue Message Queue public class SimpleProducer { /** * Main method. * args the destination used by the * example its type, and, optionally, * the number of messages to send */ public static void main(string[] args) { final int NUM_MSGS; if ( (args.length < 2) (args.length > 3) ) { System.out.println( "Program takes two or three arguments: " + "<dest_name> <queue topic> " + "[<number-of-messages>"); System.exit(1); String destname = new String(args[0]); String desttype = new String(args[1]); System.out.println("Destination name is " + destname + ", type is " + desttype); if (args.length == 3){ NUM_MSGS = (new Integer(args[2])).intValue(); J2EE 21 February J2EE 21 February

15 else { NUM_MSGS = 1; /* * Create a JNDI API InitialContext object if none * exists yet. */ Context jndicontext = null; jndicontext = new InitialContext(); catch (NamingException e) { System.out.println( "Could not create JNDI API " + "context: " + e.tostring()); System.exit(1); if (desttype.equals("queue")) { dest = (Queue) jndicontext.lookup(destname); else if (desttype.equals("topic")) { dest = (Topic) jndicontext.lookup(destname); else { throw new Exception( "Invalid destination type" + "; must be queue or topic"); catch (Exception e) { System.out.println( "JNDI API lookup failed: " + e.tostring()); e.printstacktrace(); System.exit(1); /* * Look up connection factory and destination. * if either does not exist, exit. If you look up a * TopicConnectionFactory instead of a * QueueConnectionFactory, *program behavior is the same. */ ConnectionFactory connectionfactory = null; Destination dest = null; connectionfactory = (ConnectionFactory) jndicontext.lookup( "jms/queueconnectionfactory"); /* * Create connection. * Create session from connection; * false means session is * not transacted. * Create producer and text message. * Send messages, varying text slightly. * Send end-of-messages message. * Finally, close connection. */ Connection connection = null; MessageProducer producer = null; J2EE 21 February J2EE 21 February

16 connection = connectionfactory.createconnection(); Session session = connection.createsession( false, Session.AUTO_ACKNOWLEDGE); producer = session.createproducer(dest); TextMessage message = session.createtextmessage(); for (int i = 0; i < NUM_MSGS; i++) { message.settext("this is message " + (i + 1)); System.out.println("Sending message: " + message.gettext()); producer.send(message); /** Send a non-text control message * indicating end of messages. */ producer.send(session.createmessage()); catch (JMSException e) { System.out.println("Exception occurred: " + e.tostring()); finally { if (connection!= null) { connection.close(); catch (JMSException e) { And a receiver import javax.jms.*; import javax.naming.*; public class SimpleSynchConsumer { /** * Main method. * args the destination name and type * used by the example */ public static void main(string[] args) { String destname = null; String desttype = null; Context jndicontext = null; ConnectionFactory connectionfactory = null; Connection connection = null; Session session = null; Destination dest = null; MessageConsumer consumer = null; TextMessage message = null; if (args.length!= 2) { System.out.println( "Program takes two arguments: " + "<dest_name> <queue topic>"); System.exit(1); destname = new String(args[0]); desttype = new String(args[1]); J2EE 21 February J2EE 21 February

17 System.out.println("Destination name is " + destname + ", type is " + desttype); /* * Create a JNDI API InitialContext object if none * exists yet. */ jndicontext = new InitialContext(); catch (NamingException e) { System.out.println( "Could not create JNDI API " + "context: " + e.tostring()); System.exit(1); /* * Look up connection factory and destination. * If either does not exist, exit. If you look up a * TopicConnectionFactory instead of a * QueueConnectionFactory, program behavior * is the same. */ connectionfactory = (ConnectionFactory) jndicontext.lookup( "jms/queueconnectionfactory"); if (desttype.equals("queue")) { dest = (Queue) jndicontext.lookup(destname); else if (desttype.equals("topic")) { dest = (Topic) jndicontext.lookup(destname); else { throw new Exception( "Invalid destination type" + "; must be queue or topic"); catch (Exception e) { System.out.println( "JNDI API lookup failed: " + e.tostring()); System.exit(1); /* * Create connection. * Create session from connection; false means * session is not transacted. * Create consumer, then start message delivery. * Receive all text messages from destination * until a non-text message is received * indicating end of message stream. * Close connection. */ connection = connectionfactory.createconnection(); session = connection.createsession(false, Session.AUTO_ACKNOWLEDGE); consumer = session.createconsumer(dest); connection.start(); while (true) { Message m = consumer.receive(1); if (m!= null) { J2EE 21 February J2EE 21 February

18 if (m instanceof TextMessage) { message = (TextMessage) m; System.out.println( "Reading message: " + message.gettext()); else { break; catch (JMSException e) { System.out.println("Exception occurred: " + e.tostring()); finally { if (connection!= null) { connection.close(); catch (JMSException e) { To run this you first compile and build this. Then you start a JMS provider in the J2EE server, it is of type jms/connectionfactory. Then you need to create a queue called Physical- Queue. Then you map this with the JNDI name jms/queue. After that you can run your clients. J2EE 21 February J2EE 21 February

19 You can also do this inside the J2EE container. To do this you use message beans. J2EE server Client queue EJB cont. MDB An MDB is a kind of Listener that is connected to a queue. When a message arrives, a handler is executed in the MDB. J2EE 21 February