MyBatis-Plus 是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
那么 MyBatis-Plus 是怎么加强的呢？其实就是封装好了一些 crud 方法，开发人员不需要再写 SQL 了，间接调用方法就可以获取到封装好的 SQL 语句。
特性：
支持的数据库：
下面我们先从一个简单的 demo 入手，来感受一下 MyBatis-plus 的便捷性。
MP封装的 BaseMapper 接口
public interface BaseMapper extends Mapper {
/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper wrapper);
/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper updateWrapper);
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);
} 实体类对象
/**
* 实体类
*
* @author Chill
*/
@Data
@TableName("user")
@EqualsAndHashCode(callSuper = true)
public class User extends TenantEntity {
private static final long serialVersiOnUID= 1L;
/**
* 用户编号
*/
private String code;
/**
* 账号
*/
private String account;
/**
* 密码
*/
private String password;
/**
* 昵称
*/
private String name;
}UserMapper 继承 BaseMapper 接口
/**
* Mapper 接口
*
* @author Chill
*/
public interface UserMapper extends BaseMapper {
} @Override
public User getById(String id){
User user = userMapper.selectById(id);
return null;
}最终查询的 SQL 语句如下图：
从打印的日志我们可以知道，MyBatis-Plus 最终为我们自动生成了 SQL 语句。根据上述操作分析：UserMapper 继承了 BaseMapper，拥有了 selectById 的方法，但是 MyBatis-Plus 是基于 mybatis 的增强版，关键在于最终仍然需要提供具体的SQL语句，来进行数据库操作。
下面我们 DEBUG 跟踪 MyBatis-Plus 是如何生成业务 sql 以及自动注入的，如下图所示：
发现 SQL 语句在 MappedStatement 对象中，而 sqlSource 存的就是相关的 SQL 语句，基于上面的分析，我们想要知道 SQL 语句是什么时候获取到的，就是要找到 mappedStatement 被添加的位置。追踪到 AbstractMethod 的抽象方法中。
Mybatis-Plus 在启动后会将 BaseMapper 中的一系列的方法注册到 meppedStatements 中，那么究竟是如何注入的呢？下面我们一起来分析下。
在 Mybatis-Plus 中，ISqlInjector 负责 SQL 的注入工作，它是一个接口，AbstractSqlInjector 是它的实现类，SqlInjector SQL 自动注入器接口的相关 UML 图如下：
找到了下面我们所讲到的都基于这几个类实现，接着上一个问题，追踪到 AbstractMethod 的抽象方法中，
下面我们继续 DEBUG 跟踪代码是怎么注入的。
首先跳进来 AbstractSqlInjector 抽象类执行 inspectInject 方法
@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class mapperClass) {
Class modelClass = extractModelClass(mapperClass);
if (modelClass != null) {
String className = mapperClass.toString();
Set mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
if (!mapperRegistryCache.contains(className)) {
//获取 CRUD 实现类列表
List methodList = this.getMethodList(mapperClass);
if (CollectionUtils.isNotEmpty(methodList)) {
TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
// 循环注入自定义方法，这里开始注入 sql
methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
} else {
logger.debug(mapperClass.toString() + ", No effective injection method was found.");
}
mapperRegistryCache.add(className);
}
}
} 在这里我们找到 inject 方法，跳进去
在跳进去 injectMappedStatement 方法，选择你执行的 CRUD 操作，我这里以 slectById 为例
从这里我们找到了 addMappedStatement() 方法，可以看到，生成了 SqlSource 对象，再将 SQL 通过 addSelectMappedStatement 方法添加到 meppedStatements 中。
那么实现类是怎么获取到的呢？
在 AbstractSqlInjector 抽象类 inspectInject 方法从 this.getMethodList 方法获取，如下图：
这里的 getMethodList 方法获取 CRUD 实现类列表
/**
* SQL 默认注入器
*
* @author hubin
* @since 2018-04-10
*/
public class DefaultSqlInjector extends AbstractSqlInjector {
@Override
public List getMethodList(Class mapperClass) {
return Stream.of(
new Insert(),
new Delete(),
new DeleteByMap(),
new DeleteById(),
new DeleteBatchByIds(),
new Update(),
new UpdateById(),
new SelectById(),
new SelectBatchByIds(),
new SelectByMap(),
new SelectOne(),
new SelectCount(),
new SelectMaps(),
new SelectMapsPage(),
new SelectObjs(),
new SelectList(),
new SelectPage()
).collect(toList());
}
} 从上面的源码可知，项目启动时，首先由默认注入器生成基础 CRUD 实现类对象，其次遍历实现类列表，依次注入各自的模板 SQL，最后将其添加至 mappedstatement。
那么 SQL 语句是怎么生成的？此时 SqlSource 通过解析 SQL 模板、以及传入的表信息和主键信息构建出了 SQL 语句，如下所示：
@Override
public MappedStatement injectMappedStatement(Class mapperClass, Class modelClass, TableInfo tableInfo) {
/** 定义 mybatis xml method id, 对应 **/
SqlMethod sqlMethod = SqlMethod.SELECT_BY_ID;
/** 构造 id 对应的具体 xml 片段 **/
SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
sqlSelectColumns(tableInfo, false),
tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
tableInfo.getLogicDeleteSql(true, true)), Object.class);
/** 将 xml method 方法添加到 mybatis 的 MappedStatement 中 **/
return this.addSelectMappedStatementForTable(mapperClass, getMethod(sqlMethod), sqlSource, tableInfo);
} 那么数据库表信息是如何获取的？主要根据AbstractSqlInjector抽象类的 inspectInject 方法中的initTableInfo方法获取，如下图：
/**
*
* 实体类反射获取表信息【初始化】
*
*
* @param clazz 反射实体类
* @return 数据库表反射信息
*/
public synchronized static TableInfo initTableInfo(MapperBuilderAssistant builderAssistant, Class clazz) {
TableInfo tableInfo = TABLE_INFO_CACHE.get(clazz);
if (tableInfo != null) {
if (builderAssistant != null) {
tableInfo.setConfiguration(builderAssistant.getConfiguration());
}
return tableInfo;
}
/* 没有获取到缓存信息,则初始化 */
tableInfo = new TableInfo(clazz);
GlobalConfig globalConfig;
if (null != builderAssistant) {
tableInfo.setCurrentNamespace(builderAssistant.getCurrentNamespace());
tableInfo.setConfiguration(builderAssistant.getConfiguration());
globalCOnfig= GlobalConfigUtils.getGlobalConfig(builderAssistant.getConfiguration());
} else {
// 兼容测试场景
globalCOnfig= GlobalConfigUtils.defaults();
}
/* 初始化表名相关 */
final String[] excludeProperty = initTableName(clazz, globalConfig, tableInfo);
List excludePropertyList = excludeProperty != null && excludeProperty.length > 0 ? Arrays.asList(excludeProperty) : Collections.emptyList();
/* 初始化字段相关 */
initTableFields(clazz, globalConfig, tableInfo, excludePropertyList);
/* 放入缓存 */
TABLE_INFO_CACHE.put(clazz, tableInfo);
/* 缓存 lambda */
LambdaUtils.installCache(tableInfo);
/* 自动构建 resultMap */
tableInfo.initResultMapIfNeed();
return tableInfo;
} 分析 initTableName() 方法，获取表名信息源码中传入了实体类信息 class，其实就是通过实体上的@TableName 注解拿到了表名。
我们在定义实体类的同时，指定了该实体类对应的表名。
那么获取到表名之后怎么获取主键及其他字段信息呢？主要根据AbstractSqlInjector抽象类的 inspectInject 方法中的initTableFields方法获取，如下图：
/**
*
* 初始化 表主键,表字段
*
*
* @param clazz 实体类
* @param globalConfig 全局配置
* @param tableInfo 数据库表反射信息
*/
public static void initTableFields(Class clazz, GlobalConfig globalConfig, TableInfo tableInfo, List excludeProperty) {
/* 数据库全局配置 */
GlobalConfig.DbConfig dbCOnfig= globalConfig.getDbConfig();
ReflectorFactory reflectorFactory = tableInfo.getConfiguration().getReflectorFactory();
//TODO @咩咩 有空一起来撸完这反射模块.
Reflector reflector = reflectorFactory.findForClass(clazz);
List list = getAllFields(clazz);
// 标记是否读取到主键
boolean isReadPK = false;
// 是否存在 @TableId 注解
boolean existTableId = isExistTableId(list);
List fieldList = new ArrayList<>(list.size());
for (Field field : list) {
if (excludeProperty.contains(field.getName())) {
continue;
}
/* 主键ID 初始化 */
if (existTableId) {
TableId tableId = field.getAnnotation(TableId.class);
if (tableId != null) {
if (isReadPK) {
throw ExceptionUtils.mpe("@TableId can't more than one in Class: \"%s\".", clazz.getName());
} else {
isReadPK = initTableIdWithAnnotation(dbConfig, tableInfo, field, tableId, reflector);
continue;
}
}
} else if (!isReadPK) {
isReadPK = initTableIdWithoutAnnotation(dbConfig, tableInfo, field, reflector);
if (isReadPK) {
continue;
}
}
/* 有 @TableField 注解的字段初始化 */
if (initTableFieldWithAnnotation(dbConfig, tableInfo, fieldList, field)) {
continue;
}
/* 无 @TableField 注解的字段初始化 */
fieldList.add(new TableFieldInfo(dbConfig, tableInfo, field));
}
/* 检查逻辑删除字段只能有最多一个 */
Assert.isTrue(fieldList.parallelStream().filter(TableFieldInfo::isLogicDelete).count() <2L,
String.format("@TableLogic can't more than one in Class: \"%s\".", clazz.getName()));
/* 字段列表,不可变集合 */
tableInfo.setFieldList(Collections.unmodifiableList(fieldList));
/* 未发现主键注解，提示警告信息 */
if (!isReadPK) {
logger.warn(String.format("Can not find table primary key in Class: \"%s\".", clazz.getName()));
}
} 到处我们知道 SQL 语句是怎么注入的了，如果想要更加深入了解的小伙伴，可以自己根据上面的源码方法深入去了解。
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有