从mybatis到mybatis-spring再到mybatis-springboot-starter

mybatis使用入门、springboot整合,以及整合后的事务管理原理

mybatis

mybatis是一款支持自定义SQL、存储过程和高级映射的持久化框架。通过封装几乎消除了使用者编写JDBC、手动设置参数和检索结果的代码,其底层实现通过XML配置文件、Java注解的方式来配置,将Mapper接口和POJO类映射到数据库

基本使用

核心配置

  1. 使用XML配置
  • 第一步:配置mybatis的运行环境

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    <?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>

    <properties resource="db.properties" />

    <settings>
    <setting name="logImpl" value="LOG4J"/>
    <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>

    <!--包别名,便于在mapper xml文件中简写resultType-->
    <typeAliases>
    <package name="com.luhc.mybatis.simple.model" />
    </typeAliases>

    <environments default="development">
    <environment id="development">
    <transactionManager type="JDBC"/>
    <dataSource type="UNPOOLED">
    <property name="url" value="${db.connectionURL}"/>
    <property name="driver" value="${db.driverClass}"/>
    <property name="username" value="${db.userName}"/>
    <property name="password" value="${db.password}"/>
    </dataSource>
    </environment>
    </environments>
    <mappers>
    <!-- 配置Mapper接口 -->
    <mapper resource="com/luhc/mybatis/simple/mapper/UserMapper.xml"/>
    </mappers>
    </configuration>
  • 第二步:根据配置文件来创建SqlSessionFactoryBuilder、创建SqlsessionFactory、SqlSession、从SqlSession中获取Mapper接口代理类对象

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    @Test
    public void testXMLConfig() throws IOException {
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = userMapper.findAll();
    Assert.assertFalse(users.isEmpty());

    User user = userMapper.findByKey(1L);
    Assert.assertNotNull(user);
    }
  1. 使用java code配置
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    @Test
    public void testCodeConfig() throws IOException {
    // 从properties文件中加载配置
    Properties properties = new Properties();
    properties.load(Resources.getResourceAsStream("db.properties"));
    Properties configProperties = new Properties();
    String connectUrl = properties.getProperty("db.connectionURL");
    String driverClass = properties.getProperty("db.driverClass");
    String userName = properties.getProperty("db.userName");
    String password = properties.getProperty("db.password");
    configProperties.setProperty("url", connectUrl);
    configProperties.setProperty("driver", driverClass);
    configProperties.setProperty("username", userName);
    configProperties.setProperty("password", password);

    // 配置数据源
    UnpooledDataSourceFactory unpooledDataSourceFactory = new UnpooledDataSourceFactory();
    unpooledDataSourceFactory.setProperties(configProperties);
    DataSource dataSource = unpooledDataSourceFactory.getDataSource();

    // 配置事务工厂
    TransactionFactory transactionFactory = new JdbcTransactionFactory();
    // 配置Enviroment对象
    Environment environment = new Environment("development", transactionFactory, dataSource);

    // 配置Configuration对象
    Configuration configuration = new Configuration(environment);

    // 配置mapper
    configuration.addMapper(UserMapper.class);

    // 创建SqlSessionFactory实例,用于获取SqlSession
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

    // 创建SqlSession实例,用于获取Mapper接口的代理实例
    SqlSession sqlSession = sqlSessionFactory.openSession();

    // 执行Mapper接口的方法,进行实际的查询
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = userMapper.findAll();
    Assert.assertFalse(users.isEmpty());

    User user = userMapper.findByKey(1L);
    Assert.assertNotNull(user);
    }

Mapper接口的配置

  1. XML方式
  • 定义XML文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.luhc.mybatis.simple.mapper.UserMapper">
    <!--id对应接口中的方法名; resultType为映射的POJO类-->
    <select id="findAll" resultType="com.luhc.mybatis.simple.model.User">
    select * from user
    </select>

    <select id="findByKey" resultType="com.luhc.mybatis.simple.model.User">
    select * from user where id = #{id}
    </select>

    </mapper>
  • 定义接口:类名与XML中的namespace一致,方法名与XML中的id一致

    1
    2
    3
    4
    5
    6
    public interface UserMapper {

    List<User> findAll();

    User findByKey(Long id);
    }
  1. Java注解方式
  • 注解方式只需要定义接口
    1
    2
    3
    4
    5
    6
    7
    8
    public interface UserMapper {

    @Select("select * from user")
    List<User> findAll();

    @Select("select * from user where id = #{id}")
    User findByKey(Long id);
    }

常用功能

  • environment
    实现多数据源,通过在配置中定义多个environment实例,在创建SqlSessionFactory的时候,传入指定的environment来实现多数据源并存的功能

  • 类型转换
    用于实现Jdbc数据类型Java类型之间的相互转换,通过实现接口TypeHandler来实现,mybatis提供了抽象类BaseTypeHandler来方便我们实现该接口。可参考文档typeHandler

  • 插件
    用于拦截mybatis底层代码执行的机制,可参考文档pluginPageHelper

参考文档

官方文档

mybatis-spring

mybatis-spring是一个使mybatis和spring无缝集成的库,由mybatis社区开发。主要作用:

  1. 使mybatis参与spring的事务管理
  2. 负责创建SqlSession和mybatis映射器,并且可以在其他bean中注入
  3. 转换mybatis的异常为spring的异常体系(DataAccessException)

基本使用

  1. 在spring中配置DataSource

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    @Configuration
    @PropertySource({"classpath:/db.properties"})
    public class DataSourceConfig {

    @Value("${db.connectionURL}")
    private String jdbcUrl;

    @Value("${db.driverClass}")
    private String driverClass;

    @Value("${db.userName}")
    private String userName;

    @Value("${db.password}")
    private String password;

    @Bean
    public DataSource masterDataSource() {
    DruidDataSource druidDataSource = new DruidDataSource();
    druidDataSource.setUrl(jdbcUrl);
    druidDataSource.setDriverClassName(driverClass);
    druidDataSource.setUsername(userName);
    druidDataSource.setPassword(password);

    return druidDataSource;
    }

    }
  2. 定义对应的Mapper接口和POJO模型类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Mapper
    public interface CountryMapper {
    @Delete({
    "delete from country",
    "where id = #{id,jdbcType=INTEGER}"
    })
    int deleteByPrimaryKey(Integer id);
    }

    @Data
    public class Country {
    // ...
    }
  3. 在spring中配置SqlSessionFactory

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Configuration
    @MapperScan("com.luhc.mapper") // 扫描
    public class MybatisConfig {

    @Bean
    @Autowired
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(dataSource);

    return sqlSessionFactoryBean.getObject();
    }
    }

与直接使用mybatis的差别

在直接使用mybatis的场景中,SqlSessionFactory通过SqlSessionFactoryBuilder来构建,在mybatis-spring集成环境中通过SqlSessionFactoryBean来构建,这是一个实现了spring接口FactoryBean、InitializingBean的类。在应用启动时会创建一个SqlSessionFactory的实例,并以sqlSessionFactory保存在spring IOC容器中。

mybatis-spring中mybatis是如何参与spring事务管理的

解开这个问题需要回到SqlSessionFactoryBean在应用启动时创建SqlSessionFactory的过程

可以看出,经过这一个流程后,返回的SqlSessionFactory实现类为DefaultSqlSessionFactory,可以通过它获取其内部的SpringManagedTransactionFactory。
我们再来看看在DefaultSqlSessionFactory中是如何创建SqlSession的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class DefaultSqlSessionFactory implements SqlSessionFactory {
@Override
public SqlSession openSession() {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
// 调用的是SpringManagedTransactionFactory#newTransaction方法
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
final Executor executor = configuration.newExecutor(tx, execType);
// 获取到的SqlSession
return new DefaultSqlSession(configuration, executor, autoCommit);
} catch (Exception e) {
closeTransaction(tx); // may have fetched a connection so lets call close()
throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
}

通过DefaultSqlSessionFactory创建的SqlSession为DefaultSqlSession,其内部包含了Executor实例(内部包含了上一步中TransactionFactory创建的Transaction对象),追踪到DefaultSqlSession内部

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DefaultSqlSession implements SqlSession {
@Override
public void commit(boolean force) {
try {
// 委托给Executor实例来进行实际的提交
executor.commit(isCommitOrRollbackRequired(force));
dirty = false;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error committing transaction. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
}

追踪到Executor内部、其实现类有SimpleExecutor(一般使用这个)、BatchExecutor(批量处理)、ReuseExecutor(?)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class BaseExecutor implements Executor {

@Override
public void commit(boolean required) throws SQLException {
if (closed) {
throw new ExecutorException("Cannot commit, transaction is already closed");
}
clearLocalCache();
flushStatements();
if (required) {
// 委托给Transaction实例处理
transaction.commit();
}
}
}

到了这一步,对应的Transaction实例为SpringManagedTransaction

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class SpringManagedTransaction implements Transaction {


@Override
public Connection getConnection() throws SQLException {
if (this.connection == null) {
openConnection();
}
return this.connection;
}


private void openConnection() throws SQLException {
// 用Spring的DataSourceUtils工具类获取链接
this.connection = DataSourceUtils.getConnection(this.dataSource);
this.autoCommit = this.connection.getAutoCommit();
this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);

if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"JDBC Connection ["
+ this.connection
+ "] will"
+ (this.isConnectionTransactional ? " " : " not ")
+ "be managed by Spring");
}
}

@Override
public void commit() throws SQLException {
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Committing JDBC Connection [" + this.connection + "]");
}
this.connection.commit();
}
}
}

使用SqlSessionTemplate替代代码中使用SqlSession的代码

SqlSessionTemplate利用动态代理生成SqlSession接口的代理对象,通过SqlSessionInterceptor拦截了方法执行,在获取SqlSession的时候委托给Spring的TransactionSynchronizationManager#getResource方法来获取(底层为ThreadLocal原理实现)

使用SqlSessionDaoSupport抽象类创建数据访问层

提供了便利的实现方式,让直接使用SqlSession的数据访问层可以使用SqlSessionTemplate来保证线程安全和委托spring事务管理

Mapper接口的注册

  • 第一种,手动注册

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
    SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
    sqlSessionFactory.setDataSource(dataSource());
    return (SqlSessionFactory) sqlSessionFactory.getObject();
    }

    @Bean
    public UserMapper userMapper() throws Exception {
    SqlSessionTemplate sessionTemplate = new SqlSessionTemplate(sqlSessionFactory());
    return sessionTemplate.getMapper(UserMapper.class);
    }
  • 第二种,自动扫描

  1. 使用@MapperScan注解,查看注解源码,发现可以指定要使用的SqlSessionFactory bean的名称

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    @Configuration
    @MapperScan("com.luhc.mapper")
    public class MybatisConfig {

    @Bean
    @Autowired
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(dataSource);

    return sqlSessionFactoryBean.getObject();
    }

    @Bean
    @Autowired
    public PlatformTransactionManager dataSourceTransactionManager(DataSource dataSource) {
    DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
    dataSourceTransactionManager.setDataSource(dataSource);

    return dataSourceTransactionManager;
    }
    }
  2. 注册一个MapperScannerConfigurer实例
    MapperScannerConfigurer实现了接口BeanDefinitionRegistryPostProcessor,在实例化时,spring框架会回调方法MapperScannerConfigurer#postProcessBeanDefinitionRegistry,进行mapper接口的扫描

mybatis-spring-boot-starter

mybatis-spring-boot-starter为了快速在springboot中集成mybatis,使用这个库,我们将消除模板式的xml配置代码,更少的XML配置。

基本使用

  1. 直接引入依赖

    1
    2
    3
    4
    5
    <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
    </dependency>
  2. 定义mapper接口

    1
    2
    3
    4
    5
    6
    7
    @Mapper
    public interface CityMapper {

    @Select("SELECT * FROM CITY WHERE state = #{state}")
    City findByState(@Param("state") String state);

    }
  3. springboot启动类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    @SpringBootApplication
    public class SampleMybatisApplication implements CommandLineRunner {

    private final CityMapper cityMapper;

    public SampleMybatisApplication(CityMapper cityMapper) {
    this.cityMapper = cityMapper;
    }

    public static void main(String[] args) {
    SpringApplication.run(SampleMybatisApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
    System.out.println(this.cityMapper.findByState("CA"));
    }

    }

引入依赖后,应用启动后将自动将DataSource实例注入并创建SqlSessionFactory、自动创建SqlSessionTemplate实例、自动扫描mapper接口并为其关联SqlSessionTemplate实例(保证SqlSession线程安全)。其内部默认会扫描到@Mapper注解标记的接口,如果需要更改这个机制,需要使用@MapperScan注解来配置

常用工具

代码生成器(mybatis-generator)

通过简单的XML配置,可以根据数据库表生成POJO映射类、XML mapper文件、Java mapper接口。而且对XML mapper文件不会覆盖掉自定义过的内容,只是写入自动生成有变动的部分,对于Java mapper接口文件则会直接覆盖。
这里提供一个在maven运行插件的方式,包含了常用配置的配置样例,更多的配置详情请自行到官网挖掘

  • maven插件配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    <plugin>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-maven-plugin</artifactId>
    <version>1.3.7</version>
    <configuration>
    <verbose>true</verbose>
    <overwrite>true</overwrite>
    </configuration>
    <executions>
    <execution>
    <id>Generate MyBatis Artifacts</id>
    <goals>
    <goal>generate</goal>
    </goals>
    </execution>
    </executions>
    <dependencies>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
    </dependency>
    <!--生成lombok形式的java bean-->
    <dependency>
    <groupId>com.softwareloop</groupId>
    <artifactId>mybatis-generator-lombok-plugin</artifactId>
    <version>1.0</version>
    </dependency>

    </dependencies>
    </plugin>
  • generatorConfig.xml配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
    PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
    "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

    <generatorConfiguration>
    <!--指定外部.properties配置文件-->
    <properties resource="db.properties" />

    <!--defaultModelType=flat,设置一个表只生成一个java实体类-->
    <context id="MySQL" targetRuntime="MyBatis3" defaultModelType="flat">
    <!--定义分隔符-->
    <property name="autoDelimitKeywordss" value="true" />
    <property name="beginningDelimiter" value="`" />
    <property name="endingDelimiter" value="`" />
    <property name="javaFileEncoding" value="UTF-8" />

    <!--生成lombok形式的java bean-->
    <plugin type="com.softwareloop.mybatis.generator.plugins.LombokPlugin" />

    <!--注释管理器-->
    <commentGenerator>
    <!--阻止生成注释-->
    <!--<property name="suppressAllComments" value="true" />-->

    <!--阻止生成的注释信息包含时间戳-->
    <property name="suppressDate" value="true" />
    <!--注释带上数据库表的注释信息-->
    <property name="addRemarkComments" value="true" />
    </commentGenerator>

    <!--jdbc连接器-->
    <jdbcConnection connectionURL="${db.connectionURL}"
    driverClass="${db.driverClass}"
    userId="${db.userName}"
    password="${db.password}">
    </jdbcConnection>

    <!--jdbc类型与java类型转换器-->
    <javaTypeResolver >
    <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator targetPackage="com.luhc.mybatis.simple.model" targetProject="src/main/java">
    <!--不根据database划分不同的包-->
    <property name="enableSubPackages" value="false" />
    <!--从数据库查询的值不必去除空格-->
    <property name="trimStrings" value="false" />
    </javaModelGenerator>

    <sqlMapGenerator targetPackage="com.luhc.mybatis.simple.mapper" targetProject="src/main/resources">
    <!--不根据database划分不同的包-->
    <property name="enableSubPackages" value="false" />
    </sqlMapGenerator>

    <javaClientGenerator type="ANNOTATEDMAPPER" targetPackage="com.luhc.mybatis.simple.mapper" targetProject="src/main/java">
    <!--不根据database划分不同的包-->
    <property name="enableSubPackages" value="false" />
    </javaClientGenerator>

    <table schema="mybatis" tableName="country" >
    <!--参考配置说明http://www.mybatis.org/generator/configreference/generatedKey.html-->
    <generatedKey column="id" sqlStatement="SELECT LAST_INSERT_ID()" type="post" identity="true"/>
    </table>
    <!-- 生成多张表 -->
    <table schema="mybatis" tableName="user">
    <!--参考配置说明http://www.mybatis.org/generator/configreference/generatedKey.html-->
    <generatedKey column="id" sqlStatement="SELECT LAST_INSERT_ID()" type="post" identity="true"/>
    <!-- 指定该字段对应的Java类型 -->
    <columnOverride column="sex" property="sex" javaType="com.luhc.mybatis.simple.model.SexEnum" />
    </table>

    </context>
    </generatorConfiguration>

tkmapper(通用mapper)

预定义了基本的单表CRUD操作方法,减少了手动编写CRUD的工作。

  • 引入依赖

    1
    2
    3
    4
    5
    <dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.1.5</version>
    </dependency>
  • maven插件配置,mybatis generator代码生成器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    <build>
    <plugins>
    <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>

    <plugin>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-maven-plugin</artifactId>
    <version>1.3.6</version>
    <configuration>
    <verbose>true</verbose>
    <overwrite>true</overwrite>
    </configuration>
    <executions>
    <execution>
    <id>Generate MyBatis Artifacts</id>
    <goals>
    <goal>generate</goal>
    </goals>
    </execution>
    </executions>
    <dependencies>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>6.0.6</version>
    </dependency>
    <!--生成lombok形式的java bean-->
    <dependency>
    <groupId>com.softwareloop</groupId>
    <artifactId>mybatis-generator-lombok-plugin</artifactId>
    <version>1.0</version>
    </dependency>
    <dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper</artifactId>
    <version>4.1.5</version>
    </dependency>
    </dependencies>
    </plugin>
    </plugins>
    </build>
  • generatorConfig配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
    PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
    "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

    <generatorConfiguration>

    <!--defaultModelType=flat,设置一个表只生成一个java实体类-->
    <context id="MySQL" targetRuntime="MyBatis3Simple" defaultModelType="flat">
    <!--定义分隔符-->
    <property name="autoDelimitKeywordss" value="true" />
    <property name="beginningDelimiter" value="`" />
    <property name="endingDelimiter" value="`" />
    <property name="javaFileEncoding" value="UTF-8" />

    <!--生成lombok形式的java bean。与通用Mapper插件冲突-->
    <!--<plugin type="com.softwareloop.mybatis.generator.plugins.LombokPlugin" />-->
    <!--通用mapper插件-->
    <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
    <!--生成的Mapper会继承这里指定的类-->
    <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
    <property name="caseSensitive" value="true"/>
    <property name="forceAnnotation" value="true"/>
    <property name="beginningDelimiter" value="`"/>
    <property name="endingDelimiter" value="`"/>
    <property name="needsData" value="true" />
    </plugin>
    <!--注释管理器-->
    <commentGenerator>
    <!--阻止生成注释-->
    <!--<property name="suppressAllComments" value="true" />-->

    <!--阻止生成的注释信息包含时间戳-->
    <property name="suppressDate" value="true" />
    <!--注释带上数据库表的注释信息-->
    <property name="addRemarkComments" value="true" />
    </commentGenerator>

    <!--jdbc连接器-->
    <jdbcConnection connectionURL="jdbc:mysql://111.230.14.116:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"
    driverClass="com.mysql.cj.jdbc.Driver"
    userId="用户"
    password="密码">
    </jdbcConnection>

    <!--jdbc类型与java类型转换器-->
    <javaTypeResolver >
    <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator targetPackage="com.treeinsea.glimmer.model" targetProject="src/main/java">
    <!--不根据database划分不同的包-->
    <property name="enableSubPackages" value="false" />
    <!--从数据库查询的值不必去除空格-->
    <property name="trimStrings" value="false" />
    </javaModelGenerator>

    <sqlMapGenerator targetPackage="com.treeinsea.glimmer.mapper" targetProject="src/main/resources">
    <!--不根据database划分不同的包-->
    <property name="enableSubPackages" value="false" />
    </sqlMapGenerator>

    <javaClientGenerator type="XMLMAPPER" targetPackage="com.treeinsea.glimmer.mapper" targetProject="src/main/java">
    <!--不根据database划分不同的包-->
    <property name="enableSubPackages" value="false" />
    </javaClientGenerator>

    <!--catalog指定表所在的数据库,避免了同名表的问题-->
    <table tableName="country" catalog="mybatis" >
    <property name="ignoreQualifiersAtRuntime" value="true" />
    <!--参考配置说明http://www.mybatis.org/generator/configreference/generatedKey.html-->
    <generatedKey column="id" sqlStatement="SELECT LAST_INSERT_ID()" type="post" identity="true"/>
    </table>
    <table tableName="user" catalog="mybatis" >
    <property name="ignoreQualifiersAtRuntime" value="true" />
    <!--参考配置说明http://www.mybatis.org/generator/configreference/generatedKey.html-->
    <generatedKey column="id" sqlStatement="SELECT LAST_INSERT_ID()" type="post" identity="true"/>
    </table>

    </context>
    </generatorConfiguration>
  • application.yaml指定扫描的基接口

    1
    2
    3
    4
    mapper:
    mappers:
    - tk.mybatis.mapper.common.Mapper
    not-empty: true