1.什么是代理？
对类或对象（目标对象）进行增强功能，最终形成一个新的代理对象，(Spring Framework中）当应用调用该对象（目标对象）的方法时，实际调用的是代理对象增强后的方法，比如对功能方法login实现日志记录，可以通过代理实现；
PS：目标对象–被增强的对象；代理对象–增强后的对象；
2.为什么需要代理？
一些类里面的方法有相同的代码或类中有相同的功能，可以将这些相同抽取出来形成一个公共的方法或功能，但Java有两个重要的原则：单一职责（对类来说的，即一个类应该只负责一项职责）和开闭原则（开放扩展，修改关闭），如果每个类的每个功能都调用了公共功能，就破坏了单一职责，如下图；如果这个类是别人已经写好的，你动了这个代码，同时也破坏了开闭原则（同时改动代码很麻烦，里面可能涉及其他很多的调用，可能带出无数的bug，改代码比新开发功能还难/(ㄒoㄒ)/~~）；
由于有上面的问题存在，使用代理来实现是最好的解决办法；
3.Java实现代理有哪些？
（1）静态代理：通过对目标方法进行继承或聚合（接口）实现；（会产生类爆炸，因此在不确定的情况下，尽量不要使用静态代理，避免产生类爆炸）
1）继承：代理对象继承目标对象，重写需要增强的方法；
//业务类（目标对象）public class UserServiceImpl { public void query(){ System.out.println("业务操作查询数据库...."); }}//日志功能类public class Log { public static void info(){ System.out.println("日志功能"); }}//继承实现代理（代理对象）public class UserServiceLogImpl extends UserServiceImpl { public void query(){ Log.info(); super.query(); }}
从上面代码可以看出，每种增强方法会产生一个代理类，如果现在增强方法有日志和权限，单个方法增强那需要两个代理类（日志代理类和权限代理类），如果代理类要同时拥有日志和权限功能，那又会产生一个代理类，同时由于顺序的不同，可能会产生多个类，比如先日志后权限是一个代理类，先权限后日志又是另外一个代理类。在此我向大家推荐一个架构学习交流圈。交流学习指导伪鑫：1253431195（里面有大量的面试题及答案）里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多
由此可以看出代理使用继承的缺陷：产生的代理类过多（产生类爆炸），非常复杂，维护难；
2）聚合：代理对象和目标对象都实现同一接口，使用装饰者模式，提供一个代理类构造方法（代理对象当中要包含目标对象），参数是接口，重写目标方法；
//接口public interface UserDao { void query();}//接口实现类：目标对象public class UserDaoImpl implements UserDao { @Override public void query() { System.out.println("query......"); }}//日志功能类public class Log { public static void info(){ System.out.println("日志功能"); }}//聚合实现代理：同样实现接口，使用装饰者模式；（代理对象）public class UserDaoLogProxy implements UserDao { UserDao userDao; public UserDaoLogProxy(UserDao userDao){//代理对象包含目标对象 this.userDao = userDao; } @Override public void query() { Log.info(); userDao.query(); }}//测试public static void main(String[] args) { UserDaoImpl target = new UserDaoImpl(); UserDaoLogProxy proxy = new UserDaoLogProxy(target); proxy.query();}
聚合由于利用了面向接口编程的特性，产生的代理类相对继承要少一点（虽然也是会产生类爆炸，假设有多个Dao，每个Dao产生一个代理类，所以还是会产生类爆炸），如下案例：
//时间记录功能public class Timer { public static void timer(){ System.out.println("时间记录功能"); }}//代理类：时间功能+业务public class UserDaoTimerProxy implements UserDao { UserDao userDao; public UserDaoTimerProxy(UserDao userDao){ this.userDao = userDao; } @Override public void query() { Timer.timer(); userDao.query(); }}//测试public static void main(String[] args) { //timer+query UserDao target = new UserDaoTimerProxy(new UserDaoImpl()); //log+timer+query UserDao proxy = new UserDaoLogProxy(target); proxy.query();}public static void main(String[] args) { //log+query UserDao target = new UserDaoLogProxy(new UserDaoImpl()); //timer+log+query UserDao proxy = new UserDaoTimerProxy(target); proxy.query();}
PS：
装饰和代理的区别：代理不需要指定目标对象，可以对任何对象进行代理；装饰需要指定目标对象，所以需要构造方法参数或set方法指定目标对象；
几个io的Buffer流（BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter）就是使用了装饰模式的静态代理；
public class BufferedReader extends Reader { private Reader in; ........ public BufferedReader(Reader in, int sz) { super(in); if (sz <= 0) throw new IllegalArgumentException("Buffer size <= 0"); this.in = in; cb = new char[sz]; nextChar = nChars = 0; } public BufferedReader(Reader in) { this(in, defaultCharBufferSize); }}
（2）动态代理：Java有JDK动态代理和CGLIB代理；（Spring Framework通过Spring AOP实现代理，底层还是使用JDK代理和CGLIB代理来实现）
模拟动态代理：不需要手动创建类文件（因为一旦手动创建类文件，会产生类爆炸），通过接口反射生成一个类文件，然后调用第三方的编译技术，动态编译这个产生的类文件成class文件，然后利用URLclassLoader把这个动态编译的类加载到jvm中，然后通过反射把这个类实例化。（通过字符串产生一个对象实现代理）；
PS：Java文件 -> class文件 -> byte字节（JVM）-> class对象（类对象）-> new（对象）；
所以步骤如下：
1）代码实现一个内容（完整的Java文件内容，包含包名、变量、构造方法、增强后的方法等），使其通过IO产生一个Java文件； 2）通过第三方编译技术产生一个class文件； 3）加载class文件利用反射实例化一个代理对象出来；
public class ProxyUtil { /** * content --->string * | * |生成 * v * .java <-----通过io产生 * .class <-----Java文件编程产生 * * .new <-----class文件反射产生实例对象 * @return */ public static Object newInstance(Object target){ Object proxy=null; //根据对象获取接口 Class targetInf =target.getClass().getInterfaces()[0]; //获取接口的所有方法 //getMethods(),该方法是获取本类以及父类或者父接口中所有的公共方法(public修饰符修饰的) //getDeclaredMethods(),该方法是获取本类中的所有方法，包括私有的(private、protected、默认以及public)的方法 Method[] declaredMethods = targetInf.getDeclaredMethods(); String line="\n"; String tab ="\t"; //接口名称 String targetInfName = targetInf.getSimpleName(); String content =""; //包位置 String packageContent = "package com;"+line; //接口 String importContent = "import "+targetInf.getName()+";"+line; String clazzFirstLineContent = "public class $Proxy implements "+targetInfName+"{"+line; //属性 String filedContent =tab+"private "+targetInfName+" target;"+line; //构造方法 String constructorContent =tab+"public $Proxy ("+targetInfName+" target){" +line +tab+tab+"this.target =target;" +line+tab+"}"+line; //方法 String methodContent = ""; for(Method method:declaredMethods){ //返回值 String returnTypeName = method.getReturnType().getSimpleName(); //方法名 String methodName = method.getName(); // Sting.class String.class 参数类型 Class<?>[] parameterTypes = method.getParameterTypes(); String argsContent = ""; String paramsContent=""; int flag = 0; for(Class args :parameterTypes){ //String，参数类型 String simpleName = args.getSimpleName(); //String p0,Sting p1, argsContent+=simpleName+" p"+flag+","; paramsContent+="p"+flag+","; flag++; } if (argsContent.length()>0){ argsContent=argsContent.substring(0,argsContent.lastIndexOf(",")-1); paramsContent=paramsContent.substring(0,paramsContent.lastIndexOf(",")-1); } methodContent+=tab+"public "+returnTypeName+" "+methodName+"("+argsContent+") {"+line //增强方法先写死 +tab+tab+"System.out.println(\"log\");"+line; if(returnTypeName.equals("void")){ methodContent+=tab+tab+"target."+methodName+"("+paramsContent+");"+line +tab+"}"+line; }else{ methodContent+=tab+tab+"return target."+methodName+"("+paramsContent+");"+line +tab+"}"+line; } } content+=packageContent+importContent+clazzFirstLineContent+filedContent +constructorContent+methodContent+"}"; //生成Java文件 File file = new File("D:\\com\\$Proxy.java"); try{ if(!file.exists()){ file.createNewFile(); } //创建 FileWriter wr = new FileWriter(file); wr.write(content); wr.flush(); wr.close(); //编译Java文件 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null); Iterable units = fileMgr.getJavaFileObjects(file); JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units); t.call(); fileMgr.close(); //new --> 反射 URL[] urls = new URL[]{new URL("file:D:\\\\")}; //加载外部文件 URLClassLoader classLoader = new URLClassLoader(urls); Class<?> proxyClass = classLoader.loadClass("com.$Proxy"); Constructor constructor = proxyClass.getConstructor(targetInf); //构造方法创建实例 proxy = constructor.newInstance(target); //clazz.newInstance();//根据默认构造方法创建对象 //Class.forName() }catch (Exception e){ e.printStackTrace(); } return proxy; }}
自定义代理的缺点：生成Java文件；动态编译文件；需要一个URLClassLoader；涉及到了IO操作，软件的最终性能体现到了IO操作，即IO操作影响到软件的性能；
案例：
1）接口：
public interface UserDao { void query(); void query(String name); String getName(String id);}
2）实现类：
public class UserService implements UserDao { @Override public void query() { System.out.println("query"); } @Override public void query(String name) { System.out.println(name); } @Override public String getName(String id) { System.out.println("id:"+id); return "李四"; }}
3）测试：
public static void main(String[] args) { UserDao dao = (UserDao) ProxyUtil.newInstance(new UserService()); dao.query(); dao.query("张三");}--------结果--------logquerylog张三
package com;import com.hrh.dynamicProxy.dao.UserDao;public class $Proxy implements UserDao{//自定义动态代理生成的文件 private UserDao target; public $Proxy (UserDao target){ this.target =target; } public String getName(String p) { System.out.println("log"); return target.getName(p); } public void query(String p) { System.out.println("log"); target.query(p); } public void query() { System.out.println("log"); target.query(); }}
JDK动态代理：基于反射实现，通过接口反射得到字节码，然后将字节码转成class，通过一个native（JVM实现）方法来执行；
案例实现：实现 InvocationHandler 接口重写 invoke 方法，其中包含一个对象变量和提供一个包含对象的构造方法；
public class MyInvocationHandler implements InvocationHandler { Object target;//目标对象 public MyInvocationHandler(Object target){ this.target=target; } /** * @param proxy 代理对象 * @param method 目标对象的目标方法 * @param args 目标方法的参数 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("log"); return method.invoke(target,args); }}
public class MyInvocationHandlerTest { public static void main(String[] args) { //参数： 当前类的classLoader（保证MyInvocationHandlerTest当前类可用） // 接口数组：通过接口反射得到接口里面的方法，对接口里面的所有方法都进行代理 // 实现的InvocationHandler：参数是目标对象 UserDao jdkproxy = (UserDao) Proxy.newProxyInstance(MyInvocationHandlerTest.class.getClassLoader(), new Class[]{UserDao.class},new MyInvocationHandler(new UserService())); jdkproxy.query("query"); //-----结果------ //log //query }}
下面查看底层JDK生成的代理类class：
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy18", new Class[]{UserDao.class}); try { FileOutputStream fileOutputStream = new FileOutputStream("xxx本地路径\\$Proxy18.class"); fileOutputStream.write(bytes); fileOutputStream.flush(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }
或在代码的最前面添加下面代码：
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "xxx本地路径");
代理类class反编译后的内容：下面的内容验证了JDK动态代理为什么基于聚合（接口）来的，而不能基于继承来的？因为JDK动态代理底层已经继承了Proxy，而Java是单继承，不支持多继承，所以以接口来实现；
//// Source code recreated from a .class file by IntelliJ IDEA// (powered by Fernflower decompiler)//import com.hrh.dao.UserDao;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy18 extends Proxy implements UserDao { private static Method m1; private static Method m4; private static Method m5; private static Method m2; private static Method m0; private static Method m3; public $Proxy18(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void query(String var1) throws { try { super.h.invoke(this, m4, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void query() throws { try { super.h.invoke(this, m5, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final String getName(String var1) throws { try { return (String)super.h.invoke(this, m3, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m4 = Class.forName("com.hrh.dao.UserDao").getMethod("query", Class.forName("java.lang.String")); m5 = Class.forName("com.hrh.dao.UserDao").getMethod("query"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); m3 = Class.forName("com.hrh.dao.UserDao").getMethod("getName", Class.forName("java.lang.String")); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } }}
CGLIB代理：借助asm（一个操作字节码的框架）实现代理操作；CGLIB基于继承来的（前文有CGLIB代理类class的反编译可以看出）；
public class UserService { public void query(){ System.out.println("query"); } public static void main(String[] args) { // 通过CGLIB动态代理获取代理对象的过程 Enhancer enhancer = new Enhancer(); // 设置enhancer对象的父类 enhancer.setSuperclass(UserService.class); // 设置enhancer的回调对象 enhancer.setCallback(new MethodInterceptor() { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("before method run..."); Object result = proxy.invokeSuper(obj, args); System.out.println("after method run..."); return result; } }); //创建代理对象 UserService bean = (UserService) enhancer.create(); bean.query(); }}//-----------结果------before method run...queryafter method run...
PS：如果只是对项目中一个类进行代理，可以使用静态代理，如果是多个则使用动态代理；
扫一扫
1144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
