Mybatis框架

约定不等于承诺〃 2024-03-02 09:42 163阅读 0赞

Mybatis框架

MyBatis简介

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

2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

回顾JDBC的使用步骤：

  • 1.加载驱动

    Class.forName(“com.mysql.jdbc.Driver”);

  • 2.获取连接对象

    DiverManerger.getConnection(url,username,password)

  • 3.获取执行sql的Statement对象

    connection.CreateStatement();

  • 4.执行sql语句

  • 5.处理结果集

  • 6.释放连接

    connection.Close()

与JDBC相比：

  1. Mybatis通过参数映射方式，可以将参数灵活的配置在SQL语句中的配置文件中，避免在Java类中配置参数
  2. Mybatis通过输出映射机制，将结果集的检索自动映射成相应的Java对象，避免对结果集手工检索
  3. Mybatis可以通过Xml配置文件对数据库连接进行管理

MyBatis整体架构及运行流程

Mybatis整体构造由 数据源配置文件、Sql映射文件、会话工厂、会话、执行器和底层封装对象组成

1.数据源配置文件

通过配置的方式将数据库的配置信息从应用程序中独立出来，由独立的模块管理和配置。Mybatis的数据源配置文件包含数据库驱动、数据库连接地址、用户名密码、事务管理等，还可以配置连接池的连接数、空闲时间等

一个MapConfig.xml基本的配置信息如下：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.   <environments default="development">
  7.     <environment id="development">
  8.    <!-- 事务的管理 JDBC  MANAGED-->
  9.       <transactionManager type="JDBC"/>
  10.    <!-- 数据源 POOLED UNPOOLED JNDI -->
  11.       <dataSource type="POOLED">
  12.         <property name="driver" value="${driver}"/>
  13.         <property name="url" value="${url}"/>
  14.         <property name="username" value="${username}"/>
  15.         <property name="password" value="${password}"/>
  16.       </dataSource>
  17.     </environment>
  18.   </environments>
  19.   <mappers>
  20.     <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  21.   </mappers>
  22. </configuration>

mybatis mapper文件映射

  1. <!-- 使用相对于类路径的资源引用 -->
  2. <mappers>
  3.   <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  4. </mappers>
  6. <!-- 使用映射器接口实现类的完全限定类名
  7.     mybais去加载class对应的接口，然后还会去加载该接口同目录下的同名xml文件 
  8. -->
  9. <mappers>
  10.   <mapper class="org.mybatis.builder.AuthorMapper"/>
  11. </mappers>
  13. <!-- 将包内的映射器接口实现全部注册为映射器   
  14.  使用package元素批量注册Mapper接口
  15.   1.包名和接口所在的包名字一致
  16.   2.mapper文件的名字和接口的名字一致
  17.   3.创建包是使用/分割
  18. -->
  19. <mappers>
  20.   <package name="org.mybatis.builder"/>
  21. </mappers>

设置资源文件路径

Maven中默认是只会打包resource下的资源文件。如果我们的文件不放在resource， 则需要通过配置告知Maven

  1. <resources>
  2.     <resource>
  3.         <directory>src/main/java</directory>
  4.         <includes>
  5.             <include>**/*.properties</include>
  6.             <include>**/*.xml</include>
  7.         </includes>
  8.         <filtering>false</filtering>
  9.     </resource>
  10.      <resource>
  11.         <directory>src/main/resources</directory>
  12.         <includes>
  13.           <include>**/*.properties</include>
  14.           <include>**/*.xml</include>
  15.           <include>**/*.tld</include>
  16.         </includes>
  17.         <filtering>false</filtering>
  18.       </resource>
  19. </resources>

2.Sql映射文件

Mybatis中所有数据库的操作都会基于该映射文件和配置的sql语句，在这个配置文件中可以配置任何类型的sql语句。框架会根据配置文件中的参数配置，完成对sql语句以及输入输出参数的映射配置。

Mapper.xml配置文件大致如下：

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="命名空间">
  5. <select id="方法名" resultMap="返回值类型" parameterType="参数类型">
  7. -- sql语句
  9. </select>
  11. </mapper>

3.会话工厂与会话

Mybatis中会话工厂SqlSessionFactory类可以通过加载资源文件，读取数据源配置MapConfig.xml信息，从而产生一种可以与数据库交互的会话实例SqlSession，会话实例SqlSession根据Mapper.xml文件中配置的sql,对数据库进行操作。

4.运行流程

会话工厂SqlSessionFactory通过加载资源文件获取MapConfig.xml配置文件信息，然后生成可以与数据库交互的会话实例SqlSession。会话实例可以根据Mapper配置文件中的Sql配置去执行相应的增删改查操作

执行流程图：

在这里插入图片描述

mybatis实现增删改查

  1. public class TestStudent {
  4.     @Test
  5.     public void test01(){
  8.         try {
  9.     //加载配置文件
  10.             InputStream in = Resources.getResourceAsStream("config/mybatis-config.xml");
  11.             //获取sqlSession对象
  12.             SqlSession sqlSession = new SqlSessionFactoryBuilder().build(in).openSession();
  13.             //查询所有学生信息
  14.         List<Student> students = sqlSession.selectList("cn.kgc.mybatis.dao.StudentDao.getAll");    
  15.             students.forEach(student -> System.out.println(student) );
  16.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  22.     @Test
  23.     public void test02(){
  24.     //查询一个学生信息
  26.         try {
  27.     //加载配置文件
  28.             InputStream in = Resources.getResourceAsStream("config/mybatis-config.xml");
  29.             //获取sqlSession对象
  30.             SqlSession sqlSession = new SqlSessionFactoryBuilder().build(in).openSession();
  31.             //根据用户名查询一个学生信息
  32.             Student student = sqlSession.selectOne("cn.kgc.mybatis.dao.StudentDao.findOne","tom");
  33.             System.out.println(student);
  34.             sqlSession.close();
  35.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  40.     @Test
  41.     public void test03() {
  42.     //添加一个学生信息
  44.         try {
  45.     //加载配置文件
  46.             InputStream in = Resources.getResourceAsStream("config/mybatis-config.xml");
  47.             //获取sqlSession对象
  48.             SqlSession sqlSession = new SqlSessionFactoryBuilder().build(in).openSession();
  49.             //添加一个学生信息
  50.             Student student = Student.builder().stuBirth(new Date()).stuName("lilei").stuNo("2021073001").stuSex("男").build();
  51.             int i = sqlSession.insert("cn.kgc.mybatis.dao.StudentDao.addOne", student);
  52.             System.out.println(i);
  53.             sqlSession.commit();
  54.             sqlSession.close();
  56.         } catch (IOException e) {
  58.             e.printStackTrace();
  59.         }
  61.     }
  62.     @Test
  63.     public void test04() {
  64.     //删除一个学生信息
  66.         try{
  68.             InputStream in = Resources.getResourceAsStream("config/mybatis-config.xml");
  69.             //获取sqlSession对象 同时可设置事务的自动提交  openSession(true)
  70.             SqlSession sqlSession = new SqlSessionFactoryBuilder().build(in).openSession();
  71.             int delete = sqlSession.delete("cn.kgc.mybatis.dao.StudentDao.delOne","lilei" );
  72.             sqlSession.commit();
  73.             sqlSession.close();
  74.             System.out.println(delete);
  75.         }catch (Exception e){
  77.             e.printStackTrace();
  78.         }
  80.     }
  82.     @Test
  83.     public void test05() {
  84.     //修改一个学生信息
  86.         try{
  88.             InputStream in = Resources.getResourceAsStream("config/mybatis-config.xml");
  89.             //获取sqlSession对象
  90.             SqlSession sqlSession = new SqlSessionFactoryBuilder().build(in).openSession();
  92.             Student student = Student.builder().stuBirth(new Date()).stuName("lili").stuNo("2021073001").stuSex("女").build();
  93.             int delete = sqlSession.update("cn.kgc.mybatis.dao.StudentDao.updateStudent",student);
  94.             sqlSession.commit();
  95.             sqlSession.close();
  96.             System.out.println(delete);
  97.         }catch (Exception e){
  99.             e.printStackTrace();
  100.         }
  103.     }
  105. }

mybatis中使用log4j日志工具

1.配置mybatis-config.xml

  1. <!--    开启日志-->
  2.  <setting name="logImpl" value="LOG4J"/>

开启驼峰命名

  1. <!--    设置驼峰命名-->
  2.  <setting name="mapUnderscoreToCamelCase" value="true"/>

设置别名

  1. <typeAliases>
  2.     <!--设置别名-->
  3.     <package name="cn.kgc.mybatis.pojo"/>
  4. </typeAliases>

2.配置log4j.properties文件，放置在resources目录下

  1. log4j.rootLogger=DEBUG,Console
  3. #Console
  4. log4j.appender.Console=org.apache.log4j.ConsoleAppender
  5. log4j.appender.console.Target=System.out
  6. log4j.appender.Console.layout=org.apache.log4j.PatternLayout
  7. log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
  9. log4j.logger.org.apache=ERROR
  10. log4j.logger.org.mybatis=ERROR
  11. log4j.logger.org.springframework=ERROR
  13. #这个需要
  14. log4j.logger.log4jdbc.debug=ERROR
  15. log4j.logger.com.gk.mapper=ERROR
  16. log4j.logger.jdbc.audit=ERROR
  17. log4j.logger.jdbc.resultset=ERROR
  18. #这个打印SQL语句非常重要
  19. log4j.logger.jdbc.sqlonly=DEBUG
  20. log4j.logger.jdbc.sqltiming=ERROR
  21. log4j.logger.jdbc.connection=FATAL

使用mapper代理对象实现增删改查

  1. public class TestStudentMapper {
  3.     SqlSessionFactory factory;
  4.     @Before
  5.     public void init(){
  7.         try {
  9.             InputStream  in = Resources.getResourceAsStream("config/mybatis-config.xml");
  10.             SqlSessionFactoryBuilder sfb = new SqlSessionFactoryBuilder();
  11.             factory = sfb.build(in);
  12.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         }
  18.     }
  19.     @Test
  20.     public void test01(){
  22.             //开启事务自动提交
  23.             SqlSession sqlSession = factory.openSession(true);
  24.             //获取dao层的代理对象
  25.             StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  26.             List<Student> students = studentDao.getAll();
  27.             students.forEach(student -> System.out.println(student));
  28.     }
  30.     @Test
  31.     public void test02(){
  32.      //添加数据
  34.         SqlSession sqlSession = factory.openSession(true);
  35.         Student student = Student.builder().stuSex("男").stuNo("2021073100").stuName("李四").stuBirth(new Date()).build();
  36.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  37.         Integer line = studentDao.addOne(student);
  38.         System.out.println(line);
  39.     }
  41.     @Test
  42.     public  void test03(){
  43.     //删除一条数据
  44.         SqlSession sqlSession = factory.openSession(true);
  45.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  46.         Integer line = studentDao.delOne("李四");
  47.         System.out.println(line);
  48.     }
  50.     @Test
  51.     public void test04() {
  52.      //修改数据
  53.         SqlSession sqlSession = factory.openSession(true);
  54.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  55.         Student student = Student.builder().stuSex("女").stuNo("2021073100").stuName("李四").stuBirth(new Date()).build();
  56.         Integer line = studentDao.updateOne(student);
  57.         System.out.println(line);
  59.     }
  61.     @Test
  62.     public void test06(){
  63.     //模糊查询一个学生信息 一个参数
  64.         SqlSession sqlSession = factory.openSession(true);
  65.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  67.         List<Student> students = studentDao.selectLikeName("li");
  68.         System.out.println(students.toString());
  70.     }
  72.     @Test
  73.     public void test07(){
  74.     //模糊查询一个学生信息 两个参数
  75.         SqlSession sqlSession = factory.openSession(true);
  76.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  78.         List<Student> students = studentDao.selectLikeName2("li", "2021072902");
  79.         System.out.println(students.toString());
  82.     }
  83.      @Test
  84.     public void test08(){
  85.     //模糊查询一个学生信息 一个集合参数  mapper文件中按照key取值
  86.         SqlSession sqlSession = factory.openSession(true);
  87.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  89.         HashMap<String, String> map = new HashMap<>();
  90.         map.put("stuname","li");
  91.         map.put("stuno", "2021072902");
  92.         List<Student> students = studentDao.selectLikeName3(map);
  93.         System.out.println(students.toString());
  94.     }
  96. }

Mybatis的获取参数的方式

方式1：${} 字符串拼接

方式2：#{} 占位符

1.Mapper接口参数为单个参数

  1. <delete id="delUserById" parameterType="int">
  2.         delete from user where id = #{id}
  3.  </delete>
  5.   <delete id="delUserById" parameterType="int">
  6.         delete from user where id = ${id}
  7.  </delete>
  9.  注：如何参数是String类型使用${}获取参数是需要手动添加引号 ''

2.Mapper接口参数是多个参数的获取

mybatis在处理多个参数时,会将多个参数保存到map集合中会 以 agr0 ，agr1或param1 param2为键 以参数位置进行存储

  1. User selectUserByUserNameAndPassword(String username,String password);
  3. <select id="selectUserByUserNameAndPassword" resultType="user">
  4.         select  * from user where user_name = #{arg0} and password = #{arg1}
  5.  </select>

3.将参数设为map集合进行数据的传递

  1. User selectUserByMap(Map map);
  3. <select id="selectUserByMap" resultType="cn.kgc.mybatis.entity.User">
  4.         select  * from user where user_name = #{username} and password = #{password}
  5. </select>

4.通过注解@param(“键名”)设置参数的获取名字

  1. User selectUserByUserNameAndPassword(@param("username")String username,(@param("password")String password);
  3. <select id="selectUserByUserNameAndPassword" resultType="user">
  4.         select  * from user where user_name = #{username} and password = #{password}
  5. </select>
  7. 或者
  9. <select id="selectUserByUserNameAndPassword" resultType="user">
  10.         select  * from user where user_name = #{param1} and password = #{param2}
  11. </select>

5.将多个参数设置成对象进行数据的传递

  1. int insertUser(User user);
  3. <insert id="insertUser" parameterType="user" useGeneratedKeys="true" keyProperty="id" >
  4.          insert into user values ( #{id},#{userName},#{password})
  5.  </insert>

Mybatis中的模糊查询

方式1：

  1. SELECT * FROM tableName WHERE name LIKE #{text}
  3. -- 传递的参数需要拼接  ‘%text%’

方式2：

  1. SELECT * FROM tableName WHERE name LIKE '%${text}%';
  2.  -- 使用$替代# 参数无需在拼接%  存在sql注入

方式3

  1. SELECT * FROM tableName WHERE name LIKE CONCAT('%', #{text}), '%');
  2. -- 使用mysql的函数  实现拼接

6.批量删除

  1. int deleteMore(String ids);
  3. <delete id="deleteMore">
  4.         delete from user where id in(${ids})
  5.    </delete>

mapper中自定义映射

自定义映射的用法之一，解决表格查询的字段名和实体类中不一致的情况

  1. <resultMap id="userMap" type="user">
  2.         <id column="id" property="id"></id>
  3.         <result column="user_name" property="userName"></result>
  4.         <result column="password" property="password"></result>
  5. </resultMap>

mybatis对象的关联关系

一对多关系处理(一方)

  1. <resultMap id="selectByEIdMap" type="cn.kgc.mybatis.entity.Emp">
  2.         <result column="id" property="dept.id" ></result>
  3.         <result column="dname" property="dept.dName"></result>
  4.  </resultMap>
  7.     <resultMap id="selectByEIdMap2" type="cn.kgc.mybatis.entity.Emp">
  8.         <id column="eid" property="eId"></id>
  9.         <result column="ename" property="EName"></result>
  10.         <result column="age" property="age"></result>
  11.         <result column="deptno" property="deptNo"></result>
  12.         <!--实体对象标识-->
  13.        <association property="dept" javaType="dept">
  14.            <id column="id" property="id"></id>
  15.            <result column="dname" property="dName"></result>
  16.        </association>
  17.     </resultMap>
  19.     <!-- 分步查询 -->
  20.     <resultMap id="selectByEIdMap3" type="cn.kgc.mybatis.entity.Emp">
  21.         <id column="eid" property="eId"></id>
  22.         <result column="ename" property="EName"></result>
  23.         <result column="age" property="age"></result>
  24.         <result column="deptno" property="deptNo"></result>
  25.         <association property="dept" select="cn.kgc.mybatis.mapper.DeptMapper.selectById" 
  26.                                     column="deptno" 
  27.                                     fetchType="eager">
  28.         </association>
  29.     </resultMap>
  31. 注：延迟加载设置  ：
  32.         1. <setting name="lazyLoadingEnabled" value="true"/> 
  33.         2. <setting name="aggressiveLazyLoading" value="false"/>  3.4.1之前的版本需要设置
  35.     <select id="selectByEId" resultMap="selectByEIdMap2">
  36.             select  * from emp left  join  dept on  emp.deptno = dept.id  where eid = #{eid}
  37.     </select>
  39.     <select id="selectByEId2" resultMap="selectByEIdMap3">
  40.             select  * from emp  where eid = #{eid}
  41.     </select>

一对多关系处理(多方)

  1. <resultMap id="BaseResultMap" type="cn.kgc.mybatis.entity.Dept">
  2.             <id property="id" column="id" />
  3.             <result property="dName" column="dname" />
  4.             <collection property="emps" ofType="emp">
  5.                 <id column="eid" property="eId"></id>
  6.                 <result column="ename" property="EName"></result>
  7.                 <result column="age" property="age"></result>
  8.                 <result column="deptno" property="deptNo"></result>
  9.             </collection>
  10.     </resultMap>
  13.     <resultMap id="BaseResultMap2" type="cn.kgc.mybatis.entity.Dept">
  14.         <id property="id" column="id" />
  15.         <result property="dName" column="dname" />
  16.         <collection property="emps" select="cn.kgc.mybatis.mapper.EmpMapper.selectByDeptId" column="id"></collection>
  17.     </resultMap>
  19.     <select id="selectById" resultType="dept">
  20.         select  * from dept where id = #{id}
  21.     </select>
  23.     <select id="selectById2" resultMap="BaseResultMap">
  24.         select emp.* ,dept.* from dept left join emp on dept.id = emp.deptno where id = #{id}
  25.     </select>
  27.     <select id="selectById3" resultMap="BaseResultMap2">
  28.         select dept.* from dept  where id = #{id}
  29.     </select>

mybatis动态sql

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦

动态SQL:if 语句

根据 stu_name 和 stu_sex 来查询数据。如果stu_name为空，那么将只根据stu_sex来查询；反之只根据stu_name来查询

首先不使用 动态SQL 来书写

  1. <select id="selectStudent" resultType="student" parameterType="cn.kgc.mybatis.pojo.Student">
  2.     select * from user where stu_name=#{
  3.     stu_name} and stu_sex=#{
  4.     stu_sex}
  5. </select>

可以发现，如果 #{stu_name} 为空，那么查询结果也是空，如何解决这个问题呢？使用 if 来判断

  1. <select id="selectStudent" resultType="student" parameterType="cn.kgc.mybatis.pojo.Student">
  2.      select * from student where  
  3.      <if test="stu_name != null">
  4.                stu_name=#{
  5.     stu_name}
  6.      </if>
  7.     <if test="stu_sex!= null">
  8.            and stu_sex=#{
  9.     stu_sex}
  10.     </if>
  11. </select>

这样写我们可以看到，如果 sex 等于 null，那么查询语句为 select * from student where stu_name=#{stu_name},但是如果stu_name 为空呢？那么查询语句为 select * from user where and stu_sex=#{sex}，这是错误的 SQL 语句，如何解决呢？

if+where 语句
  1. <select id="selectStudent" resultType="student" parameterType="cn.kgc.mybatis.pojo.Student">
  2.      select * from student 
  3.         <where> 
  4.                  <if test="stu_name != null">
  5.                          stu_name=#{
  6.     stu_name}
  7.                  </if>
  8.                  <if test="stu_sex!= null">
  9.                          and stu_sex=#{
  10.     stu_sex}
  11.                  </if>
  12.         </where> 
  13. </select>

这个where标签会知道如果它包含的标签中有返回值的话，它就插入一个where。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉

动态SQL:if+set 语句

上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词

  1. <update id="updateStudentById" parameterType="cn.kgc.mybatis.pojo.Student">
  2.     update student stu
  3.         <set>
  4.             <if test="stuname != null and stuname != ''">
  5.                 stu.stu_name = #{
  6.     stuName},
  7.             </if>
  8.             <if test="stusex != null and stusex != ''">
  9.                 stu.stu_sex = #{
  10.     stuSex}
  11.             </if>
  12.         </set>
  13.      where id=#{
  14.     id}
  15. </update>
  • 如果第一个条件 username 为空，那么 sql 语句为：update user u set u.sex=? where id=?
  • 如果第一个条件不为空，那么 sql 语句为：update user u set u.username = ? ,u.sex = ? where id=?
动态SQL:choose(when,otherwise) 语句

有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句

  1. <select id="selectStudentByChoose" resultType="com.ys.po.User" parameterType="com.ys.po.User">
  2.       select * from student
  3.       <where>
  4.           <choose>
  5.               <when test="id !='' and id != null">
  6.                   id=#{
  7.     id}
  8.               </when>
  9.               <when test="username !='' and username != null">
  10.                   and username=#{
  11.     username}
  12.               </when>
  13.               <otherwise>
  14.                   and sex=#{
  15.     sex}
  16.               </otherwise>
  17.           </choose>
  18.       </where>
  19.  </select>

这里我们有三个条件，id,username,sex，只能选择一个作为查询条件

  • 如果 id 不为空，那么查询语句为：select * from user where id=?
  • 如果 id 为空，那么看username 是否为空，如果不为空，那么语句为 select * from user where username=?;
  • 如果 username 为空，那么查询语句为 select * from user where sex=?
动态SQL:trim 语句

trim标记是一个格式化的标记，可以完成set或者是where标记的功能

用 trim 改写上面的 if+where 语句

  1. <select id="selectStudent" resultType="student" parameterType="cn.kgc.mybatis.pojo.Student">
  2.      select * from user 
  3.        <trim prefix="where" prefixOverrides=" and | or">
  4.             <if test="stu_name != null">
  5.                 stu_name=#{
  6.     stu_name}
  7.              </if>
  8.             <if test="stu_sex!= null">
  9.                 and stu_sex=#{
  10.     stu_sex}
  11.             </if>
  12.        </trim>
  13. </select>
  • prefix：前缀
  • prefixoverride：去掉第一个and或者是or

用 trim 改写上面的 if+set 语句

  1. <update id="updateStudentById" parameterType="cn.kgc.mybatis.pojo.Student">
  2.     update student stu
  3.        <trim prefix="set" suffixOverrides=",">
  4.             <if test="stuname != null and stuname != ''">
  5.                 stu.stu_name = #{
  6.     stuName},
  7.             </if>
  8.             <if test="stusex != null and stusex != ''">
  9.                 stu.stu_sex = #{
  10.     stuSex}
  11.             </if>
  12.         </trim>
  13.      where id=#{
  14.     id}
  15. </update>
  • suffix：后缀
  • suffixoverride：去掉最后一个逗号（也可以是其他的标记，就像是上面前缀中的and一样）
动态SQL: foreach 语句

需求：我们需要查询 user 表中 id 分别为1,2,3的用户,sql语句：

  1. select * from user where id=1 or id=2 or id=3
  3. select * from user where id in (1,2,3)

用 foreach 来改写 select * from user where id=1 or id=2 or id=3

  1. <select id="selectUserByListId" parameterType="com.ys.vo.UserVo" resultType="com.ys.po.User">
  2.     select * from user
  3.     <where>
  4.         <!--
  5.             collection:指定输入对象中的集合属性
  6.             item:每次遍历生成的对象
  7.             open:开始遍历时的拼接字符串
  8.             close:结束时拼接的字符串
  9.             separator:遍历对象之间需要拼接的字符串
  10.             select * from user where 1=1 and (id=1 or id=2 or id=3)
  11.           -->
  12.         <foreach collection="ids" item="id" separator="or">
  13.             id=#{id}
  14.         </foreach>
  15.     </where>
  16. </select>

用 foreach 来改写 select * from user where id in (1,2,3)

  1. <select id="selectUserByListId" parameterType="com.ys.vo.UserVo" resultType="com.ys.po.User">
  2.         select * from user 
  3.         <where>
  4.             <!--
  5.                 collection:指定输入对象中的集合属性
  6.                 item:每次遍历生成的对象
  7.                 open:开始遍历时的拼接字符串
  8.                 close:结束时拼接的字符串
  9.                 separator:遍历对象之间需要拼接的字符串
  10.                 select * from user where1=1 and id in (1,2,3)
  11.               -->
  12.             <foreach collection="ids" item="id" open="id in ("separator="," close=") " >
  13.                 #{id}
  14.             </foreach>
  15.         </where>
  16.  </select>
动态SQL: SQL 片段

有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

假如我们需要经常根据用户名和性别来进行联合查询，那么我们就把这个代码抽取出来，如下：

  1. <sql id="selectUserByUserNameAndSexSQL">
  2.     <if test="username != null and username != ''">
  3.         AND username = #{
  4.     username}
  5.     </if>    
  6.     <if test="sex != null and sex != ''">
  7.         AND sex = #{
  8.     sex}
  9.     </if>
  10. </sql>
  12. <select id="selectUserByUsernameAndSex" resultType="user" parameterType="com.ys.po.User">
  13.     select * from user
  14.     <trim prefix="where" prefixOverrides="and | or">
  15.         <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
  16.         <include refid="selectUserByUserNameAndSexSQL"></include>
  17.         <!-- 在这里还可以引用其他的 sql 片段 -->
  18.     </trim>
  19. </select>

注意：①、最好基于 单表来定义 sql 片段，提高片段的可重用性

②、在 sql 片段中最好不要包括 where

mybatis注解开发

  1. public interface StudentDao2 {
  4.     @Select("select * from student where stu_no = #{stu_no}")
  5.     @Results({
  7.             @Result(property = "stuNo" ,column="stu_no"),
  8.             @Result(property = "stuSex",column = "stu_sex"),
  9.             @Result(property = "birth",column = "stu_birth")
  10.     })
  11.    List<Student> getAll(String stu_no);
  13.     @Insert("insert into student (stu_no,stu_name,stu_sex,stu_birth)values(#{stuNo},#{stuName},#{stuSex},#{birth})")
  14.     int addStudent(Student student);
  16.     @Delete("delete from student where stu_no = #{stu_no}")
  17.     int delOne(String stu_no);
  19.     @Update("update student set stu_name = #{stuName} where stu_no = #{stuNo}")
  20.     int uptStudent(Student student);
  22. }

mybatis缓存

MyBatis 中的缓存就是说 MyBatis 在执行一次SQL查询或者SQL更新之后，这条SQL语句并不会消失，而是被MyBatis 缓存起来，当再次执行相同SQL语句的时候，就会直接从缓存中进行提取，而不是再次执行SQL命令。

mybatis的缓存机制有两级：

（1）一级缓存：一级缓存mybatsi已经为我们自动开启，不用我们手动操作，而且我们是关闭不了的！！但是我们可以手动清除缓存。（SqlSession级别.提交事务，缓存清空）

一级缓存失效的情况：

  1. 1.不同的SqlSession对应不同的缓存
  2. 2.同一个SqlSession但是查询条件不同
  3. 3.同一个SqlSession执行两次相同查询之间做了增删改的操作
  4. 4.同一个SqlSession执行两次相同查询之间手动清空缓存

（2）二级缓存：二级缓存需要我们手动开启。（全局级别 SqlSessionFactory）

  1. <!--开启二级缓存-->
  3. 开启二级缓存需要两个步骤，第一步在mybatis的全局配置文件中配置Setting属性，设置名为cacheEnabled的属性值为true即可
  4. <settings>
  5.         <!-- 
  6.             (1):开启二级缓存,这个全局的配置二级缓存
  7.                    默认是开启的，但是还是需要写上，防止版本的更新 
  8.         -->
  9.         <setting name="cacheEnabled" value="true"/>
  10. </settings>    
  12. 第二步：在具体需要二级缓存的mapeer映射文件中开启二级缓存，值需要在相应的映射文件中添加一个cache标签即可
  13. 2):在相应的映射文件中开启二级缓存
  14. <!-- 开启二级缓存 -->
  15.  <cache></cache>
  16. 3)查询数据封装的实体类要实现序列化的接口
  17. 4)二级缓存需要在一级缓存关闭或者提交后生效
  19. 二级缓存失效的条件：
  20. 1.在两次查询之间进行了任意的增删改操作，一级二级缓存同时失效
  22. @Test
  23.     public void test02(){
  24.     //验证mybatis的缓存机制  一级缓存 默认开启 sqlsession级别
  26.         try {
  28.             InputStream resource = Resources.getResourceAsStream("config/mybatis-config.xml");
  29.             SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resource);
  30.             SqlSession sqlSession = factory.openSession(true);
  31.             StudentDao mapper1 = sqlSession.getMapper(StudentDao.class);
  32.             StudentDao mapper2 = sqlSession.getMapper(StudentDao.class);
  33.             System.out.println(mapper1);
  34.             System.out.println(mapper2);
  35.             List<Student> a1 = mapper1.getAll();
  36.             System.out.println(a1);
  37.             //手动提交事务 清空缓存
  38.             sqlSession.commit();
  39.             List<Student> a2 = mapper2.getAll();
  40.             System.out.println(a2);
  42.             sqlSession.close();
  43.         } catch (IOException e) {
  45.             e.printStackTrace();
  46.         }
  47.     }
  50.     @Test
  51.     public void test03(){
  52.     //验证mybatis的缓存机制  二级缓存 需要配置mybatis-config.xml  和mapper文件
  54.         try {
  56.             InputStream resource = Resources.getResourceAsStream("config/mybatis-config.xml");
  57.             SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resource);
  58.             SqlSession sqlSession1 = factory.openSession(true);
  59.             SqlSession sqlSession2 = factory.openSession(true);
  60.             SqlSession sqlSession3 = factory.openSession(true);
  62.             StudentDao mapper1 = sqlSession1.getMapper(StudentDao.class);
  63.             StudentDao mapper2 = sqlSession2.getMapper(StudentDao.class);
  64.             StudentDao mapper3 = sqlSession3.getMapper(StudentDao.class);
  65.             List<Student> a1 = mapper1.getAll();
  66.             System.out.println(a1);
  67.             //关闭session将查询结果写入二级缓存
  68.             sqlSession1.close();
  70.             //当对同一张表进行增删改操作后  二级缓存清除
  71.             mapper3.delStudent("2021072901");
  72.            // sqlSession3.close();
  74.             List<Student> a2 = mapper2.getAll();
  75.             System.out.println(a2);
  77.         } catch (IOException e) {
  79.             e.printStackTrace();
  80.         }
  81.     }

mybatis分页插件

  1. <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
  2. <dependency>
  3.     <groupId>com.github.pagehelper</groupId>
  4.     <artifactId>pagehelper</artifactId>
  5.     <version>5.2.1</version>
  6. </dependency>
  8. <!--在mybatis配置文件中 配置mybatis插件 -->
  9.     <plugins>
  10.         <plugin interceptor="com.github.pagehelper.PageInterceptor">
  11.             <!-- 配置mysql方言 -->
  12.             <property name="helperDialect" value="mysql" />
  13.             <!-- 设置为true时，如果pageSize=0就会查询出全部的结果 -->
  14.             <property name="pageSizeZero" value="true" />
  15.             <!-- 3.3.0版本可用，分页参数合理化，默认false禁用 -->
  16.             <!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->
  17.             <!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->
  18.             <property name="reasonable" value="true" />
  19.         </plugin>
  20.     </plugins>

实例

  1. // 测试分页插件的使用
  2.     @Test
  3.     public void  test06(){
  5.         SqlSession session = factory.openSession(true);
  6.         StudentDao mapper = session.getMapper(StudentDao.class);
  7.         PageHelper.startPage(5, 3);
  8.         List<Student> all = mapper.findAll();
  9.         PageInfo<Student> pageInfo = new PageInfo<>(all);
  11.         //获取分页的相关数据
  12.         System.out.println(pageInfo);
  13.         //获取总条数
  14.         long total = pageInfo.getTotal();
  15.         System.out.println(total);
  16.         //获取当前页的显示数据
  17.         List<Student> list = pageInfo.getList();
  18.         list.forEach(student-> System.out.println(student));
  20.     }

name=“helperDialect” value=“mysql” /> 

  1. **实例**
  3. ```java
  4.  // 测试分页插件的使用
  5.     @Test
  6.     public void  test06(){
  7.         SqlSession session = factory.openSession(true);
  8.         StudentDao mapper = session.getMapper(StudentDao.class);
  9.         PageHelper.startPage(5, 3);
  10.         List<Student> all = mapper.findAll();
  11.         PageInfo<Student> pageInfo = new PageInfo<>(all);
  13.         //获取分页的相关数据
  14.         System.out.println(pageInfo);
  15.         //获取总条数
  16.         long total = pageInfo.getTotal();
  17.         System.out.println(total);
  18.         //获取当前页的显示数据
  19.         List<Student> list = pageInfo.getList();
  20.         list.forEach(student-> System.out.println(student));
  22.     }

发表评论

表情：
评论列表 （有 0 条评论，163人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Mybatis框架

    MyBatis框架的作用 MyBatis框架的主要作用是：简化持久层编程。 持久层：处理数据持久化的层。通常，在开发领域，讨论数据时，默认指的是内存中的数据，而内存无法

    红太狼红太狼/ 0 赞/ 161 阅读

    相关 MyBatis框架

    1.对比传统Servlet技术和SSM框架的优缺点？ Servlet是一种运行在支持Java语言的服务器上的组件，用于实现多种网络服务功能，为网络客户提供安全可靠、易于移植的

    不念不忘少年蓝@不念不忘少年蓝@/ 0 赞/ 130 阅读

    相关 Mybatis框架

    什么是Mybits > 是一款优秀的持久层框架, > 他是支持制定SQL, 存储过程以及高级映射 > .它避免了几乎所有JDBC代码和手动设置参数, 以及获取结果集

    落日映苍穹つ落日映苍穹つ/ 0 赞/ 136 阅读