上一篇文章中讲述了DefaultSqlSession的创建过程。它可以利用executor来完成crud操作、管理数据库连接和事务，也可以根据mapper类型来获取mapper代理对象。sql的执行放到后面讲，本文先记录一下mapper代理对象是如何生成的
MemberDao mapper = sqlSession.getMapper(MemberDao.class);
当我们写下getMapper(mapper.class)的时候，框架在后台做了些什么事？实际上，sqlSession本身是对mapper无感知的，所有关于mapper的信息，都在configuration属性中。所以getMapper先交给了configuration来完成。
public <T> T getMapper(Class<T> type) {
return this.configuration.getMapper(type, this);
}
在第一篇文章中说过，对mapper的解析完成后，以type：MapperProxyFactory(type)的形式将mapper的类型和产生对应代理对象的工厂存放到了mapperRegistry中的knowMapppers内，并将mapper的parameterMap、resultMap、statement等属性以namespace: val的形式存到了对应的HashMap里。然后在这里configuration.getMapper就将工作交给了mapperRegistry.同时，为了完成mapper与sqlSession的绑定，还将sqlSession作为参数传递了进来。
//委派给mapperRegistry完成
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return this.mapperRegistry.getMapper(type, sqlSession);
}
看看mapperRegistry是如何获取到mapper代理对象的吧。
// mapperRegistry.getMapper(...)
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
} else {
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception var5) {
throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
}
}
}
实际上，mapperRegistry并不承担创建代理对象的职责，它的责任就是完成mapper的注册。创建代理对象交给mapperProxyFactory来完成。mapperProxyFactory内部mapperInterface用于封装mapper的类型对象，methodCache则存放方法缓存。
public class MapperProxyFactory<T> {
private final Class<T> mapperInterface;
private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap();
// ······
protected T newInstance(MapperProxy<T> mapperProxy) {
return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
return this.newInstance(mapperProxy);
}
重点关注代理对象的创建，在这里首先调用的是 newInstance(SqlSession sqlSession)方法，然后调newInstance(MapperProxy<T> mapperProxy),最后由Proxy.newProxyInstance()生成代理对象。至于这中间做了什么，我们想想动态代理Proxy.newProxyInstance(...)是如何创建代理对象的吧。
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
Proxy.newProxyInstance(loader, interfaces, ih)需要三个参数: 被代理对象的类加载器loader、被代理对象的接口类型数组Class<?> [] interfaces、定义了方法调用逻辑的InvocationHandler h.
先思考一下：假设现在我们有一个类对象，需要创建一个能够对它的方法进行增强的代理实例对象，该对象进行方法调用的逻辑在invocationHandler中,该如何创建这个代理对象呢？
咱也不知道哇，咱只知道动态代理...这里的invocationHandler不就有方法的实现逻辑吗？我们只需要一个对象，把该对象方法的调用关联给这个invocationHandler去做不就行了吗？
//todo : 动态代理ref:https://zhuanlan.zhihu.com/p/60805342
//invocationHandler.invoke(proxy, method, args)
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
所以Proxy类就实现了这么一个功能:动态创建一个代理对象proxyObj,将对象与InvocationHandler ih关联。然后当我们在程序中使用proxyObj.method(args)的时候，实际上就交给了ih.invoke(proxyObj, method, args)去处理。
我们现在有了前两个参数，但是当方法被调用时怎么进行处理的逻辑还没有啊。因此需要先创建一个InvocationHandler对象来,这个对象就是mapperProxy.他的构造方法很简单，就是将sqlSession, 接口和方法缓存关联进来。没什么好讲的
public class MapperProxy<T> implements InvocationHandler, Serializable {
private static final long serialVersionUID = -4724728412955527868L;
private static final int ALLOWED_MODES = 15;
private static final Constructor<Lookup> lookupConstructor;
private static final Method privateLookupInMethod;
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperProxy.MapperMethodInvoker> methodCache;
public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperProxy.MapperMethodInvoker> methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
} catch (Throwable var5) {
throw ExceptionUtil.unwrapThrowable(var5);
}
}
//......
}
在newInstance(SqlSession sqlSession)时创建了mapperProxy，然后再使用Proxy.newInstance(interface.getClassLoader, new Class[]{interface}, mapperProxy)创建了一个对象，并将该对象与mapperProxy进行了关联,最后返回代理对象。如下。
public class MapperProxyFactory<T> {
// ······
protected T newInstance(MapperProxy<T> mapperProxy) {
return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
return this.newInstance(mapperProxy);
}
至此，xxxMapper = getMapper(xxxMapper.class)就结束了。我们拿到了代理对象，接下来的问题就是如何使用这个代理对象了，也就是当我们调用xxxMapper .xxxMethod()时，框架在后台做了些什么。
to be continued.
网友评论