AOP的实现

AOP基于xml配置方式实现

Spring基于xml开发AOP

• 　　　　定义目标类（接口及实现类）

/**
 * 目标类
 */
public interface UserService {
    //业务方法
    public void getById();    
    public void add();    
    public void delete();    
    public String update();
    public void batch();    
}

public class UserServiceImpl implements UserService {
    @Override
    public void getById() {
        System.out.println("UserServiceImpl类的getById方法被调用...");
        //抛出异常
        System.out.println(1/0);
    }
    @Override
    public void add() {
        System.out.println("UserServiceImpl类的add方法被调用...");
    }
    @Override
    public void delete() {
        System.out.println("UserServiceImpl类的delete方法被调用...");
//        System.out.println(1/0);
    }
    @Override
    public String update() {
        System.out.println("UserServiceImpl类的update方法被调用...");
//        System.out.println(1/0);
        return "update的返回值";
    }
    @Override
    public void batch() {
        System.out.println("UserServiceImpl类的batch方法被调用...");
    }
}

• 　　　　定义切面类

/**
 * 切面
 */
public class UserAspect {
    //前置通知
    public void beforeAdvice(JoinPoint jp){
        //获取切入点的方法的名称
        String name = jp.getSignature().getName();
        System.out.println("前置通知切入点的方法的名称："+name);                
        System.out.println("前置通知");
    }
    
    //后置通知
    public void afterAdvice(JoinPoint jp){
        //获取切入点的方法的名称
        String name = jp.getSignature().getName();
        System.out.println("后置通知切入点的方法的名称："+name);                
        System.out.println("后置通知");
    }
        
    //返回通知
    //可以获取object类型的返回值
    //注意：result名称必须和配置文件中的returning的名称保持一致
    public void afterReturningAdvice(JoinPoint jp,Object result){
        //获取切入点的方法的名称
        String name = jp.getSignature().getName();
        System.out.println("返回通知切入点的方法的名称："+name);        
        //打印返回值
        System.out.println(result);
        System.out.println("返回通知");
    }
        
    //异常通知
    public void exceptionAdvice(JoinPoint jp,Exception ex){
        //获取切入点的方法的名称
        String name = jp.getSignature().getName();
        System.out.println("异常通知切入点的方法的名称："+name);    
        //打印异常信息
        System.out.println(ex.getMessage());
        System.out.println("异常通知");
    }
        
    //环绕通知
    //必须有一个参数：ProceedingJoinPoint
    //有返回值：Object
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕通知前");
        //执行业务逻辑方法
        Object result = pjp.proceed();        
        //获取切入点的方法的名称
        String name = pjp.getSignature().getName();
        System.out.println("环绕通知切入点的方法的名称："+name);        
        System.out.println("环绕通知后");
        return result;
    }
}

• 　　　　配置spring核心配置文件

<?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-4.2.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">    
    <!-- 把切面和业务对象放到容器中 -->
    <bean id="userAspect" class="spring.aop.xml.UserAspect"></bean>
    <bean id="userServiceImpl" class="spring.aop.xml.UserServiceImpl"></bean>
        
    <!-- 配置aop的实现 -->
    <aop:config>
        <!-- 
            切入点的配置
            expression(切入点表达式)：指定切哪个方法
         -->
         <aop:pointcut expression="execution(* *.add*(..))" id="pointCut01"/>         
         <aop:pointcut expression="execution(* *.delete*(..))" id="pointCut02"/>
         <aop:pointcut expression="execution(* *.update*(..))" id="pointCut03"/>
         <aop:pointcut expression="execution(* *.getById*(..))" id="pointCut04"/>
         <aop:pointcut expression="execution(* *.batch*(..))" id="pointCut05"/>
                 
         <!-- 切面的配置 -->
         <aop:aspect ref="userAspect">
             <!-- 
                 前置通知的配置：在pointCut01切入点的位置添加beforeAdvice的通知
              -->
              <aop:before method="beforeAdvice" pointcut-ref="pointCut01"/>              
              
             <!-- 
                 后置通知的配置：在pointCut02切入点的位置添加afterAdvice的通知
              -->
              <aop:after method="afterAdvice" pointcut-ref="pointCut02"/>
                            
             <!-- 
                 返回通知的配置：在pointCut03切入点的位置添加afterReturningAdvice的通知
                 returning：返回值的参数名称
              -->
              <aop:after-returning method="afterReturningAdvice" pointcut-ref="pointCut03" returning="result"/>
                            
             <!-- 
                 异常通知的配置：在pointCut04切入点的位置添加exceptionAdvice的通知
                 throwing：抛出异常的名称，必须和通知上的形参名称一致
              -->
              <aop:after-throwing method="exceptionAdvice" pointcut-ref="pointCut04" throwing="ex"/>
                            
             <!-- 
                 环绕通知的配置：在pointCut05切入点的位置添加aroundAdvice的通知
              -->
              <aop:around method="aroundAdvice" pointcut-ref="pointCut05"/>
         </aop:aspect>    
    </aop:config>    
</beans>

• 　　　　测试

//使用xml方式配置AOP
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-aop-xml.xml")
public class XmlAopTest {
    //注入业务对象
    @Autowired
    private UserService userService;
    
    //测试AOP，对切入点进行增强
    @Test
    public void test(){
        //前置通知的测试
//        userService.add();
                
        //后置通知的测试(无论有没有异常都会执行)
//        userService.delete();
                
        //返回通知的测试(只有业务方法正常执行时，才会执行的通知)
//        userService.update();
                
        //异常通知的测试
//        userService.getById();
                
        //环绕通知的测试
        userService.batch();
    }
}

---

　　　　

AOP的切入点表达式execution

　　　　表达式的写法：修饰关键词   返回值类型   包名.类名.方法名(..)

修饰关键词：protected ,  public  ,  private ….一般都省略不写

返回值类型：一般返回值类型用 * 号代替，表示任意的返回值都可以

方法名中的两个点：表示所带的参数的个数。

　　　　　　　　举例如下：

　　任意以public修饰的方法都可以

execution(public * *(..))

　　任何以set开头的方法都可以

execution(* set*(..))

　　任何在AccountService 这个接口下面的方法都可以

execution(* com.xyz.service.AccountService.*(..))

　　任何在com.xyz.service 这个包下面的所有类的所有方法都可以

execution(* com.xyz.service.*.*(..))

　　任何在com.xyz.service 这个包以及整个包下面的所有子包的所有类的所有方法都可以

execution(* com.xyz.service..*.*(..))

　　..代表这个包及这个包下面的所有子包

Spring中的5种通知类型及参数

• • • 　　前置通知：在目标方法开始之前进行执行的通知

      　　　　参数：JoinPoint

    • 　　后置通知：在目标方法执行之后，无论是否发生异常，都进行执行的通知

      　　　　参数：JoinPoint

    • 　　返回通知：在目标方法正常结束时，才执行的通知

      　　　　参数：JoinPoint，Object

    • 　　异常通知：在目标方法出现异常时才会进行执行的通知

      　　　　参数：JoinPoint，Exception

    • 　　环绕通知：在目标方法执行之前、 之后都会执行的通知

      　　　　参数：ProceedingJoinPoint(必须有)

 

---

---

 

AOP基于注解方式的实现

xml配置中开启spring注解扫描及开启aop注解的自动代理

　　　　

<?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-4.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
    <!-- 开启spring的注解驱动 -->
    <context:component-scan base-package="spring.aop.annotation"></context:component-scan>
    
    <!-- 开启aop的自动代理：使用注解实现AOP，这个必须配置 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

　　　　定义接口及接口实现类

　　　　

 此处省略，同xml配置方式相同

　　　　通过注解的方式定义切面类

/**
 * 切面
 */
@Component
@Aspect
public class UserAspect {
    //前置通知
    @Before(value = "execution(* *.add*(..))")
    public void beforeAdvice(JoinPoint jp){
        String name = jp.getSignature().getName();
        System.out.println("前置通知的切入点的方法名：" + name);        
        System.out.println("前置通知...");
    }
        
    //后置通知
    @After(value = "execution(* *.delete*(..))")
    public void afterAdvice(JoinPoint jp){
        String name = jp.getSignature().getName();
        System.out.println("后置通知的切入点的方法名：" + name);        
        System.out.println("后置通知...");
    }
        
    //返回通知
    @AfterReturning(value = "execution(* *.update*(..))",returning="result")
    public void afterReturningAdvice(JoinPoint jp,Object result){
        String name = jp.getSignature().getName();
        System.out.println("返回通知的切入点的方法名：" + name);        
        System.out.println(result);        
        System.out.println("返回通知...");
    }
        
    //异常通知
    @AfterThrowing(value = "execution(* *.getById*(..))",throwing="ex")
    public void exceptionAdvice(JoinPoint jp,Exception ex){
        String name = jp.getSignature().getName();
        System.out.println("异常通知的切入点的方法名：" + name);        
        System.out.println(ex.getMessage());
        System.out.println("异常通知...");
    }
        
    //环绕通知
    @Around(value = "execution(* *.batch*(..))")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕通知前...");        
        Object result = pjp.proceed();
        String name = pjp.getSignature().getName();
        System.out.println("环绕通知的切入点的方法名：" + name);        
        System.out.println("环绕通知后...");        
        return result;
    }
}

　　　　测试

/**
 * 注解形式的AOP的单元测试类
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-aop-annotation.xml")
public class AnnotationAopTest {
    @Autowired
    private UserService userService;
    
    @Test
    public void test(){
        //注解：前置通知的测试
//        userService.add();
        
        //后置通知的测试
//        userService.delete();
        
        //返回通知
//        userService.update();
        
        //异常通知
//        userService.getById();
        
        //环绕通知
        userService.batch();
    }
}

---

---