$prompt> keytool -genkey -alias serverCert -keyalg RSA -keysize 1024 -validity 9999 -keystore server.ks

Enter keystore password:  trustno1
What is your first and last name?
  [Unknown]:  Krishnan Subramanian
What is the name of your organizational unit?
  [Unknown]:  Professional Services
What is the name of your organization?
  [Unknown]:  Borland Software Corporation
What is the name of your City or Locality?
  [Unknown]:  Amstelveen
What is the name of your State or Province?
  [Unknown]:  North Holland
What is the two-letter country code for this unit?
  [Unknown]:  NL
Is CN=Krishnan Subramanian, OU=Professional Services, O=Borland Software Corporation, L=Amstelveen, ST=North Holland, C=NL correct?
  [no]:  y
Enter key password for
        (RETURN if same as keystore password): 

$prompt>

$prompt>keytool -list -keystore server.ks
Enter keystore password:  trustno1

Keystore type: jks
Keystore provider: SUN

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;

public class SocketServer {

  public static final boolean USE_SECURE = true;
  public static final int PORT = 6666;
  public static final String PASS_PHRASE = "knock knock";

  public static void main(String[] args) throws IOException {
    ServerSocket mServerSocket = null;
    if (USE_SECURE) {
      mServerSocket = getSecureSocket();
    }
    else {
      mServerSocket = getPlainSocket();
    }
    System.out.println("SocketServer listening . . . ");
    startListening(mServerSocket);

Share This | Email this page to a friend
              
                Posted by Krishnan Subramanian on July 28th, 2005 under General,  J2EE,  Java | 22 Comments »                

                

              
              

              

                              
              
Extending Container Managed Persistence (CMP) Types
              
Entity beans represent an object view of data - usually stored in a relational database. The EJB 2.x specification does not limit the mapping of entity beans to a relational database although an RDBMS remains the most popular choice of supported persistence for most CMP engine implementations.
 
Entity beans have been bashed - and continue to be bashed - for many reasons. The most common ones being performance (or the lack thereof) and the amount of necessary boiler-plate code to be written. The former is more of an implementation issue - that is, the responsibility of the Container vendor. And the latter is mostly due to the lack of proper tool support for treating EJBs as first class citizens. You can read some rantings concerning the latter at http://blogs.codegear.com/krish/archive/2004/11/12/1808.aspx
 
But a majority of the entity bean bashing is quite naive and by people mostly misinformed about the problem space entity beans attempt to address and when/why they should be used. Many cite performance as a factor. If I were to state that a popular Open Source AppServer provides poor scalability and performance for entity beans, what would the reaction of the community be? Indifference? If I went further to state that for an out-of-the-box comparison (only JVM heap sizes adjusted) of this Open Source product and the Borland Enterprise Server (BES), the latter led by a margin of 20x (2000%) in terms of raw throughput (transactions per second) and 3x (300%) after extensive tuning of both products, would the reaction of the community still be one of indifference? And that a raw-SQL (using DAO from a session bean) version of the benchmark on the Open Source AppServer showed it still lagging behind in performance compared to the entity bean version of the same benchmark running on BES? I might publish the results of that benchmark if I get some response  
 
But I digress.
 
Most CMP 2.0 engines provide support for the following Java types that map to the specified SQL Types (these types are defined in the class java.sql.Types).
 
Java Type                                 SQL Type
————————————————–
boolean/Boolean                           BIT
byte/Byte                                 TINYINT
char/Character                            CHAR(1)
double/Double                             DOUBLE
float/Float                               REAL
int/Integer                               INTEGER
long/Long                                 BIGINT
short/Short                               SMALLINT
String                                    VARCHAR
java.math.BigDecimal                      NUMERIC
byte[]                                    VARBINARY
java.sql.Date                             DATE
java.sql.Time                             TIME
java.sql.Timestamp                        TIMESTAMP
java.util.Date                            TIMESTAMP
java.io.Serializable                      VARBINARY
 
In addition to these types, most Containers also provide support for LOBs (Large Objects) such as Oracle CLOBs (Character LOBs) and BLOBs (Binary LOBs). Many Containers also provide support for dependent objects, the fields of which are again are limited to the above listed types. Now assume that I have a type that is not listed or supported by the methods in the generic interfaces in the the java.sql package but rely on specific extensions provided by the database and the JDBC Driver. How do I map those to a CMP field?
 
Let’s take a specific example. I was recently at a BES customer here in Europe in the first week of Dec 2004 (the weather there was 17C compared to the almost freezing weather in Amsterdam). I had to work with a team of 5; all of them very intelligent and with a great sense of humour. They were using Oracle 9i and were using an Oracle specific type - XMLTYPE as one of the columns in the database. This specific type is stored internally as a CLOB, but cannot be accessed directly as a CLOB by the JDBC APIs. To access this field, you would have to use oracle.jdbc.OracleResultSet specific methods along the following lines:
 
  // …. 
  oracle.jdbc.OracleResultSet oracleRs = (oracle.jdbc.OracleResultSet) resultSet;
  oracle.jdbc.OPAQUE value = oracleRs.getOPAQUE(index);
  if (!oracleRs.wasNull()) {
    String xmlString = oracle.jdbc.XMLType.createXML(value).getStringVal();
  }
 
And some similar code to set/modify the value.
 
The problem of course is that if you were using CMP, what type do you use as the CMP field? And more importantly, how do you map that field to the Oracle XMLTYPE in the database?
 
Borland Enterprise Server provides a mechanism to do so. How this work in short is that whenever a particular column type (CMP field) matches some criteria you specify (either the CMP field type or CMP field name or both), the Container can delegate the accessing/mutating of this field to custom methods you implement. In all cases, there will be no code changes involved in the entity bean or its generated code or its persistence manager. BES provides the following abstract interface:
 
  package com.borland.ejb.pm;

  import java.rmi.RemoteException;

  public abstract interface JdbcAccesserFactory {
    JdbcGetter getGetter(Class cmpFieldType, String cmpFieldName) throws RemoteException;
    JdbcSetter getSetter(Class cmpFieldType, String cmpFieldName) throws RemoteException;
  }
 
The implementation of this class has to create its implementation of the abstract class JdbcGetter and JdbcSetter. The custom implementations of JdbcGetter and JdbcSetter have to override methods to get or set the value using specific APIs. Methods in the JdbcGetter and JdbcSetter get passed the java.sql.PreparedStatement, java.sql.ResultSet and the value of the CMP field as parameters. From these, you can cast them to Oracle specific types and use Oracle JDBC Driver specific methods to get or set the value of the CMP field. To use our implementation of the JdbcAccesserFactory, an XML entry in the ejb-borland.xml (Table CMP property) instructs the EJB Container to use our class for accessing the value in the database.
 
In the case of an XMLTYPE field in the Oracle database, the first observation might be to map things to a CMP field of type java.lang.String and then undertake the conversion of this String field to Oracle XMLTYPE via our custom JdbcGetter and JdbcSetter implementations. Mapping directly to a String field is possible, but requires some more code to ensure that other java.lang.String fields in the same entity bean do not get mapped to XMLTYPE as well. For example, I might have 10 java.lang.String CMP fields in the same entity bean, of which 9 of them map to an Oracle VARCHAR2 and only one maps to an XMLTYPE. Then I have to write extra code to ensure that only the java.lang.String CMP field that maps to an Oracle XMLTYPE should be handled by my JdbcAccesserFactory implementation.
 
To get around these, for simplicity lets assume that I create a custom holder class along the lines of:
 
  package com.whatever.data;

  public class MyXmlStringHolder implements java.io.Serializable {
    private String xmlValue;
    public String getXmlValue() { return this.xmlValue; }
    public void setXmlValue(String newValue) {this.xmlValue = newValue; }
  }
 
And the above class is the one I use as my CMP field for the column that has to map to an Oracle XMLTYPE. So my entity bean would look like:
 
  public abstract class OurEntityBean implements EntityBean {
    // skipped some methods …. 
    public abstract void setXmlMessage(MyXmlStringHolder sh);
  
    public abstract MyXmlStringHolder getXmlMessage();
    // here xmlMessage is a CMP field that maps to some
    // Oracle column of XMLTYPE
  } 
Now for the custom JdbcAccesserFactory implementation. This would be along the lines of:
 
package com.borland.ejb.pm.oracle;
 
import java.rmi.RemoteException;
 
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
 
import com.borland.ejb.pm.JdbcAccesserFactory;
import com.borland.ejb.pm.JdbcGetter;
import com.borland.ejb.pm.JdbcSetter;
import com.inprise.visitransact.jdbc2.PreparedStatementProxy;

import com.whatever.data.MyXmlStringHolder;
 
import oracle.jdbc.OraclePreparedStatement;
import oracle.jdbc.OracleResultSet;
import oracle.sql.OPAQUE;
import oracle.xdb.XMLType;
 
public class OracleXmlAccesser implements JdbcAccesserFactory {
  public OracleXmlAccesser() {
  }
 
  public JdbcGetter getGetter(Class fieldType, String fieldName) throws
      RemoteException {
    if (fieldType.getName().equals(MyXmlStringHolder.class.getName())) {
      return new XmlJdbcGetter();
    }
    return null;
  }
 
  public JdbcSetter getSetter(Class fieldType, String fieldName) throws
      RemoteException {
    if (fieldType.getName().equals(MyXmlStringHolder.class.getName())) {
      return new XmlJdbcSetter();
    }
    return null;
  }
 
  private class XmlJdbcGetter extends JdbcGetter {
    public Object get(ResultSet rs, int index, ClassLoader cl) throws
        SQLException {
      MyXmlStringHolder ret = new MyXmlStringHolder();
      OracleResultSet oracleRs = (OracleResultSet) rs;
      OPAQUE value = oracleRs.getOPAQUE(index);
      if (oracleRs.wasNull()) {
        return ret;
      } else {
        ret.setXmlValue(XMLType.createXML(value).getStringVal());
        return ret;
      }
    }
  }
 
  private class XmlJdbcSetter extends JdbcSetter {
    public void set(PreparedStatement ps, int index, Object object) throws
        SQLException {
      MyXmlStringHolder holder = (MyXmlStringHolder)object
      if (holder.getXmlValue() == null) {
        PreparedStatementProxy proxy = (PreparedStatementProxy) ps;
        OraclePreparedStatement ops = (OraclePreparedStatement) proxy.getPreparedStatement();
        ops.setNull(index, Types.VARCHAR);
      } else {
        PreparedStatementProxy proxy = (PreparedStatementProxy) ps;
        OraclePreparedStatement ops = (OraclePreparedStatement) proxy.getPreparedStatement();
        ops.setObject(index, XMLType.createXML(ps.getConnection(), holder.getXmlValue()));
      }
    }
 
    public void set(ResultSet rs, PreparedStatement ps, int index, Object object) throws SQLException {
      set(ps, index, object);
    }
  }
 
}
 
And the above class would be packaged as a library and present on the classpath of BES’s partition or deployed alongwith the EJB Module in a JAR or EAR. For an entity bean to use the above class to map its CMP field(s) to an Oracle XMLTYPE, you would need an entry in the ejb-borland.xml descriptor along the lines of:
 
 
 
  <table-properties>
    <table-name>MyOracleTable</table-name>
    <column-properties>
      <column-name>MY_XML_COLUMN</column-name>
      <property>
        <prop-name>ignoreOnInsert</prop-name>
        <prop-type>java.lang.Boolean</prop-type>
        <prop-value>true</prop-value>
      </property>
    </column-properties>
    <!– other entries skipped for brevity –>
    <property>
      <prop-name>jdbcAccesserFactory</prop-name>
      <prop-type>java.lang.String</prop-type>
      <prop-value>com.borland.ejb.pm.oracle.OracleXmlAccesser</prop-value>
    </property>
  </table-properties>