目录
1.代理模式
“为其他对象提供一种代理，以控制这个对象的访问”，作为官方是这么定义的。简言之，A类自己做一件事，使用代理后，A类不直接做，而由A类的代理类B做。代理类其实就是在之前类的基础上做了一层封装。java中有静态代理/jdk动态代理/cglib动态代理，静态代理是在编译期就存在的，相反动态代理是在程序运行期动态生成的。
2.静态代理
程序运行前，代理类和被代理类的关系就已经确定了。实现步骤：定义一个公共接口，供代理类和被代理类实现。
缺点：有几个需要被代理的方法，就要为几个方法进行代理，维护成本高。
公共接口：
package cn.com.staticProxy;
/**
* *
*<p>Title: IUserDao</p>
* <p>Description:公共的接口</p>
* <p>Company: </p>
* @author Administrator
* @date 2020年3月24日 下午4:15:12
*/
public interface IUserDao {
void save();
void find();
}被代理类：
package cn.com.staticProxy;
public class UserDao implements IUserDao{
/**
* 被代理类或者叫代理目标类
*/
@Override
public void save() {
// TODO Auto-generated method stub
System.out.println("模拟保存用户");
}
@Override
public void find() {
// TODO Auto-generated method stub
System.out.println("模拟查找用户");
}
}被代理类上可以看到，被代理类要做的就是save和find操作，如果不使用代理模式，那么我们的使用方式则是直接使用：
package cn.com.staticProxy;
/**
* *
*<p>Title: Test2</p>
* <p>Description:直接使用被代理类 </p>
* <p>Company: </p>
* @author Administrator
* @date 2020年3月24日 下午4:18:39
*/
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
IUserDao udp=new UserDao();
udp.save();
System.out.println("-------------------");
udp.find();
}
}结果：
模拟保存用户
-------------------
模拟查找用户代理类：
package cn.com.staticProxy;
public class UserDaoProxy implements IUserDao {
private UserDao ud = new UserDao();
@Override
public void save() {
// TODO Auto-generated method stub
System.out.println("代理操作，开启事务");
ud.save();
System.out.println("代理操作，关闭事务");
}
@Override
public void find() {
// TODO Auto-generated method stub
System.out.println("代理操作，开启事务");
ud.find();
System.out.println("代理操作，关闭事务");
}
}可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例，通过被代理类实例调用被代理对象的方法，另外在方法之前前后均可加入其它的方法处理逻辑，
最后，看使用代理类的测试方法：
package cn.com.staticProxy;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
IUserDao udp=new UserDaoProxy();
udp.save();
System.out.println("-------------------");
udp.find();
}
}结果：
代理操作，开启事务
模拟保存用户
代理操作，关闭事务
-------------------
代理操作，开启事务
模拟查找用户
代理操作，关闭事务可以发现使用了代理之后，可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作。缺点就是如果被代理方法很多，就要为每个方法进行代理，增加了代码维护的成本。有没有其他的方式可以减少代码的维护，那就是动态代理。
3.JDK动态代理
(应用：Spring aop 、mybatis mapper接口映射)
Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。下面我们来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中
Mapper 接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Mapper接口生成代理对象proxy，代理对象会拦截接口方法，根据类的全限定名+方法名，唯一定位到一个MapperStatement并调用执行器执行所代表的sql，然后将sql执行结果返回
代理类：
package cn.com.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;
/**
* *
*<p>Title: DynamicProxy</p>
* <p>Description: 动态代理类</p>
* <p>Company: </p>
* @author Administrator
* @date 2020年3月24日 下午4:35:00
*/
public class DynamicProxy implements InvocationHandler{
//被代理类的实例
private IUserDao iud=null;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
Object result=null;
System.out.println("开始JDK动态代理");
method.invoke(iud, args);
System.out.println("结束JDK动态代理");
return result;
}
//构造方法
public DynamicProxy(IUserDao iud){
this.iud=iud;
}
}需要实现JDK中的InvocationHandler接口，实现其中的invoke方法，在此方法中通过反射的方式调用被代理类的方法，可以在方法执行前或后进行别的处理，下面看测试代码：
package cn.com.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
UserDao ud=new UserDao();
DynamicProxy dp=new DynamicProxy(ud);
//生成代理对象
IUserDao iud=(IUserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), dp);
iud.save();
System.out.println("--------------");
iud.find();
}
}在测试代码中通过Proxy类的newProxyInstance方法，生成代理类的实例iud，需要三个参数，
第一个为被代理类的类加载器，第二个为被代理类实现的接口，第三个则为invocationHandler的实现类，
这样就生成了代理对象，然后通过代理对象调用方法执行结果如下：
开始JDK动态代理
模拟保存用户
结束JDK动态代理
--------------
开始JDK动态代理
模拟查找用户
结束JDK动态代理由于第三个参数为一个接口，还可以使用匿名内部类的方式进行书写，其实现代码如下：
package cn.com.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
//被代理类的实例
UserDao ud = new UserDao();
IUserDao iud = (IUserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
Object result = null;
if ("find".equals(method.getName())) {
result = method.invoke(ud, args);
} else {
System.out.println("开始JDK代理");
result = method.invoke(ud, args);
System.out.println("结束JDK代理");
}
return result;
}
});
//使用代理类调用方法
iud.find();
System.out.println("----------------");
iud.save();
}
}结果:
模拟查找用户
----------------
开始JDK代理
模拟保存用户
结束JDK代理从上面可以看出代理类是由Proxy这个类通过newProxyInstance方法动态生成的，生成对象后使用“实例调用方法”的方式进行方法调用，那么代理类的被代理类的关系只有在执行这行代码的时候才会生成，因此成为动态代理。
JDK的动态代理也存在不足，即被代理类必须要有实现的接口，如没有接口则无法使用JDK动态代理（从newProxyInstance方法的第二个参数可得知，必须传入被代理类的实现接口），那么需要使用CGLib动态代理。
4.CGLib动态代理
应用：Spring aop应用； hibernate 懒加载机制（延迟加载） load方法查询便是懒加载，返回代理对象
Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。下面我们来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中
CGLib是一个第三方实现的动态代理库，不要求被代理类必须实现接口，它采用的继承被代理类，使用其子类的方式，弥补了被代理类没有接口的不足。需要引入的库
要使用CGLib代理需要实现其MethodInterceptor接口：
package cn.com.cglib;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
// TODO Auto-generated method stub
System.out.println("开始CGLib动态代理");
Object object=proxy.invokeSuper(obj, args);
System.out.println("结束CGLib动态代理");
return object;
}
}测试代码：
package cn.com.cglib;
import cn.com.staticProxy.UserDao;
import net.sf.cglib.proxy.Enhancer;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Enhancer enhancer=new Enhancer();
enhancer.setSuperclass(UserDao.class);
enhancer.setCallback(new MyMethodInterceptor());
//生成代理类
UserDao ud=(UserDao) enhancer.create();
ud.save();
System.out.println("----------------");
ud.find();
}
}可以看出使用Enhancer生成代理类，需要设置被代理类，也就是父类（从这里可以看出是使用继承，生成的子类），设置回调方法。
开始CGLib动态代理
模拟保存用户
结束CGLib动态代理
--------------------
开始CGLib动态代理
模拟查找用户
结束CGLib动态代理在设置回调enhancer.setCallback的时候需要传入MethodInterceptor的实例，这里可以使用匿名内部类的方式，可参照上面的。
5.总结
对静态代理、JDK动态代理、CGLib动态代理做一个总结，静态代理的维护成本比较高，有一个被代理类就需要创建一个代理类，而且需要实现相同的接口。JDK动态代理模式和CGLib动态代理的区别是JDK动态代理需要被代理类实现接口，而CGLib则是生成被代理类的子类，要求被代理类不能是final的，因为final类无法被继承。
576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
