最近的一个使用DDD风格建模的项目中，遇到这样的一个场景：

1. 领域类的抽象类层次，作为Hibernate实体类使用，由于其包含了一些业务逻辑，需要Spring依赖注入的支持，故使用了@Configurable注解+AspectJ编译时织入的方式
2. 具体领域类，一般没有业务逻辑，但是类数量较多，故使用Javassist进行自动的类生成

运行的时候出现问题了，使用Javassist生成的具体领域类，无法注入依赖，尽管其父类上有@Configurable注解。经过跟踪，发现子类也必须进行织入才能正常的进行依赖注入，那么，如何在生成字节码的时候，同时织入AOP逻辑呢？

import java.lang.instrument.IllegalClassFormatException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.aspectj.weaver.loadtime.Aj;
import org.aspectj.weaver.loadtime.DefaultWeavingContext;
import org.aspectj.weaver.loadtime.definition.Definition;
import org.aspectj.weaver.tools.WeavingAdaptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Weave byte codes at load time.
 * 
 * @author Andrica Silviu
 * @author WangZhen
 */
public class AspectJBytecodeWeaver
{

    private static final Logger LOGGER = LoggerFactory.getLogger( AspectJBytecodeWeaver.class );

    private class DynamicAspectWeavingContext extends DefaultWeavingContext
    {

        public DynamicAspectWeavingContext( ClassLoader loader )
        {
            super( loader );
        }

        public List<Definition> getDefinitions( ClassLoader loader, WeavingAdaptor adaptor )
        {
            List<Definition> definitions = new ArrayList<Definition>();
            Definition d = new Definition();
            for ( String aspectName : aspectNames )
            {
                d.getAspectClassNames().add( aspectName );
            }
            d.appendWeaverOptions( "-Xjoinpoints:synchronization" );
            if ( LOGGER.isDebugEnabled() )
            {
                d.appendWeaverOptions( "-showWeaveInfo" );
            }
            definitions.add( d );
            return definitions;
        }

    }

    private final Map<ClassLoader, Aj> mapFromClassLoaderToAj;

    private final String[]             aspectNames;

    public AspectJBytecodeWeaver( String[] aspectName )
    {
        mapFromClassLoaderToAj = new ConcurrentHashMap<ClassLoader, Aj>();
        this.aspectNames = aspectName;
    }

    /**
     * Weaving delegation
     * 
     * @param loader
     *            the defining class loader
     * @param className
     *            the name of class beeing loaded
     * @param bytes
     *            the bytecode before weaving
     * @return the weaved bytecode
     */
    public byte[] weave( ClassLoader loader, String className, byte[] bytes ) throws IllegalClassFormatException
    {
        if ( className.replace( "/", "." ).equals( aspectNames ) )
        {
            return null;
        }
        Aj aj = getAj( loader );
        if ( LOGGER.isDebugEnabled() )
        {
            LOGGER.debug( "Weaving class : {} with aspect(s) :{}", className, Arrays.deepToString( aspectNames ) );
        }
        byte[] b = aj.preProcess( className, bytes, loader );
        return b;
    }

    private Aj getAj( ClassLoader loader )
    {
        if ( mapFromClassLoaderToAj.containsKey( loader ) )
        {
            return mapFromClassLoaderToAj.get( loader );
        }
        Aj aj = new Aj( new DynamicAspectWeavingContext( loader ) );
        mapFromClassLoaderToAj.put( loader, aj );
        return aj;
    }
}

public class SpringAspectJ
{
    private static final String               ASPECT_BEAN_CONFIG =
                                                                         "org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect";

    private static final String               ASPECT_SCHEDULING  =
                                                                         "org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect";

    private static final String               ASPECT_TRANSACTION =
                                                                         "org.springframework.transaction.aspectj.AnnotationTransactionAspect";

    private static final String               ASPECT_CACHE       =
                                                                         "org.springframework.cache.aspectj.AnnotationCacheAspect";

    public static final AspectJBytecodeWeaver WEAVER             = new AspectJBytecodeWeaver( new String[] {
                                                                 ASPECT_BEAN_CONFIG, ASPECT_SCHEDULING,
                                                                 ASPECT_TRANSACTION, ASPECT_CACHE } );
}

ClassPool cp = ClassPool.getDefault();
ClassPath clsPath = new ClassClassPath( this.getClass() );
cp.insertClassPath( clsPath );
CtClass cc = cp.makeClass( getClassName() );
if ( StringUtils.isNotBlank( getSuperClassName() ) )
{
    cc.setSuperclass( cp.get( getSuperClassName() ) );
}
ClassFile cf = cc.getClassFile();
ConstPool constPool = cf.getConstPool();

if ( isWeaveSpringAspects() )
{
    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    try
    {
        //织入Spring切面
        byte[] b = SpringAspectJ.WEAVER.weave( loader, getClassName(), cc.toBytecode() );
        cc.detach();
        cc = cp.makeClass( new ByteArrayInputStream( b ) );
    }
    catch ( IOException e )
    {
        throw new RuntimeException( e.getMessage(), e );
    }
}
Class<?> c = cc.toClass();
cc.detach();
return c;

The post Aspject加载时织入示例 appeared first on 绿色记忆.