03、MyBatis 映射文件
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, email=plutoo@atguigu.com, 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, lastName=plutoo, email=plutoo@atguigu.com, gender=1]
关闭:Employee [id=1, lastName=plutoo, email=plutoo@atguigu.com, 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,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分步查询)
(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.last_name last_name,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,LAST_NAME,EMAIL) values(employees_seq.nextval,#{lastName},#{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, 0, 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},email=#{email},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, Object> map = new HashMap<>();
map.put("id", 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
<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> |
03、MyBatis 映射文件的更多相关文章
- Mybatis映射文件完整模板参照
Mybatis映射文件完整模板参照 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE map ...
- Mybatis映射文件中#取值时指定参数相关规则
Mybatis映射文件中#取值时指定参数相关规则 在#{}中,除了需要的数值外,还可以规定参数的一些其他规则. 例如:javaType,jdbcType,mode(存储过程),numericScale ...
- SSM实战——秒杀系统之DAO层实体定义、接口设计、mybatis映射文件编写、整合Spring与Mybatis
一:DAO实体编码 1:首先,在src目录下,新建org.myseckill.entity包,用于存放实体类: 2:实体类设计 根据前面创建的数据库表以及映射关系,创建实体类. 表一:秒杀商品表 对应 ...
- MyBatis 映射文件详解
1. MyBatis 映射文件之<select>标签 <select>用来定义查询操作; "id": 唯一标识符,需要和接口中的方法名一致; paramet ...
- MyBatis映射文件中用#和$传递参数的特点
在MyBatis映射文件中用#和$传递参数的特点, #是以占位符的形式来传递对应变量的参数值的,框架会对传入的参数做预编译的动作, 用$时会将传入的变量的参数值原样的传递过去,并且用$传递传递参数的时 ...
- MyBatis映射文件 相关操作
一.MyBatis映射文件 1.简介 MyBatis 的真正强大在于它的映射语句,也是它的魔力所在.由于它的异常强大,映射器的 XML 文件就显得相对简单.如果拿它跟具有相同功能的 JDBC 代码进行 ...
- Mybatis映射文件标签(关于sql)
Mybatis映射文件 1.接口的全限定名和映射文件的namespace一致 <mapper namespace="com.offcn.dao.UserDao"> 2. ...
- MyBatis 映射文件
Mybatis映射文件简介 1) MyBatis 的真正强大在于它的映射语句.由于它的异常强大,映射器的 XML 文件就显得相对简单.如果拿它跟具有相同功能的 JDBC 代码进行对比,你会立即发现省掉 ...
- Mybatis映射文件
Mapper XML 文件 MyBatis 的真正强大在于它的映射语句,也是它的魔力所在.由于它的异常强大,映射器的 XML 文件就显得相对简单.如果拿它跟具有相同功能的 JDBC 代码进行对比,你会 ...
- MyBatis映射文件的resultMap如何做表关联
MyBatis的核心是其映射文件,SqlMap文件,里面配置了项目中用到了什么SQL语句,和数据库相关的逻辑都在这个映射文件里.顾名思义,映射文件就是对Java对象和SQL的映射.这里简单介绍一下映射 ...
随机推荐
- spring boot:用cookie保存i18n信息避免每次请求时传递参数(spring boot 2.3.3)
一,用cookie保存i18n信息的优点? 当开发一个web项目(非api站)时,如果把i18n的选择信息保存到cookie, 则不需要在每次发送请求时都传递所选择语言的参数, 也不需要增加heade ...
- centos 开机启动服务 systemctl
systemctl 实现开机自启服务 转载起一个好听的名字 最后发布于2018-06-26 13:49:06 阅读数 13473 收藏 展开 systemctl是RHEL 7 的服务管理工具中主要的 ...
- Linux+Nginx/Apache下的PHP exec函数执行Linux命令
1.php.ini配置文件 打开PHP的配置文件,里面有一行 disable_function 的值,此处记录了禁止运行的函数,在里面将exec和shell_exec.system等函数删除. 2.权 ...
- 简述 QPS、TPS、并发用户数、吞吐量关系
1. QPS QPS Queries Per Second 是每秒查询率 ,是一台服务器每秒能够相应的查询次数,是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准, 即每秒的响应请求数,也即 ...
- 第六章 类(Class) 和对象(Object)
一.笔记导图 二.实例代码: public class PrintCarStatus{ public static void main(String[] args){ int speed; Strin ...
- (静默安装)Cent OS 6_5(x86_64)下安装Oracle 11g
Cent OS 6_5(x86_64)下安装Oracle 11g 1 硬件要求 1.1 内存 & swap 物理内存不少于1G 硬盘可以空间不少于5G swap分区空间不少于2G Mini ...
- Semaphore(信号灯)
public class SemaphoreDemo { public static void main(String[] args) { //三个停车位 Semaphore sp = new Sem ...
- vue 项目抛出警告
There are multiple modules with names that only differ in casing. 此图为 博主(初雪日)的截图, 这个问题虽然不报错,但是会对项目有影 ...
- 大二逃课总结的1.2w字的计算机网络知识!扫盲!
本文是我在大二学习计算机网络期间整理, 大部分内容都来自于谢希仁老师的<计算机网络>这本书. 为了内容更容易理解,我对之前的整理进行了一波重构,并配上了一些相关的示意图便于理解. @ 目录 ...
- Vulnhub DC3
靶机简介 C-3是另一个专门建造的易受攻击的实验室,目的是获得渗透测试领域的经验.与以前的DC版本一样,这个版本是为初学者设计的,尽管这次只有一个标志,一个入口点,根本没有线索.Linux技能和熟悉L ...