话题导入：首先我一开始接触mybatis的时候，还是在做SSM课程设计，我会在项目的spring配置文件中会有如下配置：
<!-- ===================整合Mybatis=================== -->
<!-- 配置数据库环境 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!-- mysql url -->
<property name="url"
value="jdbc:mysql://localhost:3306/mybaits"></property>
<!-- 驱动 -->
<property name="driverClassName"
value="com.mysql.jdbc.Driver"></property>
<!-- 用户名密码 -->
<property name="username" value="root"></property>
<property name="password" value=""></property>
</bean>
<!-- 创建数据库映射器，扫描包下所有接口，并为其创建动态代理类 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.project.dao" />
</bean>
<!-- 配置 Mybatis 的 SqlSessionFactory -->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 指定数据库环境 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 指定Mybatis配置文件 -->
<property name="configLocation"
value="classpath:config/mybatisConfig.xml"></property>
<!-- 指定Mybatis映射文件，*.xml 会匹配所有xml文件 -->
<!-- <property name="mapperLocations" value="classpath:com/project/mapper/*.xml"></property> -->
</bean>
<!-- 创建事务管理器：针对jdbc或Mybatis的事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 指定环境， name的dataSource是固定写法，ref是前面创建的环境id -->
<property name="dataSource" ref="dataSource"></property>
</bean>
复制代码
\
准备知识：
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
<location>
<property>
<name>city</name>
<value>beijing</value>
</property>
<property>
<name>district</name>
<value>chaoyang</value>
</property>
</location>
复制代码
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;
// <?xml version="1.0" encoding="UTF-8" ?>
// <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
// "http://mybatis.org/dtd/mybatis-3-config.dtd">
// <configuration>
// <environments default="development">
// <environment id="development">
// <transactionManager type="JDBC"/>
// <dataSource type="POOLED">
// <property name="driver" value="${driver}"/>
// <property name="url" value="${url}"/>
// <property name="username" value="${username}"/>
// <property name="password" value="${password}"/>
// </dataSource>
// </environment>
// </environments>
// <mappers>
// <mapper resource="org/mybatis/example/BlogMapper.xml"/>
// </mappers>
// </configuration>
//根节点是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<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
for (Class<?> mapperClass : mapperSet) {
addMapper(mapperClass);
}
}
复制代码
//添加一个映射，及寻找xml文件
public <T> void addMapper(Class<T> 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<T>(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<XNode> 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> T getMapper(Class<T> type) {
//最后会去调用MapperRegistry.getMapper
return configuration.<T>getMapper(type, this);
}
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
//MapperRegistry类的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);
}
}
//mapperProxyFactory类通过jdk动态代理构建代理类
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
//是不是看到了熟悉的动态代理
protected T newInstance(MapperProxy<T> mapperProxy) {
//用JDK自带的动态代理生成映射器，参数mapperProxy相当于之前讲的任务调度器，也肯定实现了InvocationHandler jdk调度接口
//最后的真正sql调用数据库肯定再这个代理类里发起
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
//MapperProxy是真正执行逻辑的地方，MapperProxy的invock方法里会真正去拼装sql，jdbc执行sql
复制代码
总结：获取mapper代理类的流程：
- 从sqlSession中获取mapper
- 从configration中获取mapper
- 从MapperRegistry中获取mapper
- 从knownMappers中获取mapper的动态代理类工厂
- 用工厂生成mapper的代理类（代理中传入了sqlSession）
三、Executor执行sql
3、执行sql
//mapper调度器（代理类是jdk生成的字节码文件，最后代理类会调这个调度器，逻辑在调度器里）
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 {
//代理以后，所有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<Integer, String> getParams(Method method, boolean hasNamedParameters) {
//用一个TreeMap,这样就保证还是按参数的先后顺序
final SortedMap<Integer, String> params = new TreeMap<Integer, String>();
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<String, Object> param = new ParamMap<Object>();
int i = 0;
for (Map.Entry<Integer, String> entry : params.entrySet()) {
//1.先加一个#{0},#{1},#{2}...参数
param.put(entry.getValue(), args[entry.getKey().intValue()]);
// issue #71, add param names as param1, param2...but ensure backward compatibility
final String genericParamName = "param" + String.valueOf(i + 1);
if (!param.containsKey(genericParamName)) {
//2.再加一个#{param1},#{param2}...参数
//你可以传递多个参数给一个映射器方法。如果你这样做了,
//默认情况下它们将会以它们在参数列表中的位置来命名,比如:#{param1},#{param2}等。
//如果你想改变参数的名称(只在多参数情况下) ,那么你可以在参数上使用@Param(“paramName”)注解。
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
//通过上述代码，我们在xml文件中取出入参可以用#{0},#{param0},#{paramName}三种方式
复制代码
//执行数据库操作
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
//可以看到执行时就是4种情况，insert|update|delete|select，分别调用SqlSession的4大类方法
if (SqlCommandType.INSERT == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
} else if (SqlCommandType.UPDATE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
} else if (SqlCommandType.DELETE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
} else if (SqlCommandType.SELECT == command.getType()) {
if (method.returnsVoid() && method.hasResultHandler()) {
//如果有结果处理器
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
//如果结果有多条记录
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
//如果结果是map
result = executeForMap(sqlSession, args);
} else {
//否则就是一条记录
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
} else {
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}
复制代码
我们就选一个最简单的select返回一条跟进源码看一下
//核心selectOne
@Override
public <T> T selectOne(String statement, Object parameter) {
// Popular vote was to return null on 0 results and throw exception on too many.
//转而去调用selectList,很简单的，如果得到0条则返回null，得到1条则返回1条，得到多条报TooManyResultsException错
// 特别需要主要的是当没有查询到结果的时候就会返回null。因此一般建议在mapper中编写resultType的时候使用包装类型
//而不是基本类型，比如推荐使用Integer而不是int。这样就可以避免NPE
List<T> list = this.<T>selectList(statement, parameter);
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 1) {
throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
} else {
return null;
}
}
看到TooManyResultsException这个异常是不是有点熟悉，可能我们代码会出现这个异常。
返回类型最好用包装类，避免查不到结果返回null，导致控制住
复制代码
//从configration中根据namespace+方法id去粗mapperedStatment
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
//根据statement id找到对应的MappedStatement
MappedStatement ms = configuration.getMappedStatement(statement);
//转而用执行器来查询结果,注意这里传入的ResultHandler是null
return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
获取解析过的sql对象
//SqlSession.selectList会调用此方法
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
//得到绑定sql,该boundsql中的sql为解析后的sql,动态sql中若参数是${},则会直接解析成参数，若参数是#{}，则会解析成？，解析成？的会在下文stmt = prepareStatement方法中替换为参数
BoundSql boundSql = ms.getBoundSql(parameter);
//创建缓存Key
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
//查询
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
//创建statmentHandler以及prepareStatment（jdbc）
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
//新建一个StatementHandler
//这里看到ResultHandler传入了
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
//准备语句
stmt = prepareStatement(handler, ms.getStatementLog());
//StatementHandler.query
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
//给动态sql中#{}的在boundSql的？替换为真实参数
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Connection connection = this.getConnection(statementLog);
Statement stmt = handler.prepare(connection, this.transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
//jdbc执行
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
String sql = boundSql.getSql();
statement.execute(sql);
//先执行Statement.execute，然后交给ResultSetHandler.handleResultSets
return resultSetHandler.<E>handleResultSets(statement);
}
复制代码
小结：调接口查询时，首先执行了调度器中方法，创建mapperedMethod，并且创建方法签名，比如会把方法入参获取放入一个map中，key时0，1，2，3.。。。param0，param1.。。paramName。根据方法的包名及方法名从configration中获取先前解析好的mapperdStatement，里面包含解析过的sql语句。调jdbc进行执行查数据库。
\
mybatis中重要的几个类：
- Configration 全局配置类
- MapperedStatement 封装一个sql（select/insert/update/delete）信息。MapperMethod封装了一个sql，也是根据当前该sql的类型（select/insert/update/delete）发起sqlSession执行总入口
- BoundSql 直接存储sql的类，将#{}转换为？后的sql
- Executor sql执行类 所有sql语句执行都下这个类方法里
- MapperRegistry，包含一个Map<Class, MapperProxyFactory> knownMappers的map属性，key为一个mapper接口类的class，value为这个mapper代理类的工程
\
四、整合spring的原理
当我们使用@Autowired注解的时候有没有想过，为啥能这么简单得 我们什么都没做就能拿到这了一个类，然后还能执行我们写在mapper.xml中的sql？神奇啊
1、首先看过获取mapper代理流程的应该清楚 为啥能从一个mapper的java接口就能执行我们写在mapper.xml中的sql？ 动态代理！！
2、为啥这个动态代理类能被我们用@autowired注入进来？肯定是这个 代理类在spring容器中！！
那么最终的问题就变成这个代理类是怎么到spring容器中的？下面进行一步步解析：
mybatis整合spring的一个javaconfig配置类：
主要有两个重点：1、@MapperScan 2、SqlSessionFactoryBean.getObject
@Configuration
// 重点看这里 重点看这里 重点看这里 重点看这里 MapperScan MapperScan 这里就是spring整合的重点
@MapperScan(basePackages = "com.wwdz.mall.mapper.single", sqlSessionTemplateRef = "singleSqlTemplate")
public class DataSourceSingleConfig {
@Bean(name = "rdsPolar")
@ConfigurationProperties(prefix = "spring.datasource.rds-polar")
public DataSource dataSourceRdsPolar() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setName("rdsPolar");
DatasourceUtil.setDruidProperty(dataSource);
return dataSource;
}
/** 重点看这里 重点看这里 重点看这里
构建SqlSessionFactory的过程，和单独使用mybatis一样，就是解析mybatis配置文件，把所有配置配置放到configuration中，然后configuration
最终放到sqlSession中（当然包括解析mapper.xml文件）
**/
@Bean("singleSqlFactory")
public SqlSessionFactory sqlSessionFactory() throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSourceRdsPolar());
sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mappers/single/*.xml"));
// 这句代码就是开始解析 下面会介绍
return sqlSessionFactoryBean.getObject();
}
@Bean("singleSqlTemplate")
public SqlSessionTemplate sqlSessionTemplate(@Qualifier("singleSqlFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
@Bean(name = "singleTransactionManager")
public PlatformTransactionManager singleTransactionManager(@Qualifier("rdsPolar") DataSource dataSource) throws Exception {
return new DataSourceTransactionManager(dataSource);
}
@Bean(name = "singleTransactionTemplate")
public TransactionTemplate transactionTemplate(@Qualifier("singleTransactionManager") PlatformTransactionManager mybatisTransactionManager) {
TransactionTemplate transactionTemplate = new TransactionTemplate();
transactionTemplate.setIsolationLevel(ISOLATION_DEFAULT);
transactionTemplate.setTimeout(3);
transactionTemplate.setTransactionManager(mybatisTransactionManager);
return transactionTemplate;
}
}
复制代码
1、SqlSessionFactoryBean.getObject->SqlSessionFactoryBean.afterPropertiesSet->SqlSessionFactoryBean.buildSqlSessionFactory 这一串流程会解析SqlSessionFactoryBean中配置的配置信息最终解析出来都放到configuration中，然后把configuration放到sqlSessionFactory中，返回sqlSessionFactory；
2、重点关注@MapperScan
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({MapperScannerRegistrar.class}) // 重点看这里啊啊 MapperScannerRegistrar这个类
@Repeatable(MapperScans.class)
public @interface MapperScan {
String[] value() default {};
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
Class<? extends Annotation> annotationClass() default Annotation.class;
Class<?> markerInterface() default Class.class;
String sqlSessionTemplateRef() default "";
String sqlSessionFactoryRef() default "";
Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;
}
/**
这个类继承了spring的ImportBeanDefinitionRegistrar，需要实现registerBeanDefinitions方法
**/
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
private ResourceLoader resourceLoader;
public MapperScannerRegistrar() {
}
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
// 这个方法是继承自spring中的ImportBeanDefinitionRegistrar
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 获取@MapperScan注解上的属性
AnnotationAttributes mapperScanAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
if (mapperScanAttrs != null) {
this.registerBeanDefinitions(mapperScanAttrs, registry);
}
}
void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry) {
// 重点 看这里
// 这个ClassPathMapperScanner类也很关键 是用来扫码指定路径的mapper接口变为BeanDefinition的
// 这个类继承自spring的ClassPathBeanDefinitionScanner，spring的这个类的作用是在spring容器启动的过程中，
// 去读取指定路径下的类变成BeanDefinition，但是只会读普通类，接口和抽象类不会读，所以mybatis-spring的需要继承这个类之后对
// 这个类中的isCandidateComponent方法重写，变为只读取接口，因为我们的mapper.java都是接口。其他方法还是用父类的
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
Optional var10000 = Optional.ofNullable(this.resourceLoader);
Objects.requireNonNull(scanner);
var10000.ifPresent(scanner::setResourceLoader);
Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
if (!Annotation.class.equals(annotationClass)) {
scanner.setAnnotationClass(annotationClass);
}
Class<?> markerInterface = annoAttrs.getClass("markerInterface");
if (!Class.class.equals(markerInterface)) {
scanner.setMarkerInterface(markerInterface);
}
Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
if (!BeanNameGenerator.class.equals(generatorClass)) {
scanner.setBeanNameGenerator((BeanNameGenerator)BeanUtils.instantiateClass(generatorClass));
}
Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
scanner.setMapperFactoryBeanClass(mapperFactoryBeanClass);
}
scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
List<String> basePackages = new ArrayList();
basePackages.addAll((Collection)Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));
basePackages.addAll((Collection)Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText).collect(Collectors.toList()));
basePackages.addAll((Collection)Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName).collect(Collectors.toList()));
scanner.registerFilters();
// 开始扫描指定包路径下的mapper接口为beanDifinition
scanner.doScan(StringUtils.toStringArray(basePackages));
}
}
复制代码
ClassPathMapperScanner中重要的几个方法：非常重要
/**
* 方法实现说明:真正调用扫描我们@MapperScan指定的路径下的mapper包
*
* @author:xsls
* @param basePackages
* :路径长度
* @return:
* @exception:
* @date:2019/8/21 17:27
* 这个doscan方法其实是重写了spring中父类ClassPathBeanDefinitionScanner的doscan
*/
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
/**
* 调用父类ClassPathBeanDefinitionScanner 来进行扫描
* 然后这个方法中会调用isCandidateComponent这个方法，这个方法又是被当前ClassPathMapperScanner这个类重写过了
* 只会扫描mapper接口，所以最终的结果是会拿到所有mapper接口的beanDefinition
* 父类spring中的ClassPathBeanDefinitionScanner的isCandidateComponent只会扫描普通的类成为beanDifinition到ioc容器中，抽象类和接口都不会
*/
Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
/**
* 若扫描后 我们mapper包下有接口类,那么扫描bean定义就不会为空
*/
if (beanDefinitions.isEmpty()) {
LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
+ "' package. Please check your configuration.");
} else {
/**
* 正是在这里mybaits做了一个很牛逼的功能，将spring的 的bean定义玩到极致(做了偷天换日的操作) 现在我们知道t通过父类扫描出来的mapper是接口类型的
* 比如我们com.tuling.mapper.UserMapper 他是一个接口 我们有基础的同学可能会知道我们的bean定义最终会被实例化成
* 对象，但是我们接口是不能实例化的,所以在processBeanDefinitions 来进行偷天换日
*/
processBeanDefinitions(beanDefinitions);
}
return beanDefinitions;
}
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;
/**
* 循环我们所有扫描出mapper的bean定义出来
*/
for (BeanDefinitionHolder holder : beanDefinitions) {
// 获取我们的bean定义
definition = (GenericBeanDefinition) holder.getBeanDefinition();
// 获取我们的bean定义的名称 这里是mapper接口的名字
String beanClassName = definition.getBeanClassName();
LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
+ "' mapperInterface");
/**
* 进行真的偷天换日操作,也就是这二行代码是最最最最最重要的, 关乎我们 spring整合mybaits的整合 definition.setBeanClass(this.mapperFactoryBeanClass);
*/
// 设置ConstructorArgumentValues 会通过构造器初始化对象 MapperFactoryBean有一个构造方法 入参为真正mapper接口的beanClassName
definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
// 设置成factoryBean this.mapperFactoryBeanClass = MapperFactoryBean.class 把mapper接口的beanDifiniton的class类型设置为MapperFactoryBean，这就是偷天换日
definition.setBeanClass(this.mapperFactoryBeanClass);
// 总结下上面两步做的：拿到每一个mapper接口的beanDifiniton，将beanDifiniton中的beanClass设置为MapperFactoryBean.class，然后通过MapperFactoryBean的构造方法设置真正mapper接口的beanclassname
// MapperFactoryBean是FactoryBean的子类，在spring中，通过beanDifinition创建bean实例的时候会判断这个beanDifinition的beanClass是否是FactoryBean，是的话，则放到spring容器中的对象是FactoryBean的getObject方法返回的对象
// MapperFactoryBean对象的getObject方法返回的就是mapper接口的jdk代理对象
definition.getPropertyValues().add("addToConfig", this.addToConfig);
/**
* 为我们的Mapper对象绑定我们的sqlSessionFactory引用 说白了就是我们的UserMapper(实际上是就是为我们的MapperFactoryBean添加一个sqlSessionFactory的属性)
* 然后SpringIoc在实例话我们的MapperFactoryBean的时候会经历populate()方法为我么你的UserMapper(MapperFactoryBean)
* 的sqlSessionFactory赋值(调用set方法)
*/
boolean explicitFactoryUsed = false;
if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
definition.getPropertyValues().add("sqlSessionFactory",
new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
explicitFactoryUsed = true;
} else if (this.sqlSessionFactory != null) {
definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
explicitFactoryUsed = true;
}
/**
* 为我们的Mapper对象绑定我们的sqlSessionTemplate属性对象
* 说白了就是我们的UserMapper(实际上是就是为我们的MapperFactoryBean添加一个sqlSessionTemplate的属性)
* 然后SpringIoc在实例话我们的MapperFactoryBean的时候会经历populate()方法为我么你的UserMapper(MapperFactoryBean)
* 的sqlSessionTemplate赋值(调用set方法)
*/
if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
if (explicitFactoryUsed) {
LOGGER.warn(
() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
}
definition.getPropertyValues().add("sqlSessionTemplate",
new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
explicitFactoryUsed = true;
} else if (this.sqlSessionTemplate != null) {
if (explicitFactoryUsed) {
LOGGER.warn(
() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
}
// 将sqlSessionTemplate通过AUTOWIRE_BY_TYPE自动装配
definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
explicitFactoryUsed = true;
}
/**
* 设置UserMapper<MapperFactoryBean>定义的注入模型是通过 包扫描进来的，所有我们的默认注入模型就是
* AutowireCapableBeanFactory.AUTOWIRE_NO=0注入模型为0的时候,在这种情况下,若我们的MapperFactoryBean
* 的字段属性是永远自动注入不了值的因为字段上是没有 @AutoWired注解,所以我们需要把UserMapper<MapperFactoryBean> 的bean定义的注入模型给改成我们的 AUTOWIRE_BY_TYPE
* = 1,指定这个类型就是根据类型装配的话， 第一:我们的字段上不需要写@AutoWired注解，为啥? springioc会把当前UserMapper<MapperFactoryBean>中的setXXX(入参)
* 都会去解析一次入参,入参的值可定会从ioc容器中获取，然后调用setXXX方法给赋值好. 或 AUTOWIRE_By_Type=1
* 指定这个类型就是根据类型装配的话，第一:我们的字段上不需要写@AutoWired注解，为啥? springioc会把当前UserMapper<MapperFactoryBean>中的setXXX(入参)都会去解析一次入参,
* 入参的值可定会从ioc容器中获取，然后调用setXXX方法给赋值好.
*
* ??????????????为啥在这里mybaits却要指定AUTOWIRE_BY_TYPE了？ 假设我们指定的是by_name的话， 那么他会通过setXXX(入参)的引用名去ioc容器中获取值，
* 假设我们自己配置的bean的名称不是相同的那么就会抛出异常
*
* public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) { if (this.sqlSessionTemplate == null ||
* sqlSessionFactory != this.sqlSessionTemplate.getSqlSessionFactory()) { this.sqlSessionTemplate
* =createSqlSessionTemplate(sqlSessionFactory); } } 所以在IOC实例化我们的UserMapper<MapperFactoryBean>的时候，会调用父类
* SqlSessionDaoSupport的setSqlSessionFactory(SqlSessionFactory sqlSessionFactory)
* 方法,而我们的sqlSessionFactory需要去容器中获取（也就是我们自己配置的SqlSessionFactoryBean）
*
*/
if (!explicitFactoryUsed) {
LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
}
/**
* 设置bean定义的加载模型(是否为懒加载)
*/
definition.setLazyInit(lazyInitialization);
}
}
/**
* {@inheritDoc}
* 这里很关键 重写了父类的方法 spring 父类中的这个方法 只会扫描类 不会要接口和抽象类 这里重写为只要接口（mapper接口）
*/
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
}
复制代码
// spring中的FactoryBean类，作用就是spring容器启动的时候，会把这个类getObject方法返回的对象注册到ioc容器中
public interface FactoryBean<T> {
@Nullable
T getObject() throws Exception;
@Nullable
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
}
复制代码
/**
* @vlog: 高于生活，源于生活
* @desc: 类的描述:这个了就是我们UserMapper的代理类,他也会经过 springIoc容器bean的生命周期,在bean的生命周期方法populate()方法会给属性进行赋值
* 由于在ClassMapperScan类中已经把当前的bean定义的注入模型给修改了by_type 所以，凡是写了setXXX的方法的,spring ioc在populate() 去进行调用
* @author: xsls
* @createDate: 2019/8/22 19:20
* @version: 1.0
* MapperFactoryBean 继承了spring的FactoryBean 重点重点重点
*/
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
private Class<T> mapperInterface;
private boolean addToConfig = true;
public MapperFactoryBean() {
// intentionally empty
}
/**
* 在这里又是一个牛逼的设计闪光点:我们知道在ClassPathMapperScanner 扫描我们的UserMapper<MapperFactoryBean>的时候做了一个牛逼的事情,
* 他扫描我们的UserMapper的时候的bean定义是接口类型的，我们知道接口类型是不能够被实例化的 所以在ClassPathMapperScanner扫描之后马上进行来处理UserMapper的bean定义
* definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
* definition.setBeanClass(this.mapperFactoryBeanClass); 把UserMapper的bean定义给改成我们的MapperFactoryBean,
* 最终我们实例化UserMapper就是我们的MapperFactoryBean类型,
* definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
* 就是来指定我们的实例化MapperFactoryBean的构造函数的参数。这么做的目的就是 因为MapperFactoryBean 是我们的Factorybean对象, 最终返回的是getObject()方法放回的对象
* 而getObject()对象返回的是一个jdk代理对象，我们知道jdk代理对象需要代理接口， 所以这里就是为了保存我们传入进来的接口类型
*
* @param mapperInterface
*/
public MapperFactoryBean(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
/**
* 方法实现说明:在UserMapper<MapperFactoryBean> 父类DaoSupport 的bean的生命周期回调
* InitializingBean.afterPropertiesSet()方法的时候,会进行checkDaoConfig();检查
*
* @author:xsls
* @return:
* @exception:
* @date:2019/8/22 20:07
*/
@Override
protected void checkDaoConfig() {
/**
* 调用父类的SqlSessionDaoSupport的方法来检查我们的SqlSessionFactory 或者sqlSessionTemplate是否为空
*/
super.checkDaoConfig();
/**
* 断言我们的mapperInterface(我们mapper接口class类型是否为空)
*/
notNull(this.mapperInterface, "Property 'mapperInterface' is required");
/**
* 在这里进行了二个操作,第一步:getSqlSession() 是调用父类的获取SqlSession类型（接口）实现类 SqlSessionTemplate 第二步:getConfiuration
* 是调用sqlSessionTemplate的sqlSessionFactory对象获取他的Configuration属性
*/
Configuration configuration = getSqlSession().getConfiguration();
/**
* 判断我们的mapperRegistry 的knownMappers Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
*/
if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
try {
/**
* 把我们的接口类型保存到sqlSessionFactory的属性Configuration对象 的MapperRegistry属性中
*/
configuration.addMapper(this.mapperInterface);
} catch (Exception e) {
logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
throw new IllegalArgumentException(e);
} finally {
ErrorContext.instance().reset();
}
}
}
/**
* 请看这里 最重要的就是这里这一步骤 真实注入到ioc容器的是getSqlSession().getMapper(this.mapperInterface)返回的代理类（这是mybatis原生的代码逻辑了）
* 方法实现说明:由于是我们factoryBean,那么我们service中注入我们的UserMapper的时候 就会调用我们的getObject()
*
* @author:xsls
* @return:
* @exception:
* @date:2019/8/22 20:35
*/
@Override
public T getObject() throws Exception {
/**
* 第一步:就是获取我么女的SqlSessionTemplate 第二步:获取我们的SqlSessionTemplate.getMapper(mapperInterface)方法
*/
return getSqlSession().getMapper(this.mapperInterface);
}
/**
* {@inheritDoc}
*/
@Override
public Class<T> getObjectType() {
return this.mapperInterface;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isSingleton() {
return true;
}
// ------------- mutators --------------
/**
* Sets the mapper interface of the MyBatis mapper
*
* @param mapperInterface
* class of the interface
*/
public void setMapperInterface(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
/**
* Return the mapper interface of the MyBatis mapper
*
* @return class of the interface
*/
public Class<T> getMapperInterface() {
return mapperInterface;
}
/**
* If addToConfig is false the mapper will not be added to MyBatis. This means it must have been included in
* mybatis-config.xml.
* <p>
* If it is true, the mapper will be added to MyBatis in the case it is not already registered.
* <p>
* By default addToConfig is true.
*
* @param addToConfig
* a flag that whether add mapper to MyBatis or not
*/
public void setAddToConfig(boolean addToConfig) {
this.addToConfig = addToConfig;
}
/**
* Return the flag for addition into MyBatis config.
*
* @return true if the mapper will be added to MyBatis in the case it is not already registered.
*/
public boolean isAddToConfig() {
return addToConfig;
}
}
复制代码
画个spring整合mybatis的流程图：
整合spring总结：
1、@mapperScan注解引入了MapperScannerRegistrar，这是ImportBeanDefinitionRegistrar的子类，在spring启动中会执行ImportBeanDefinitionRegistrar的registerBeanDefinitions方法往容器中注册beanDefinition。
2、ClassPathMapperScanner类继承自spring的ClassPathBeanDefinitionScanner，通过该类的doscan方法把mapper接口都扫描并得到对应的beanDefiniton。
3、将beanDifiniton中的beanClass设置为MapperFactoryBean.class（spring中FactoryBean的子类），然后通过MapperFactoryBean的构造方法设置真正mapper接口的beanclassname，MapperFactoryBean的getObject方法放回的是sqlSesiion.getMapper返回真正的mapper接口的代理对象。
五、重要类
- MapperRegistry：有一个属性knownMappers本质上是一个Map，其中的key是Mapper接口的全限定名，value的MapperProxyFactory；
- MapperProxyFactory：这个类是MapperRegistry中存的value值，在通过 sqlSession获取Mapper时，其实先获取到的是这个工厂，然后通过这个工厂创建 Mapper的动态代理类；
- MapperProxy：实现了InvocationHandler接口，Mapper的动态代理接口方法的调 用都会到达这个类的invoke方法；
- MapperMethod：判断你当前执行的方式是增删改查哪一种，并通过SqlSession执 行相应的操作；
- SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能，Executor会创建好放在这个类里；
- Executor：MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护，一级缓存在这个类里，所以看出一级缓存是sqlSession级别的，每个sqlSesiion都有对应的一级缓存；
- StatementHandler:封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合；
- ParameterHandler:负责对用户传递的参数转换成JDBC Statement 所需要的参数；
- ResultSetHandler:负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
- TypeHandler:负责java数据类型和jdbc数据类型之间的映射和转换；
- MappedStatement:MappedStatement维护了一条<select|update|delete|insert>节点的封装；
- SqlSource:负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回；
- BoundSql:表示动态生成的SQL语句以及相应的参数信息；
- Configuration:MyBatis所有的配置信息都维持在Configuration对象之中。
调试主要关注点
MapperProxy.invoke方法：MyBatis的所有Mapper对象都是通过动态代理生成
的，任何方法的调用都会调到invoke方法，这个方法的主要功能就是创建
MapperMethod对象，并放进缓存。所以调试时我们可以在这个位置打个断点，看下是
否成功拿到了MapperMethod对象，并执行了execute方法。
MapperMethod.execute方法：这个方法会判断你当前执行的方式是增删改查哪一
种，并通过SqlSession执行相应的操作。Debug时也建议在此打个断点看下。
DefaultSqlSession.selectList方法：这个方法获取了获取了MappedStatement对
象，并最终调用了Executor的query方法；
总流程图
1121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
