J2EE Technologies and Distributed Multi-Tiered Application by bzs12927

VIEWS: 6 PAGES: 66

									 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
               Steven.Reagan@uconn.edu
                 Jijun.Lu@uconn.edu
                marwan@engr.uconn.edu
                xiewg@engr.uconn.edu

                                                     J2EE--1
         Organization of presentation

1.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan)
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   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

                               Sockets     Middle Tier     JDBC
                                           HTTP Server
                                   HTTP                        JDBC
                                                     Servlet          Database
                                 JMS                      JDBC
                                               JMS
Client (Application/Browser)



                                         J2EE Middle Tier




                                                                                 J2EE--6
          Organization of presentation

1.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan)
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   Conclusion




                                                J2EE--7
                              Sockets (API)

   A socket is an interface between        host or                       host or
                                            server                        server
    app layer and transport layer
   process sends/receives messages
    to/from its socket                                  controlled by
                                                        app developer
   socket analogous to door                process                       process
      sending process shoves
                                             socket                       socket
         message out door
      sending process assumes             TCP with                      TCP with
                                                              Internet   buffers,
         transport infrastructure on other buffers,
         side of door which brings         variables                     variables
         message to socket at receiving
         process
                                                 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


8000                                                         1 Client
                                                             5 Clients
6000                                                         10 Clients
                                                             20 Clients
4000                                                         30 Clients

2000


   0
                          K

                                 K

                                         6K


                                          ,

                                              1M

                                                   4M

                                                        8M
        1K

             2K

                  8K




                                        2K
                       16

                              32

                                      25

                                     51




                                                                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.   Introduction and Motivation (Marwan).
2.   Java Sockets (Marwan).
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven).
5.   Java Message Service (JMS) (Jijun).
6.   Java Database Connectivity (Wangang).
7.   Comparison of the four methods (Wangang).
8.   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 {
     …                                                                      Client Side
}
Public File getFile(String filename) throws SQLException {
     table.put(“name”, “getFile”);
     table.put(“args”, new Object[] {filename});
     sendRequestToMiddleTier(table);
}

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.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan).
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   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                              JDBC
                                        Java Servlet                Database




          Tier 1                           Tier 2                    Tier 3
                                                                              J2EE--30
                          Performance (cont’d)
    Average Response Times:
       One Client                       Five Clients
Data Received Response Time (ms)   Data Received Response Time (ms)
      1K             10.00               1K             92.20
      2K             10.00               2K            109.00
      8K             10.00               8K             94.00
     16K             10.00              16K            110.00
     32K             10.00              32K            102.00
     256K            40.00              256K           213.00
     512K            90.00              512K           376.20
      1M            180.00               1M            651.00
      4M            671.00               4M           2175.00
      8M           1332.00               8M           5153.00


       Ten Clients                     Twenty Clients                     Thirty Clients
Data Received Response Time (ms)   Data Received Response Time (ms)   Data Received Response Time (ms)
      1K             119.00              1K             166.00              1K             185.33
      2K             123.00              2K             149.00              2K             179.67
      8K             120.00              8K             152.55              8K             181.67
     16K             121.00             16K             276.80             16K             173.33
     32K             143.00             32K             236.50             32K             289.33
     256K            311.00             256K            517.35             256K            664.60
     512K            603.00             512K           1011.40             512K        Out of Memory
      1M            1087.70              1M            1844.95              1M         Out of Memory
      4M            4173.70              4M         Out of Memory           4M         Out of Memory
      8M         Out of Memory           8M         Out of Memory           8M         Out of Memory


                                                                                               J2EE--31
                                       Performance (cont’d)
                        Average Response Times:
                                                 Average Response Time

                     6000.00




                     5000.00




                     4000.00
Response Time (ms)




                                                                                                One Client
                                                                                                Five Clients
                     3000.00                                                                    Ten Clients
                                                                                                Twenty Clients
                                                                                                Thirty Clients

                     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.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan)
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   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       Bind
   Tool                       JNDI Namespace


             Lookup


JMS Client                      JMS Provider
                  Logical
                 Connection



                                               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            Queue                   Client2
               sends
                                acknowledges


                                                   J2EE--37
          JMS Messaging Domains
   Publish-Subscribe systems
      uses a “topic” to send and receive messages
      each message has multiple consumers


                                subscribes

              Msg                            Client2
                                delivers
    Client1
              publishes Topic   subscribes
                                             Client3
                                delivers
                                                   J2EE--38
       JMS API Programming Model

                        Connection
                         Factory
                            creates

                        Connection

Message       creates                 creates   Message
Producer                 Session                Consumer
                                                      receives
      sends to               creates                    from

Destination                Msg                  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   JMS Middle   JDBC
                                   Tier            Database



      Tier 1                      Tier 2              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


                     1400.00
Response Time (ms)




                     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.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan)
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   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                                       subclasses
Statement                PreparedStatement                                 CallableStatement
                                                                           Input/Output of
                                                       Input to
                                                       PreparedStatement   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    1       5       10       20       30        50
        1K        16      6.2     7.8       3.8      4.2      4.66
        2K         0      6.2     3.2       3.8      3.1      2.2
        8K         0      6.4     3.1       2.4      3.6      3.48
        16K        0       3      4.7      3.85      5.2      5.34
        32K       15      9.6     7.8      6.25      6.8      6.52
       256K       16     34.4     35.9    44.55     31.8     35.92
       512K       62     81.2     84.4      93      88.1     90.68
        1M        125    212.2   214.2     371      241.2    279.96
        4M        438   1484.4   2128.1   2835.9   2893.8   3100.66
        8M        828   2978.4   4036.3




                                                                      J2EE--54
             JDBC Connect with MySQL
   Response time

      4500



      4000             1 Client


                       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
       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
   JDBC and Java applications
       driver should only be used with code loaded from that same source
   Network security
       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.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan)
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   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 (un-
        trusted) Client users.
                                                                      J2EE--58
                                           Performance
                       Average Response Times:
                                                Average Response Time
                                                      (One Client)


                     2000.00


                     1800.00


                     1600.00


                     1400.00
Response Time (ms)




                     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




                     4000.00
Response Time (ms)




                                                                                        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




                     5000.00
Response Time (ms)




                     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



                     6000.00
Response Time (ms)




                     5000.00

                                                                                          Servlet
                     4000.00                                                              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--62
                                          Performance
                            Average Response Times:
                                              Average Response Time
                                                  (Thirty Clients)

                     12000




                     10000




                     8000
Response Time (ms)




                                                                          Servlet
                     6000                                                 Direct SQL
                                                                          Socket



                     4000




                     2000




                        0
                               1
                                                Data Received (K)




                                                                      J2EE--63
         Organization of presentation

1.   Introduction and Motivation (Marwan)
2.   Java Sockets (Marwan)
3.   Middle-tier architecture (Steven)
4.   Java Servlets (Steven)
5.   Java Message Service (JMS) (Jijun)
6.   Java Database Connectivity (Wangang)
7.   Comparison of the four methods (Wangang)
8.   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

								
To top