数据库访问
一、数据源的配置
在依赖于 Spring Boot 的 spring”boot-starter-data- a 后，它就会默认为你配置数据源，这些默认的数据源主要是内存数据库，如 h2 、 hqldb 和 Derby 等内存数据，有时候需要配置为我们想要的数据源 。
1.启动默认的数据源
下面以 h2 数据库为例，在 Maven 中加入它的依赖，如代码清单 5 -1 所示。
代码清单 5-1 配置 h2 默认数据库
<dependency>
<groupid>org.springfrarnework . boot</groupid>
<artifactid>spring-boot-starter-data-]pa</artifactid>
</dependency>
<dependency>
<groupid>com.h2database</groupid>
<artifactid>h2</artifactid>
<scope>runtime</ scope>
</dependency>
这里引入了 JPA（Java Persistence API） 的依赖。对 JPA 来说，在 Spring Boot 中是依赖 Hibernate 去实现的，这样我们就可以在不使用任何配置数据库的情况下运行 S pring Boot 工程了，因为 h2 是内嵌式数据库，它会随着 Spring Boot 项目的启动而启
动 ， 并不需要任何的配置，更多的时候我们希望使用的是商用数据库，因此，我们需要考虑如何配置其他数据库厂商的数据源
2.配置自定义数据源
<dependency>
<groupid>mysql</groupid>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupid>org.springfrarnework.boot</groupid>
<artifactid>spring-boot-starter-data-jpa</artifactid>
</dependency>
此外还需要配置数据库的相关信息才能连接到数据库 ， 这里可以配置 application.properties 配置文件以达到配置数据源的效果 。
spring.datasource.url=jdbc:mysql://localhost:3306/chapter5
spring.datasource.username=root
spring.datasource.password=l23456
spring.datasource.driver-class-name=com.mysql.jdbcDriver
上面只是匹配 Spring Boot 绑定的 Tomcat 的数据源 ， 有时候我们希望使用的是第三方数据源 ，这也是没有任何问题的 。 例如 ， 如果我们要使用 DBCP 数据源 ， 只 需要加入 DBCP 的数据源的 Maven依赖
<dependency>
<groupid>org.apache.commons</group i d >
<artifactid>commons-dbcp2</artifactid>
</dependency>
修改application.properties文件
spring.datasource.url=jdbc:mysql://localhost:3306/chapter5
spring.datasource.username=root
spring.datasource.password=l23456
spring.datasource.driver-class-name=com.mysql.jdbcDriver
#指定了数据库连接池的类型
spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
测试
public class DataSourceShow implements ApplicationContextAware {
ApplicationContext appl 工cationContext = null ;
//Spring 容器会自动调用这个方法,注入 Spring IOC容器
@override
public void setApplicationContext (ApplicationContext applicationContext)throws BeansException {
this. applicationContext = applicationContext ;
DataSource dataSource = applicationContext.getBean(DataSource.class) ;
System.out .println(dataSource.getClass() . getNa皿e()) ;
}
}
上述代码中 实现了 接 口 ApplicationContextAware 的方setApplicationContext（),依照 SpringBean 生命周 期的规则， 在其初始化的时候该方法就会被调用，从而获取 Spring IoC 容器 的上下文( applicationContext ），这时通过 getBean 方法就可 以获取数据库连接池，然后打印出数据连接池的全限定名，这样就可以知道它使用的是哪种数据库连接池了 .
为完成下面的操作我们简历下面表和类
create table t_user(
id int(12) not null auto increment,
user_ame varchar(60) not null ,
／＊＊性别列， 1 － 男， 2 －女＊＊／
sex int(3) not null default 1 check (sex in(l,2)) ,
note varchar(256) null ,
primary key (id)
);
POJO类
public class User {
private Long id = null;
private String userName = null;
private SexEnum sex = null ;／／枚举
private String note = null;
/**** setter and getter****/
}
public enum SexEnum {
MALE(l ，” 男 ”），FEMALE(2 ， ”女 ”）;
private int id;
private String name;
SexEnum (int id , String name) {
this.id = id;
this.name= name;
}
public static SexEnum getEnumByid （Int id) {
for (SexEnum sex : SexEnum. values()) {
if (sex.getid() == id) {
return sex;
}
return null;
}
}
／**** setter and getter ****／
}
二、使用JdbcTemplate操作数据库
在配置数据源后， Spring Boot 通过其自动配置机制配置好了 JdbcTemplate, JdbcTemplate 模板是Spring 框架提供的。
下面先创建一个 Service 接口，定义一些方法，这样通过它的实现类就可以注入 Spring Boot 已经为我们配置好的 JdbcTemplate ， 直接就可以使用了。
package com.demo.service；
/**** imports ****/
public interface JdbcTmplUserService{
public User getUser(Long id);
public List<User> findUsers(String userName,String note);
public int insertUser(User user);
public int updateUser(User user);
public int deleteUser(User user);
}
其实现类为
package com.demo.service.impl;
/**** imports ****/
public class jdbcImplUserServiceImpl implements jdbcTmplUserService{
@AutoWired
private JdebTempate jdbcTemplate=null;
// 获取映射关系
private RowMapper<User> getUserMapper(){
// 使用lambda表达式
RowMapper<user> userRowMapper=(ResultSet rs,int rownum)->{
User user = new User();
user.setId(rs.getLong("id")) ;
user.setUserName(rs.getString("user"));
int sexId = rs.getInt("sex");
sexEnum sex= SexEnum.getEnumById(sexId);
user.setSex(sex);
use.setNote(re.getString("note"));
return user;
} ;
return userRowMapper;
}
@Override
public User getUser(Long id){
String sql = "select id ,user_name,sex,note from t_user where id =?";
Object[] params= new Object[]{id};
User user =jdbcTemplate.queryForObject(sql,params,getUserMapper());
}
@Override
public List<User> findUsers(Strog userName,String note){
String sql="select id ,user_name,sex,note from t_user"
+"where user_name like concat('%',?,'%')"
+"and note like concat("%",?,"%")";
Object params=new Object[]{userName,note};
list<User> userList=jdbcTemplate.query(sql,params,getUserMapper());
return userList;
}
@Override
public int insertUser(User user){
String sql="insert into t_user (user_name,sex,note) values(?,?,?)";
return jdbcTemple.update(sql,user,getUserrName,user.getSex().getId(),user.getNote());
}
@Override
public int updateUser(User user){
sql="update t_user set user_name=?,sex=?,note=? where id=?";
return jdbcTemplate.update(sql,user.getUserName(),user.getSex().getId(),user.getNote(),user.getId());
}
@Override
publiC int deleteUser (Long id ) {
return jdbcTemplate.update(sql,id);
}
JdbcTemplate 的映射关系是需要开发者自己实现 RowMapper的接口的，这样就可以完成数据库到POJO对象之间的映射；
有时候我们希望在一个连接里面执行多条 SQL ， 对此我们也可以使用 StatementCallback 或者 ConnectionCallback 接口 实现回调
public User getUser2(Long id){
User result = this.jdbcTemplate.excute((Statament stmt)->{
String sqll ="select count(*) total from t_user where id=" + id ;
ResultSet rsl = stmt.executeQuery(sqll) ;
while (rsl.next()) {
int total= rsl . getint ( ” total ”) ;
System . out . println(total) ;
}
//执行的 SQL
String sql2 = ” select id, user name, sex, note from t user "
+ " where id = ” + id;
Resul tSet rs2 = stmt executeQuery (sql2) ;
User user = null ;
while (rs2.next()) {
int rowNum = rs2.getRow();
user= getUserMapper() .mapRow(rs2, rowNum) ;
}
return user;
});
}
public User getUser3 (Long id) {
／／通过 Lambda 表达式使用 ConnectionCallback 接口
return this. jdbcTemplate. execute ( (Connection conn) - > {
String sqll =” select count （*） as total from t user "
+ " where id = ?” ;
PreparedStatement psl = conn . prepareStatement(sqll) ;
psl .setLong(l , id);
ResultSet rsl = psl.executeQuery() ;
while (rsl.next()) {
System . out . println(rsl . getint( "total ”) ) ;
String sql2 ＝ ” select 工 d , user name , sex, note from t user where id = ?” ;
PreparedStatement ps2 = conn . prepareStatement(sql2);
ps2 . setLong(l , id) ;
ResultSet rs2 = ps2 executeQuery( );
User user = nul l;
while (rs 2 .ne xt()) {
int rowNum = rs2 . getRow( );
user= getUserMapper () . mapRow(rs2 , rowNum );
}
return user ;
}
}
三、使用JPA(Hibernate)
操作数据JPA (Java Persistence API, Java 持久化 APO ， 是定义了对象关系映射 CORM ）以及实体对象持久化的标准接口。 JPA 不局限于 EJB 3.0 ，而是作为 POJO 持久化的标准规范 ， 可以脱离容器独立运行 。
在 Spring Boot 中 JPA 是依靠 Hibernate 才得 以实现的 ，JPA 所维护的核心是实体（ Entity Bean ），而它是通过一个持久化上下文（ Persistence Context )来使用的 。
持久化上下文包含一下三个部分：
- 对象关系映射（Object Relational Mapping ,ORM）,JPA 支持注解和XML进行描述，在Spring Boot 中主要通过注解实现；
- 实体操作API,通过这节规范可以实现对实体对象的CRUD操作，来完成对象的持久化和查询；
- 查询语言，约定了面向对象的查询语言JPQL(Java Persistence Query Language)，通过这层关系可以实行比较灵活的查询；
1.定义POJO
package com.demo.pojo
//标明这是一个实体类
@Entity(name="user")
//定义映射的表
@Table(name="t_user")
public class User {
//表明主键
@Id
//设置主键策略
@GenerateValue(strategy=GenerationType.TDENTITY)
private Long id = null
//定义实体类属性与表的映射关系
@Column(name="user_name")
private String userName = null;
@Column(name="note")
private String note = null;
//定义转发器
@Convert(converter=SexConverte.class)
private SexEnum sex = null ;
/**** setter and getter****/
}
- ＠Entity 标明这是一个实体类，
- ＠Table 配置的属性 name 指出它映射数据库的表，这样实体就映射到了对应的表上
- ＠Id 标注那个属性为表的主键，
- ＠GeneratedValue 则是可以配置采用何种策略生成主键，这里采用 Gen巳rationType.IDENTITY ， 这是一种依赖于数据库递增的策略
- ＠Column 属性就能与数据库的表的宇段一一对应起来了。
- ＠Convert 可以指定属性与表字段的转化方式。
public class SexConverter implements AttributeConverter<SexEnum , Integer>{
//将枚举转换为数据库列
@Override
public Integer convertToDatabaseCol umn (SexEnum sex) {
return sex. getId () ;
}
//将数据库列转换为枚举
@Override
public SexEnum convertToEntityAttribute (Integer id) {
return SexEnum.getEnumByid(id);
}
}
2.JpaRepository 接口的使用
有了上述的 POJO 对象的定义，我们还需要一个 JPA 接口来定义对应的操作 。为此 Spring
提供了 JpaRepository 接口提供， 它本身也继承了其他的接口
JPA 最顶级的接口是 Repository，而它没有定义任何方法，定义方法的是它的子接口 CrudRepository ， 其定义实体最基本 的增删改的操作，功能性还不足够强大 ， 为此
Pag ingAndSortingRepository 则 继承了它并且提供了分页和排序的功能 ， 最后 JpaRepository 扩展了PagingAndSortingRepository ，扩展了QueryByExampleExecutor 接 口。我们只需要定义JPA扩展JPArepository便可以获得JPA提供的方法了，
package com.demo.dao
public interface JpaUserRepository extends JparRepository<User,Long>{
}
这样便拥有了系统默认帮我们实现的方法。请注意，这并不需要提供任何的实现类，spring会2根据JPA接口规范帮我们完成，然后我们就可以开发控制器了JpaController
@Controller
@RequestMapping("/jpa")
public class JpaController{
//注入Jpa接口，这里不需要使用实现类
@AutoWired
private JpaUserRepository jpaUserRepository = null;
@RequestMapping("/getUser")
@ResponseBody
public User getUser(Long id){
User user=jpaUserRepository.findById(id).get();
return user;
}
}
接口JpaUserRepository还需要制定 Spring Boot 的扫描路径，才能将接口扫描到 Spring IoC 容器 中 。 与此同时，我们还要将实体类（ Entity Bean ）注册给 JPA
@SpringbootApplication
//定义JPA接口扫描路径
@EnableJpaRepositories(basePackage="com.demo.dao")
//定义实体Bean扫描包路径
@EntityScan(basePackage="com.demo.pojo")
public class DemoApplication{
public static void main(String[] args)throws Exception{
SpringApplication.run(DemoApplication.class,args);
}
}
- EnableJpaRepositories 启用 JPA 和制定扫描的包， 这样 Spring 就会将对应的 JPA 接口扫描进来，并且生成对应的 Bean ， 装配在 IoC 容器中，这样就可以在控制器上用＠Autowired 进行依赖注入了
- ＠EntityScan 定义的包扫描，就可以通过扫描装载 JPA 的实体类 了
为了对JPA进行一定的配置。
＃使用 MySQL 数据库方言
spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect
＃打印数据库 SQL
spring.jpa.show-sql=true
＃选择 Hibernate 数据定义语言（ DDL )策略为 update
spring.jpa.hibernate ddl-auto=update
四、整合myBatis框架
文档：http://www.mybatis.org/mybatis-3/zh/index.html
官方定义：MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层
框架 。
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集 。 MyBatis 可以对配置和原生 Map 使用简单的 XML 或注解 ， 将接口和 Java 的 POJO ( Plain Old Java Obect，普通的 Java对象）映射成数据库中的记录 。
MyBatis 是基于一种 SQL 到 POJO 的模型，它需要我们提供 SQL 、
映射关系（ XML 或者注解 ， 目前以 XML 为主）和 POJO 。 但是对于 SQL 和 POJO 的映射关系 ， 它提供了自动映射和驼峰映射等 ， 使开发者的开发工作大大减少 ：由于没有屏蔽 SQL ， 这对于追求高响应和l性能的互联网系统是十分重要的 ， 因此我们可以尽可能地通过 SQL 去优化性能
MyBatis 的配置文件包括两个大的部分 ， 一是基础配置文件 ， 一个是映射文件 。 在 MyBatis 中也可以使用注解来实现映射，但是主要使用XML进行配置 。
首先需要引入starter
1.MyBatis的配置
myBatis 是一个基于SqlSessionFactory构建的框架。对于SqlSessionFactory而言，它的作用是生成SqlSession接口对象。这个接口对象就是MyBatis操作的核心，而在MyBatis-Spring 的结合中甚至可以“擦除”这个对象，使其在代码中“消失”，这样做的意义是重大的，因为 SqlSession 是一个功能性的代码，“擦除”它之后，就剩下了业务代码，这样就可以使得代码更具可读性 。 因为SqlSessionFactory 的作用是单一 的，只是为了创建核心接口 SqISession ，所以在 MyBatis 应用的生命周期中理当只存在一个 SqlSessionFactory 对象，并且往往会使用单例模式 。 而构建 SqlSessionFactory
是通过配置类（ Configuration ）来完成的 .因此对于 mybatis-spring-boot-starter，它会给予我们在配置文件（ application.properties ）进行 Configuration 配置的相关内容 .
MyBatis可以配置的内容：
- properties(属性)：属性在在应用中一般采用Spring配置，而不是myBatis进行配置，而不是MyBatis
- settings(设置)：它的配置将改变 MyBatis 的底层行为 ，可以配置映射规则，如自动映射和驼峰映射、执行器（ Executor ）类型、缓存等内容，比较复杂，具体配置项可参考 MyBatis官方网站（ http://www.mybatis.org/mybatis-3/zh/configuration.html#settings ）
- typeAliases(类型别名)：：因为使用类全限定名会比较长，所以 MyBatis 会对常用的类提供默认的别名，此外还允许我们通过 typeAliases 配置自定义的别名
- typeHandlers(类型处理器)：这是 MyBatis 的重要配置之一 ，在 MyBatis 写入和读取数据库的过程中对于不同类型的数据（对于 Java 是 JavaType，对于数据库则是 JdbcType ）进行自定义转换，在大部分的情况下我们不需要使用自定义的 typeHandler，因为在 MyBatis 自 身就已经定义了比较多 的 typeHandler, MyBatis 会 自 动识别 javaType和 jdbcType，从而实现各种
类型的转换。一般来说 ， typeHandler 的使用集中在枚举类型上 。- objectFactory(对象工厂)：这是一个在 MyBatis 生成返回的 POJO 时会调用的工厂类。一般我们使用 MyBatis 默认提供的对象工厂类 （DefaultObjectFactory ）就可以了，而不需要任何配置
- plugins(插件)：有时候也称为拦截器 ， 是 MyBatis 最强大也是最危险的组件，它通过动态代理和责任链模式来完成，可以修改 MyBatis 底层的实现功能
- environments(数据库环境)：可以配置数据库连接 内容和事务。一般而言 ， 这些交 由 Spring托管
- databaseIdProvider(数据库厂商标识)：允许 MyBatis 配置多类型数据库支持， 不常用
- mappers(映射器)：是 MyBatis 最核心的组件，它提供 SQL 和 POJO 映射关系 ， 这是 MyBatis开发的核心
常用的是environments和mappers
对上面的实例进行修改
package com.demo.pojo;
@Alias(value="user") //指定别名为user
public class User{
private Long id=null;
private String userName=null;
private String note=null;
//性别枚举，这里需要使用typeHandler进行转化
private SexEnum sex=null;
public User(){
}
/****setter and getter****/
}
枚举可以通过typeHandler进行转化。我们需要自定义一个typeHandler
package com.demo.typehandler;
/**** imports****/
//声明JdbcType为整型
@MappedJdbcTypes(JdbcType.INTEGER)
//生命JavaType为sexEnum
@MappedJdbcTypes(value=sexEnum.class)
public class SexTypeHandler extends BaseTypeHandler<SexEnum>{
//通过列名读取性别
@Override
public SexEnum getNullableResult(ResultSet rs,String col) throws SQLException{
int sex=rs.getInt(col);
if(sex !=1 && sex!=e){
return null;
}
return SexEnum.getEnumById();
}
//通过下标读取性别
@Override
public SexEnum getNullableResult(ResultSet rs,int idx) throws SQLException{
int sex=rs.getInt(idx);
if(sex!=1&& sex!=2){
return null
}
return sexEnum.getEnumById(sex);
}
//通过存储过程读取性别
public getNullableResult(callbaleStatement cs,int idx0)throws SqlException{
int sex=cs.getInt(idx);
if(sex!=1 && sex!=2){
return null;
}
return sexEnum.getEnumById(sex);
}
//设置非空性别参数
public void setNonNullParameter(PreparedStatement ps,int idx,SexEnm sex,Jdbctype jdbctype)throws SQLException{
ps.setInt(idx,sex.getId());
}
}
在 MyBatis 中对于 typeHandler 的要求是实现 TypeHandler<1>接口，而它自身为了更加方便也通过抽象类 BaseTyp空Handler<T＞实现了 TypeHandler<T＞接 口，所以这里直接继承抽象类 BaseTypeHandler
为 SexEnurn，这样 MyBatis 即可据此对对应的数据类型进行转换了
了使这个 POJO 能够与数据库的数据对应，还需要提供一个映射文件 userMapper.xml
<?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.demo.dao.MyBatisUserDao" 〉
<select id="getUser" parameterType="long " resultType="user" >
select id , user_name as userName , sex , note from t_user where id= #{id}
</select>
</mapper>
先看到＜mapper＞元素的 namespace 属性，它指定一个接口 ， 后文会提供这个接口；接着定义一个＜select＞元素，它代表着一个查询语句，而 id 属性指代这条 SQL, parameterType 属性配置为long ，则表示是一个长整型（ Long ）参数， resultType 指定返回值类型，这里使用了 user ，这是一个别 名，因为代码清单. 5-23 中我们己经有了指代，所以才能这样使用，也可以使用全限定名( com.springboot.chapter5.poj o.User ）；再接着是 SQL 语句，这里的列名和 POJO 的属性名是保持一致的 。 请注意 ，数据库表 中的字段名为 user_name，而 POJO 的属名为 userName ， 这里的 SQL 是通过宇段的别名 （ userName ）来让它们保持一致的 。 在默认的情况下， MyBatis 会启动自动映射，将 SQL中的列映射到 POJO 上，有时候你也可以启动驼峰映射，这样就可以不启用别名了 .为了启用这个映射，我们还需要一个接口，注意仅仅是一个接口，并不需要任何实现类，它就是＜mapper＞元素的namespace 属性定义的 MyBatisUserDao
package com.demo.dao;
@Repository
class MyBatisUserDao{
public User getUser(@Param('id')Long id);
}
＠Repository 这个注解可以扫描加载 MyBatis 接口 为Bean ，而它的方法 getUser 和映射文件中定义的查询 SQL 的 id 是保持一致的，参数也是如此 。
然后我们需要对映射文件、POJO的别名、typeHandler进行配置。可以在application.properties中进行配置
#myBatis映射文件进行配置
myBatis.mapper-locations=classpath:com/demo/mapper/*.xml
#myBatis扫描别名包，和注解@Alias联用
myBatis.type-aliases-package=com.demo.pojo
#配置typeHandler的扫描包
mybatis.type-hanglers-package=com.demo.typehandler
2.Spring Boot整合MyBatis
在大部分的情况下，应该“擦除” SqlSession 接口 的使用而直接获取 Mapper 接口 ， 这样就更加集中于业务的开发，而不是 MyBatis 功能性的开发。但是在上面我们可以看到 Mapper 是一个接口，是不可 以使用 new 为其生成对象实例的 。为了方便我们使用， MyBatis 社区在与 Spring 整合的包中提供了两个类，它 们 是 MapperFactoryBean 和 MapperScannerConfigurer
- MapperFactoryBean 针对一个接口配置，
- MapperScannerConfigurer则是扫描装配，也就是提供扫描装配MyBatis的接口到Spring IoC容器中
实际上，MyBatis还提供了注解@MapperScan
- @MapperScan 能够将myBatis所需要的接口扫描到Spring IoC 容器当中。
关于MapperFactoryBean 和 MapperScannerConfigurer的使用
首先用MapperFactoryBean配置MyBatis接口。我们在Spring Boot的启动文件中加入如下的代码
@Autowired
SqlSessionFactory sqlSessionFactory=null
@Bean
public MapperFactoryBean<myBatisUserDao> initMyBatisUserDao(){
MapperFactoryBean<MyBatisUserDao> bean=new MapperFactoryBean<>();
bean.setMappperInterface(MyBatisUserDao.class);
bean.setSqlSessionFactory=(sqlSessionFactory sqlSessionFactory);
return bean;
}
然后开发业务层代码来装配它
package com.demo.service;
import com.demo.pojo.User;
public interface MyBatisUserService{
public User getUser(Long id);
}
package com.demo.services
import com.demo.pojo.User;
@Service
public class MyBatisUserServiceImpl implements MyBatisUserService{
@AutoWired
private MyBatisUserDao myBatisUserDao=null;
@Override
public User getUser(Long id){
return myBatisUserDao.getUser(id);
}
}
开发web层控制器
package com.demo.controller;
@Controller
@RequestMapping("/mybatis")
public class MyBatisontroller{
@AutoWired
private MyBatisUserService myBatisUserService=null;
@RequestMapping("/getUser")
@ResponseBody
public User getUser(Long id){
return myBatisUserService.getUser(id)
}
}
使用MapperFactoryBean可以将一个mapper 装配到Spring IoC 容器当中，然而现实是接口是很多的，这时可以使用MapperScannnerConfigures类来进行扫描了，它可以配置包和注解（或者接口）类型进行装配，然后在spring boot的启动配置文件中加入代码以下代码。
/**
*配置MyBatis接口扫描
*@return 返回扫描器
*/
@Bean
public MapperScannerConfigurer mapperScannerConfig(){
//定义扫描器实例
MapperScannerConfigurer mapperScannerConfigurer= new MapperScannerConfigurer();
//加载SplSessionFactory
mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
//定义扫描的包
mapperScannerConfigurer.setBasePackage("com.demo.*");
//限定被标注@Repositroy的接口才被扫描
mapperScannerConfigurer.setAnnotationClass(Repository.class);
//t通过继承某个接口限制扫描
//mapperScannerConfigurer.setMarkerInterface(....);
return mapperScannerConfigurer;
}
上述的两种方法需要编写额外的代码而使用@MapperScan不需要
package com.demo.main
@SpringBootApplication(scanBasePackage={"com.demo"})
@EnableJpaRepositories(basePackages="com.demo")
@EntityScan(basePackages="com.demo.pojo")
@MapperScan(
//指定扫描包
basePackage="com.demo.*",
//指定SqlSessionFactroy,如果SqlSessionTemplate被指定，那么作废
sqlSessionFactoryRef="sqlSesssionFactory";
//指定SqlSessionTemplate，将忽略sqlSessionFactory的配置
sqlSessionTemplateRef="sqlSessionTemplate";
//根据接口做限定
//markerInterface=Class.class
//根据注解做限制
annotationClass=Repository.class
)
public class DemoApplication{
......
}
3. mybatis的其他常用配置
＃定义 Mapper 的 XML 路径
mybatis.mapper-locations=......
＃定义另别名名扫描的包， 需要与日Alias 联合使用
mybatis.type-aliases-package=..... .
#MyBatis 配置文件，当你的配置比较复杂的时候，可以使用它
mybatis.config-location=
＃配置 MyBaits 插件（拦截器）
mybatis.configuration.interceptors=
＃具体类需要与@MappedJdbcTypes联合使用
mybatis.type- handlers-package= .
＃级联延迟加载属性配置
mybatis.configuration. aggressive-lazy loading= ..
＃执行器（ Executor 〕，可以配置 SIMPLE , REUSE , BATCH ，默认为 SIMPLE
mybat 工 s.executor - type=