深入理解Java设计模式-代理模式

不念不忘少年蓝@ 2023-07-15 06:00 4阅读 0赞

### 代理模式 ###

*   *   *  什么是代理模式
         *  代理模式应用场景
         *  代理的分类
         *  三种代理的区别
         *  用代码演示三种代理
         *   *  1.静态代理
             *  2.动态代理
             *  3.CGLIB动态代理

### 什么是代理模式 ###

通过代理控制对象的访问，可以在这个对象调用方法之前、调用方法之后去处理/添加新的功能。(也就是AO的P微实现)

代理在原有代码乃至原业务流程都不修改的情况下，直接在业务流程中切入新代码，增加新功能，这也和Spring的（面向切面编程）很相似

### 代理模式应用场景 ###

Spring AOP、日志打印、异常处理、事务控制、权限控制等

### 代理的分类 ###

静态代理(静态定义代理类)  
动态代理(动态生成代理类，也称为Jdk自带动态代理)  
Cglib 、javaassist（字节码操作库）

### 三种代理的区别 ###

1.  静态代理：简单代理模式，是动态代理的理论基础。常见使用在代理模式
2.  jdk动态代理：使用反射完成代理。需要有顶层接口才能使用，常见是mybatis的mapper文件是代理。
3.  cglib动态代理：也是使用反射完成代理，可以直接代理类（jdk动态代理不行），使用字节码技术，不能对 final类进行继承。（需要导入jar包）

### 用代码演示三种代理 ###

#### 1.静态代理 ####

**什么是静态代理**  
由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

**代码演示：**  
我有一段这样的代码：（如何能在不修改UserDao接口类的情况下开事务和关闭事务呢）

package com.lijie;
    
    //接口类
    public class UserDao{ 
    	public void save() { 
    		System.out.println("保存数据方法");
    	}
    }

package com.lijie;
    
    //运行测试类
    public  class Test{ 
    	public static void main(String[] args) { 
    		UserDao userDao = new UserDao();
    		userDao.save();
    	}
    }

**修改代码，添加代理类**

package com.lijie;
    
    //代理类
    public class UserDaoProxy extends UserDao { 
    	private UserDao userDao;
    
    	public UserDaoProxy(UserDao userDao) { 
    		this.userDao = userDao;
    	}
    
    	public void save() { 
    		System.out.println("开启事物...");
    		userDao.save();
    		System.out.println("关闭事物...");
    	}
    
    }

//添加完静态代理的测试类
    public class Test{ 
    	public static void main(String[] args) { 
    		UserDao userDao = new UserDao();
    		UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
    		userDaoProxy.save();
    	}
    }

**缺点：每个需要代理的对象都需要自己重复编写代理，很不舒服，  
优点：但是可以面相实际对象或者是接口的方式实现代理**

#### 2.动态代理 ####

**什么是动态代理**  
动态代理也叫做，JDK代理、接口代理。

动态代理的对象，是利用JDK的API，动态的在内存中构建代理对象（是根据被代理的接口来动态生成代理类的class文件，并加载运行的过程），这就叫动态代理

package com.lijie;
    
    //接口
    public interface UserDao { 
        void save();
    }

package com.lijie;
    
    //接口实现类
    public class UserDaoImpl implements UserDao { 
    	public void save() { 
    		System.out.println("保存数据方法");
    	}
    }

//下面是代理类，可重复使用，不像静态代理那样要自己重复编写代理

package com.lijie;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    // 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
    public class InvocationHandlerImpl implements InvocationHandler { 
    
    	// 这其实业务实现类对象，用来调用具体的业务方法
        private Object target;
    
        // 通过构造函数传入目标对象
        public InvocationHandlerImpl(Object target) { 
            this.target = target;
        }
    
        //动态代理实际运行的代理方法
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            System.out.println("调用开始处理");
            //下面invoke()方法是以反射的方式来创建对象，第一个参数是要创建的对象，第二个是构成方法的参数，由第二个参数来决定创建对象使用哪个构造方法
    		Object result = method.invoke(target, args);
            System.out.println("调用结束处理");
            return result;
        }
    }

//利用动态代理使用代理方法

package com.lijie;
    
    import java.lang.reflect.Proxy;
    
    public class Test { 
        public static void main(String[] args) { 
            // 被代理对象
            UserDao userDaoImpl = new UserDaoImpl();
            InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDaoImpl);
    
            //类加载器
            ClassLoader loader = userDaoImpl.getClass().getClassLoader();
            Class<?>[] interfaces = userDaoImpl.getClass().getInterfaces();
    
            // 主要装载器、一组接口及调用处理动态代理实例
            UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
            newProxyInstance.save();
        }
    }

**缺点：必须是面向接口，目标业务类必须实现接口**  
**优点：不用关心代理类，只需要在运行阶段才指定代理哪一个对象。**

#### 3.CGLIB动态代理 ####

**CGLIB动态代理原理：**  
利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

**什么是CGLIB动态代理**  
CGLIB动态代理和jdk代理一样，使用反射完成代理，不同的是他可以直接代理类（jdk动态代理不行，他必须目标业务类必须实现接口），CGLIB动态代理底层使用字节码技术，CGLIB动态代理不能对 final类进行继承。（CGLIB动态代理需要导入jar包）

**代码演示：**

package com.lijie;
    
    //接口
    public interface UserDao { 
        void save();
    }

package com.lijie;
    
    //接口实现类
    public class UserDaoImpl implements UserDao { 
    	public void save() { 
    		System.out.println("保存数据方法");
    	}
    }

package com.lijie;
    
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    import java.lang.reflect.Method;
    
    //代理主要类
    public class CglibProxy implements MethodInterceptor { 
    	private Object targetObject;
    	// 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
    	public Object getInstance(Object target) { 
    		// 设置需要创建子类的类
    		this.targetObject = target;
    		Enhancer enhancer = new Enhancer();
    		enhancer.setSuperclass(target.getClass());
    		enhancer.setCallback(this);
    		return enhancer.create();
    	}
    
    	//代理实际方法
    	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
    		System.out.println("开启事物");
    		Object result = proxy.invoke(targetObject, args);
    		System.out.println("关闭事物");
    		// 返回代理对象
    		return result;
    	}
    }

package com.lijie;
    
    //测试CGLIB动态代理
    public class Test { 
        public static void main(String[] args) { 
            CglibProxy cglibProxy = new CglibProxy();
            UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDaoImpl());
            userDao.save();
        }
    }