《Spring AOP面向切面编程》(上)

1.AOP概览

AOP（Aspect Oriented Programming），什么是面向切面编程？
1）AOP是一种编程范式，不是编程语言

• 编程范式概览
• 面向过程编程
• 面向对象编程
• 函数式编程
• 事件驱动编程
• 面向切面编程

2）AOP是为了解决特定问题，不是解决所有问题。AOP是OOP的补充，不是替代关系。
AOP的初衷是关注点隔离
切面隔离：将功能性需求和非功能性需求分离开来

做系统设计时，通常将大系统做分解，按业务功能分解成一个个低耦合、高内聚的模块。
分解后发现有趣的事情是，有些东西是公用的，或者跨越了多个模块。

• 日志：对特定的操作输出日志来记录
• 安全：在操作之前进行操作检查
• 性能：统计每个方法的执行时间
• 事务：方法开始前开始事务，方法结束后提交或回滚事务

我们可以将这些通用模块写好，在实现业务模块的时候去调用就好了。

但是，功能是实现了，但是业务代码中大部分都是日志、性能、事务等，几乎把真正的业务代码给淹没了！
最好的方法是将日志、安全、事务这样的代码和业务代码完全隔离开来，因为他们的关注点和业务代码的关注点完全不同。
他们之间的关系应该是正交的。如果把这个业务功能看成一层层面包的话， 这些日志/安全/事务 像不像一个个“切面”(Aspect) ？
如果我们能让这些“切面“能和业务独立， 并且能够非常灵活的“织入”到业务方法中， 那就实现了面向切面编程(AOP)！

AOP的应用场景

• 审计日志：对特定的操作输出日志来记录
• 权限控制：在操作之前进行操作检查
• 性能监控：统计每个方法的执行时间
• 事务控制：方法开始前开始事务，方法结束后提交或回滚事务
• 缓存控制
• 异常处理
  根据织入时机的不同，AOP可以分为以下3种实现方式
  1）编译期织入（AspectJ）
  2）类加载时织入（AspectJ 5+）
  3）运行时织入（Spring AOP）

2.Spring AOP的使用举例

Spring AOP实现权限控制：只有管理员可以进行修改操作

@Service
public class ProductService {
    
    public Product get(Long id) {
        System.out.println("get product id = " + id);
        return new Product(id, "aaa");
    }
    
    @AdminOnly
    public void insert(Product product) {
        System.out.println("insert product");
    }
​
    @AdminOnly
    public void delete(Long id) {
        System.out.println("delete product id = " + id);
    }
}

@Aspect  //1）表明这个是一个切面类
@Component
public class SecurityAspect {
    //2）切入点
    @Pointcut("@annotation(AdminOnly)")
    public void adminOnly() {
    }
    //3）通知
    @Before("adminOnly()")
    public void check() {
        String user = CurrentUserHolder.get();
        if (!"admin".equals(user)) {
            throw new RuntimeException("operation not allow");
        }
    }
}

PointCut切入点

PointCut（切入点）：一个方法或一组方法（可以通过通配符支持）。
比如，“对于com.xxx这个包中所有类的execute方法” 。

Advice通知

Advice（通知）：方法调用时需要做什么。比如，”在方法调用之前/之后 ， 需要执行xxx操作“ 。
具体的通知类型包括：

• before：前置通知，在方法调用前执行。
• after returning：方法返回通知，在方法正常返回时执行。
• throwing：方法异常通知，在方法抛出异常时执行。
• after：方法结束通知，包含了方法正常返回和方法抛出异常两种情况。
• around：环绕通知。

3.Spring AOP的实现原理

3.1运行时织入

根据织入时机的不同，AOP可以分为以下3种实现方式

1）编译期织入（AspectJ）
2）类加载时织入（AspectJ 5+）
3）运行时织入（Spring AOP）

Spring中的AOP实现是在运行时织入的。
运行时织入是如何实现的呢？通过动态代理的方式。

3.1.1代理模式

什么是代理模式

调用方Caller通过Proxy代理对象间接地与目标对象Target交互。
类图

两个关键点：
1）Client客户端通过接口引用操作的对象Subject。且RealSubject真实对象和Proxy代理对象实现了同一个接口
2）Proxy代理对象会持有RealSubject真实对象的引用，真正要执行的方法委托给真实对象来执行，自己则执行一些额外的逻辑

public interface Subject {
    void request() throws Exception;
}

public class RealSubject implements Subject {

    public void request() {
        System.out.println("RealSubject execute request()");
    }
}

public class Proxy implements Subject {

    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
    /**
    * 在真实对象request()方法之前或之后，可以执行一些额外的操作
    */
    public void request() throws Exception{
        System.out.println("before");
        try {
            realSubject.request();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }
}

public class Client {

    public static void main(String[] args) throws Exception{
        Subject subject = new Proxy(new RealSubject());
        subject.request();
    }
}

运行结果

before
RealSubject execute request()
after

上面代码展示的是静态代理的实现。

静态代理有如下缺点：
1）假设真实对象有100方法，则代理对象需要对100个方法进行委托。
2）且在这100个方法中代理对象执行的额外逻辑是一样的。
就像下面代码展示的那样。

public interface Subject {
    void request() throws Exception;
    void request2() throws Exception;
    void request3() throws Exception;
    void request4() throws Exception;

public class RealSubject implements Subject {

    public void request() {
        System.out.println("RealSubject execute request()");
    }

    public void request2() {
        System.out.println("RealSubject execute request2()");
    }

    public void request3() {
        System.out.println("RealSubject execute request3()");
    }

    public void request4() {
        System.out.println("RealSubject execute request4()");
    }
}

public class Proxy implements Subject {

    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() throws Exception{
        System.out.println("before");
        try {
            realSubject.request();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }
    
    //静态代理的缺点：
    //由于Subject添加了request2()、request3()、request4()方法，代理类中也要实现相应的方法
    //而且代理对象在request2()、request3()、request4()等方法中额外需要执行的逻辑都是一样的。
    public void request2() throws Exception{
        System.out.println("before");
        try {
            realSubject.request2();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }

    public void request3() throws Exception{
        System.out.println("before");
        try {
            realSubject.request3();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }

    public void request4() throws Exception{
        System.out.println("before");
        try {
            realSubject.request4();
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after");
        }
    }   
}

由于静态代理有上面的缺点，就产生了动态代理技术。

动态代理有两种实现方式
1）基于接口实现：JDK动态代理
2）基于继承实现：cglib动态代理

3.1.2 JDK动态代理

将上面的静态代理实现，改为使用JDK动态代理后，代码如下。

public class JdkProxySubject implements InvocationHandler {

    private RealSubject realSubject;

    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = null;
        try {
           result = method.invoke(realSubject, args);
        } catch (Exception e) {
            throw e;
        } finally {
            System.out.println("after");
        }
        return result;
    }
}

public class Client {

    public static void main(String[] args) throws Exception {
        //通过调用Proxy.newProxyInstance生成代理对象
        //方法参数为：1）classLoader  2）要代理的接口 3）代理对象的InvocationHandler
        //(通过方法参数也可以看出来，JDK代理只能通过代理接口来来实现动态代理)
        Subject subject = (Subject) Proxy.newProxyInstance(Client.class.getClassLoader(),
                new Class[]{Subject.class}, new JdkProxySubject(new RealSubject()));
        //调用代理对象的request方法。
        //（根据InvocationHandler接口的定义，可以知道实际调用的是JdkProxySubject里的invoke方法）
        subject.request();
    }
}

JDK动态代理实现原理 //

3.1.3 cglib动态代理

将上面的静态代理实现，改为使用cglib动态代理后，代码如下。

public class DemoMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("before in cglib");
        Object result = null;
        try {
            //注意：调用的是proxy.invokeSuper来调用目标类的方法
            result = methodProxy.invokeSuper(o, args);
        } catch (Exception e) {
            System.out.println("ex:" + e.getMessage());
            throw e;
        } finally {
            System.out.println("after in cglib");
        }
        return null;
    }
}

public class Client {

    public static void main(String[] args) throws Exception {
        //创建一个增强器
        Enhancer enhancer = new Enhancer();
        //设置目标类
        enhancer.setSuperclass(RealSubject.class);
        //设置拦截对象
        enhancer.setCallback(new DemoMethodInterceptor());
        //生成代理对象
        Subject subject = (Subject) enhancer.create();
        //调用代理对象的request方法
        subject.request();
    }
}

3.1.4 Spring如何创建代理bean

动态代理有两种实现方式，JDK动态代理和cglib动态代理，那Spring是如何选择的？

ProxyFactoryBean的getObject()方法

@Override
public Object getObject() throws BeansException {
		initializeAdvisorChain();
    //对singleton和prototype的类型进行区分，生成对应的proxy
		if (isSingleton()) {
			return getSingletonInstance();
		}
		else {
			if (this.targetName == null) {
				logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
						"Enable prototype proxies by setting the 'targetName' property.");
			}
			return newPrototypeInstance();
		}
	}

getSingletonInstance()方法

	/**
	 * Return the singleton instance of this class's proxy object,
	 * lazily creating it if it hasn't been created already.
	 * @return the shared singleton proxy
	 */
	private synchronized Object getSingletonInstance() {
		if (this.singletonInstance == null) {
			this.targetSource = freshTargetSource();
			if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
				// Rely on AOP infrastructure to tell us what interfaces to proxy.
				Class<?> targetClass = getTargetClass();
				if (targetClass == null) {
					throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
				}
				setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
			}
			// Initialize the shared singleton instance.
			super.setFrozen(this.freezeProxy);
			this.singletonInstance = getProxy(createAopProxy());
		}
		return this.singletonInstance;
	}

其中，生成代理实例的代码是这句。

	this.singletonInstance = getProxy(createAopProxy());

可以将这句代码拆成下面两句。
1）aopProxy = createAopProxy()。
2）this.singletonInstance = getProxy(aopProxy) 。

createAopProxy()

createAopProxy()的方法如下。

protected final synchronized AopProxy createAopProxy() {
		if (!this.active) {
			activate();
		}
		return getAopProxyFactory().createAopProxy(this);
	}

其中getAopProxyFactory()返回一个AopProxyFactory。在这里，返回的是AopProxyFactory的默认实现DefaultAopProxyFactory。

DefaultAopProxyFactory的createAopProxy()方法

/**
 * Default {@link AopProxyFactory} implementation, creating either a CGLIB proxy
 * or a JDK dynamic proxy.
 *
 * <p>Creates a CGLIB proxy if one the following is true for a given
 * {@link AdvisedSupport} instance:
 * <ul>
 * <li>the {@code optimize} flag is set
 * <li>the {@code proxyTargetClass} flag is set
 * <li>no proxy interfaces have been specified
 * </ul>
 *
 * <p>In general, specify {@code proxyTargetClass} to enforce a CGLIB proxy,
 * or specify one or more interfaces to use a JDK dynamic proxy.
 */
@SuppressWarnings("serial")
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    //如果满足下面3个条件，将使用cglib动态代理
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
      //以下两种情况除外
      //targetClass是接口   或者  targetClass本身就是使用jdk动态代理的proxy
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
    //否则，使用jdk动态代理
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

	/**
	 * Determine whether the supplied {@link AdvisedSupport} has only the
	 * {@link org.springframework.aop.SpringProxy} interface specified
	 * (or no proxy interfaces specified at all).
	 */
	private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
		Class<?>[] ifcs = config.getProxiedInterfaces();
		return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
	}
}

1）如果目标对象实现了接口，则默认采用JDK动态代理
2）如果目标对象没有实现接口，则采用cglib进行动态代理
3）如果目标对象实现了接口，且强制cglib代理，则使用cglib动态代理

getProxy(aopProxy)

protected Object getProxy(AopProxy aopProxy) {
    return aopProxy.getProxy(this.proxyClassLoader);
}

如果入参中的aopProxy是JdkDynamicAopProxy的实例的话，会调用JdkDynamicAopProxy类中的方法。

如果入参中的aopProxy是ObjenesisCglibAopProxy的实例的话，会调用ObjenesisCglibAopProxy类中的方法。

JdkDynamicAopProxy.getProxy()方法

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
 
  @Override
	public Object getProxy(ClassLoader classLoader) {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
		}
		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}
}

可以看到JdkDynamicAopProxy实现了InvocationHandler接口，并通过Proxy.newProxyInstance(classLoader, proxiedInterfaces, this)生成代理对象。

ObjenesisCglibAopProxy.getProxy()方法

与下面代码逻辑类似。

 Enhancer enhancer = new Enhancer();
        //设置目标类
        enhancer.setSuperclass(RealSubject.class);
        //设置拦截对象
        enhancer.setCallback(new DemoMethodInterceptor());
        //生成代理对象
        Subject subject = (Subject) enhancer.create();
        //调用代理对象的request方法
        subject.request();

参考：
https://chuansongme.com/n/399865051525 （Spring本质系列(2)-AOP）