mybatis原理及整合spring原理

话题导入：首先我一开始接触mybatis的时候，还是在做SSM课程设计，我会在项目的spring配置文件中会有如下配置：

    
    
        
        
        
        
        
        
        
    
    
    
        
    
    
    
        
        
        
        
        
        
    
    
    
        
        
    
复制代码

\

准备知识：

1、jdbc使用

public class DbUtil {

    public static final String URL = "jdbc:mysql://localhost:3306/imooc";
    public static final String USER = "liulx";
    public static final String PASSWORD = "123456";

    public static void main(String[] args) throws Exception {
        //1.加载驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获得数据库连接
        Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
        //3.操作数据库，实现增删改查
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT user_name, age FROM imooc_goddess");
        //如果有数据，rs.next()返回true
        while(rs.next()){
            System.out.println(rs.getString("user_name")+" 年龄："+rs.getInt("age"));
        }
        
        //prepareStatement用法
        //sql
        String sql = "INSERT INTO imooc_goddess(user_name, sex, age, birthday, email, mobile,"+
            "create_user, create_date, update_user, update_date, isdel)"
                +"values("+"?,?,?,?,?,?,?,CURRENT_DATE(),?,CURRENT_DATE(),?)";
        //预编译
        PreparedStatement ptmt = conn.prepareStatement(sql); //预编译SQL，减少sql执行

        //传参
        ptmt.setString(1, g.getUser_name());
        ptmt.setInt(2, g.getSex());
        ptmt.setInt(3, g.getAge());
        ptmt.setDate(4, new Date(g.getBirthday().getTime()));
        ptmt.setString(5, g.getEmail());
        ptmt.setString(6, g.getMobile());
        ptmt.setString(7, g.getCreate_user());
        ptmt.setString(8, g.getUpdate_user());
        ptmt.setInt(9, g.getIsDel());

        //执行
        ptmt.execute();
    }
}
复制代码

2、动态代理

说到动态代理前先讲下静态代理：

\

\

\

先从静态代理说起：

生活举列子：江俊想买一辆车子，想直接去大众厂家拿车，但是拿不到，就只能从经销商（4儿子）那里拿车，但是4儿子想赚钱，就会强制让我们买装潢（贴膜，导航，行车记录仪），还会让我们买保养（购车后开了1w公里去他们那里保养一下），4儿子就是中间的代理（Proxy）

//汽车售卖接口
public interface CarSale {
    /**
     * 卖车
     */
    void saleCar();
}

//经销商卖车
public class CarFactorySale implements CarSale {
    /**
     * 卖车
     */
    @Override
    public void saleCar() {
        System.out.println("成本价卖车");
    }
}

//4儿子店卖车
public class FourSsale implements CarSale{
    /**
     * 厂家
     */
    private CarFactorySale carFactorySale;

    public FourSsale(CarFactorySale carFactorySale) {
        this.carFactorySale = carFactorySale;
    }
    /**
     * 卖车
     */
    @Override
    public void saleCar() {
        System.out.println("必须先来买我的装潢");
        carFactorySale.saleCar();
        System.out.println("买完车，之后必须到我这里做保养");
    }
}


小结：代理类与实际类都要基础同一个接口，代理类中引入了实际类，代理类其实就是对实际类功能的增强。
复制代码

题外话：是不是想到了切面？

接下来是jdk动态代理(必须有接口)：以helloWorld为例子

//接口类
public interface HelloWorld {
    void sayHello();
}

//实际类
public class HelloWorldImpl implements HelloWorld {
    @Override
    public void sayHello() {
        System.out.println("hello world");
    }
}

//调用处理器
public class MyInvocationHandler implements InvocationHandler{
    //传入实际类
    private Object realTarget;

    public MyInvocationHandler(Object target) {
        this.realTarget = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method:" + method.getName() + "is invoked!");
        System.out.println("在执行实际类逻辑之前，我在。。。");
        Object returnObject = method.invoke(realTarget, args);
        System.out.println("在执行实际类逻辑之后，我在。。。");
        return returnObject;
    }
}

//测试类
public class JDKProxyTest {
    public  void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //创建代理类 代理类class内容见下一段代码
        Class proxyClass = Proxy.getProxyClass(JDKProxyTest.class.getClassLoader(), HelloWorld.class);
        //获取代理类构造方法
        final Constructor constructors = proxyClass.getConstructor(InvocationHandler.class);
        //new一个调度器（里面包含增强逻辑）
        final InvocationHandler invocationHandler = new MyInvocationHandler(new HelloWorldImpl());
        //将包含增强逻辑的调度器作为入池传入代理类构造方法，new一个代理类
        HelloWorld helloWorld = (HelloWorld)constructors.newInstance(invocationHandler);
        //执行代理类的业务方法
        helloWorld.sayHello();

        // 保存生成的代理类的字节码文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //写法二
//        HelloWorld helloWorld = (HelloWorld) Proxy.newProxyInstance(JDKProxyTest.class.getClassLoader(),
//                new Class[]{HelloWorld.class}, new MyInvocationHandler(new HelloWorldImpl()));
//        helloWorld.sayHello();

    }
}

//jdk帮我们生成的代理类
public final class $Proxy0 extends Proxy implements HelloWorld {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    //包含调度器的构造方法
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    //代理方法
    public final void sayHello() throws  {
        try {
            //最终还是调用调用器中的增强方法
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    
    
    //以下三个方法为jdk代理生成的Object下的三个方法
    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("component.HelloWorld").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

小结：动态代理的代理类不用像静态代理那样必须手写一个，而是由jdk生成class文件。这就是静态和动态的区别。
我理解的最大好处就是相比静态代理，动态代理不必为一个新接口就重新写一个调度器，而静态代理如果来了一个新接口 就必须
再写一个代理类。
查资料得知：springAop中用的就是动态代理，统一拦截所有接口请求。如果是静态代理就做不到了，
得一个个写代理类，明显是不可取的。
复制代码

3、xml解析

mybatis中很重要的第一步便是解析配置文件，以及mapper.xml

解析用的都是W3C包下的Document以及javax.xml包下的xpath

  
     city
     beijing
  
  
      district
      chaoyang
  

复制代码

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
 
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
 
public class XPathTest {
	
	public static void main(String args[]){
		  try {
			  //解析文档
			  DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
			  domFactory.setNamespaceAware(true); // never forget this!
			  DocumentBuilder builder = domFactory.newDocumentBuilder();
			  Document doc = builder.parse("city.xml");
			  
			   XPathFactory factory = XPathFactory.newInstance(); //创建 XPathFactory
			   XPath xpath = factory.newXPath();//用这个工厂创建 XPath 对象
			  
			   NodeList nodes = (NodeList)xpath.evaluate("location/property", doc, XPathConstants.NODESET);
			   String name = "";
			   String value = "";
			   for (int i = 0; i < nodes.getLength(); i++) {
				    Node node = nodes.item(i);  
			        name = (String) xpath.evaluate("name", node, XPathConstants.STRING);
			        value = (String) xpath.evaluate("value", node, XPathConstants.STRING);
			        System.out.println("name="+name+";value="+value);
			   }
			  
			  
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
}
复制代码

进入正题：

步骤1：读取配置文件，生成全局Configuration对象

一、解析配置

不整合spring使用mybatis示例代码：

public static void main(String[] args) {
        String resource = "mybatis-config.xml";
        Reader reader;
        try {
            //将XML配置文件构建为Configuration配置类
            reader = Resources.getResourceAsReader(resource);
            // 通过加载配置文件流构建一个SqlSessionFactory  DefaultSqlSessionFactory
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
            // 数据源 执行器  DefaultSqlSession
            SqlSession session = sqlMapper.openSession();
            try {
                // 执行查询 底层执行jdbc
                User user = (User)session.selectOne("com.tuling.mapper.UserMapper.selectById", 1);

                /*UserMapper mapper = session.getMapper(UserMapper.class);
                System.out.println(mapper.getClass());
                User user = mapper.selectById(1L);*/
                session.commit();
                System.out.println(user.getUserName());
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                session.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
复制代码

\

//获取sqlsessionFactory
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }
复制代码

//解析配置入口
public Configuration parse() {
    //如果已经解析过了，报错
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
//   
//   
//   
//   
//   
//   
//   
//   
//   
//   
//   
//   
//   
//  
//   
//   
//   
//  
    
    //根节点是configuration
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }
复制代码

\

//解析配置文件中每一种配置
  private void parseConfiguration(XNode root) {
    try {
      //分步骤解析
      //issue #117 read properties first
      //1.properties
      propertiesElement(root.evalNode("properties"));
      //2.类型别名
      typeAliasesElement(root.evalNode("typeAliases"));
      //3.插件
      pluginElement(root.evalNode("plugins"));
      //4.对象工厂
      objectFactoryElement(root.evalNode("objectFactory"));
      //5.对象包装工厂
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      //6.设置
      settingsElement(root.evalNode("settings"));
      // read it after objectFactory and objectWrapperFactory issue #631
      //7.环境
      environmentsElement(root.evalNode("environments"));
      //8.databaseIdProvider
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      //9.类型处理器
      typeHandlerElement(root.evalNode("typeHandlers"));
      //10.映射器
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }
复制代码

接下来详细介绍如何解析mapper文件：

//解析mapper所在路径
private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          //10.4自动扫描包下所有映射器
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
复制代码

//扫描mapper所在包路径，获取所有接口包 遍历添加
public void addMappers(String packageName, Class superType) {
    //查找包下所有是superType的类
    ResolverUtil> resolverUtil = new ResolverUtil>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set>> mapperSet = resolverUtil.getClasses();
    for (Class mapperClass : mapperSet) {
      addMapper(mapperClass);
    }
  }
复制代码

//添加一个映射，及寻找xml文件
  public  void addMapper(Class type) {
    //mapper必须是接口！才会添加
    if (type.isInterface()) {
      if (hasMapper(type)) {
        //如果重复添加了，报错
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
          //***这一步就是新建出代理类工厂放入一个map中，便于之后取出调用
        knownMappers.put(type, new MapperProxyFactory(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        //扫描sql注解
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        //寻找xml文件
        parser.parse();
        loadCompleted = true;
      } finally {
        //如果加载过程中出现异常需要再将这个mapper从mybatis中删除,这种方式比较丑陋吧，难道是不得已而为之？
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }
复制代码

//加载与接口同名的mapper xml文件
private void loadXmlResource() {
    // Spring may not know the real resource name so we check a flag
    // to prevent loading again a resource twice
    // this flag is set at XMLMapperBuilder#bindMapperForNamespace
    if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
        // 将mapper接口转为xml路径 比如com.burton.usermapper -> com/burton/usermapper.xml
      String xmlResource = type.getName().replace('.', '/') + ".xml";
      InputStream inputStream = null;
      try {
        inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
      } catch (IOException e) {
        // ignore, resource is not required
      }
      if (inputStream != null) {
        XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource, configuration.getSqlFragments(), type.getName());
        //解析mapper的xml文件
          xmlParser.parse();
      }
    }
  }
复制代码

public void parse() {
    //如果没有加载过再加载，防止重复加载
    if (!configuration.isResourceLoaded(resource)) {
      //配置解析mapper
      configurationElement(parser.evalNode("/mapper"));
      //标记一下，已经加载过了
      configuration.addLoadedResource(resource);
      //绑定映射器到namespace
      bindMapperForNamespace();
    }

    //还有没解析完的东东这里接着解析？  
    parsePendingResultMaps();
    parsePendingChacheRefs();
    parsePendingStatements();
  }
复制代码

\

//解析mapper文件里面内容
private void configurationElement(XNode context) {
    try {
      //1.配置namespace
      String namespace = context.getStringAttribute("namespace");
      if (namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      //2.配置cache-ref
      cacheRefElement(context.evalNode("cache-ref"));
      //3.配置cache 二级缓存 不是很重要 责任链模式 很多种cache一层套一层
      cacheElement(context.evalNode("cache"));
      //4.配置parameterMap(已经废弃,老式风格的参数映射)
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      //5.配置resultMap(高级功能)
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      //6.配置sql(定义可重用的 SQL 代码段)
      sqlElement(context.evalNodes("/mapper/sql"));
      //7.配置select|insert|update|delete TODO
      **buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }

 //构建语句
  private void buildStatementFromContext(List list, String requiredDatabaseId) {
    for (XNode context : list) {
      //构建所有语句,一个mapper下可以有很多select
      //语句比较复杂，核心都在这里面，所以调用XMLStatementBuilder
      final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
          //**核心XMLStatementBuilder.parseStatementNode
        statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
          //如果出现SQL语句不完整，把它记下来，塞到configuration去
        configuration.addIncompleteStatement(statementParser);
      }
    }
  }


    /**
    statementParser.parseStatementNode()方法中有langDriver.createSqlSource方法负责将sql语句解析成一层层的sqlNode封装在sqlSource中
     * 通过class org.apache.ibatis.scripting.xmltags.XMLLanguageDriver来解析我们的
     * sql脚本对象  .  解析SqlNode. 注意， 只是解析成一个个的SqlNode， 并不会完全解析sql,因为这个时候参数都没确定，动态sql无法解析
     */
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);


//最终将mapper文件中某一句增删改查的全部信息（sql语句解析为sqlsource，还有paramtype，resultMap等）构建出MappedStatement，加入configration的map中，key为namespace+id
  public MappedStatement addMappedStatement(
      String id,
      SqlSource sqlSource,
      StatementType statementType,
      SqlCommandType sqlCommandType,
      Integer fetchSize,
      Integer timeout,
      String parameterMap,
      Class parameterType,
      String resultMap,
      Class resultType,
      ResultSetType resultSetType,
      boolean flushCache,
      boolean useCache,
      boolean resultOrdered,
      KeyGenerator keyGenerator,
      String keyProperty,
      String keyColumn,
      String databaseId,
      LanguageDriver lang,
      String resultSets) {
    
    if (unresolvedCacheRef) {
      throw new IncompleteElementException("Cache-ref not yet resolved");
    }
    
    //为id加上namespace前缀
    id = applyCurrentNamespace(id, false);
    //是否是select语句
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

    //又是建造者模式
    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType);
    statementBuilder.resource(resource);
    statementBuilder.fetchSize(fetchSize);
    statementBuilder.statementType(statementType);
    statementBuilder.keyGenerator(keyGenerator);
    statementBuilder.keyProperty(keyProperty);
    statementBuilder.keyColumn(keyColumn);
    statementBuilder.databaseId(databaseId);
    statementBuilder.lang(lang);
    statementBuilder.resultOrdered(resultOrdered);
    statementBuilder.resulSets(resultSets);
    setStatementTimeout(timeout, statementBuilder);

    //1.参数映射
    setStatementParameterMap(parameterMap, parameterType, statementBuilder);
    //2.结果映射
    setStatementResultMap(resultMap, resultType, resultSetType, statementBuilder);
    setStatementCache(isSelect, flushCache, useCache, currentCache, statementBuilder);

    MappedStatement statement = statementBuilder.build();
    //建造好调用configuration.addMappedStatement
    configuration.addMappedStatement(statement);
    return statement;
  }
复制代码

总结：当mybatis配置文件里配置了dao层接口的包名，mybatis会去对应的报下获取所有的接口，遍历，分别再找到同名的mapper.xml文件。解析xml文件，将resultMap，sql，insert，select，delete，update（增删改查都会封装mapperedStatement存到map中 key为namaspace+id，mapperedStatement中包含sqlSource，sqlSource中是sqlNode）都封装进全局configration对象中。

所有配置都解析到configration对象中，configration对象封装在sqlSessionFactory中，通过sqlSessionFactory获取sqlSession，所以sqlsession中也有configration。

**sqlSession—configration-**MapperRegistry-knownMappers（一个map，包含接口class为key， 接口代理工厂MapperProxyFactory

（通过这个工厂拿到代理类（MapperProxyFactory.newInstance），真正执行拦截器以及sql在代理类MapperProxy的invoke方法里，通过sqlSwssion.getMapper就能通过以上步骤拿到代理类）为value，mapper文件解析过了，则存在这个knownmappers中，不允许重复解析mapper文件，是在解析配置文件中mapper所在路径的时候放到这个map中的，key为mapper的class，value为MapperProxyFactory，这个类可以生成动态代理）

\

Configuration类中mappedStatements字段是一个map，保存了解析mapper.xml中的select update insert等，map的value是MappedStatement就是一个select/ update/ insert语句解析好的信息（解析得到sqlNode），key是mapper文件的namespace+select update insert的id

【其他】1、TypeHandler 类型转换器 负责设置sql语句prepareStatement参数Java类型转为数据库类型 以及查到结果将resultSet中数据库结果类型转为java类型（其实就是使用jdbc）。各种转换器注册在TypeHandlerRegister中。

2、#{id} 在后续会解析为sql中的？，最后给prepareStatement设置参数参数时，会把？的值设置为id的值（通过typeHandler）。

\

二、获取mapper代理

一、讲mapper（整合spring我们一般都是这么使用）代理之前先讲下，另一种调用方式通过statmentId执行sql（mapper文件中的一句sql会封装未一个mapperedStatement）

// 执行查询 底层执行jdbc com.tuling.mapper.UserMapper.selectById为statementId
User user = (User)session.selectOne("com.tuling.mapper.UserMapper.selectById", 1);

/*UserMapper mapper = session.getMapper(UserMapper.class);
                System.out.println(mapper.getClass());
                User user = mapper.selectById(1L);*/
session.commit();
System.out.println(user.getUserName());
复制代码

二、执行sql前获取mapper接口的代理

//defaultSqlSession的方法：获取mapper  
public  T getMapper(Class type) {
    //最后会去调用MapperRegistry.getMapper
    return configuration.getMapper(type, this);
  }

 public  T getMapper(Class type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

  //MapperRegistry类的getMapper方法 返回代理类
  public  T getMapper(Class type, SqlSession sqlSession) {
    final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) 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);
    }
  }

//mapperProxyFactory类通过jdk动态代理构建代理类
  public T newInstance(SqlSession sqlSession) {
    final MapperProxy mapperProxy = new MapperProxy(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
//是不是看到了熟悉的动态代理
  protected T newInstance(MapperProxy mapperProxy) {
    //用JDK自带的动态代理生成映射器，参数mapperProxy相当于之前讲的任务调度器，也肯定实现了InvocationHandler jdk调度接口
    //最后的真正sql调用数据库肯定再这个代理类里发起
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

//MapperProxy是真正执行逻辑的地方，MapperProxy的invock方法里会真正去拼装sql，jdbc执行sql
复制代码

总结：获取mapper代理类的流程：

1. 从sqlSession中获取mapper
2. 从configration中获取mapper
3. 从MapperRegistry中获取mapper
4. 从knownMappers中获取mapper的动态代理类工厂
5. 用工厂生成mapper的代理类（代理中传入了sqlSession）

三、Executor执行sql

3、执行sql

//mapper调度器（代理类是jdk生成的字节码文件，最后代理类会调这个调度器，逻辑在调度器里）
public class MapperProxy implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class mapperInterface;
  private final Map methodCache;

  public MapperProxy(SqlSession sqlSession, Class mapperInterface, Map methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //代理以后，所有Mapper的方法调用时，都会调用这个invoke方法
    //并不是任何一个方法都需要执行调用代理对象进行执行，如果这个方法是Object中通用的方法（toString、hashCode等）无需执行
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    //这里优化了，去缓存中找MapperMethod
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    //执行
    return mapperMethod.execute(sqlSession, args);
  }

  //去缓存中找MapperMethod
  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      //找不到才去new
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

}
复制代码

//去缓存中找MapperMethod或者新建mapperMehod
  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      //找不到才去new
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

//构造器新建mapperMethod
 public MapperMethod(Class mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, method);
  }

//新建MethodSignature 方法签名相关信息
  public MethodSignature(Configuration configuration, Method method) {
      this.returnType = method.getReturnType();
      this.returnsVoid = void.class.equals(this.returnType);
      this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
      this.mapKey = getMapKey(method);
      this.returnsMap = (this.mapKey != null);
      this.hasNamedParameters = hasNamedParams(method);
      //以下重复循环2遍调用getUniqueParamIndex，是不是降低效率了
      //记下RowBounds是第几个参数
      this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
      //记下ResultHandler是第几个参数
      this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
      **this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters));
    }

//获取接口入参
//得到所有参数
    private SortedMap getParams(Method method, boolean hasNamedParameters) {
      //用一个TreeMap,这样就保证还是按参数的先后顺序
      final SortedMap params = new TreeMap();
      final Class[] argTypes = method.getParameterTypes();
      for (int i = 0; i < argTypes.length; i++) {
        //是否不是RowBounds/ResultHandler类型的参数
        if (!RowBounds.class.isAssignableFrom(argTypes[i]) && !ResultHandler.class.isAssignableFrom(argTypes[i])) {
          //参数名字默认为0,1,2，这就是为什么xml里面可以用#{1}这样的写法来表示参数了
          String paramName = String.valueOf(params.size());
          if (hasNamedParameters) {
            //还可以用注解@Param来重命名参数
            paramName = getParamNameFromAnnotation(method, i, paramName);
          }
          params.put(i, paramName);
        }
      }
      return params;
    }

//解析入参@param参数
 private String getParamNameFromAnnotation(Method method, int i, String paramName) {
      final Object[] paramAnnos = method.getParameterAnnotations()[i];
      for (Object paramAnno : paramAnnos) {
        if (paramAnno instanceof Param) {
          paramName = ((Param) paramAnno).value();
        }
      }
      return paramName;
    }

//将方法入参转化为xml文件中用#{}可以解析出来的参数
public Object convertArgsToSqlCommandParam(Object[] args) {
      final int paramCount = params.size();
      if (args == null || paramCount == 0) {
        //如果没参数
        return null;
      } else if (!hasNamedParameters && paramCount == 1) {
        //如果只有一个参数
        return args[params.keySet().iterator().next().intValue()];
      } else {
        //否则，返回一个ParamMap，修改参数名，参数名就是其位置
        final Map param = new ParamMap