【超详细】MyBatis详解

- 日理万妓 2024-03-29 15:26 140阅读 0赞

目录

一、什么是MyBatis？

二、MyBatis快速入门

三、Mapper代理开发

四、MyBatis核心配置文件

五、配置文件完成增删改查

5.1 环境准备

5.2 功能清单列表

5.2.1 查询

5.2.2 添加

5.2.3 修改

5.2.4 删除

六、MyBatis参数传递

七、注解完成增删改查

八、MyBatis的逆向工程

九、分页插件

一、什么是MyBatis？

  • MyBatis是一款优秀的持久层框架，用于简化JDBC开发。
  • MyBatis本来是Apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github
  • 官网：http://mybatis.org/mybatis-3/zh/index.html

持久层：负责将数据保存到数据库的安那一层代码。

JavaEE三层架构：表现层、业务层、持久层

框架：框架就是一个半成品软件，是一套可重用的、通用的。软件基础代码模型。

在框架的基础上构建软件编写更加高效、规范、通用、可扩展。

94cdd80696bf4c2dab3a40d393897426.png

二、MyBatis快速入门

c2a79577978242abb21ebd05e3941dfd.png mybatis-config.xml的基础配置：

5d683b18eded4043958787efec5183e4.png

userMapper：

11c96ac93b334e9c9bacd896af8c4f77.png Java代码：

  1. public class MyBatisDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  4.         String resource = "mybatis-config.xml";
  5.         //返回一个字节输入流
  6.         InputStream inputStream = Resources.getResourceAsStream(resource);
  7.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  10.         //2.获取SqlSession对象，用它来执行sql
  11.         SqlSession sqlSession = sqlSessionFactory.openSession();
  13.         //3.执行sql
  14.         List<User> users = sqlSession.selectList("test.selectAll");
  16.         System.out.println(users);
  18.         //4.释放资源
  19.         sqlSession.close();
  21.     }
  23. }

95456520e52548f2b7e5c31f6c7256cd.png

三、Mapper代理开发

目的：

  1. 解决原生方式中的硬编码。

2.简化后期执行SQL

a91f620c5f414f17870614c06908f664.png

步骤：使用Mapper代理方式完成入门案例

  1. 定义与sql映射文件（.xml文件）同名的Mapper接口，并且将Mapper接口和sql映射文件放置在同一目录下
  2. 设置sql映射文件的namesapce属性为Mapper全限定名
  3. 在Mapper接口中定义方法，方法名就是sql映射文件中sql语句中的id，并保持参数类型和返回值类型一致
  4. 编码137159bd55f04b65a973877084e7c56c.png

bc368b7a1a8346b881f4d8fe5709adae.png

  1. /**
  2.  * MyBatis 代理开发
  3.  */
  4. public class MyBatisDemo2 {
  5.     public static void main(String[] args) throws IOException {
  6.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  7.         String resource = "mybatis-config.xml";
  8.         //返回一个字节输入流
  9.         InputStream inputStream = Resources.getResourceAsStream(resource);
  10.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  13.         //2.获取SqlSession对象，用它来执行sql
  14.         SqlSession sqlSession = sqlSessionFactory.openSession();
  16.         //3.执行sql
  17.         //List<User> users = sqlSession.selectList("test.selectAll");
  19.         //3.1获取UserMapper接口的代理对象
  20.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  21.         List<User> users = userMapper.selectAll();
  23.         System.out.println(users);
  26.         //4.释放资源
  27.         sqlSession.close();
  29.     }
  31. }

四、MyBatis核心配置文件

18004c5873344d04aa541cdcaf3e451b.png

五、配置文件完成增删改查

" class="reference-link">7071bcc17f244b19b0bef7d6acf3610f.png

5.1 环境准备

  1. 数据库表tb_brand
  2. 实体类Brand
  3. 测试用例
  4. 安装MyBatisX插件

61b436b53dde4f20b0a62a71a449e5ff.png

建议安装1.4X版本，该版本下的resultType实体类对象别名不爆红

5.2 功能清单列表

5.2.1 查询

  1. 查询所有数据
  2. 查看详情
  3. 条件查询

1. 查询所有数据

①编写接口的方法：Mapper接口

  • 参数：无
  • 结果：List

②Map接口

  1. List<Brand> selectAll();

编写SQL语句：编写SQL映射文件

  1. <select id="selectById" resultType="brand">
  2.         select * from tb_brand;
  3.  </select>

③执行方法，测试

  1. @Test
  2.     public void testSelectAll() throws IOException {
  3.         //1.获取SqlSessionFactory
  4.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  5.         String resource = "mybatis-config.xml";
  6.         //返回一个字节输入流
  7.         InputStream inputStream = Resources.getResourceAsStream(resource);
  8.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  11.         //2. 获取sqlSession对象
  12.         SqlSession sqlSession = sqlSessionFactory.openSession();
  14.         //3. 获取Mapper接口的代理对象
  15.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  17.         //4. 执行方法
  18.         List<Brand> brands = brandMapper.selectAll();
  19.         System.out.println(brands);
  21.         //5. 释放资源
  22.         sqlSession.close();
  23.     }

解决数据库表的列名(brand_name)与实体类(brandName)的属性名不匹配方案：

数据库表的字段名称和实体类属性名称不一样，则不能自动封装数据
方案一：起别名：对不一样的列名起别名，让别名和实体类的属性名也一样
缺点：每次查询都要定义一次别名

  1. <select id="selectAll" resultType="brand">
  2.      select id, brand_name as brandName, company_name as companyName,
  3.             ordered,description, status
  4.      from tb_brand;
  5.  </select>

改进：
采用 sql片段

  1. <sql id="brand_column">
  2.     id, brand_name as brandName, company_name as companyName, 
  3.     ordered, description, status 
  4. </sql>
  5. <select id="selectAll" resultType="brand">
  6.     select
  7.     <include refid="brand_column"></include>
  8.     from tb_brand;
  9. </select>

缺点：不灵活

改进：

使用resultMap

resultMap:id为唯一标识
1.定义标签
2.
select *
from tb_brand;

方案二：在mybatis-config.xml中设置中的标签的value值为true

  • 是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。



     
  1.     <!--
  2.         数据库表的字段名称和实体类属性名称不一样，则不能自动封装数据
  3.         *方案一：起别名：对不一样的列名起别名，让别名和实体类的属性名也一样
  4.         *缺点：每次查询都要定义一次别名
  5.                 <select id="selectAll" resultType="brand">
  6.                 select id, brand_name as brandName, company_name as companyName, ordered, description, status
  7.                 from tb_brand;
  8.                 </select>
  9.             *改进：
  10.                 sql片段
  11.            <sql id="brand_column">
  12.                 id, brand_name as brandName, company_name as companyName, ordered, description, status
  13.             </sql>
  14.             <select id="selectAll" resultType="brand">
  15.                 select
  16.                 <include refid="brand_column"></include>
  17.                 from tb_brand;
  18.             </select>
  19.             *缺点：不灵活
  20.                 *resultMap:id为唯一标识
  21.                     1.定义<resultMap>标签
  22.                     2.<select>标签中使用resultMap属性来替换resultType属性
  24.                 <resultMap id="brandResultMap" type="brand">
  25.                     id：完成主键字段的映射
  26.                     column：数据库表的列名
  27.                     property：对应的实体类属性名
  28.                     <result column="brand_name" property="brandName"/>
  29.                     <result column="compnamy_name" property="companyName"/>
  30.                 </resultMap>
  32.                 <select id="selectAll" resultMap="brandResultMap">
  33.                 select *
  34.                 from tb_brand;
  35.                 </select>
  37.         *方案二：在mybatis-config.xml中设置<configuration>中的<setting>标签的value值为true
  38.                 是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。
  39.                 <settings>
  40.                     <setting name="mapUnderscoreToCamelCase" value="faulse"/>
  41.                 </settings>
  42.     -->
  43.     <resultMap id="brandResultMap" type="brand">
  44.         <result column="brand_name" property="brandName"/>
  45.         <!--column：数据库表的列名 property：对应的实体类属性名-->
  46.         <result column="compnamy_name" property="companyName"/>       
  47.     </resultMap>
  49.     <select id="selectAll" resultMap="brandResultMap">
  50.         select *
  51.         from tb_brand;
  52.     </select>
  54.    <!-- <select id="selectAll" resultType="brand">
  55.         select *
  56.         from tb_brand;
  57.         </select>-->
  59. </mapper>

2. 查看详情

①编写接口的方法：Mapper接口

  • 参数：id
  • 结果：Brand对象

②Map接口

  1. Brand selectById(int id);

编写SQL语句：编写SQL映射文件

  1. <select id="selectAllById" resultMap="brandResultMap">
  2.         select *
  3.         from tb_brand where id = #{id};
  4.  </select>
  6. *参数占位符
  7.     1. #{}:将其替换为 ? ,为了防止SQL注入
  8.     2. ${}:拼SQL，会存在SQl注入
  9.     3. 使用时机:
  10.         *参数传递时，用#{}
  11.         *表名或者列名不固定的情况下，${}一定会存在SQL注入问题
  13.  * 参数类型:parameterType:用于设置参数类型，可以省略
  14.  * 特殊字符处理:
  15.       1.转义字符(eg:'<'转义为'<')
  16.       2.CDATA区(CD+enter，CD提示,将符号写在括号内)
  17.         <![CDATA[
  19.         ]]>

③执行方法，测试

  1. <resultMap id="brandResultMap" type="brand">
  2.         <result column="brand_name" property="brandName"/>
  3.         <!--column：数据库表的列名 property：对应的实体类属性名-->
  4.         <result column="company_name" property="companyName"/>
  5.     </resultMap>
  8.     <!--
  9.         *参数占位符
  10.             1. #{}:将其替换为 ? ,为了防止SQL注入
  11.             2. ${}:拼SQL，会存在SQl注入
  12.             3. 使用时机:
  13.                 *参数传递时，用#{}
  14.                 *表名或者列名不固定的情况下，${}一定会存在SQL注入问题
  16.          * 参数类型:parameterType:可以省略
  17.          *特殊字符处理:
  18.               1.转义字符(eg:'<'转义为'<')
  19.               2.CDATA区(CD+enter，将符号写在括号内)
  20.     -->
  21.     <select id="selectAllById" resultMap="brandResultMap">
  22.         select *
  23.         from tb_brand where id = #{id};
  24.     </select>

3. 条件查询

  • 多条件查询：d49aed046ae241f393c499fddc23a7f5.png

①编写接口的方法：

  • 参数：所有查询条件

  • 结果：List

    ②编写SQL语句

散装参数（Mapper接口）：

  1. List<Brand> selectByCondition(@Param("status") int status, @Param("companyName") String companyName, @Param("brandName") String brandName);

对象参数（Mapper接口）：

  1. List<Brand> selectByCondition(Brand brand);

map集合（Mapper接口）： 

  1. List<Brand> selectByCondition(Map map);

SQL语句：编写SQL映射文件

  1. <select id="selectByCondition" resultMap="brandResultMap">
  2.         select *
  3.         from tb_brand
  4.         where status = #{status}
  5.         and company_name like #{companyName}
  6.         and brand_name like #{brandName}
  7. </select>

③执行方法，测试

  1. **参数接收：
  2. *  1.散装参数（如果方法中有多个参数，需要使用@Param（“SQL参数占位符名称”）
  4. @Test
  5.     public void testSelectByCondition() throws IOException {
  7.         //接收参数：
  8.         int status = 1;
  9.         String companyName = "华为";
  10.         String brandName = "华为";
  12.         //处理参数
  13.         companyName = "%" + companyName + "%";
  14.         brandName = "%" + brandName + "%";
  17.         //1.获取SqlSessionFactory
  18.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  19.         String resource = "mybatis-config.xml";
  20.         //返回一个字节输入流
  21.         InputStream inputStream = Resources.getResourceAsStream(resource);
  22.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  25.         //2. 获取sqlSession对象
  26.         SqlSession sqlSession = sqlSessionFactory.openSession();
  28.         //3. 获取Mapper接口的代理对象
  29.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  31.         //4. 执行方法
  32.         List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName);
  34.         System.out.println(brands);
  36.         //5. 释放资源
  37.         sqlSession.close();
  38.     }
  40. *  2.对象参数
  42. ​
  43.   @Test
  44.     public void testSelectByCondition() throws IOException {
  46.         //接收参数：
  47.         int status = 1;
  48.         String companyName = "华为";
  49.         String brandName = "华为";
  51.         //处理参数
  52.         companyName = "%" + companyName + "%";
  53.         brandName = "%" + brandName + "%";
  56.         //1.获取SqlSessionFactory
  57.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  58.         String resource = "mybatis-config.xml";
  59.         //返回一个字节输入流
  60.         InputStream inputStream = Resources.getResourceAsStream(resource);
  61.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  64.         //2. 获取sqlSession对象
  65.         SqlSession sqlSession = sqlSessionFactory.openSession();
  67.         //3. 获取Mapper接口的代理对象
  68.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  70.         //4. 执行方法
  71.         List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName);
  73.         System.out.println(brands);
  75.         //5. 释放资源
  76.         sqlSession.close();
  77.     }
  79. ​
  81. *  3.map集合参数
  83. @Test
  84.     public void testSelectByCondition() throws IOException {
  86.         //接收参数：
  87.         int status = 1;
  88.         String companyName = "华为";
  89.         String brandName = "华为";
  91.         //处理参数
  92.         companyName = "%" + companyName + "%";
  93.         brandName = "%" + brandName + "%";
  95.         //封装对象
  97.         Map map = new HashMap();
  98.         map.put("status",status);
  99.         map.put("companyName",companyName);
  100.         map.put("brandName",brandName);
  102.         //1.获取SqlSessionFactory
  103.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  104.         String resource = "mybatis-config.xml";
  105.         //返回一个字节输入流
  106.         InputStream inputStream = Resources.getResourceAsStream(resource);
  107.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  110.         //2. 获取sqlSession对象
  111.         SqlSession sqlSession = sqlSessionFactory.openSession();
  113.         //3. 获取Mapper接口的代理对象
  114.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  116.         //4. 执行方法
  117.         List<Brand> brands = brandMapper.selectByCondition(map);
  118.         System.out.println(brands);
  120.         //5. 释放资源
  121.         sqlSession.close();
  122.     }

6953b39af3bc469e8a86f9d83a5169e1.png

  • 动态条件查询：9dbb98e5d9f048938147bb9390cda213.png

多条件-动态条件查询

①编写接口的方法：Mapper接口

参数：所有查询条件

结果：List

②Map接口

  1. List<Brand> selectByCondition(@Param("status") int status, @Param("companyName") String companyName, @Param("brandName") String brandName);

编写SQL语句：编写SQL映射文件

  1. <select id="selectByCondition" resultMap="brandResultMap">
  2.         select *
  3.         from tb_brand
  4.         <where>
  5.             <if test="status != null">
  6.                 status = #{status}
  7.             </if>
  8.             <if test="companyName != null and companyName!= ''">
  9.                 and company_name like #{companyName}
  10.             </if>
  12.             <if test="brandName != null and brandName!= ''">
  13.                 and brand_name like #{brandName}
  14.             </if>
  15.         </where>
  16.  </select>

③执行方法，测试

  1. 多条件-动态条件查询
  2.     if:条件判断
  3.         test：逻辑表达式
  4.     问题：只有没有第一个条件时会出现SQL语法错误
  5.         *恒等式：添加"1=1"并将后续语句改为条件一致，构造SQL
  7. select *
  8. from tb_brand
  9. where 1 = 1
  10.     <if test="status != null">
  11.         and  status = #{status}
  12.     </if>
  13.     <if test="companyName != null and companyName!= ''">
  14.         and company_name like #{companyName}
  15.     </if>
  16.     <if test="brandName != null and brandName!= ''">
  17.         and brand_name like #{brandName}
  18.     </if>
  20. *用标签<where> 替换 where 关键字
  22. select *
  23. from tb_brand
  24. <where>
  25.     <if test="status != null">
  26.         status = #{status}
  27.     </if>
  28.     <if test="companyName != null and companyName!= ''">
  29.         and company_name like #{companyName}
  30.      </if>
  31.      <if test="brandName != null and brandName!= ''">
  32.          and brand_name like #{brandName}
  33.      </if>
  34. </where>
  36. @Test
  37.     public void testSelectByCondition() throws IOException {
  39.         //接收参数：
  40.         int status = 1;
  41.         String companyName = "华为";
  42.         String brandName = "华为";
  44.         //处理参数
  45.         companyName = "%" + companyName + "%";
  46.         brandName = "%" + brandName + "%";
  48.         //封装对象
  49.        /* Brand brand = new Brand();
  50.         brand.setStatus(status);
  51.         brand.setCompanyName(companyName);
  52.         brand.setBrandName(brandName);*/
  54.         Map map = new HashMap();
  55.         map.put("status",status);
  56.         map.put("companyName",companyName);
  57.         map.put("brandName",brandName);
  59.         //1.获取SqlSessionFactory
  60.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  61.         String resource = "mybatis-config.xml";
  62.         //返回一个字节输入流
  63.         InputStream inputStream = Resources.getResourceAsStream(resource);
  64.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  67.         //2. 获取sqlSession对象
  68.         SqlSession sqlSession = sqlSessionFactory.openSession();
  70.         //3. 获取Mapper接口的代理对象
  71.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  73.         //4. 执行方法
  74. //      List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName);
  75. //      List<Brand> brands = brandMapper.selectByCondition(brand);
  76.         List<Brand> brands = brandMapper.selectByCondition(map);
  77.         System.out.println(brands);
  79.         //5. 释放资源
  80.         sqlSession.close();
  81.     }
  82. ​

7673c65c60204a4eb82f4aa398c4c154.png

单条件-动态条件查询

  • 从多个条件中选择一个
  • choose（when，otherwise）：选择，类似于Java中的switch语句

①编写接口的方法：Mapper接口

  • 参数：所有查询条件
  • 结果：List

②Mapper接口

  1. List<Brand> selectByConditionSingle(Brand brand);

编写SQL语句：编写SQL映射文件

  1. <select id="selectByConditionSingle" resultMap="brandResultMap">
  2. <!--        select *-->
  3. <!--        from tb_brand-->
  4. <!--        where-->
  5. <!--            <choose><!–相当于switch–>-->
  6. <!--                <when test="status != null">-->
  7. <!--                    status = #{status}-->
  8. <!--                </when><!–相当于case–>-->
  9. <!--                <when test="companyName != null and companyName!= ''">-->
  10. <!--                    company_name like #{companyName}-->
  11. <!--                </when><!–相当于case–>-->
  12. <!--                <when test="brandName != null and brandName!= ''">-->
  13. <!--                    brand_name like #{brandName}-->
  14. <!--                </when><!–相当于case–>-->
  15. <!--                <otherwise><!–相当于default–>-->
  16. <!--                    1 = 1-->
  17. <!--                </otherwise>-->
  18. <!--            </choose>-->
  19. <!--    </select>-->
  20.         select *
  21.         from tb_brand
  22.         <where>
  23.             <choose><!--相当于switch-->
  24.             <when test="status != null">
  25.                 status = #{status}
  26.             </when><!--相当于case-->
  27.             <when test="companyName != null and companyName!= ''">
  28.                 company_name like #{companyName}
  29.             </when><!--相当于case-->
  30.             <when test="brandName != null and brandName!= ''">
  31.                 brand_name like #{brandName}
  32.             </when><!--相当于case-->
  33.             </choose>
  34.         </where>
  35. </select>

③执行方法，测试

  1. 单条件-动态条件查询
  2.     choose(when,otherwise):选择，类似于Java中的switch语句
  3.         test：逻辑表达式
  4.     问题：只有没有条件时会出现SQL语法错误
  5.         *恒等式：添加"1=1"构造SQL使之符合语法。
  7. <select id="selectByConditionSingle" resultMap="brandResultMap">
  8.         select *
  9.         from tb_brand
  10.         where
  11.             <choose><!--相当于switch-->
  12.                 <when test="status != null">
  13.                     status = #{status}
  14.                 </when><!--相当于case-->
  15.                 <when test="companyName != null and companyName!= ''">
  16.                     company_name like #{companyName}
  17.                 </when><!--相当于case-->
  18.                 <when test="brandName != null and brandName!= ''">
  19.                     brand_name like #{brandName}
  20.                 </when><!--相当于case-->
  21.                 <otherwise><!--相当于default-->
  22.                     1 = 1
  23.                 </otherwise>
  24.             </choose>
  25.  </select>
  27. *用标签<where> 替换 where 关键字
  29. <select id="selectByConditionSingle" resultMap="brandResultMap">
  30.         select *
  31.         from tb_brand
  32.         <where>
  33.             <choose><!--相当于switch-->
  34.             <when test="status != null">
  35.                 status = #{status}
  36.             </when><!--相当于case-->
  37.             <when test="companyName != null and companyName!= ''">
  38.                 company_name like #{companyName}
  39.             </when><!--相当于case-->
  40.             <when test="brandName != null and brandName!= ''">
  41.                 brand_name like #{brandName}
  42.             </when><!--相当于case-->
  43.             </choose>
  44.         </where>
  45.  </select>
  47. @Test
  48.     public void testSelectByCondition() throws IOException {
  50.         //接收参数：
  51.         int status = 1;
  52.         String companyName = "华为";
  53.         String brandName = "华为";
  55.         //处理参数
  56.         companyName = "%" + companyName + "%";
  57.         brandName = "%" + brandName + "%";
  59.         //封装对象
  60.         Brand brand = new Brand();
  61.         //brand.setStatus(status);
  62.         brand.setCompanyName(companyName);
  63.         //brand.setBrandName(brandName);
  65.         //1.获取SqlSessionFactory
  66.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  67.         String resource = "mybatis-config.xml";
  68.         //返回一个字节输入流
  69.         InputStream inputStream = Resources.getResourceAsStream(resource);
  70.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  73.         //2. 获取sqlSession对象
  74.         SqlSession sqlSession = sqlSessionFactory.openSession();
  76.         //3. 获取Mapper接口的代理对象
  77.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  79.         //4. 执行方法
  80. //      List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName);
  81. //      List<Brand> brands = brandMapper.selectByCondition(brand);
  82.         List<Brand> brands = brandMapper.selectByCondition(map);
  83.         System.out.println(brands);
  85.         //5. 释放资源
  86.         sqlSession.close();
  87.     }
  88. ​

5.2.2 添加

①编写接口的方法：Mapper接口

  1. void add(Brand brand);
  • 参数：除id之外的所有数据
  • 结果：void

②编写SQL语句、编写SQL映射文件

  1. <insert id="add">
  2.         insert into tb_brand (brand_name, company_name, ordered, description, status)
  3.         values (#{brandName},#{companyName},#{ordered},#{description},#{status});
  4. </insert>

③执行方法，测试

  1. @Test
  2.     public void testadd() throws IOException {
  4.         //接收参数：
  5.         int status = 1;
  6.         String companyName = "波导手机";
  7.         String brandName = "波导";
  8.         String description = "手机中的战斗机";
  9.         int ordered = 100;
  12.         //封装对象
  13.         Brand brand = new Brand();
  14.         brand.setStatus(status);
  15.         brand.setCompanyName(companyName);
  16.         brand.setBrandName(brandName);
  17.         brand.setDescription(description);
  18.         brand.setOrdered(ordered);
  20.         //1.获取SqlSessionFactory
  21.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  22.         String resource = "mybatis-config.xml";
  23.         //返回一个字节输入流
  24.         InputStream inputStream = Resources.getResourceAsStream(resource);
  25.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  28.         //2. 获取sqlSession对象
  29. //        SqlSession sqlSession = sqlSessionFactory.openSession();
  30.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
  31.         //3. 获取Mapper接口的代理对象
  32.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  34.         //4. 执行方法
  35.         brandMapper.add(brand);
  37.         //提交事务
  38. //        sqlSession.commit();
  40.         //5. 释放资源
  41.         sqlSession.close();
  42.     }

Mybatis事务：

openSession（）：默认开启事务，进行增删改后需要使用sqlSession.commit();手动提交事务

openSession（true）：可以设置为自动提交事务（默认为false:手动提交事务）

****添加—-主键返回 ****

在数据添加成功后，需要获取插入数据库数据的主键的值

c3e38e80ca7d45fdb75a33534e364204.png

比如：添加订单和订单项

1.添加订单

2.添加订单项，订单项中需要设置所属订单的id

  1. <insert id="add" useGeneratedKeys="true" keyProperty="id">
  2.         insert into tb_brand (brand_name, company_name, ordered, description, status)
  3.         values (#{brandName},#{companyName},#{ordered},#{description},#{status});
  4. </insert>

5.2.3 修改

  1. 修改所有字段
  2. 修改动态字段

1.修改所有字段

①编写接口的方法：Mapper接口

  1. void update(Brand brand);
  • 参数：所有数据
  • 结果：void

②编写SQL语句：编写SQL映射文件

  1. <update id="update">
  2.         update tb_brand
  3.         set brand_name = #{brandName},
  4.             company_name = #{companyName},
  5.             ordered = #{ordered},
  6.             description = #{description},
  7.             status = #{status}
  8.         where id = #{id};
  9.     </update>

③执行方法，测试

  1. /**
  2.      * 修改
  3.      * @throws IOException
  4.      */
  5.     @Test
  6.     public void testUpdate() throws IOException {
  8.         //接收参数：
  9.         int status = 1;
  10.         String companyName = "波导手机";
  11.         String brandName = "波导";
  12.         String description = "波导手机，手机中的战斗机";
  13.         int ordered = 200;
  15.         int id = 5;
  17.         //封装对象
  18.         Brand brand = new Brand();
  19.         brand.setStatus(status);
  20.         brand.setCompanyName(companyName);
  21.         brand.setBrandName(brandName);
  22.         brand.setDescription(description);
  23.         brand.setOrdered(ordered);
  24.         brand.setId(id);
  26.         //1.获取SqlSessionFactory
  27.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  28.         String resource = "mybatis-config.xml";
  29.         //返回一个字节输入流
  30.         InputStream inputStream = Resources.getResourceAsStream(resource);
  31.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  34.         //2. 获取sqlSession对象
  35.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
  36.         //3. 获取Mapper接口的代理对象
  37.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  39.         //4. 执行方法
  40.         int count = brandMapper.update(brand);
  42.         System.out.println(count);
  44.         //5. 释放资源
  45.         sqlSession.close();
  46.     }

2. 修改动态字段

①编写接口的方法：Mapper接口

  1. void update(Brand brand);
  • 参数：所有数据
  • 结果：void

②编写SQL语句：编写SQL映射文件

  1. <update id="update">
  2.         update tb_brand
  3.         <set>
  4.             <if test="brandName != null and brandName!= ''">
  5.                 brand_name = #{brandName},
  6.             </if>
  7.             <if test="companyName != null and brandName!= ''">
  8.                 company_name = #{companyName},
  9.             </if>
  10.             <if test="ordered != null">
  11.                 ordered = #{ordered},
  12.             </if>
  13.             <if test="description != null and brandName!= ''">
  14.                 description = #{description},
  15.             </if>
  16.             <if test="status != null">
  17.                 status = #{status}
  18.             </if>
  19.         </set>
  20.         where id = #{id};
  21.     </update>

③执行方法，测试

  1. /**
  2.      * 修改动态字段
  3.      * @throws IOException
  4.      */
  5.     @Test
  6.     public void testUpdate() throws IOException {
  8.         //接收参数：
  9.         int status = 0;
  10.         String companyName = "波导手机";
  11.         String brandName = "波导";
  12.         String description = "波导手机，手机中的战斗机";
  13.         int ordered = 200;
  15.         int id = 7;
  17.         //封装对象
  18.         Brand brand = new Brand();
  19.         brand.setStatus(status);
  20. //        brand.setCompanyName(companyName);
  21. //        brand.setBrandName(brandName);
  22. //        brand.setDescription(description);
  23. //        brand.setOrdered(ordered);
  24.         brand.setId(id);
  26.         //1.获取SqlSessionFactory
  27.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  28.         String resource = "mybatis-config.xml";
  29.         //返回一个字节输入流
  30.         InputStream inputStream = Resources.getResourceAsStream(resource);
  31.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  34.         //2. 获取sqlSession对象
  35.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
  36.         //3. 获取Mapper接口的代理对象
  37.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  39.         //4. 执行方法
  40.         int count = brandMapper.update(brand);
  42.         System.out.println(count);
  44.         //5. 释放资源
  45.         sqlSession.close();
  46.     }

5.2.4 删除

  1. 删除一个
  2. 批量删除

1. 删除一个

①编写接口的方法：Mapper接口

  1. void update(Brand brand);
  • 参数：id
  • 结果：void

②编写SQL语句：编写SQL映射文件

  1. <select id="deleteById">
  2.     delete from tb_brand where id = #{id};
  3. </select>

③执行方法，测试

  1. /**
  2.      * 根据Id删除一个
  3.      * @throws IOException
  4.      */
  5.     @Test
  6.     public void testDeleteById() throws IOException {
  8.         //接收参数：
  9.         int id = 9;
  11.         //1.获取SqlSessionFactory
  12.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  13.         String resource = "mybatis-config.xml";
  14.         //返回一个字节输入流
  15.         InputStream inputStream = Resources.getResourceAsStream(resource);
  16.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  19.         //2. 获取sqlSession对象
  20.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
  21.         //3. 获取Mapper接口的代理对象
  22.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  24.         //4. 执行方法
  25.         brandMapper.deleteById(id);
  28.         //5. 释放资源
  29.         sqlSession.close();
  30.     }

2. 批量删除

①编写接口的方法：Mapper接口

  1. void update(Brand brand);
  • 参数：id数组
  • 结果：void

②编写SQL语句：编写SQL映射文件

  1. <!--
  2.         Mybatis会将数组参数封装为一个Map集合。
  3.             *默认：array = 数组
  4.             *可以使用@Param注解改变map集合的默认key名称
  5.     -->
  6.    <!-- <delete id="deleteByIds">
  7.         delete from tb_brand where id
  8.          in
  9.         /*
  10.         **separator:分隔符
  11.         **open:循环开始前的字符
  12.         **close：循环结束后的字符
  13.         */
  14.              <foreach collection="ids" item="id" separator="," open="(" close=")">
  15.                  #{id}
  16.              </foreach>;
  17.     </delete>-->
  18. <delete id="deleteByIds">
  19.         delete from tb_brand where id
  20.         in
  21.         /*
  22.         **separator:分隔符
  23.         **open:循环开始前的字符
  24.         **close：循环结束后的字符
  25.         */
  26.         <foreach collection="array" item="id" separator="," open="(" close=")">
  27.             #{id}
  28.         </foreach>;
  29. </delete>

③执行方法，测试

  1. /**
  2.      * 根据Id删除一个
  3.      * @throws IOException
  4.      */
  5.     @Test
  6.     public void testDeleteById() throws IOException {
  8.         //接收参数：
  9.         int id = 9;
  11.         //1.获取SqlSessionFactory
  12.         //加载mybatis的核心配置文件，获取SqlSessionFactory
  13.         String resource = "mybatis-config.xml";
  14.         //返回一个字节输入流
  15.         InputStream inputStream = Resources.getResourceAsStream(resource);
  16.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  19.         //2. 获取sqlSession对象
  20.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
  21.         //3. 获取Mapper接口的代理对象
  22.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  24.         //4. 执行方法
  25.         brandMapper.deleteById(id);
  27.         //5. 释放资源
  28.         sqlSession.close();
  29.     }

注意：

  1. Mybatis会将数组参数封装为一个Map集合。
  2.     *默认：array = 数组
  3.     *可以使用@Param注解改变map集合的默认key名称
  5. delete from tb_brand where id
  6.  in
  7. /*
  8. **separator:分隔符
  9. **open:循环开始前的字符
  10. **close：循环结束后的字符
  11. */
  12.      <foreach collection="ids" item="id" separator="," open="(" close=")">
  13.          #{id}
  14.      </foreach>;

六、MyBatis参数传递

1136eb2aa6e24166bab586faca73ff9d.png

9447471c21ba4fe6b59818c54958dabe.png

七、注解完成增删改查

a17a7ece83ad4223a8e631745265945e.png

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

选择何种方式来配置映射，以及是否应该要统一映射语句定义的形式，完全取决于你和你的团队。 换句话说，永远不要拘泥于一种方式，你可以很轻松地在基于注解和 XML 的语句映射方式间自由移植和切换。

八、MyBatis的逆向工程

自动生成Mapper接口和对应的实体类以及映射文件

generatorConfig.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE generatorConfiguration
  3.         PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
  4. <generatorConfiguration>
  5.     <!--
  6.     targetRuntime: 执行生成的逆向工程的版本
  7.     MyBatis3Simple: 生成基本的CRUD（清新简洁版）
  8.     MyBatis3: 生成带条件的CRUD（奢华尊享版）
  9.     -->
  10.     <context id="DB2Tables" targetRuntime="MyBatis3">
  11.         <!-- 数据库的连接信息 -->
  12.         <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"
  13.                         userId="root" password="4">
  14.         </jdbcConnection>
  15.         <!-- javaBean的生成策略-->
  16.         <javaModelGenerator targetPackage="com.itguigu.mybatis.pojo" targetProject=".\src\main\java">
  17.             <property name="enableSubPackages" value="true" />
  18.             <property name="trimStrings" value="true" />
  19.         </javaModelGenerator>
  20.         <!-- SQL映射文件的生成策略 -->
  21.         <sqlMapGenerator targetPackage="com.itguigu.mybatis.mapper" targetProject=".\src\main\resources">
  22.             <property name="enableSubPackages" value="true" />
  23.         </sqlMapGenerator>
  24.         <!-- Mapper接口的生成策略 -->
  25.         <javaClientGenerator type="XMLMAPPER" targetPackage="com.atguigu.mybatis.mapper"    targetProject=".\src\main\java">
  26.             <property name="enableSubPackages" value="true" />
  27.         </javaClientGenerator>
  28.         <!-- 逆向分析的表 -->
  29.         <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
  30.         <!-- domainObjectName属性指定生成出来的实体类的类名 -->
  31.         <table tableName="t_emp" domainObjectName="Emp"/>
  32.         <table tableName="t_dept" domainObjectName="Dept"/>
  33.     </context>
  34. </generatorConfiguration>

mybatis-config.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">
  7. <configuration>
  9.     <properties resource="jdbc.properties"></properties>
  10.     <settings>
  11.         <setting name="mapUnderscoreToCamelCase" value="true"/>
  12.     </settings>
  13.     <typeAliases>
  14.         <package name="com.itguigu.mybatis.pojo"/>
  15.     </typeAliases>
  16.     <environments default="development">
  17.         <environment id="development">
  18.             <transactionManager type="JDBC"/>
  19.             <dataSource type="POOLED">
  20.                 <property name="driver" value="${jdbc.driver}"/>
  21.                 <property name="url" value="${jdbc.url}"/>
  22.                 <property name="username" value="${jdbc.username}"/>
  23.                 <property name="password" value="${jdbc.password}"/>
  24.             </dataSource>
  25.         </environment>
  26.     </environments>
  28.     <!--引入mybatis的映射文件-->
  29.     <mappers>
  30.         <package name="com.itguigu.mybatis.mapper"/>
  31.     </mappers>
  33. </configuration>

pom文件中引入的依赖：

  1. <packaging>jar</packaging>
  2.     <!--mybatis核心jar包-->
  3.     <dependencies>
  4.         <dependency>
  5.             <groupId>org.mybatis</groupId>
  6.             <artifactId>mybatis</artifactId>
  7.             <version>3.5.7</version>
  8.         </dependency>
  9.         <!-- junit测试 -->
  10.         <dependency>
  11.             <groupId>junit</groupId>
  12.             <artifactId>junit</artifactId>
  13.             <version>4.12</version>
  14.             <scope>test</scope>
  15.         </dependency>
  17.         <!-- log4j日志 -->
  18.         <dependency>
  19.             <groupId>log4j</groupId>
  20.             <artifactId>log4j</artifactId>
  21.             <version>1.2.17</version>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>mysql</groupId>
  25.             <artifactId>mysql-connector-java</artifactId>
  26.             <version>8.0.16</version>
  27.         </dependency>
  28.     </dependencies>
  30.     <!-- 控制Maven在构建过程中相关配置 -->
  31.     <build>
  33.         <!-- 构建过程中用到的插件 -->
  34.         <plugins>
  36.             <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
  37.             <plugin>
  38.                 <groupId>org.mybatis.generator</groupId>
  39.                 <artifactId>mybatis-generator-maven-plugin</artifactId>
  40.                 <version>1.3.0</version>
  42.                 <!-- 插件的依赖 -->
  43.                 <dependencies>
  45.                     <!-- 逆向工程的核心依赖 -->
  46.                     <dependency>
  47.                         <groupId>org.mybatis.generator</groupId>
  48.                         <artifactId>mybatis-generator-core</artifactId>
  49.                         <version>1.3.2</version>
  50.                     </dependency>
  52.                     <!-- MySQL驱动 -->
  53.                     <dependency>
  54.                         <groupId>mysql</groupId>
  55.                         <artifactId>mysql-connector-java</artifactId>
  56.                         <version>8.0.16</version>
  57.                     </dependency>
  58.                 </dependencies>
  59.             </plugin>
  60.         </plugins>
  61.     </build>

然后点击Idea中右侧Maven中的mybatis-generator插件即可自动生成。

九、分页插件

limit index，pageSize

index：当前页的起始索引，index=（pageNum-1）*pageSize

pageSize：每页显示条数

pageNum：当前页的页码

count：总记录数

totalPage：总页数

if（count%pageSize !=0）{

totalPage+=1；

}

导入依赖：

  1. <dependency>
  2.             <groupId>com.github.pagehelper</groupId>
  3.             <artifactId>pagehelper</artifactId>
  4.             <version>5.2.0</version>
  5.         </dependency>

同时还需要在核心配置文件中配置：

  1. <plugins>
  2.         <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
  3.     </plugins>

查询功能开启前要开启分页功能：

  1. Page<Object> page = PageHelper.startPage(1, 4);

分页数据：

  1. PageInfo<Emp> pageInfo = new PageInfo<>(emps, 5);

分页相关数据：

PageInfo{
pageNum=8, pageSize=4, size=2, startRow=29, endRow=30, total=30, pages=8,
list=Page{count=true, pageNum=8, pageSize=4, startRow=28, endRow=32, total=30,
pages=8, reasonable=false, pageSizeZero=false},
prePage=7, nextPage=0, isFirstPage=false, isLastPage=true, hasPreviousPage=true,
hasNextPage=false, navigatePages=5, navigateFirstPage4, navigateLastPage8,
navigatepageNums=[4, 5, 6, 7, 8]
}
pageNum：当前页的页码
pageSize：每页显示的条数
size：当前页显示的真实条数
total：总记录数
pages：总页数
prePage：上一页的页码
nextPage：下一页的页码
isFirstPage/isLastPage：是否为第一页/最后一页
hasPreviousPage/hasNextPage：是否存在上一页/下一页
navigatePages：导航分页的页码数
navigatepageNums：导航分页的页码，[1,2,3,4,5]

发表评论

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

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

相关阅读