Syntax

1.   //  Aim - To obtain a connection for any purpose, from the outside.
     //  1st, get initial JNDI context (Java Naming and Directory Interfaces).
     InitialContext initctx = new InitialContext();
     //  Perform JNDI lookup to obtain a connection factory.
     connectionFactory =
       (IConnectionFactory) initctx.lookup("EISConnections/JDBCFactory");
     //  Next retrieve the ConnectionSpec and set the values.
     IConnectionSpec spec = connectionFactory.getConnectionSpec();
     spec.setPropertyValue("client", "800");
     spec.setPropertyValue("user", "aditm");
     spec.setPropertyValue("passwd", "macpc");
     spec.setPropertyValue("language", "EN");
     spec.setPropertyValue("ashost", "10.30.116.40");
     spec.setPropertyValue("sysnr", "00");
     //  Then retrieve the connection handle.
     con = connectionFactory.getConnectionEx(spec);
     //  Writing the code in the connector that establish the connection.
     //  First, the application server passes the connection manager instance   //  to the connection 
     //  factory object and instantiates the connection factory object during   //  startup.
     public CCIConnectionFactory(
       JDBCManagedConnectionFactory managedConnectionFactory,
       ConnectionManager connectionManager) {
       m_managedConnectionFactory = managedConnectionFactory;
       if (connectionManager == null)
         m_connectionManager = new JDBCConnectionManager();
       else
         m_connectionManager = connectionManager;
     }
     //  We delegate the request for a new connection to the application 
     //  server connection manager.
     public IConnection getConnectionEx(IConnectionSpec properties)
       throws ConnectionFailedException {
       try {
         return (IConnection)
   
         //  We are passing two parameters here: the real connection factory,  
         //  and  the connection properties object.
         m_connectionManager.allocateConnection(
           m_managedConnectionFactory,
           (ConnectionRequestInfo) properties);
       } catch (ResourceException re) {
         throw new ConnectionFailedException(
           re.getLinkedException().getMessage());
       }
     }
     //  Next, the connection manager, which is not part of our code, but 
     //  rather part of the  application server, looks up the requested 
     //  connection using the connection properties 
      (ConnectionReuqestInfo).
     //  The connection manager has a pool of connections, but it does not 
     //  know if a certain connection is the same as the one requested. That  
     //  can only be determined by the connector.
     //  Therefore, it calls the matching method on the real connection 
     //  factor y (the managed connection factory).
     public ManagedConnection matchManagedConnections(
       Set connectionSet,
       Subject subject,
       ConnectionRequestInfo info)
       throws ResourceException {
       Map connectionProperties = (Map) info;
   
       Iterator it = connectionSet.iterator();
       while (it.hasNext()) {
         Object obj = it.next();
         if (obj instanceof JDBCManagedConnection) {
           JDBCManagedConnection mc = (JDBCManagedConnection) obj;
           // Depending on the following method, the pool will either be 
           // efficient or not, that is,
           // there may be two connections that can be treated as the same. 
           // They connect to the same 
           // data source. Yet, they are not treated as such because they 
           // differ on an irrelevant 
           // property. the connection manager is then forced to create a new
           // connection when one 
           // from the pool would have sufficed.
           if (this.equals(mc.getManagedConnectionFactory())
             && connectionProperties.equals(mc.getConnectionProperties()))
             //The following is pseudocode.
             if (connectionProperties essentialyEquals mc
               .getConnectionProperties())
               change the Non Essential Properies of mc.return mc;
         }
       }
   
       return null;
     }
     //  Then we found the connector in the pool, the connection manager calls
     //  createConnection on the managed connection.
   
     public Object getConnection(Subject subject, ConnectionRequestInfo info)
       throws javax.resource.ResourceException {
       return (javax.resource.cci.Connection) new CCIConnection(this);
     }
     //  The connection object is returned to the user.
     //  If the connector was not found in the pool, we need to create 
     //  a new managed connection.
     public ManagedConnection createManagedConnection(
       Subject subject,
       ConnectionRequestInfo connectionRequestInfo)
       throws ResourceException {
       try {
         Map connectionProperties = (Map) connectionRequestInfo;
   
         JDBCManagedConnection managedConnection =
           new JDBCManagedConnection(this);
         if (m_connectionTimeout == -1) // no timeout
           {
           managedConnection.init(connectionProperties);
           if (managedConnection.isInitialized())
             return managedConnection;
           else
             throw new ConnectionFailedException(
               "Connection Properties:"
                 + connectionProperties.toString());
         } else {
           Thread asyncConnectionThread =
             new Thread(
               new AsyncConnectionFactory(
                 Thread.currentThread(),
                 managedConnection,
                 connectionProperties));
           asyncConnectionThread.start();
           try {
             Thread.sleep(m_connectionTimeout);
           } catch (InterruptedException ie) {
             asyncConnectionThread.destroy();
             if (managedConnection.isInitialized())
               return managedConnection;
             else
               throw new ConnectionFailedException(
                 "Connection Properties:"
                   + connectionProperties.toString());
           }
   
           asyncConnectionThread.destroy();
           throw new TimeoutException(
             "Connection Properties:" + connectionProperties.toString());
         }
       } catch (Exception e) {
         ResourceException re = new ResourceException(e.getMessage());
         re.setLinkedException(e);
         throw re;
       }
       //  Lets see the constructor and init method in managed connection.
       public JDBCManagedConnection(JDBCManagedConnectionFactory managedConnectionFactory) {
         m_connection = null;
         m_managedConnectionFactory = managedConnectionFactory;
         m_initialized = false;
         // this is a flag to indicate if init has succeeded.
       }
   
       public void init(Map connectionProperties) {
         m_connectionProperties = connectionProperties;
         try {
           //  Now, the actual connection object is being instanstiated.
           m_connection =
             DriverManager.getConnection(
               (String) connectionProperties.get("url"),
               (String) connectionProperties.get("username"),
               (String) connectionProperties.get("password"));
         } catch (SQLException se) {
           throw new RuntimeException("SQL Exception: " + se.getMessage());
         }
   
         m_eventListeners = new ArrayList();
         try {
           m_initialized = !(m_connection.isClosed());
         } catch (Exception e) {
         }
   
       }
       //  The application server adds an event listener to the managed  
       //  connection object. when the managed connection object will close, 
       //  it will notify the event listener.
       public void addConnectionEventListener
                           (ConnectionEventListener addedEventListener) {
         m_eventListeners.add(addedEventListener);
       }