目录

一、搭建Mybatis

二、JUnit测试添加功能

三、加入log4j日志

四、Mybatis的简单增删改查

五、封装SqlSessionUtils工具类并测试功能

六、Mybatis获取参数值的两种方式

七、MyBatis的各种查询功能

八、Mybatis中特殊SQL的执行

九、自定义映射resultMap

十、动态SQL

十一、Mybatis的缓存

十二、Mybatis的逆向工程

一、搭建Mybatis

1、开发环境

• IDE：IntelliJ IDEA 2021.2.3
• 构建工具：Maven 3.6.3
• MySQL版本：MySQL 5.7
• MyBatis版本：3.5.7

2、创建数据库和表

• 创建名为mybatis 的数据库
• 在数据库中新建数据表 t_user 字段如下图所示

3、创建Maven工程，在pom文件中引入依赖

 
        
        
            org.mybatis
            mybatis
            3.5.7
        
        
        
            junit
            junit
            4.12
            test
        
        
        
            mysql
            mysql-connector-java
            5.1.3
        
    

3、创建Mybatis的核心配置文件

• 习惯上命名为 mybatis-config.xml
• 存放的位置是 src/main/resources 目录下
• 核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息

4、创建实体类

• 保证 数据表字段名 和 实体类属性名 一致
• 设置setter、getter方法，有参构造、无参构造和 toString 方法

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String sex;
    private String email;

    public User(Integer id, String username, String password, Integer age, String sex, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    public User() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + ''' +
                ", password='" + password + ''' +
                ", age=" + age +
                ", sex='" + sex + ''' +
                ", email='" + email + ''' +
                '}';
    }
}

5、创建mapper接口

• MyBatis中的mapper接口相当于以前的 dao
• 区别在于，mapper仅仅是接口，不需要提供实现类

public interface UserMapper {
    
    int insertUser();
}

6、创建MyBatis的映射文件

ORM（Object Relationship Mapping）对象关系映射：

• 对象：Java的实体类对象
• 关系：关系型数据库
• 映射：二者之间的对应关系 

映射文件的命名规则：

• 表所对应的实体类的类名+Mapper.xml
• 一个映射文件对应一个实体类，对应一张表的操作
• MyBatis映射文件用于编写SQL，访问以及操作表中的数据
• MyBatis映射文件存放的位置是 src/main/resources/mappers 目录下

MyBatis中可以面向接口操作数据，要保证两个一致：

• mapper接口的 全类名 和映射文件的 命名空间 namespace 保持一致
• mapper接口中方法的 方法名 和映射文件中编写SQL的标签的 id属性 保持一致

    
    
        insert into t_user values(null,'张三','123456',18,'男','123456@qq.com')
    

二、JUnit测试添加功能

在test文件夹下新建 MybatisTest测试类

•  SqlSession：代表Java程序和数据库之间的会话
• SqlSessionFactory：是“生产”SqlSession的“工厂”
• 工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的 相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象。

public class MybatisTest {

    

    @Test
    public void testMyBatis() throws IOException{
        //加载核心配置文件
        InputStream is=Resources.getResourceAsStream("mybatis-config.xml");
        //获取sqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //获取mapper接口对象 通过代理模式创建UserMapper接口的代理实现类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //测试功能
        int result = userMapper.insertUser();
        //提交事务
        sqlSession.commit();
        System.out.println("result: "+result);
    }

}

测试结果，返回受影响的行数

三、加入log4j日志

1、在pom.xml文件中加入依赖

    log4j
    log4j
    1.2.17

2、加入配置文件 log4j.xml

log4j的配置文件名为log4j.xml，存放位置是 src/main/resources 目录下

输出的日志

日志级别：

• FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
• 从左到右打印的内容越来越详细 

四、Mybatis的简单增删改查

先在mapper接口中定义方法，再到相应的映射文件中写sql语句

public interface UserMapper {

    // 添加用户信息
    int insertUser();

    // 删除用户信息
    int deleteUser();

    // 修改用户信息
    int updateUser();

    // 查询查询一个实体类对象
    User getUserById();

    // 查询集合
    List getUserList();

}

1、添加 insert

    
        insert into t_user values(null,'小王','123564',18,'女','234567@qq.com')
    

2、删除 delete

    
    
        delete from t_user where id = 3
    

3、修改 update

    
    
        update t_user set username='xiaowang',password='123333' where id = 2
    

4、查询 select

注意：

1、select标签 必须设置属性 resultType 或 resultMap，用于设置实体类和数据库表的映射关系

• resultType：自动映射，用于属性名和表中字段名一致的情况
• resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况

2、当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常 TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

查询一个实体类对象

    
    
        select * from t_user where id = 2
     
查询集合
 
    
    
        select * from t_user
    

测试修改和删除功能：

t_user 原始数据

1、编写 testUpdate 测试类

    @Test
    public void testUpdate() throws IOException {
        InputStream is=Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int result = userMapper.updateUser();
        System.out.println("result: "+result);
    }

执行结果：修改成功

 2、编写 testDelete 测试类

 @Test
    public void testDelete() throws IOException {
        InputStream is=Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int result = userMapper.deleteUser();
        System.out.println("result: "+result);
    }

执行结果：成功删除id为3的数据

 测试查询功能：

1、编写 testGetUserById 测试类

@Test
    public void testGetUserById() throws IOException {
        InputStream is=Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user=userMapper.getUserById();
        System.out.println(user);
    }

执行结果：查询出id=2的数据

2、 编写 testGetUserList测试类

@Test
    public void testGetUserList() throws IOException {
        InputStream is=Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List list=userMapper.getUserList();
        list.forEach(user -> System.out.println(user));
    }

执行结果：返回所有数据集合

五、封装SqlSessionUtils工具类并测试功能

1、封装SqlSessionUtils工具类

public class SqlSessionUtils {
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sqlSession;
    }
}

2、测试

项目结构：

ParameterMapper 接口：

public interface ParameterMapper {
    //查询所有员工信息
    List getAllUser();
}

ParameterMapper.xml 映射文件：

    
        select * from t_user
    
 
ParameterMapperTest 测试类:
 
public class ParameterMapperTest {

    @Test
    public void testGetAllUser(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper parameterMapper =sqlSession.getMapper(ParameterMapper.class);
        List list=parameterMapper.getAllUser();
        list.forEach(user -> System.out.println(user));
    }
}
 
执行结果：成功返回所有用户的信息
 
 
六、Mybatis获取参数值的两种方式 
 Mybatis获取参数值的两种方式： ${} 和 #{}
 
${} 本质是字符串拼接
#{} 本质是占位符赋值
Mybatis获取参数的各种情况： 
1、参数为单个的字面量类型 
可以通过${}和#{}以任意字符串参数获取参数值，但需要注意${}的单引号问题
 
在ParameterMapper接口中加入 
 
    //根据用户名查询信息
    User getUserByUsername(String username);
 
在ParameterMapper.xml中加入 (利用 #{} 获取参数)
 
    
        select * from t_user where username = #{username}
    

testGetUserByUsername测试类

@Test
    public void testGetUserByUsername(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper parameterMapper =sqlSession.getMapper(ParameterMapper.class);
        User user=parameterMapper.getUserByUsername("xiaowang");
        System.out.println(user);
    }

查看日志,#{}本质就是占位符赋值，传输的参数名不重要，和位置有关

将映射文件中的 #{} 改成 ${} ,再次执行测试类查看结果

 查看日志，发现参数缺少引号，${} 本质是字符串拼接，需要自己加上引号

 

 2、参数为多个字面量类型

在ParameterMapper接口中加入 

    //验证登录
    User ckeckLogin(String username,String password);

 在ParameterMapper.xml中加入 (利用 #{} 获取参数)

    
        select * from t_user where username = #{username} and password = #{password}
     
testCheckLogin测试类
 
@Test
    public void testCheckLogin(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper parameterMapper =sqlSession.getMapper(ParameterMapper.class);
        User user=parameterMapper.ckeckLogin("张三",123456);
        System.out.println(user);
    }
 
执行结果：报错
 
 
原因：当mapper接口中的方法参数为多个时，MyBatis会自动将这些参数放在一个map集合中，
 
以两种方式存储数据：
 
以arg0,arg1...为键，以参数为值；
以 param1,param2...为键，以参数为值；
因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号
修改ParameterMapper.xml中的内容
 
 
 同样的使用${}需要手动加单引号
 
成功返回对应的用户信息
 
 
3、参数为map集合类型 
mapper接口中的方法需要的参数为多个时，可以手动创建map集合，将这些数据放在map中
只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号
与第二种情况相比，可以自行设置map集合中键的值
在ParameterMapper接口中加入 
 
 //验证登录（参数为map)
    User checkLoginByMap(Map map);
 
 在ParameterMapper.xml中加入 (利用 #{} 获取参数)
 
    
        select * from t_user where username = #{username}  and password =#{password}
    

testCheckLoginByMap测试类

  @Test
    public void testCheckLoginByMap(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper parameterMapper =sqlSession.getMapper(ParameterMapper.class);
        Map map=new HashMap<>();
        map.put("username","张三");
        map.put("password","123456");
        User user=parameterMapper.checkLoginByMap(map);
        System.out.println(user);
    }

执行结果：成功返回对应用户信息

4、参数为实体类类型

• mapper接口中的方法参数为实体类对象时可以使用${}和#{}，
• 通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

在ParameterMapper接口中加入 

    //添加用户信息
    int insertUser(User user);

在ParameterMapper.xml中加入 (利用 #{} 获取参数,通过属性名获取属性值)

    
        insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
    

testInsertUser测试类

 @Test
    public void testInsertUser(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper parameterMapper =sqlSession.getMapper(ParameterMapper.class);
        int result=parameterMapper.insertUser(new User(null,"小蓝","123455",22,"男","654872@123.com"));
        System.out.println(result);
    }

执行结果：成功添加用户信息

5、使用@Param命名参数

• 通过@Param注解标识mapper接口中的方法参数
• Mybatis会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值
• 或者以 param1,param2...为键，以参数为值
• 只需要通过${}和#{}访问map集合的键就可以获取相对应的值， 注意${}需要手动加单引号

在ParameterMapper接口中加入 

//验证登录(使用@Param)
    User checkLoginByParam(@Param("username")String username,@Param("password") String password);

在ParameterMapper.xml中加入 (利用 #{} 获取参数)

    
        select * from t_user where username = #{username}  and password =#{password}
     
testCheckLoginByParam测试类
 
 @Test
    public void testCheckLoginByParam(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper parameterMapper =sqlSession.getMapper(ParameterMapper.class);
        User user=parameterMapper.checkLoginByParam("张三","123456");
        System.out.println(user);
    }
 
执行结果：成功查询出对应的用户信息
 
七、MyBatis的各种查询功能 
 新建SelectMapper接口、SelectMapper.xml映射文件、SelectMapperTest测试类
 
 
1、查询一个实体类对象 
若查询出的数据只有一条，可以通过实体类对象接收
若查询出的数据有多条，一定不能通过实体类对象接收，会抛出异常TooManyResultsException
SelectMapper接口
 
public interface SelectMapper {
    //根据id查询用户信息
    User getUserById(@Param("Id") Integer id);
}
 
SelectMapper.xml
 




    
        select * from t_user where id = #{Id}
    

SelectMapperTest测试类中的testGetUserById

public class SelectMapperTest {
    @Test
    public void testGetUserById(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SelectMapper selectMapper=sqlSession.getMapper(SelectMapper.class);
        User user=selectMapper.getUserById(2);
        System.out.println(user);
    }
}

执行结果：成功返回id=2的用户信息 

2、查询一个list集合

• 查询出的数据有多条，可以通过list集合接收

SelectMapper接口加入

    //查询所有用户信息
    List getUserList();

SelectMapper.xml 加入

    
        select * from t_user
     
testGetUserList测试类
 
 @Test
    public void testGetUserList(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SelectMapper selectMapper=sqlSession.getMapper(SelectMapper.class);
        List list=selectMapper.getUserList();
        list.forEach(user -> System.out.println(user));
    }
 
执行结果：成功返回所有用户信息 
 
 
3、查询单个数据 
SelectMapper接口加入
 
    //查询用户信息的总记录数
    Integer getCount();
 
SelectMapper.xml 加入
 
    
        select count(*) from t_user
    

testGetCount测试类

 @Test
    public void testGetCount(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SelectMapper selectMapper=sqlSession.getMapper(SelectMapper.class);
        System.out.println(selectMapper.getCount());
    }

执行结果：返回t_user表的记录数

4、查询一条数据为map集合

SelectMapper接口加入

    //根据id用户信息为一个map集合
    Map getUserByIdToMap(@Param("Id") Integer id)

SelectMapper.xml 加入

    
        select * from t_user where id = #{Id}
     
testGetUserByIdToMap测试类
 
  @Test
    public void testGetUserByIdToMap(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SelectMapper selectMapper=sqlSession.getMapper(SelectMapper.class);
        System.out.println(selectMapper.getUserByIdToMap(2));
    }
 
执行结果：返回 以字段为键，以字段对应的值为值 的map集合
 
5、查询多条数据为map集合 
方法一： 
表中的数据以map集合的方式查询，一条数据对应一个map；
若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取
SelectMapper接口加入
 
    //查询所有用户信息为map集合
    List> getAllUserToMap();
 
SelectMapper.xml 加入
 
    
        select * from t_user
    

testGetAllUserToMap测试类

    @Test
    public void testGetAllUserToMap1(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SelectMapper selectMapper=sqlSession.getMapper(SelectMapper.class);
        System.out.println(selectMapper.getAllUserToMap());
    }

执行结果：

方法二：

• 要以一个map的方式返回数据，需要通过@MapKey注解设置map集合的键
• 值是每条数据所对应的map集合

    //查询所有用户信息为map集合
    @MapKey("id")
    Map getAllUserToMap();

执行结果：id为键，每条数据所对应的map集合为值 的map集合

八、Mybatis中特殊SQL的执行

新建SQLMapper接口，SQLMapper.xml 及 SQLMapperTest测试类

1、模糊查询

SQLMapper接口

public interface SQLMapper {
    //根据用户名模糊查询用户信息
    List getUserByLike(@Param("username") String username);
}

SQLMapperTest测试类中的testGetUserByLike

public class SQLMapperTest {
    @Test
    public void testGetUserByLike(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SQLMapper sqlMapper=sqlSession.getMapper(SQLMapper.class);
        List list=sqlMapper.getUserByLike("小");
        System.out.println(list);
    }
}

方案一： ${} 接收参数

    
        select * from t_user where username like '%${username}%'
     
方案二：concat 字符串拼接 
    
        select * from t_user where username like concat('%',#{username},'%')
    

方案三：用双引号包含%拼接

    
        select * from t_user where username like "%"#{username}"%"
     
查询结果
 
 
2、批量删除 
批量删除sql语句中不能使用 #{ }
 
SQLMapper接口
 
    //批量删除
    int deleteMore(@Param("Ids") String ids);
 
SQLMapper.xml
 
    
        delete from t_user where id in (${Ids})
    
 
testDeleteMore测试类
 
 @Test
    public void testDeleteMore(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SQLMapper sqlMapper=sqlSession.getMapper(SQLMapper.class);
        int result = sqlMapper.deleteMore("4,5");
        System.out.println(result);
    }
 
执行结果： 成功删除id为4、5的用户数据
 
 
 
3、动态设置表名 
动态设置表名sql语句中不能使用 #{ }
 
SQLMapper接口
 
 //查询指定表中的数据
    List getUserByTableName(@Param("tableName") String tableName);
 
SQLMapper.xml
 
    
        select * from ${tableName}
    

testGetUserByTableName测试类

    @Test
    public void testGetUserByTableName(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SQLMapper sqlMapper=sqlSession.getMapper(SQLMapper.class);
        List list=sqlMapper.getUserByTableName("t_user");
        list.forEach(user -> System.out.println(user));
    }

执行结果： 成功查询出表t_user的用户数据

4、添加功能获取自增的主键

• useGeneratedKeys：设置使用自增的主键
• keyProperty：将自增的主键的值赋值给传输到映射文件中参数的某个属性

SQLMapper接口

    //添加用户信息
    void insertUser(User user);

SQLMapper.xml

因为增删改有统一的返回值是受影响的行数，

因此只能将获取的自增的主键放在传输的参 数user对象的id中

    
        insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
    

testInsertUser测试类 这里传入的id为null,自动递增

    @Test
    public void testInsertUser(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        SQLMapper sqlMapper=sqlSession.getMapper(SQLMapper.class);
        User user=new User(null,"王五","135659",21,"男","12356@123.com");
        sqlMapper.insertUser(user);
        System.out.println(user);
    }

执行结果：执行完添加操作之后，user对象的id属性的值为自增的主键

九、自定义映射resultMap

新建两个新的数据表 t_emp t_dept

 加入数据

创建Emp、Dept实体类、mapper接口、映射文件

实体类Emp

public class Emp {
    private Integer eid;

    private String empName;

    private Integer age;

    private String sex;

    private String email;

    public Emp(Integer eid, String empName, Integer age, String sex, String email) {
        this.eid = eid;
        this.empName = empName;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    public Emp() {
    }

    public Integer getEid() {
        return eid;
    }

    public void setEid(Integer eid) {
        this.eid = eid;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "eid=" + eid +
                ", empName='" + empName + ''' +
                ", age=" + age +
                ", sex='" + sex + ''' +
                ", email='" + email + ''' +
                '}';
    }
}

EmpMapper接口

public interface EmpMapper {
    //查询所有员工信息
    List getAllEmp();
}

EmpMapper.xml

    
        select * from t_emp
    
 
 项目结构
 
 
 1、resultMap处理字段和属性的映射关系 
数据表中的字段名为emp_name,实体类中的属性名为empName
 
 
不会报错，empName字段返回null,字段和属性不一致映射不了
 
 
解决字段名的属性名不一致的情况： 
方案一：给字段起别名 
通过给字段起别名，保证属性名和字段名一致
 
    
        select eid,emp_name empName,age,sex,email from t_emp
    

方案二：设置全局配置

在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，

在查询表中数据时，自动将下划线类型的字段名转换为驼峰类型 emp_name -> empName

方式三：通过resultMap设置自定义映射关系

resultMap属性：

• id：表示自定义映射的唯一标识
• type：查询的数据要映射的实体类的类型

子标签：

• id：设置主键的映射关系
• result：设置普通字段的映射关系
• association：设置多对一的映射关系
• collection：设置一对多的映射关系

属性：

• property：设置映射关系中实体类中的属性名
• column：设置映射关系中表中的字段名

    

        

        
        
        
        
    

    
        select * from t_emp
     
 
2、多对一映射处理 
查询员工信息以及员工所对应的部门信息
 
public interface EmpMapper {

    //查询员工信息以及员工所对应的部门信息
    Emp getEmpAndDept(@Param("eid") Integer eid);

}
 
多对一关系在 多 的一方创建 一 所对于的对象
 
在员工实体类中创建部门对象，并生成getter、setter方法，重新生成toString方法
 
 
方案一：通过级联属性赋值解决多对一映射关系 
    
        
        
        
        
        

        
        
        
    
    
        select * from t_emp left join t_dept on t_emp.did = t_dept.did
        where t_emp.eid = #{eid}
    

方案二：通过association处理映射关系

association属性：

• property：设置映射关系中实体类中的属性名
• column：指定表中对应字段
• javaType: 指定映射到实体对象属性的类型
• select：指定引入嵌套子查询的子SQL语句，用于关联映射中的嵌套查询
• fetchType：指定在关联查询时是否启用延迟加载

 
        
        
        
        
        

        
            
            
        

    

    
        select * from t_emp left join t_dept on t_emp.did = t_dept.did
        where t_emp.eid = #{eid}
     
方案三：分步查询 
1、查询员工信息
 
public interface EmpMapper {
   
    //分步查询查询员工信息以及员工所对应的部门信息
    //第一步 查询员工信息
    Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

}
 
EmpMapper.xml
 
select：设置分步查询的sql的唯一标识( namespace.SQLId 或 mapper接口的全类名.方法名 )
column：将sql以及查询结果中的某个字段设置为分步查询的条件
  
    
        
        
        
        
        
        
        
    

    
        select * from t_emp where eid = #{eid}
    

2、根据员工所对应的部门id查询部门信息

public interface DeptMapper {

    //分步查询查询员工信息以及员工所对应的部门信息
    //第二步 通过did查询员工所对应的部门信息
    Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);
}

DeptMapper.xml

    
        select * from t_dept where did = #{did}
    

 
查询结果：
 
 
分步查询的优点：
 
可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：
 
lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
 
可以实现按需加载，获取的数据是什么，就只会执行相应的sql
 
    
        
        
    
 
 association中的 fetchType 属性
 
当开启全局延迟加载后，可以通过此属性手动控制延迟加载效果
 
fetchType="lazy"         延迟加载
fetchType="eager"      立即加载
3、一对多映射处理 
获取部门及部门中所有员工的信息
 
一对多关系，在Dept部门实体类中创建Emp员工集合，并生成getter、setter方法，toString方法
 
 
public interface DeptMapper {

    //获取部门以及部门中所有员工的信息
    Dept getDeptAndEmp(@Param("did") Integer did);
}
 
方案一：collection处理一对多映射 
collection子元素的属性大部分与association元素相同，但其包含特殊属性ofType
 
ofType：设置collection标签所处理的集合属性中存储数据的类型
 





    
        
        
        
        
            
            
            
            
            
        
    

    
        select * from t_dept left join t_emp on t_dept.did = t_emp.did
        where t_dept.did = #{did}
    

方案二：分步查询

 1、询部门信息

public interface DeptMapper {

    //分步查询部门以及部门中所有员工的信息
    //第一步 查询部门信息
    Dept getDeptAndEmpByStepOne(@Param("did") Integer did);
}

DeptMapper.xml

    
        
        
        
        
    

    
        select * from t_dept where did = #{did}
     
2、根据did查询员工信息
 
public interface EmpMapper {
   
    //分步查询部门以及部门中所有员工的信息
    //第二步 根据did查询员工信息
    List getDeptAndEmpByStepTwo(@Param("did") Integer did);

}
 
EmpMapper.xml
 
    
        select * from t_emp where did = #{did}
    

查询结果：

十、动态SQL

• Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能
• 它存在的意义是为了解决拼接SQL语句字符串时的痛点问题

1、if

if:根据标签中text属性所对应的表达式决定标签中的内容是否需要拼接到SQL中

DynamicSQLMapper

public interface DynamicSQLMapper {
    //多条件查询
    List getEmpByCollection(Emp emp);
}

DynamicSQLMapper.xml

    
        select * from t_emp where 1=1
        
            and emp_name = #{empName}
        
        
            and age = #{age}
        
        
            and sex = #{sex}
        
        
            and email = #{email}
        
    

 
testGetEmpByCollection 测试类
 
public class DynamicSQLMapperTest {

    @Test
    public void testGetEmpByCollection(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        DynamicSQLMapper dynamicSQLMapper =sqlSession.getMapper(DynamicSQLMapper.class);
        List list =dynamicSQLMapper.getEmpByCollection(
                new Emp(null,null,32,"男","123@qq.com"));
        System.out.println(list);
    }
}
 
执行结果：
 
 
2、where 
where 和 if 一般结合使用
当where标签有内容时会自动生成 where 关键字
将内容前多余的 and 或 or 去掉
注意：where标签不能去掉其中内容后多余的 and 或 or
 
若标签中没有任何内容 where 标签没有任何效果
 
  
    
        select * from t_emp
        
            
                emp_name = #{empName}
            
            
                and age = #{age}
            
            
                and sex = #{sex}
            
            
                and email = #{email}
            
        
    

执行结果： 

3、trim

trim属性：

• prefix：将 trim 标签中内容前面添加指定内容
• prefixOverrides：在trim标签中的内容前面去掉某些内容
• suffix：将 trim 标签中内容后面添加指定内容
• suffixOverrides：在 trim 标签中的内容后面去掉某些内容

若标签中没有任何内容 trim 标签没有任何效果

 
    
        select * from t_emp
        
            
                emp_name = #{empName} and
            
            
                age = #{age} or
            
            
                sex = #{sex} and
            
            
                email = #{email}
            
        
     
 执行结果：
 
 
4、choose、when、otherwise 
相当于 if ... else if ... else结构 或者 switch ... case...default结构
when 至少要有一个
otherwise 最多只能有一个
public interface DynamicSQLMapper {

    //测试choose when otherwise
    List getEmpByChoose(Emp emp);
}
 
    
        select * from t_emp
        
            
                
                    emp_name=#{empName}
                
                
                    age=#{age}
                
                
                    sex=#{sex}
                
                
                    email=#{email}
                
                
                
                    did = 1
                
            
        
    

 @Test
    public void testGetEmpByChoose(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        DynamicSQLMapper dynamicSQLMapper =sqlSession.getMapper(DynamicSQLMapper.class);
        List list =dynamicSQLMapper.getEmpByChoose(
                new Emp(null,"张三",32,"男","123@qq.com"));
        System.out.println(list);
    }

多个条件成立，拼接第一个成立的 when 中的内容

 所有条件都不成立，拼接 otherwise 中的内容

5、foreach

foreach属性：

• collection：设置需要循环的数组或集合
• item：表示数组或集合中的每一个数据
• separator：循环体之间的分隔符
• open：foreach标签所循环的所有内容的开始符
• close：foreach标签所循环的所有内容的结束符

通过数组实现批量删除

public interface DynamicSQLMapper {

    //通过数组实现批量删除
    int deleteMoreByArray(@Param("eids") Integer[] eids);
}

在数据表t_emp中增加几条测试数据

 DynamicSQLMapper.xml中加入

    
        delete from t_emp where eid in
        (
        
            #{eid}
        
        )
    

@Test
    public void testDeleteMoreByArray(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        DynamicSQLMapper dynamicSQLMapper =sqlSession.getMapper(DynamicSQLMapper.class);
        int result=dynamicSQLMapper.deleteMoreByArray(new Integer[]{6,7,8});
        System.out.println(result);

    }

执行结果：

通过集合批量添加 

public interface DynamicSQLMapper {

    //通过list集合实现批量添加
    int insertMoreByList(@Param("emps") List emps);
}

DynamicSQLMapper.xml中加入

    insert into t_emp values
    
        (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
    

    @Test
    public void testInsertMoreByList(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        DynamicSQLMapper dynamicSQLMapper =sqlSession.getMapper(DynamicSQLMapper.class);
        Emp emp1=new Emp(null,"小刘",22,"男","12345@qq.com");
        Emp emp2=new Emp(null,"小吴",26,"女","12345@qq.com");
        Emp emp3=new Emp(null,"小何",21,"男","12345@qq.com");
        List list=Arrays.asList(emp1,emp2,emp3);
        int result=dynamicSQLMapper.insertMoreByList(list);
        System.out.println(result);
    }
}

执行结果：

6、SQL片段

• sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入
• sql标签设置sql片段 如： eid,emp_name,age,sex,email 
• include标签引入sql片段 如：

    
        eid,emp_name,age,sex,email
    

    
    
        select  from t_emp
        
            
                emp_name = #{empName} and
            
            
                age = #{age} or
            
            
                sex = #{sex} and
            
            
                email = #{email}
            
        
     
 @Test
    public void testGetEmpByCondition(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        DynamicSQLMapper dynamicSQLMapper =sqlSession.getMapper(DynamicSQLMapper.class);
        List list =dynamicSQLMapper.getEmpByCollection(
                new Emp(null,"张三",32,"男","123@qq.com"));
        System.out.println(list);
    }
 
执行结果：
 
 
十一、Mybatis的缓存 
缓存仅对查询功能有效
 
1、Mybatis的一级缓存 
一级缓存默认开启
一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存
下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问
新建CacheMapper接口,CacheMapper.xml，CacheMapperTest测试类
 
public interface CacheMapper {

    Emp getEmpByEid(@Param("eid") Integer eid);
}
 




    
        select * from t_emp where eid = #{eid}
    

public class CacheMapperTest {

    @Test
    public void testCache(){
        SqlSession sqlSession= SqlSessionUtils.getSqlSession();
        CacheMapper cacheMapper=sqlSession.getMapper(CacheMapper.class);
        Emp emp = cacheMapper.getEmpByEid(1);
        System.out.println(emp);
    }
}

执行结果：

 增加一个查询，再查询一次相同的数据

 结果只输出一条SQL语句，说明第二次查询没有执行SQL，是从缓存中获取数据

 一级缓存失效的四种情况：

1. 不同的SqlSession对应不同的一级缓存
2. 同一个SqlSession但是查询条件不同
3. 同一个SqlSession两次查询期间执行了任何一次增删改操作
4. 同一个SqlSession两次查询期间手动清空了缓存 SqlSession.clearCache()

2、Mybatis的二级缓存

• 二级缓存需要手动开启
• 二级缓存是SqlSessionFactory级别
• 通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存
• 此后若再次执行相同的查询语句，结果就会从缓存中获取

开启二级缓存

1. 在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
2. 在映射文件中设置标签 cache
3. 二级缓存必须在SqlSession关闭或提交之后有效 SqlSession.commit() SqlSession.close()
4. 查询的数据所转换的实体类类型必须实现序列化的接口 implements Serializable

   @Test
    public void testTwoCache(){
        try{
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            SqlSession sqlSession1=sqlSessionFactory.openSession(true);
            CacheMapper cacheMapper1=sqlSession1.getMapper(CacheMapper.class);
            System.out.println(cacheMapper1.getEmpByEid(1));
            sqlSession1.close();
            SqlSession sqlSession2=sqlSessionFactory.openSession(true);
            CacheMapper cacheMapper2=sqlSession2.getMapper(CacheMapper.class);
            System.out.println(cacheMapper2.getEmpByEid(1));
            sqlSession2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

执行结果：

二级缓存失效的情况：

两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

二级缓存相关配置--cache标签中的属性

eviction:

• LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象
• FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们
• SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象
• WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象
• 默认是 LRU

flushInterval：

• 刷新间隔，单位毫秒
• 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

size：

• 引用数目，正整数
• 代表缓存最多可以存储多少个对象，太大容易导致内存溢出

readOnly：true/false

• true：只读缓存
• 会给所有调用者返回缓存对象的相同实例，调用者只能读不能写
• false：读写缓存
• 会返回缓存对象的拷贝（通过序列化）会慢一些，但是安全，默认是 false

3、Mybatis缓存的查询顺序

二级缓存对应多个SqlSession,一级缓存对应一个SqlSession

一级缓存和二级缓存同时有效，先搜索大范围在搜索小范围

• 先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
• 如果二级缓存没有命中，再查询一级缓存
• 如果一级缓存也没有命中，则查询数据库
• SqlSession关闭之后，一级缓存中的数据会写入二级缓存

十二、Mybatis的逆向工程

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。

逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：

• Java实体类
• Mapper接口
• Mapper映射文件

1、创建逆向工程的步骤

①新建一个空项目 Mybatis_MBG

②添加依赖插件

  
    
        
            org.mybatis
            mybatis
            3.5.7
        
    
    
    
        
        
            
            
                org.mybatis.generator
                mybatis-generator-maven-plugin
                1.3.0
                
                
                    
                    
                        org.mybatis.generator
                        mybatis-generator-core
                        1.3.2
                    
                    
                    
                        com.mchange
                        c3p0
                        0.9.2
                    
                    
                    
                        mysql
                        mysql-connector-java
                        5.1.8
                    
                
            
        
    

③创建MyBatis的核心配置文件

④创建逆向工程配置文件，文件名必须是 generatorConfig.xml

    
    
        
        
        
        
        
            
            
        
        
        
            
        
        
        
            
        
        
        
        
        
⑤双击执行mybatis-generator插件
生成效果：

转载请注明：文章转载自 www.mshxw.com
本文地址：https://www.mshxw.com/it/820905.html

   上一篇  微服务部署，前端post请求出现UTF-8错误
 
   下一篇  多个vue项目以不同的端口部署到同一个Tomcat中
  



Java相关栏目本月热门文章

  
1【Linux驱动开发】设备树详解（二）设备树语法详解
  
2别跟客户扯细节
  
3Springboot+RabbitMQ+ACK机制(生产方确认(全局、局部)、消费方确认)、知识盲区
  
4【Java】对象处理流（ObjectOutputStream和ObjectInputStream）
  
5【分页】常见两种SpringBoot项目中分页技巧
  
6一文带你搞懂OAuth2.0
  
7我要写整个中文互联网界最牛逼的JVM系列教程 | 「JVM与Java体系架构」章节：虚拟机与Java虚拟机介绍
  
8【Spring Cloud】新闻头条微服务项目：FreeMarker模板引擎实现文章静态页面生成
  
9JavaSE - 封装、static成员和内部类
  
10树莓派mjpg-streamer实现监控及拍照功能调试
  
11用c++写一个蓝屏代码
  
12从JDK8源码中看ArrayList和LinkedList的区别
  
13idea 1、报错java: 找不到符号 符号: 变量 log 2、转换成Maven项目
  
14在openwrt使用C语言增加ubus接口（包含C uci操作）
  
15Spring 解决循环依赖
  
16SpringMVC——基于MVC架构的Spring框架
  
17Andy‘s First Dictionary C++ STL set应用
  
18动态内存管理
  
19我的创作纪念日
  
20Docker自定义镜像-Dockerfile




热门相关搜索



路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名






学习工具
代数计算器
三角函数
解析几何
立体几何


知识解答
教育知识
百科知识
生活知识
常识知识


写作必备
作文大全
作文素材
句子大全

实用范文


关于我们
关于我们
联系我们
网站地图


 
名师互学网交流群


名师互学网客服





名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 




关于我们
文章归档
网站地图
联系我们
版权所有 (c)2021-2022 MSHXW.COM
ICP备案号：晋ICP备2021003244-6号