JAVA代理,静态,动态详解

目录

• 代理
• 静态代理
• 动态代理
• JDK动态代理
• CGLib动态代理
• 总结

代理

为其他对象提供一种代理以控制这个对象的访问，在某些情况下一个对象不能直接访问那个对象时，代理就起到了客户端和被代理对象 (委托类) 中介作用。

按照代理的创建时期，代理类可以分为两种：

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

动态：在程序运行时运用反射机制动态创建而成。

静态代理

Subject： 代理类和被代理类实现同样的接口

Proxy：代理类，里面有被代理类，具体逻辑委托被代理类进行处理

RealSubject：被代理类，可以在其内做一些访问权限控制，额外的业务处理

Client：看到的是代理类，并不知道具体处理业务逻辑的类，降低耦合性

代码实现

UserDAO 代理和被代理的公共的接口(Subject)

public interface ProxyDao {
    boolean insert(String name);
}

UserDAOImpl 被代理类(RealSubject)

public class ProxyDaoImpl implements ProxyDao {
    @Override
    public boolean insert(String name) {
        System.out.println("insert name=" + name);
        return true;
    }
}

ProxyByInterface 代理类，通过实现接口方式实现代理方式(Proxy)

public class ProxyByInterface implements ProxyDao {
    private ProxyDao proxyDao;
    public ProxyByInterface(ProxyDao proxyDao) {
        this.proxyDao = proxyDao;
    }
    @Override
    public boolean insert(String name) {
        System.out.println("before insert by interface");
        return proxyDao.insert(name);
    }
}

ProxyByExtend 代理类，通过继承被代理类实现的代理方式(Proxy)

public class ProxyByExtend extends ProxyDaoImpl{
    private ProxyDaoImpl proxyDao;
    public ProxyByExtend(ProxyDaoImpl proxyDao) {
        this.proxyDao = proxyDao;
    }
    @Override
    public boolean insert(String name) {
        System.out.println("before insert by extend");
        return proxyDao.insert(name);
    }
}

获取代理对象客户端(Client)

public class Client {
    public static void main(String[] args) {
        ProxyDaoImpl proxyDao = new ProxyDaoImpl();
        //和被代理类实现同个接口方式进行代理
        ProxyByInterface proxyByInterface = new ProxyByInterface(proxyDao);
        proxyByInterface.insert("zc-Interface");
        //通过继承被代理类方式进行代理
        ProxyByExtend proxyByExtend = new ProxyByExtend(proxyDao);
        proxyByExtend.insert("zc-Extend");
    }
}

好处：

可以不用动原来类的逻辑，再次增加一些功能，符合开闭原则。

真正的业务还是交给被代理对象处理的，无须修改原来的类就可以使用代理进行实现。

缺点：

出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

动态代理

JDK动态代理

Jdk动态代理，针对的是实现接口的类；

要求目标对象必须实现接口，因为它创建代理对象的时候是根据接口创建的。被代理对象可以可以实现多个接口，创建代理时指定创建某个接口的代理对象就可以调用该接口定义的方法了。

需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

//Object proxy:被代理的对象
//Method method:要调用的方法
//Object[] args:方法调用时所需要参数
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

//CLassLoader loader:类的加载器
//Class interfaces:得到全部的接口
//InvocationHandler h:得到InvocationHandler接口的子类的实例
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException

代码实现

NameDao 姓名-接口(Subject)

public interface NameDao {
    public boolean addName(String name);
}

AgeDao 年龄-接口(Subject)

public interface AgeDao {
    public boolean addAge(Integer age);
}

NameAndAgeDaoImpl 姓名、年龄实现类(RealSubject)

public class NameAndAgeDaoImpl implements NameDao,AgeDao {
    @Override
    public boolean addName(String name) {
        System.out.println("NameDaoImpl----->" + name);
        return true;
    }
    @Override
    public boolean addAge(Integer age) {
        System.out.println("AgeDaoImpl----->" + age);
        return true;
    }
}

MyInvocationHandler，对接口提供的方法进行增强(Proxy)

public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("----------before----------");
        System.out.println("Proxy=" + proxy.getClass());
        System.out.println("method=" + method);
        System.out.println("args=" + Arrays.toString(args));
        //执行目标方法对象
        Object result = method.invoke(target, args);
        System.out.println("----------after----------");
        return result;
    }
}

ProxyFactory 代理工厂

public class ProxyFactory {
    public 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(),
                proxyObj.getClass().getInterfaces(), new MyInvocationHandler(proxyObj));
    }
    public static void main(String[] args) {
        NameDao nameDao = (NameDao) getProxy(new NameAndAgeDaoImpl());
        AgeDao ageDao = (AgeDao) getProxy(new NameAndAgeDaoImpl());
        nameDao.addName("zc");
        ageDao.addAge(20);
    }
}

思考 为什么需要 实现接口的类，而不是 类

main函数中，运行该语句：

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

public static void main(String[] args) {
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
    NameDao nameDao = (NameDao) getProxy(new NameAndAgeDaoImpl());
    AgeDao ageDao = (AgeDao) getProxy(new NameAndAgeDaoImpl());
    nameDao.addName("zc");
    ageDao.addAge(20);
}

可以查看 $Proxy0 类：

会发现他已经继承了 Proxy , 之后才是创建的一个(多个)接口；而由于java是 单继承、多接口 的特性，所以JDK动态代理，需要实现接口的类。

CGLib动态代理

CGLIB实现动态代理，并不要求被代理类必须实现接口，底层采用asm字节码生成框架生成代理类字节码(该代理类继承了被代理类)。

所以被代理类一定不能定义为final class并且对于final 方法不能被代理。

实现需要

//MethodInterceptor接口的intercept方法
/**
*obj 代理对象
*method 委托类方法,被代理对象的方法字节码对象
*arg 方法参数
*MethodProxy 代理方法MethodProxy对象，每个方法都会对应有这样一个对象 
*/
public 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)

public class UserDaoImpl {
    public boolean insert(String name) {
        System.out.println("insert name=" + name);
        return true;
    }
    public final boolean insert1(String name) {
        System.out.println("final insert name=" + name);
        return true;
    }
}

CglibProxy CGLIB代理类(Proxy)

public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("----------before----------");
        System.out.println("Proxy=" + o.getClass());
        System.out.println("method=" + method);
        System.out.println("args=" + Arrays.toString(objects));
        System.out.println("methodProxy=" + methodProxy);
        //执行目标方法对象
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("----------after----------");
        return result;
    }
}

ProxyFactory 代理工厂

public class ProxyFactory {
    private static Enhancer enhancer = new Enhancer();
    private static CglibProxy cglibProxy = new CglibProxy();
    public static Object getProxy(Class cls) {
        enhancer.setSuperclass(cls);
        enhancer.setCallback(cglibProxy);
        return enhancer.create();
    }
    public static void main(String[] args) {
        UserDaoImpl userDao = (UserDaoImpl) getProxy(UserDaoImpl.class);
        userDao.insert("zc");
    }
}

思考

为什么这里面使用 invokeSuper() ，不使用 invoke()

1.Method method 是被代理对象的方法字节码对象。

2.MethodProxy methodProxy 是代理对象的方法字节码对象。

使用 MethodProxy 的好处：

不需要给代理对象传入被代理对象，效率更高。不会出现死循环的问题。

第一点查看代码就可以看出，对第二点进行讲解：

如何出现死循环的现象：

	Proxy.newProxyInstance(xxx, xxx,
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    	...
                      //加入这一句  
                    	proxy.toString();
                    	...
                    }
                });

原因：代理对象方法的时候，都会经过拦截器方法。因此，如果在拦截器中再调用代理对象的方法，就会再次进入拦截器，这样就形成了死循环。

**invokeSuper()**方法，可以使用代理对象父类的方法（就是被代理对象）而不必经过拦截器-----详情可以学习：《类加载机制》、《双亲委派模型》

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容！