Posted 2019-02-10Spring10 minutes read (About 1489 words)

Spring注解驱动开发（四）

AOP面向切面编程

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

底层实现

Spring 的 AOP 的底层用到两种代理机制：

JDK 的动态代理：类必须实现接口，所以是针对实现了接口的类产生代理.
Cglib 的动态代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强的技术生成当前类的子类对象

JDK 的动态代理

UserService接口，实现增删改查的功能

package com.cuzz.service;

public interface UserService {
    void add();
    void delete();
    void update();
    void get();
}

UserService接口的实现的类

public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("添加一个user");
    }

    @Override
    public void delete() {
        System.out.println("删除一个user");
    }

    @Override
    public void update() {
        System.out.println("更新一个user");
    }

    @Override
    public void get() {
        System.out.println("查询一个user");
    }
}

实现动态代理

package com.cuzz.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserServiceProxyFactory implements InvocationHandler{
    
    private UserService us;

    public UserServiceProxyFactory(UserService us) {
        super();
        this.us = us;
    }
    
    // 获得动态代理
    public UserService getUserServiceProxy() {
        // 生成动态代理
        UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
                UserServiceImpl.class.getInterfaces(), 
                this); // 这个 this 就是实现 InvocationHandler 的对象
        return usProxy;
    }
    
    @Override
    public Object invoke(Object arg0, Method method, Object[] arg2)
            throws Throwable {
        System.out.println("打开事务!");
        Object invoke = method.invoke(us, arg2);
        System.out.println("提交事务!");
        return invoke;
    }
}

测试

public class TestDemo {    
    @Test
    public void test01(){
        UserService us = new UserServiceImpl();       
        UserServiceProxyFactory factory = new UserServiceProxyFactory(us);        
        UserService usProxy = factory.getUserServiceProxy();     
        usProxy.add();   
    }
}

输出

打开事务!
添加一个user
提交事务!

Cglib 的动态代理

Cglib 的动态代理的代码实现

package com.cuzz.service;

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class UserServiceProxyFactory2 implements MethodInterceptor {
    
    public UserService getUserServiceProxy(){
        // 帮我们生成代理对象
        Enhancer en = new Enhancer();
        // 设置对谁进行代理
        en.setSuperclass(UserServiceImpl.class);
        // 代理要做什么
        en.setCallback(this);
        // 创建代理对象
        UserService us = (UserService) en.create();
        return us;
    }

    @Override
    public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
        // 打开事务
        System.out.println("打开事务!");
        // 调用原有方法
        Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);
        // 提交事务
        System.out.println("提交事务!");
        
        return returnValue;
    }
}

测试

@Test
public void test02() {    
    UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();  
    UserService usProxy = factory.getUserServiceProxy();
    usProxy.add();
}

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语：

Joinpoint(连接点)：所谓连接点是指那些被拦截到的点，在 spring 中这些点指的是方法，因为 spring 只支持方法类型的连接点
Pointcut(切入点)：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
Advice(通知/增强)：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
Target(目标对象)：代理的目标对象
Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程，spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入
Proxy（代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
Aspect(切面)：是切入点和通知（引介）的结合

通知类型

前置通知：在目标方法执行之前执行
后置通知：在目标方法执行之后执行
环绕通知：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现异常的时候执行
最终通知：无论目标方法是否出现异常最终通知都会执行

代码演示

通知类，给切面的目标方法标注何时地运行，必须告诉 Spring 哪个类是切面类，添加注解 @Aspect

@Aspect  // 表示该类是一个通知类
public class MyAdvice {
    
    // 前置通知
    @Before("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void before(){
        System.out.println("这是前置通知!!");
    }

    // 后置通知
    @AfterReturning("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }
    // 环绕通知
    @Around("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        // 调用目标方法
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知之后的部分!!");
        return proceed;
    }
    // 异常通知
    @AfterThrowing("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }
    // 后置通知
    @After("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

配置类，将切面类和业务逻辑类都加入到容器中，给配置类加 @EnableAspectJAutoProxy 注解

/**
 * @Author: cuzz
 * @Date: 2019/2/10 20:43
 * @Description:
 */
@Configuration
@EnableAspectJAutoProxy
public class MainConfigOfAOP {

    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }

    @Bean
    public MyAdvice myAdvice() {
        return new MyAdvice();
    }
}

测试

@Test
public void test03() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

    UserService userService = (UserService) applicationContext.getBean("userService");
    userService.add();
    userService.delete();
    userService.update();
    userService.get();
}

如果报错添加依赖

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.4</version>
 </dependency>

#Spring 注解源码