标签：支持 col nec 结果的处理 信息 不用 bytearray flush output
代理模式: 为其他对象提供一种代理以控制对这个对象的访问。
中介隔离：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
开闭原则，增加功能代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。
代理模式主要包含三个角色，即抽象主题角色(Subject)、委托类角色(被代理角色，Proxied)以及代理类角色(Proxy)
抽象主题角色:可以是接口，也可以是抽象类；
委托类角色：真实主题角色，业务逻辑的具体执行者；
代理类角色：内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。
1. 自定义aop、事务aop
2. 日志收集
3. 权限控制
4. 过滤器
5. 全局异常捕获
6. 自定义注解的实现 （apo+ 反射技术）
7. Mybatis的Mapper接口，JPA的Respoitory接口
8. 分布式事务lcn,seata,分库分表中间件shardingSphere 代理数据源（拦截劫持数据源实现功能增强）
9. Rpc远程调用中间件，也是走代理
静态代理和动态代理
静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。一句话，自己手写代理类就是静态代理。
基于接口实现方式
public interface MessageService { void sendMessage(); } public class MessageServiceImpl implements MessageService { public void sendMessage() { System.out.println("发送消息.."); } } public class MessageServiceProxy implements MessageService { /** * 被代理对象 */ private MessageService proxiedMessageService; public MessageServiceProxy(MessageService messageService) { this.proxiedMessageService=messageService; } public void sendMessage() { System.out.println("日志收集开始.."); proxiedMessageService.sendMessage(); System.out.println("日志收集结束.."); } } public class ClientTest { public static void main(String[] args) { MessageService messageService = new MessageServiceProxy(new MessageServiceImpl()); messageService.sendMessage(); } }
基于继承方式实现
public class MessageServiceProxy extends MessageServiceImpl { public void sendMessage() { System.out.println("日志收集开始.."); super.sendMessage(); System.out.println("日志收集结束.."); } } public class ClientTest { public static void main(String[] args) { new OrderServiceProxy().sendMessage(); } }
静态代理其实很好理解，就是要我们手动的去实现代理类，下面的动态代理才是我要讲的重点
动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成 。
java 反射技术：可以动态根据class文件获取类的信息（类的名称，属性，方法），帮助实例化对象，动态的调用某个方法，比如某个方法是私有，都可以通过反射技术实现调用.
反射的缺点
性能问题
1.使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。
2.反射包括了一些动态类型，所以JVM无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被 执行的代码或对性能要求很高的程序中使用反射。
使用反射会模糊程序内部逻辑
程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。
安全限制
使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如Applet，那么这就是个问题了
内部暴露
由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用－－代码有功能上的错误，降低可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
JDK动态代理的一般步骤如下：
1.创建被代理的接口和类；
2.实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；
3.调用Proxy的静态方法，创建代理类并生成相应的代理对象；
public interface OrderService { void order(); } public class OrderServiceImpl implements OrderService { public void order() { System.out.println("订单操作....."); } } public class JdkInvocationHandler implements InvocationHandler { /** * 目标对象 -- 即被代理对象 */ public Object target; public JdkInvocationHandler(Object target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(">>>日志收集开始>>>>"); // 执行代理对象方法 Object reuslt = method.invoke(target, args); System.out.println(">>>日志收集结束>>>>"); return reuslt; } /** * 获取代理对象接口 * * @param <T> * @return */ public <T> T getProxy() { return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } }
// System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 可以获取动态代理生成的class文件 JdkInvocationHandler jdkInvocationHandler = new JdkInvocationHandler(new OrderServiceImpl()); OrderService proxy = jdkInvocationHandler.getProxy(); proxy.order();
注意：继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
JDK动态代理原理分析
1.在使用jdk动态代理的时候，必须要实现InvocationHandler接口，invoke方法
invoke(Object proxy, Method method, Object[] args) ， Invoke 方法中该三个参数分别表示为: 生成的代理对象、被代理执行的方法、参数
通过设置System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 获取动态代理的生成的class文件
使用jdk动态代理获取代理类对象（JDK自动生成代理类） $Proxy0.class 如下（后面的0表示序号，如果有多个代理类这个序号会
从反编译的代码可以看出代理类$Proxy0继承的Proxy类并实现了OrderService接口，order()方法，实际走的InvocationHandler.invoke()方法，m3就是接口的方法，反编译代码如下
现在我们来debug下代码，走到$Proxy的order方法，看下 this, m3，h的debug信息
public final class $Proxy0 extends Proxy implements OrderService { }
ClassLoader 是类加载器,ClassLoader 作用：负责将 Class 加载到 JVM 中，审查每个类由谁加载（父优先的等级加载机制）将 Class 字节码重新解析成 JVM 统一要求的对象格式
package com.brian.proxy.service; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public interface BrianInvocationhandler { /** * 模拟jdk动态代理 InvocationHandler接口
* @param proxy 代理对象 * @param method 被代理类执行的方法 * @param args 参数 * @return */ Object invoke(Object proxy, Method method,Object[] args) throws InvocationTargetException, IllegalAccessException; }
/** * @program: architect * @author: Brian Huang * @create: 2019-05-20 20 **/ @Slf4j public class BrianJdkInvocationhandler implements BrianInvocationhandler { private Object target; public BrianJdkInvocationhandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException { log.info("方法执行前，，，"); Object result = method.invoke(target, args);//使用Java反射技术执行 log.info("方法执行后，，，"); return result; } }
package com.brian.proxy.service.impl; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; /** * java类加载器 将class字节码文件加载到内存中 * @program: architect * @author: Brian Huang * @create: 2019-05-20 22 **/ public class JavaClassLoader extends ClassLoader { private File classPathFile; public JavaClassLoader(){ String classPath=JavaClassLoader.class.getResource("").getPath(); this.classPathFile=new File(classPath); } @Override public Class<?> findClass(String name) throws ClassNotFoundException { String className= JavaClassLoader.class.getPackage().getName()+"."+name; if(classPathFile!=null){ File classFile=new File(classPathFile,name.replaceAll("\\.","/")+".class"); if(classFile.exists()){ FileInputStream in=null; ByteArrayOutputStream out=null; try { in=new FileInputStream(classFile); out=new ByteArrayOutputStream(); byte[] buff=new byte[1024]; int len; while ((len=in.read(buff))!=-1){ out.write(buff,0,len); } return defineClass(className,out.toByteArray(),0,out.size()); }catch (Exception e){ e.printStackTrace(); }finally { if(in!=null){ try { in.close(); } catch (IOException e) { e.printStackTrace(); } } if(out!=null){ try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } } } return null; } }
package com.brian.proxy.proxy; import com.brian.proxy.service.OrderService; import com.brian.proxy.service.impl.BrianJdkInvocationhandler; import com.brian.proxy.service.impl.JavaClassLoader; import com.brian.proxy.service.impl.OrderServiceImpl; import javax.tools.JavaCompiler; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; import java.io.File; import java.io.FileWriter; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * @program: architect * @author: Brian Huang * @create: 2019-05-20 22 **/ public class MyProxy { static String rt = "\r\t"; /** * @param classInfo 被代理实现的接口信息 <br> * @param h * @return */ public static Object newProxyInstance(JavaClassLoader javaClassLoader, Class classInfo, BrianJdkInvocationhandler h) { try { // 1.创建代理类java源码文件,写入到硬盘中.. Method[] methods = classInfo.getMethods(); String proxyClass = "package com.brian.proxy.service.impl;" + rt + "import java.lang.reflect.Method;" + rt + "import com.brian.proxy.service.impl.BrianJdkInvocationhandler;" + rt + "import java.lang.reflect.InvocationTargetException;" + rt + "public class $Proxy2 implements " + classInfo.getName() + "{" + rt + "BrianJdkInvocationhandler h;" + rt + "public $Proxy2(BrianJdkInvocationhandler h)" + "{" + rt + "this.h= h;" + rt + "}" + getMethodString(methods, classInfo) + rt + "}"; // 2. 将代理类源码文件写入硬盘中 //String filename = "C:\\Users\\LiangHuang\\Desktopd\\$Proxy2.java"; String filename = JavaClassLoader.class.getResource("").getPath()+"$Proxy2.java"; File f = new File(filename); FileWriter fw = new FileWriter(f); fw.write(proxyClass); fw.flush(); fw.close(); // 3.使用JavaCompiler 编译该$Proxy2源代码 获取class文件 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null); Iterable units = fileMgr.getJavaFileObjects(filename); JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units); t.call(); fileMgr.close(); //4.使用classClassLoader 将$Proxy2.class读取到内存中... Class proxy2Class = javaClassLoader.findClass("$Proxy2"); //5.使用java反射机制给函数中赋值 Constructor m = proxy2Class.getConstructor(BrianJdkInvocationhandler.class); Object o = m.newInstance(h); return o; } catch (Exception e) { e.printStackTrace(); } return null; } public static String getMethodString(Method[] methods, Class intf) { String proxyMe = ""; for (Method method : methods) { proxyMe += "public void " + method.getName() + "() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {" + rt + "Method md= " + intf.getName() + ".class.getMethod(\"" + method.getName() + "\",new Class[]{});" + rt + "this.h.invoke(this,md,null);" + rt + "}" + rt; } return proxyMe; } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { OrderService o = (OrderService) MyProxy.newProxyInstance(new JavaClassLoader(), OrderService.class, new BrianJdkInvocationhandler(new OrderServiceImpl())); o.order(); } }
Cglib是一个强大的，高性能，高质量的代码生成类库。它可以在运行期扩展JAVA类与实现JAVA接口。其底层实现是通过ASM字节码处理框架来转换字节码并生成新的类。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。
运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。
优点：JDK动态代理要求被代理的类必须实现接口，当需要代理的类没有实现接口时Cglib代理是一个很好的选择。另一个优点是Cglib动态代理比使用java反射的JDK动态代理要快
缺点：对于被代理类中的final方法，无法进行代理，因为子类中无法重写final函数
实现MethodInterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。
intercept方法的具体参数有
obj 目标类的实例
1. method 目标方法实例（通过反射获取的目标方法实例）
2. args 目标方法的参数
3. proxy 代理类的实例
该方法的返回值就是目标方法的返回值。
public interface MessageService { void sendMessage(Object object); } @Slf4j public class MessageServiceImpl implements MessageService { @Override public void sendMessage(Object object) { log.info("发送航班消息:" + object); } } @Slf4j public class BrianMethodInterceptor implements MethodInterceptor { @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { log.info("cglib执行前...."); Object result = methodProxy.invokeSuper(o, objects); log.info("cglib执行后...."); return result; } } System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"C:\\Users\\LiangHuang\\Desktop\\work"); Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(MessageServiceImpl.class); enhancer.setCallback(new BrianMethodInterceptor()); MessageServiceImpl messageService = (MessageServiceImpl) enhancer.create(); messageService.sendMessage("CX233航班即将起飞...");
其中通过设置 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"C:\\Users\\LiangHuang\\Desktop\\work")，将动态生成的class文件生成到指定文件夹下
可以看到生成了三个class文件
其中 MessageServiceImpl$$EnhancerByCGLIB$$dc2beff3 就是我们到代理类，可以看到可以看到继承了我们的MessageServiceImpl类
MessageServiceImpl$$EnhancerByCGLIB$$dc2beff3$$FastClassByCGLIB$$1d34c464 继承自FastClass类
MessageServiceImpl$$FastClassByCGLIB$$98ff1a9f 也是继承自FastClass类，
仔细看下两个类的invoke()方法发现两者区别
ok,现在我们把MessageServiceImpl$$FastClassByCGLIB$$98ff1a9f 复制出来，命名为java文件Debug看一下
MessageServiceImpl$$EnhancerByCGLIB$$dc2beff3 enhancerByCGLIB$$dc2beff3 = new MessageServiceImpl$$EnhancerByCGLIB$$dc2beff3(); BrianMethodInterceptor[] brianMethodInterceptors = new BrianMethodInterceptor[1]; brianMethodInterceptors[0] = new BrianMethodInterceptor(); enhancerByCGLIB$$dc2beff3.setCallbacks(brianMethodInterceptors); enhancerByCGLIB$$dc2beff3.sendMessage("CX880航班30分钟后停靠E22...");
下面的代码要开始翻看class编译代码
var10000就是我们的动态生成的代理类，那这个索引值17在哪获取的呢？看下面
最后看下我们代理类的的CGLIB$sendMessage$0方法，实际走的supper.sendMessage()方法，即走我们目标的类MessageServiceImpl的sendMessage()方法
<dependencies>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
静态代理需要自己写代理类，而动态代理不需要写代理类。
JDK动态代理底层实现:
1. 基于实现接口的方式生成动态代理代理对象，通过java反射技术调用目标方法，相比直接调用方法慢
2. 执行过程分4步
2.1 拼接java源代码$Proxy0.java
2.2 通过编译器编译为class文件
2.3 通过类读取class文件到内存中
2.4 采用java反射技术执行我们的目标方法
CGLIB动态代理底层实现:
1.通过继承类的方式生成我们的代理对象，使用ASM字节码技术实现，通过FastClass索引机制直接调用我们的目标方法。
2.执行过程分3步
2.1 采用ASM字节码技术生成class文件
2.2 通过类加载器读取class文件到内存中
2.3 采用FastClass索引技术直接调用我们的目标方法，比Java反射技术效率要高
标签：支持 col nec 结果的处理 信息 不用 bytearray flush output
原文地址：https://www.cnblogs.com/hlkawa/p/13263607.html
