springboot和mybatis两个框架结合教程

本文我们来讲讲springboot和mybatis如何结合

依赖和数据源配置

springboot依赖了spring4，需要依赖mybatis-spring，最新版本是1.2.2。

数据源相关的依赖：

    com.zaxxer
    HikariCP-java6
    ${HikariCP.version}


    mysql
    mysql-connector-java
    ${mysql-connector-java.version}


    org.mybatis
    mybatis
    ${mybatis.version}


    org.mybatis
    mybatis-spring
    ${mybatis-spring.version}

前两个是数据源的依赖，包括HikariCP和mysql驱动。后面两个是mybatis依赖，包括mybatis本身和mybatis-spring模块。

有了这些依赖之后，就可以通过spring4的配置类，对mybatis数据源等进行配置。

@Configuration
@PropertySource("classpath:datasource.properties")
@MapperScan(basePackages="xxx.repository", sqlSessionFactoryRef = "sqlSessionFactory")
public class DatasourceConfig {
    @Autowired
    private Environment env;
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setDriverClassName("com.mysql.jdbc.Driver");
        config.setAutoCommit(false);
        config.setJdbcUrl(env.getProperty("xxx.db.url"));
        config.setUsername(env.getProperty("xxx.db.username"));
        config.setPassword(env.getProperty("xxx.db.password"));
        return new HikariDataSource(config);
    }
    @Bean
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setTypeAliasesPackage("xxx.mybatis");
        return sessionFactory.getObject();
    }
}

首先引入配置文件，并且注入到env对象中。env类似System的properties对象，封装了配置文件中的key value。
然后通过MapperScan注解定义mapper接口包路径。这里同时定义了sqlSessionFactoryRef，是因为需要用到多数据源，
防止spring无法注入，后面会提到。

之后代码就可以开始定义输出的bean。一个是datasource，直接初始化一个Hikari的数据源，springboot提供了builder类，
但是查看源码和api之后，DataSourceBuilder无法配置autocommit属性。

再下面是事务管理，需要通过构造函数注入dataSource。最后一个是mybatis的sqlSessionFactory，主要也是注入一个数据源。

mapper(DAO)实现

dao实现和原先的ibatis差不多，但是mybatis可以通过注解的形式直接生成动态sql。既然springboot用了代码来取代xml，mybatis中也同样去掉了xml。

插入

插入操作需要注意两个地方，一个是如何返回插入之后的主键（mysql），一个是如何使用数据类型的handler。
首先看代码：

@Insert("INSERT INTO aegis_cron_timer " +
"(id, gmt_create, gmt_modified, name, expression, event_class_name, description, last_trigger_time, status, parameter) " +
"VALUES (NULL, now(), now(), #{name:VARCHAR}, #{expression:VARCHAR}, " +
"#{eventClassName:VARCHAR}, #{description:VARCHAR}, now(), #{status:VARCHAR}, " +
"#{parameter,typeHandler=com.alibaba.aegis.seawater.cron.service.dao.mybatis.MapToJsonTypeHandler})")
@SelectKey(before = false, statement = "SELECT LAST_INSERT_ID()", keyProperty = "id", resultType = java.lang.Long.class)
public Long insertCronTimer(CronTimer cronTimer);

针对mysql，可以通过SelectKey这个注解，设置插入后主键的返回。由于mysql是自增主键，所以设置为插入后执行，定义返回的类型为long（数据库中定义了bigint）。

另外，这里有个字段需要从map序列化成json字符串，作为varchar类型存放到数据库中。在插入的sql中，可以直接在变量后面定义typeHandler，值是对应handler的完整类名。

更新

更新操作比较简单，直接使用Update注解即可。和插入类似，如果需要指定type handler，直接在字段后面增加参数即可。更新函数可以返回一个int值，表示本次更新的行数。

查询

查询通过Select注解完成，mybatis可以直接通过字段名字和查询结果的java bean之间做自动关联。如果名字不匹配，有两种方式，一种是通过sql中增加AS关键字转成java bean中的字段名，一种是通过@Result注解指定二者的映射关系。

@Select("SELECT name, expression, event_class_name AS eventClassName, description, status, parameter " +
"FROM aegis_cron_timer " +
"WHERE status = 'ENABLE'")
@Results({
@Result(column = "parameter", jdbcType = JdbcType.VARCHAR, property = "parameter", typeHandler = MapToJsonTypeHandler.class)
})
public List listAllAvailableCronTimer();

这里通过Result注解配置了type handler，特别注意Result注解必须在Results注解中，不然不会生效。

自定义type handler

前文已经提到了如何在插入、更新、查询语句中使用type handler，type handler实现也比较简单。mybatis自带的type handler都是通过extends BaseTypeHandler来实现的，但例子中直接实现了TypeHandler接口：

@MappedTypes(Map.class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class MapToJsonTypeHandler implements TypeHandler> {
    @Override
    public void setParameter(PreparedStatement ps, int i, Map parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, JSON.toJSONString(parameter));
    }
    @Override
    public Map getResult(ResultSet rs, String columnName) throws SQLException {
        String value = rs.getString(columnName);
        return jsonToMap(value);
    }
    @Override
    public Map getResult(ResultSet rs, int columnIndex) throws SQLException {
        String value = rs.getString(columnIndex);
        return jsonToMap(value);
    }
    @Override
    public Map getResult(CallableStatement cs, int columnIndex) throws SQLException {
        String value = cs.getString(columnIndex);
        return jsonToMap(value);
    }
    private Map jsonToMap(String value) {
        if (StringUtils.isBlank(value)) {
            return Collections.emptyMap();
        } else {
            return JSON.parseObject(value, new TypeReference>() {
            });
        }
    }
}

实现比较简单，序列化的时候直接通过fastjson将map对象转成json string，放到PreparedStatement中。反序列化的时候返回来转成Map即可。

多数据源实现

由于项目需要从老的数据库迁移到新的数据库，所以需要两个数据源，在设置多数据源的时候也踩了很多坑。

另一个数据源配置类：

@Configuration
@PropertySource("classpath:amon-datasource.properties")
@MapperScan(basePackages="com.alibaba.aegis.seawater.cron.migrate.repository",
        sqlSessionFactoryRef = "amonSqlSessionFactory", sqlSessionTemplateRef = "amonSqlSessionTemplate")
public class AmonDataSourceConfig {
    @Autowired
    private Environment env;
    @Bean(name = "amonDataSource")
    public DataSource amonDataSource() {
        HikariConfig config = new HikariConfig();
        config.setDriverClassName("com.mysql.jdbc.Driver");
        config.setAutoCommit(true);
        config.setJdbcUrl(env.getProperty("amon.db.url"));
        config.setUsername(env.getProperty("amon.db.username"));
        config.setPassword(env.getProperty("amon.db.password"));
        return new HikariDataSource(config);
    }
    @Bean(name = "amonTransactionManager")
    public DataSourceTransactionManager amonTransactionManager(@Qualifier("amonDataSource")DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    @Bean(name = "amonSqlSessionFactory")
    public SqlSessionFactory amonSqlSessionFactory(@Qualifier("amonDataSource")DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        return sessionFactory.getObject();
    }
    @Bean(name = "amonSqlSessionTemplate")
    public SqlSessionTemplate amonSqlSessionTemplate(@Qualifier("amonSqlSessionFactory")SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

这里也定义了一个配置文件，需要注意的是不要和前面一个的key相同，不然会覆盖的。定义bean的时候需要设置下name，或者函数名字改了也行。
需要定义的bean和之前的一样，特别注意MapperScan注解需要修改sqlSessionFactoryRef或者sqlSessionTemplateRef。这里两个都改了但是启动的时候会
提示：

Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.

这边定义了bean之后，直接使用就没有问题了。唯一需要特别注意的是@Transactional注解，由于定义了两个transactionManager，
无法通过类型来注入事务管理器了，需要注解中特别指定。比如使用前面定义的数据源的事物管理器，需要改成：

@Transactional("transactionManager")

这样spring可以通过名字注入bean。

DAO测试

为了方便测试，对应测试类中，重新覆盖了dataSource，采用h2这种内存数据库，解决单元测试数据干扰。

@Configuration
@MapperScan(basePackages="com.alibaba.aegis.seawater.cron.repository")
public class TestDatasourceConfig extends DatasourceConfig {
    @Autowired
    private Environment env;
    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .setName("cron")
                .addScript("h2.sql")
                .build();
    }
}

这里直接通过springboot提供的EmbeddedDatabaseBuilder来创建一个h2的数据库，并添加初始化数据库schema的sql文件。
这里需要注意的是，如果这个sql文件直接叫schema.sql，之前mysql数据源在执行的时候也会去执行，因此这里没有使用默认的名字。

其他坑

在springboot注入properties文件中配置的时候，还遇到一个恶心的问题，除了PropertySource注解指定的properties文件之外，
spring还会默认带上jvm变量、系统环境变量。刚开始直接把数据库用户名字段的key写成了username，结果由于测试服务器上使用了sudo命令，sudo在切换用户的同时设置了USERNAME这个环境变量标识原始执行用户，导致springboot一直在注入这个值，调试了很久。

求教Springboot+mybatis的配置

官方木有springboot+mybatis的配置，只有JPA的，JPA不想用，表关联查询太纠结。

有没有配置过springboot+mybatis的求参考。或者如何在springboot下，添加原生的配置方法也行，在线等，求大神。

回答：很简单的....

@Configuration
@EnableTransactionManagement
@MapperScan("com.*.*.mapper")
public class DataBaseConfig {
 
    private final Logger log = LoggerFactory.getLogger(DataBaseConfig.class);
 
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "datasource.primary")
    public DataSource dataSource() {
        log.debug("Configuring Datasource");
        return new DruidDataSource();
    }
 
    @Bean
    public PlatformTransactionManager txManager() {
        return new DataSourceTransactionManager(dataSource());
    }
 
    @Bean
    public SqlSessionFactory sqlSessionFactoryBean() throws Exception {
 
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());
 
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
 
        sqlSessionFactoryBean.setMapperLocations(resolver
                .getResources("classpath:/mapper/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }
 
}