AOP面向切面编程 + 手写AOP框架
核心解读
AOP：Aspect Oriented Programming，面向切面编程
核心1：将公共的，通用的，重复的代码单独开发，在需要时反织回去
核心2：面向接口编程，即设置接口类型的变量，传入接口类型的参数，返回接口类型的返回值，调用接口类型的变量自身的实现方法
图示
图示分析：例如，在开发中普遍需要使用到日志输出功能，会将日志输出功能大量耦合到项目的不同位置，如上图左侧所示。
而日志输出功能与其实与项目本身的核心业务逻辑无关，我们只是为了不时的查看项目的运行状态。
则可以将日志功能单独提出去开发，在需要的地方将日志输出功能(所谓：日志功能切面)反织回去即可，如上图右侧所示。
手写AOP框架
下面将手写5个版本的AOP框架，在版本的不断优化中，逐步理解AOP面向切面编程的核心，最后一个版本最接近Spring中AOP的原生实现
业务功能和切面功能用简单的输出语句来模拟，主要是为了简洁直观的演示AOP核心思想
手写的AOP框架的业务背景：图书购买业务
项目结构
5个AOP版本分别放在proxy01 ～ proxy05这5个包下，下图左侧为项目结构，右侧为各版本用到的接口和实现类
AOP版本1
实体类
整个版本1，只是一个BookService实体类，业务功能和切面功能严重耦合
package com.example.proxy01;
/**
* 图书购买功能和事务切面功能耦合在一个类中
*/
public class BookService {
public void buy(){
try{
System.out.println("开启事务....");
System.out.println("图书购买业务....");
System.out.println("提交事务....");
}catch (Exception e){
System.out.println("回滚事务....");
}
}
}
测试
调用BookService实体对象中的buy()方法即可
AOP版本2
优化原理
通过子类代理来实现将业务功能和切面功能初步拆分解耦
实体类
实体类BookService及其子类SubBookService
BookService实体类
package com.example.proxy02;
/**
* 图书购买功能
*/
public class BookService {
public void buy(){
System.out.println("图书购买功能....");
}
}
SubBookService子类
package com.example.proxy02;
/**
* 子类代理：将图书购买功能和事务切面划分到不同类中
*/
public class SubBookService extends BookService{
@Override
public void buy() {
try{
System.out.println("开启事务事务....");
super.buy();
System.out.println("提交事务....");
}catch (Exception e){
System.out.println("回滚事务....");
}
}
}
测试
调用SubBookService实体类对象中的buy()方法即可
AOP版本3
优化原理
通过静态代理，可以进行受代理对象的灵活切换
接口
Service接口
package com.example.proxy03;
/**
* 静态代理接口
*/
public interface Service {
//定义业务功能
void buy();
}
实现类
BookServiceImpl实现类
package com.example.proxy03;
/**
* 目标对象
*/
public class BookServiceImpl implements Service{
@Override
public void buy() {
System.out.println("图书购买业务....");
}
}
ProductServiceImpl实现类
package com.example.proxy03;
/**
* 另外一种业务功能的目标对象
*/
public class ProductServiceImpl implements Service{
@Override
public void buy() {
System.out.println("产品购买业务....");
}
}
静态代理对象
package com.example.proxy03;
/**
* 静态代理对象
*/
public class Agent implements Service{
//接口类型的参数
Service target;
//传入接口类型的参数，灵活调用多种Service接口的实现类
public Agent(Service target){
this.target = target;
}
@Override
public void buy() {
try{
System.out.println("开启事务....");
target.buy();
System.out.println("提交事务....");
}catch (Exception e){
System.out.println("关闭事务....");
}
}
}
测试
面向接口编程，可灵活代理多种Service接口的实现类，灵活切换受代理对象
package com.example.test;
import com.example.proxy03.Agent;
import com.example.proxy03.ProductServiceImpl;
import com.example.proxy03.Service;
import org.junit.Test;
public class TestProxy03 {
@Test
public void testProxy03(){
//可以灵活切换受代理对象，因为接口类型的参数都能接住
//Service agent = new Agent(new BookServiceImpl());
Service agent = new Agent(new ProductServiceImpl());
agent.buy();
}
}
AOP版本4
优化原理
AOP版本3中，虽然受代理对象可以灵活切换，但是不同的受代理对象被绑定到相同的切面功能，切面功能无法灵活切换
可以将上述切面功能上升到接口层次，针对不同切面功能有不同实现类
核心：就像Agent代理对象持有Service接口类型的变量一样，若持有切面接口类型的变量，则可以接收不同切面接口的实现类，实现不同切面功能的灵活切换
考虑到切面功能出现在业务功能的前后关系，以及异常处理等情况，可以根据切面出现的时机定义切面接口中的方法
推导出需要定义切面接口以及如何定义接口中方法的思路图示
接口
业务接口：Service接口
package com.example.proxy04;
/**
* 静态代理接口
*/
public interface Service {
//定义业务功能
void buy();
}
切面接口：Aop接口
package com.example.proxy04;
/**
* 自定义Aop,切面接口
*/
public interface Aop {
default void before(){} //default关键字，jdk8的新特性，可以提供空实现，不强迫接口实现类实现所有接口中的方法
default void after(){} //实现类需要实现哪个方法就实现哪个方法
default void exception(){}
}
实现类
业务功能实现类：BookServiceImpl和ProductServiceImpl
package com.example.proxy04;
/**
* 目标对象
*/
public class BookServiceImpl implements Service {
@Override
public void buy() {
System.out.println("图书购买业务....");
}
}
package com.example.proxy04;
public class ProductServiceImpl implements Service {
@Override
public void buy() {
System.out.println("产品生产业务....");
}
}
切面功能实现类：TransAopImpl和LogAopImpl
package com.example.proxy04;
public class TransAopImpl implements Aop{
@Override
public void before() {
System.out.println("开启事务....");
}
@Override
public void after() {
System.out.println("提交事务....");
}
@Override
public void exception() {
System.out.println("回滚事务....");
}
}
package com.example.proxy04;
//切面接口中定义方法时使用了default，不必实现所有接口方法，按需实现方法即可
public class LogAopImpl implements Aop{
@Override
public void before() {
System.out.println("前置日志输出....");
}
}
测试
可以实现业务功能和切面功能的灵活组合
而且就像下面第2个测试一样，因为代理对象也是Service的一个实现类，所以代理对象还可以再次被代理，一个业务功能被多个切面包围，实现多切面
此时的版本已经很灵活，也已经揭示出了AOP面向切面编程的核心
package com.example.test;
import com.example.proxy04.*;
import org.junit.Test;
public class TestProxy04 {
//测试：单个业务功能 + 单个切面功能
@Test
public void testProxy04(){
//分别传入要完成的业务功能和要切入的功能，可以灵活组合，这里就可以有业务功能和切面功能的4种组合：2 x 2
//Service agent = new Agent(new ProductServiceImpl(), new LogAopImpl());
//Service agent = new Agent(new ProductServiceImpl(), new TransAopImpl());
//Service agent = new Agent(new BookServiceImpl(), new LogAopImpl());
Service agent = new Agent(new BookServiceImpl(), new TransAopImpl());
agent.buy();
}
//测试：单个业务功能 + 多个切面功能(本例为：日志切面 + 事务切面)
@Test
public void testManyProxies(){
Service agent = new Agent(new ProductServiceImpl(), new LogAopImpl());
Service agent2 = new Agent(agent, new TransAopImpl());
agent2.buy();
}
}
AOP版本5
优化原理
静态代理可以做到受代理对象的灵活切换，但是不可以做到代理功能的灵活切换，就像我们用动态代理优化静态代理一样，还可以用jdk动态代理继续优化上述AOP版本4
在Spring原生的AOP框架中，底层就是使用的jdk动态代理，AOP版本5最接近Spring原生AOP框架
实体类
AOP版本5中除了用ProxyFactory代理工厂来动态获取代理对象外(不再写AOP版本4中的Agent类，4版本是静态的，现在不用写了)，其他接口和实现类与AOP版本4完全一致，不再赘述
新增ProxyFactory类，代替AOP版本4中的Agent类
参数比较多，看起来有些乱(包涵 包涵)，若对jdk动态代理不是很熟悉，可以参考mybatis博客集(mybatis 01 对jdk动态代理有详细讨论)
package com.example.proxy05;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理工厂，获取动态代理对象
*/
public class ProxyFactory {
//静态方法获取jdk动态代理对象：传入业务功能对象 + 切面功能对象
public static Object getProxy(Service target, Aop aop){
//该方法有三个参数，第三个参数是一个匿名内部类
return Proxy.newProxyInstance(
//参数1
target.getClass().getClassLoader(),
//参数2
target.getClass().getInterfaces(),
//参数3：匿名内部类重写的方法又有三个参数
//其中method用来反射调用外部调用的那个方法，args是调用目标方法时要传的参数
new InvocationHandler() {
@Override
public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
//用来存放目标对象被调用的方法的返回值
Object res = null;
try{
//切面功能
aop.before();
//业务功能，根据外部调用的功能，动态代理目标对象被调用的方法
res = method.invoke(target, args);
//切面功能
aop.after();
}catch (Exception e){
//切面功能
aop.exception();
}
//返回目标对象被调用的方法的返回值给外部调用者
return res;
}
}
);
}
}
测试
package com.example.test;
import com.example.proxy05.BookServiceImpl;
import com.example.proxy05.ProxyFactory;
import com.example.proxy05.Service;
import com.example.proxy05.TransAopImpl;
import org.junit.Test;
public class TestProxy05 {
//测试：AOP版本5
@Test
public void testProxy05(){
//获取动态代理对象，传入业务功能对象和切面功能对象，这里传入的业务对象和切面对象可以有多种组合
Service agent = (Service) ProxyFactory.getProxy(new BookServiceImpl(), new TransAopImpl());
//完成业务功能和切面功能的组合
agent.buy();
}
}
测试输出
开启事务....
图书购买业务....
提交事务....
Process finished with exit code 0
扩展测试
为了体现动态代理的优点，并测试有参数和有返回值的方法都可被代理，为Service接口扩展功能：order（预定图书的功能)
接口
Service接口新增order方法
package com.example.proxy05;
/**
* 静态代理接口
*/
public interface Service {
//定义业务功能
void buy();
//新扩展一个预定功能
default String order(int orderNums){return null;}
//default,不强制实现类都实现该方法，按需实现
}
实现类
让BookServiceImpl实现该新增的方法
package com.example.proxy05;
/**
* 目标对象
*/
public class BookServiceImpl implements Service {
@Override
public String order(int orderNums) {
System.out.println("新预定图书: " + orderNums + " 册");
return "预定成功";
}
@Override
public void buy() {
System.out.println("图书购买业务....");
}
}
测试
package com.example.test;
import com.example.proxy05.BookServiceImpl;
import com.example.proxy05.ProxyFactory;
import com.example.proxy05.Service;
import com.example.proxy05.TransAopImpl;
import org.junit.Test;
public class TestProxy05 {
@Test
public void testProxy05(){
//获取动态代理对象，传入业务功能对象和切面功能对象
Service agent = (Service) ProxyFactory.getProxy(new BookServiceImpl(), new TransAopImpl());
//完成业务功能和切面功能的组合
String res = agent.order(10);
System.out.println("返回结果: " + res);
}
}
测试结果
开启事务....
新预定图书: 10 册
提交事务....
返回结果: 预定成功
Process finished with exit code 0
小结
在AOP版本3优化了业务功能(静态代理)
在AOP版本4优化了切面功能(AOP面向切面编程)
在AOP版本5优化了代理功能(jdk动态代理)
此时手写的AOP版本5可以做到被代理对象的灵活切换，代理功能的灵活切换，业务功能和切面功能的灵活组合
AOP版本5最接近Spring中AOP的原生实现原理
