MyBatis注解开发

1 Mybatis注解开发单表操作

1.1 MyBatis的常用注解

Mybatis也可以使用注解开发方式，这样可以减少编写Mapper映射文件

@Insert：实现新增

@Update：实现更新

@Delete：实现删除

@Select：实现查询

@Result：实现结果集封装

@Results：可以与@Result 一起使用，封装多个结果集

@One：实现一对一结果集封装

@Many：实现一对多结果集封装

• 注意：修改MyBatis的核心配置文件，使用了注解替代的映射文件，只需要加载使用了注解的Mapper接口即可

<mappers>
    <!--扫描使用注解的类-->
    <mapper class="cn.zxy.mapper.IUserMapper"></mapper>
</mappers>

或者指定扫描包含映射关系的接口所在的包也可以

<mappers>
    <!--扫描使用注解的类所在的包-->
    <package name="cn.zxy.mapper"></package>
</mappers>

1.2 注解开发总结

注解可以简化开发操作，省略映射配置文件的编写

常用注解:

• @Select(“查询的 SQL 语句”)：执行查询操作注解

• @Insert(“查询的 SQL 语句”)：执行新增操作注解

• @Update(“查询的 SQL 语句”)：执行修改操作注解

• @Delete(“查询的 SQL 语句”)：执行删除操作注解

• 配置映射关系

二.MyBatis注解开发的多表操作

2.1 MyBatis的注解实现复杂映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置

2.2 一对一查询

2.2.1 一对一查询的模型

查询一个用户信息，与此同时查询出该用户对应的身份证信息

2.2.2 一对一查询的语句

对应的sql语句：

SELECT * FROM card；
​
SELECT * FROM person WHERE id=#{id}

2.2.3 创建PersonMapper接口

public interface PersonMapper {
    //根据id查询
    @Select("SELECT * FROM person WHERE id=#{id}")
    public abstract Person findById(Integer id);
}
​

2.2.4 使用注解配置Mapper

public interface CardMapper {
     @Select("select * from card")
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "number",property = "number"),
            @Result(
                    property = "p",             // 被包含对象的变量名
                    javaType = Person.class,    // 被包含对象的实际数据类型
                    column = "pid",             // 根据查询出的card表中的pid字段来查询person表
                    /*
                        one、@One 一对一固定写法
                        select属性：指定调用哪个接口中的哪个方法
                     */
       one = @One(select = "cn.zxy.mapper.PersonMapper.findById")
            )
    })
    public  List<Card> findAll();
}

2.2.5 测试类

@Test
    public void oneTest(){
        //1.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession(true);
        //2.获取CardMapper接口的实现类对象
        CardMapper mapper = sqlSession.getMapper(CardMapper.class);
        //3.调用实现类对象中的方法，接收结果
        List<Card> cardList = mapper.findAll();
        for (Card card : cardList) {
            System.out.println(card);
        }
        //4.释放资源
        MybatisUtils.closeSqlSession(sqlSession);
​
    }
​

2.2.6 一对一配置总结

@Results：封装映射关系的父注解。
    Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
    column 属性：查询出的表中字段名称
    property 属性：实体对象中的属性名称
    javaType 属性：被包含对象的数据类型
    one 属性：一对一查询固定属性
 @One：一对一查询的注解。
    select 属性：指定调用某个接口中的方法

2.3 一对多查询

2.3.1 一对多查询的模型

查询一个课程，与此同时查询出该该课程对应的学生信息

2.3.2 一对多查询的语句

对应的sql语句：

SELECT * FROM classes
​
SELECT * FROM student WHERE cid=#{cid}

2.3.3 创建StudentMapper接口

public interface StudentMapper {
    //根据cid查询student表
    @Select("SELECT * FROM student WHERE cid=#{cid}")
    public abstract List<Student> findByCid(Integer cid);
}
​

2.3.4 使用注解配置Mapper

//查询全部
    @Select("SELECT * FROM classes")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(
                    property = "students",  // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出的classes表的id字段来查询student表
                    /*
                        many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法
                     */
      many = @Many(select = "com.by.mapper.StudentMapper.findByCid")
            )
    })
    public  List<Classes> findAll();

2.3.5 测试类

 @Test
    public void oneManyTest(){
        //1.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession(true);
        //2.获取CardMapper接口的实现类对象
        ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);
        //3.调用实现类对象中的方法，接收结果
        List<Classes> classesList = mapper.findAll();
        for (Classes classes : classesList) {
            System.out.println(classes);
        }
        //4.释放资源
        MybatisUtils.closeSqlSession(sqlSession);
​
    }

运行结果查看：

2.3.6 一对多配置总结

@Results：封装映射关系的父注解。
    Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
    column 属性：查询出的表中字段名称
    property 属性：实体对象中的属性名称
    javaType 属性：被包含对象的数据类型
    many 属性：一对多查询固定属性
@Many：一对多查询的注解。
    select 属性：指定调用某个接口中的方法

2.4 多对多查询

2.4.1 多对多查询的模型

多对多查询的需求：查询学生以及所对应的课程信息

2.4.2 多对多查询的语句

对应的sql语句：

SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id
SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}

2.4.3 添加CourseMapper 接口方法

public interface CourseMapper {
    //根据学生id查询所选课程
    @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}")
    public abstract List<Course> findBySid(Integer id);
}
​

2.4.4 使用注解配置Mapper

//查询全部
    @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(
                    property = "courses",   // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出student表的id来作为关联条件，去查询中间表和课程表
                    /*
                        many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "cn.zxy.mapper.CourseMapper.findBySid")
            )
    })
    public List<Student> findAll();
​

2.4.5 测试类

@Test
    public void ManyToManyTest(){
        //1.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession(true);
        //2.获取CardMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        //3.调用实现类对象中的方法，接收结果
        List<Student> studentList = mapper.findAll();
        for (Student student : studentList) {
            System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
            List<Course> courses = student.getCourses();
            for (Course cours : courses) {
                System.out.println(cours);
            }
​
        }
        //4.释放资源
        MybatisUtils.closeSqlSession(sqlSession);
​
    }

结果打印：

2.4.6 多对多配置总结

@Results：封装映射关系的父注解。
    Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
    column 属性：查询出的表中字段名称
    property 属性：实体对象中的属性名称
    javaType 属性：被包含对象的数据类型
    many 属性：一对多查询固定属性
@Many：一对多查询的注解。
    select 属性：指定调用某个接口中的方法