Demo

在分析动态代理之前，我们先做一个 Demo，来模拟一下 MyBatis 是如果执行 SQL 的

思路是：

  • 写一个 @Select 注解，注解里面写上 SQL 语句
  • 写一个 SessionFactory，获取 mapper

  • 写一个动态代理，执行 Dao 接口中的 query 方法

    1. @Target(ElementType.METHOD)
    2. @Retention(RetentionPolicy.RUNTIME)
    3. public @interface Select {
    4.   String value() default "";
    5. }

    ```java public interface UserDao {

    @Select(“select * from user”) List query();

    }

    1. ```java
    2. public class MyInvocationHandler implements InvocationHandler {
    3.     @Override
    4.     public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
    5.         System.out.println("db connection...");
    6.         Select annotation = method.getAnnotation(Select.class);
    7.         String sql = annotation.value();
    8.         System.out.println("execute sql: " + sql);
    9.         Class<?> returnType = method.getReturnType();
    10.         return null;
    11.     }
    12. }
    1. public class SessionFactory {
    3.     public static <T> T getMapper(Class<T> clazz) {
    4.         return (T) Proxy.newProxyInstance(SessionFactory.class.getClassLoader(), 
    5.                                           new Class[]{clazz}, 
    6.                                           new MyInvocationHandler());
    7.     }
    8. }
    1. public static void main(String[] args) {
    2.     AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
    3.     ac.register(AppConfig.class);
    4.     ac.refresh();
    6.     UserDao mapper = SessionFactory.getMapper(UserDao.class);
    7.     mapper.query();
    8. }
    10. // db connection...
    11. // execute sql: select * from user

    这就是一个典型的动态代理案例，相当于我们自己实现了一个接口实现类，并重写了业务逻辑

    什么是代理

    代理就是对原有对象进行了一个“改变”，代理分为静态代理和动态代理，

    静态代理

    静态代理的实现有“继承”和“聚合”两种方法

    继承

    优点：使用简单，缺点：不灵活，当有一个新的需求，就需要新写一个类

    1. public class UserService {
    2.     public void find() {
    3.         System.out.println("find users");
    4.     }
    5. }
    7. public class UserServiceProxyLog extends UserService {
    8.     @Override
    9.     public void find() {
    10.         System.out.println("record log");
    11.         super.find();
    12.     }
    13. }
    15. public class Test {
    16.     public static void main(String[] args) {
    17.         UserService userService = new UserServiceProxyLog();
    18.         userService.find();
    19.     }
    20. }

    聚合

    1. 代理对象和目标对象，都必须实现同一个接口
    2. 代理对象必须包含目标对象
    3. 执行代理对象重写的方法

    优点：层次清晰，缺点：如果业务流程很复杂，代码量就会比较大

    1. public interface Service {
    2.     void query();
    3. }
    5. public class UserService implements Service {
    6.     @Override
    7.     public void query() {
    8.         System.out.println("query for user");
    9.     }
    10. }
    12. public class ServiceLog implements Service {
    14.     Service target;
    16.     public ServiceLog(Service target) {
    17.         this.target = target;
    18.     }
    20.     @Override
    21.     public void query() {
    22.         System.out.println("log");
    23.         target.query();
    24.     }
    25. }
    27. public class ServicePower implements Service {
    28.     Service target;
    30.     public ServicePower(Service target) {
    31.         this.target = target;
    32.     }
    34.     @Override
    35.     public void query() {
    36.         System.out.println("power");
    37.         target.query();
    38.     }
    39. }
    41. public class Test {
    43.     public static void main(String[] args) {
    44.         Service proxy = new ServiceLog(new UserService());
    45.         proxy.query();
    47.         Service proxy1 = new ServicePower(proxy);
    48.         proxy1.query();
    49.     }
    51. }

    动态代理

    动态代理有 JDK 动态代理和 CGLIB 动态代理，这里我们模拟一下 JDK 的 Proxy

    接口

    1. public interface Service {
    2.     void query(String name);
    3. }

    实现类

    我们现在的需求是给实现类加上一个日志方法

    1. public class UserService implements Service {
    2.     @Override
    3.     public void query(String name) {
    4.         System.out.println("query " + name);
    5.     }
    6. }

    方法增强

    1. public interface MyInvocationHandler {
    2.     void invoke();
    3. }

    动态代理类

    1. public class MyProxy {
    3.     public static final String LINE = "\n";
    4.     public static final String TAB = "\t";
    6.     @SuppressWarnings("unchecked")
    7.     public static <T> T getInstance(Object target, MyInvocationHandler handler) {
    9.         Class<?> clazz = target.getClass().getInterfaces()[0];
    11.         String interfaceName = clazz.getSimpleName();
    13.         String packageContent = "package org.eric.proxy;" + LINE;
    14.         String importContent = "import " + clazz.getName() + ";" + LINE;
    15.         importContent += "import " + MyInvocationHandler.class.getName() + ";" + LINE;
    17.         String clazzFirstLineContent = "public class $Proxy implements " + interfaceName + " {" + LINE;
    18.         String fieldContent = TAB + "private " + interfaceName + " target;" + LINE;
    19.         fieldContent += TAB + "private MyInvocationHandler handler;" + LINE;
    21.         String constructorContent = TAB + "public $Proxy(" + interfaceName + " target, MyInvocationHandler handler) {" + LINE;
    22.         constructorContent += TAB + TAB + "this.target = target;" + LINE;
    23.         constructorContent += TAB + TAB + "this.handler = handler;" + LINE;
    24.         constructorContent += TAB + "}" + LINE;
    26.         String methodContent = "";
    27.         Method[] methods = clazz.getDeclaredMethods();
    28.         for (Method method : methods) {
    29.             Class<?>[] args = method.getParameterTypes();
    30.             String argsContent = "";
    31.             String paramsContent = "";
    32.             int flag = 0;
    33.             for (Class<?> arg : args) {
    34.                 String temp = arg.getSimpleName();
    35.                 // String p0, String p1,
    36.                 argsContent += temp + " p" + flag + ", ";
    37.                 // p0, p1,
    38.                 paramsContent += "p" + flag + ", ";
    39.                 flag++;
    40.             }
    41.             if (args.length > 0) {
    42.                 argsContent = argsContent.substring(0, argsContent.lastIndexOf(","));
    43.                 paramsContent = paramsContent.substring(0, paramsContent.lastIndexOf(","));
    44.             }
    46.             String returnTypeName = method.getReturnType().getSimpleName();
    47.             String methodName = method.getName();
    49.             methodContent += TAB + "public " + returnTypeName + " " + methodName + "(" + argsContent + ") {" + LINE;
    50.             methodContent += TAB + TAB + "handler.invoke();" + LINE;
    51.             methodContent += TAB + TAB + "target." + methodName + "(" + paramsContent + ");" + LINE;
    52.             methodContent += TAB + "}" + LINE;
    53.         }
    55.         String content = packageContent + importContent + clazzFirstLineContent + fieldContent + constructorContent + methodContent + "}";
    57.         try {
    58.             File file = new File("d:\\org\\eric\\proxy\\$Proxy.java");
    59.             if (!file.getParentFile().exists()) {
    60.                 file.getParentFile().mkdirs();
    61.             }
    62.             if (!file.exists()) {
    63.                 file.createNewFile();
    64.             }
    65.             FileWriter fw = new FileWriter(file);
    66.             fw.write(content);
    67.             fw.flush();
    68.             fw.close();
    70.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    71.             StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
    72.             Iterable<? extends JavaFileObject> javaFileObjects = fileManager.getJavaFileObjects(file);
    73.             JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, javaFileObjects);
    74.             t.call();
    75.             fileManager.close();
    77.             URL[] urls = new URL[]{new URL("file:D:\\\\")};
    78.             URLClassLoader urlClassLoader = new URLClassLoader(urls);
    79.             Class<?> aClass = urlClassLoader.loadClass("org.eric.proxy.$Proxy");
    80.             Constructor<?> constructor = aClass.getConstructor(clazz, MyInvocationHandler.class);
    81.             return (T) constructor.newInstance(target, handler);
    83.         } catch (Exception e) {
    84.             e.printStackTrace();
    85.         }
    87.         return null;
    89.     }
    91. }

    测试

    有了动态代理类后，我们就可以用，动态代理类来增强现有实现类的方法

    1. public class Test {
    3.     public static void main(String[] args) {
    4.         Service target = new UserService();
    5.         Service proxy = MyProxy.getInstance(target, new MyInvocationHandler() {
    6.             @Override
    7.             public void invoke() {
    8.                 System.out.println("record log...");
    9.             }
    10.         });
    11.         proxy.query("hello");
    12.     }
    14. }
    16. // record log...
    17. // query hello

    总结

    动态代理其实就是改变原有实现类的方法，核心是，直接在内存中生成字节码文件，并返回实现类的接口