JavaWEB大神成长篇：MyBatis传统DAO模式开发实战精解（第六期）

是真的小外套

303人浏览 · 2026-06-01 11:26:16

是真的小外套 · 2026-06-01 11:26:16 发布

4_MyBatis传统DAO模式开发

概念
- 普通模式, 也称为传统 DAO 模式, 就是在传统DAO模式下, 定义接口和实现类, 如 interface EmpDao class EmpDaoImpl implements EmpDao
- 在实现类中, 用 SQLSession 对象调用 select insert delete update 等方法实现
- 目前极为少见
  - 在传统模式下, 我们需要知道 SqlSession 对象实现 CURD 和参数传递的处理

1_sqlSession查询的三种方式

SqlSession对象本身的API中就有三个查询方法, 分别能够实现如下查询方式
- 返回单个对象 selectOne
- 返回对象List集合 selectList
- 返回对象Map集合 selectMap
接下来我们就对这三个方法进行一个快速的学习

创建 Emp 实体类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Emp implements Serializable {
  private Integer empno;
  private String ename;
  private String job;
  private Integer mgr;
  private Date hiredate;
  private Double sal;
  private Double comm;
  private Integer deptno;
}

准备 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="EmpMapper">

  <!--
  返回单个对象
  public Emp findOne();
  id 相当于方法名
  resultType  相当于返回值类型
  sql语句的查询结果用哪个类来进行封装 如果返回值类型是集合,这里写的也是集合中的元素对应的类,不是集合本身作为类型
  paramaterType 参数类型
  SQL语句就是具体的方法体的实现
  -->

  <select id="findOne" resultType="emp" >
    select * from emp where empno = 7499
  </select>

  <!--
  返回多个对象List集合
  查询全部的员工信息
  public List<Emp> findAll()
  -->

  <select id="findAll" resultType="emp">
    select * from emp
  </select>

  <!--返回多个对象的Map集合
  把查询出来的数据中的某一列作为键, 整条数据封装的对象作为值
  public Map<key,Emp> findEmpMap()
  <empno,Emp>
  <key,Emp>
  -->

  <select id="findEmpMap" resultType="map">
    select * from emp
  </select>
</mapper>

2_sqlSession传递参数的三种方式

1.单个基础数据类型作为参数
2.多个基础数据类型的 map 集合作为参数
3.引用类型作为参数

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="EmpMapper2">
  <!--
  参数为一个基本数据类型
  根据员工工号查询员工的全部信息, 返回单个员工对象
  public Emp findByEmpno(int empno);
  parameterType 在有参数情况下也是可以省略不写  mybatis 可以根据实际情况自动判断
  如果要写 parameterType 那么就要写对
  在SQL语句上可以使用 ${}  #{} 代表参数的占位
  如果参数是单个基本数据类型, {}中名字可以随便写, 见名知意${} 代表mybatis底层使用Statment语句对象,参数是以字符串拼接的形式设置
  ${} 代表mybatis底层使用Statment语句对象,参数是以字符串拼接的形式设置
  #{} 代表mybatis底层使用的preparedStatment语句对象,参数使用?作为占位符处理
  #{} 以后常用
  -->
  <select id="findByEmpno" resultType="emp" parameterType="int">
    select * from emp where empno = #{empno}
  </select>
  
  <!--
  参数为 map 集合
  查询指定部门号和指定最低薪资的员工信息
  20 号部门 且工资在 1500 以上的员工信息
  public List<Emp> findEmpByDeptnoAndSal(int deptno, double sal); 
  <  >  最好要进行转译处理, 参照 HTML 转译 w3school 在线文档中有转译符号对应规则
  Map<String,Object> args=new HashMap<>();
    args.put("deptno", 20);
    args.put("sal", 1500.0);
  #{} 中写的是 map 集合中,  参数的键
  -->
  
  <select id="findEmpByDeptnoAndSal" resultType="emp" parameterType="map">
    select * from emp where deptno = #{deptno} and sal &gt;= #{sal}
  </select>

  <!--
  参数为对象
  emp >>>  deptno   sal
  参数是我们自定义的类型, 那么 #{} 中写的是参数的属性名
  -->

  <select id="findEmpByDeptnoAndSal2" resultType="emp" parameterType="emp">
    select * from emp where deptno = #{deptno} and sal &gt;= #{sal}
  </select>
</mapper>

测试代码

package com.xxx.test;

import com.xxx.pojo.Emp;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Test3 {
  private SqlSession sqlSession;
  @Before
  public void init(){
    SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
    InputStream resourceAsStream = null;
    try {
      resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    } catch (IOException e) {
      e.printStackTrace();
    }
    SqlSessionFactory factory = ssfb.build(resourceAsStream);
    sqlSession = factory.openSession();
  }

  @Test
  public void testSingleArg(){
    // 测试单个基本数据类型作为参数
    Emp emp = sqlSession.selectOne("findByEmpno", 7499);
    System.out.println(emp);
  }

  @Test
  public void testMapArg(){
    // 测试Map集合作为参数
    Map<String,Object> args = new HashMap<>();
    args.put("deptno", 20);
    args.put("sal", 3000.0);
    List<Emp> emps = sqlSession.selectList("findEmpByDeptnoAndSal", args);
    emps.forEach(System.out::println);
  }

  @Test
  public void testEmpArg(){
    // 测试Map集合作为参数
    Emp arg = new Emp();
    arg.setDeptno(10);
    arg.setSal(2000.0);
    List<Emp> emps = sqlSession.selectList("findEmpByDeptnoAndSal2", arg);
    emps.forEach(System.out::println);
  }

  @After
  public void release(){
    // 关闭SQLSession
    sqlSession.close();
  }
}

3_sqlSession完成DML所有操作

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="EmpMapper3">
  <!--
  增删方法的返回值类型都是 int
  resultType 就无需指定了
  insert update delete 标签中没有 resultType
  但是仍然可以有 paramaterType
  -->

  <!-- 增加方法
  public int addEmp(Emp emp);
  -->
  <insert id="addEmp" parameterType="emp">
    insert into emp values(#{empno},#{ename},#{job},#{mgr},#{hiredate},#{sal},#{comm},#{deptno})
  </insert>

  <!--修改
  根据工号修改员工姓名
  public int updateEmp(Emp emp);
  -->

  <update id="updateEmp" parameterType="emp">
    update emp set ename = #{ename} where empno = #{empno}
  </update>
  <!-- 删除
  删除大于给定工号的员工信息
  public int deleteEmp(int empno)
  -->
  <delete id="deleteEmp" parameterType="int">
    delete from emp where empno >= #{empno}
  </delete>
</mapper>

测试代码

package com.xxx.test;

import com.msb.pojo.Emp;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test4 {
  private SqlSession sqlSession;
  @Before
  public void init(){
    SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
    InputStream resourceAsStream = null;
    try {
      resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    } catch (IOException e) {
      e.printStackTrace();
    }
    SqlSessionFactory factory = ssfb.build(resourceAsStream);
    sqlSession = factory.openSession(true);
  }

  @Test
  public void testInsert(){
    Emp emp = new Emp(null,"按住啦Baby","SALESMAN",7839,new Date(),3100.0, 200.0,10 );
    int rows = sqlSession.insert("addEmp", emp);
    System.out.println(rows);
    // 手动提交事务
    // sqlSession.commit();
    /* 增删改 要提交事务
    * sqlSession.commit();手动提交事务
    * sqlSession = factory.openSession(true); 设置事务自动提交
    */
  }

  @Test
  public void testUpdate(){
    Emp emp = new Emp();
    emp.setEname("晓明");
    emp.setEmpno(7937);
    int rows = sqlSession.update("updateEmp", emp);
    System.out.println(rows);
  }

  @Test
  public void testDelete(){
    int rows = sqlSession.delete("deleteEmp", 7936);
    System.out.println(rows);
  }

  @After
  public void release(){
    // 关闭SQLSession
    sqlSession.close();
  }
}

5_MyBatis代理模式开发

1_使用Mapper代理方式实现查询

项目结构: 注意文件路径和文件位置!!!

准备接口和 mapper 映射文件

EmpMapper接口

package com.xxx.mapper;

import com.xxx.pojo.Emp;
import java.util.List;

public interface EmpMapper {
  /**
   * 该方法用于查询全部的员工信息
   * @return 全部员工信息封装的 Emp 对象的 List 集合
   */
  List<Emp> findAll();
}

EmpMapper.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.xxx.mapper.EmpMapper">
  <!--
  1 接口的名字和 Mapper 映射为文件名字必须保持一致(不包含拓展名)
  2 Mapper 映射文件的 namespace 必须是接口的全路径名
  3 sql 语句的 id 必须是对应方法的名
  4 DeptMapper 映射文件应该和接口编译之后放在同一个目录下
  -->
  <!--List<Emp> findAll();-->
  <select id="findAll" resultType="emp" >
    select * from emp    
  </select>
</mapper>

在 sqlMapConfig.xml 核心配置文件中使用包扫描形式加载所有的映射文件

<!--  加载mapper映射文件  -->
<mappers>
  <!--  通过类的全路径去找mapper映射文件  -->
  <mapper class="com.xxx.mapper.EmpMapper"/>
</mappers>

测试代码

package com.xxx.test;

import com.xxx.mapper.EmpMapper;
import com.xxx.pojo.Dept;
import com.xxx.pojo.Emp;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test1 {
  private SqlSession sqlSession;
  @Before
  public void init(){
    SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
    InputStream resourceAsStream = null;
    try {
      resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    } catch (IOException e) {
      e.printStackTrace();
    }
    SqlSessionFactory factory = ssfb.build(resourceAsStream) ;
    sqlSession = factory.openSession();
  }

  @Test
  public void testFindAll(){
    EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
    List<Emp> emps = empMapper.findAll();
    emps.forEach(System.out::println);
  }

  @After
  public void release(){
    // 关闭SQLSession
    sqlSession.close();
  }
}

代理模式浅析
- mybatis 是如何通过代理模式实现查询的
  - 这条语句的底层使用了动态代理模式，动态创建一个 EmployeeMapper 的一个代理对象并赋给接口引用
  - 所以在 MyBatis 中不需要显式提供 Mapper 接口的实现类，这也是简单的地方

6_代理模式下开发各种功能

1_多种参数传递问题

类型
- 1单个基本数据类型
- 2多个基本数据类型
- 3单个引用数据类型
- 4map集合数据类型
- 5多个引用数据类型

接口

package com.xxx.mapper;

import com.xxx.pojo.Emp;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface EmpMapper {
  /**
   * 该方法用于查询全部的员工信息
   * @return 全部员工信息封装的Emp对象的List集合
   */
  List<Emp> findAll();

  /**
   * 根据员工编号查询单个员工信息的方法
   * @param empno 员工编号
   * @return 如果找到了返回Emp对象,找不到返回null
   */
  Emp findByEmpno(int empno);

  /**
   * 根据员工编号和薪资下限去查询员工信息
   * @param empno 员工编号
   * @param sal 薪资下限
   * @return 多个Emp对象的List集合
   */

  List<Emp> findByDeptnoAndSal(@Param("deptno") int deptno,@Param("sal") double sal);
  List<Emp> findByDeptnoAndSal2(Map<String, Object> map);
  List<Emp> findByDeptnoAndSal3(Emp emp);
  List<Emp> findByDeptnoAndSal4(@Param("empa") Emp empa,@Param("empb") Emp empb);
}

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.xxx.mapper.EmpMapper">
  <!--
  1 接口的名字和 Mapper 映射为文件名字必须保持一致(不包含拓展名)
  2 Mapper 映射文件的 namespace 必须是接口的全路径名
  3 sql 语句的 id 必须是对应方法的名
  4 DeptMapper 映射文件应该和接口编译之后放在同一个目录下
  -->

  <!--List<Emp> findAll();-->
  <select id="findAll" resultType="emp" >
    select * from emp
  </select>

  <!--
  单个基本数据类型作为方法参数
  #{}中可以随便写,  遵循见名知意
  Emp findByEmpno(int empno);
  -->

  <!--
  多个基本数据类型作为方法参数
  List<Emp> findByDeptnoAndSal(@Param("detpno") int deptno,@Param("sal") double sal);
  方式1 arg*     arg0 arg1 arg2 数字是索引,从0开始
  方式2 param*   param1 param2 param3 数字是编号,从1开始
  使用别名
  List<Emp> findByDeptnoAndSal(@Param("detpno") int deptno,@Param("sal") double sal);
  通过 @Param 注解使用别名之后,就不能再使用 arg* 但是可以继续使用 param*
  -->
  <select id="findByDeptnoAndSal" resultType="emp">
    <!--select * from emp where deptno =#{arg0} and sal >= #{arg1}-->
    <!-- select * from emp where deptno =#{param1} and sal >= #{param2}-->
    <!-- select * from emp where deptno =#{deptno} and sal >= #{sal}-->
  </select>

  <!--
  参数是map,  {}写键的名字
  -->

  <select id="findByDeptnoAndSal2" resultType="emp" parameterType="map" >
    <!-- select * from emp where deptno =#{arg0} and sal >= #{arg1} -->
    <!-- select * from emp where deptno =#{param1} and sal >= #{param2} -->
    select * from emp where deptno =#{deptno} and sal >= #{sal}
  </select>
  
  <!--单个引用类型,{}中写的使用对象的属性名-->
  <select id="findByDeptnoAndSal3" resultType="emp" parameterType="emp" >
    select * from emp where deptno =#{deptno} and sal >= #{sal}
  </select>

  <!--
  多个引用类型作为方法参数
  List<Emp> findByDeptnoAndSal4(@Param("empa") Emp empa,@Param("empb") Emp empb);
  如果用@Param定义了别名,那么就不能使用arg*.属性名,但是可以使用param*.属性名和别名.属性名
  -->

  <select id="findByDeptnoAndSal4" resultType="emp"  >
    <!-- select * from emp where deptno =#{arg0.deptno} and sal >= #{arg1.sal} -->
    select * from emp where deptno =#{param1.deptno} and sal >= #{param2.sal}
    <!-- select * from emp where deptno =#{empa.deptno} and sal >= #{empb.sal}-->
  </select>
</mapper>

测试代码

package com.xxx.testDemo;

import com.xxx.mapper.EmpMapper;
import com.xxx.pojo.Emp;
import com.xxx.util.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class Test1 {
  public static void main(String[] args) {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
    /**
     * 帮助我们生成一个接口下的实现类对象的
     */
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    List<Emp> emps = mapper.getAllEmp();
    for(Emp emp:emps) {
      System.out.println(emp);
    }
    // 1单个基本数据类型作为方法参数
    Emp emp = mapper.getByEmpno(7902);
    System.out.println(emp);
    // 2多个基本数据类型作为方法参数
    List<Emp> emps2 = mapper.getByDeptnoAndSal(10, 1500);
    for(Emp em:emps2) {
      System.out.println(em);
    }
    // 3单个引用类型作为方法参数
    Emp condition = new Emp();
    condition.setDeptno(10);
    condition.setSal(1500.0);
    List<Emp> emps3 = mapper.getByDeptnoAndSal2(condition);
    for(Emp em:emps3) {
      System.out.println(em);
    }

    // 4多个引用类型作为方法参数
    Emp condition1 = new Emp();
    condition1.setDeptno(10);
    Emp condition2 = new Emp();
    condition2.setSal(1500.0);
    List<Emp> emps4 = mapper.getByDeptnoAndSal3(condition1,condition2);
    for(Emp em:emps4) {
      System.out.println(em);
    }
    sqlSession.close();    
  }
}

2_模糊查询功能

概念
- 在进行模糊查询时，在映射文件中可以使用 concat() 函数来连接参数和通配符
- 另外注意对于特殊字符，比如 <，不能直接书写，应该使用字符实体替换

接口

/**
 * 根据名字做模糊查询
 * @param name 模糊查询的文字
 * @return  Emp对象List集合
 */
List<Emp> findByEname(String name);

mapper映射文件

<!--List<Emp> getByName(String name);-->
<select id="findByEname"  resultType="emp" >
  select * from emp where ename like concat('%', #{name}, '%')
</select>

3_主键自增回填
- 概念
  - MySQL支持主键自增
  - 有时候完成添加后需要立刻获取刚刚自增的主键，由下一个操作来使用
  - 比如结算构造车后，主订单的主键确定后，需要作为后续订单明细项的外键存在
  - 如何拿到主键呢，MyBatis提供了支持，可以非常简单的获取
- 接口
```
public interface DeptMapper {
  int addDept(Dept dept);
  int addDept2(Dept dept);
}
```
- mapper映射文件
```
<mapper namespace="com.xxx.mapper.DeptMapper">
  

  <insert id="addDept" parameterType="dept" useGeneratedKeys="true" keyProperty="deptno">
    insert into dept values(null,#{dname},#{loc})
  </insert>

  <insert id="addDept2" parameterType="dept">
    <selectKey order="AFTER" keyProperty="deptno"  resultType="int">
      select @@identity
    </selectKey>
    insert into dept values(null,#{dname},#{loc})
  </insert>
</mapper>
```
- 测试代码
```
SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
Dept dept = new Dept(null,"AI学院","北京");
int i = mapper.addDept2(dept);
System.out.println(i);
System.out.println(dept.getDeptno());
sqlSession.close();
```
- 方式1
  - useGeneratedKeys
    - 表示要使用自增的主键
  - keyProperty
    - 表示把自增的主键赋给 JavaBean 的哪个成员变量
  - 以添加 Dept 对象为例，添加前 Dept 对象的 deptno 是空的，添加完毕后可以通过 getDeptno() 获取自增的主键
- 方式2
  - order
    - 取值 AFTER|BEFORE，表示在新增之后|之前执行 <selectKey> 中的SQL命令
  - keyProperty
    - 执行 select @@identity 后结果填充到哪个属性中
  - resultType
    - 结果类型
- 技术扩展在很多应用场景中需要新增数据后获取到新增数据的主键值，针对这样的需求一般由三种解决方式
  - 主键自定义，用户通过 UUID 或时间戳等方式生成唯一主键，把这个值当做主键值，在分布式场景中应用较多
  - 查询后通过 select max(主键) from 表获取主键最大值，这种方式在多线程访问情况下可能出现问题
  - 查询后通过 select @@identity 获取最新生成主键，要求这条 SQL 必须在 insert 操作之后，且数据库连接没有关闭

4_实现DML操作

EmpMapper接口

/**
 * 增加员工信息
 * @param emp 存储新增员工信息的Emp对象
 * @return 对数据库数据产生影响的行数
 */
int addEmp(Emp emp);

/**
 * 根据员工编号修改员工姓名的方法
 * param empno 要修改的员工编号
 * @param ename 修改之后的新的员工名字
 * @return 对数据库数据产生影响的行数
 */
int updateEnameByEmpno(@Param("empno") int empno, @Param("ename") String ename);

/** 
 * 根据员工编号删除员工信息 
 * @param empno 要删除的员工编号 
 * @return 对数据库数据产生影响的行数 
 */
int deleteByEmpno(int empno);

EmpMapper映射文件

<!--int addEmp(Emp emp);-->
<insert id="addEmp" >
  insert into emp values(DEFAULT ,#{ename},#{job},#{mgr},#{hiredate},#{sal},#{comm},#{deptno})
</insert>
<!--int updateEnameByEmpno(@Param("empno") int empno,@Param("ename") String ename);-->
<update id="updateEnameByEmpno" >
  update emp set ename =#{ename} where empno =#{empno}
</update>
<!--int deleteByEmpno(int empno);-->
<update id="deleteByEmpno" >
  delete from emp where empno = #{empno}
</update>

测试代码

package com.xxx.test;

import com.xxx.mapper.DeptMapper;
import com.xxx.mapper.EmpMapper;
import com.xxx.pojo.Dept;
import com.xxx.pojo.Emp;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;

public class Test3 {
  private SqlSession sqlSession;
  @Before
  public void init(){
    SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();        
    InputStream resourceAsStream = null;
    try {
      resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    } catch (IOException e) {
      e.printStackTrace();
    }
    SqlSessionFactory factory = ssfb.build(resourceAsStream) ;
    sqlSession = factory.openSession();
  }

  @Test
  public void testAddEmp(){
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    mapper.addEmp(new Emp(null, "TOM", "SALESMAN", 7521, new Date(), 2314.0, 100.0, 10));
    sqlSession.commit();
  }

  @Test
  public void testUpdateEnameByEmpno(){
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    mapper.updateEnameByEmpno(7938, "TOM");
    sqlSession.commit();
  }

  @Test
  public void testDeletByEmpno(){
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    mapper.deleteByEmpno(7938);
    sqlSession.commit();
  }

  @After
  public void release(){
    // 关闭SQLSession
    sqlSession.close();
  }
}

亚马逊云科技技术品牌专区

更多推荐

Gemini 2.5 Flash Lite 新手极速上手指南

在开发智能应用时，很多开发者常常面临一个两难选择：是追求模型的强大理解能力，还是担心高昂的算力成本和复杂的部署流程？特别是在处理长文档分析、图片内容识别或需要实时交互的场景下，传统方案往往显得力不从心。要么响应速度慢得让人失去耐心，要么在处理复杂上下文时出现“遗忘”现象，导致回答断章取义。其实，随着新一代大模型 API 的成熟，这些问题已经有了更优雅的解法。不需要自己搭建庞大的服务器集群，也不必深

亚马逊云科技技术品牌专区

Kiro Editor 开发实战：使用 Cargo 构建、测试与性能优化指南

欢迎来到这篇终极指南，我们将深入探索如何使用Rust构建高性能的终端文本编辑器Kiro Editor。无论你是Rust新手还是经验丰富的开发者，这篇完整教程将带你了解如何利用Cargo工具链进行高效的开发、测试和性能优化，打造一款快速、轻量且功能强大的UTF-8文本编辑器。## 什么是Kiro Editor？Kiro Editor是一款使用Rust编写的极简终端文本编辑器，它最初是著名编辑

亚马逊云科技技术品牌专区

Kimi 智能助手新手入门与实战指南

在处理长篇技术文档或行业研报时，我们往往只需要其中的核心结论或特定数据。利用 AI 进行长文档摘要，可以极大缩短信息获取周期。操作时，直接将文档内容复制粘贴到对话框中（注意遵守平台的长度限制，若超长可分段处理），然后配合精准的指令。假设你手头有一份五十页的《云计算架构演进趋势报告》，你可以输入：“请阅读以下关于云计算架构的报告内容。首先，用不超过 200 字总结全文的核心观点。其次，提取出文中提到

亚马逊云科技技术品牌专区

所有评论(0)

查看更多评论

是真的小外套

@2401_88349202

已为社区贡献8条内容

JavaWEB大神成长篇：MyBatis传统DAO模式开发实战精解（第六期）

是真的小外套

4_MyBatis传统DAO模式开发

概念

普通模式, 也称为传统 DAO 模式, 就是在传统DAO模式下, 定义接口和实现类, 如 interface EmpDao class EmpDaoImpl implements EmpDao

在实现类中, 用 SQLSession 对象调用 select insert delete update 等方法实现

目前极为少见

在传统模式下, 我们需要知道 SqlSession 对象 实现 CURD 和 参数传递的处理

1_sqlSession查询的三种方式

SqlSession对象本身的API中就有三个查询方法, 分别能够实现如下查询方式

返回单个对象 selectOne

返回对象List集合 selectList

返回对象Map集合 selectMap

接下来我们就对这三个方法进行一个快速的学习

创建 Emp 实体类

准备 Mapper 映射文件

2_sqlSession传递参数的三种方式

1.单个基础数据类型作为参数

2.多个基础数据类型的 map 集合作为参数

3.引用类型作为参数

Mapper 映射文件

测试代码

3_sqlSession完成DML所有操作

Mapper映射文件

测试代码

5_MyBatis代理模式开发

1_使用Mapper代理方式实现查询

项目结构: 注意文件路径和文件位置!!!

准备接口和 mapper 映射文件

EmpMapper接口

EmpMapper.xml映射文件

在 sqlMapConfig.xml 核心配置文件中使用包扫描形式加载所有的映射文件

测试代码

代理模式浅析

mybatis 是如何通过代理模式实现查询的

这条语句的底层使用了动态代理模式，动态创建一个 EmployeeMapper 的一个代理对象并赋给接口引用

所以在 MyBatis 中不需要显式提供 Mapper 接口的实现类，这也是简单的地方

6_代理模式下开发各种功能

1_多种参数传递问题

类型

1单个基本数据类型

2多个基本数据类型

3单个引用数据类型

4map集合数据类型

5多个引用数据类型

接口

mapper映射文件

测试 代码

2_模糊查询功能

概念

在进行模糊查询时，在映射文件中可以使用 concat() 函数来连接参数和通配符

另外注意对于特殊字符，比如 <，不能直接书写，应该使用字符实体替换

接口

mapper映射文件

3_主键自增回填

概念

MySQL支持主键自增

有时候完成添加后需要立刻获取刚刚自增的主键，由下一个操作来使用

比如结算构造车后，主订单的主键确定后，需要作为后续订单明细项的外键存在

如何拿到主键呢，MyBatis提供了支持，可以非常简单的获取

接口

mapper映射文件

测试代码

方式1

useGeneratedKeys

表示要使用自增的主键

keyProperty

表示把自增的主键赋给 JavaBean 的哪个成员变量

以添加 Dept 对象为例，添加前 Dept 对象的 deptno 是空的，添加完毕后可以通过 getDeptno() 获取自增的主键

方式2

order

取值 AFTER|BEFORE，表示在新增之后|之前执行 <selectKey> 中的SQL命令

keyProperty

执行 select @@identity 后结果填充到哪个属性中

resultType

结果类型

技术扩展在很多应用场景中需要新增数据后获取到新增数据的主键值，针对这样的需求一般由三种解决方式

主键自定义，用户通过 UUID 或 时间戳 等方式生成唯一主键，把这个值当做主键值，在分布式场景中应用较多

查询后通过 select max(主键) from 表获取主键最大值，这种方式在多线程访问情况下可能出现问题

查询后通过 select @@identity 获取最新生成主键，要求这条 SQL 必须在 insert 操作之后，且数据库连接没有关闭

在传统模式下, 我们需要知道 SqlSession 对象实现 CURD 和参数传递的处理

测试代码

在进行模糊查询时，在映射文件中可以使用 `concat()` 函数来连接参数和通配符

另外注意对于特殊字符，比如 `<`，不能直接书写，应该使用字符实体替换

`useGeneratedKeys`

`keyProperty`

以添加 `Dept` 对象为例，添加前 `Dept` 对象的 `deptno` 是空的，添加完毕后可以通过 `getDeptno()` 获取自增的主键

`order`

取值 `AFTER|BEFORE`，表示在新增之后`|`之前执行 `<selectKey>` 中的SQL命令

`keyProperty`

执行 `select @@identity` 后结果填充到哪个属性中

`resultType`

主键自定义，用户通过 UUID 或时间戳等方式生成唯一主键，把这个值当做主键值，在分布式场景中应用较多

查询后通过 `select max(主键) from` 表获取主键最大值，这种方式在多线程访问情况下可能出现问题

查询后通过 `select @@identity` 获取最新生成主键，要求这条 SQL 必须在 insert 操作之后，且数据库连接没有关闭

EmpMapper映射文件