spring框架AOP配置-蒲公英云

第一步：导入包
aopalliance-1.0.jar
aspectjweaver-1.8.13.jar
spring-aop-3.2.13.RELEASE.jar

spring开头的包自带的有
aopalliance,aspectjweaver去https://repo.spring.io/下载
还加上ioc的5个包：

commons-logging-1.2.jar
spring-beans-3.2.13.RELEASE.jar
spring-context-3.2.13.RELEASE.jar
spring-core-3.2.13.RELEASE.jar
spring-expression-3.2.13.RELEASE.jar

第二步：配置ApplicationContext.xml文件

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
               http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="usLogger" class="com.big3.aop.UserServiceLogger"/>
    <!-- 日志增强注入 -->
    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="pointcut" expression="execution(public void eat(com.big3.pojo.User))"/>
        <!--织入增强处理，ref：增强处理对象，注入的日志类-->
        <aop:aspect ref="usLogger">
             <!--前置增强处理，method:被织入的方法，pointcut-ref：切入点-->
            <aop:before method="before" pointcut-ref="pointcut"/>
             <!--后置增强处理，method:被织入的方法，pointcut-ref：切入点，returning：指定返回值的属性名为result-->
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
        </aop:aspect>
    </aop:config>
    <bean id="errorLogger" class="com.big3.aop.ErrorLogger"/>
    <!-- 异常增强注入 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="point" expression="execution(public void save(com.big3.pojo.User))"/>
        <!-- 织入增强处理，ref：增强处理对象，注入的异常类 -->
        <aop:aspect ref="errorLogger">
            <!--after-throwing：异常增强， method:被织入的方法，pointcut-ref：切入点，throwing：为e参数注入异常实例 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="point" throwing="e"/>
        </aop:aspect>
    </aop:config>
    <bean id="afterLogger" class="com.big3.aop.AfterLogger"  />
    <!-- 最终增强注入 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="points" expression="execution(public void eat(int ,String))"/>
        <!-- 织入增强处理，ref：增强处理对象，注入的异常类-->
        <aop:aspect ref="afterLogger">
            <!--after：最终增强， method:被织入的方法，pointcut-ref：切入点 ;-->
            <aop:after method="after" pointcut-ref="points"/>
        </aop:aspect>
    </aop:config>
    <bean id="aroundLogger" class="com.big3.aop.AroundLogger"/>
    <!-- 环绕增强 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="pointse" expression="execution(public int saves(com.big3.pojo.User))"/>
        <aop:aspect ref="aroundLogger">
            <aop:around method="aroundLogger" pointcut-ref="pointse"/>
        </aop:aspect>
    </aop:config>
</beans>

如果用注解配置文件如下：

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
               http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--扫描包中注解标注的类-->
    <context:component-scan base-package="com.big3.dao,com.big3.pojo,com.big3.aop"/>
    <!--注册Aspectj代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

注意：如果用了spring mvc框架，IOC,AOP需要配置在springmvc配置文件里

<!--指定扫描注解定义的包，因为DAO层是自动实现，所以不用注解不用新建bean了，只需对service和pojo层aop层注解，实现loc新建bean的处理-->
<context:component-scan base-package="cn.kgc.service,cn.kgc.pojo,cn.kgc.service.impl,cn.kgc.controller,cn.kgc.aop"/>
<!--注册Aspectj代理对象,AOP切面增强用，注解方式-->
 <aop:aspectj-autoproxy/>

第三步：JAVA应用，如果不用注解，就不用注解标示

日志增强

@Aspect
@Component("usLogger")
public class UserServiceLogger {
    private static Logger log=Logger.getLogger(UserServiceLogger.class);
    //定义切入点方法
    @Pointcut("execution(public void eat(com.big3.pojo.User))")
    public void pointcut(){}
    //前置增强
    @Before("pointcut()")
    public void before(JoinPoint jp){
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"方法，方法参数：\"+Arrays.toString(jp.getArgs()));\n" +
                "\t}"+Arrays.toString(jp.getArgs()));
    }
    //后置增强
    @AfterReturning(pointcut="pointcut()",returning="result")
    public void afterReturning(JoinPoint jp,Object result){
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"方法，方法返回值："+result);
    }

异常增强

@Aspect //增强处理
@Component("errorLogger")
public class ErrorLogger {
    private static Logger log=Logger.getLogger(UserServiceLogger.class);
    //定义切入点方法
    @Pointcut("execution(public void save(com.big3.pojo.User))")
    public void pointcut(){}
    //定义异常增强方法
    @AfterThrowing(pointcut="pointcut()",throwing="e")
    public void afterThrowing(JoinPoint jp,RuntimeException e){
        log.error(jp.getSignature().getName()+"方法发生异常,"+e);
    }
}

最终增强

//最终增强，不管是否发生异常都执行，用于释放资源
@Aspect //增强处理
@Component("afterLogger")
public class AfterLogger {
    private static Logger log=Logger.getLogger(UserServiceLogger.class);
    //定义切入点方法
    @Pointcut("execution(public void eat(int ,String))")
    public void pointcut(){}
    //定义最终增强方法
    @After("pointcut()")
    public void after(JoinPoint jp){
        log.info(jp.getSignature().getName()+"方法结束了");
    }
}

环绕增

//环绕增强
@Aspect //增强处理
@Component("aroundLogger")
public class AroundLogger {
    private static final Logger log=Logger.getLogger(AroundLogger.class);
    //定义环绕增强方法
    @Around("execution(public int saves(com.big3.pojo.User))")
    public Object aroundLogger(ProceedingJoinPoint jp)throws Throwable{
        User user=(User)jp.getArgs()[0];
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法。方法入参"+user.getName());
        try {
            int result=(int)jp.proceed();//执行目标方法并获得返回值
            log.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法。方法返回值"+(result+200));
            return result;
        } catch (Throwable throwable) {
            log.error(jp.getSignature().getName()+"方法发生异常"+throwable);
            throw throwable;
        }finally {
            log.info(jp.getSignature().getName()+"方法结束执行.");
        }
    }
}