Spring框架使用注解定义切面 AspectJ

AspectJ:面向切面的框架，他扩展了java语言，定义了AOP语法，能够在编译期提供代码的织入。

需求说明：使用注解实现日志切面。

定义切面：UserServiceLogger.java

package aop;

import java.util.Arrays;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//日志处理类  增强处理类-日志
@Aspect
public class UserServiceLogger {
    private Logger logger = Logger.getLogger(UserServiceLogger.class);

    // 前置增强  表示的是service包下的UserService下面的任意方法
    @Before("execution(* service.UserService.*(..))")
    public void before(JoinPoint joinPoint) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature() + "方法，方法参数是："
                + Arrays.toString(joinPoint.getArgs()));
    }

    // 后置增强pointcut表示切入点表达式   returning表示返回值
    @AfterReturning(pointcut="execution(* service.UserService.*(..))",returning="result")
    public void afterReturning(JoinPoint joinPoint,Object result) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature() + "方法，方法的返回值是："
                +result);
    }
    
    // 异常抛出增强
    public void afterThrowingError(JoinPoint joinPoint,RuntimeException e) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature().getName() + "方法，发生异常："
                +e);
    }
    //最终增强
    public void after(JoinPoint joinPoint) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature().getName() + "方法，结束了"
                );
    }
    
    //环绕增强
    public void aroundLogger(ProceedingJoinPoint joinPoint) {
        //下面是目标方法的前面执行的处理
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature() + "方法，方法参数是："
                + Arrays.toString(joinPoint.getArgs()));
        Object result;//这个相当于是目标方法  
        try {
            //下面是目标方法之后进行的处理
                result = joinPoint.proceed();
                logger.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature()+"方法，方法返回值："+result);
            
        } catch (Throwable e) {
            logger.error(joinPoint.getSignature().getName()+"方法发生异常"+e);
            e.printStackTrace();
        } finally{
            
        }
    }
}

package dao.impl;

import org.springframework.stereotype.Repository;

import dao.UserDao;
import entity.User;

/**
 * 用户DAO类，实现IDao接口，负责User类的持久化操作
 */
@Repository("userDao")
public class UserDaoImpl implements UserDao {

    public void save(User user) {
        // 这里并未实现完整的数据库操作，仅为说明问题
        System.out.println("保存用户信息到数据库");
        //throw new RuntimeException("为了测试程序异常");
    }
}

    package service.impl;
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Service;
    
    import service.UserService;
    import dao.UserDao;
    import entity.User;
    
    /**
     * 用户业务类，实现对User功能的业务管理
     */
    @Service("userService")
    public class UserServiceImpl implements UserService {
    
        // 声明接口类型的引用，和具体实现类解耦合
        
        private UserDao dao;
    
    
        public UserDao getDao() {
            return dao;
        }
    
        @Resource//通过resource注解进行装配
        public void setUserDao(UserDao dao) {
            this.dao = dao;
        }
    
    
    
        public void addNewUser(User user) {
            // 调用用户DAO的方法保存用户信息
            dao.save(user);
            System.out.println("注入进去的user对象的信息是："+user.toString());
        }
    }

核心配置文件：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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.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-3.2.xsd">
    <!-- 扫描包中注解标注的类 -->
    <context:component-scan base-package="service,dao" />
    <!--申明切面注解类  -->
    <bean class="aop.UserServiceLogger"></bean>
    <!--启动aspectj框架，让注解生效  -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

编写测试方法：

package test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import service.UserService;
import service.impl.UserServiceImpl;

import entity.TestEntity;
import entity.User;


public class AopTest {

    @Test
    public void aopTest() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService a = (UserService) ctx.getBean("userService");
        User user=new User();
        user.setUsername("丫丫");
        a.addNewUser(user);
    }

}

运行结果：

12-31 11:32:53[INFO]aop.UserServiceLogger
-调用service.impl.UserServiceImpl@1283bb96的void service.UserService.addNewUser(User)方法，方法参数是：[entity.User@2a3b5b47]
保存用户信息到数据库
注入进去的user对象的信息是：entity.User@2a3b5b47
12-31 11:32:53[INFO]aop.UserServiceLogger
-调用service.impl.UserServiceImpl@1283bb96的void service.UserService.addNewUser(User)方法，方法的返回值是：null

有时候，一个切入点表达式会在很多的增强方法上面进行引用，一个一个的配置太麻烦了，我们可以统一定义一个切入点方法。

修改一下UserServiceLogger.java类

package aop;

import java.util.Arrays;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

//日志处理类  增强处理类-日志
@Aspect
public class UserServiceLogger {
    private Logger logger = Logger.getLogger(UserServiceLogger.class);
    //统一定义切入点
    @Pointcut("execution(* service.UserService.*(..))")
    public void pointcut(){
        
    }
    // 前置增强  表示的是service包下的UserService下面的任意方法
    @Before("pointcut()")
    public void before(JoinPoint joinPoint) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature() + "方法，方法参数是："
                + Arrays.toString(joinPoint.getArgs()));
    }

    // 后置增强pointcut表示切入点表达式   returning表示返回值
    @AfterReturning(pointcut="pointcut()",returning="result")
    public void afterReturning(JoinPoint joinPoint,Object result) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature() + "方法，方法的返回值是："
                +result);
    }
    
    // 异常抛出增强
    public void afterThrowingError(JoinPoint joinPoint,RuntimeException e) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature().getName() + "方法，发生异常："
                +e);
    }
    //最终增强
    public void after(JoinPoint joinPoint) {
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature().getName() + "方法，结束了"
                );
    }
    
    //环绕增强
    public void aroundLogger(ProceedingJoinPoint joinPoint) {
        //下面是目标方法的前面执行的处理
        logger.info("调用" + joinPoint.getTarget() + "的"
                + joinPoint.getSignature() + "方法，方法参数是："
                + Arrays.toString(joinPoint.getArgs()));
        Object result;//这个相当于是目标方法  
        try {
            //下面是目标方法之后进行的处理
                result = joinPoint.proceed();
                logger.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature()+"方法，方法返回值："+result);
            
        } catch (Throwable e) {
            logger.error(joinPoint.getSignature().getName()+"方法发生异常"+e);
            e.printStackTrace();
        } finally{
            
        }
    }
}

同样是能够正确运行的。