從mybatis源碼看JDK動態代理

網上好多說到動態代理的文章內容都是這樣子的：

一個實際干事的類Real；一個被創造的代理類Proxy。

Proxy調用Real中被代理的方法；有模有樣的在被代理的方法前后打印出一些字符串。

比如下面的例子：

public class JdkProxy {
    static interface IProxy{
        String say(String s);
    }
    static class Real implements IProxy{
        @Override
        public String say(String s) {
            System.out.println("說完了，返回結果");
            return s;
        }
    }   

    static class MyInvocationHandler implements  InvocationHandler{
        private Object real;

        public MyInvocationHandler(Object real) {
            this.real = real;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object res=null;
            if(method.getName().equals("say")){
                System.out.println("say start...");
                res=method.invoke(real,args);
                System.out.println("say end...");
            }
            return res;
        }
    }    

    public static void main(String[] args) {
        execu1();      
    }

    private static void execu1(){
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        Real real=new Real();
        IProxy proxy=(IProxy) Proxy.newProxyInstance(real.getClass().getClassLoader(), real.getClass().getInterfaces(),new MyInvocationHandler(real));
        String s=proxy.say("abc");
        System.out.println(s);
    }   

}

上面21-27行代碼是調用被代理的方法；

如果我現在不調用被代理的方法，而是直接寫一個方法體。

代碼如下：

public class JdkProxy {
    static interface IProxy{
        String say(String s);
    }
    static class Real implements IProxy{
        @Override
        public String say(String s) {
            System.out.println("說完了，返回結果");
            return s;
        }
    }   

    static class MyInvocationHandler implements  InvocationHandler{
        private Object real;

        public MyInvocationHandler(Object real) {
            this.real = real;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           return "我什么也不代理，我直接就是一個方法"; 23         }
    }    

    public static void main(String[] args) {
        execu1();      
    }

    private static void execu1(){
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        Real real=new Real();
        IProxy proxy=(IProxy) Proxy.newProxyInstance(IProxy.class.getClassLoader(),new Class[]{IProxy.class},new MyInvocationHandler(real));
        String s=proxy.say("abc");
        System.out.println(s);
    }   

}

改動代碼是22行的代碼。

如果不需要被代理的方法了，那么還需要實際干活的類嗎？

繼續修改代碼：

public class JdkProxy {
    static interface IProxy{
        String say(String s);
    }   

    static class MyInvocationHandler implements  InvocationHandler{
        

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           return "我什么也不代理，我直接就是一個方法";
        }
    }    

    public static void main(String[] args) {
        execu1();      
    }

    private static void execu1(){
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");      
        IProxy proxy=(IProxy) Proxy.newProxyInstance(IProxy.class.getClassLoader(),new Class[]{IProxy.class},new MyInvocationHandler());
        String s=proxy.say("abc");
        System.out.println(s);
    } 
}

 上面的程序依然能夠正常運行。

從這個層面來說，動態代理就是給我們創造了一個類，至於有沒有實際干活的類無關。

網上到處都在說mybatis接口編程的用的是動態代理，創造代理類我們很好理解，那么他到底代理了什么類呢？

先來個簡單的mybatis例子：

SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
SqlSession sqlSession= sqlSessionFactory.openSession();
IRoleMapper iRoleMapper=sqlSession.getMapper(IRoleMapper.class);
List<Role> list=iRoleMapper.getRole(1L);

第三行代碼就應該是獲取代理的過程；iRoleMapper指向具體的代理類。

下面查看源碼：

getMapper（）源碼：

 public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

代碼比較簡潔，代理類是在第7行生成的。進入newInstance()方法：

newInstance()源碼：

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

第1行的newInstance調用的是JDK的代理方法

第5行的newInstance是Mybatis自己的方法，根據JDK動態代理的調用規則，第6行的MapperProxy一定繼承了InvocationHandler接口，並且實現了接口方法invoke（）；

invoke（）源碼

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (method.isDefault()) {
        if (privateLookupInMethod == null) {
          return invokeDefaultMethodJava8(proxy, method, args);
        } else {
          return invokeDefaultMethodJava9(proxy, method, args);
        }
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

invoke（）方法體中並沒有調用    res=method.invoke(real,args);這類的代碼。說明一個問題，這里並沒有我們常說的Real這樣的類。

總結：

1.JDK動態代理只是需要一個接口，至於實際干活類不是必須的；至於具體做什么，由程序員在invoke（）中去實現。

2.Mybatis用了JDK動態代理，但是並沒有提供被代理的類；只是提供了一個代理類或者干脆說提供了一個我們看不見的類用於執行Sql