03、MyBatis 映射文件
发布时间：2020-12-14 18:03:44 所属栏目：大数据 来源：网络整理
导读：1.XML映射器 2.select ??Select元素来定义查询操作 ? ?Id：唯一标识符 - 用来引用这条语句，需要和接口的方法名一致 ? ?parameterType：参数类型 - 可以不传，MyBatis会根据TypeHandler自动推断 ? ?resultType：返回值类型 - 别名或者全类名，如果返回的是集
|
1.XML映射器
2.select ??Select元素来定义查询操作 ? ?Id：唯一标识符 - 用来引用这条语句，需要和接口的方法名一致 ? ?parameterType：参数类型 - 可以不传，MyBatis会根据TypeHandler自动推断 ? ?resultType：返回值类型 - 别名或者全类名，如果返回的是集合，定义集合中元素的类型。不能和resultMap同时使用
1)返回List public List<Employee> getEmpsByLastNameLike(String lastName);
<!-- public List<Employee> getEmpsByLastNameLike(String lastName) -->
<select id="getEmpsByLastNameLike" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where last_name like #{lastName}
</select>
List<Employee> like = mapper.getEmpsByLastNameLike("%e%");
for(Employee employee : like) {
System.out.println(employee);
}
2)返回单条Map数据 //返回一条记录的map key:列名 value:值
public Map<String,Object> getEmpByIdReturnMap(Integer id);
<!-- public Map<String,Object> getEmpByIdReturnMap(Integer id) -->
<!-- resultType:期望从这条语句中返回结果的类全限定名或别名.因为Map类型已经内置了所以我们只需要填map即可 -->
<select id="getEmpByIdReturnMap" resultType="map">
select * from tbl_employee where id=#{id}
</select>
Map<String,Object> map = mapper.getEmpByIdReturnMap(1);
System.out.println(map);
3)返回多条Map数据 //多条记录封装为一个map Map<String,Employee> key:记录的主键 value:记录封装后的javabean
//通知mybatis封装成这个map的时候使用那个属性作为主键
// @MapKey("lastName")
// public Map<String,Employee> getEmpByLastNameLikeReturnMap(String lastName);
@MapKey("id")
public Map<Integer,Employee> getEmpByLastNameLikeReturnMap(String lastName);
<!-- public Map<Integer,Employee> getEmpByLastNameLikeReturnMap(String lastName) -->
<select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where last_name like #{lastName}
</select>
// Map<String,Employee> map = mapper.getEmpByLastNameLikeReturnMap("%r%");
// System.out.println(map);
Map<Integer,Employee> map = mapper.getEmpByLastNameLikeReturnMap("%r%");
System.out.println(map);
4)结果映射
5)高级结果映射
(1)自动映射
①.开启驼峰命名(默认规则) ??对比开启mapUnderscoreToCamelCase和不开启mapUnderscoreToCamelCase的区别. ??开启:Employee [id=1,lastName=plutoo,email=plutoo@atguigu.com,gender=1] ??关闭:Employee [id=1,lastName=null,gender=1] ??通过'开启'和'关闭'两个对比，我们清楚到在开启驼峰命名的情况下，mybatis会自动帮我们进行last_name的封装. <settings >
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!-- public Employee getEmpByid(Integer id) -->
<!-- resultType:使用了emp是因为我们起了别名@Alias("emp") -->
<select id="getEmpById" resultType="emp">
select * from tbl_employee where id = #{id}
</select>
@Test
public void test05() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee empById = mapper.getEmpById(1);
System.out.println(empById);
}finally {
openSession.close();
}
}
②.关闭驼峰命名(自定义规则) ??对比开启mapUnderscoreToCamelCase和不开启mapUnderscoreToCamelCase的区别. ??开启:Employee [id=1,gender=1] ??通过'开启'和'关闭'两个对比，我们是否开启驼峰命名的情况下，对mybatis我们进行last_name的封装并无影响,因为我们自定义了封装规则. public Employee getEmpById(Integer id);
<settings>
<!-- <setting name="mapUnderscoreToCamelCase" value="true"/> -->
</settings>
<!-- 自定义某个javaBean的封装规则 -->
<!-- type:自定义规则的Java类型 -->
<!-- id:唯一id方便引用 -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
<!-- 指定主键列的封装规则,id定义主键底层会有优化 -->
<!-- column:指定列 -->
<!-- property:指定对应的javaBean属性 -->
<id column="id" property="id"/>
<!-- 定义普通封装规则 -->
<result column="last_name" property="lastName"/>
<!-- 其他不指定的列会自动封装.只要写resultMap就把全部的映射规则补全 -->
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</resultMap>
<!-- public Employee getEmpByid(Integer id) -->
<!-- resultType:使用了emp是因为我们起了别名@Alias("emp") -->
<!-- resultMap:对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 -->
<!-- resultType 和 resultMap 之间只能同时使用一个 -->
<select id="getEmpById" resultMap="MySimpleEmp">
select * from tbl_employee where id = #{id}
</select>
@Test
public void test05() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee empById = mapper.getEmpById(1);
System.out.println(empById);
}finally {
openSession.close();
}
}
(2)resultMap的应用场景 ①.查询Employee的同时查询员工对应的部门(联合查询) Employee===Department (1.数据表的创建 CREATE TABLE tbl_dept(
id INT(11) PRIMARY KEY AUTO_INCREMENT,dept_name VARCHAR(255)
)
(2.添加外键约束 ALTER TABLE tbl_employee ADD COLUMN d_id INT(11);
ALTER TABLE tbl_employee ADD CONSTRAINT fk_emp_dept
FOREIGN KEY(d_id) REFERENCES tbl_dept(id);?
(3.配置resultMap public Employee getEmpAndDept(Integer id);
<!-- 联合查询:级联属性封装结果集 -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="did" property="dept.id"/>
<result column="dept_name" property="dept.departmentName"/>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id) -->
<!-- 场景一:查询Employee的同时查询员工对应的部门 -->
<!-- 员工与对应部门信息:id last_name gender d_id did dept_name (private Department dept;) -->
<select id="getEmpAndDept" resultMap="MyDifEmp">
SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,d.id did,d.dept_name dept_name
FROM tbl_employee e,tbl_dept d
WHERE e.d_id=d.id AND e.id=#{id}
</select>
@Test
public void test05() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee empAndDept = mapper.getEmpAndDept(1);
System.out.println(empAndDept);
System.out.println(empAndDept.getDept());
}finally {
openSession.close();
}
}
②.查询Employee的同时查询员工对应的部门(association) Employee===Department
public Employee getEmpAndDept(Integer id);
<!-- 使用association定义关联的单个对象的封装规则 -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<!-- association:可以指定联合的javaBean对象 -->
<!-- property:映射到列结果的字段或属性。如果用来匹配的 JavaBean 存在给定名字的属性，那么它将会被使用。 -->
<!-- javaType:JDBC类型.只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可能存在空值的列指定这个类型。 -->
<!-- <id column="did" property="id"/>|<id column="id" property="id"/> 这两个property都表示是id,但是column不可一样否则认定为同一个id -->
<association property="dept" javaType="com.atguigu.mybatis.bean.Department">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
</association>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id) -->
<!-- 场景一:查询Employee的同时查询员工对应的部门 -->
<!-- 员工与对应部门信息:id last_name gender d_id did dept_name (private Department dept;) -->
<select id="getEmpAndDept" resultMap="MyDifEmp2">
SELECT e.id id,tbl_dept d
WHERE e.d_id=d.id AND e.id=#{id}
</select>
@Test
public void test05() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee empAndDept = mapper.getEmpAndDept(1);
System.out.println(empAndDept);
System.out.println(empAndDept.getDept());
}finally {
openSession.close();
}
}
③.查询Employee的同时查询员工对应的部门(association分步查询) (1.Department.java public class Department {
private Integer id;
private String departmentName;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getDepartmentName() {
return departmentName;
}
public void setDepartmentName(String departmentName) {
this.departmentName = departmentName;
}
@Override
public String toString() {
return "Department [id=" + id + ",departmentName=" + departmentName + "]";
}
}?
(2.DepartmentMapper.java public interface DepartmentMapper {
public Department getDeptById(Integer id);
}
(3.EmployeeMapperPlus.java public interface EmployeeMapperPlus {
public Employee getEmpByIdStep(Integer id);
}
(4.DepartmentMapper.xml <mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
<!-- public Department getDeptById(Integer id) -->
<select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
select dept_name departmentName,id from tbl_dept where id=#{id}
</select>
</mapper>
(5.Employee.java public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
private Department dept;
public Department getDept() {
return dept;
}
public void setDept(Department dept) {
this.dept = dept;
}
public Employee() {
super();
// TODO Auto-generated constructor stub
}
public Employee(Integer id,String lastName,String email,String gender) {
this.id = id;
this.lastName = lastName;
this.email = email;
this.gender = gender;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Employee [id=" + id + ",lastName=" + lastName + ",email=" + email + ",gender=" + gender + "]";
}
}
(6.EmployeeMapperPlus.xml <mapper namespace="com.atguigu.mybatis.dao.EmployeeMapperPlus">
<!-- id last_name email gender d_id -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!-- association定义关联对象的封装规则 -->
<!-- select:表明当前属性是调用select指定的方法查出的结果 -->
<!-- column:指定将一列的值传给这个方法 -->
<!-- 流程:使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性-->
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</resultMap>
<!-- 使用association进行分步查询 -->
<!-- 1、先按照员工id查询员工信息 -->
<!-- 2、根据查询员工信息中的d_id值去部门表查出部门信息 -->
<!-- 3、部门设置到员工中 -->
<!-- public Employee getEmpByIdStep(Integer id) -->
<select id="getEmpByIdStep" resultMap="MyEmpByStep">
select * from tbl_employee where id=#{id}
</select>
</mapper>
(7.MyBatisTest.java @Test
public void test05() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee employee = mapper.getEmpByIdStep(1);
System.out.println(employee);
System.out.println(employee.getDept());
}finally {
openSession.close();
}
}
(8.延迟加载 ? 观察Test中的查询两条的结果.通过控制台我们可以知道，开启了延迟加载后.我们查询的结果为单条单条的查询,按查询需要给控制台，不会一下子把查询结果全部给控制台. ??旧版本的MyBatis需要额外的支持包 – asm-3.3.1.jar – cglib-2.2.2.jar <!-- 使用延迟加载(懒加载) (按需加载) -->
<!-- 分段查询的基础之上加上两个配置 -->
<!-- mybatis-config.xml全局配置中在<settings>中添加一下两条 -->
<!-- <setting name="lazyLoadingEnabled" value="true"/> -->
<!-- <setting name="aggressiveLazyLoading" value="false"/> -->
<settings >
<!--显示的指定我们需要更改的配置的值，即使默认的。防止版本迭代后带来的问题 -->
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
System.out.println(employee);
-------------------------------------------------------------------------------------------
System.out.println(employee);
System.out.println(employee.getLastName());
④.查询部门的时候将部门对应的所有员工信息也查询出来
public class Department {
private Integer id;
private String departmentName;
private List<Employee> emps;
}
<mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
<!-- private Integer id; private String departmentName; private List<Employee> emps; -->
<!-- did dept_name ||(分割) eid last_name email gender -->
<!-- 嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
<!-- collection:定义关联集合类型的属性的封装规则 -->
<!-- ofType:指定集合里面元素的类型 -->
<collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
<!-- 定义集合中元素的封装规则 -->
<id column="eid" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</collection>
</resultMap>
<!-- public Department getDeptByIdPlus(Integer id) -->
<select id="getDeptByIdPlus" resultMap="MyDept">
SELECT d.id did,d.dept_name dept_name,e.id eid,e.email email,e.gender gender
FROM tbl_dept d
LEFT JOIN tbl_employee e
ON d.id=e.d_id
WHERE d.id=#{id}
</select>
</mapper>
@Test
public void test06() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
Department department = mapper.getDeptByIdPlus(1);
System.out.println(department);
System.out.println(department.getEmps());
}finally {
openSession.close();
}
}
⑤.查询部门的时候将部门对应的所有员工信息也查询出来(分步查询) public interface EmployeeMapperPlus {
public List<Employee> getEmpsByDeptId(Integer deptId);
}
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapperPlus">
<!-- 场景二:查询部门的时候将部门对应的所有员工信息也查询出来;注释在DepartmentMapper.xml中 -->
<!-- public List<Employee> getEmpsByDeptId(Integer deptId) -->
<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where d_id=#{deptId}
</select>
</mapper>
<mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
<!-- collection分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
column="{deptId=id}" fetchType="lazy">
</collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id) -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select id,dept_name departmentName from tbl_dept where id=#{id}
</select>
</mapper>
@Test
public void test06() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
Department deptByIdStep = mapper.getDeptByIdStep(1);
System.out.println(deptByIdStep);
System.out.println(deptByIdStep.getEmps());
}finally {
openSession.close();
}
}
延迟加载 <!-- 场景二:查询部门的时候将部门对应的所有员工信息也查询出来;注释在DepartmentMapper.xml中 -->
<!-- public List<Employee> getEmpsByDeptId(Integer deptId) -->
<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where d_id=#{deptId}
</select>
<!-- collection分段查询 -->
<!-- 扩展:需要将多列的值传递 -->
<!-- 将多列的值封装map传递 -->
<!-- column="{key1=column1,key2=column2}" -->
<!-- fetchType="lazy|eager":表示使用延迟加载 lazy:延迟 eager:立即 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
column="{deptId=id}" fetchType="lazy">
</collection>
</resultMap>
6).鉴别器 ?
Department deptByIdStep = mapper.getDeptByIdStep(1);
System.out.println(deptByIdStep);
System.out.println(deptByIdStep.getEmps());
<!-- <discriminator javaType=""></discriminator> -->
<!-- 鉴别器:一个数据库查询可能会返回多个不同的结果集（但总体上还是有一定的联系的）。 鉴别器元素就是被设计来应对这种情况的 -->
<!-- 如果查出的是女生:就把部门信息查询出来,否则不查询 -->
<!-- 如果是男生:把last_name这一列的值赋值给email -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!-- column:指定判定的列名 -->
<!-- javaType:列值对应的java类型 -->
<discriminator javaType="string" column="gender">
<!-- resultType:指定封装的结果类型；不能缺少 -->
<!-- 女生:就把部门信息查询出来 -->
<case value="0" resultType="com.atguigu.mybatis.bean.Employee">
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</case>
<!-- 男生:把last_name这一列的值赋值给email -->
<case value="1" resultType="com.atguigu.mybatis.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="last_name" property="email"/>
<result column="gender" property="gender"/>
</case>
</discriminator>
</resultMap>
<select id="getEmpByIdStep" resultMap="MyEmpDis">
select * from tbl_employee where id=#{id}
</select>
3.insert update delete
1)insert (1)支持自增方式数据库 ??若数据库支持自动生成主键的字段（比如 MySQL和 SQL Server）,则可以设置useGeneratedKeys=”true”，然后再把keyProperty 设置到目标属性上 public void addEmp(Employee employee);
<!-- public void addEmp(Employee employee) -->
<!-- parameterType:将会传入这条语句的参数的类全限定名或别名。这个属性是可选的。 -->
<!-- 获取自增主键的值 -->
<!-- mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys() -->
<!-- useGeneratedKeys:使用自增主键获取主键值策略 true|false -->
<!-- keyProperty:指定对应的主键属性;mybatis获取到主键值以后，将值封装给指定的javaBean属性 -->
<insert id="addEmp" parameterType="com.atguigu.mybatis.bean.Employee" useGeneratedKeys="true"
keyProperty="id">
insert into tbl_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
</insert>
(2)不支持自增方式数据库 ? 而对于不支持自增型主键的数据库（例如Oracle），则可以使用 selectKey 子元素：selectKey 元素将会首先运行，id 会被设置，然后插入语句会被调用 public void addEmp(Employee employee);
<!-- 获取非自增主键的值:Oracle不支持自增.Oracle使用序列来模拟自增.每次插入的数据的主键是从序列中拿到的值.-->
<!-- selectKey:执行查询Key操作 -->
<!-- keyProperty:指定对应的主键属性;mybatis获取到主键值以后，将值封装给指定的javaBean属性 -->
<!-- statementType:MyBatis 支持 STATEMENT，PREPARED 和 CALLABLE 类型的映射语句，分别代表 Statement,PreparedStatement 和 CallableStatement 类型。 -->
<!-- resultType:结果的类型 -->
<!-- order:可以设置为 BEFORE 或 AFTER。如果设置为 BEFORE，它首先会生成主键，设置 keyProperty 再执行插入语句。如果设置为 AFTER，先执行插入语句，然后 selectKey 中的语句 -->
<insert id="addEmp" databaseId="oracle">
<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
<!-- 编写查询主键的sql语句 -->
<!-- BEFORE -->
select EMPLOYEES_SEQ.nextval from dual
<!-- AFTER：-->
<!-- select EMPLOYEES_SEQ.currval from dual -->
</selectKey>
<!-- 插入时的主键是从序列中拿到的 -->
<!-- BEFORE:-->
insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) values(#{id},#{lastName},#{email<!--,jdbcType=NULL -->})
<!-- AFTER：-->
<!-- insert into employees(EMPLOYEE_ID,EMAIL) values(employees_seq.nextval,#{email}) -->
</insert>
2)update public void updateEmp(Employee employee);
<!-- public void updateEmp(Employee employee) -->
<update id="updateEmp">
update tbl_employee set last_name=#{lastName},email=#{email},gender=#{gender} where id=#{id}
</update>
3)delete public void deleteEmpById(Integer id);
<!-- public void deleteEmpById(Integer id) -->
<delete id="deleteEmpById">
delete from tbl_employee where id=#{id}
</delete>
4)Test /**
* 测试增删改
* 1、mybatis允许增删改直接定义一下的类型返回值 Integer Long Boolean void
* 2、我们需要手动提交数据
* 手动提交:sqlSessionFactory.openSession()
* 自动提交:sqlSessionFactory.openSession(true)
* @throws IOException
*
*/
@Test
public void test03() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
// 测试添加
Employee employee = new Employee(null,"jerry","atguigu@atguigu.com","1");
mapper.addEmp(employee);
System.out.println(employee.getId());
//测试修改
// Employee employee = new Employee(1,"pluto","pluto@pluto.com","0");
// mapper.updateEmp(employee);
//测试删除
// mapper.deleteEmpById(2);
openSession.commit();
}finally {
openSession.close();
}
}
4.MyBatis参数
1)单个参数 ??可以接受基本类型，对象类型，集合类型的值。这种情况MyBatis可直接使用这个参数，不需要经过任何处理 public Employee getEmpById(Integer id);
select * from tbl_employee where id = #{id}
2)多个参数 ??异常：org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available parameters are [1,param1,param2] public Employee getEmpByIdAndLastName(Integer id,String lastName);
select * from tbl_employee where id = #{id} and last_name=#{lastName}
??任意多个参数，都会被MyBatis重新包装成一个Map传入. ??Map的key是param1，param2，0，1…，值就是参数的值. select * from tbl_employee where id=#{param1} and last_name=#{param2}
(1)命名参数 ? 参数使用@Param起一个名字，MyBatis就会将这些参数封装进map中，key就是我们自己指定的名字. - 明确指定封装参数时map的key；@Param("id"); - 多个参数会被封装成一个map - key：使用@Param注解指定的值|value：参数值 - #{指定的key}取出对应的参数值 public Employee getEmpByIdAndLastName(@Param("id")Integer id,@Param("lastName")String lastName);
select * from tbl_employee where id=#{id} and last_name=#{lastName}
@Test
public void test04() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
//1.获取到sqlSessionFactory但是不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee employee = mapper.getEmpByIdAndLastName(1,"plutoo");
System.out.println(employee);
}finally {
openSession.close();
}
}?
(2)POJO ??当这些参数属于我们业务POJO时.换句话说，如果多个参数正好是我们业务逻辑的数据模型，我们直接传递POJO. public void getEmpPoJo(Employee employee);
<!-- public Employee getEmpPoJo(Integer id,String email) -->
<select id="getEmpPoJo" resultType="com.atguigu.mybatis.bean.Employee">
update tbl_employee
set last_name=#{lastName},gender=#{gender}
where id=#{id}
</select>
@Test
public void test04() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession(true);
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee employee = new Employee(1,"plutoo","plutoo@atguigu.com","1");
mapper.getEmpPoJo(employee);
}finally {
openSession.close();
}
}
(3)Map 我们也可以封装多个参数为map，直接传递. 如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map public Employee getEmpByMap(Map<String,Object> map);
<!-- public Employee getEmpByMap(Map<String,Object> map) -->
<select id="getEmpByMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where id=#{id} and last_name=#{lastName}
</select>
@Test
public void test04() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
//1.获取到sqlSessionFactory但是不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
// Employee employee = mapper.getEmpByIdAndLastName(1,"pluto");
Map<String,Object> map = new HashMap<>();
map.put("id",1);
map.put("lastName","pluto");
Employee employee = mapper.getEmpByMap(map);
mapper.getEmpByMap(map);
System.out.println(employee);
}finally {
openSession.close();
}
}
(4)To: ??如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map ?
(5)参数举例 public Employee getEmp(@Param("id")Integer id,String lastName);
取值：id==>#{id/param1} lastName==>#{param2}
public Employee getEmp(Integer id,@Param("e")Employee emp);
取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}
##特别注意：如果是Collection（List、Set）类型或者是数组，
也会特殊处理。也是把传入的list或者数组封装在map中。
key：Collection（collection）,如果是List还可以使用这个key(list)
数组(array)
public Employee getEmpById(List<Integer> ids);
取值：取出第一个id的值： #{list[0]}
(6)查看源码 MyBati怎么处理参数 ??参数多时会封装map，为了不混乱，我们可以使用@Param来指定封装时使用的key public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
//1、参数为null直接返回
if (args == null || paramCount == 0) {
return null;
//2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
//3、多个元素或者有Param标注
} else {
final Map<String,Object> param = new ParamMap<Object>();
int i = 0;
//4、遍历names集合；{0=id,1=lastName,2=2}
for (Map.Entry<Integer,String> entry : names.entrySet()) {
//names集合的value作为key; names集合的key又作为取值的参考args[0]:args【1，"Tom"】:
//eg:{id=args[0]:1,lastName=args[1]:Tom,2=args[2]}
param.put(entry.getValue(),args[entry.getKey()]);
// add generic param names (param1,param2,...)param
//额外的将每一个参数也保存到map中，使用新的key：param1...paramN
//效果：有Param注解可以#{指定的key}，或者#{param1}
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
if (!names.containsValue(genericParamName)) {
param.put(genericParamName,args[entry.getKey()]);
}
i++;
}
return param;
}
}
}?
(@Param("id")Integer id,@Param("lastName")String lastName); ParamNameResolver解析参数封装map的 //names：{0=id,1=lastName}；构造器的时候就确定好了 流程： ??①.获取每个标了param注解的参数的@Param的值:id，lastName赋值给name ??②.每次解析一个参数给map中保存信息：（key：参数索引，value：name的值） - name的值： - 标注 - param注解：注解的值 - 无标注： - 全局配置：useActualParamName(jdk1.8):name=参数名 - name=map.size()；相当于当前元素的索引 (7)参数值的获取 #{}：可以获取map中的值或者pojo对象属性的值； ${}：可以获取map中的值或者pojo对象属性的值；
select * from tbl_employee where id=${id} and last_name=#{lastName}
Preparing: select * from tbl_employee where id=2 and last_name=?
select * from tbl_employee where id=#{id} and last_name=#{lastName}
Preparing: select * from tbl_employee where id=? and last_name=?
①.区别 ??#{}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入 ??${}:取出的值直接拼装在sql语句中；会有安全问题； ??大多情况下，我们去参数的值都应该去使用#{}； 原生jdbc不支持占位符的地方我们就可以使用${}进行取值 ? 比如分表、排序。。。；按照年份分表拆分 ????select * from ${year}_salary where xxx; ????select * from tbl_employee order by ${f_name} ${order} <!-- public Employee getEmpByMap(Map<String,Object> map) -->
<select id="getEmpByMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from #{tableName} where id=#{id} and last_name=#{lastName}
</select>
<!-- public Employee getEmpByMap(Map<String,Object> map) -->
<select id="getEmpByMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from ${tableName} where id=#{id} and last_name=#{lastName}
</select>
@Test
public void test04() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
//1.获取到sqlSessionFactory但是不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Map<String,2);
map.put("lastName","plutoo");
map.put("tableName","tbl_employee");
Employee employee = mapper.getEmpByMap(map);
mapper.getEmpByMap(map);
System.out.println(employee);
}finally {
openSession.close();
}
}
②.#{}用法 jdbcType ??在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle(报错) JdbcType OTHER:无效的类型.因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理. ??全局配置中:jdbcTypeForNull=OTHER；oracle不支持； 两种办法 ??- #{email,jdbcType=OTHER}; ? - jdbcTypeForNull=NULL <setting name="jdbcTypeForNull" value="NULL"/> 参考文档:https://mybatis.org/mybatis-3/zh/sqlmap-xml.html# https://mybatis.org/mybatis-3/zh/configuration.html#settings ? ? ? ? ? ?
（编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |
