1、什么是代理模式
    为其他对象提供一种代理以控制对这个对象的访问。

    2、为什么使用代理模式
    开闭原则，增加功能。

    3、代理模式实现原理
    代理模式主要包含三个角色:抽象主题角色Subject,被代理角色Proxied,代 理类proxy

    图片1.png

    4、代理模式应用场景
    SpringAOP、日志收集、权限控制、过滤器、RPC远程调用

    5、代理模式的创建方式
    静态代理和动态代理
    理解：自己手写代理类就是静态代理

    6、静态代理（两种实现方式）

    1. //基于接口实现方式
    2. public interface OrderService {
    3.     void order();
    4. }
    6. public class OrderServiceImpl implements OrderService {
    7.     public void order() {
    8.         System.out.println("用户下单操作..");
    9.     }
    10. }
    12. public class OrderServiceProxy implements OrderService {
    13.     /**
    14.      * 代理对象
    15.      */
    16.     private OrderService proxiedOrderService;
    18.     public OrderServiceProxy( OrderService orderService) {
    19.       this.proxiedOrderService=orderService;
    20.     }
    22.     public void order() {
    23.         System.out.println("日志收集开始..");
    24.         proxiedOrderService.order();
    25.         System.out.println("日志收集结束..");
    26.     }
    27. }
    28. public class ClientTest {
    29.     public static void main(String[] args) {
    30.         OrderService orderService = new OrderServiceProxy(new OrderServiceImpl());
    31.         orderService.order();
    32.     }
    33. }
    37. //接口继承方式实现
    38. public class OrderServiceProxy extends OrderServiceImpl {
    40.     public void order() {
    41.         System.out.println("日志收集开始..");
    42.         super.order();
    43.         System.out.println("日志收集结束..");
    44.     }
    45. }
    46. public class ClientTest {
    47.     public static void main(String[] args) {
    48.         OrderService orderService = new OrderServiceProxy();
    49.         orderService.order();
    50.     }
    51. }

    7、动态代理
    JDK动态代理：
    JDK动态代理所代理的类定要实现某个接口，其底层应用的是java反射实 现的；

    创建的步骤：
    1、创建被代理的接口和类；
    2、实现InvocationHandler接口，对目标接口中声明的所有方 法进行统一处理；
    3、调用Proxy的静态方法，创建代理类并生成相应的代理对 象。

    2. public interface OrderService {
    3.     void order();
    4. }
    7. public class OrderServiceImpl implements OrderService {
    8.     public void order() {
    9.         System.out.println("修改数据库订单操作..");
    10.     }
    11. }
    14. public class JdkInvocationHandler implements InvocationHandler {
    15.     /**
    16.      * 目标代理对象
    17.      */
    18.     public Object target;
    20.     public JdkInvocationHandler(Object target) {
    21.         this.target = target;
    22.     }
    24.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    25.         System.out.println(">>>日志收集开始>>>>");
    26.         // 执行代理对象方法
    27.         Object reuslt = method.invoke(target, args);
    28.         System.out.println(">>>日志收集结束>>>>");
    29.         return reuslt;
    30.     }
    32.     /**
    33.      * 获取代理对象接口
    34.      *
    35.      * @param <T>
    36.      * @return
    37.      */
    38.     public <T> T getProxy() {
    39.         return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    40.     }
    42. }
    44. //测试
    45. JdkInvocationHandler jdkInvocationHandler = new JdkInvocationHandler(new OrderServiceImpl());
    46. OrderService proxy = jdkInvocationHandler.getProxy();
    47. proxy.order();

    原理分析：
    F24D6D79-18D2-4478-AFEA-A8438CEB850E.png
    1、获取代理的生成的class文件
    System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);
    2、使用反编译工具进行反编译
    1.png

    CGLIB动态代理
    JDK动态代理是通过实现接口来实现 的，而CGLIB是通过继承实现类来实现的；其底层是通过ASM字节码框架来动态修改目标类的字节码来实现的，从而CGLI代理类对象实现动态代理效率比Jdk动态代理反射技术效率要高。
    缺点：对于被代理类中的final方法，无法进行代理，因为子类中无法重写final函数
    实现步骤：
    实现MethodInterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。
    intercept方法的具体参数有
    obj 目标类的实例
    1、 method 目标方法实例（通过反射获取的目标方法实例）
    2、 args 目标方法的参数
    3.、proxy 代理类的实例
    该方法的返回值就是目标方法的返回值。

    1. public class OrderServiceImpl {
    2.     public void order() {
    3.         System.out.println("用户下单操作..");
    4.     }
    5. }
    7. public class CglibMethodInterceptor implements MethodInterceptor {
    8.     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    9.         System.out.println("<<<<<日志收集开始...>>>>>>>");
    10.         Object reuslt = proxy.invokeSuper(obj, args);
    11.         System.out.println("<<<<<日志收集结束...>>>>>>>");
    12.         return reuslt;
    13.     }
    14. }
    16. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
    17. CglibMethodInterceptor cglibMethodInterceptor = new CglibMethodInterceptor();
    18. Enhancer enhancer = new Enhancer();
    19. // 设置代理类的付类
    20. enhancer.setSuperclass(OrderServiceImpl.class);
    21. // 设置回调对象
    22. enhancer.setCallback(cglibMethodInterceptor);
    23. // 创建代理对象
    24. OrderServiceImpl orderServiceImpl = (OrderServiceImpl) enhancer.create();
    25. orderServiceImpl.order();

    maven依赖

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>cglib</groupId>
    4.         <artifactId>cglib</artifactId>
    5.         <version>3.2.12</version>
    6.     </dependency>
    7. </dependencies>

    8、深入理解
    自己手写
    思路：
    1.拼接代理类的源代码
    2. 写入到到本地文件中.
    3. 使用JavaCompiler技术将源代码编译成class文件
    4.使用classLoader 加载到内存中.
    5.指明初始化有参数构造函数

    1. public interface OrderService {
    3.     public void order() throws Throwable;
    4. }
    6. public class OrderServiceImpl implements OrderService {
    8.     public void order() {
    9.         System.out.println("数据库订单执行操作");
    10.     }
    11. }
    13. public interface MyExtJdkInvocationHandler {
    14.     /**
    15.      * @param proxy  代理类
    16.      * @param method 目标方法
    17.      * @param args   参数
    18.      * @return
    19.      * @throws Throwable
    20.      */
    21.     public Object invoke(Object proxy, Method method, Object[] args)
    22.             throws Throwable;
    23. }
    25. public class MyJdkInvocationHandler implements MyExtJdkInvocationHandler {
    26.     /**
    27.      * 目标对象 被代理的类 真实访问的类的对象
    28.      */
    29.     private Object target;
    31.     public MyJdkInvocationHandler(Object target) {
    32.         this.target = target;
    33.     }
    35.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    36.         System.out.println("<<<<<<<<<纯手写jdk动态代理日志开始>>>>>>>>>>");
    37.         Object result = method.invoke(target, args);// 使用java的反射执行
    38.         System.out.println("<<<<<<<<纯手写jdk动态代理结束>>>>>>>>>>");
    39.         return result;
    40.     }
    41. }
    44. public class MyProxy {
    45.     static String rt = "\r\t";
    47.     public static Object newProxyInstance(JavaClassLoader javaClassLoader,
    48.                                           Class<?> classInfo,
    49.                                           MyExtJdkInvocationHandler h) {
    50.         //1.拼接代理类的源代码
    51.         try {
    53.             // 1.创建代理类java源码文件,写入到硬盘中..
    54.             Method[] methods = classInfo.getMethods();
    55.             String proxyClass = "package com.mayikt.ext.proxy;" + rt
    56.                     + "import java.lang.reflect.Method;" + rt
    57.                     + "import com.mayikt.ext.proxy.MyExtJdkInvocationHandler;" + rt
    58.                     + "public class $Proxy0 implements " + classInfo.getName() + "{" + rt
    59.                     + "MyExtJdkInvocationHandler h;" + rt
    60.                     + "public $Proxy0(MyExtJdkInvocationHandler h)" + "{" + rt
    61.                     + "this.h= h;" + rt + "}"
    62.                     + getMethodString(methods, classInfo) + rt + "}";
    63.             // 2. 写入到到本地文件中..
    64.             String filename = "d:/$Proxy0.java";
    65.             File f = new File(filename);
    66.             FileWriter fw = new FileWriter(f);
    67.             fw.write(proxyClass);
    68.             fw.flush();
    69.             fw.close();
    70.             // 3. 将源代码编译成class文件
    71.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    72.             StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
    73.             Iterable units = fileMgr.getJavaFileObjects(filename);
    74.             JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
    75.             t.call();
    76.             fileMgr.close();
    77.             // 4.使用classLoader 加载到内存中..
    78.             Class<?> $Proxy0 = javaClassLoader.findClass("$Proxy0");
    79.             // 5.指明初始化有参数构造函数
    80.             Constructor<?> constructor = $Proxy0.getConstructor(MyExtJdkInvocationHandler.class);
    81.             Object o = constructor.newInstance(h);
    82.             return o;
    84.         } catch (Exception e) {
    85.             e.printStackTrace();
    86.         }
    88.         return null;
    89.     }
    91.     public static String getMethodString(Method[] methods, Class intf) {
    92.         String proxyMe = "";
    93.         for (Method method : methods) {
    94.             proxyMe += "public void " + method.getName() + "() throws Throwable {" + rt
    95.                     + "Method md= " + intf.getName() + ".class.getMethod(\"" + method.getName()
    96.                     + "\",new Class[]{});" + rt
    97.                     + "this.h.invoke(this,md,null);" + rt + "}" + rt;
    99.         }
    100.         return proxyMe;
    101.     }
    103.     public static void main(String[] args) {
    104.         newProxyInstance(null, OrderService.class, null);
    105.     }
    107. }

    工具类

    1. public class JavaClassLoader extends ClassLoader {
    3.     private File classPathFile;
    5.     public JavaClassLoader(){
    6. //        String classPath=JavaClassLoader.class.getResource("").getPath();
    7.         String classPath="D:\\";
    8.         this.classPathFile=new File(classPath);
    9.     }
    11.     @Override
    12.     public Class<?> findClass(String name) throws ClassNotFoundException {
    13.         String className= JavaClassLoader.class.getPackage().getName()+"."+name;
    14.         if(classPathFile!=null){
    15.           File classFile=new File(classPathFile,name.replaceAll("\\.","/")+".class");
    16.           if(classFile.exists()){
    17.               FileInputStream in=null;
    18.               ByteArrayOutputStream out=null;
    19.               try {
    20.                   in=new FileInputStream(classFile);
    21.                   out=new ByteArrayOutputStream();
    22.                   byte[] buff=new byte[1024];
    23.                   int len;
    24.                   while ((len=in.read(buff))!=-1){
    25.                      out.write(buff,0,len);
    26.                   }
    27.                   return defineClass(className,out.toByteArray(),0,out.size());
    28.               }catch (Exception e){
    29.                   e.printStackTrace();
    30.               }finally {
    31.                   if(in!=null){
    32.                       try {
    33.                           in.close();
    34.                       } catch (IOException e) {
    35.                           e.printStackTrace();
    36.                       }
    37.                   }
    38.                   if(out!=null){
    39.                       try {
    40.                           out.close();
    41.                       } catch (IOException e) {
    42.                           e.printStackTrace();
    43.                       }
    44.                   }
    45.               }
    46.           }
    47.         }
    48.         return null;
    49.     }
    50. }

    java反射

    1. public static void main(String[] args) {
    2.     MemberServiceImpl memberService = new MemberServiceImpl();
    3.     Class member= memberService.getClass();
    4.     Annotation[] annotations=member.getAnnotations();
    5.     for(int i=0;i<annotations.length;i++){
    6.         //org.springframework.web.bind.annotation.RestController
    7.         System.out.println(annotations[i].annotationType().getName());
    8.         //RestController
    9.         System.out.println(annotations[i].annotationType().getSimpleName());
    10.     }
    12. }
    14. @RestController
    15. public class MemberServiceImpl {
    17. }