静态代理、动态代理、springAOP、spring事务

今天药忘吃喽~ 2022-11-16 05:51 166阅读 0赞

### 静态代理 ###

public interface UserService {
        public void register(User user);
        public boolean login(String name,String password);
    }

public class UserServiceImpl implements UserService{
        @Override
        public void register(User user) {
            System.out.println("userServiceImpl.register....");
        }
    
        @Override
        public boolean login(String name, String password) {
            System.out.println("userServiceImpl.login....");
            return false;
        }
    }

public class UserServiceStaticProxy implements UserService{
        private UserServiceImpl userService = new UserServiceImpl();
        @Override
        public void register(User user) {
            System.out.println("----增强方法---");
            userService.register(user);
        }
    
        @Override
        public boolean login(String name, String password) {
            System.out.println("---增强方法---");
            userService.login(name,password);
            return false;
        }
    
    }

public class TestProx {
        @Test
        public void test(){
            UserService userService = new UserServiceStaticProxy();
            userService.login("aa","123");
        }
    }

缺点 ：每一个类都需要一个代理类，导致类特别多           增强方法如果需要改变每个代理类都需要改变

### 动态代理    (这里所说的动态代理是spring提供的动态代理类，底层依旧是jdk、cglib动态代理) ###

userService类  和UserServiceImpl 类  同上静态代理   额外添加一个Before类继承MethodBeforeAdvice  并且加入spring容器

import java.lang.reflect.Method;
    public class Before implements MethodBeforeAdvice {
        @Override
        /**
         * 把加强的额外功能写在before方法中
         */
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("----增强方法---");
        }
    }

或则是MethodInterceptor 实现类

import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    public class MyMotherInterceptor implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {    //invocation 封装了jdk动态代理的这几个参数  Object proxy, Method method, Object[] args
            System.out.println("befor-------原始方法前后可以执行自己逻辑---------");
            Object object = invocation.proceed();   //代表原始方法运行，可以是login(),也可以是regist()
            System.out.println("after-------原始方法前后可以执行自己逻辑---------");
            return object;
        }
    }

application.xml 中添加

此时从spring容器中获取的UserserviceImpl 变为动态代理类

MethodBeforeAdvice、MethodInterceptor 整个过程大致就是使用的jdk提供的动态代理的接口InvocationHandler（提供额外方法）和Proxy

我的理解Aop 是通过一系列的注解或则标签，拿到对应的类的方法，然后通过spring提供的MethodBeforeAdvice或则MethodInterceptor动态代理添加额外方法，即aop的切入方法 （不一定对，自己猜测）

写一个JDK 动态代理

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    public class JDKProxyDemo {
        public static void main(String[] args) {
            UserService userService =new UserServiceImpl();
    //    InvocationHandler handler = new InvocationHandler() {
    //        @Override
    //        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //            return null;
    //        }
    //    };
            InvocationHandler handler = (proxy,method,arg)->{
                System.out.println("befor-------原始方法前后可以执行自己逻辑---------");
                Object ret = method.invoke(userService,arg);  //执行原始方法
                System.out.println("after-------原始方法前后可以执行自己逻辑---------");
                return ret;
            };
            UserService userService1Proxy =(UserService) Proxy.newProxyInstance(JDKProxyDemo.class.getClassLoader(),userService.getClass().getInterfaces(),handler );
            userService1Proxy.login("aaa","123");
        }
    }

Aop的底层实现

/**
    *此伪代码
    */
    public class MyBeanPostProessor implements BeanPostProcessor {
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            return bean;
        }
    
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {   //bean  就是被代理类userService
           UserServiceProxy = Proxy.newProxyInstance(classloader,interface,invocationHandler)
           return UserServiceProxy;   返回的也是代理对象，所以aop 代理类通过bean id获取的是代理对象
        }
    }
    
    
    /**
    *实现代码
    */
    
    class MyBeanPostProessor implements BeanPostProcessor {
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            return bean;
        }
    
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            //bean  就是被代理类userService
           InvocationHandler handler =(proxy,method,args)->{
               System.out.println("------加强方法------");
               Object object = method.invoke(bean,args);
               return object;
           };
           return Proxy.newProxyInstance(MyBeanPostProessor.class.getClassLoader(),bean.getClass().getInterfaces(),handler)
    
        }
    }