SpringAOP底层实现原理

第四章AOP实现底层原理

1.AOP概念

AOP 面向切面编程 == spring动态代理开发
	以切面基本单位完成程序开发，通过切面之间的彼此协同，完成程序开发
	切面 = 切入点 + 额外功能
OOP 面向对象编程
	以对象为基本单位完成程序开发，通过对象间的相互协同，完成程序构建
POP 面向过程编程
	以函数为基本单位完成程序开发，通过函数间的相互调用，完成程序构建

2.切面名词解释

切面 = 切入点 + 额外功能

面 = 点 + 相同性质

需要给多个原始类加入相同的额外功能 那么就相当于是一个切面

3.AOP的底层实现原理

3.1核心问题

1.AOP如何创建动态代理类
	动态字节码技术 
2.通过原始对象的id值获得的是代理类的对象

3.2JDKProxy动态代理类创建

package com.xia.jdk;

import com.xia.basic.User;
import com.xia.proxy.UserService;
import com.xia.proxy.UserServiceImpl;

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

public class TestJDKProxy {
    public static void main(String[] args) {
        // 1.创建原始对象
        UserService userService = new UserServiceImpl();
        // 2.创建动态代理

        // InvocationHandler 实现额外功能
        // 用于添加额外功能和之前的MethodInterceptor类似
        // 其实就是对Invocation实现了封装
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // proxy 原始对象 method原始方法 args 方法参数
                System.out.println("------JDKProxyBefore-----");
                Object ret = method.invoke(userService,args);
                System.out.println("------JDKProxyAfter-----");
                return ret;
            }
        };
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(
                /*
                * 类加载器功能
                * 1.把对应类的字节码文件加载入jvm内存中
                * 2.创建这个类的类对象 Class
                * 3.借一个类加载器
                * */
                TestJDKProxy.class.getClassLoader(),
                // 获得原始对象的所有的接口 这样就可以创建和原始类实现相同接口的代理类
                userService.getClass().getInterfaces(),
                // 额外功能
                handler);
        userServiceProxy.login(new User());

    }
    
}

3.3Cglib动态代理

public class TestCjLib {
    public static void main(String[] args) {
        // 创建原始对象
        UserService userService = new UserService();
        // cglib创建代理对象
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(TestCjLib.class.getClassLoader());
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("cglib--before");
                Object ret = method.invoke(userService, "夏冬","123456");
                System.out.println("cglib--after");
                return ret;
            }
        });
        UserService userServiceProxy = (UserService)enhancer.create();
        userServiceProxy.login("xiadong","123456");
    }
}

3.4总结

jdk动态代理:通过接口创建代理类
cjlib动态代理:通过父类创建代理类

3.5Spring工厂如何加工原始对象

public class ProxyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(bean.getClass());
        enhancer.setClassLoader(ProxyBeanPostProcessor.class.getClassLoader());
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("beanPostProcessor--before");
                Object invoke = method.invoke(bean, objects);
                System.out.println("beanPostProcessor--after");
                return invoke;
            }
        });
        return enhancer.create();
    }
}