MyBatis系列六: 映射关系多对一

已于 2024-06-19 13:40:57 修改
阅读量506 收藏 3
点赞数 5
分类专栏： MyBatis 文章标签： mybatis sql
于 2024-06-18 16:10:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18817831/article/details/139776592
版权

动态SQL语句-更复杂的查询业务需求

在这里插入图片描述

官方文档

文档地址: https://mybatis.org/mybatis-3/zh_CN/sqlmap-xml.html

基本介绍

●基本介绍
1.项目中多对1的关系是一个基本的映射关系, 也可以理解成1对多
2.User --- Pet: 一个用户可以养多只宠物
3.Dep --- Emp: 一个部门可以有多个员工

●注意细节
1.我们直接讲 双向的多对一的关系, 单向的多对一比双向的多对一简单.
2.在实际的项目开发中, 要求会使用双向的多对一的映射关系
3.说明: 什么是双向的多对一的关系: 比如通过User可以查询到对应的Pet, 返回来, 通过Pet也可以级联查询到对应的User信息.
4.多对多的关系, 是在多对1的基础上扩展即可.

映射方式

1.方式1: 通过配置XxxMapper.xml 实现多对1 [配置方式]
2.方式2: 通过注解的方式实现 多对1 [注解方式]
3.我们都实现代码, 应用举例.

配置Mapper.xml的方式-应用实例

●需求说明: 实现级联查询, 通过user的id可以查询到用户信息, 并可以查询到关联的pet信息. 反过来, 通过Pet的id可以查询到Pet的信息, 并且可以级联查询到它的主人User对象信息
在这里插入图片描述

1.创建user表和pet表

USE mybatis;

CREATE TABLE `mybatis_user` (
`id` INT PRIMARY KEY AUTO_INCREMENT,
`name` VARCHAR(32) NOT NULL DEFAULT ''
)CHARSET=utf8

CREATE TABLE `mybatis_pet` (
`id` INT PRIMARY KEY AUTO_INCREMENT,
`nickname` VARCHAR(32) NOT NULL DEFAULT '',
`user_id` INT,
FOREIGN KEY(`user_id`) REFERENCES `mybatis_user`(`id`)
)CHARSET=utf8

INSERT INTO `mybatis_user` VALUES (NULL, '宋江'), (NULL, '卢俊义');
INSERT INTO `mybatis_pet` VALUES (NULL, '波斯猫', 1), (NULL, '旺财', 1);
INSERT INTO `mybatis_pet` VALUES (NULL, '斑点猫', 2), (NULL, '花猫', 2);

SELECT * FROM `mybatis_user`;
SELECT * FROM `mybatis_pet`;

2.创建com.zzw.entity.Pet 和 com.zzw.entity.User. 这里toString方法有问题, 后面揭晓

@Getter
@Setter
public class Pet {
    /**
     * CREATE TABLE `mybatis_pet` (
     * `id` INT PRIMARY KEY AUTO_INCREMENT,
     * `nickname` VARCHAR(32) NOT NULL DEFAULT '',
     * `user_id` INT,
     * FOREIGN KEY(`user_id`) REFERENCES `mybatis_user`(`id`)
     * )CHARSET=utf8
     */
    private Integer id;
    private String nickname;
    //一个pet对应一个主人 User对象
    private User user;

    //toString会造成StackOverFlow
    //@Override
    //public String toString() {
    //    return "Pet{" +
    //            "id=" + id +
    //            ", nickname='" + nickname + '\'' +
    //            ", user=" + user +
    //            '}';
    //}
}

@Getter
@Setter
public class User {
    /**
     * CREATE TABLE `mybatis_user` (
     * `id` INT PRIMARY KEY AUTO_INCREMENT,
     * `name` VARCHAR(32) NOT NULL DEFAULT ''
     * )CHARSET=utf8
     */
    private Integer id;
    private String name;
    //因为一个user可以养多个宠物, mybatis 使用集合体现体现这个关系
    private List<Pet> pets;

    //toString会带来麻烦?=>会造成StackOverFlow
    //@Override
    //public String toString() {
    //    return "User{" +
    //            "id=" + id +
    //            ", name='" + name + '\'' +
    //            ", pets=" + pets +
    //            '}';
    //}
}

3.创建UserMapper 和 PetMapper

public interface UserMapper {
    //通过id获取User对象
    public User getUserById(Integer id);
}

public interface PetMapper {
    //通过User的id来获取pet对象, 可能有多个, 因此使用List接收
    public List<Pet> getPetByUserId(Integer userId);

    //通过pet的id获取pet对象, 同时会查询到pet对象关联的user对象
    public Pet getPetById(Integer id);
}

4.创建PetMapper.xml 和 UserMapper.xml

<mapper namespace="com.zzw.mapper.PetMapper">
    <!--
    1.配置/实现public List<Pet> getPetByUserId(Integer userId);
    2.通过User的id来获取pet对象, 可能有多个, 因此使用List接收
    3.完成的思路和前面大体相同
    -->
    <resultMap id="petResultMap" type="Pet">
        <id property="id" column="id"/>
        <result property="nickname" column="nickname"/>
        <association property="user" column="user_id"
                     select="com.zzw.mapper.UserMapper.getUserById"/><!--先写完, 再去实现getUserById方法-->
    </resultMap>
    <select id="getPetByUserId" parameterType="Integer"
            resultMap="petResultMap">
        SELECT * FROM `mybatis_pet` WHERE `user_id` = #{userId}
    </select>
</mapper>

<mapper namespace="com.zzw.mapper.UserMapper">
    <!--解读
    1.想一想前面的1对1怎么实现的
    2.配置/实现public User getUserById(Integer id);
    3.通过id获取User对象
    4.思路(1) 先通过user-id 查询得到用户信息 (2) 再根据user-id查询对应的pet信息
      并映射到List<Pet> pets
    -->
    <resultMap id="userResultMap" type="User">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--解读: 因为pets属性是集合, 因此这里需要使用collection标签来处理
        1.ofType="Pet" 指定返回的集合中存放的数据类型Pet
        2.collection 表示 pets 是一个集合
        3.property="pets" 是返回的user对象的属性 pets
        4.column="id" select * from `mybatis_user` where `id` = #{id} 返回的id字段对应的值
        -->
        <collection property="pets" column="id" ofType="Pet"
                    select="com.zzw.mapper.PetMapper.getPetByUserId"/>
    </resultMap>
    <select id="getUserById" parameterType="Integer"
            resultMap="userResultMap">
        select * from `mybatis_user` where `id` = #{id}
    </select>
</mapper>

5.新建UserMapperTest 和 PetMapperTest 

public class UserMapperTest {
    //属性
    private SqlSession sqlSession;
    private UserMapper userMapper;

    //初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
        System.out.println("userMapper--" + userMapper);
    }

    @Test
    public void getUserById() {
        User user = userMapper.getUserById(2);
        System.out.println("user信息--" + user.getId() + "-" + user.getName());

        List<Pet> pets = user.getPets();
        for (Pet pet : pets) {
            System.out.println("养的宠物信息-" + pet.getId() + "-" + pet.getNickname());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }

    }
}

public class PetMapperTest {
    //属性
    private SqlSession sqlSession;
    private PetMapper petMapper;

    //初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        petMapper = sqlSession.getMapper(PetMapper.class);
        System.out.println("petMapper--" + petMapper.getClass());
    }

    @Test
    public void getPetByUserId() {
        List<Pet> pets = petMapper.getPetByUserId(1);
        for (Pet pet : pets) {
            System.out.println("pet信息-" + pet.getId() + "-"  + pet.getNickname());
            User user = pet.getUser();
            System.out.println("user信息-" + user.getName());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

6.实现getPetById, 体会复用

<!--说明
1. 注意体会resultMap带来好处, 直接复用
2. 配置/实现public Pet getPetById(Integer id);
3. 通过pet的id获取pet对象
-->
<select id="getPetById" parameterType="Integer"
        resultMap="petResultMap">
    SELECT * FROM `mybatis_pet` where `id` = #{id};
</select>

@Test
public void getPetById() {
    Pet pet = petMapper.getPetById(4);
    System.out.println("pet信息-" + pet.getId() + "-" + pet.getNickname());
    User user = pet.getUser();
    System.out.println("主人信息-" + user.getId() + "-" + user.getName());
    if (sqlSession != null) {
        sqlSession.close();
    }
}

注解的方式实现-应用实例

●需求说明: 通过注解的方式来实现下面的多对1的映射关系, 实现级联查询, 通过user的id可以查询到用户信息, 并可以查询到关联的pet信息. 反过来, 通过Pet的id可以查询到Pet的信息, 并且可以级联查询到它的主人User对象信息

说明: 在实际开发中还是 推荐使用配置方式

1.新建com.zzw.mapper.UserMapperAnnotation接口

/**
 * @author 赵志伟
 * @version 1.0
 * UserMapperAnnotation: 使用注解的方式实现多对一
 */
public interface UserMapperAnnotation {
    /**
     * 1.说明: 注解的形式就是前面xml配置方式的体现
     * 2.这里同学们可以结合前面xml实现
     *  <resultMap id="userResultMap" type="User">
     *         <id property="id" column="id"/>
     *         <result property="name" column="name"/>
     *         <collection property="pets" column="id" ofType="Pet"
     *                     select="com.zzw.mapper.PetMapper.getPetByUserId"/>
     *     </resultMap>
     *     <select id="getUserById" parameterType="Integer"
     *             resultMap="userResultMap">
     *         select * from `mybatis_user` where `id` = #{id}
     *     </select>
     */
    @Select("select * from `mybatis_user` where `id` = #{id}")
    @Results({
            @Result(id = true, property = "id", column = "id"),
            @Result(property = "name", column = "name"),
            //这里请小伙伴注意, pets属性对应的是集合
            @Result(property = "pets", column = "id",
                    many = @Many(select = "com.zzw.mapper.PetMapperAnnotation.getPetByUserId"))
    })
    public User getUserById(Integer id);
}

2.新建com.zzw.mapper.PetMapperAnnotation接口

public interface PetMapperAnnotation {
    /**
     * <resultMap id="petResultMap" type="Pet">
     *     <id property="id" column="id"/>
     *     <result property="nickname" column="nickname"/>
     *     <association property="user" column="user_id"
     *                  select="com.zzw.mapper.UserMapper.getUserById"/>
     * </resultMap>
     * <select id="getPetByUserId" parameterType="Integer"
     *         resultMap="petResultMap">
     *     SELECT * FROM `mybatis_pet` WHERE `user_id` = #{userId}
     * </select>
     */
    //id = "petResultMap" 就是给我们的Results[Result Map] 指定一个名字
    //, 目的是为了后面复用
    @Select("SELECT * FROM `mybatis_pet` WHERE `user_id` = #{userId}")
    @Results(id = "petResultMap", value = {
            @Result(id = true, property = "id", column = "id"),
            @Result(property = "nickname", column = "nickname"),
            @Result(property = "user", column="user_id",
                    one = @One(select = "com.zzw.mapper.UserMapperAnnotation.getUserById"))
    })
    public List<Pet> getPetByUserId(Integer userId);

    /**
     * <select id="getPetById" parameterType="Integer"
     *         resultMap="petResultMap">
     *     SELECT * FROM `mybatis_pet` where `id` = #{id}
     * </select>
     *
     * @ResultMap("petResultMap") 使用/引用我们上面定义的 Results[ResultMap]
     */
    @Select("SELECT * FROM `mybatis_pet` where `id` = #{id}")
    @ResultMap("petResultMap")
    public Pet getPetById(Integer id);
}

3.新建 com.zzw.mapper.UserMapperAnnotationTest 和 com.zzw.mapper.PetMapperAnnotationTest

public class UserMapperAnnotationTest {
    //属性
    private SqlSession sqlSession;
    private UserMapperAnnotation userMapperAnnotation;

    //初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        userMapperAnnotation = sqlSession.getMapper(UserMapperAnnotation.class);
        System.out.println("userMapperAnnotation--" + userMapperAnnotation.getClass());
    }

    @Test
    public void getUserById() {
        User user = userMapperAnnotation.getUserById(2);
        System.out.println("[注解方式]--user信息--" + user.getId() + "-" + user.getName());

        List<Pet> pets = user.getPets();
        for (Pet pet : pets) {
            System.out.println("养的宠物信息-" + pet.getId() + "-" + pet.getNickname());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

public class PetMapperAnnotationTest {
    //属性
    private SqlSession sqlSession;
    private PetMapperAnnotation petMapperAnnotation;

    //初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        petMapperAnnotation = sqlSession.getMapper(PetMapperAnnotation.class);
        System.out.println("petMapperAnnotation--" + petMapperAnnotation.getClass());
    }

    @Test
    public void getPetByUserId() {
        List<Pet> pets = petMapperAnnotation.getPetByUserId(1);
        for (Pet pet : pets) {
            System.out.println("pet信息-" + pet.getId() + "-"  + pet.getNickname());
            User user = pet.getUser();
            System.out.println("user信息-" + user.getName());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }

    @Test
    public void getPetById() {
        Pet pet = petMapperAnnotation.getPetById(4);
        System.out.println("pet信息-" + pet.getId() + "-" + pet.getNickname());
        User user = pet.getUser();
        System.out.println("主人信息-" + user.getId() + "-" + user.getName());
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

课后练习

1.自己设计表 dept(部门) 和 emp(雇员), 是1对多的关系
2.通过查询dept, 可以级联查询得到所有emp的信息
3.通过查询emp, 可以级联查询得到对应的dept信息
4.字段小伙伴可以自己设计, 尽量完成.
- dept(id, dep_name)
- emp(id, name, salary, dept_id)

●代码实现
1.创建 dept表 和 emp表

USE mybatis;

CREATE TABLE `dept` (
`id` INT PRIMARY KEY AUTO_INCREMENT,
`dep_name` VARCHAR(64) NOT NULL DEFAULT ''
)CHARSET=utf8

CREATE TABLE `emp` (
`id` INT PRIMARY KEY AUTO_INCREMENT,
`name` VARCHAR(64) NOT NULL DEFAULT '',
`salay` DOUBLE NOT NULL DEFAULT 0.0,
`dept_id` INT,
FOREIGN KEY(`dept_id`) REFERENCES `dept`(`id`)
)CHARSET=utf8

INSERT INTO `dept` VALUES (1, '宣传部'), (2, '技术部');
INSERT INTO `emp` VALUES (1, '赵志伟', 6000, 2), (2, '赵培竹', 6000, 1), (3, '阳光', 12000, 2), (4, '月亮', 12000, 1);

SELECT * FROM `dept`;
SELECT * FROM `emp`;

2.创建com.zzw.entity.dept.java 和 com.zzw.entity.emp.java

@Getter
@Setter
public class Dept {
    private Integer id;
    private String depName;
    //级联查询, 一对多
    private List<Emp> emps;
}

@Getter
@Setter
public class Emp {
    private Integer id;
    private String name;
    private Double salary;
    //级联查询, 一对一
    private Dept dept;
}

3.创建EmpMapper.java 和 DeptMapper.java

public interface EmpMapper {
    //通过emp的id查询到emp对象, 同时会查询到emp对象关联的dept对象
    public Emp getEmpById(Integer id);

    //通过dept的id获取emp对象, 可能有多个, 因此用List接收
    public List<Emp> getEmpByDeptId(Integer deptId);
}

public interface DeptMapper {
    //通过dept的id查询到dept对象
    public Dept getDeptById(Integer id);
}

4.创建EmpMapper.xml 和 DeptMapper.xml

<mapper namespace="com.zzw.mapper.EmpMapper">
    <!--
    1.配置/实现public List<Emp> getEmpByDeptId(Integer deptId);
    2.通过dept的id获取emp对象, 可能有多个, 因此用List接收
    -->
    <resultMap id="EmpResultMap" type="Emp">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="salary" column="salary"/>
        <association property="dept" column="dept_id"
                     select="com.zzw.mapper.DeptMapper.getDeptById"/>
    </resultMap>
    <select id="getEmpByDeptId" parameterType="Integer" resultMap="EmpResultMap">
        SELECT * FROM `emp` WHERE dept_id = #{deptId}
    </select>
</mapper>

<mapper namespace="com.zzw.mapper.EmpMapper">
    <!--
    1.配置/实现public Dept getDeptById(Integer id);
    2.通过dept的id查询到dept对象
    3.思路(1) 先通过dept-id 查询到部门信息 (2) 再根据dept-id查询对应的emp信息
      并映射到List<Emp> emps
    -->
    <resultMap id="DeptResultMap" type="Dept">
        <id property="id" column="id"/>
        <result property="depName" column="dep_name"/>
        <!--解读: 因为emps属性是集合, 因此这里需要使用collection标签来处理
        1.ofType="Emp" 指定返回的集合中存放的数据类型Emp
        2.collection 表示 emps 是一个集合
        3.property="emps" 是返回的dept对象的属性 emps
        4.column="id" SELECT * FROM `dept` WHERE `id` = #{id} 返回的id字段的值
        -->
        <collection property="emps" column="id" ofType="Emp"
                    select="com.zzw.mapper.EmpMapper.getEmpByDeptId"/>
    </resultMap>
    <select id="getDeptById" parameterType="Integer" resultMap="DeptResultMap">
        SELECT * FROM `dept` WHERE `id` = #{id}
    </select>
</mapper>

5.创建EmpMapperTest 和 DeptMapperTest

public class EmpMapperTest {
    //属性
    private SqlSession sqlSession;
    private EmpMapper empMapper;

    //编写方法完成初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        empMapper = sqlSession.getMapper(EmpMapper.class);
        System.out.println("empMapper=" + empMapper.getClass());
    }

    @Test
    public void getEmpByDeptId() {
        List<Emp> emps = empMapper.getEmpByDeptId(2);
        for (Emp emp : emps) {
            System.out.println("emp信息-" + emp.getId() + "-" + emp.getName() + "-" + emp.getSalary());
            Dept dept = emp.getDept();
            System.out.println("部门信息-" + dept.getId() + "-" + dept.getDepName());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

public class DeptMapperTest {
    //属性
    private SqlSession sqlSession;
    private DeptMapper deptMapper;

    //编写方法完成初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        deptMapper = sqlSession.getMapper(DeptMapper.class);
        System.out.println("deptMapper=" + deptMapper.getClass());
    }

    @Test
    public void getDeptById() {
        Dept dept = deptMapper.getDeptById(1);
        System.out.println("部门信息-" + dept.getId() + "-" + dept.getDepName());
        List<Emp> emps = dept.getEmps();
        for (Emp emp : emps) {
            System.out.println("员工信息-" + emp.getId() + "-" + emp.getName() + "-" + emp.getSalary());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

6.实现getEmpById, 体会复用

<!--
1.配置/实现public Emp getEmpById(Integer id);
2.通过emp的id查询到emp对象, 同时会查询到emp对象关联的dept对象
-->
<select id="getEmpById" parameterType="Integer" resultMap="EmpResultMap">
    SELECT * FROM `emp` WHERE `id` = #{id}
</select>

@Test
public void getEmpById() {
    Emp emp = empMapper.getEmpById(2);
    System.out.println("emp信息-" + emp.getId() + "-" + emp.getName() + "-" + emp.getSalary());
    Dept dept = emp.getDept();
    System.out.println("部门信息-" + dept.getId() + "-" + dept.getDepName());
    if (sqlSession != null) {
        sqlSession.close();
    }
}

注解方式实现

1.新建EmpMapperAnnotation接口

public interface EmpMapperAnnotation {

   /**
    * 通过emp的id查询到emp对象, 同时会查询到emp对象关联的dept对象
    * <select id="getEmpById" parameterType="Integer" resultMap="EmpResultMap">
    *     SELECT * FROM `emp` WHERE `id` = #{id}
    * </select>
    */
   @Select("SELECT * FROM `emp` WHERE `id` = #{id}")
   @ResultMap("EmpResultMap")
   public Emp getEmpById(Integer id);

   /**
    * 通过dept的id获取emp对象, 可能有多个, 因此用List接收
    * <resultMap id="EmpResultMap" type="Emp">
    *     <id property="id" column="id"/>
    *     <result property="name" column="name"/>
    *     <result property="salary" column="salary"/>
    *     <association property="dept" column="dept_id"
    *                  select="com.zzw.mapper.DeptMapper.getDeptById"/>
    * </resultMap>
    * <select id="getEmpByDeptId" parameterType="Integer" resultMap="EmpResultMap">
    *     SELECT * FROM `emp` WHERE dept_id = #{deptId}
    * </select>
    */
   @Select("SELECT * FROM `emp` WHERE dept_id = #{deptId}")
   @Results(id = "EmpResultMap", value = {
           @Result(id = true, property = "id", column = "id"),
           @Result(property = "name", column = "name"),
           @Result(property = "salary", column = "salary"),
           @Result(property = "dept", column = "dept_id",
                   one = @One(select = "com.zzw.mapper.DeptMapperAnnotation.getDeptById"))
   })
   public List<Emp> getEmpByDeptId(Integer deptId);
}

2.新建DeptMapperAnnotation接口

public interface DeptMapperAnnotation {
    /**通过dept的id查询到dept对象
     * <resultMap id="DeptResultMap" type="Dept">
     *     <id property="id" column="id"/>
     *     <result property="depName" column="dep_name"/>
     *     解读: 因为emps属性是集合, 因此这里需要使用collection标签来处理
     *     1.ofType="Emp" 指定返回的集合中存放的数据类型Emp
     *     2.collection 表示 emps 是一个集合
     *     3.property="emps" 是返回的dept对象的属性 emps
     *     4.column="id" SELECT * FROM `dept` WHERE `id` = #{id} 返回的id字段的值
     *     -->
     *     <collection property="emps" column="id" ofType="Emp"
     *                 select="com.zzw.mapper.EmpMapper.getEmpByDeptId"/>
     * </resultMap>
     * <select id="getDeptById" parameterType="Integer" resultMap="DeptResultMap">
     *     SELECT * FROM `dept` WHERE `id` = #{id}
     * </select>
     */
    @Select("SELECT * FROM `dept` WHERE `id` = #{id}")
    @Results(id = "DeptResultMap", value = {
            @Result(id = true, property = "id", column = "id"),
            @Result(property = "depName", column = "dep_name"),
            @Result(property = "emps", column = "id",
                    many = @Many(select = "com.zzw.mapper.EmpMapperAnnotation.getEmpByDeptId"))
    })
    public Dept getDeptById(Integer id);
}

3.新建 com.zzw.mapper.EmpMapperAnnotationTest 和 com.zzw.mapper.DeptMapperAnnotationTest

public class EmpMapperAnnotationTest {
    //属性
    private SqlSession sqlSession;
    private EmpMapperAnnotation empMapperAnnotation;

    //编写方法完成初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        empMapperAnnotation = sqlSession.getMapper(EmpMapperAnnotation.class);
        System.out.println("empMapperAnnotation=" + empMapperAnnotation.getClass());
    }

    @Test
    public void getEmpByDeptId() {
        List<Emp> emps = empMapperAnnotation.getEmpByDeptId(2);
        for (Emp emp : emps) {
            System.out.println("[注解方式]emp信息-" + emp.getId() + "-" + emp.getName() + "-" + emp.getSalary());
            Dept dept = emp.getDept();
            System.out.println("部门信息-" + dept.getId() + "-" + dept.getDepName());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }

    @Test
    public void getEmpById() {
        Emp emp = empMapperAnnotation.getEmpById(2);
        System.out.println("[注解方式]emp信息-" + emp.getId() + "-" + emp.getName() + "-" + emp.getSalary());
        Dept dept = emp.getDept();
        System.out.println("[注解方式]dept信息-" + dept.getId() + "-" + dept.getDepName());
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

public class DeptMapperAnnotationTest {
    //属性
    private SqlSession sqlSession;
    private DeptMapperAnnotation deptMapperAnnotation;

    //编写方法完成初始化
    @Before
    public void init() {
        sqlSession = MyBatisUtils.getSqlSession();
        deptMapperAnnotation = sqlSession.getMapper(DeptMapperAnnotation.class);
        System.out.println("deptMapperAnnotation=" + deptMapperAnnotation.getClass());
    }

    @Test
    public void getDeptById() {
        Dept dept = deptMapperAnnotation.getDeptById(1);
        System.out.println("[注解方式]dept信息-" + dept.getId() + "-" + dept.getDepName());
        List<Emp> emps = dept.getEmps();
        for (Emp emp : emps) {
            System.out.println("[注解方式]emp信息-" + emp.getId() + "-" + emp.getName() + "-" + emp.getSalary());
        }
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

接下来我们学习, mybatis缓存…在这里插入图片描述
💐💐💐💐💐💐💐💐给个赞, 点个关注吧, 各位大佬!💐💐💐💐💐💐💐💐

💐💐💐💐💐💐💐💐祝各位2024年大吉大运💐💐💐💐💐💐💐💐💐💐
请添加图片描述

~ 小团子
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深入浅出mybatis系列
10-28
MyBatis是一个轻量级的ORM（对象关系映射）框架，它允许开发者将SQL语句直接写在XML映射文件中，提供了灵活的数据访问控制。 首先，我们注意到“springmvc + mybatis”的组合在近年来非常流行。SpringMVC作为Spring...
MyBatis 36道面试题和答案.docx
06-14
动态SQL是MyBatis的一大特色，它允许在XML映射文件中使用一系列的标签（如trim、where、set、foreach、if、choose、when、otherwise、bind）来实现SQL语句的动态拼接。执行原理是MyBatis使用OGNL语言表达式计算出SQL...
【MyBatis】如何使用“动态SQL”（超详解）
weixin_44825912的博客
04-28 5126
MyBatis提供了10种动态SQL标签：trim、where、set、foreach、if、choose、when、otherwise、bind、include；其执行原理为，使用OGNL从SQL参数对象中计算表达式的值，根据表达式的值动态拼接SQL，以此来完成动态SQL的功能。
MyBatis 动态 SQL
小唐的博客
03-17 571
MyBatis 动态 SQL
Mybatis动态SQL
最新发布
m0_59281987的博客
04-23 823
在页面原型中，列表上方的条件是动态的，是可以不传递的，也可以只传递其中的1个或者2个或者全部。而在我们刚才编写的SQL语句中，我们会看到，我们将三个条件直接写死了。如果页面只传递了参数姓名name 字段，其他两个字段 性别 和 入职时间没有传递，那么这两个参数的值就是null。此时，执行的SQL语句为：这个查询结果是不正确的。正确的做法应该是：传递了参数，再组装这个查询条件；如果没有传递参数，就不应该组装这个查询条件。
Mybatis动态SQL（详细介绍）
m0_74777020的博客
08-16 8906
Mybatis的动态SQL介绍及应用——详细介绍
【MyBatis】如何使用“动态SQL”（不用找了，这一篇足矣）
CYK_byte的博客
01-09 1123
若empName，age，gender其中任意一项为空，都可能会导致sql语句语法错误，例如，empName为空，sql语句就变成了select * from emp where and age =?只需要在where后面加上一个1=1的恒成立条件（辅助拼接后面的and，某些情况下让where有意义），并且在每一个if的sql前面都加上一个and即可，这个时候，无论哪个if不成立，或者是都不成立，sql语句都不会出现语法错误；例如：在员工表中，根据姓名，年龄，性别查询员工信息（查询满足任意一个属性即可）
Mybatis动态sql
热门推荐
weixin_52394141的博客
07-18 1万+
Mybatis缓存以及实现动态sql
MyBatis源码：原来 resultMap解析完是这样.docx
11-17
`ResultMap`是对数据库查询结果集 `<resultMap>` 中定义的一系列映射规则的集合。它可以包含多个`ResultMapping`对象，每个`ResultMapping`代表结果集中的一列与Java对象的一个属性之间的对应。`ResultMap`还支持...
MyBatis深入
10-02
该讲义介绍了MyBatis从入门、核心配置文件详解、mapper映射文件详解、动态SQL、关系映射到懒加载等一系列知识点。
Spring、mybatis、SpringMVC
10-09
MyBatis 提供了灵活的配置方式，可以通过注解或者 XML 配置文件的方式来配置 SQL 和映射关系。 Spring MVC 是一种基于 MVC（模型-视图-控制器）模式的 Web 框架，是 Spring Framework 的核心子项目。它提供了一系列...
MyBatis 执行动态 SQL语句详解
09-01
大家对mybatis执行任意sql语句都了解，那么MyBatis执行动态SQL语句呢？下面脚本之家小编给大家解答下mybatis执行动态sql语句的方法，非常不错，感兴趣的朋友参考下吧
MyBatis执行动态SQL的方法
08-26
今天小编就为大家分享一篇关于MyBatis执行动态SQL的方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
MyBatis之动态sql
kissship的博客
08-24 1885
resultType适用于简单的结果映射，可以自动进行映射；resultMap适用于复杂的结果映射，需要手动定义映射关系。
【MyBatis学习】动态SQL的使用,MyBatis还能这样使用?惊掉了我的下巴 ,赶快带着好奇心一起畅游动态SQL的海洋吧! ! !
m0_58097299的博客
06-23 416
【MyBatis学习】动态SQL的使用,MyBatis还能这样使用?惊掉了我的下巴 ,赶快带着好奇心一起畅游动态SQL的海洋吧! ! !
MyBatis 实现动态 SQL
2302_76339343的博客
02-09 1928
MyBatis 中的动态 SQL 就是SQL语句可以根据不同的情况情况来拼接不同的sql。 本文会介绍 xml 和 注解 两种方式的动态SQL实现方式。
Mybatis动态 sql用法
weixin_49336701的博客
08-13 3146
在sql语句中加入标签，按照之前sqlmap中的动态sql的样式书写。将 SQL 语句类和 Mapper 接口类关联，利用方法中的 type 属性和 method 属性；解决 Java 代码中嵌入 SQL 语句，通过简单地创建一个实例来调用方法生成SQL语句。在接口中定义内部类，来构建需要的动态sql语句，比使用标签的方式结构更加清晰。开始或插入到 SELECT 子句，可以被多次调用，参数也会添加到 SELECT子句。编写测试类，测试动态生成的SQL 语句是否准确。...
MyBatis 框架动态SQL
cym2033987216的博客
09-22 149
foreach collection="参数名称" item="元素别名" open="(" separactor="," close=")" index="当前元素位置下标">where可以自动剔除标签内多余的and关键字，并可以在没有过滤条件时忽略where关键字，从而简化SQL语句并智能处理where、and、or关键字的作用。4、当所有的when标签中的test属性判断为false时，进入otherwise标签。
MyBatis 动态sql
wang_s_f的博客
06-30 577
1>. 自定义 trim 元素改写上面的 where + if 语句-- <where>= null"></if>= null"></if>-- 改写后的效果 -->= null"></if>= null"></if></trim></select>prefix：插入 prefix 属性中指定的内容，即前缀。
mybatis关系映射和缓存机制
09-09
MyBatis关联映射是指通过MyBatis框架实现对象之间的关系映射，包括一对一、一对多、多对一和多对多等关系。关联映射可以通过配置文件和注解的方式来实现。 MyBatis缓存机制是指MyBatis框架自带的缓存功能，可以提高数据库查询的性能。MyBatis缓存可以分为一级缓存和二级缓存。一级缓存是指在同一个SqlSession中，对于相同的查询语句，MyBatis会将查询结果缓存起来，下次再执行相同的查询时，直接从缓存中获取结果，而不需要再次访问数据库。二级缓存是指在多个SqlSession中，对于相同的查询语句，MyBatis会将查询结果缓存起来，当其他SqlSession执行相同的查询时，可以直接从缓存中获取结果，而不需要再次访问数据库。 关于Spring JdbcTemplate类中几个常用方法的作用，我无法在提供的引用内容中找到明确的回答。但是一般来说，Spring JdbcTemplate类提供了一系列方法来执行数据库的增删改查操作。常用的方法包括：execute()方法用于执行SQL语句，query()方法用于执行查询操作并返回结果集，update()方法用于执行更新操作并返回受影响的行数，batchUpdate()方法用于执行批处理操作等。这些方法可以帮助开发人员简化数据库操作的代码，并提高开发效率。 但是，如果您对Spring JdbcTemplate类中具体方法的作用有进一步的疑问，我建议您参考《Java EE企业级应用开发教程 第2版（Spring Spring MVC MyBatis）》这本书，其中可能会有更详细的解释和示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

~ 小团子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值