MyBatis完整教程IDEA版(2)--ResultMap/注解/一对多/多对一/lombok/log4j

【狂神说Java】Mybatis最新完整教程IDEA版通俗易懂: P10 - P21

1、解决属性名和字段名不一致的问题

数据库中的字段

新建一个项目，拷贝之前的，测试实体类字段不一致的情况。

public class User {
    private int id;
    private String name;
    private String password;
}

测试出现问题

//select * from mybatis.user where id = #{id}
//类型处理器
//select id,name,pwd from mybatis.user where id = #{id}

解决方法：

• 起别名

      <select id="getUserById" parameterType="int" resultType="com.lingbo.pojo.User">
          select id,name,pwd as password from mybatis.user where id = #{id}
      </select>
  

1.2、ResultMap

结果集映射

id 	name 	pwd
id 	name 	password

<!--结果集映射-->
<resultMap id="UserMap" type="User">
    <!--column数据库中的字段，property实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" parameterType="int" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>

• resultMap 元素是 MyBatis 中最重要最强大的元素。
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
• 如果这个世界总是这么简单就好了。

2、日志

2.1、日志工厂

如果一个数据库操作出现了异常，我们需要排错。日志就是最好的助手！

曾经：sout、debug

现在：日志工厂！

• SLF4J
• LOG4J（3.5.9 起废弃） 【掌握】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握】
• NO_LOGGING

在Mybatis中具体使用哪一个日志实现，在设置中设定！

STDOUT_LOGGING标准日志输出

为了学习log4j，将Mybatis版本从3.5.19降回3.5.6

<!--mybatis-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

2.2、LOG4J

什么是log4j？

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
• 我们也可以控制每一条日志的输出格式
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

如何使用log4j？

1. 先导入log4j的包

   <!-- https://mvnrepository.com/artifact/log4j/log4j -->
   <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.17</version>
   </dependency>
   

2. log4j.properties

   #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
   log4j.rootLogger=DEBUG,console,file
   
   #console 控制台输出的相关配置
   log4j.appender.console=org.apache.log4j.ConsoleAppender
   log4j.appender.console.Target=System.out
   log4j.appender.console.Threshold=DEBUG
   log4j.appender.console.layout=org.apache.log4j.PatternLayout
   log4j.appender.console.layout.conversionPattern=[%c]-%m%n
   
   #file 文件输出的相关配置
   log4j.appender.file=org.apache.log4j.RollingFileAppender
   log4j.appender.file.File=./log/lingbo.log
   log4j.appender.file.MaxFileSize=10mb
   log4j.appender.file.Threshold=DEBUG
   log4j.appender.file.layout=org.apache.log4j.PatternLayout
   log4j.appender.file.layout.conversionPattern=[%p][%d{%yy-MM-dd}][%c]%m%n
   
   #日志输出级别
   log4j.logger.org.mybatis=DEBUG
   log4j.logger.java.sql=DEBUG
   log4j.logger.java.sql.Statement=DEBUG
   log4j.logger.java.sql.ResultSet=DEBUG
   log4j.logger.java.sql.PreparedStatement=DEBUG
   

3. 配置log4j为日志的实现

       <settings>
           <setting name="logImpl" value="LOG4J"/>
       </settings>
   

4. Log4j的使用，直接测试运行刚才的查询

简单使用

1. 在要使用Log4j的类中，导入包import org.apache.log4j.Logger;

2. 日志对象，参数为当前类的class

   static Logger logger = Logger.getLogger(UserMapperTest.class);
   

3. 日志级别

           logger.info("info:进入了testLog4j");
           logger.debug("debug:进入了testlog4j");
           logger.error("error:进入了testlog4j");
   

3、分页

思考：为什么要分页？

• 减少数据的处理量

3.1、使用Limit分页

# 语法
select * from `user` limit startIndex,pageSize;
select * from `user` limit n; #[0,n]

使用Mybatis实现分页，核心SQL

1. 接口

   //分页
   List<User> getUserByLimit(Map<String, Object> map);
   

2. Mapper XML

   <!--  分页实现查询  -->
   <select id="getUserByLimit"  parameterType="map" resultMap="UserMap">
       select * from mybatis.user limit #{startIndex},#{pageSize}
   </select>
   

3. 测试

   @Test
   public void getUserByLimit(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
   
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
       Map<String, Object> map = new HashMap<>();
   
       map.put("startIndex", 1);
       map.put("pageSize", 2);
   
       List<User> userList = mapper.getUserByLimit(map);
       userList.forEach(System.out::println);
   
       sqlSession.close();
   }
   

3.2、RowBounds分页

不再使用SQL实现分页

1. 接口

       //分页2
       List<User> getUserByRowBounds();
   

2. mapper.xml

   <!--  RowBounds分页实现查询  -->
   <select id="getUserByRowBounds" resultMap="UserMap">
       select * from mybatis.user
   </select>
   

3. 测试

      @Test
       public void getUserByRowBounds(){
   
           SqlSession sqlSession = MybatisUtils.getSqlSession();
   
           //RowBounds实现
           RowBounds rowBounds = new RowBounds(1, 2);
   
           //通过Java代码层面实现分页
           List<User> userList = sqlSession.selectList("com.lingbo.dao.UserMapper.getUserByRowBounds",null,rowBounds);
   
           for (User user : userList) {
               System.out.println(user);
           }
   
           sqlSession.close();
   
   
       }
   

3.3、分页插件

了解即可。

官方文档：Mybatis PageHelper

4、使用注解开发

4.1、面向接口编程

• 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程

• 根本原因:解耦，可拓展，提高复用,分层开发中,上层不用管具体的实现,大家都遵守共同的标准,使得开发变得容易，规范性更好

• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;

• 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交豆，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

• 接口从更深层次的理解，应是定义(规范，约束)与实现(名实分离的原则)的分离。
• 接口的本身反映了系统设计人员对系统的抽象理解。
• 接口应有两类:
  • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class);
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面(interface);
• 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

• 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法.
• 面向过程是指，我们考虑问题时，以一个具体的流程(事务过程)为单位，考虑它的实现.
• 接口设计与非接口设计是针对复用技术而言的，与面向对象(过程)不是一个问题,更多的体现就是对系统整体的架构

4.2、使用注解开发

1. 注解在接口上实现

   @Select("select * from user")
   List<User> getUsers();
   

2. 需要在核心配置文件中绑定接口

   <!--  绑定接口  -->
   <mappers>
       <mapper class="com.lingbo.dao.UserMapper"/>
   </mappers>
   

3. 测试

   @Test
   public void testSelectAll() {
       SqlSession sqlSession = MybatisUtils.getSqlSession();
   
       //底层主要应用反射
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       List<User> users = mapper.getUsers();
   
       for (User user : users) {
           System.out.println(user);
       }
   
       sqlSession.close();
   }
   

本质：反射机制实现

底层：动态代理

4.3、MyBatis详细的执行流程！

4.4、CRUD

我们可以在工具类创建的时候实现自动提交事务！

    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession(true);
    }

编写接口，增加注解

public interface UserMapper {

    @Select("select * from user")
    List<User> getUsers();

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

    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

    @Update("UPDATE user set name = #{name} ,pwd = #{password} where id = #{id}")
    int updateUser(User user);

    @Delete("delete from user where id = #{id}")
    int deleteUserById(@Param("id") int id);

}

测试

【注意：我们必须要将接口注册绑定到我们的核心配置文件中！】

<!--  绑定接口  -->
<mappers>
    <mapper class="com.lingbo.dao.UserMapper"/>
</mappers>

4.5、关于@Param()注解

• 基本类型的参数或者String类型，需要加上。
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！
• 我们在SQL中引用的(#{uid})，就是我们这里的@Param()中设定的属性名！

#{}和${}的区别

${}会有SQL注入的风险，不安全！

5、Lombok

• Lombok项目是一个java库，它可以自动插入到编辑器和构建工具中，增强java的性能。
• 不需要再写getter、setter或equals方法，只要有一个注解，就有一个功能齐全的构建器、自动记录变量等等。

使用步骤：

1. 在IDEA中安装lombok插件

2. 在项目中导入lombok的jar包

   <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.30</version>
   </dependency>
   

3. 在实体类上加注解即可

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Jacksonized

@Data：无参构造，getter，setter，toString，hashcode，equals
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@ToString

6、多对一处理

多对一：

• 多个学生，对应一个老师
• 对于学生这边而言，关联… 多个学生，关联一个老师 【多对一】
• 对于老师而言，集合，一个老师，有很多学生 【一对多】

数据准备：

CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');

CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

6.1、测试环境搭建

1. 导入lombok
2. 新建实体类Teacher，Student
3. 建立Mapper接口
4. 建立Mapper.xml文件
5. 在核心配置文件中绑定注册Mapper接口或者文件！
6. 测试查询是否能够成功！

6.2、按照查询嵌套处理

<!--
思路：
    1.查询所有的学生信息
    2.根据查询出来的学生的tid，寻找对应的老师！  子查询
-->
<select id="getStudents" resultMap="StudentTeacher">
    <!--        select s.id,s.name,t.name from student s, teacher t where s.tid = t.id;-->
    select * from student;
</select>
<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <!--    复杂的属性，我们需要单独处理 对象：association 集合: collection   -->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>


<select id="getTeacher" resultType="Teacher">
    select * from teacher where id = #{id};
</select>

6.3、按照结果嵌套处理

<!--按照结果嵌套处理-->

<select id="getStudents2" resultMap="StudentTeacher2">
    select s.id sid,s.name sname,t.name tname from student s, teacher t where s.tid = t.id;
</select>

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!--    复杂的属性，我们需要单独处理 对象：association 集合: collection   -->
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

回顾MySQL多对一查询的方式：

• 子查询
• 联表查询

7、一对多处理

比如：一个老师拥有多个学生！

对于老师而言，就是一对多的关系！

7.1、环境搭建，和多对一一样

实体类

@Data
public class Teacher {
    private int id;
    private String name;
    //一个老师拥有多个学生
    private List<Student> students;
}

@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

7.2、按照结果嵌套处理

    <!--按结果嵌套查询-->
    <select id="getTeacherById" resultMap="TeacherStudent">
        select s.id sid, s.name sname, t.name tname, t.id tid
        from student s, teacher t
        where s.tid=t.id and t.id = #{tid}
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--    复杂的属性，我们需要单独处理 对象：association 集合: collection
           javaType="" 指定属性的类型
           集合中的泛型信息，我们使用ofType获取
           -->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

7.3、按照查询嵌套处理

<select id="getTeacherById2" resultMap="TeacherStudent2">
    select *
    from teacher
    where id = #{tid}
</select>

<resultMap id="TeacherStudent2" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
 </resultMap>

<select id="getStudentByTeacherId" resultType="Student">
    select * from student where tid = #{tid}
</select>

7.4、小结

1. 关联 - association 【多对一】
2. 集合 - collection 【一对多】
3. javaType & ofType
   1. JavaType 用来指定实体类中属性的类型
   2. ofType 用来指定映射到List或者集合中的 POJO类型，泛型中的约束类型！

注意点：

• 保证SQL的可读性，尽量通俗易懂
• 注意一对多和多对一种，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志，建议使用log4j

慢SQL 1s 1000s

面试高频

• MySQL引擎
• InnoDB底层原理
• 索引
• 索引优化