（三）Mybatis注解开发和扩展

一、面向接口编程

• 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口
  编程
• 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准
  , 使得开发变得容易 , 规范性更好
• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，
  各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了

1.1、关于接口的理解

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

1.2、三个面向区别

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

1.3、使用注解开发

sql 类型主要分成 :

• @select ()
• @update ()
• @Insert ()
• @delete ()

【注意】利用注解开发就不需要mapper.xml映射文件了

1. 注解在接口上实现

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

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

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

3. 测试

   @Test
   public void testGetAllUser() {
   	SqlSession session = MybatisUtils.getSession();
   	//本质上利用了jvm的动态代理机制
   	UserMapper mapper = session.getMapper(UserMapper.class);
   	List<User> users = mapper.getAllUser();
   	for (User user : users){
   		System.out.println(user);
   	}
   	session.close();
   }
   

1.4、CRUD

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

public static SqlSession getSqlSession() {
    // 自动提交事务
    return sqlSessionFactory.openSession(true);
}

编写接口，增加注解

@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 deleteUser(@Param("id") int id);

注意：必须要将接口注册绑定到核心配置文件中

@Param()注解

• 基本类型的参数或者String类型，需加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议加上
• 在SQL中引用的就是这里的@Param中设定的属性名

#{}和${}的区别

• #{}是预编译处理
• ${}是字符串替换
• mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值
• mybatis在处理 $ {} 时，就是把 ${} 替换成变量的值。
• 使用 #{} 可以有效的防止SQL注入，提高系统安全性

二、Lombok

使用步骤：

1. 在IDEA中安装Lombok插件

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

   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.12</version>
   </dependency>
   

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

   @Data //无参构造，getter、setter、toString、hashcode、equals
   @AllArgsConstructor // 有参构造
   @NoArgsConstructor //无参构造
   @ToString
   @EqualsAndHashCode
   @Getter
   @Setter
   

三、多对一的处理

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

3.1、数据库设计

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=utf8
INSERT 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');

3.2、测试环境搭建

1. 导入Lombok

2. 新建实体类

   public class Teacher {
       private Integer id;
       private String name;
   }
   

   public class Student {
       private Integer id;
       private String name;
       // 学生需要关联一个老师
       private Teacher teacher;
   }
   

3. 编写实体类对应的Mapper接口 【两个】

   public interface StudentMapper {
   }
   

   public interface TeacherMapper {
   }
   

4. 编写Mapper接口对应的 mapper.xml配置文件 【两个】

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.kuang.mapper.StudentMapper">
   </mapper>
   

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.kuang.mapper.TeacherMapper">
   </mapper>
   

3.3、按照查询嵌套处理

<!--
    思路：
        1、查询所有的学生信息
        2、根据查询出来的学生的tid寻找对应的老师：子查询
-->

<resultMap id="StudentTeacher" type="com.study.pojo.Student">
    <id property="id" column="id"></id>
    <result property="name" column="name"></result>
    <!-- 复杂的属性需要单独处理
        对象使用association
        	property属性名 javaType属性类型 column在多的一方的表中的列名
        集合使用collection
     -->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"></association>
</resultMap>

<select id="getStudents" resultMap="StudentTeacher">
    select * from student
</select>

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

<resultMap id="StudentTeacher" type="Student">
	<!--association关联属性 property属性名 javaType属性类型 column在多的一方
	的表中的列名-->
	<association property="teacher" column="{id=tid,name=tid}"
	javaType="Teacher" select="getTeacher"/>
</resultMap>
<!--
这里传递过来的id，只有一个属性的时候，下面可以写任何值
association中column多参数配置：
column="{key=value,key=value}"
其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段
名。
-->
<select id="getTeacher" resultType="teacher">
	select * from teacher where id = #{id} and name = #{name}
</select>

3.4、按照结果嵌套处理

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"></result>
    <result property="name" column="sname"></result>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"></result>
    </association>
</resultMap>

<!-- 按照结果嵌套处理 -->
<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>

四、一对多处理

比如：一个老师拥有多个学生
对于老师而言，就是一对多的关系

4.1、 环境搭建

1. 新建实体类

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

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

4.2、接口

// 获取指定老师下的所有学生及老师的信息
Teacher getTeacher(@Param("tid") int id);

4.3、按结果嵌套查询

<!-- 按结果嵌套查询 -->
<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"></result>
    <result property="name" column="tname"></result>
    <!-- 复杂的属性，需要单独处理
        对象：association
        集合：collection
        javaType：指定属性的类型
        集合中的泛型信息，使用ofType获取
     -->
    <collection property="students" ofType="com.study.pojo.Student">
        <result property="id" column="sid"></result>
        <result property="name" column="sname"></result>
        <result property="tid" column="tid"></result>
    </collection>
</resultMap>

<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid, s.name sname, t.name tname, t.id tid from teacher t, student s where s.tid = t.id and t.id = #{tid}
</select>

4.4、 按照查询嵌套处理

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

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

<select id="getStudentByTeacherId" resultType="com.study.pojo.Student">
    select * from student where tid = #{tid};
</select>

小结

1、关联 - association

2、集合 - collection

3、javaType & ofType

• javaType用来指定实体类中属性的类型
• ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

注意点：

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