在IDEA2021-2中使用MyBatis

目录

• 前言
• 一、准备工作
• • 1、进入Mybatis官网
  • 2、新建maven空项目
  • 3、配置pom.xml
  • 4、新建module
  • 5、连接数据库
• 二、配置mybatis相关
• • 1、新建mybatis-config.xml（核心配置文件）
  • 2、编写mybatis工具类
  • 3、实体类
  • 4、dao接口
  • 5、接口实现（xml映射文件）
  • 6、测试
• 三、CRUD测试
• • 1、根据id查询用户
  • 2、增删改
  • 3、map
  • 4、模糊查询
• 四、对配置文件的深度解析
• • 1、环境配置（environments）
  • 2、属性（properties）
  • 3、类型别名（typeAliases）
  • 4、设置（settings）
  • 5、映射器（mappers）
  • 6、作用域（Scope）和生命周期
• 五、属性名和字段名不一致的解决方法
• • 1、在 SELECt 语句中给字段名起别名
  • 2、在xml中使用结果映射（resultMap）
• 六、日志
• • 1、STDOUT_LOGGING（标准日志输出）
  • 2、LOG4J
• 七、分页
• • 1、熟悉sql语句
  • 2、使用Offset /Fetch Next
  • 3、使用RowBounds
  • 4、分页插件（Mybatis PageHelper）
• 八、使用注解开发
• • 1、新建module
  • 2、修改几个文件
  • 3、CRUD
• 九、复杂查询环境搭建
• • 1、建表
  • 2、新建module并测试
  • 3、多对一的处理
  • 4、一对多的处理
• 十、动态sql
• • 1、建表
  • 2、新建module
  • 3、if
  • 4、where
  • 5、choose、when、otherwise
  • 6、set
  • 7、trim
  • 8、foreach
  • 9、SQL片段
• 十一、缓存

前言

我是跟随狂神的B站教学视频以及mybatis官网学习的，狂神B站传送门：https://www.bilibili.com/video/BV1NE411Q7Nx
喜欢看视频的直接去看就行了，讲的非常nice

用到的数据库表名user我改成了login，因为user是sql server关键字（老师用的mysql，我用的sql server）
其他步骤大致相同，相当于我的学习笔记，掺杂了一些个人见解
只想学基础增删改查的看完前三部分就行

我的学习顺序：MyBatis=>Spring=>SpringMVC=>SpringBoot
其他相关博客会陆续发布…

一、准备工作

什么是 MyBatis？
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1、进入Mybatis官网

传送门 https://mybatis.org/mybatis-3/zh/index.html
点击侧边栏中的 入门
可以看到在maven中的依赖代码

2、新建maven空项目

点击next,项目命名为mybatis

点击finish
删除src，方便新建module

3、配置pom.xml

1）导入三个依赖 mssql-jdbc、mybatis、junit

 
     
     
         com.microsoft.sqlserver
         mssql-jdbc
         9.4.0.jre16
     

     
     
         org.mybatis
         mybatis
         3.5.6
     

     
         junit
         junit
         4.12
     
     
 

2）再配置build中的resources节点，防止无法导出配置文件（所有pom文件都要做此修改）

 
        
        
            
                src/main/resources
                
                    ***.xml
                
                true
            
            
                src/main/java
                
                    ***.xml
                
                true
            
        
    

4、新建module

命名test

可以看到父子项目的依赖完全相同

5、连接数据库

连接名为test的数据库

二、配置mybatis相关 1、新建mybatis-config.xml（核心配置文件）

只要修改四处，把对应的value修改即可

2、编写mybatis工具类

新建MybatisUtils类

我们需要从 XML 中构建 SqlSessionFactory
再从 SqlSessionFactory 中获取 SqlSession

package com.jiyu.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    //1、从 XML 中构建 SqlSessionFactory
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //2、从 SqlSessionFactory 中获取 SqlSession
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

3、实体类

1）数据库建表login

增加数据

2）建立Login类

4、dao接口

新建LoginDao接口

接口中的方法

5、接口实现（xml映射文件）

一个sql语句既可以通过 XML 定义，也可以通过注解定义。
先看xml的方法
新建LoginMapper.xml（以后实现接口方法的xml文件都简称xml映射文件）

    
        select * from login
    

 
修改以下四处即可
 
 
6、测试 
1）先在核心配置文件中注册mapper
 修改一处代表Mapper.xml文件路径的代码即可
 
 2）在测试文件中新建LoginDaoTest
 
 
package com.jiyu.dao;

import com.jiyu.entity.Login;
import com.jiyu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;


public class LoginDaoTest {
    @Test
    public void test(){
        //获得sqlSession
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方法一：getMapper
        LoginDao loginDao = sqlSession.getMapper(LoginDao.class);
        List loginList = loginDao.getLoginList();

        //方法二：selectList（不太好）
        //List loginList = sqlSession.selectList("com.jiyu.dao.LoginDao.getLoginList");

        for(Login login:loginList){
            System.out.println(login);
        }

        //关闭sqlSession
        sqlSession.close();
    }
}

 
运行后显示结果
 
 
三、CRUD测试 
之前建立的接口LoginDao是为了方便理解
 现在改名为LoginMapper
 
 
1、根据id查询用户 
1）在接口（LoginMapper.java）中，建立方法
 
Login getLoginById(int id);
 
2）在对应的xml映射文件（LoginMapper.xml）中编写对应sql语句
 

        select * from login where id=#{id}

3）在测试文件（LoginDaoTest.java）测试

@Test
    public void getLoginById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        Login login = mapper.getLoginById(1);
        System.out.println(login);

        sqlSession.close();
    }

结果正确

总结：增删改查都是三步：
1、编写接口中的方法
2、编写对应xml映射文件（要在核心配置文件中注册mapper），主要写sql语句
3、测试
但是增删改需要提交事务，代码有一点不同

2、增删改

增删改的步骤和查找一样，只是在测试时需要提交事务
下面直接贴代码

1）接口（LoginMapper.java）

package com.jiyu.dao;

import com.jiyu.entity.Login;

import java.util.List;

public interface LoginMapper {
    //查询全部用户
    List getLoginList();

    //根据id查询用户
    Login getLoginById(int id);

    //增加一个用户
    int addLogin(Login login);

    //修改用户
    int updateLogin(Login login);

    //删除一个用户
    int deleteLogin(int id);
}

2）xml映射文件（LoginMapper.xml）

    
        select * from login
    

    
        select * from login where id=#{id}
    

    
        insert into login (id,name,pwd) values (#{id},#{name},#{pwd})
    
    
    
        update login
        set name = #{name},pwd=#{pwd}
        where id=#{id};
    

    
        delete
        from login
        where id=#{id};
    

3）测试（LoginDaoTest.java）

package com.jiyu.dao;

import com.jiyu.entity.Login;
import com.jiyu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;


public class LoginDaoTest {
    @Test
    public void test(){
        //获得sqlSession
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方法一：getMapper
        LoginMapper loginDao = sqlSession.getMapper(LoginMapper.class);
        List loginList = loginDao.getLoginList();

        //方法二：selectList（不太好）
        //List loginList = sqlSession.selectList("com.jiyu.dao.LoginDao.getLoginList");

        for(Login login:loginList){
            System.out.println(login);
        }

        //关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void getLoginById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        Login login = mapper.getLoginById(1);
        System.out.println(login);

        sqlSession.close();
    }

    //增删改需要提交事务  sqlSession.commit()
    @Test
    public void addLogin(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        int res = mapper.addLogin(new Login(4, "zhaosi", "zhaosipass"));
        if(res>0){
            System.out.println("success!");
        }

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void updateLogin(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        mapper.updateLogin(new Login(4,"zhaosisi","zhaosipass"));

        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void deleteLogin(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        mapper.deleteLogin(4);

        sqlSession.commit();
        sqlSession.close();
    }
}

3、map

数据库表的字段或者实体类参数过多，考虑使用map
map传参，在sql中取出key即可
对象传参，在sql中取出对象的属性即可
只有一个基本类型参数时，可以直接在sql中取到
多个参数用map或者注解

下面是两个例子
主要是利用map.put()方法建立一个map后，作为参数将多个数据传入sql

1、addLogin2：增加Login

1）接口

int addLogin2(Map map);

2）xml映射文件

        insert into login (id, name, pwd)
        values (#{userId},#{userName},#{password});

3）测试

@Test
    public void addLogin2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        Map map = new HashMap<>();

        map.put("userId",5);
        map.put("userName","wangwu");
        map.put("password","wangwupass");

        mapper.addLogin2(map);

        sqlSession.commit();
        sqlSession.close();
    }

2、getLoginById2：通过id获取Login

1）接口

    Login getLoginById2(Map map);

2）xml映射文件

        select * from login where id=#{id} and name=#{name};

 
3）测试
 
@Test
    public void getLoginById2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        Map map = new HashMap<>();

        map.put("id",1);
        map.put("name","jiyu");

        Login login = mapper.getLoginById2(map);
        System.out.println(login);

        sqlSession.close();
    }
 
4、模糊查询 
1）接口
 
    List getLoginLike(String value);
 
2）xml映射文件
 方法一（较为安全）
 

        select * from login where name like #{value};

方法二（容易sql注入）

        select * from login where name like "%"#{value}"%";

 
3）测试(如果使用方法二，则将"%李%“改为"李”）
 
 @Test
    public void getLoginLike(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        List loginList = mapper.getLoginLike("%李%");

        for(Login login:loginList){
            System.out.println(login);
        }

        sqlSession.close();
    }
 
四、对配置文件的深度解析 
1、环境配置（environments） 
 
 
每个数据库对应一个 SqlSessionFactory 实例
 每个 SqlSessionFactory 实例只能选择一种环境
 
 
在核心配置文件mybatis-config.xml中，可以配置多个environment
 如图建立了id为test的环境
 
 可以通过设置默认使用的环境为test
 下面的代码分别表示事务管理器和数据源的类型
 

            
 
2、属性（properties） 
 
 
属性可以在外部进行配置，并可以进行动态替换。
 既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置
 
 
 
 
如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：
 
 
首先读取在 properties 元素体内指定的属性。 然后根据 properties 元素中的 resource属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。
 因此，通过方法参数传递的属性具有最高优先级，resource/url属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。
 
 
以下是编写配置文件的示例
 
1）新建db.properties
 
 
driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
url=jdbc:sqlserver://localhost:1433;databaseName=test
username=sa
password=123456
 
2）在核心配置文件中引入
 先通过引入外部配置文件
 再通过修改默认环境为test
 在test环境中，修改四个value值即可
 以后修改连接的数据库就可以在db.properties文件中修改了（无需改动核心配置文件）
 
 
3、类型别名（typeAliases） 
 
 
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写
 
 
1）typeAlias
 在mybatis-config.xml核心配置文件中输入
 

        

 
在LoginMapper.xml映射文件中,原本法人resultType为com.jiyu.entity.Login
 此时可以更改为别名Login
 

 2）package
 
 
 
也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean。
 
 

        

 
 
 
每一个在包 com.jiyu.entity 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 com.jiyu.entity.Login 的别名为 login；若有注解，则别名为其注解值。
 
 
@Alias("login")
public class Login {
    ...
}
 
4、设置（settings） 
 
 
MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为
 
 
下面几个是比较重要的
 
 

 在遇到日志时会进行讲解
 
5、映射器（mappers） 
 
 
既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。
 
 
 
 
这些配置会告诉 MyBatis 去哪里找映射文件，剩下的细节就应该是每个 SQL 映射文件了
 
 
1）使用相对于类路径的资源引用（推荐使用）
 

        

 
2）使用映射器接口实现类的完全限定类名
 

        

 
 
 
注意该方法的使用限制：
 接口和对应的Mapper配置文件必须同名且在同一个文件夹下！
 
 
3）将包内的映射器接口实现全部注册为映射器
 

 	 

 
 
 
和第二种方法的限制一样！
 
 
6、作用域（Scope）和生命周期 
 
 
理解我们之前讨论过的不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。
 
 
1）SqlSessionFactoryBuilder
 一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）
 
2）SqlSessionFactory
 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
 最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。
 
3）SqlSession
 每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。
 
五、属性名和字段名不一致的解决方法 
1、在 SELECT 语句中给字段名起别名 
 
 
MyBatis 会在幕后自动创建一个 ResultMap，再根据属性名来映射列到 JavaBean 的属性上。
 
 

 select
   user_id             as "id",
   user_name           as "userName",
   hashed_password     as "hashedPassword"
 from some_table
 where id = #{id}

2、在xml中使用结果映射（resultMap）

resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

直接使用官网的例子：

先定义一个resultMap（id是主键，result是普通的字段）

然后在引用它的语句中设置 resultMap 属性就行了（注意我们去掉了 resultType 属性）

  select user_id, user_name, hashed_password
  from some_table
  where id = #{id}

 

 
 
六、日志 
 
 
如果一个数据库操作出现异常，需要排错，就需要用到日志
 
 
曾经使用的方法：sout、debug
 现在：日志工厂
 
 
1、STDOUT_LOGGING（标准日志输出） 
在核心配置文件中
 

        

 
运行后可以在控制台看到日志
 主要看以下的部分
 
 
2、LOG4J 
在百度百科中有如下解释：
 
 使用方法：
 1）导包
 在pom.xml中新增依赖：
 

    log4j
    log4j
    1.2.17

 
2)在resources下建立log4j.properties
 可以参考博客https://www.jianshu.com/p/ccafda45bcea
 以下是比较简单的配置（建议直接copy，不要自己手打，以后基本不会修改）
 
#1、配置根Logger

#日志记录的最低级别为DEBUG，输出到console和file两个目的地
log4j.rootLogger=DEBUG,console,file

#2、配置日志信息输出目的地（appender）

# 控制台(console)
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件(file)
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/jiyu.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yyy-MM-dd HH:mm:ss}][%c]%m%n

#3、配置日志信息的输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
 
这一处表示生成的日志文件名称以及所在目录（会自动新建）
 
 
3）配置setting
 

        

 
4)运行测试
 随便运行一个方法，我这里运行的是getLoginLike()
 控制台可以看到
 
 日志文件jiyu.log可以看到
 
 
再在LoginDaoTest中写一个方法：
 
@Test
    public void testLog4j(){
        Logger logger = Logger.getLogger(LoginDaoTest.class);

        logger.info("info");
        logger.debug("debug");
        logger.error("error");
    }
 
运行后，控制台会输出：
 
 也会在日志文件中输出
 
七、分页 
1、熟悉sql语句 
 
 
我用的是sql server，所以主要讲解在sql server中的分页，mysql的分页语句更加简单，不难理解
 
 
1）首先要会在idea中使用Query Consoles，方便后期我们的测试
 
 
 2）mysql
 使用limit
 
SELECT * FROM tableName LIMIT [offset] ,rows;
 
3）sql server
 使用Offset /Fetch Next，必须有order by ***
 
select [column1]
      ,[column2]
      ...     
     ,[columnN]
from [tableName]
order by [columnM]
offset (pageIndex-1)*pageSize rows
fetch next pageSize rows only
 
 
2、使用Offset /Fetch Next 
1)接口
 
List getLoginByFetch(Map map);
 
2）xml映射文件
 

        select * from login
        order by id
        offset #{pageIndex} rows
        fetch next #{pageSize} rows only

 
3）测试
 
 @Test
    public void getLoginByFetch(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);

        HashMap map = new HashMap<>();
        map.put("pageIndex",0);
        map.put("pageSize",2);

        List loginList = mapper.getLoginByFetch(map);
        for (Login login : loginList) {
            System.out.println(login);
        }

        sqlSession.close();
    }
 
控制台输出如下：
 
 
3、使用RowBounds 
 
 
该方法不需要使用sql（映射文件中的sql语句固定）。仅需要在方法中做一处改动即可
 
 
1）接口
 
    List getLoginByRowBounds();
 
2）xml映射文件
 

        select * from login

3）测试

@Test
   public void getLoginByRowBounds(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();

       RowBounds rowBounds = new RowBounds(0, 2);//只需要改动这里的参数即可

       List loginList = sqlSession.selectList("com.jiyu.dao.LoginMapper.getLoginByRowBounds",null,rowBounds);
       for (Login login : loginList) {
           System.out.println(login);
       }

       sqlSession.close();
   }

在idea中可以看到两个参数的意义，其他两个文件写好后不需要改动

4、分页插件（Mybatis PageHelper）

官网传送门：https://pagehelper.github.io/
点击左上角 文档 即可查看使用教程，不做详细讲解

八、使用注解开发

映射的语句可以不用 XML 来配置，而可以使用 Java 注解来配置
使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。

1、新建module

1）建立名为test02的module
以下几个文件都是复制test模块的，暂时未做修改

2、修改几个文件

未提及的文件都是和test模块一模一样，无需修改的

1）核心配置文件

2）接口

package com.jiyu.dao;

import com.jiyu.entity.Login;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Map;

public interface LoginMapper {
    @Select("select * from login")
    List getLogins();
}

3）测试
新建LoginMapperTest

import com.jiyu.dao.LoginMapper;
import com.jiyu.entity.Login;
import com.jiyu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class LoginMapperTest {
    @Test
    public void getLogins(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);
        List logins = mapper.getLogins();
        for (Login login : logins) {
            System.out.println(login);
        }

        sqlSession.close();
    }
}

运行结果

3、CRUD

先设置事务自动提交
在MybatisUtils.java中，给openSession方法添加参数true，表示自动commit

1）接口

package com.jiyu.dao;

import com.jiyu.entity.Login;
import org.apache.ibatis.annotations.*;

import java.util.List;
import java.util.Map;


public interface LoginMapper {
    @Select("select * from login")
    List getLogins();

    //方法存在多个参数，所有的参数前面必须加上@param("")注解
    @Select("select * from login where id=#{id}")
    Login getLoginById(@Param("id") int id);

    @Insert("insert into login(id,name,pwd) values(#{id},#{name},#{pwd})")
    int addLogin(Login login);

    @Update("update login set name=#{name},pwd=#{pwd} where id=#{id}")
    int updateLogin(Login login);

    @Delete("delete from login where id=#{uid}")
    int deleteLogin(@Param("uid") int id);//注解使用的是@Param("uid")中的uid而非该方法的参数id
}

2）测试

import com.jiyu.dao.LoginMapper;
import com.jiyu.entity.Login;
import com.jiyu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;


public class LoginMapperTest {
    @Test
    public void getLogins(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);
        List logins = mapper.getLogins();
        for (Login login : logins) {
            System.out.println(login);
        }

        sqlSession.close();
    }

    @Test
    public void getLoginById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);
        Login loginById = mapper.getLoginById(1);
        System.out.println(loginById);
        sqlSession.close();
    }

    @Test
    public void addLogin(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);
        mapper.addLogin(new Login(666,"test","testpass"));

        sqlSession.close();
    }

    @Test
    public void updateLogin(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);
        mapper.updateLogin(new Login(666,"test666","test666pass"));

        sqlSession.close();
    }

    @Test
    public void deleteLogin(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        LoginMapper mapper = sqlSession.getMapper(LoginMapper.class);
        mapper.deleteLogin(666);

        sqlSession.close();
    }
}

九、复杂查询环境搭建 1、建表

新建名为complex relationship的数据库
连接

接下来新建表
1）teacher

create table teacher
(
    id   int not null
        constraint teacher_pk
            primary key nonclustered,
    name nvarchar(30)
)

数据

2）student
外键：tid(对应teacher的id)

create table student
(
	id int not null
		constraint student_pk
			primary key nonclustered,
	name nvarchar(30),
	tid int
		constraint student_teacher_id_fk
			references teacher
				on update cascade on delete cascade
)

数据

可以查看两张表的关系

2、新建module并测试

1）建立module：test03
2）module中的文件：（数字代表建立的顺序）

下面是所有文件的代码，用数字表示文件名
1、

driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
url=jdbc:sqlserver://localhost:1433;databaseName=complex relationship
username=sa
password=123456

2、(mappers部分在建立了两个接口文件后再写进去)

3、

package com.jiyu.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    //1、从 XML 中构建 SqlSessionFactory
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //2、从 SqlSessionFactory 中获取 SqlSession
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }
}

4、

package com.jiyu.entity;

public class Teacher {
    private int id;
    private String name;

    public Teacher(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Teacher() {
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + ''' +
                '}';
    }
}

5、

package com.jiyu.entity;

public class Student {
    private int id;
    private String name;
    private Teacher teacher;//关联老师

    public Student() {
    }

    public Student(int id, String name, Teacher teacher) {
        this.id = id;
        this.name = name;
        this.teacher = teacher;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", teacher=" + teacher +
                '}';
    }
}

6、

package com.jiyu.dao;

import com.jiyu.entity.Teacher;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface TeacherMapper {

    @Select("select * from teacher where id=#{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

7、

package com.jiyu.dao;

public interface StudentMapper {
}

8、

9、

10、

import com.jiyu.dao.TeacherMapper;
import com.jiyu.entity.Teacher;
import com.jiyu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class MyTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);


        sqlSession.close();
    }
}

运行结果

至此说明基本的环境已经配置好了

3、多对一的处理

目的：查询所有的学生信息，以及对应的老师的信息
对应sql语句：

select s.id,s.name,t.name from student s,teacher t where s.tid=t.id

但是该语句涉及到了两个实体（多表查询），所以在xml映射文件中不能仅通过简单的一句sql来实现

1、先看问题的引入：select * from student

1）接口（StudentMapper）

public List getStudent();

2）xml映射文件

        select * from student
    

3）测试

 @Test
   public void testStudent(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
       List students = mapper.getStudent();
       for (Student student : students) {
           System.out.println(student);
       }

       sqlSession.close();
   }

结果：
出现了teacher=null的情况（因为对象的属性和表中的字段没有对应）
这个时候就需要一个对teacher的查询

2、解决方法一：嵌套 Select 查询（类似sql中的嵌套查询）

1）接口：不变
2）xml映射文件：
修改为

        select * from student
    
    
        
        

        
    

    
        select * from teacher where id=#{id}
    

association那一行表示：
在查询学生时，字段tid映射为teacher，并且是一个对象，对象类型为Teacher，这个对象需要使用一个select语句，对应的查询语句id为getTeacher

在官网对select的解释：

所以，column中的tid会作为参数传递给查询语句的大括号中的“id”，实际上，无论大括号内写什么，都不会影响最后的效运行结果，因为他的参数只取决于column的属性

3）测试：不变
直接运行

3、解决方法二：相当于联表查询（较为简单）

1）接口：

    public List getStudent2();

2）xml映射文件

	
        select s.id sid,s.name sname,t.name tname
        from student s,teacher t 
        where s.tid=t.id;
    
    
        
        
        
            
        
    
 
3）测试：
 
@Test
    public void testStudent2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List students = mapper.getStudent2();
        for (Student student : students) {
            System.out.println(student);
        }

        sqlSession.close();
    }
 
运行结果同方法一
 该方法比方法一简洁，而且只需要一句sql，不需要像方法一那样写多句sql，建议使用该方法
 
4、一对多的处理 
 
 
1、环境搭建
 
 
1）新建module：test04
 2）java和resources文件夹下的都是从test03复制的，将dao中两个接口的方法清空，xml映射文件的mapper标签对中的内容清空，测试类MyTest也清空。其他文件暂且不修改
 
 
3）修改实体类
 Student类。无参和有参构造器、get、set、toString方法自己生成（Shift+Alt+s）
 
 

 Teacher类
 
 
 
 
2、问题的引入
 
 
1）接口（TeacherMapper）
 
public interface TeacherMapper {
    List getTeacher();
}
 
2）xml映射文件
 

        select * from teacher
 

3）测试

public class MyTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        List teachers = mapper.getTeacher();
        for (Teacher teacher : teachers) {
            System.out.println(teacher);
        }

        sqlSession.close();
    }
}

结果：

可以看到students=null

3、解决方法

先用sql查询

1）接口

Teacher getTeacher2(@Param("tid") int id);

2）xml映射文件

	
        select s.id sid,s.name sname,t.name tname,t.id tid
        from student s,teacher t
        where s.tid=t.id and t.id=#{tid}
    
    
        
        

        
            
            
            
        
    
 
官网关于ofType的使用说明
 
 3）测试
 
 @Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher2 = mapper.getTeacher2(1);
        System.out.println(teacher2);

        sqlSession.close();
    }

 
结果：
 
 
Teacher{id=1, name='张三老师', students=[
Student{id=1, name='学生1', tid=1}, 
Student{id=2, name='学生2', tid=1}, 
Student{id=3, name='学生3', tid=1},
 Student{id=4, name='学生4', tid=1}, 
 Student{id=5, name='学生5', tid=1}]}

 
十、动态sql 
 
 
动态sql：根据不同的条件生成不同的sql语句。语法类似JSTL
 
 
1、建表 
create table blog
(
	id nvarchar(50) not null,
	title nvarchar(100) not null,
	author nvarchar(30) not null,
	create_time datetime not null,
	views int not null
)
 
2、新建module 
建立module： test05
 
 只有MybatisUtils和db.properties是不变的，直接复制以前的，其他几个文件内容如下：
 1)mybatis-config.xml
 核心配置文件
 




    

    
        
        
    

    
        
    

    
        
            
            
                
                
                
                
            
        

        
            
            
                
                
                
                
            
        
    

    
        
    

 
其中，用法如下
 
 2)IdUtils
 使用UUID生成随机ID
 
package com.jiyu.utils;

import org.junit.Test;

import java.util.UUID;

public class IdUtils {

    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }

    @Test
    public void test(){
        System.out.println(IdUtils.getId());
        System.out.println(IdUtils.getId());
        System.out.println(IdUtils.getId());
        System.out.println(IdUtils.getId());
    }
}

 
运行test方法可以查看随机生成的id
 3)Blog
 实体类
 
package com.jiyu.entity;

import java.util.Date;

public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
//省略了有参和无参构造器、get和set、toString方法
   }

 
4)BlogMapper
 接口
 
package com.jiyu.dao;

import com.jiyu.entity.Blog;

public interface BlogMapper {

    int addBlog(Blog blog);
}

 
5)BlogMapper.xml
 xml映射文件
 




    
        insert into blog (id, title, author, create_time, views)
        values (#{id},#{title},#{author},#{createTime},#{views});
    

 
6)MyTest
 测试
 
import com.jiyu.dao.BlogMapper;
import com.jiyu.entity.Blog;
import com.jiyu.utils.IdUtils;
import com.jiyu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.Date;

public class MyTest {
    @Test
    public void addInitBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        Blog blog=new Blog();
        blog.setId(IdUtils.getId());
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("jiyu");
        blog.setCreateTime(new Date());
        blog.setViews(9999);
        mapper.addBlog(blog);

        blog.setId(IdUtils.getId());
        blog.setTitle("Java如此简单");
        blog.setViews(1000);
        mapper.addBlog(blog);

        blog.setId(IdUtils.getId());
        blog.setTitle("Spring如此简单");
        blog.setViews(9999);
        mapper.addBlog(blog);

        blog.setId(IdUtils.getId());
        blog.setTitle("微服务如此简单");
        mapper.addBlog(blog);

        sqlSession.close();
    }
}
 
运行后，查看表blog，共插入了四条记录
 
 
3、if 
1）接口
 
    List queryBlogIF(Map map);
 
2）xml映射文件
 

        select * from blog where 1=1
        
            and title=#{title}
        
        
            and author=#{author}
        
    

3）测试

 @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        List blogs = mapper.queryBlogIF(map);

        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        sqlSession.close();
    }

运行结果：

因为传入的map为空，所以sql语句相当于select * from blog

当在测试文件加上这句代码，修改map后

运行结果：
此时sql相当于select * from blog where title='Java如此简单'
所以只能查到一条数据
如果修改成下面这样，那么sql相当于select * from blog where author='jiyu'

4、where

where 元素只会在子元素返回任何内容的情况下才插入 “WHERe” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

1）接口

    List queryBlogWhere(Map map);

2）xml映射文件

	
        select * from blog
        
            
                 title=#{title}
            
            
                and author=#{author}
            
        
    

3）测试

@Test
    public void queryBlogWhere(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
         map.put("title","Java如此简单");
//        map.put("author","jiyu");

        List blogs = mapper.queryBlogWhere(map);

        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        sqlSession.close();
    }

5、choose、when、otherwise

官网的简介非常清楚
相当于switch case default

用法如下：
1）接口

    List queryBlogChoose(Map map);

2）xml映射文件

	
        select * from blog
            
                
                    
                        title=#{title}
                    
                    
                        and author=#{author}
                    
                    
                        and views=#{views}
                    
                
            
    
 
3）测试
 
@Test
    public void queryBlogChoose(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();

        map.put("title","Java如此简单");
//        map.put("author","jiyu");
        map.put("views",9999);

        List blogs = mapper.queryBlogChoose(map);

        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        sqlSession.close();
    }
 
这三行代码挨个注释再运行方法，可以深入理解choose的运用
 
 
6、set 
 
 
set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。
 
 
1）接口
 
    int updateBlog(Map map);
 
2）xml映射文件
 

        update blog
        
            
                title=#{title},
            
            
                author=#{author}
            
        
        where id=#{id}
    
 
3）测试
 
@Test
    public void updateBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();

        map.put("title","Java如此简单2");
        map.put("author","jiyu");
        map.put("id","75124c5898224b39aff8769a6697103b");
//        map.put("views",9999);

        mapper.updateBlog(map);

        sqlSession.close();
    }
 
运行后对应的title改变
 
 
7、trim 
官网说明如下，不做过多说明
 
 
 
8、foreach 
如图是对应关系
 
 接下来开始引入问题
 
先更改表中的各个id，方便测试
 
 
 
 
问题：遍历1、2、3号记录
 
 
sql：
 
select *
from blog
where (id=1 or id=2 or id=3);
 

 1）接口
 
    List queryBlogForeach(Map map);
 
2）xml映射文件
 
	
        select * from blog
        
            
                id=#{id}
            
        
    
 
ids就是由map传入的
 
 这一段表明，
 开头是"("
 结尾是 “)”
 分隔符是 “or”
 可以看做
 
select *
from blog
where (id=? or id=? or id=?......);
 
3）测试
 
@Test
    public void queryBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();

        ArrayList ids = new ArrayList<>();
        ids.add(1);
        ids.add(2);
        ids.add(3);

        map.put("ids",ids);

        List blogs = mapper.queryBlogForeach(map);

        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        sqlSession.close();
    }
 
 
9、SQL片段 
 
 
将一些常用的SQL代码复用
 
 
下面的代码在之前我们经常会用到，所以可以用include标签引用
 

 	title=#{title},


    author=#{author}

 
先定义这段sql
 
	
        
            and title=#{title}
        
        
            and author=#{author}
        
    
 
在引用的时候格式如下，直接写在要引用的位置，相当于写了定义的那段sql
 

 
refid对应中的id
 
十一、缓存 
 
 
一级缓存：基于sqlSession级别
 二级缓存：基于namespace级别
 
 
下面是官网中比较重要的话
 
 
 这部分我就不详细说了，可以去看狂神的讲解，非常详细


转载请注明：文章转载自 www.051e.com
本文地址：http://www.051e.com/it/275154.html


   上一篇  Mybatis 实战： 一对一关系
 
   下一篇  继承里面的重写问题
  






Java相关栏目本月热门文章

  
1JPA+QueryDSL
  
2Cookie、Session、Token之间的区别到底在哪？
  
3springBoot使用自定义注解实现复杂校验
  
4Mybatis-plus学习笔记---乐观锁、逻辑删除、代码自动生成器等
  
5反射Field、Method、Constructor
  
6Servlet+mybatis整合Web项目
  
7SLF4j的介绍与使用+SpringBoot日志配置
  
8MybatisPlus【SpringBoot】 2 入门案例
  
9IntelliJ IDEA 2022免费激活码正规申请方法（IDEA官方激活注册码）
  
10Qt多线程编程简介
  
11商品管理模块微服务demo
  
12移动开发技术作业2
  
13SpringCloud 之OpenFeign 自定义配置和使用/自定义拦截器
  
14关于前端安全性那些事
  
15JSP超市管理系统myeclipse定制开发SQLServer数据库网页模式java编程jdbc
  
16java---数位dp---计数问题（每日一道算法2022.10.21）
  
17在javaweb项目中进行添加的时候，下拉框选中的数据怎末进行保存呢
  
18移动开发课程-作业二
  
19基本数据类型转换（java）
  
20Spring Boot工程配置多数据源，Cannot resolve configuration property dynamic







热门相关搜索



北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
铁岭卫生职业学院排名
沈阳北软信息职业技术学院排名
吉林艺术学院排名
吉林体育学院排名
白城师范学院排名
通化师范学院排名
吉林农业大学排名
长春电子科技学院排名
吉林工业职业技术学院排名
吉林司法警官职业学院排名
吉林警察学院排名
长春健康职业学院排名
吉林水利电力职业学院排名
大庆师范学院排名
黑龙江大学排名
哈尔滨剑桥学院排名
哈尔滨铁道职业技术学院排名
哈尔滨应用职业技术学院排名
黑龙江民族职业学院排名
七台河职业学院排名
黑龙江生态工程职业学院排名
华东师范大学排名
上海健康医学院排名
华东理工大学排名
上海交通大学排名
同济大学排名
复旦大学排名
上海杉达学院排名
上海戏剧学院排名
上海音乐学院排名







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


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


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

实用范文


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




终身学习网 版权所有 ©2023-2025  051e.com     ICP备案号：京ICP备12030808号
 






关于我们
文章归档
网站地图
联系我们
版权所有 ©2023-2025  051e.com
ICP备案号：京ICP备12030808号