spring aop 手动实现简单的动态代理

什么是AOP我们先来看一张图

图中A就是通知，比如你要给每个方法前都加一个before()方法，目标类的每一个方法叫joinpoint（切入点），每个切入点都会用到通知，把通知和切入点连起来，点成线，线成面，这就是切面，也就是AOP，下面我们来简单写个小例子来实现一下

目标类的接口

public interface UserService {

    public void addUser() ;

    public void updateUser();

    public void deleteUser();
}

目标类接口的实现

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("addUser");
    }

    @Override
    public void updateUser() {
        System.out.println("updateUser");
    }

    @Override
    public void deleteUser() {
        System.out.println("deleteUser");
    }
}

通知类

public class MyAspect {

    public void before(){
        System.out.println("before");
    }

    public void after(){
        System.out.println("after");
    }
}

代理类

public class MyBeanFactory {

    public static UserService createService(){
        //1.目标类
        final UserService userService = new UserServiceImpl() ;
        //2.切面类
        final MyAspect myAspect = new MyAspect();
//        切入点和切面类结合



//      三个参数
//        1. loader ,类加载器 运行是加载，用类加载器将其加载到内存
//        2. interfaces 代理类需要实现的所有接口
//        3. invocationHandler 处理类，一般采用匿名内部类
//        提供了invoke方法 代理类每个方法执行时都将调用一次invoke ,又有三个参数
//        1. Object proxy 代理对象
//        2. Method method 代理对象方法的反射
//        3. Object[] args 方法的实际参数
        UserService proxyService = (UserService) Proxy.newProxyInstance(MyBeanFactory.class.getClassLoader(),
                userService.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(method.getName());
                        myAspect.before();
                        Object obj = method.invoke(userService, args);
                        myAspect.after();
                        return obj ;
                    }
                });



        return proxyService ;
    }
}

测试类

public class UserServiceImplTest {
    @org.junit.jupiter.api.Test
    public void demo() throws Exception {
            UserService userService = MyBeanFactory.createService();
            userService.addUser();
            userService.deleteUser();
            userService.updateUser();
    }

}

结果

addUser
before
addUser
after
deleteUser
before
deleteUser
after
updateUser
before
updateUser
after

Process finished with exit code 0

我们可以看到每个方法都执行了通知，用了动态代理就不用手动的给每个方法前后加入通知，这样既节省了时间，也保证了主体代码不被改变