数据库访问

一、数据源的配置

在依赖于 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就可以了 。 注解＠MappedJdbcTypes 声明 JdbcType 为数据库的整型，＠MappedTypes 声 明 JavaType
为 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=

数据库访问

原文：https://www.cnblogs.com/yanquhonggui/p/11105540.html