devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Mybatis学习笔记_mybatis框架学习笔记

作者：喵喵爱编程 | 2024-07-14 02:30:23

赞

踩

mybatis框架学习笔记

Mybatis简介

1、Mybatis是什么？

        Mybatis是一个半自动的ORM持久层框架，支持自定义SQL、存储过程和高级映射。可以使用简单的xml或注解用于配置和原始映射，将接口和java的pojo(普通的java对象)映射成数据库中的记录

        什么是ORM？

        Object Relation Mapping，对象关系映射，对象指的是java对象，关系指的是数据库中的关系模型。所谓的对象关系映射指的是java对象和数据库的关系模型之间建立的一种对应关系。

2、Mybatis执行过程

（1）加载配置。配置来源于两个地方，一个是配置文件，一个是java代码上的注释。将SQL的配置信息加载成为一个个MappedStatement对象（包括传入参数映射配置、执行的SQL语句，结果映射配置），存储到内存中

（2）SQL解析。API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（Map、JavaBean或基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入的参数对象对MappedStatement进行解析，解析后获得最终要执行的SQL语句和参数。

（3）SQL执行。将最终得到的SQL和参数拿到数据库执行，得到操作数据的结果

（4）结果映射。将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回。

第一个Mybatis程序

1、创建maven项目

2、导入依赖

  1. <dependencies>
  2.     <!--mybatis核心-->
  3.     <dependency>
  4.         <groupId>org.mybatis</groupId>
  5.         <artifactId>mybatis</artifactId>
  6.         <version>3.5.7</version>
  7.     </dependency>
  8.  
  9.     <!--junit测试-->
  10.     <dependency>
  11.         <groupId>junit</groupId>
  12.         <artifactId>junit</artifactId>
  13.         <version>4.12</version>
  14.         <scope>test</scope>
  15.     </dependency>
  16.  
  17.     <!--mysql驱动-->
  18.     <dependency>
  19.         <groupId>mysql</groupId>
  20.         <artifactId>mysql-connector-java</artifactId>
  21.         <version>5.1.3</version>
  22.     </dependency>
  23.     
  24.     <!--lombok-->
  25.     <dependency>
  26.         <groupId>org.projectlombok</groupId>
  27.         <artifactId>lombok</artifactId>
  28.         <version>1.18.24</version>
  29.     </dependency>
  30. </dependencies>

3、在resource下创建mybatis核心配置文件

（1）先在resource下创建文件jdbc.properties：

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/自己的数据库名称?userSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC
  3. jdbc.username=数据库用户名
  4. jdbc.password=数据库密码

（2）在resource下创建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">
  5. <configuration>
  6.     <!--引入properties文件-->
  7.     <properties resource="jdbc.properties" />    
  8.     <!--配置连接数据库的环境-->
  9.     <environments default="development">
  10.         <environment id="development">
  11.             <transactionManager type="JDBC"/>
  12.             <dataSource type="POOLED">
  13.                 <property name="driver" value="${jdbc.driver}"/>
  14.                 <property name="url" value="${jdbc.url}"/>
  15.                 <property name="username" value="${jdbc.username}"/>
  16.                 <property name="password" value="${jdbc.password}"/>
  17.             </dataSource>
  18.         </environment>
  19.     </environments>
  20.     <!--引入映射文件-->
  21.     <mappers>
  22.         <mapper resource=""/>
  23.     </mappers>
  24. </configuration>

4、创建mapper接口

（1）创建数据库表user：

  1. DROP TABLE IF EXISTS `user`;
  2. CREATE TABLE `user`  (
  3.   `id` int(11) NOT NULL AUTO_INCREMENT,
  4.   `username` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  5.   `password` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  6.   `age` int(11) NULL DEFAULT NULL,
  7.   `sex` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  8.   `email` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  9.   PRIMARY KEY (`id`) USING BTREE
  10. ) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  11.  
  12. SET FOREIGN_KEY_CHECKS = 1;

（2）创建java实体类TUser（对应数据库表）：

  1. package com.cyj.mybatis.pojo;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.EqualsAndHashCode;
  5. import lombok.NoArgsConstructor;
  6. @Data
  7. @AllArgsConstructor
  8. @NoArgsConstructor
  9. @EqualsAndHashCode
  10. public class TUser {
  11.     private Integer id;
  12.     private String username;
  13.     private String password;
  14.     private Integer age;
  15.     private String sex;
  16.     private String email;
  17. }

 （3） 创建mapper接口UserMapper：

  1. package com.cyj.mybatis.mapper;
  2. public interface UserMapper {
  3.      int insertUser();
  4. }

5、在resource下创建com/cyj/mybatis/mapper包，在该包下创建Mybatis映射文件UserMapper.xml

        要注意的点：

        1、映射文件的namespace的值要和mapper接口的全类名相同。

        2、映射文件的SQL语句的id要和mapper接口中的方法名一致。

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5.  
  6. <!--mapper接口的全类名-->
  7. <mapper namespace="com.cyj.mybatis.mapper.UserMapper">
  8.     <insert id="insertUser">
  9.         insert into user values(null, '王五', '123456', 25, '女', 'wangwu@163.com')
  10.     </insert>
  11. </mapper>

6、在核心配置文件mybatis-config.xml中引入映射文件

  1.  <mappers>
  2.         <!--以包为单位引入映射文件-->
  3.         <package name="com.cyj.mybatis.mapper"/>
  4.     </mappers>

       此时的项目结构截图

7、测试

  1. @Test
  2. public void testMybatis() throws IOException {
  3.     //加载核心配置文件
  4.     InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
  5.     //获取SqlSessionFactoryBuilder
  6.     SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
  7.     //获取SqlSessionFactory
  8.     SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
  9.     //获取SqlSession，并设置自动提交
  10.     SqlSession sqlSession = sqlSessionFactory.openSession(true);
  11.     //获取mapper接口对象
  12.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  13.     //测试功能
  14.     int i = userMapper.insertUser();
  15.     System.out.println("i:" + i);
  16. }

Mybatis核心配置文件Mybatis-config.xml解析

        核心配置文件中的标签必须按照顺序写：

  1. configuration
  2.     properties（属性）
  3.     settings（设置）
  4.     typeAliases（类型别名）
  5.     typeHandlers（类型处理器）
  6.     objectFactory（对象工厂）
  7.     plugins（插件）
  8.     environments（环境配置）
  9.     environment（环境变量）
  10.     transactionManager（事务管理器）
  11.     dataSource（数据源）
  12.     databaseIdProvider（数据库厂商标识）
  13.     mappers（映射器）
  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.     <!--引入properties文件，此时就可以${属性名}的方式访问属性值-->
  7.     <properties resource="jdbc.properties" />
  8.     
  9.     <settings>
  10.         <!--将表中字段的下划线自动转换为驼峰-->
  11.         <setting name="mapUnderscoreToCamelCase" value="true"/>
  12.         <!--开启延迟加载-->
  13.         <setting name="lazyLoadingEnabled" value="true"/>
  14.     </settings>
  15.     
  16.     <!--设置类型别名-->
  17.     <typeAliases>
  18.         <!--二选一，一般用第二个-->
  19.         <!--设置单个的类型别名,别名不区分大小写-->
  20.         <typeAlias type="com.cyj.mybatis.pojo.User" alias="User"></typeAlias>
  21.         <!--设置包下的所有类型别名，默认为实体类名-->
  22.         <package name="com.cyj.mybatis.pojo"/>
  23.     </typeAliases>
  24.     
  25.     <!--配置连接数据库的环境-->
  26.     <environments default="development">
  27.         <environment id="development">
  28.             <!--
  29.             transactionManager：设置事务管理方式
  30.             属性：
  31.             type：设置事务管理方式，type="JDBC/MANAGED"
  32.             type="JDBC"：设置当前环境的事务管理都必须手动处理
  33.             type="MANAGED"：设置事务被管理，例如spring中的AOP
  34.             -->
  35.             <transactionManager type="JDBC"/>
  36.             <!--
  37.             dataSource：设置数据源
  38.             属性：
  39.             type：设置数据源的类型，type="POOLED/UNPOOLED/JNDI"
  40.             type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
  41.             type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
  42.             type="JNDI"：调用上下文中的数据源
  43.             -->
  44.             <dataSource type="POOLED">
  45.                 <property name="driver" value="${jdbc.driver}"/>
  46.                 <property name="url" value="${jdbc.url}"/>
  47.                 <property name="username" value="${jdbc.username}"/>
  48.                 <property name="password" value="${jdbc.password}"/>
  49.             </dataSource>
  50.         </environment>
  51.     </environments>
  52.     
  53.     <!--引入映射文件-->
  54.     <mappers>
  55.         <!--二选一-->
  56.         <!--1、单独引入映射文件-->
  57.         <mapper resource="com\cyj\mybatis\mapper\UserMapper.xml"/>
  58.         <!--
  59.         2、以包为单位引入映射文件：
  60.             （1）mapper接口所在的包要和映射文件所在的包一致
  61.             （2）mapper接口要和映射文件的名字一致
  62.         -->
  63.         <package name="com.cyj.mybatis.mapper"/>
  64.     </mappers>
  65. </configuration>

SqlSession工具类，用来获取SqlSession

  1. package com.cyj.mybatis.utils;
  2. import org.apache.ibatis.io.Resources;
  3. import org.apache.ibatis.session.SqlSession;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8.  
  9. public class SqlSessionUtils {
  10.     public static SqlSession getSqlSession(){
  11.         SqlSession sqlSession = null;
  12.         try {
  13.             InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
  14.             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  15.             sqlSession = sqlSessionFactory.openSession(true);
  16.         } catch (IOException e) {
  17.             e.printStackTrace();
  18.         }
  19.         return sqlSession;
  20.     }
  21. }

Mybatis的增删改查

        UserMapper接口

  1. /**
  2.  * 增加用户
  3.  * @return
  4.  */
  5. int insertUser();
  6.  
  7. /**
  8.  * 删除用户
  9.  * @return
  10.  */
  11. int deleteUser();
  12.  
  13. /**
  14.  * 修改用户
  15.  * @return
  16.  */
  17. int updateUser();
  18.  
  19. /**
  20.  * 查询单个用户
  21.  * @return
  22.  */
  23. TUser selectUser();
  24.  
  25. /**
  26.  * 查询所有用户
  27.  * @return
  28.  */
  29. List<TUser> selectAllUser();

        映射文件

  1. <!--int insertUser();-->
  2. <insert id="insertUser">
  3.     insert into user values(null, '田七', '123456', 28, '女', 'tianqi@163.com')
  4. </insert>
  5.  
  6. <!--int deleteUser();-->
  7. <delete id="deleteUser">
  8.     delete from user where id = 6
  9. </delete>
  10.  
  11. <!--int updateUser();-->
  12. <update id="updateUser">
  13.     update user set age = 50 where id = 5;
  14. </update>
  15.  
  16. <!--TUser selectUserByUsername();-->
  17. <select id="selectUser" resultType="com.cyj.mybatis.pojo.TUser">
  18.     select * from user where username = "张三"
  19. </select>
  20.  
  21. <!--List<TUser> selectAllUser();-->
  22. <select id="selectAllUser" resultType="com.cyj.mybatis.pojo.TUser">
  23.     select * from user;
  24. </select>

        测试

  1. @Test
  2. public void InsertUserTest(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  5.     int insertUser = userMapper.insertUser();
  6.     System.out.println("insertUser:" + insertUser);
  7. }
  8.  
  9. @Test
  10. public void DeleteUserTest(){
  11.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  12.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  13.     int deleteUser = userMapper.deleteUser();
  14.     System.out.println("insertUser:" + deleteUser);
  15. }
  16.  
  17. @Test
  18. public void UpdateUserTest(){
  19.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  20.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  21.     int updateUser = userMapper.updateUser();
  22.     System.out.println("insertUser:" + updateUser);
  23. }
  24.  
  25. @Test
  26. public void SelectUserTest(){
  27.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  28.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  29.     TUser user = userMapper.selectUser();
  30.     System.out.println("User:" + user);
  31. }
  32.  
  33. @Test
  34. public void SelectALlUserTest(){
  35.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  36.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  37.     List<TUser> userList = userMapper.selectAllUser();
  38.     for (TUser user : userList) {
  39.         System.out.println(user);
  40.     }
  41. }

查询功能需要在标签中设置resultType或者resultMap，用于设置实体类和数据库表的映射关系

        resultType：设置默认的映射关系，自动映射，用于属性名和表中字段名一致的情况

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

Mybatis获取参数值的两种方式

        ${}：本质是字符串拼接，使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号

        #{}：本质是占位符赋值，使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，不需要手动添加单引号

1、单个字面量类型的参数

  1. <!--User getUserByUsername(String username);-->
  2. <!--#{}-->
  3. <select id="getUserByUsername" resultType="com.cyj.mybatis.pojo.User">
  4.     select * from user where username = #{username}
  5. </select>
  6.  
  7. <!--${}-->
  8. <select id="getUserByUsername" resultType="com.cyj.mybatis.pojo.User">
  9.     select * from user where username = '#{username}'
  10. </select>

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

Mybatis会将这些参数存放在map集合中，以两种方式进行存储

（1）以arg0、arg1......为键，参数为值

（2）以param1、param2......为键，以参数为值

  1. <!--User CheckUserLogin(String username, String password);-->
  2. <!--#{}-->
  3. <select id="checkUserLogin" resultType="com.cyj.mybatis.pojo.User">
  4.     select * from user where username = #{arg0} and password = #{arg1}
  5.     或者
  6.     select * form user where username = #{param1} and password = #{param2}
  7. </select>
  8.  
  9. <!--${}-->
  10. <select id="checkUserLogin" resultType="com.cyj.mybatis.pojo.User">
  11.     select * from user where username = '${arg0}' and password = '${arg1}'
  12.     或者
  13.     select * form user where username = '${param1}' and password = '${param2}'
  14. </select>

3、实体类类型的参数

  1. <!--int insetUser(User user);-->
  2. <!--#{}-->
  3. <insert id="insetUser">
  4.     insert into user values(null, #{username}, #{password}, #{age}, #{sex}, #{email})
  5. </insert>
  6.  
  7. <!--${}-->
  8. <insert id="insetUser">
  9.     insert into user values(null, '${username}', '${password}', '${age}', '${sex}', '${email}')
  10. </insert>

4、使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中

（1）以@Param注解的value属性值为键，以参数为值；

（2）以param1,param2...为键，以参数为值；

  1.  User checkLogin(@Param("username") String username, @Param("password") String password);
  2.  
  3. //Mybatis会将这些参数存放在map集合中，以两种方式进行存储
  4.     （1）以命名的字符串为键，参数为值
  5.     （2）以param1、param2......为键，以参数为值
  6. <select id="checkLogin" resultType="com.cyj.mybatis.pojo.User">
  7.     select * from user where username = #{username} and password = #{password}
  8.     //或者
  9.     select * from user where username = '${username}' and password = '${password}'
  10.     //或者
  11.     select * form user where username = #{param1} and password = #{param2}
  12.     //或者
  13.     select * form user where username = '${param1}' and password = '${param2}'
  14. </select>

Mybatis特殊查询

1、模糊查询

  1. List<User> getUserByUsername(@Param("username") String username);
  2.  
  3. select * from user where username like '%${username}%';
  4. //或者
  5. select * from user where username like concat('%', #{username}}, '%');
  6. //或者
  7. select * from user where username like "%"#{username}"%";

2、批量删除

        只能使用${}。如果使用#{}，则解析后的sql语句为delete from t_user where id in ('1,2,3')，这样是将1,2,3看做是一个整体，只有id为1,2,3的数据会被删除。正确的语句应该是delete from t_user where id in (1,2,3)，或者delete from t_user where id in ('1','2','3')

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

3、字段名和属性名不一致的情况

创建emp和dept表

  1. DROP TABLE IF EXISTS `emp`;
  2. CREATE TABLE `emp`  (
  3.   `eid` int(11) NOT NULL AUTO_INCREMENT,
  4.   `emp_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  5.   `age` int(11) NULL DEFAULT NULL,
  6.   `sex` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  7.   `email` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  8.   `did` int(11) NULL DEFAULT NULL,
  9.   PRIMARY KEY (`eid`) USING BTREE
  10. ) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  11.  
  12.  
  13. DROP TABLE IF EXISTS `dept`;
  14. CREATE TABLE `dept`  (
  15.   `did` int(11) NOT NULL AUTO_INCREMENT,
  16.   `dept_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  17.   PRIMARY KEY (`did`) USING BTREE
  18. ) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

创建Emp对象和Dept对象

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. @EqualsAndHashCode
  5. public class Emp {
  6.     private Integer eid;
  7.     private String empName;
  8.     private Integer age;
  9.     private String sex;
  10.     private String email;
  11.     private Dept dept;
  12. }
  13.  
  14. @Data
  15. @AllArgsConstructor
  16. @NoArgsConstructor
  17. @EqualsAndHashCode
  18. public class Dept {
  19.     private Integer did;
  20.     private String deptName;
  21. }

1、为字段起别名，保持和属性名的一致

select eid, emp_name empName, age, sex, email from emp;

2、设置全局配置，在mybatis全局配置文件mybtis-config.xml中添加标签

  1. //该标签要放在<properties>标签之下，<typeAliases>标签之上
  2. <settings>
  3.     <setting name = "mapUnderScoreToCamelCase", value = "true">
  4. </settings>

3、通过resultMap设置自定义映射关系

  1. <!--
  2.     resultMap：设置自定义映射关系
  3.         id：唯一标识
  4.         type；查询的数据要映射的实体类类型
  5. -->
  6. <resultMap id = "empResultMap", type = "Emp">
  7.     <id property = "id", column = "id">
  8.     <result property = "empName", column = "emp_name">
  9.     <result property = "age", column = "age">
  10. </resultMap>
  11.  
  12. <!--List<Emp> getAllEmp();-->
  13. <select id = "getAllEmp", resultmap = "empResultMap">
  14.     select * from emp
  15. </select>

自定义映射resultMap

1、处理多对一的映射关系

（1）级联属性赋值

  1. <resultMap id = "empAndDeptResultMapOne", type = "Emp">
  2.     <id property = "eid" column = "eid">
  3.     <result property = "empName" column = "emp_name">
  4.     <result property = "age" column = "age">
  5.     <result property = "sex" column = "sex">
  6.     <result property = "email" column = "email">
  7.     <result property = "dept.did" column = "did">
  8.     <result property = "dept.deptName" column = "dept_name">
  9. </resultMap>
  10.  
  11. <!--Emp getEmpAndDept(@Param("eid") Integer eid);-->
  12. <select id = "getEmpAndDept" resultMap = "empAndDeptResultMapOne">
  13.     <select * from emp left join dept on emp.did = dept.did where emp.eid = #{eid}>
  14. </select>

（2）使用association解决多对一的映射关系

  1. <resultMap id = "empAndDeptResultMapTwo", type = "Emp">
  2.     <id property = "eid" column = "eid">
  3.     <result property = "empName" column = "emp_name">
  4.     <result property = "age" column = "age">
  5.     <result property = "sex" column = "sex">
  6.     <result property = "email" column = "email">
  7.     <association property = "dept" javaType = "Dept">
  8.         <id property = "did" column = "did">
  9.         <result property = "deptName" column = "dept_name">
  10.     </association>
  11. </resultMap>
  12.  
  13. <!--Emp getEmpAndDept(@Param("eid") Integer eid);-->
  14. <select id = "getEmpAndDept" resultMap = "empAndDeptResultMapTwo">
  15.     <select * from emp left join dept on emp.did = dept.did where emp.eid = #{eid}>
  16. </select>

               测试代码

  1. @Test
  2. public void MybatisTest01(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
  5.     Emp emp = empMapper.getEmpAndDept(3);
  6.     System.out.println("emp:" + emp);
  7. }

2、处理一对多的映射关系

        设置Dept实体类

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. @EqualsAndHashCode
  5. public class Dept {
  6.     private Integer did;
  7.     private String deptName;
  8.     private List<Emp> emps;
  9. }

        通过collection解决一对多的映射关系

                collection：用来处理一对多的映射关系

                ofType：表示该属性对饮的集合中存储的数据的类型

  1. <resultMap id="getAllEmpResult" type="Dept">
  2.     <id property="did" column="did"></id>
  3.     <result property="deptName" column="dept_name"></result>
  4.     <collection property="emps" ofType="Emp">
  5.         <id property="eid" column="eid"></id>
  6.         <result property="empName" column="emp_name"></result>
  7.         <result property="age" column="age"></result>
  8.         <result property="sex" column="sex"></result>
  9.         <result property="email" column="email"></result>
  10.     </collection>
  11. </resultMap>
  12.  
  13. <!--List<Emp> getALlEmp(@Param("did") Integer did);-->
  14. <select id="getALlEmp" resultMap="getAllEmpResult">
  15.     select * from dept left join emp on dept.did = emp.did where dept.did = #{did}
  16. </select>

        测试

  1. @Test
  2. public void MybatisTest02(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
  5.     List<Emp> empList = deptMapper.getALlEmp(1);
  6.     System.out.println(empList);
  7. }

动态sql

        什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句

if：

 if标签可通过test属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行

  1. <!--List<Emp> grtEmpByCondition(Emp emp);-->
  2. <select id="grtEmpByCondition" resultType="com.cyj.mybatis.pojo.Emp">
  3.     select * from emp where 1 = 1
  4.     <if test="empName != null and empName != ''">
  5.         emp_name = #{empName}
  6.     </if>
  7.     <if test="age != null and age != ''">
  8.         and age = #{age}
  9.     </if>
  10.     <if test="sex != null and sex != ''">
  11.         and sex = #{sex}
  12.     </if>
  13.     <if test="email != null and email != ''">
  14.         and email = #{email}
  15.     </if>
  16. </select>

 测试

  1. @Test
  2. public void dynamicTest(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DynamicMapper dynamicMapper = sqlSession.getMapper(DynamicMapper.class);
  5.     List<Emp> empList = dynamicMapper.grtEmpByCondition(new Emp(null, null, null, "男", null));
  6.     for (Emp emp : empList) {
  7.         System.out.println(emp);
  8.     }
  9. };

where

where和if一般结合使用：

        若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字

        若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉

  1. <!--List<Emp> grtEmpByConditionTwo(Emp emp);-->
  2. <select id="grtEmpByConditionTwo" resultType="com.cyj.mybatis.pojo.Emp">
  3.     select * from emp
  4.     <where>
  5.         <if test="empName != null and empName != ''">
  6.             emp_name = #{empName}
  7.         </if>
  8.         <if test="age != null and age != ''">
  9.             and age = #{age}
  10.         </if>
  11.         <if test="sex != null and sex != ''">
  12.             and sex = #{sex}
  13.         </if>
  14.         <if test="email != null and email != ''">
  15.             and email = #{email}
  16.         </if>
  17.     </where>
  18. </select>

        测试

  1. @Test
  2. public void dynamicTest(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DynamicMapper dynamicMapper = sqlSession.getMapper(DynamicMapper.class);
  5.     List<Emp> empList = dynamicMapper.grtEmpByCondition(new Emp(null, null, null, "男", null));
  6.     for (Emp emp : empList) {
  7.         System.out.println(emp);
  8.     }
  9. };

trim：用于去掉或添加标签中的内容

常用属性

        prefix：在trim标签中的内容的前面添加某些内容

        suffix：在trim标签中的内容的后面添加某些内容

        prefixOverrides：在trim标签中的内容的前面去掉某些内容

        suffixOverrides：在trim标签中的内容的后面去掉某些内容

  1. <!--List<Emp> greEmpByConditionThree(Emp emp);-->
  2. <select id="getEmpByConditionThree" resultType="com.cyj.mybatis.pojo.Emp">
  3.     select * from emp
  4.     <trim prefix="where" prefixOverrides="and|or">
  5.         <if test="empName != null and empName != ''">
  6.             emp_name = #{empName}
  7.         </if>
  8.         <if test="age != null and age != ''">
  9.             and age = #{age}
  10.         </if>
  11.         <if test="sex != null and sex != ''">
  12.             and sex = #{sex}
  13.         </if>
  14.         <if test="email != null and email != ''">
  15.             and email = #{email}
  16.         </if>
  17.     </trim>
  18. </select>

        测试

  1. @Test
  2. public void dynamicTest01(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DynamicMapper dynamicMapper = sqlSession.getMapper(DynamicMapper.class);
  5.     List<Emp> empList = dynamicMapper.getEmpByConditionThree(new Emp(null, null, null, "男", null));
  6.     for (Emp emp : empList) {
  7.         System.out.println(emp);
  8.     }
  9. }

choose、when、otherwise（相当于if...else if...else）when至少要有一个，otherwise至多只有一个

  1. <!--List<Emp> getEmpByOtherwise(Emp emp);-->
  2. <select id="getEmpByOtherwise" resultType="com.cyj.mybatis.pojo.Emp">
  3.     select * from emp
  4.     <where>
  5.         <choose>
  6.             <when test="empName != null and empName != ''">
  7.                 emp_name = #{empName}
  8.             </when>
  9.             <when test="age != null and age != ''">
  10.                 age = #{age}
  11.             </when>
  12.             <when test="sex != null and sex != ''">
  13.                 sex = #{sex}
  14.             </when>
  15.             <when test="email != null and email != ''">
  16.                 email = #{email}
  17.             </when>
  18.             <otherwise>
  19.                 did = 1
  20.             </otherwise>
  21.         </choose>
  22.     </where>
  23. </select>

        测试

  1. @Test
  2. public void dynamicTest02(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DynamicMapper dynamicMapper = sqlSession.getMapper(DynamicMapper.class);
  5.     List<Emp> empList = dynamicMapper.getEmpByOtherwise(new Emp(null, null, null, "男", null));
  6.     for (Emp emp : empList) {
  7.         System.out.println(emp);
  8.     }
  9. }

foreach

属性：

        collection：设置要循环的数组或集合

        item：表示集合或数组中的每一个数据

        separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,

        open：设置foreach标签中的内容的开始符

        close：设置foreach标签中的内容的结束符

        批量删除

  1. <!--int deleteEmpByIdArray(@Param("ids") Integer[] ids);-->
  2. <delete id="deleteEmpByIdArray">
  3.     delete from emp where eid in
  4.     <foreach collection="ids" item="eid" separator="," open="(" close=")">
  5.         #{eid}
  6.     </foreach>
  7. </delete>

        测试

  1. @Test
  2. public void deleteTest(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DynamicMapper dynamicMapper = sqlSession.getMapper(DynamicMapper.class);
  5.     int deleteNum = dynamicMapper.deleteEmpByIdArray(new Integer[]{5, 6, 7});
  6.     System.out.println(deleteNum);
  7. }

         批量增加

  1. <!--int insertEmpByList(@Param("empList") List<Emp> empList);-->
  2. <insert id="insertEmpByList">
  3.     insert into emp values
  4.     <foreach collection="empList" item="emp" separator=",">
  5.         (null, #{emp.empName}, #{emp.age}, #{emp.sex}, #{emp.email}, null)
  6.     </foreach>
  7. </insert>

        测试

  1. @Test
  2. public void insertTest(){
  3.     SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  4.     DynamicMapper dynamicMapper = sqlSession.getMapper(DynamicMapper.class);
  5.     Emp emp1 = new Emp(null, "猪八戒", 24, "男", "123456@163.com");
  6.     Emp emp2 = new Emp(null, "孙悟空", 25, "男", "123456@163.com");
  7.     Emp emp3 = new Emp(null, "沙和尚", 30, "男", "123456@163.com");
  8.     Emp emp4 = new Emp(null, "唐三藏", 35, "男", "123456@163.com");
  9.     List<Emp> empList = Arrays.asList(emp1, emp2, emp3, emp4);
  10.     int insertNum = dynamicMapper.insertEmpByList(empList);
  11.     System.out.println(insertNum);
  12. }

sql片段

  1. <sql id="allColumn">eid, emp_name empName, age, sex, email</sql>
  2. <!--List<Emp> getAllEmp();-->
  3. <select id="getAllEmp" resultType="com.cyj.mybatis.pojo.Emp">
  4.     select <include refid="allColumn"></include> from emp
  5. </select>

Mybatis缓存

1、什么是缓存

（1）缓存就是内存中的临时数据。将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（数据库）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题

（2） 为什么使用缓存？

减少和数据库的交互次数，减少系统开销，提高系统效率

（3） 什么样的数据可以使用缓存？

经常查询并且不经常改变的数据

2、Mybatis一级缓存

        一级缓存是SqlSession级别的，通过同一个SqlSession查询到的数据会被缓存，下次查询相同的数据时会直接从缓存中获得，不会再去查询数据库。

一级缓存会失效的情况：

（1）不同的SqlSession对应不同的一级缓存

（2）同一个SqlSession但是查询条件不相同

（3）同一个SqlSession两次查询中间进行过增删改操作

（4）同一个SqlSession两次查询中间手动清空了缓存

3、Mybatis二级缓存

        二级缓存是SqlSessionFactory级别的，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存

二级缓存开启条件

（1）在核心配置文件中设置全局配置属性cacheEnabled="true"，默认为true，不需要设置

  1. <settings>
  2.     <!--显示的开启全局缓存-->
  3.     <setting name="cacheEnabled" value="true"/>
  4.     <!--下划线转驼峰-->
  5.     <setting name="mapUnderscoreToCamelCase" value="true"/>
  6. </settings>

（2）在映射文件中设置标签

  1. <!--mapper接口的全类名-->
  2. <mapper namespace="com.cyj.mybatis.mapper.CacheMapper">
  3.     <!--在当前CacheMapper.xml中使用二级缓存-->
  4.     <cache
  5.         eviction="FIFO"
  6.         flushInterval="60000"
  7.         size="512"
  8.         readOnly="true"/>
  9.     <!--Emp getEmpByEid(@Param("eid") Integer eid);-->
  10.     <select id="getEmpByEid" resultType="com.cyj.mybatis.pojo.Emp">
  11.         select * from emp where eid = #{eid}
  12.     </select>
  13. </mapper>

（3）二级缓存必须在SqlSession关闭或者提交后才能生效

（4）查询的数据所对应的实体类必须实现序列化接口

二级缓存失效的情况：两次查询期间进行了任意的增删改操作

二级缓存的相关配置：

（1）eviction属性：缓存回收策略

        LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。（默认）

        FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。

        SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。

        WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

（2）flushInterval属性：刷新间隔，单位毫秒

        默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新

（3）size属性：引用数目，正整数

        代表缓存最多可以存储多少个对象，太大容易导致内存溢出

（4）readOnly属性：只读，true/false

        true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。

        false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

4、Mybatis缓存查询的顺序

（1）先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用

（2）如果二级缓存没有命中，再查询一级缓存

（3）如果一级缓存也没有命中，则查询数据库

（4）SqlSession关闭之后，一级缓存中的数据会写入二级缓存

5、第三方缓存EHCache

（1）添加依赖

  1. <!-- Mybatis EHCache整合包 -->
  2. <dependency>
  3. <groupId>org.mybatis.caches</groupId>
  4. <artifactId>mybatis-ehcache</artifactId>
  5. <version>1.2.1</version>
  6. </dependency>
  7. <!-- slf4j日志门面的一个具体实现 -->
  8. <dependency>
  9. <groupId>ch.qos.logback</groupId>
  10. <artifactId>logback-classic</artifactId>
  11. <version>1.2.3</version>
  12. </dependency>

（2）创建EHCache的配置文件ehcache.xml（名字必须为这个）

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
  4.     <!-- 磁盘保存路径 -->
  5.     <diskStore path="D:\mybatis\ehcache"/>
  6.     <defaultCache
  7.             maxElementsInMemory="1000"
  8.             maxElementsOnDisk="10000000"
  9.             eternal="false"
  10.             overflowToDisk="true"
  11.             timeToIdleSeconds="120"
  12.             timeToLiveSeconds="120"
  13.             diskExpiryThreadIntervalSeconds="120"
  14.             memoryStoreEvictionPolicy="LRU">
  15.     </defaultCache>
  16. </ehcache>
  17.  
  18. <!-- 
  19. 属性说明：
  20. diskStore：指定数据在磁盘中的存储位置。
  21. defaultCache：当借助 CacheManager.add("demoCache") 创建 Cache 时，EhCache 便会采用 <defalutCache/> 指定的的管理策略。
  22.  
  23. 必须的属性：
  24. maxElementsInMemory - 在内存中缓存的 element 的最大数目。
  25. maxElementsOnDisk - 在磁盘上缓存的 element 的最大数目，若是 0 表示无穷大。
  26. eternal - 设定缓存的 elements 是否永远不过期。如果为 true，则缓存的数据始终有效，如果为 false 那么还要根据 timeToIdleSeconds，timeToLiveSeconds 判断。
  27. overflowToDisk - 设定当内存缓存溢出的时候是否将过期的 element 缓存到磁盘上。
  28.  
  29. 可选的属性：
  30. timeToIdleSeconds - 当缓存在 EhCache 中的数据前后两次访问的时间超过 timeToIdleSeconds 的属性取值时，这些数据便会删除，默认值是 0，也就是可闲置时间无穷大。
  31. timeToLiveSeconds - 缓存 element 的有效生命期，默认是 0，也就是 element 存活时间无穷大。
  32. diskSpoolBufferSizeMB - 这个参数设置 DiskStore （磁盘缓存）的缓存区大小.默认是 30MB.每个 Cache 都应该有自己的一个缓冲区。
  33. diskPersistent - 在 VM 重启的时候是否启用磁盘保存 EhCache 中的数据，默认是 false。
  34. diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是 120 秒。每个 120s，相应的线程会进行一次 EhCache 中数据的清理工作。
  35. memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的 element 加入的时候， 移除缓存中 element 的策略。默认是 LRU（最近最少使用），可选的有 LFU（最不常使用）和 FIFO（先进先出）。
  36.  -->

（3）设置二级缓存的类型

        在映射文件CacheMapper.xml中设置缓存的类型

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

（4）创建logback日志文件ogback.xml，加入logback日志

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration debug="true">
  3.     <!-- 指定日志输出的位置 -->
  4.     <appender name="STDOUT"
  5.               class="ch.qos.logback.core.ConsoleAppender">
  6.         <encoder>
  7.             <!-- 日志输出的格式 -->
  8.             <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
  9.             <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
  10.         </encoder>
  11.     </appender>
  12.     <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
  13.     <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
  14.     <root level="DEBUG">
  15.         <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
  16.         <appender-ref ref="STDOUT" />
  17.     </root>
  18.     <!-- 根据特殊需求指定局部日志级别 -->
  19.     <logger name="com.cyj.mybatis.mapper" level="DEBUG"/>
  20. </configuration>

Mybatis逆向工程

1、在pom.xml中添加插件

  1. <dependencies>
  2.     <!--mybatis核心-->
  3.     <dependency>
  4.         <groupId>org.mybatis</groupId>
  5.         <artifactId>mybatis</artifactId>
  6.         <version>3.5.7</version>
  7.     </dependency>
  8.  
  9.     <!--junit测试-->
  10.     <dependency>
  11.         <groupId>junit</groupId>
  12.         <artifactId>junit</artifactId>
  13.         <version>4.12</version>
  14.         <scope>test</scope>
  15.     </dependency>
  16.  
  17.     <!--mysql驱动-->
  18.     <dependency>
  19.         <groupId>mysql</groupId>
  20.         <artifactId>mysql-connector-java</artifactId>
  21.         <version>5.1.3</version>
  22.     </dependency>
  23.  
  24.     <!--lombok-->
  25.     <dependency>
  26.         <groupId>org.projectlombok</groupId>
  27.         <artifactId>lombok</artifactId>
  28.         <version>1.18.24</version>
  29.     </dependency>
  30. </dependencies>
  31.  
  32.  
  33. <!-- 控制Maven在构建过程中相关配置 -->
  34. <build>
  35. 	<!-- 构建过程中用到的插件 -->
  36. 	<plugins>
  37. 		<!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
  38. 		<plugin>
  39. 			<groupId>org.mybatis.generator</groupId>
  40. 			<artifactId>mybatis-generator-maven-plugin</artifactId>
  41. 			<version>1.3.0</version>
  42. 			<!-- 插件的依赖 -->
  43. 			<dependencies>
  44. 				<!-- 逆向工程的核心依赖 -->
  45. 				<dependency>
  46. 					<groupId>org.mybatis.generator</groupId>
  47. 					<artifactId>mybatis-generator-core</artifactId>
  48. 					<version>1.3.2</version>
  49. 				</dependency>
  50. 				<!-- 数据库连接池 -->
  51. 				<dependency>
  52. 					<groupId>com.mchange</groupId>
  53. 					<artifactId>c3p0</artifactId>
  54. 					<version>0.9.2</version>
  55. 				</dependency>
  56. 				<!-- MySQL驱动 -->
  57. 				<dependency>
  58. 					<groupId>mysql</groupId>
  59. 					<artifactId>mysql-connector-java</artifactId>
  60. 					<version>8.0.27</version>
  61. 				</dependency>
  62. 			</dependencies>
  63. 		</plugin>
  64. 	</plugins>
  65. </build>

2、创建mybatis核心配置文件

  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 core file-->
  6. <configuration>
  7.  
  8.     <properties resource="jdbc.properties"/>
  9.  
  10.     <!--设置类型别名-->
  11.     <typeAliases>
  12.         <package name=""/>
  13.     </typeAliases>
  14.  
  15.     <environments default="development">
  16.         <environment id="development">
  17.             <transactionManager type="JDBC"/>
  18.             <dataSource type="POOLED">
  19.                 <property name="driver" value="${jdbc.driver}"/>
  20.                 <property name="url" value="${jdbc.url}"/>
  21.                 <property name="username" value="${jdbc.username}"/>
  22.                 <property name="password" value="${jdbc.password}"/>
  23.             </dataSource>
  24.         </environment>
  25.     </environments>
  26.  
  27.     <mappers>
  28.         <!--以包为单位引入映射文件-->
  29.         <package name=""/>
  30.     </mappers>
  31. </configuration>

3、创建逆向工程的配置文件generatorConfig.xml

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

4、测试

  1. @Test
  2.     public void GeneratorTest(){
  3.         try {
  4.             InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
  5.             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  6.             SqlSession sqlSession = sqlSessionFactory.openSession(true);
  7.             EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
  8.  
  9.             //查询所有数据
  10. //            List<Emp> empList = empMapper.selectByExample(null);
  11. //            for (Emp emp : empList) {
  12. //                System.out.println(emp);
  13. //            }
  14.  
  15.             //根据条件查询
  16. //            EmpExample empExample = new EmpExample();
  17. //            empExample.createCriteria().andEmpNameEqualTo("张三");
  18. //            List<Emp> empList = empMapper.selectByExample(empExample);
  19. //            for (Emp emp : empList) {
  20. //                System.out.println(emp);
  21. //            }
  22.  
  23.             //updateByPrimaryKey：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null
  24.             empMapper.updateByPrimaryKey(new Emp(1, "admin", 22, "女", "123@163.com", 2));
  25.             //updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段
  26.             empMapper.updateByPrimaryKeySelective(new Emp(1, "admin", 22, null, "123@163.com", 2));
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }

分页插件

1、添加依赖

  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.0</version>
  6. </dependency>

2、在MyBatis的核心配置文件（mybatis-config.xml）中配置插件

  1. <plugins>
  2.     <!--设置分页插件-->
  3.     <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
  4. </plugins>

3、在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能

  1. @Test
  2. public void pageHelperTest(){
  3.     try {
  4.         InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
  5.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  6.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
  7.         EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
  8.  
  9.         //查询第一页，每页三条数据
  10.         PageHelper.startPage(1, 3);
  11.         List<Emp> empList = empMapper.selectByExample(null);
  12.         for (Emp emp : empList) {
  13.             System.out.println(emp);
  14.         }
  15.     } catch (IOException e) {
  16.         e.printStackTrace();
  17.     }
  18. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/822775
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号