最近的一个使用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 绿色记忆.

hibernateDialect=org.hibernate.dialect.MySQL5Dialect
#启用了log4jdbc支持
jdbcDriver=net.sf.log4jdbc.DriverSpy
jdbcDriverUrl=jdbc:log4jdbc:mysql://192.168.0.201:3306/initpemsdb1.1.1
jdbcUserName=root
jdbcPassword=root

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:task="http://www.springframework.org/schema/task" 
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/task  http://www.springframework.org/schema/task/spring-task-3.0.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
    ">
    <!-- 定义属性，在后面的配置中可以使用#{appCfg.xxx}引用 -->
    <util:properties id="appCfg" location="classpath:applicationConfig.properties" />
    <!-- 包扫描配置 -->
    <context:component-scan base-package="cc.gmem.demo">
        <!-- 去除Java Config类 -->
        <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />
        <!-- 去除Spring MVC类 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        <!-- 匹配AspectJ Pattern的类被去除 -->
        <context:exclude-filter type="aspectj" expression="cc.gmem.demo.aop.web.*" />
    </context:component-scan>
    <!-- 启用注解支持 -->
    <context:annotation-config />
    <!-- 支持@Configurable注解 -->
    <context:spring-configured />
    <!--  启用注解方式的事务：基于AspectJ织入 -->
    <tx:annotation-driven transaction-manager="txManager" mode="aspectj" />
    <!--  启用注解方式的缓存配置：基于AspectJ织入 -->
    <cache:annotation-driven cache-manager="cacheManager" mode="aspectj" />
    <!--  启用注解方式的任务执行(例如@Async)：基于AspectJ织入 -->
    <task:annotation-driven executor="taskExecutor" mode="aspectj" />
    
    <!--  任务调度器配置，pool-size为线程池大小，限制了同时最多被调度的任务 -->
    <task:scheduler pool-size="100" id="scheduler" />
    <!-- 任务计划列表，支持固定频率、固定延迟、Cron表达式等 -->
    <task:scheduled-tasks scheduler="scheduler">
        <task:scheduled fixed-rate="120000" method="run" ref="hibernateStatisticsMonitor" />
    </task:scheduled-tasks>
    <!-- 任务执行器，用于异步执行任务 -->
    <task:executor id="taskExecutor" keep-alive="3600" pool-size="10-100" queue-capacity="10000" rejection-policy="CALLER_RUNS" />
    <!-- 引入其它Spring配置文件 -->
    <import resource="report-and-etl.xml" />  
    <!-- Hibernate配置  -->
    <bean id="dataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">
        <property name="alias" value="connectionPool" />
        <property name="driver" value="#{appCfg.jdbcDriver}" />
        <property name="driverUrl" value="#{appCfg.jdbcDriverUrl}" />
        <property name="user" value="#{appCfg.jdbcUserName}" />
        <property name="password" value="#{appCfg.jdbcPassword}" />
        <property name="statistics" value="10s" />
        <property name="minimumConnectionCount" value="10" />
        <property name="maximumConnectionCount" value="100" />
        <property name="simultaneousBuildThrottle" value="10" />
        <property name="maximumActiveTime" value="3600000" />
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" autowire="byName" />
    <bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" lazy-init="true" />
    <bean id="sessionFactory" p:dataSource-ref="dataSource" class="cc.gmem.demo.hibernate.AnnotationSessionFactoryBean" depends-on="appCfg" >
        <property name="packagesToScan">
            <list>
                <value>cc.gmem.demo.**.domain</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=#{appCfg.hibernateDialect}
                hibernate.jdbc.batch_size=30
                hibernate.show_sql=false
                hibernate.format_sql=true
                hibernate.generate_statistics=true
                hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory
                hibernate.current_session_context_class=org.springframework.orm.hibernate3.SpringSessionContext
                hibernate.query.factory_class=org.hibernate.hql.ast.ASTQueryTranslatorFactory
                hibernate.hbm2ddl.auto=update
                #启用二级缓存
                hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=true
                hibernate.cache.region.factory_class=org.hibernate.cache.SingletonEhCacheRegionFactory
            </value>
        </property>
    </bean>
    <!-- Spring缓存配置 -->
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
        <property name="cacheManager" ref="ehcache" />
    </bean>
    <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
        <property name="configLocation">
            <value>classpath:ehcache.xml</value>
        </property>
        <property name="shared" value="true" />
    </bean>
    <bean id="hibernateStatisticsMonitor" class="cc.gmem.demo.hibernate.HibernateStatisticsMonitor" />
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" p:sessionFactory-ref="sessionFactory" />
    <!-- Velocity引擎配置 -->
    <bean id="velocityEngine" class="org.apache.velocity.app.VelocityEngine">
        <constructor-arg type="java.util.Properties">
            <value>
                <![CDATA[
                #{T(org.apache.velocity.runtime.RuntimeConstants).RUNTIME_LOG_LOGSYSTEM_CLASS}=org.apache.velocity.runtime.log.Log4JLogChute
                runtime.log.logsystem.log4j.logger=velocityLogger
                #{T(org.apache.velocity.runtime.RuntimeConstants).INPUT_ENCODING}=UTF-8
                #{T(org.apache.velocity.runtime.RuntimeConstants).OUTPUT_ENCODING}=UTF-8
                #{T(org.apache.velocity.runtime.RuntimeConstants).VM_PERM_ALLOW_INLINE}=true
                #{T(org.apache.velocity.runtime.RuntimeConstants).RESOURCE_LOADER}=class
                #{T(org.apache.velocity.runtime.RuntimeConstants).PARSER_POOL_SIZE}=100
                class.resource.loader.class=org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
                ]]>
            </value>
        </constructor-arg>
    </bean>
    <!--国际化支持-->
    <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
         <property name="basenames">
             <list>
                 <value>classpath:message.gmemdemo</value>
             </list>
         </property>
         <property name="defaultEncoding" value="UTF-8" />
         <property name="cacheSeconds" value="5" />
    </bean>
    <!--Jackson JSON -->
    <bean id="objectMapper" class="com.fasterxml.jackson.databind.ObjectMapper" autowire="byType" />
    <!-- Spring类型转换服务，特别是用于时间日期格式转换 -->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="net.greenmemory.spring.converter.DateTimeConvertor">
                    <constructor-arg>
                        <array>
                            <value>yyyy-MM-dd</value>
                            <value>yyyy-MM-dd HH:mm:ss</value>
                            <value>yyyy-MM-dd HH:mm:ss.SSS</value>
                       </array>
                    </constructor-arg>
                </bean>
            </set>
       </property>
       <property name="formatters">
           <set>
               <bean class="org.springframework.format.datetime.DateFormatter">
                   <constructor-arg>
                       <value>yyyy-MM-dd</value>
                   </constructor-arg>
               </bean>
           </set>
       </property>
       <property name="formatterRegistrars">
           <set>
           </set>
       </property>
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    ">
    <context:component-scan base-package="cc.gmem.demo.**.ctrl">
        <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />
    </context:component-scan>
    <context:component-scan base-package="cc.gmem.demo.aop.web" />

    <context:annotation-config />

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.jacksonjson.MappingJackson2HttpMessageConverter">
                <property name="objectMapper" ref="objectMapper" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <mvc:interceptors>
        <bean id="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
            <property name="sessionFactory" ref="sessionFactory" />
        </bean>
            <mvc:interceptor>     
            <mvc:mapping path="/home/*" /> 
            <!-- 自定义MVC拦截器 -->
            <bean class="cc.gmem.demo.spring.LogonInterceptor" /> 
        </mvc:interceptor>  
        
    </mvc:interceptors>

    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
        <property name="order" value="0" />
    </bean>

    <mvc:resources mapping="/css/**" location="/css/" />
    <mvc:resources mapping="/icons/**" location="/icons/" />
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/themes/**" location="/themes/" />
    <mvc:resources mapping="/js/**" location="/js/" />
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <diskStore path="D:/Temp/ehcache" />
    <defaultCache eternal="false" />
    <cache name="entityCache" eternal="false" maxElementsInMemory="1000" timeToIdleSeconds="120" timeToLiveSeconds="3600"
        overflowToDisk="true" memoryStoreEvictionPolicy="LFU" />
</ehcache>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>cc.gmem.demo.spring.SpringBeanDefinitionRegistrar</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>cc.gmem.demo.spring.SpringMVCBeanDefinitionRegistrar</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>adminServlet</servlet-name>
        <url-pattern>/proxool</url-pattern>
    </servlet-mapping>

    <session-config>
        <session-timeout>60</session-timeout>
    </session-config>

    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/jsp/error-404.jsp</location>
    </error-page>
    <error-page>
        <error-code>401</error-code>
        <location>/WEB-INF/jsp/error-401.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/WEB-INF/jsp/error-500.jsp</location>
    </error-page>
     <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

@Configuration
/* XML-based bean definitions */
@ImportResource ( "classpath:applicationContext.xml" )
public class SpringBeanDefinitionRegistrar
{

    /* Auto injected spring context */
    @SuppressWarnings ( "unused" )
    @Inject
    private ApplicationContext applicationContext;

    /* Programmatic bean definition */
    @Bean ( name = "helper" )
    public Helper helper()
    {
        Helper helper = new Helper();
        return helper;
    }

}

@Configuration
@ImportResource ( "classpath:spring-mvc.xml" )
public class SpringMVCBeanDefinitionRegistrar
{

}

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring.version>3.1.2.RELEASE</spring.version>
    <hibernate.version>3.6.10.Mod</hibernate.version>
    <aspectj.version>1.6.11</aspectj.version>
    <jackson.version>2.0.4</jackson.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>${jackson.version}</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.4</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>el-api</artifactId>
        <version>2.2</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>proxool</groupId>
        <artifactId>proxool</artifactId>
        <version>0.9.1</version>
    </dependency>

    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.15.0-GA</version>
    </dependency>

    <dependency>
        <groupId>net.sf.log4jdbc</groupId>
        <artifactId>log4jdbc3</artifactId>
        <version>1.2-ext-3</version>
    </dependency>
    <dependency>
        <groupId>com.sqlinform</groupId>
        <artifactId>sqlinform</artifactId>
        <version>0.0.1</version>
    </dependency>

    <dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>jsr250-api</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>

    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.1</version>
    </dependency>

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>

    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.9</version>
    </dependency>
    
    <dependency>
        <groupId>opensymphony</groupId>
        <artifactId>quartz-all</artifactId>
        <version>1.6.3</version>
    </dependency>
</dependencies>

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.4</version>
    <executions>
        <execution>
            <id>compile</id>
            <configuration>
                <XnoInline>true</XnoInline>
                <forceAjcCompile>true</forceAjcCompile>
                <showWeaveInfo>true</showWeaveInfo>
                <source>1.5</source>
                <target>1.5</target>
                <encoding>UTF-8</encoding>
                <verbose>true</verbose>
                <outxml>true</outxml>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

The post Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架 appeared first on 绿色记忆.

本文介绍在Eclipse下，结合Maven进行基于AspectJ的AOP编程（编译期织入）的基础知识，并给出简单的示例。 本文中使用的Eclipse版本为：3.7.1，AJDT版本为：1.6

1. 安装AspectJ Development Tools（AJDT）插件 可以到Eclipse Marketplace搜索“AJDT”，注意版本要和你的Eclipse版本匹配。或者从Update Site：http://download.eclipse.org/tools/ajdt/37/update/等位置安装，37表示Eclipse的版本为3.7。如果安装不成功，可以到AJDT网站下载离线安装包：http://www.eclipse.org/aspectj/downloads.php
2. 可以使用aspectj-maven-plugin插件，让Maven支持AspectJ编译器织入。为了使用该插件，必须安装：
   i)：AJDT Configurator：Update Site为 http://dist.springsource.org/release/AJDT/configurator/
   ii)：m2e connector for build-helper-maven-plugin：到Eclipse Marketplace搜索并安装

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <id>compile</id>
                    <configuration>
                        <XnoInline>true</XnoInline>
                        <forceAjcCompile>true</forceAjcCompile>
                        <showWeaveInfo>true</showWeaveInfo>
                        <source>1.5</source>
                        <target>1.5</target>
                        <encoding>UTF-8</encoding>
                        <verbose>true</verbose>
                        <outxml>true</outxml>
                        <aspectLibraries>
                            <aspectLibrary>
                                <!-- 在这里声明需要用到的切面库，这些库里面包含AspectJ切面的定义 -->
                                <!-- 切面库同时需要作为dependency配置 -->
                                <groupId>org.springframework</groupId>
                                <artifactId>spring-aspects</artifactId>
                            </aspectLibrary>
                        </aspectLibraries>
                    </configuration>
                    <goals>
                        <goal>compile</goal>
                        <goal>test-compile</goal><!-- 如果/src/test/java下没有任何类使用了AOP，则需要去掉这一行，否则Maven执行报错（1.4版本） -->
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

package cc.gmem.demo.aop.web;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

import org.aspectj.lang.annotation.SuppressAjWarnings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Configurable;

import cc.gmem.demo.ext.ExtAjaxResult;
import cc.gmem.demo.ext.ExtAjaxResultCallback;
import cc.gmem.demo.ext.ExtAjaxResultTemplate;

@Configurable
public aspect AjaxResultAspect issingleton() {

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

    @Inject
    private ExtAjaxResultTemplate ajaxTemplate;

    @PostConstruct
    public void init()
    {
        LOGGER.debug( "AjaxResultAspect initialized." );
    }

    public pointcut autoExtAjaxResultMarked() :@annotation(AutoExtAjaxResult);

    @SuppressAjWarnings
    Object around():autoExtAjaxResultMarked(){
        return ajaxTemplate.callback( new ExtAjaxResultCallback() {

            public Void callback( ExtAjaxResult result ) throws Throwable
            {
                Object retVal = proceed();
                result.setObject( retVal );
                return VOID;
            }
        } );
    }
}

//整个static块均为织入的内容
static
{
  ajc$preClinit();
  try { LOGGER = LoggerFactory.getLogger(AjaxResultAspect.class); ajc$postClinit(); } catch (Throwable localThrowable) { ajc$initFailureCause = localThrowable; }
}
//构造器的代码为织入的内容，包含了进行Spring依赖注入的逻辑
public AjaxResultAspect()
{
  JoinPoint localJoinPoint2 = Factory.makeJP(ajc$tjp_1, this, this); JoinPoint localJoinPoint1 = Factory.makeJP(ajc$tjp_0, this, this); if ((this != null) && (getClass().isAnnotationPresent(Configurable.class)) && (AnnotationBeanConfigurerAspect.ajc$if$bb0((Configurable)getClass().getAnnotation(Configurable.class)))) AnnotationBeanConfigurerAspect.aspectOf().ajc$before$org_springframework_beans_factory_aspectj_AbstractDependencyInjectionAspect$1$e854fa65(this); if (((this == null) || (!getClass().isAnnotationPresent(Configurable.class)) || (!AnnotationBeanConfigurerAspect.ajc$if$bb0((Configurable)getClass().getAnnotation(Configurable.class)))) && (this != null) && (getClass().isAnnotationPresent(Configurable.class)) && (AbstractDependencyInjectionAspect.ajc$if$6f1(localJoinPoint1))) AnnotationBeanConfigurerAspect.aspectOf().ajc$afterReturning$org_springframework_beans_factory_aspectj_AbstractDependencyInjectionAspect$2$1ea6722c(this); if ((!AnnotationBeanConfigurerAspect.ajc$if$bb0((Configurable)getClass().getAnnotation(Configurable.class))) && (AbstractDependencyInjectionAspect.ajc$if$6f1(localJoinPoint2))) AnnotationBeanConfigurerAspect.aspectOf().ajc$afterReturning$org_springframework_beans_factory_aspectj_AbstractDependencyInjectionAspect$2$1ea6722c(this);
}

The post Eclipse下进行基于AspectJ的AOP编程 appeared first on 绿色记忆.

1. AspectJ编译器能识别任何普通的Java代码，可以使用ajc编译.java文件
2. 织入方式：
   

   源代码织入	织入器作为编译器的一部分，处理源代码，支持经典语法和注解语法。生成的字节码符合JVM规范，需要使用ajc代替javac
   字节码织入	传递给织入器的是字节码。使用这种方式时，包含编译普通Java类、编译切面，织入3个步骤。
   加载时织入	传递给织入器的是Java类字节码、切面类，以及aop.xml配置文件。

3. AspectJ暴露的连接点。只能在这些连接点上应用通知：
   

   	暴露的连接点	代码表现
   方法	执行 Execution	方法体：该连接点环绕整个方法体的执行过程。这也是Spring AOP唯一支持的接入点类型。通知被织入方法体 切入点语法：execution(方法签名)
   	调用 Call	方法调用：该接入点发生在方法被调用时。通知被织入调用者代码处 切入点语法：call(方法签名)
   构造器	执行 Execution	对象构造逻辑：该连接点环绕整个构造器的执行过程 切入点语法：execution(构造器签名)
   	调用 Call	对象构造调用 切入点语法：call(构造器签名)
   字段访问	读访问 Read access	读取类或对象的字段 切入点语法：get(字段签名)
   	写访问 Read access	写入类或对象的字段 切入点语法：set(字段签名)
   异常处理	处理器 Handler	处理异常的catch块 切入点语法：handler(类型签名)
   初始化	类初始化 Class initialization	类加载，包括静态成员初始化部分 切入点语法：staticinitialization(类型签名)
   	对象初始化 Object initialization	在构造器中的对象初始化。包含：从一个父构造器返回，到当前构造器执行完成的部分（不包括调用父构造器的部分） 切入点语法：initialization(构造器签名) Spring的@Configurable即为此例 。下面的例子解释了连接点的范围： public class SavingsAccount extends Account { private boolean isOverdraft; private int minimumBalance; //构造器1 public SavingsAccount( int accountNumber, boolean isOverdraft ) { super( accountNumber ); //对象初始化连接点：构造器1，2 this.isOverdraft = isOverdraft; } //构造器2 public SavingsAccount( int accountNumber ) { //对象初始化连接点：构造器2 this( accountNumber, false ); //对象初始化连接点：构造器2 this.minimumBalance = 25; } }
   	对象预初始化 pre-initialization	在构造器中的对象初始化之前：用的很少，从当前构造器调用，到父构造器调用结束为止 切入点语法：preinitialization(构造器签名)
   通知	执行 Execution	通知的执行：环绕某个通知的整个执行。可以对通知进行通知 切入点语法：adviceexecution()

4. AspectJ切入点声明语法
   

   /**
    * 切入点声明语法，包含5个部分：
    * 访问标识符：例如 public
    * 关键字：pointcut
    * 切入点名称()
    * 切入点类型：例如execution、call，参考：第3点
    * 切入点签名：根据切入点类型不同，可能是类型签名、方法签名、字段签名
    */
   public pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));

   AspectJ支持仅有切入点名称，而没有类型和签名的切入点，通常使用在抽象切面中。
   AspectJ支持匿名切入点，作为通知签名的一部分存在。
   AspectJ支持使用 !、 && 、|| 来作为切入点的运算符

5. AspectJ通知定义语法：由通知声明、切入点定义、通知体三部分组成
   

   组成	说明
   整体语法形式： [@AdviceName("通知的名称")] [返回值] 通知类型([上下文信息]) [returning|throwing] [throws 通知抛出的异常] : 切入点定义([上下文信息]) { 通知体 }
   通知声明	通知类型可以是：before, after 或 around，其中around需要声明返回值通知声明可以指定通知体可用的上下文信息，包括：执行对象通知声明可以指定通知体可能抛出的异常
   切入点定义	位于冒号之后，任何匹配切入点定义的连接点上都会执行本通知
   通知体	可以访问一系列特殊的变量或关键字，例如：proceed、thisJoinPoint、thisJoinPointStaticPart、 thisEnclosingJoinPointStaticPart

6. AspectJ支持的通知类型
   

   通知类型	说明
   Before advice	在连接点执行之前执行，如果抛出异常，那么连接点不被执行
   After advice	在连接点执行之后执行，根据连接点的执行结果，具有3个子类型：After (finally)：在连接点执行之后执行，不论其结果，通知声明语法：after()After returning：在连接点执行成功后执行，通知声明语法：after() returning(<ReturnType returnObject>)After throwing：在连接点执行失败后执行，通知声明语法：after() throwing(<ExceptionType exceptionObject>)
   Around advice	环绕连接点的执行过程，具有修改连接点执行上下文的能力，可以用来： 在连接点之前/之后添加额外的逻辑，例如性能分析 跳过原先逻辑还执行备选的逻辑，例如缓存。只要不调用proceed()，即跳过 使用try-catch包裹原先逻辑，提供异常处理策略，例如事务管理

通配符用于匹配一系列的连接点。

这里的类型泛指：类、接口、注解、切面、基本类型
基本类型签名示例：

基于注解的类型签名示例：
由于Java不支持注解的继承，所有注解名后不会出现加号。注意注解必须运行时可见（

RetentionPolicy.RUNTIME

基于泛型的类型签名示例：

联合类型签名示例：

构造器签名与方法类似，但是：

1. 由于构造器没有返回值，因此不得在签名中指定返回值
2. 由于构造器不能为静态，故不得添加static关键字
3. 由于构造器没有名称，必须使用new作为其名称部分

基本方法签名示例：

基于注解的方法签名示例：

注意注解必须运行时可见（

RetentionPolicy.RUNTIME

字段签名中，使用get表示读字段，set表示写字段：

字段签名示例：

注意注解必须运行时可见（

RetentionPolicy.RUNTIME

AspectJ提供几种切入点指示器（designators），配合上面所述的切入点签名，即组成切入点。
切入点通过两种方式与连接点进行匹配：

1. 类型限定的切入点：直接映射到某个类型的连接点，参考AspectJ暴露的连接点一节中的“切入点语法”部分
2. 无类型的切入点：根据指定的信息，来选择特定的连接点。这些信息可以是：连接点上下文的运行时类型、控制流，或者此法作用域（lexical scope）

匹配：指定类型和签名的连接点
Spring：仅支持execution类型
静态确定：是

不去限定连接点的类型，还是通过若干种规则去匹配多种连接点。

Spring虽然仅仅支持execution一种类型的连接点，但是却支持多种方式来选择它们

基于控制流的切入点
这一类的切入点匹配 处于其他切入点的控制流之中 的连接点。这句话比较难以理解，以贷款业务为例，假设Account.debit()方法调用Account.getBalance()进行余额查询，那么，可以说：getBalance在debit的控制流之中。类似的，字段访问、异常处理，也可以处于某个切入点的控制流之中。
Spring不支持这一类切入点，不能静态确定（需要运行时判断）
包含两种切入点类型：cflow、cflowbelow，后者不包括启动控制流的连接点本身

下面以事务管理的场景为例，来说明控制流切入点的用法：

package cc.gmem.aj.cflow;
public class Account
{
    //两个方法均具有事务注解，但是，我们需要在“最外层”来启动事务
    //需要忽略内层的事务注解
    @Transactional
    public void debit()
    {
        getBalance();
    }
    @Transactional
    public void getBalance()
    {
    }
}

public aspect TransactionAspect
{
    //匹配所有标注了@Transactional的方法执行
    private pointcut transacted() : execution(@Transactional * *(..));
    //匹配这样的@Transactional方法：不在@Transactional方法的所确定的控制流的内部
    private pointcut topLevelTransacted() : transacted() && !cflowbelow(transacted());

    Object around() : topLevelTransacted() {
        System.out.println( "启动事务" );
        Object ret = proceed();
        System.out.println( "结束事务" );
        return ret;
    }
}

基于词法结构的切入点
匹配：在指定类型、方法、构造器内的连接点
Spring：支持within()，不支持withincode()
可以静态确定
包含两种切入点类型：within(类型签名)、withincode(构造器签名|方法签名)

执行对象切入点
根据运行时对象类型来选择连接点。并且，可以收集执行对象——双重功能。

包含两种类型：this(<Type or ObjectIdentifier>)、target(<Type or ObjectIdentifier>)，前者匹配this引用为指定类型的连接点；后者匹配方法调用target为指定类型的连接点。

该类切入点不支持类型通配，也不支持泛型。该类切入点不会匹配任何静态方法的执行连接点。

注意区别：
execution(* Account.*(..)) 匹配Account类的任何静态、成员方法
execution(* *.*(..))  && this(Account)：匹配Account及其子类的任何成员方法
参数切入点
该类切入点根据连接点的参数对象的运行时类型来匹配。并且，可以收集匹配的参数对象。
Spring支持此类切入点。无法静态确定。
所谓参数对象，根据连接点不同，含义也不同：

1. 对于方法、构造器连接点，参数对象即方法参数
2. 对于异常处理连接点，参数对象即被处理的异常
3. 对于字段写入连接点，参数对象即被写入的值

该类切入点的形式为：args(Type or ObjectIdentifier, ..)

基于注解的切入点

注意：注解本身被标注的注解影响AOP行为：

1. @Retention(RetentionPolicy.RUNTIME)：只有设置为运行时保留，才能在运行时进行匹配性判断
2. @Inherited：只有标注了此注解，子编程元素（类、方法）才能继承父元素上标注的注解

AspectJ支持根据类型、方法、字段所标注的注解来匹配连接点

条件检查切入点
此类切入点在连接点上的一些条件检查。通常和其它切入点联合使用

本段代码示意经典的AspectJ语法：

package cc.gmem.aj;

//切面的声明
public aspect SecurityAspect
{

    private Authenticator auth = new Authenticator();

    //切入点的声明
    pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));
    //通知声明：针对secureAccess切入点的before通知
    before() : secureAccess() {
        System.out.println( "Checking and authenticating user" );
        auth.doAuthenticate();
    }
}

本段代码示意基于注解的AspectJ语法：
基于注解的语法，可以作为普通Java类编译，并且使用LTW（加载时织入）机制，在类被加载到JVM中时进行织入。

package cc.gmem.aj;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class SecurityAspect
{

    private Authenticator auth = new Authenticator();

    @Pointcut ( "execution(* cc.gmem.aj.MessageCommunicator.deliver(..))" )
    public void secureAccess()
    {
    }

    @Before ( "secureAccess()" )
    public void secure()
    {
        System.out.println( "Checking and authenticating user" );
        auth .doAuthenticate();
    }
}

环绕通知的简单例子，注意proceed()的使用：

public aspect SecurityAspect
{
    private Authenticator auth = new Authenticator();

    pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));

    Object around() : secureAccess() {
        long start = System.nanoTime();
        //伪关键字proceed，用于继续执行被通知的目标方法
        Object ret = proceed();
        //thisJoinPointStaticPart是通知可用变量之一，可以获取连接点的静态信息，例如方法名
        System.out.println( thisJoinPointStaticPart.getSignature() + " took " + ( end - start ) + " nanoseconds" );
        return ret;
    }
}

上下文收集的简单例子：

package cc.gmem.aj;

import java.sql.Connection;
import java.sql.SQLException;

public aspect ConnectionAspect
{
    //匹配Connection的任何抛出SQLException方法的调用
    //被调用（target）的Connection对象收集为connection变量。
    pointcut connectionOperation( Connection connection )//独立定义的切入点，必须使用这种参数声明来传递上下文信息给通知
        : call(* Connection.*(..) throws SQLException) && target(connection);

    Object around( Connection connection ) : connectionOperation(connection) {//传递了上下文
        long startTime = System.nanoTime();
        Object ret = proceed();
        //thisJoinPoint是通知体可用的变量之一
        System.out.println( "Operation " + thisJoinPoint + " on " + connection + " took " + ( System.nanoTime() - startTime ) );
        return ret;
    }
}

上下文收集注解的例子：

before(Secured secured ) : 
    //匹配任何方法执行
    execution(* *(..)) 
    //匹配连接点目标————即方法本身————上具有@secured注解的连接点
    && @annotation(secured)
{
    //注解可以像普通对象一样被使用
    checkPermission(secured.permission());
}

上下文收集的另外一个例子，注意传递给目标的参数被收集，可被通知体使用：

package cc.gmem.aj;

public aspect AccountAspect
{

    boolean processOverdraft( Account account, float amount )
    {
        return true;
    }

    void around( Account account, float amount ) throws InsufficientBalanceException
    //匹配任何对Account.debit(float) throws InsufficientBalanceException方法的调用
        : call(void Account.debit(float) throws InsufficientBalanceException)
        && target(account) && args(amount)//收集的上下文信息作为局部变量使用
    {
        try
        {
            proceed( account, amount );//传递给目标方法的参数，可以任意修改
        }
        catch ( InsufficientBalanceException ex )
        {
            //进行透支处理
            if ( !processOverdraft( account, amount ) )
            {
                throw ex;
            }
        }
    }
}

在classpath的META-INF/aop.xml中，声明需要织入的切面：

<aspectj>
    <aspects>
        <aspect name="cc.gmem.aj.SecurityAspect"/>
    </aspects>
</aspectj>

通过指定JVM启动参数-javaagent来启用LTW：

-javaagent:%ASPECTJ_HOME%\lib\aspectjweaver.jar

如果使用Spring，可以通过配置，避免修改JVM启动参数

AspectJ支持连接点、切入点、切面等构造。

AspectJ的动态横切构造依赖于“通知”实现。通知包括Before、After、Around几种。

收集连接点上下文

连接点上下文包括两种类型：

通过反射访问连接点上下文

作为备选方式，AspectJ提供了基于反射机制的访问静态（不会随着连接点执行而变化的）、动态连接点上下文信息的方法。这种方式可以完全替换上一条进行动态上下文收集，但是具有以下缺点：

1. 性能较为低下
2. 缺少静态语法检查
3. 比较笨重

通过AspectJ提供的通知体可用的特殊变量来使用这种反射API：

两种访问连接点上下文的方式的对照表

静态横切总是在动态横切之前应用。

静态横切构造由：跨类型声明（inter-type declaration ，ITD，亦称“引入introduction)”）和织入时声明（weave-time declarations）组成
跨类型声明（引入）
可以修改类、接口、或者切面的静态结构，例如增加一个字段，添加一个接口。在一个切面中，声明其他类型的结构，故曰ITD。下面是一个例子：

package cc.gmem.aj;

public aspect TrackingAspect
{

    //声明MessageCommunicator实现接口AccessTracked，效果和Java标准语法一样
    declare      parents: MessageCommunicator implements AccessTracked;

    //声明AccessTracked类型的一个字段，所有它的子类型自动获取此字段
    private long AccessTracked.lastAccessedTime;

    //声明AccessTracked类型的两个方法，所有它的子类型自动继承这些方法
    public void AccessTracked.updateLastAccessedTime()
    {
        lastAccessedTime = System.currentTimeMillis();
    }

    public long AccessTracked.getLastAccessedTime()
    {
        return lastAccessedTime;
    }

    before( AccessTracked accessTracked ) : //声明了一个通知局部变量accessTracked
        execution(* AccessTracked+.*(..)) //AccessTracked子类型的任何方法
        && !execution(* AccessTracked.*(..))//除了AccessTracked本身的方法
        && this(accessTracked)//this对象收集为accessTracked变量
    {
        accessTracked.updateLastAccessedTime();
    }

    private static interface AccessTracked
    {
    }
}

成员引入的规则

1. 只能引入private、public成员，前者只能被切面类访问，后者可以被系统中所有类访问
2. 如果是private的，多个切面可以引入同名的成员
3. 切面可以引入字段、函数、构造器到类或者接口。特别的，可以引入方法的实现到接口——缺省实现
4. 如果切面引入一个和类中同名的方法，那么，类中的那个方法被保留
5. 成员引入只能针对一个类型

接口缺省实现的例子

package cc.gmem.aj;

public interface Nameable
{
    public void setName( String name );

    public String getName();
    //缺省实现
    static aspect Impl
    {
        private String Nameable.name;

        public void Nameable.setName( String name )
        {
            this.name = name;
        }

        public String Nameable.getName()
        {
            return this.name;
        }
    }
}

使用ITD来实现Java的Mixin机制

Mixin是一种程序构造，允许在已有类中混入特定的逻辑，Java语言没有语言级别的机制，下面的例子示意了如何使用AspectJ进行混入

//一个标记性接口，用于混入功能
public interface BeanSupport {}
//一个简单的POJO，需要混入：属性变更监听的功能
public class Customer implements BeanSupport
{
    private String address;
    public String getAddress()
    {
        return address;
    }
    public void setAddress( String address )
    {
        this.address = address;
    }
}

通过下面的代码，即可为Customer或者任何实现了BeanSupport的类型混入属性变更的功能，而没有任何的侵入性。

public aspect BeanMakerAspect
{

    private PropertyChangeSupport BeanSupport.propertyChangeSupport;
    public void BeanSupport.addPropertyChangeListener( PropertyChangeListener listener )
    {
        propertyChangeSupport.addPropertyChangeListener( listener );
    }
    public void BeanSupport.removePropertyChangeListener( PropertyChangeListener listener )
    {
        propertyChangeSupport.removePropertyChangeListener( listener );
    }
    pointcut beanCreation( BeanSupport bean )
    //匹配BeanSupport及其子类型的初始化连接点
    : initialization(BeanSupport+.new(..)) && this(bean);

    pointcut beanPropertyChange( BeanSupport bean, Object newValue )
    //匹配BeanSupport及其子类型的任何Setter方法的执行
    : execution(void BeanSupport+.set*(*))
    && args(newValue) && this(bean);
    //BeanSupport初始化成功后，创建一个propertyChangeSupport字段的实例
    after( BeanSupport bean ) returning : beanCreation(bean) {
        bean.propertyChangeSupport = new PropertyChangeSupport( bean );
    }
    //Setter调用后，发布相应的事件
    void around( BeanSupport bean, Object newValue )  : beanPropertyChange(bean, newValue) 
    {
        String methodName = thisJoinPointStaticPart.getSignature().getName();
        String propertyName = Introspector.decapitalize( methodName.substring( 3 ) );
        Object oldValue = getPropertyValue( bean, propertyName );
        proceed( bean, newValue );
        bean.propertyChangeSupport.firePropertyChange( propertyName, oldValue, newValue );
    }
}

修改类层次结构

AspectJ提供两种需要类层次的形式：

declare parents : [TypePattern] implements [InterfaceList];
declare parents : [TypePattern] extends [Class or InterfaceList];
//举例：所有实体类实现BeanSupport接口
public aspect EntityBeanParticipationAspect {
    declare parents: @Entity * implements BeanSupport;
}
//hasMethod、hasField，任何包含指定模式方法或者字段的类：
declare parents: hasmethod(@Observed * *(*)) implements BeanSupport;

引入注解

AspectJ支持为字段、类、方法等添加注解

简化异常处理

允许不强制捕获受查异常，声明方式如下：

//这里声明不需要强制捕获的异常
declare soft : <ExceptionTypePattern> : <pointcut>;

织入时声明——警告或者错误信息

可以在织入时，根据一定的模式来生成错误或者警告信息，举例：

//当doAuthenticate方法在SecurityAspect以外调用时，生成警告
declare      warning: 
    call(void Authenticator.doAuthenticate()) //切入点：方法被调用的地方，与execution不同
    && !within(SecurityAspect)  : //切入点，不在SecurityAspect内
        
        "Authentication should be performed only by SecurityAspect";

这种场景下，本质上还是Spring基于JDK动态代理的AOP机制，只是借用AspectJ的语法。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    ">
    <!-- 提示Spring自动为目标对象创建代理 -->
    <aop:aspectj-autoproxy />
    <!-- 声明普通Bean -->
    <bean id="messageCommunicator" class="cc.gmem.aj.MessageCommunicator" />
    <!-- 声明切面Bean，注意，必须使用注解语法定义切面 -->
    <bean id="securityAspect" class="cc.gmem.aj.SecurityAspect" />
</beans>

可以基于AspectJ，而不是Spring AOP来实现：事务管理、缓存、任务调度等常用AOP场景，以避免Spring AOP的固有缺陷。
特别是使用@Configurable注解来支持非Spring Bean的依赖注入，必须基于AspectJ完成。

<!-- 支持非受管对象（Spring Bean）的依赖注入和生命周期注解 -->
<context:spring-configured />
<!-- 支持基于AspectJ的事务管理 -->
<tx:annotation-driven transaction-manager="txManager" mode="aspectj" />
<!-- 支持基于AspectJ的缓存机制-->
<cache:annotation-driven cache-manager="cacheManager" mode="aspectj" />
<!-- 支持基于AspectJ的任务调度和执行 -->
<task:annotation-driven  scheduler="taskScheduler" executor="taskExecutor" mode="aspectj" />

The post AspectJ编程学习笔记 appeared first on 绿色记忆.