Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/bytecode/javassist/JavassistClassTransformer.java
//$Id: $
package org.hibernate.bytecode.javassist;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.security.ProtectionDomain;

import javassist.bytecode.ClassFile;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.bytecode.AbstractClassTransformerImpl;
import org.hibernate.bytecode.util.ClassFilter;

/**
 * Enhance the classes allowing them to implements InterceptFieldEnabled
 * This interface is then used by Hibernate for some optimizations.
 *
 @author Emmanuel Bernard
 @author Steve Ebersole
 */
public class JavassistClassTransformer extends AbstractClassTransformerImpl {

  private static Log log = LogFactory.getLogJavassistClassTransformer.class.getName() );

  public JavassistClassTransformer(ClassFilter classFilter, org.hibernate.bytecode.util.FieldFilter fieldFilter) {
    superclassFilter, fieldFilter );
  }

  protected byte[] doTransform(
      ClassLoader loader,
      String className,
      Class classBeingRedefined,
      ProtectionDomain protectionDomain,
      byte[] classfileBuffer) {
    ClassFile classfile;
    try {
      // WARNING: classfile only
      classfile = new ClassFilenew DataInputStreamnew ByteArrayInputStreamclassfileBuffer ) ) );
    }
    catch (IOException e) {
      log.error"Unable to build enhancement metamodel for " + className );
      return classfileBuffer;
    }
    FieldTransformer transformer = getFieldTransformerclassfile );
    if transformer != null ) {
      if log.isDebugEnabled() ) {
        log.debug"Enhancing " + className );
      }
      DataOutputStream out = null;
      try {
        transformer.transformclassfile );
        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
        out = new DataOutputStreambyteStream );
        classfile.writeout );
        return byteStream.toByteArray();
      }
      catch (Exception e) {
        log.error"Unable to transform class", e );
        throw new HibernateException"Unable to transform class: " + e.getMessage() );
      }
      finally {
        try {
          if out != null out.close();
        }
        catch (IOException e) {
          //swallow
        }
      }
    }
    return classfileBuffer;
  }

  protected FieldTransformer getFieldTransformer(final ClassFile classfile) {
    if alreadyInstrumentedclassfile ) ) {
      return null;
    }
    return new FieldTransformer(
        new FieldFilter() {
          public boolean handleRead(String desc, String name) {
            return fieldFilter.shouldInstrumentFieldclassfile.getName(), name );
          }

          public boolean handleWrite(String desc, String name) {
            return fieldFilter.shouldInstrumentFieldclassfile.getName(), name );
          }

          public boolean handleReadAccess(String fieldOwnerClassName, String fieldName) {
            return fieldFilter.shouldTransformFieldAccessclassfile.getName(), fieldOwnerClassName, fieldName );
          }

          public boolean handleWriteAccess(String fieldOwnerClassName, String fieldName) {
            return fieldFilter.shouldTransformFieldAccessclassfile.getName(), fieldOwnerClassName, fieldName );
          }
        }
    );
  }

  private boolean alreadyInstrumented(ClassFile classfile) {
    String[] intfs = classfile.getInterfaces();
    for int i = 0; i < intfs.length; i++ ) {
      if FieldHandled.class.getName().equalsintfs[i] ) ) {
        return true;
      }
    }
    return false;
  }
}