1.为什么会有这样的想法去生成接口的实现类
 
在学习mybatis的过程中，其存在一种机制，接口式编程。利用接口对我们sql的查询进行约束
 
我们只是写了接口，mybatis能给我们返回一个该接口的实例，这个实例是怎么来的？
 
思考：由于我们没有写该接口的实现类，mybatis返回的对象肯定不是简单的动态代理
 
但是我们打印其返回对象的class发现
 
class com.sun.proxy.$Proxy0
 
可以看出其就是jdk的动态代理对象。
 
2.实现动态的为接口生成实现类
 
我们利用jdk的动态代理，来对接口进行实现。
 
传统的使用动态代理的方式，需要传入一个被代理类来进行动态代理
 
我们这里由于没有接口实现类所以我们在写InvocationHandler的实现类的时候，不为其内部添加实现类。
 
代码如下：
 
要生成实现类的接口
 
public interface Person {
	public void showName();
	public void saying();
}
 
InvocationHandler的实现类，内部没有上面接口的实现类，也就是没有被代理类
 
public class InvokeHandler implements InvocationHandler {

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// object的公用方法直接调用当前invoke对象的。
            if (Object.class.equals(method.getDeclaringClass())) {
			return method.invoke(this, args);
            // 针对接口的不同方法书写我们具体的实现
		} else if ("showName".equals(method.getName())) {
			System.out.println("张三");
		} else if ("saying".equals(method.getName())) {
			System.out.println("我叫张三");
		}
		return null;
	}
}
 
 测试：
 
	public static void main(String[] args) {
		Person person = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class}, new InvokeHandler());
		person.showName();
		person.saying();
		System.out.println(person);
		System.out.println(person.getClass());
	}
 
张三
我叫张三
toString
D.InvokeHandler@6bc7c054
class com.sun.proxy.$Proxy0
 
这样我们就动态的简单的生成了一个接口的实现类。其原理还是动态代理，只是抛弃掉了被代理类
 
3.总结
 
mybaties内部动态的生成接口的实现类，其基本原理就是是如上面的代码所展示
 
可以去看其MapperProxy的源码：
 
public class MapperProxy<T> implements InvocationHandler, Serializable {
  // 可以看出内部字段是没有被代理类的
  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache;

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  @Override
  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 (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }

  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
      throws Throwable {
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
        .getDeclaredConstructor(Class.class, int.class);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
    return constructor
        .newInstance(declaringClass,
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  }

  /**
   * Backport of java.lang.reflect.Method#isDefault()
   */
  private boolean isDefaultMethod(Method method) {
    return (method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
        && method.getDeclaringClass().isInterface();
  }
}
 
 
 
 
 
 
 
 

JDK代理，代理的是接口，那么笔者想一想，既然代理的是接口，那如果没有实现类怎么办，能不能代理。答案是可以的，Mybatis就是这样的。
 
Mybatis使用JDK动态代理来实现Mapper接口，事先保存好Mapper接口，和接口声明的方法，返回值，参数类型，然后代理类的方法调用的时候使用MapperMethod这个事先放入方法缓存里的对象来真实调用功能。
 
笔者极度简化了一下代码：
 
被代理的接口：
 
public interface Subject2 {

    String selectById();
}
 
这个接口可以看成是Mapper接口
 
代理对象：
 
public class SubjectProxy2<T> implements InvocationHandler {

    private Class<T> proxyInterface;
    //这里可以维护一个缓存，存这个接口的方法抽象的对象

    

    SubjectProxy2(Class<T> proxyInterface){
        this.proxyInterface = proxyInterface;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("selectById")){
            //String result = (String) method.invoke(proxyInterface,args);
            //这里可以得到方法抽象对象来调用真的的查询方法
            System.out.println("selectById调用成功");
        }
        return null;
    }

    public T getProxy(){
        return (T) Proxy.newProxyInstance(proxyInterface.getClassLoader(),new Class[]{proxyInterface},this);
    }
}
 
这个代理类使用了泛型，说明这个代理类可以代理所有的mapper接口。
 
那么接下来测试一下：
 
public class ProxyTest2 {

    public static void main(String[] args) {
        SubjectProxy2<Subject2> subjectProxy2 = new SubjectProxy2(Subject2.class);
        Subject2 subject2 = subjectProxy2.getProxy();
        subject2.selectById();
    }
}
 
结果不言而喻。肯定会有相应的输出
 
没有看mybatis源码的时候，我以为动态代理一定要要有实现类才能代理，但是看了优秀的顶级大牛的源码之后，我才发现，原来还可以这样。
 
 

我们大家都知道，一般情况下，如果一个接口没有实现类的话，我们直接调用该接口的方法会报错。但我们用过的Mybatis中Dao接口，或者Spring Data JPA接口，其实我们没有手动为他们编写实现类，那为什么仍然能正常调用呢？这里就涉及到了动态代理。下面我演示一下，如何利用JDK为一个接口创建动态实现。
 
代码目录大致如下，在com.company.proxy包下有三个类文件
 
一、SaleService 这个是一个接口声明，后面我们将为该接口创建一个动态实现。其源码如下：
 
package com.company.proxy;

/**
 *
 * @author LICHUANG
 */
public interface SaleService {

    /**
     * 出售
     * @param goodsName 商品名称
     * @param price 价格
     * @return
     */
    String sale(String goodsName,Integer price);
}
 
二、SaleInvocation 该类实现了InvocationHandler接口，并重写其invoke方法。其源码如下：
 
package com.company.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 *
 * @author LICHUANG
 */
public class SaleInvocation implements InvocationHandler {

    private Class<?> clazz;

    public SaleInvocation(Class<?> o) {
        this.clazz = o;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //一般DEBUG时，我们查看变量时，会调用其toString()方法，由于该方法也会被代理，所以出现递归调用，
        //这里为了避免DEBUG时，重复调用方法，所以作特殊处理
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this,args);
        }
        System.out.println("调用前");
        //这里是为接口的方法构造实现逻辑，
        // 由于我们已经获取到了方法名称和参数值，所以可以根据实际需要去创建实现逻辑。
        Object result = "方法名称:" + method.getName() + ",参数值:" + Arrays.toString(args) + ",clazz:" + clazz;
        System.out.println("调用后result:" + result);
        return result;
    }
}
 
三、ProxyTest 这个类主要是包含main方法，用来测试的。其源码如下：
 
package com.company.proxy;

import java.lang.reflect.Proxy;

/**
 * 
 *
 * @author LICHUANG
 */
public class ProxyTest {

    public static void main(String[] args) {
        Class<?> clazz = SaleService.class;
        SaleInvocation invocation = new SaleInvocation(clazz);
        SaleService proxyObject = (SaleService) Proxy.newProxyInstance(clazz.getClassLoader(),new Class[] {clazz},invocation);
        String result = proxyObject.sale("商品名称",5);
        System.out.println("得到返回结果：" + result);
    }
}
 
可以注意到，以上SaleService接口，我并没有手动编写任何实现类，但我仍然能正常调用其String sale(String goodsName,Integer price)方法。
 
最后main方法运行结果如下：
 
调用前
调用后result:方法名称:sale,参数值:[商品名称, 5],clazz:interface com.company.proxy.SaleService
得到返回结果：方法名称:sale,参数值:[商品名称, 5],clazz:interface com.company.proxy.SaleService

Process finished with exit code 0
 
 

使用通过接口定义，或解析接口注解等完成相关功能，如mybatis的SqlSession.getMapper的实现
 
接口定义
 
package cn.proxy;  

public interface IHello {  
    String say(String aa);  
}  
 
代理实现
 
package cn.proxy;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
/** 
  JDK动态代理代理类  
 */  
@SuppressWarnings("unchecked")  
public class FacadeProxy implements InvocationHandler {    
    @Override    
    public Object invoke(Object proxy, Method method, Object[] args)    
            throws Throwable {    
        System.out.println("接口方法调用开始");    
        //执行方法    
        System.out.println("method toGenericString:"+method.toGenericString());  
        System.out.println("method name:"+method.getName());  
        System.out.println("method args:"+(String)args[0]);  
        System.out.println("接口方法调用结束");    
        return "调用返回值";    
    }    
    public static <T> T newMapperProxy(Class<T> mapperInterface) {  
        ClassLoader classLoader = mapperInterface.getClassLoader();  
        Class<?>[] interfaces = new Class[]{mapperInterface};  
        FacadeProxy proxy = new FacadeProxy();  
        return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);  
      }  
}  
 
运行
 
package cn.proxy;  

public class Test {  
    public static void main(String[] args) {  
        IHello hello = FacadeProxy.newMapperProxy(IHello.class);  
        System.out.println(hello.say("hello world"));  
    }  
}  
 
运行结果
 
接口方法调用开始  
method toGenericString:public abstract java.lang.String cn.proxy.IHello.say(java.lang.String)  
method name:say  
method args:hello world  
接口方法调用结束  
调用返回值 
 
转载于http://blog.csdn.net/zhu_tianwei/article/details/40076391