JAVA基础之静态代理与动态代理 java代理模式

这个是新鲜的热乎的，针对某个面试题写了的内容，如果有问题欢迎来喷。来看看他们的区别

静态/动态	区别
静态	由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了
动态	在程序运行时运用反射机制动态创建而成。

我们先把静态代理和动态代理的代码放上来
看名字，这个是需要被代理的接口，无论是静态还是动态，都需要一个接口
ToBeProxyedInterface.java

public interface ToBeProxyedInterface { void addUser(String userId, String userName); void delUser(String userId); String findUser(String userId); void modifyUser(String userId, String userName); }

下面是两个类，ToBeProxyedService1.java，ToBeProxyedService2.java，静态代理只需要一个就可以了，动态代理为了实验其动态性，所以来了两个具体的Service，后边可以看Client的main方法实现，如何指定1还是2的service调用
ToBeProxyedService1.java

public class ToBeProxyedService1 implements ToBeProxyedInterface { @Override public void addUser(String userId, String userName) { System.out.println("ToBeProxyedService1.addUser"); } @Override public void delUser(String userId) { System.out.println("ToBeProxyedService1.delUser"); } @Override public String findUser(String userId) { System.out.println("ToBeProxyedService1.findUser"); return "张三"; } @Override public void modifyUser(String userId, String userName) { System.out.println("ToBeProxyedService1.modifyUser"); } }

ToBeProxyedService2.class

public class ToBeProxyedService2 implements ToBeProxyedInterface { @Override public void addUser(String userId, String userName) { System.out.println("ToBeProxyedService2.addUser"); } @Override public void delUser(String userId) { System.out.println("ToBeProxyedService2.delUser"); } @Override public String findUser(String userId) { System.out.println("ToBeProxyedService2.findUser"); return "张三2"; } @Override public void modifyUser(String userId, String userName) { System.out.println("ToBeProxyedService2.modifyUser"); } }

重点来类，静态代理，通过构造方法传入了具体的需要代理的Service，因此每一个Handler只能代理一个Service，再增加一个Service时候，就需要在对应一个Handler，扩展不太好
StaticProxyHandler.java

public class StaticProxyHandler implements ToBeProxyedInterface { // 目标对象 private ToBeProxyedService1 toBeProxyedService1; // 通过构造方法传入目标对象 public StaticProxyHandler(ToBeProxyedService1 toBeProxyedService1){ this.toBeProxyedService1=toBeProxyedService1; } @Override public void addUser(String userId, String userName) { try{ //添加打印日志的功能 //开始添加用户 System.out.println("start StaticProxyHandler-->addUser()"); toBeProxyedService1.addUser(userId, userName); //添加用户成功 System.out.println("success StaticProxyHandler-->addUser()"); }catch(Exception e){ //添加用户失败 System.out.println("error StaticProxyHandler-->addUser()"); } } @Override public void delUser(String userId) { toBeProxyedService1.delUser(userId); } @Override public String findUser(String userId) { toBeProxyedService1.findUser(userId); return "张三"; } @Override public void modifyUser(String userId, String userName) { toBeProxyedService1.modifyUser(userId,userName); } }

最重点来了，动态代理，可以在里面看不到任何具体的Service是哪个，具体的指定哪个Service在后边的Client的main方法传入指定不同的Service。实际上动态代理是通过实现了InvocationHandler实现的
具体看下，newProxyInstance方法是通过入参传入指定的具体的哪个Service的动态绑定，而Handler中实现InvocationHandler中的invoke方法，才是真正调用的具体的方法的实现。
DynamicProxyHandler.java

public class DynamicProxyHandler implements InvocationHandler { // 目标对象 private Object targetObject; //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。 public Object newProxyInstance(Object targetObject){ this.targetObject=targetObject; //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例 //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器 //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口 //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法 //根据传入的目标返回一个代理对象 return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(),this); } @Override //关联的这个实现类的方法被调用时将被执行 /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("start DynamicProxyHandler--invoke >>"); for(int i=0; i>"); //调用目标方法 ret=method.invoke(targetObject, args); /*原对象方法调用后处理日志信息*/ System.out.println("success DynamicProxyHandler call method -->>"); }catch(Exception e){ e.printStackTrace(); System.out.println("error DynamicProxyHandler call method -->>"); throw e; } return ret; } }

【JAVA基础之静态代理与动态代理】下面的main方法可以看到，静态代理传入的就是具体的ToBeProxyedService1，无法实现扩展
后边的动态代理我写了两遍，实际上每次传入的不同的ToBeProxyedService1和ToBeProxyedService2，分别都可以执行，方便动态扩展，后边如果再有ToBeProxyedService3，只要调用前修改就可以，不用修改具体的Handler，方便扩展了。
Client.java

public class Client { public static void main(String[] args){ //静态代理，每一个固定写死了具体的需要代理的类 StaticProxyHandler staticProxyHandler = new StaticProxyHandler(new ToBeProxyedService1()); staticProxyHandler.addUser("1111", "张三"); //动态代理，需要执行ToBeProxyedService1就传入ToBeProxyedService1，如果需要执行ToBeProxyedService2就传入ToBeProxyedService2 DynamicProxyHandler proxyHandler=new DynamicProxyHandler(); ToBeProxyedInterface service = (ToBeProxyedInterface) proxyHandler.newProxyInstance(new ToBeProxyedService1()); service.addUser("1111", "张三"); service = (ToBeProxyedInterface) proxyHandler.newProxyInstance(new ToBeProxyedService2()); service.addUser("1111", "张三"); } }