Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Extensible Storage Engine wikipedia , lookup
Relational model wikipedia , lookup
Concurrency control wikipedia , lookup
Microsoft SQL Server wikipedia , lookup
Microsoft Jet Database Engine wikipedia , lookup
Open Database Connectivity wikipedia , lookup
Database model wikipedia , lookup
Clusterpoint wikipedia , lookup
J2EE Technologies and Distributed Multi-Tiered Application Development Presented by Steven Reagan, Jijun Lu, Marwan Sleiman, Wangang Xie Semester Project CSE333 – Distributed Component Systems (Spring 2004) Instructor Prof. Steven A. Demurjian Department of Computer Science and Engineering University of Connecticut [email protected] [email protected] [email protected] [email protected] J2EE--1 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan) Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--2 Introduction Java is widely used in academia as well as in industry. Developers are more concerned about the speed & security of their applications as they are deployed over the internet, J2EE provides the necessary tools and technologies to facilitate their work. The J2EE platform offers a multi-tiered distributed application model. We will present J2EE as a multi-tier solution for applications. A database application will be studied. Different alternatives in our prototype will be compared. J2EE--3 Why J2EE? Java is free. Java is portable: Platform independent and enables compressible executable jar files. Java is reusable: using past code in current problems is time saving. J2EE has powerful technologies: Java Server Pages (JSPs) Java Servlet JDBC Enterprise JavaBeans (EJBs) Java Messaging Server (JMS) Java Secure Socket Extension (JSSE) J2EE--4 Motivation – Why Multi-Tier? Benefits of Multi-Tier Deployment. Portable and platform independent. Better flexibility for scaling-up and scaling-out. Lower deployment cost on a controlled server than deploying software on all the user terminals. Possibility of securing deployments using firewalls and/or secure connections. Easier to troubleshoot and localize errors. Filters overload (undesired traffic) from the clients on the servers. Filters abnormal access to the server. J2EE--5 Our Prototype architecture Direct JDBC Middle Tier HTTP Server Sockets HTTP JDBC Servlet JMS JDBC Database JDBC JMS Client (Application/Browser) J2EE Middle Tier J2EE--6 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan) Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--7 Sockets (API) host or A socket is an interface between server app layer and transport layer process sends/receives messages to/from its socket socket analogous to door process sending process shoves socket message out door TCP with sending process assumes transport infrastructure on other buffers, variables side of door which brings message to socket at receiving process host or server controlled by app developer process socket Internet TCP with buffers, variables controlled by OS API: (1) choice of transport protocol; (2) ability to implement encryption. J2EE--8 The Socket Technology We implemented the socket programming with TCP because it is connection oriented and provides a reliable point-to-point communication channel that client-server applications can use to communicate with each other. TCP socket connections are setup in the following way: 1. A server has a server socket, bound to a specific port number to listen for any client willing to make a connection. 2. Knowing the hostname and port number, the client sends a connection request to the server. 3. The server accepts the connection and gets a new socket bound to a new port. 4. A socket is created on the client and communication begins. J2EE--9 Patterns - Tiers Client Tier Requests different sizes of files from the database ( 1k to 8M ) Contains TCP Client Socket Connects with the middle-tier Communicates the database request and result via HashMap over the Socket Calculates the response time for each file request Middle – Tier Contains the Server Socket Gets the database command from the Client Socket Connects to the MySQL databse server. Returns the SQL results to the client. Handles multiple Client connection by using multithreading. Database Tier Contains the MySQL server. J2EE--10 Experiments done Different sizes of database files: 1k to 8M Different numbers of clients. Data 1 Client 5 Clients 10 Clients 20 Clients 30 Clients 1K 141 251 254 224 320 2K 120 151 129 149 142 8K 191 140 132 157 151 16K 190 179 135 168 143 32K 201 188 138 176 170 256K 240 244 267 341 200 512K, 262 481 570 661 649 1M 400 790 895 1443 2121 4M 971 2914 4481 7172 9563 8M 1682 5320 5876 Out of Memory Out of Memory J2EE--11 Graph: Average Response Time (ms) 12000 10000 1 Client 8000 5 Clients 6000 10 Clients 20 Clients 4000 30 Clients 2000 8M 4M 1M 25 6K 51 2K , 32 K 16 K 8K 2K 1K 0 J2EE--12 Evaluation of the results. We remark that, for small file sizes (1k to 8k), the response time decreases as the file size increases. This unusual behavior is the result of the overhead of the initial handshaking when the connection is established. System limitations on the middle-tier/server sides caused the program to crash: A typical Dell workstation (P4, 2.6 GHz, 1GB RAM) was unable to support more than 30 concurrent socket connections. As we increased the memory size of the machines used, bigger files we exchanged without memory overflow. J2EE--13 Socket Security consideration JSSE provides us with SSLSocket , and SSLServer Socket classes, which are extensions to the classical Socket , and Server Socket. They add a layer of security protections over the underlying TCP network transport protocol. Those protections include: Integrity Protection. SSL protects against modification of messages by intruders. Authentication. In most modes, SSL provides peer authentication. Confidentiality (Privacy Protection). In most modes, SSL encrypts the data sent between client and server. J2EE--14 Socket Security consideration SSL protocol overview: TCP/IP Protocol Stack With SSL TCP/IP Layer Protocol Application Layer HTTP, NNTP, Telnet, FTP, etc. Secure Sockets Layer SSL Transport Layer TCP Internet Layer IP The SSL Process/Handshaking: Negotiate the cipher suite. Authenticate identity (optional). Establish information security by agreeing on encryption mechanisms J2EE--15 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan). Java Sockets (Marwan). Middle-tier architecture (Steven) Java Servlets (Steven). Java Message Service (JMS) (Jijun). Java Database Connectivity (Wangang). Comparison of the four methods (Wangang). Conclusion. J2EE--16 Middle Tier Communication A Middle Tier Application defines a public API accessible to all Clients. A Client application remotely access any available public method. The Client must be able communicate: The remote method to invoke. The arguments for the remote method. The return value(s) expected. Thus, we need an interface to facilitate this notion of remote method invocation. RMI does this already! However, it is typically only used for communication between standalone client and server applications. – Separate plugin required for each client to communicate with a Servlet Middle Tier. J2EE--17 Middle Tier Communication (cont’d) We established a simple interface for Client/Middle Tier communication. Used for each Middle Tier implementation for consistency. A Table (Object) is always transmitted between the Client and Middle Tier Applications. Client to Middle Tier Table Contains: – String – Remote Method Name. – Object[] – Remote Method Parameters. Middle Tier to Client Table Contains: – Object – Return Value. – Exception – Any Exception thrown by the Middle Tier or Remote Method. Method Invoked using the Java Reflection API: – Method method = this.getClass().getDeclaredMethod(name, types); – Object result = method.invoke(this, args); J2EE--18 Middle Tier Communication (cont’d) A consistent model has been chosen for our Middle Tier architecture. Conceptually, each implementation consists of four files. Client Side: Client.java – Test Program. – Constant for each implementation (Does not change). Database.java – “Artificial Database”. – Appears to Client programmers as the Database. – Handles communication to and from the Middle Tier. – Specific for each Middle Tier choice (Sockets, HTTP). Server Side: MiddleTier.java – Middle Tier Application. – Handles communication from and to the Client. – Specific for each implementation. Database.java – JDBC Wrapper. – Constant for each implementation (Does not change). J2EE--19 Middle Tier Communication (cont’d) Client.java Database db = new Database(); File = db.getFile(“filename”); Database.java … public void addFile(String filename, byte[] data) throws SQLException { … } Public File getFile(String filename) throws SQLException { table.put(“name”, “getFile”); table.put(“args”, new Object[] {filename}); sendRequestToMiddleTier(table); } Client Side MiddleTier.java … public requestMade(Table table) { Method method = this.getClass().getDeclaredMethod(table.get(“name”), table.get(“argTypes”); Object result = method.invoke(this, args); sendResponse(result); } public File getFile(String filename) throws SQLException { return database.getFile(filename); } Server Side Database.java … public File getFile(String filename) throws SQLException { PreparedStatement ps = connection.prepareStatemnt(“SELECT Data FROM file WHERE Name = ?”); … return file; } J2EE--20 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan). Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--21 Servlets Java program that runs within a web server (Apache Tomcat, Sun One Server, JBoss, …) Typically small in size. Receive/Respond to requests made from web clients over HTTP (Hyper Text Transfer Protocol). Dynamic User-Oriented Content. Server-Side. Middle Tier Solutions. Many benefits. J2EE--22 Servlet (cont’d) Four Methods Commonly Implemented. doGet – HTTP GET. doPost – HTTP Post. init – Beginning of Servlet Life Cycle. destroy – End of Servlet Life Cycle. Life Cycle Controlled by the web container where the Servlet was deployed. Upon request the following steps are performed: 1. If the Servlet instance does not exists, the web container: – Loads the Servlet class and creates an instance.. – Initializes the Servlet (init method). 2. Invokes the service method passing in request/response objects. If the web container needs to remove the Servlet, the Servlet’s destroy method is called. J2EE--23 Dynamic Content Earliest Attempts: Applets: Focused on Client platform for dynamic experience. Advantages: – Rich User Interfaces. Disadvantages: – Must be downloaded by the Client. – Slow! CGI scripts: Dynamic Content generated on Server Side. Advantages: – May be written in many languages (C, C++, Perl, …) – Faster than applets (Server Side). Disadvantages: – Platform Dependence. J2EE--24 Dynamic Content (cont’d) Benefits of the Servlet: Portable. Run on any J2EE supported Server. Simplified Deployment. Standard Packaging. – Single Web Application Archive (WAR) file. Fast. Server Side. Servlet instances persist across client requests. – No need for the Server to constantly be spawning new processes. J2EE--25 Example Todays Date: protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("Todays Date: " + new Date() + "<br>"); } J2EE--26 Middle Tier By definition, a Middle Tier Implements a request/response programming model. Servlets fit the request/response paradigm! Natural choice for web service developers. Requests and Responses are made over HTTP. Any Serializeable object may be sent or received via HTTP. Thus, any Client or Web Service that can communicate over HTTP may access a Middle Tier’s set of API methods. Java Desktop Applications. HTML documents. Java Web Services. J2EE--27 Middle Tier (cont’d) Client (Browser) HTTP Client (Application) JDBC HTTP Java Servlet Database Web Service HTTP J2EE--28 Middle Tier (cont’d) Benefits: Servlet is a Java Program written in the Java Programming language. Access to entire set of Java APIs. Portable (Write Once Run Anywhere). Java VM manages Servlets. – Little Concern about Memory Leaks or Garbage Collection. Resource pooling (Database connections). Simplified Deployment. Run on any J2EE enable web server. Standard Packaging. – Single Web Application Archive (WAR) file. Servlet instances can persist Across multiple clients. Minimal external processes. J2EE--29 Performance Three Tier Architecture: Tier 1: Client Tier. Tier 2: Servlet Middle Tier. Tier 3: Database Backend. Request Response Times: Single Client. Retrieval of files ranging from 1k to 8M. Multiple Clients. Retrieval of files ranging from 1k to 8M. Client (Application) HTTP Tier 1 JDBC Java Servlet Database Tier 2 Tier 3 J2EE--30 Performance (cont’d) Average Response Times: One Client Five Clients Data Received Response Time (ms) 1K 10.00 2K 10.00 8K 10.00 16K 10.00 32K 10.00 256K 40.00 512K 90.00 1M 180.00 4M 671.00 8M 1332.00 Data Received Response Time (ms) 1K 92.20 2K 109.00 8K 94.00 16K 110.00 32K 102.00 256K 213.00 512K 376.20 1M 651.00 4M 2175.00 8M 5153.00 Ten Clients Twenty Clients Thirty Clients Data Received Response Time (ms) 1K 119.00 2K 123.00 8K 120.00 16K 121.00 32K 143.00 256K 311.00 512K 603.00 1M 1087.70 4M 4173.70 8M Out of Memory Data Received Response Time (ms) 1K 166.00 2K 149.00 8K 152.55 16K 276.80 32K 236.50 256K 517.35 512K 1011.40 1M 1844.95 4M Out of Memory 8M Out of Memory Data Received Response Time (ms) 1K 185.33 2K 179.67 8K 181.67 16K 173.33 32K 289.33 256K 664.60 512K Out of Memory 1M Out of Memory 4M Out of Memory 8M Out of Memory J2EE--31 Performance (cont’d) Average Response Times: Average Response Time 6000.00 5000.00 Response Time (ms) 4000.00 One Client Five Clients Ten Clients Twenty Clients Thirty Clients 3000.00 2000.00 1000.00 0.00 1 2 8 16 32 256 512 1000 4000 8000 Data Received (K) J2EE--32 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan) Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--33 Java Message Service(JMS) A specification that describes a common way for Java programs to create, send, receive and read distributed enterprise messages loosely coupled communication Asynchronous messaging Reliable delivery A message is guaranteed to be delivered once and only once. Outside the specification Security services Management services J2EE--34 A JMS Application JMS Clients Java programs that send/receive messages Messages Administered Objects preconfigured JMS objects created by an admin for the use of clients ConnectionFactory, Destination (queue or topic) JMS Provider messaging system that implements JMS and administrative functionality SunONE (SUN) WebSphere (IBM) WebLogic (BEA) J2EE--35 A JMS Application (cont’d) Administrative Tool Bind JNDI Namespace Lookup JMS Client Logical Connection JMS Provider J2EE--36 JMS Messaging Domains Point-to-Point (PTP) built around the concept of message queues each message has only one consumer Msg Msg consumes Client1 sends Client2 Queue acknowledges J2EE--37 JMS Messaging Domains Publish-Subscribe systems uses a “topic” to send and receive messages each message has multiple consumers subscribes Client2 Msg delivers Client1 publishes Topic subscribes Client3 delivers J2EE--38 JMS API Programming Model Connection Factory creates Connection Message Producer creates sends to Destination Session creates creates Msg Message Consumer receives from Destination J2EE--39 Producer Sample Setting up connections and sessions // Obtain a JNDI connection InitialContext jndiContext=new InitialContext(); //look up for the connection factory ConnectionFactory cf=jndiContext.lookup(connectionfactoryname); //create a connection Connection connection=cf.createConnection(); //create a session Session session=connection.createSession(false,Session.AUTO_ACKNOWLEDGE); //create a destination object Destination dest1=(Queue) jndiContext.lookup(“/jms/myQueue”); //for PointToPoint Destination dest2=(Topic)jndiContext.lookup(“/jms/myTopic”); //for publish-subscribe J2EE--40 Producer Sample (cont’d) Creating producer MessageProducer producer=session.createProducer(dest1); Send a message Message m=session.createTextMessage(); m.setText(“just another message”); producer.send(m); Closing the connection connection.close(); J2EE--41 Consumer Sample (Asynchronous) Setup the connection, create a session Create consumer Registering the listener // registering the listener MessageListener listener=new myListener(); consumer.setMessageListener(listener); myListener should have onMessage() // onMessage() method public void onMessage(Message msg){ // read the massage and do something // see next slides } J2EE--42 Listener Example public void onMessage(Message message) { TextMessage msg = null; try { if (message instanceof TextMessage) { msg = (TextMessage) message; System.out.println("Reading message: " + msg.getText()); } else { System.out.println("Message of wrong type: " + message.getClass().getName()); } } catch (JMSException e) { System.out.println("JMSException in onMessage(): " + e.toString()); } } catch (Throwable t) { System.out.println("Exception in onMessage():" + t.getMessage()); } J2EE--43 JMS in Our Application Three Tier Architecture: Tier 1: JMS Client Tier. Tier 2: JMS Middle Tier. Tier 3: Database Backend. In our project, we do not enable multi clients. No “multi thread support” in this JMS middle tier. JMS Messaging Tier 1 JMS Middle Tier Tier 2 JDBC Database Tier 3 J2EE--44 Performance Average Response Times (for one client): One Client Data Received Response Time (ms) 1K 10.00 2K 10.00 8K 20.00 16K 20.00 32K 20.00 256K 60.00 512K 331.00 1M 501.00 4M 1392.00 8M 1822.00 J2EE--45 Performance (cont’d) Average Response Times: Average Response Time (One Client) 2000.00 1800.00 1600.00 Response Time (ms) 1400.00 1200.00 JMS Servlet 1000.00 Direct JDBC Socket 800.00 600.00 400.00 200.00 0.00 1 2 8 16 32 256 512 1000 4000 8000 Data Received (K) J2EE--46 Performance (cont’d) Pros: Loosely coupled Asynchronous Reliable Scalable Cons: JMS is complicated: management, server monitoring, and security issues Differences exist between various implementations. J2EE--47 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan) Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--48 JDBC- Java Database Connectivity A Java API for connecting programs written in Java to relational databases Data Access Interface Access many data sources Database access Spreadsheets Flat Files Performs common task like Connection pooling Batch updates Transaction management J2EE--49 JDBC- Java Database Connectivity General steps: Importing Packages Registering the JDBC drivers Opening a Connection to a Database Creating a Statement Object Executing a Query and Returning a Results Set Object Processing the Result Set Closing the Result Set and Statement Objects Closing the Connection J2EE--50 JDBC-Architecture Two-tier architecture The top level: visible to application programs The lower level: consists of drivers for individual engines J2EE--51 JDBC- Classes and Interface Connection prepareStatement subclasses Statement subclasses PreparedStatement Input to PreparedStatement CallableStatement Input/Output of CallableStatement Data types executeQuery getXXX ResultSet J2EE--52 JDBC Connect with MySQL MySQL Connector/J: an implementation of JDBC 3.0 API for the MySQL relational database server public class Connect { public static void main (String[] args) { Connection conn = null; try { String userName = "testuser"; String password = "testpass"; String url = "jdbc:mysql://localhost/test"; Class.forName ("com.mysql.jdbc.Driver").newInstance (); conn = DriverManager.getConnection (url, userName, password); System.out.println ("Database connection established"); } catch (Exception e) { System.err.println ("Cannot connect to database server"); } finally { if (conn != null) { try { conn.close (); System.out.println ("Database connection terminated"); } catch (Exception e) { /* ignore close errors */ } } } } } J2EE--53 JDBC Connect with MySQL Response time File/Client 1K 2K 8K 16K 32K 256K 512K 1M 4M 8M 1 16 0 0 0 15 16 62 125 438 828 5 6.2 6.2 6.4 3 9.6 34.4 81.2 212.2 1484.4 2978.4 10 7.8 3.2 3.1 4.7 7.8 35.9 84.4 214.2 2128.1 4036.3 20 3.8 3.8 2.4 3.85 6.25 44.55 93 371 2835.9 30 4.2 3.1 3.6 5.2 6.8 31.8 88.1 241.2 2893.8 50 4.66 2.2 3.48 5.34 6.52 35.92 90.68 279.96 3100.66 J2EE--54 JDBC Connect with MySQL Response time 4500 1 Client 4000 5 Client 3500 10 Client 3000 20 Client 30 Client 2500 50 Client 2000 1500 1000 500 0 1K 2K 8K 16K 32K 256K 512K 1M 4M 8M J2EE--55 JDBC- Security consideration JDBC and untrusted applets JDBC and Java applications driver should only be used with code loaded from that same source Network security assume that normal unsigned applets are untrustworthy not allow untrusted applets access to local database data avoid making use of local credentials when connecting to remote database servers the network protocols used for database access fixed by the DBMS vendor or connectivity vendor Security Responsibilities of Drivers Sharing TCP connections Check all local file access J2EE--56 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan) Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--57 Comparison of the four methods Speed… Naturally, the exclusion of a Middle Tier results in faster request/response times. Ease of programming… Addition of a Middle Tier means a more complicated design and evolving issues: A Server program or web server must be deployed. New technologies must be learned (Servlet Programming, Socket Programming, Java Messaging). A Communication interface needs to be developed and tested. Security… Allowing a Client direct access to a database puts the most critical resource (information) at risk. Passwords remain unencrypted in the client’s program files. – Available to any slightly skilled user/programmer. A Middle Tier Application hides data from the (untrusted) Client users. J2EE--58 Performance Average Response Times: Average Response Time (One Client) 2000.00 1800.00 1600.00 Response Time (ms) 1400.00 1200.00 JMS Servlet 1000.00 Direct JDBC Socket 800.00 600.00 400.00 200.00 0.00 1 2 8 16 32 256 512 1000 4000 8000 Data Received (K) J2EE--59 Performance Average Response Times: Average Response Time (Five Clients) 6000.00 5000.00 Response Time (ms) 4000.00 Servlet 3000.00 Direct JDBC Socket 2000.00 1000.00 0.00 1 2 3 4 5 6 7 8 9 10 Data Received (K) J2EE--60 Performance Average Response Times: Average Response Time (Ten Clients) 7000.00 6000.00 Response Time (ms) 5000.00 4000.00 Servlet Direct JDBC Socket 3000.00 2000.00 1000.00 0.00 1 2 3 4 5 6 7 8 9 10 Data Received (K) J2EE--61 Performance Average Response Times: Average Response Time (Twenty Clients) 8000.00 7000.00 Response Time (ms) 6000.00 5000.00 Servlet Direct JDBC 4000.00 Socket 3000.00 2000.00 1000.00 0.00 1 2 3 4 5 6 7 8 9 10 Data Received (K) J2EE--62 Performance Average Response Times: Average Response Time (Thirty Clients) 12000 10000 Response Time (ms) 8000 Servlet Direct SQL 6000 Socket 4000 2000 0 1 Data Received (K) J2EE--63 Organization of presentation 1. 2. 3. 4. 5. 6. 7. 8. Introduction and Motivation (Marwan) Java Sockets (Marwan) Middle-tier architecture (Steven) Java Servlets (Steven) Java Message Service (JMS) (Jijun) Java Database Connectivity (Wangang) Comparison of the four methods (Wangang) Conclusion J2EE--64 Conclusions Direct access to the database consistently yields faster request/response times. How important is Speed? How important is the Data Set? Remember, Middle Tier hides database from user. In practice, any Client to Database communication will be facilitated by a Middle Tier. Data almost always more important than the slightly better request/response times. It was expected that Socket communication would be faster than HTTP. because it operates at a lower level. However, results indicated otherwise. Reasons: We use the TCP Socket, which is connection oriented and provides a reliable point-to-point communication channel. UDP communication would have been faster, however unreliable. In, Servlets, multithreading is done by J2EE, while in the socket method, we wrote the code by hand. J2EE--65 Conclusions (cont’d) JMS provide a loosely coupled communication with asynchronous and reliable messaging services. More complicated and costly. Time = Money. Difficult to use in a system that is inherently synchronous. JMS messaging is more appropriate for Middle Tier to Component/Java Bean communication. Servlets hold a deployment advantage over JMS and Socket Servers. Web container is responsible for creating Servlet processes. Socket Server applications must be started and stopped manually. J2EE--66