目录
代理
静态代理
动态代理
JDK动态代理
CGLib动态代理
总结
代理
为其他对象提供一种代理以控制这个对象的访问，在某些情况下一个对象不能直接访问那个对象时，代理就起到了客户端和被代理对象 (委托类) 中介作用。
按照代理的创建时期，代理类可以分为两种：
静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
动态：在程序运行时运用反射机制动态创建而成。
静态代理
ubject： 代理类和被代理类实现同样的接口
roxy：代理类，里面有被代理类，具体逻辑委托被代理类进行处理
RealSubject：被代理类，可以在其内做一些访问权限控制，额外的业务处理
Client：看到的是代理类，并不知道具体处理业务逻辑的类，降低耦合性
代码实现
UserDAO 代理和被代理的公共的接口(Subject)
ublic interface ProxyDao {
oolean insert(String name)；
}
UserDAOImpl 被代理类(RealSubject)
ublic class ProxyDaoImpl implements ProxyDao {
[email protected]/* */
ublic boolean insert(String name) {
ystem.out.println("insert name=" name)；
return true;
}
}
roxyByInterface 代理类，通过实现接口方式实现代理方式(Proxy)
ublic class ProxyByInterface implements ProxyDao {
rivate ProxyDao proxyDao;
ublic ProxyByInterface(ProxyDao proxyDao) {
this.proxyDao = proxyDao;
}
[email protected]/* */
ublic boolean insert(String name) {
ystem.out.println("before insert by interface");
return proxyDao.insert(name);
}
}
roxyByExtend 代理类，通过继承被代理类实现的代理方式(Proxy)
ublic class ProxyByExtend extends ProxyDaoImpl{
rivate ProxyDaoImpl proxyDao;
ublic ProxyByExtend(ProxyDaoImpl proxyDao) {
this.proxyDao = proxyDao;
}
[email protected]/* */
ublic boolean insert(String name) {
ystem.out.println("before insert by extend");
return proxyDao.insert(name);
}
}
获取代理对象客户端(Client)
ublic class Client {
ublic static void main(String[] args) {
roxyDaoImpl proxyDao = new ProxyDaoImpl();
//和被代理类实现同个接口方式进行代理
roxyByInterface proxyByInterface = new ProxyByInterface(proxyDao);
roxyByInterface.insert("zc-Interface");
//通过继承被代理类方式进行代理
roxyByExtend proxyByExtend = new ProxyByExtend(proxyDao);
roxyByExtend.insert("zc-Extend");
}
}
好处：
可以不用动原来类的逻辑，再次增加一些功能，符合开闭原则。
真正的业务还是交给被代理对象处理的，无须修改原来的类就可以使用代理进行实现。
缺点：
出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。
动态代理
JDK动态代理
Jdk动态代理，针对的是实现接口的类；
要求目标对象必须实现接口，因为它创建代理对象的时候是根据接口创建的。被代理对象可以可以实现多个接口，创建代理时指定创建某个接口的代理对象就可以调用该接口定义的方法了。
需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持
//Object proxy:被代理的对象
//Method method:要调用的方法
//Object[] args:方法调用时所需要参数
ublic interface InvocationHandler {
ublic Object invoke(Object proxy， Method method， Object[] args) throws Throwable;
}
//CLassLoader loader:类的加载器
//Class<？> interfaces:得到全部的接口
//InvocationHandler h:得到InvocationHandler接口的子类的实例
ublic static Object newProxyInstance(ClassLoader loader, Class<？>[] interfaces, InvocationHandler h) throws IllegalArgumentException
代码实现
ameDao 姓名-接口(Subject)
ublic interface NameDao {
ublic boolean addName(String name);
}
AgeDao 年龄-接口(Subject)
ublic interface AgeDao {
ublic boolean addAge(Integer age);
}
ameAndAgeDaoImpl 姓名、年龄实现类(RealSubject)
ublic class NameAndAgeDaoImpl implements NameDao,AgeDao {
[email protected]/* */
ublic boolean addName(String name) {
ystem.out.println("NameDaoImpl——>" name);
return true;
}
[email protected]/* */
ublic boolean addAge(Integer age) {
ystem.out.println("AgeDaoImpl——>" age);
return true;
}
}
MyInvocationHandler，对接口提供的方法进行增强(Proxy)
ublic class MyInvocationHandler implements InvocationHandler {
rivate Object target;
ublic MyInvocationHandler(Object target) {
this.target = target;
}
[email protected]/* */
ublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
ystem.out.println("——-before——-");
ystem.out.println("Proxy=" proxy.getClass());
ystem.out.println("method=" method);
ystem.out.println("args=" Arrays.toString(args));
//执行目标方法对象
Object result = method.invoke(target, args);
ystem.out.println("——-after——-");
return result;
}
}
roxyFactory 代理工厂
ublic class ProxyFactory {
ublic static Object getProxy(Object proxyObj) {
/**
* loader 指定加载jvm运行时动态生成的代理对象的加载器
* interface 真实对象实现的所有接口
* h 实现InvocationHandler接口对象
*/
// return Proxy.newProxyInstance(proxyObj.getClass().getClassLoader(),
// proxyObj.getClass().getInterfaces(), new MyInvocationHandler(proxyObj));
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
roxyObj.getClass().getInterfaces(), new MyInvocationHandler(proxyObj));
}
ublic static void main(String[] args) {
ameDao nameDao = (NameDao) getProxy(new NameAndAgeDaoImpl());
AgeDao ageDao = (AgeDao) getProxy(new NameAndAgeDaoImpl());
ameDao.addName("zc");
ageDao.addAge(20);
}
}
思考 为什么需要 实现接口的类，而不是 类
main函数中，运行该语句：
ystem.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
ublic static void main(String[] args) {
ystem.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
ameDao nameDao = (NameDao) getProxy(new NameAndAgeDaoImpl());
AgeDao ageDao = (AgeDao) getProxy(new NameAndAgeDaoImpl());
ameDao.addName("zc");
ageDao.addAge(20);
}
可以查看 $Proxy0 类：
会发现他已经继承了 Proxy , 之后才是创建的一个(多个)接口；而由于java是 单继承、多接口 的特性，所以JDK动态代理，需要实现接口的类。
CGLib动态代理
CGLIB实现动态代理，并不要求被代理类必须实现接口，底层采用asm字节码生成框架生成代理类字节码(该代理类继承了被代理类)。
所以被代理类一定不能定义为final class并且对于final 方法不能被代理。
实现需要
//MethodInterceptor接口的intercept方法
/**
*obj 代理对象
*method 委托类方法,被代理对象的方法字节码对象
*arg 方法参数
*MethodProxy 代理方法MethodProxy对象，每个方法都会对应有这样一个对象
*/
ublic Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy)
Ehancer enhancer = new Enhancer() //Enhancer为字节码增强器,很方便对类进行扩展
enhancer.setSuperClass(被代理类.class);
enhancer.setCallback(实现MethodInterceptor接口的对象)
enhancer.create()//返回代理对象，是被代理类的子类
代码实现
UserDaoImpl 用户实现类(RealSubject)
ublic class UserDaoImpl {
ublic boolean insert(String name) {
ystem.out.println("insert name=" name);
return true;
}
ublic final boolean insert1(String name) {
ystem.out.println("final insert name=" name);
return true;
}
}
CglibProxy CGLIB代理类(Proxy)
ublic class CglibProxy implements MethodInterceptor {
[email protected]/* */
ublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
ystem.out.println("——-before——-");
ystem.out.println("Proxy=" o.getClass());
ystem.out.println("method=" method);
ystem.out.println("args=" Arrays.toString(objects));
ystem.out.println("methodProxy=" methodProxy);
//执行目标方法对象
Object result = methodProxy.invokeSuper(o, objects);
ystem.out.println("——-after——-");
return result;
}
}
roxyFactory 代理工厂
ublic class ProxyFactory {
rivate static Enhancer enhancer = new Enhancer();
rivate static CglibProxy cglibProxy = new CglibProxy();
ublic static Object getProxy(Class cls) {
enhancer.setSuperclass(cls);
enhancer.setCallback(cglibProxy);
return enhancer.create();
}
ublic static void main(String[] args) {
UserDaoImpl userDao = (UserDaoImpl) getProxy(UserDaoImpl.class);
userDao.insert("zc");
}
}
思考
为什么这里面使用 invokeSuper() ，不使用 invoke()
1.Method method 是被代理对象的方法字节码对象。
2.MethodProxy methodProxy 是代理对象的方法字节码对象。
使用 MethodProxy 的好处：
不需要给代理对象传入被代理对象，效率更高。不会出现死循环的问题。
第一点查看代码就可以看出，对第二点进行讲解：
如何出现死循环的现象：
roxy.newProxyInstance(xxx, xxx,
ew InvocationHandler() {
[email protected]/* */
ublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
……
//加入这一句
roxy.toString();
……
}
});
原因：代理对象方法的时候，都会经过拦截器方法。因此，如果在拦截器中再调用代理对象的方法，就会再次进入拦截器，这样就形成了死循环。
