[第一节 HelloWorld]
[第二节 HelloWorld强化]
[第三节 给SQL语句传参]
[第四节 数据输入]
[第五节 数据输出]
文章目录- 第二章 Mybatis基本用法
- 第一节 HelloWorld
- 1、物理建模
- 2、逻辑建模
- ①创建Maven module
- ②创建Java实体类
- 3、搭建框架开发环境
- ①导入依赖
- ②准备配置文件
- [1]Mybatis全局配置文件
- [2]Mybatis映射文件
- 5、junit测试代码
- 第二节 HelloWorld强化
- 1、加入日志
- ①目的
- ②操作
- [1]加入依赖
- [2]加入log4j的配置文件
- ③日志的级别
- ④STDOUT
- ⑤打印效果
- 2、关联外部属性文件
- ①需求
- ②做法
- 3、用上Mapper接口
- ①思路
- ②调整junit代码
- ③完成Mapper接口
- ④最终的junit测试方法
- 10、增删改操作
- ①insert
- ②delete
- ③update
- 第三节 给SQL语句传参
- 1、#{}方式
- 2、${}方式
- ①SQL语句
- ②Mapper接口
- ③junit测试
- ④实际打印的SQL
- ⑤应用场景举例
- 第四节 数据输入
- 1、Mybatis总体机制概括
- 2、概念说明
- 3、单个简单类型参数
- ①Mapper接口中抽象方法的声明
- ②SQL语句
- 4、实体类类型参数
- ①Mapper接口中抽象方法的声明
- ②SQL语句
- ③对应关系
- ④结论
- 5、零散的简单类型数据
- ①Mapper接口中抽象方法的声明
- ②SQL语句
- ③对应关系
- 6、Map类型参数
- ①Mapper接口中抽象方法的声明
- ②SQL语句
- ③junit测试
- ④对应关系
- ⑤使用场景
- 第五节 数据输出
- 1、返回单个简单类型数据
- ①Mapper接口中的抽象方法
- ②SQL语句
- ③junit测试
- 2、返回实体类对象
- ①Mapper接口的抽象方法
- ②SQL语句
- 3、返回Map类型
- ①Mapper接口的抽象方法
- ②SQL语句
- ③junit测试
- 4、返回List类型
- ①Mapper接口中抽象方法
- ②SQL语句
- ③junit测试
- 5、返回自增主键
- ①使用场景
- ②在Mapper配置文件中设置方式
- [1]Mapper接口中的抽象方法
- [2]SQL语句
- [3]junit测试
- ④注意
- ⑤不支持自增主键的数据库
- 6、数据库表字段和实体类属性对应关系
- ①别名
- ②全局配置自动识别驼峰式命名规则
- ③使用resultMap
CREATE DATABASE `mybatis-example`;
USE `mybatis-example`;
CREATE TABLE `t_emp`(
emp_id INT AUTO_INCREMENT,
emp_name CHAr(100),
emp_salary DOUBLE(10,5),
PRIMARY KEY(emp_id)
);
INSERT INTO `t_emp`(emp_name,emp_salary) VALUES("tom",200.33);
2、逻辑建模
①创建Maven module
②创建Java实体类
实体类是和现实世界中某一个具体或抽象的概念对应,是软件开发过程中,为了管理现实世界中的数据而设计的模型。
实体类的多个不同的叫法:
domain:领域模型
entity:实体
POJO:Plain Old Java Object
Java bean:一个Java类
public class Employee {
private Integer empId;
private String empName;
private Double empSalary;
public Employee() {
}
public Integer getEmpId() {
return empId;
}
public void setEmpId(Integer empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public Double getEmpSalary() {
return empSalary;
}
public void setEmpSalary(Double empSalary) {
this.empSalary = empSalary;
}
@Override
public String toString() {
return "Employee{" +
"empId=" + empId +
", empName='" + empName + ''' +
", empSalary=" + empSalary +
'}';
}
public Employee(Integer empId, String empName, Double empSalary) {
this.empId = empId;
this.empName = empName;
this.empSalary = empSalary;
}
}
3、搭建框架开发环境
①导入依赖
②准备配置文件 [1]Mybatis全局配置文件org.mybatis mybatis 3.5.7 junit junit 4.12 test mysql mysql-connector-java 5.1.3 com.alibaba druid 1.0.31
习惯上命名为mybatis-config.xml,这个文件名仅仅只是建议,并非强制要求。将来整合Spring之后,这个配置文件可以省略,所以大家操作时可以直接复制、粘贴。
注意:配置文件存放的位置是src/main/resources目录下。
[2]Mybatis映射文件相关概念:ORM(Object Relationship Mapping)对象关系映射。
- 对象:Java的实体类对象
- 关系:关系型数据库
- 映射:二者之间的对应关系
| Java概念 | 数据库概念 |
|---|---|
| 类 | 表 |
| 属性 | 字段/列 |
| 对象 | 记录/行 |
注意:EmployeeMapper.xml所在的目录要和mybatis-config.xml中使用mapper标签配置的一致。
5、junit测试代码@Test
public void testSelectEmployee() throws IOException {
// 1.创建SqlSessionFactory对象
// ①声明Mybatis全局配置文件的路径
String mybatisConfigFilePath = "mybatis-config.xml";
// ②以输入流的形式加载Mybatis配置文件
InputStream inputStream = Resources.getResourceAsStream(mybatisConfigFilePath);
// ③基于读取Mybatis配置文件的输入流创建SqlSessionFactory对象
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 2.使用SqlSessionFactory对象开启一个会话
SqlSession session = sessionFactory.openSession();
// 3.根据Mapper配置文件的名称空间+SQL语句的id找到具体的SQL语句
// 格式是:名称空间.SQL语句的id
String statement = "com.atguigu.mybatis.dao.EmployeeMapper.selectEmployee";
// 要传入SQL语句的参数
Integer empId = 1;
// 执行SQL语句
Object result = session.selectOne(statement, empId);
System.out.println("o = " + result);
// 4.关闭SqlSession
session.close();
}
说明:
- SqlSession:代表Java程序和数据库之间的会话。(HttpSession是Java程序和浏览器之间的会话)
- SqlSessionFactory:是“生产”SqlSession的“工厂”。
- 工厂模式:如果创建某一个对象,使用的过程基本固定,那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中,以后都使用这个工厂类来“生产”我们需要的对象。
在Mybatis工作过程中,通过打印日志的方式,将要执行的SQL语句打印出来。
②操作 [1]加入依赖[2]加入log4j的配置文件log4j log4j 1.2.17
支持XML和properties属性文件两种形式。无论使用哪种形式,文件名是固定的:
- log4j.xml
- log4j.properties
③日志的级别
FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
从左到右打印的内容越来越详细
④STDOUT是standard output的缩写,意思是标准输出。对于Java程序来说,打印到标准输出就是打印到控制台。
⑤打印效果2、关联外部属性文件 ①需求DEBUG 05-24 18:51:13,331 ==> Preparing: select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=? (BaseJdbcLogger.java:137)
DEBUG 05-24 18:51:13,371 > Parameters: 1(Integer) (BaseJdbcLogger.java:137)
DEBUG 05-24 18:51:13,391 < Total: 1 (BaseJdbcLogger.java:137)
o = Employee{empId=1, empName=‘tom’, empSalary=200.33}
在实际开发时,同一套代码往往会对应多个不同的具体服务器环境。使用的数据库连接参数也不同。为了更好的维护这些信息,我们建议把数据库连接信息提取到Mybatis全局配置文件外边。
②做法创建jdbc.properties配置文件
wechat.dev.driver=com.mysql.jdbc.Driver
wechat.dev.url=jdbc:mysql://192.168.198.100:3306/mybatis-example
wechat.dev.username=root
wechat.dev.password=atguigu
wechat.test.driver=com.mysql.jdbc.Driver
wechat.test.url=jdbc:mysql://192.168.198.150:3306/mybatis-example
wechat.test.username=root
wechat.test.password=atguigu
wechat.product.driver=com.mysql.jdbc.Driver
wechat.product.url=jdbc:mysql://192.168.198.200:3306/mybatis-example
wechat.product.username=root
wechat.product.password=atguigu
在Mybatis全局配置文件中指定外部jdbc.properties文件的位置
在需要具体属性值的时候使用${key}格式引用属性文件中的键
3、用上Mapper接口
Mybatis中的Mapper接口相当于以前的Dao。但是区别在于,Mapper仅仅是接口,我们不需要提供实现类。
①思路 ②调整junit代码public class PromotedMybatisTest {
private SqlSessionFactory sessionFactory;
@Before
public void init() throws IOException {
// 1.创建SqlSessionFactory对象
// ①声明Mybatis全局配置文件的路径
String mybatisConfigFilePath = "mybatis-config.xml";
// ②以输入流的形式加载Mybatis配置文件
InputStream inputStream = Resources.getResourceAsStream(mybatisConfigFilePath);
// ③基于读取Mybatis配置文件的输入流创建SqlSessionFactory对象
sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void testSelectEmployee() throws IOException {
SqlSession session = sessionFactory.openSession();
session.close();
}
}
③完成Mapper接口
public interface EmployeeMapper {
Employee selectEmployee(Integer empId);
}
- 方法名和SQL的id一致
- 方法返回值和resultType一致
- 方法的参数和SQL的参数一致
- 接口的全类名和映射配置文件的名称空间一致
@Test
public void testSelectEmployee() throws IOException {
// 1.从工厂对象中获取SqlSession对象
SqlSession session = sessionFactory.openSession();
// 2.通过SqlSession对象获取Mapper接口对象
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
// 3.调用Mapper接口的方法
Employee employee = employeeMapper.selectEmployee(1);
// 4.打印返回值
System.out.println("employee = " + employee);
// 5.关闭Session
session.close();
}
10、增删改操作
①insert
SQL语句
insert into t_emp(emp_name,emp_salary) values(#{empName},#{empSalary})
Java代码中的Mapper接口:
public interface EmployeeMapper {
Employee selectEmployee(Integer empId);
int insertEmployee(Employee employee);
}
Java代码中的junit测试:
@Test
public void testSaveEmployee() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
// 创建要保存到数据库的对象
Employee employee = new Employee();
// 给实体类对象设置具体属性值
employee.setEmpName("jerry");
employee.setEmpSalary(5000.33);
// 执行保存操作
int result = employeeMapper.insertEmployee(employee);
// 打印受影响的行数
System.out.println("result = " + result);
// 提交事务
session.commit();
session.close();
}
②delete
SQL语句
delete from t_emp where emp_id=#{empId}
Java代码中的Mapper接口:
public interface EmployeeMapper {
Employee selectEmployee(Integer empId);
int insertEmployee(Employee employee);
int deleteEmployee(Integer empId);
}
Java代码中的junit测试:
@Test
public void testRemoveEmployee() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
int result = employeeMapper.deleteEmployee(1);
System.out.println("result = " + result);
session.commit();
session.close();
}
③update
SQL语句:
update t_emp set emp_name=#{empName},emp_salary=#{empSalary} where emp_id=#{empId}
Java代码中的Mapper接口:
public interface EmployeeMapper {
Employee selectEmployee(Integer empId);
int insertEmployee(Employee employee);
int deleteEmployee(Integer empId);
int updateEmployee(Employee employee);
}
Java代码中的junit测试:
@Test
public void testUpdateEmployee() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Employee employee = new Employee(2, "AAAAAA", 6666.66);
int result = employeeMapper.updateEmployee(employee);
System.out.println("result = " + result);
session.commit();
session.close();
}
第三节 给SQL语句传参
1、#{}方式
Mybatis会在运行过程中,把配置文件中的SQL语句里面的#{}转换为“?”占位符,发送给数据库执行。
配置文件中的SQL:
delete from t_emp where emp_id=#{empId}
实际执行的SQL:
delete from t_emp where emp_id=?2、${}方式
将来会根据${}拼字符串
①SQL语句②Mapper接口select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_name like '%${empName}%'
注意:由于Mapper接口中方法名是作为SQL语句标签的id,不能重复,所以Mapper接口中不能出现重名的方法,不允许重载!
public interface EmployeeMapper {
Employee selectEmployee(Integer empId);
Employee selectEmployeeByName(@Param("empName") String empName);
int insertEmployee(Employee employee);
int deleteEmployee(Integer empId);
int updateEmployee(Employee employee);
}
③junit测试
@Test
public void testDollar() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Employee employee = employeeMapper.selectEmployeeByName("r");
System.out.println("employee = " + employee);
session.commit();
session.close();
}
④实际打印的SQL
select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_name like '%r%'⑤应用场景举例
在SQL语句中,数据库表的表名不确定,需要外部动态传入,此时不能使用#{},因为数据库不允许表名位置使用问号占位符,此时只能使用${}。
其他情况,只要能用#{}肯定不用${},避免SQL注入。
第四节 数据输入 1、Mybatis总体机制概括 2、概念说明这里数据输入具体是指上层方法(例如Service方法)调用Mapper接口时,数据传入的形式。
- 简单类型:只包含一个值的数据类型
- 基本数据类型:int、byte、short、double、……
- 基本数据类型的包装类型:Integer、Character、Double、……
- 字符串类型:String
- 复杂类型:包含多个值的数据类型
- 实体类类型:Employee、Department、……
- 集合类型:List、Set、Map、……
- 数组类型:int[]、String[]、……
- 复合类型:List
、实体类中包含集合……
Employee selectEmployee(Integer empId);②SQL语句 4、实体类类型参数 ①Mapper接口中抽象方法的声明
int insertEmployee(Employee employee);②SQL语句
③对应关系 ④结论insert into t_emp(emp_name,emp_salary) values(#{empName},#{empSalary})
Mybatis会根据#{}中传入的数据,加工成getXxx()方法,通过反射在实体类对象中调用这个方法,从而获取到对应的数据。填充到#{}这个位置。
5、零散的简单类型数据 ①Mapper接口中抽象方法的声明int updateEmployee(@Param("empId") Integer empId,@Param("empSalary") Double empSalary);
②SQL语句
③对应关系 6、Map类型参数 ①Mapper接口中抽象方法的声明update t_emp set emp_salary=#{empSalary} where emp_id=#{empId}
int updateEmployeeByMap(Map②SQL语句paramMap);
③junit测试update t_emp set emp_salary=#{empSalaryKey} where emp_id=#{empIdKey}
@Test
public void testUpdateEmpNameByMap() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
Map paramMap = new HashMap<>();
paramMap.put("empSalaryKey", 999.99);
paramMap.put("empIdKey", 5);
int result = mapper.updateEmployeeByMap(paramMap);
System.out.println("result = " + result);
session.commit();
session.close();
}
④对应关系
#{}中写Map中的key
⑤使用场景有很多零散的参数需要传递,但是没有对应的实体类类型可以使用。使用@Param注解一个一个传入又太麻烦了。所以都封装到Map中。
第五节 数据输出 1、返回单个简单类型数据 ①Mapper接口中的抽象方法int selectEmpCount();②SQL语句
③junit测试
@Test
public void testEmpCount() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
int count = employeeMapper.selectEmpCount();
System.out.println("count = " + count);
session.commit();
session.close();
}
2、返回实体类对象
①Mapper接口的抽象方法
Employee selectEmployee(Integer empId);②SQL语句
通过给数据库表字段加别名,让查询结果的每一列都和Java实体类中属性对应起来。
3、返回Map类型适用于SQL查询返回的各个字段综合起来并不和任何一个现有的实体类对应,没法封装到实体类对象中。能够封装成实体类类型的,就不使用Map类型。
①Mapper接口的抽象方法Map②SQL语句selectEmpNameAndMaxSalary();
③junit测试
@Test
public void testQueryEmpNameAndSalary() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Map resultMap = employeeMapper.selectEmpNameAndMaxSalary();
Set> entrySet = resultMap.entrySet();
for (Map.Entry entry : entrySet) {
String key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}
session.commit();
session.close();
}
4、返回List类型
查询结果返回多个实体类对象,希望把多个实体类对象放在List集合中返回。此时不需要任何特殊处理,在resultType属性中还是设置实体类类型即可。
①Mapper接口中抽象方法List②SQL语句selectAll();
③junit测试
@Test
public void testSelectAll() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
List employeeList = employeeMapper.selectAll();
for (Employee employee : employeeList) {
System.out.println("employee = " + employee);
}
session.commit();
session.close();
}
5、返回自增主键
①使用场景
例如:保存订单信息。需要保存Order对象和List
在保存List 这里需要用到的order_id,是在保存Order对象时,数据库表以自增方式产生的,需要特殊办法拿到这个自增的主键值。至于,为什么不能通过查询最大主键的方式解决这个问题,参考下图: Mybatis是将自增主键的值设置到实体类对象中,而不是以Mapper接口方法返回值的形式返回。 而对于不支持自增型主键的数据库(例如 Oracle),则可以使用 selectKey 子元素:selectKey 元素将会首先运行,id 会被设置,然后插入语句会被调用 或者是 将字段的别名设置成和实体类属性一致。 关于实体类属性的约定: getXxx()方法、setXxx()方法把方法名中的get或set去掉,首字母小写。 在Mybatis全局配置文件加入如下配置: SQL语句中可以不使用别名 使用resultMap标签定义对应关系,再在后面的SQL语句中引用这个对应关系insert into t_order_item(item_name,item_price,item_count,order_id) values(...)
int insertEmployee(Employee employee);
[2]SQL语句
[3]junit测试
@Test
public void testSaveEmp() {
SqlSession session = sessionFactory.openSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Employee employee = new Employee();
employee.setEmpName("john");
employee.setEmpSalary(666.66);
employeeMapper.insertEmployee(employee);
System.out.println("employee.getEmpId() = " + employee.getEmpId());
session.commit();
session.close();
}
④注意
6、数据库表字段和实体类属性对应关系
①别名
②全局配置自动识别驼峰式命名规则
③使用resultMap



