JavaWeb---Maven&MyBatis
我只想卷死各位，或者被各位卷死，在此特别感谢黑马程序员的JavaWeb教程
Maven
Maven简介
- 什么是Maven？这里先引用知乎的一个回答
Maven是专门用于管理和构建Java项目的工具，它的主要功能有：
- 提供了一套标准化的项目结构
- 提供了一套标准化的构建流程（编译，测试，打包，发布……）
- 提供了一套依赖管理机制
标准化的项目结构：
项目结构我们都知道，每一个开发工具（IDE）都有自己不同的项目结构，它们互相之间不通用。我再eclipse中创建的目录，无法在idea中进行使用，这就造成了很大的不方便
而Maven提供了一套标准化的项目结构，所有的IDE使用Maven构建的项目完全一样，所以IDE创建的Maven项目可以通用。如下图右边就是Maven构建的项目结构。
标准化的构建流程：
例如我们开发了一套系统，代码需要进行编译、测试、打包、发布，这些操作如果需要反复进行就显得特别麻烦，而Maven提供了一套简单的命令来完成项目构建。依赖管理：
依赖管理其实就是管理你项目所依赖的第三方资源（jar包、插件）。如之前我们项目中需要使用JDBC和Druid的话，就需要去网上下载对应的依赖包，复制到项目中，创建一个lib文件夹存放各种jar包，还要将jar包加入工作环境这一系列的操作。
而Maven使用标准的坐标配置来管理各种依赖，只需要简单的配置就可以完成依赖管理。
下面的代码就是mysql驱动包的坐标，在项目中只需要写这段配置，其他都不需要我们担心，Maven都帮我们进行操作了。
市面上有很多构建工具，而Maven依旧还是主流构建工具。1
2
3
4
5<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.34</version>
</dependency>
IDEA中使用Maven
以后开发中我们肯定会在高级开发工具中使用Maven管理项目，而我们常用的高级开发工具是IDEA，所以接下来我们会讲解Maven在IDEA中的使用。
IDEA配置Maven环境
- 选择 IDEA中 File —> Settings
- 在Setting页面搜索maven
- 设置 IDEA 使用本地安装的 Maven，并修改配置文件路径（默认的jar包下载路径在C盘，我们最好把它改到D盘）
Maven坐标详解
什么是坐标？
- Maven 中的坐标是
资源的唯一标识 - 使用坐标来定义项目或引入项目中需要的依赖
- Maven 中的坐标是
Maven 坐标主要组成
- groupId：定义当前Maven项目隶属组织名称（通常是域名反写，例如：com.itheima）
- artifactId：定义当前Maven项目名称（通常是模块名称，例如 order-service、goods-service）
- version：定义当前项目版本号
下面的代码就是用坐标表示一个项目
1
2
3<groupId>com.alibaba</groupId> <!--隶属组织阿里巴巴-->
<artifactId>druid</artifactId> <!--模块名称是德鲁伊-->
<version>1.1.12</version> <!--版本号是1.1.12-->
IDEA 创建 Maven项目
- 创建模块，选择Maven，点击Next
- 填写模块名称，坐标信息，点击finish，创建完成
- 创建好的项目目录结构如下
IDEA 导入 Maven项目
- 选择右侧Maven面板，点击 + 号
- 选中对应项目的pom.xml文件，双击即可
依赖范围
通过设置坐标的依赖范围(scope)，可以设置 对应jar包的作用范围：编译环境、测试环境、运行环境。
如下图所示给 junit 依赖通过 scope 标签指定依赖的作用范围。 那么这个依赖就只能作用在测试环境，其他环境下不能使用。1
2
3
4<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
那么 scope 都可以有哪些取值呢？
| 依赖范围 | 编译classpath | 测试classpath | 运行classpath | 例子 |
|---|---|---|---|---|
| compile | Y | Y | Y | logback |
| test | - | Y | - | Junit |
| provided | Y | Y | - | servlet-api |
| runtime | - | Y | Y | jdbc驱动 |
| system | Y | Y | - | 存储在本地的jar包 |
- compile ：作用于编译环境、测试环境、运行环境。
- test ： 作用于测试环境。典型的就是Junit坐标，以后使用Junit时，都会将scope指定为该值
- provided ：作用于编译环境、测试环境。我们后面会学习
servlet-api，在使用它时，必须将scope设置为该值，不然运行时就会报错 - runtime ： 作用于测试环境、运行环境。jdbc驱动一般将
scope设置为该值，当然不设置也没有任何问题
MyBatis
MyBatis概述
持久层：
- 负责将数据到保存到数据库的那一层代码。
以后开发我们会将操作数据库的Java代码作为持久层。而Mybatis就是对jdbc代码进行了封装。
- 负责将数据到保存到数据库的那一层代码。
框架：
- 框架就是一个半成品软件，是一套可重用的、通用的、软件基础代码模型
- 在框架的基础之上构建软件编写更加高效、规范、通用、可扩展
MyBatis快速入门
查询user表中的数据
1、创建user表，添加数据1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16CREATE DATABASE mybatis;
USE mybatis;
DROP TABLE IF EXISTS tb_user;
CREATE TABLE tb_user(
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(20),
PASSWORD VARCHAR(20),
gender CHAR(1),
addr VARCHAR(30)
);
INSERT INTO tb_user VALUES (1, 'zhangsan', '123', '男', '北京');
INSERT INTO tb_user VALUES (2, '李四', '234', '女', '天津');
INSERT INTO tb_user VALUES (3, '王五', '11', '男', '西安');
2、创建模块，导入坐标
由于涉及到了数据库的相关操作，所以我们也要将数据库的jar包的坐标导入。同理，我们还可以导入一些其他需要的jar包，例如junit单元测试，写日志的logback等
1 | <dependencies> |
随后将logback需要的XML配置文件存放在
src/main/resource目录下1 |
|
3、编写MyBatis核心配置文件 —> 替换连接信息 解决硬编码问题
这里继续看看官网怎么说的
我们继续在
src/main/resource目录下创建一个mybatis-config.xml，将示例给出的XML代码复制到我们创建好的XML文件中，将数据库的连接信息改成我们自己的数据库链接信息。那现在还差一个SQL映射文件
4、编写SQL映射文件 —> 统一管理SQL语句，解决硬编码问题
继续看看官网怎么说的
继续在
src/main/resource目录下UserMapper文件（命名规则：操作对象User+Mapper，根据不同的操作对象，将User换成不同的名称），将示例代码粘贴进去，随后将resultType改成User类的路径，那么查询结果就会自动返回一个User类型，同时在src/main/java目录下，新建com.blog.pojo.User类，属性与数据库中的User表相对应。查询语句改为了查询user表中的所有数据，同时将id改为selectAll用来标识此sql语句，resultType改为我们刚刚创建的User类的路径，namespace我们后面再说
然后将第3步的映射文件路径改为我们新创建的UserMapper路径 <mapper resource="UserMapper.xml"/>1
2
3
4
5
6
7
8
9
<mapper namespace="UserMapper">
<select id="selectAll" resultType="com.blog.pojo.User">
select * from tb_user;
</select>
</mapper>
1 | package com.blog.pojo; |
5、编码 —> 定义POJO类，加载核心配置文件 —> 获取SqlSessionFactory对象 —> 获取SqlSession对象，执行SQL语句 —> 释放资源
- 看看官网怎么说
我们在java目录下新建com.blog.MyBatisDemo类，将示例代码粘贴进去，将resource的路径改为我们的mybatis-config.xml文件路径1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import com.blog.pojo.User;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyBatisDemo {
public static void main(String[] args) throws IOException {
//1. 加载MyBatis核心配置文件，获取SqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 调用SqlSessionFactory的openSession()，获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 执行sql语句，String类型的参数写我们的UserMapper.xml中的 namespace.id
List<User> users = sqlSession.selectList("UserMapper.selectAll");
System.out.println(users);
//4. 资源关闭
sqlSession.close();
}
}
Mapper代理开发
Mapper代理开发概述
之前我们写的代码是基本使用方式，它也存在硬编码的问题，这里调用 selectList() 方法传递的参数是映射配置文件中的 namespace.id值。如果参数写错了，程序就无法执行，而参数的内容也没有IDE的自动补全功能，也不利于后期的维护1
2List<User> users = sqlSession.selectList("UserMapper.selectAll");
System.out.println(users);
如果使用 Mapper 代理方式则不存在硬编码问题。1
2UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> users = userMapper.selectAll();
通过上面的描述可以看出 Mapper 代理方式的目的：
- 解决原生方式中的硬编码
- 简化后期执行SQL
Mybatis 官网也是推荐使用 Mapper 代理的方式。
使用Mapper代理要求
使用Mapper代理方式，必须满足以下要求：
- 定义与SQL映射文件同名的Mapper接口，并且将Mapper接口和SQL映射文件放置在同一目录下。如下图：
设置SQL映射文件的namespace属性为Mapper接口全限定名
1
<mapper namespace="com.blog.mapper.UserMapper">
在 Mapper 接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致
对应的Java中的方法名应为selectAll，且返回值类型应为User
1
<select id="selectAll" resultType="com.blog.pojo.User">
1
2
3
4
5
6import com.blog.pojo.User;
import java.util.List;
public interface UserMapper {
List<User> selectAll();
}
案例代码的实现
在 com.blog.mapper 包下创建 UserMapper接口，代码如下：1
2
3
4
5
6import com.blog.pojo.User;
import java.util.List;
public interface UserMapper {
List<User> selectAll();
}
在 resources 下创建 com/blog/mapper 目录，并将原来 UserMapper.xml 映射配置文件粘贴进去，此时应该将MyBatis核心配置文件的SQL映射文件的路径更新
1 |
|
1 |
|
修改我们的MybatisDemo测试类的第3步，代码如下1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import com.blog.mapper.UserMapper;
import com.blog.pojo.User;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyBatisDemo {
public static void main(String[] args) throws IOException {
//1. 加载MyBatis核心配置文件，获取SqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 调用SqlSessionFactory的openSession()，获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 获取UserMapper的代理对象
//3.1 通过SqlSession的getMapper方法获取Mapper接口的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//3.2 调用对应方法完成sql的执行
List<User> users = userMapper.selectAll();
System.out.println(users);
//4. 资源关闭
sqlSession.close();
}
}
细节:如果Mapper接口名称和SQL映射文件名称相同，并在同一目录下，则可以使用包扫描的方式简化SQL映射文件的加载
如果遵循Mapper代理的方式 —> Mapper接口名与SQL映射文件名就相同 —> 可以使用包扫描。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:13306/mybatis?useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="PASSWORD."/>
</dataSource>
</environment>
</environments>
<mappers>
<!--如果要在这里写好多映射文件，一个一个手写，也太麻烦了，如果你遵循了Mapper代理方式，就可以用包扫描的方式来简化操作-->
<!--<mapper resource="com/blog/mapper/UserMapper.xml"/>-->
<package name="com.blog.mapper"/>
</mappers>
</configuration>
核心配置文件
核心配置文件中还可以配置很多内容。我们可以通过查询官网看可以配置的内容
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：
- configuration（配置）
- properties（属性）
- settings（设置）
- typeAliases（类型别名）
- typeHandlers（类型处理器）
- objectFactory（对象工厂）
- plugins（插件）
- environments（环境配置）
- environment（环境变量）
- transactionManager（事务管理器）
- dataSource（数据源）
- environment（环境变量）
- databaseIdProvider（数据库厂商标识）
- mappers（映射器）
配置各个标签的时候，必须遵守前后顺序
多环境配置
在核心配置文件的 environments 标签中其实是可以配置多个 environment ，使用 id 给每段环境起名，在 environments 中使用 default='环境id' 来指定使用哪儿段配置。我们一般就配置一个 environment 即可。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23<environments default="development"> <!--切换不同的id可以使用不同的环境-->
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<!--数据库连接信息-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
</dataSource>
</environment>
<environment id="test"> <!--例如开发和测试使用的不是同一个数据库，或者想测试不同版本的数据库，可以新建一个环境-->
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<!--数据库连接信息-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
</dataSource>
</environment>
</environments>
类型别名
在映射配置文件中的 resultType 属性需要配置数据封装的类型（类的全限定名）。而每次这样写是特别麻烦的，Mybatis 提供了 类型别名(typeAliases) 可以简化这部分的书写。
首先需要现在核心配置文件中配置类型别名，也就意味着给pojo包下所有的类起了别名（别名就是类名），不区分大小写。内容如下：1
2
3
4<typeAliases>
<!--name属性的值是实体类所在包-->
<package name="com.blog.pojo"/>
</typeAliases>
通过上述的配置，我们就可以简化映射配置文件中 resultType 属性值的编写1
2
3
4
5<mapper namespace="com.blog.mapper.UserMapper">
<select id="selectAll" resultType="user">
select * from tb_user;
</select>
</mapper>
Mybatis练习
目标
- 能够使用映射配置文件实现CRUD操作
- 能够使用注解实现CRUD操作
一般的产品原型，里面都会包含品牌数据的 查询 、按条件查询、添加、删除、批量删除、修改 等功能，而这些功能其实就是对数据库表中的数据进行CRUD操作。接下来我们就使用Mybatis完成品牌数据的增删改查操作。以下是我们要完成功能列表：
- 查询
- 查询所有数据
- 查询详情
- 条件查询
- 添加
- 修改
- 修改全部字段
- 修改动态字段
- 删除
- 删除一个
- 批量删除
环境准备
数据库表（tb_brand）及数据准备
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23-- 删除tb_brand表
DROP TABLE IF EXISTS tb_brand;
-- 创建tb_brand表
CREATE TABLE tb_brand
(
-- id 主键
id INT PRIMARY KEY AUTO_INCREMENT,
-- 品牌名称
brand_name VARCHAR(20),
-- 企业名称
company_name VARCHAR(20),
-- 排序字段
ordered INT,
-- 描述信息
description VARCHAR(100),
-- 状态：0：禁用 1：启用
STATUS INT
);
-- 添加数据
INSERT INTO tb_brand (brand_name, company_name, ordered, description, STATUS)
VALUES ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
('小米', '小米科技有限公司', 50, 'are you ok', 1);实体类 Brand，在
com.itheima.pojo包下创建 Brand 实体类。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75public class Brand {
// id 主键
private Integer id;
// 品牌名称
private String brandName;
// 企业名称
private String companyName;
// 排序字段
private Integer ordered;
// 描述信息
private String description;
// 状态：0：禁用 1：启用
private Integer status;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getBrandName() {
return brandName;
}
public void setBrandName(String brandName) {
this.brandName = brandName;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public Integer getOrdered() {
return ordered;
}
public void setOrdered(Integer ordered) {
this.ordered = ordered;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String toString() {
return "Brand{" +
"id=" + id +
", brandName='" + brandName + '\'' +
", companyName='" + companyName + '\'' +
", ordered=" + ordered +
", description='" + description + '\'' +
", status=" + status +
'}';
}
}编写测试用例，测试代码需要在
test/java目录下创建包及测试用例。安装 MyBatisX 插件
- MybatisX 是一款基于 IDEA 的快速开发插件，为效率而生。
- 主要功能
- XML映射配置文件 和 接口方法 间相互跳转
- 根据接口方法生成 statement
查询所有数据
实现该功能我们分以下步骤进行实现：
- 编写接口方法：Mapper接口
- 参数：无
查询所有数据功能是不需要根据任何条件进行查询的，所以此方法不需要参数。 - 结果：
List<Brand>
我们会将查询出来的每一条数据封装成一个Brand对象，而多条数据封装多个Brand对象，需要将这些对象封装到List集合中返回。 - 执行方法、测试
- 参数：无
编写接口方法
在 com.blog.mapper 包写创建名为 BrandMapper 的接口。并在该接口中定义 List<Brand> selectAll() 方法。1
2
3
4
5
6
7
8
9package com.blog.mapper;
import com.blog.pojo.Brand;
import java.util.List;
public interface BrandMapper {
List<Brand> selectAll();
}
编写SQL语句
在 reources 下创建 com/itheima/mapper 目录结构，并在该目录下创建名为 BrandMapper.xml 的映射配置文件1
2
3
4
5
6
7
8
9
10
<mapper namespace="com.blog.mapper.BrandMapper">
<select id="selectAll" resultMap="brandResultMapper">
select *
from tb_brand;
</select>
</mapper>
编写测试方法
在 MybatisTest 类中编写测试查询所有的方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void testSelectAll() throws IOException{
//1. 加载MyBatis核心配置文件，获取SqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
List<Brand> brands = brandMapper.selectAll();
System.out.println(brands);
//5. 资源关闭
sqlSession.close();
}
执行测试方法部分结果如下Brand{id=1, brandName='null', companyName='null', ordered=5, description='好吃不上火', status=0
其中brandName和companyName的值为NULL，究其原因是我们Brand类中的属性名和MySQL中的列名不一致。
这个问题我在上篇JDBC文章中给出了一个比较初级的解决方案，那就是给列取别名，令别名与我们Java中的命名方式相同，这样我们就可以通过获取列的别名，来进行反射赋值。
另一种解决方式是使用resultMap定义字段和属性的映射关系（推荐）
起别名解决上述问题
我们可以在写sql语句时给这两个字段起别名，将别名定义成和属性名一致即可。1
2
3
4
5<select id="selectAll" resultType="brand">
select
id, brand_name as brandName, company_name as companyName, ordered, description, status
from tb_brand;
</select>
而上面的SQL语句中的字段列表书写麻烦，如果表中还有更多的字段，同时其他的功能也需要查询这些字段时就显得我们的代码不够精炼。Mybatis提供了sql 片段可以提高sql的复用性。
SQL片段：
将需要复用的SQL片段抽取到
sql标签中1
2
3<sql id="brand_column">
id, brand_name as brandName, company_name as companyName, ordered, description, status
</sql>id属性值是唯一标识，引用时也是通过该值进行引用。
在原sql语句中进行引用
使用include标签引用上述的 SQL 片段，而refid指定上述 SQL 片段的id值1
2
3
4
5<select id="selectAll" resultType="brand">
select
<include refid="brand_column" />
from tb_brand;
</select>
使用resultMap解决上述问题
起别名 + sql片段的方式可以解决上述问题，但是它也存在问题。如果还有功能只需要查询部分字段，而不是查询所有字段，那么我们就需要再定义一个 SQL 片段，这就显得不是那么灵活。
那么我们也可以使用resultMap来定义字段和属性的映射关系的方式解决上述问题。
- 在映射配置文件中使用resultMap定义
字段和属性的映射关系1
2
3
4
5
6
7
8
9
10
11
12
13<!--id用来标识唯一的resultMap，type表示映射类型-->
<resultMap id="brandResultMap" type="brand">
<!--
id：完成主键字段的映射
column：表的列名
property：实体类的属性名
result：完成一般字段的映射
column：表的列名
property：实体类的属性名
-->
<result column="brand_name" property="brandName"/>
<result column="company_name" property="companyName"/>
</resultMap>
- SQL语句正常编写
1
2
3
4
5<!--使用resultMap属性替换掉原有的resultType属性-->
<select id="selectAll" resultMap="brandResultMap">
select *
from tb_brand;
</select>
查询详情
查看详情功能实现步骤：
- 编写接口方法：Mapper接口
- 参数：id
查看详情就是查询某一行数据，所以需要根据id进行查询。而id以后是由页面传递过来。 - 结果：Brand
根据id查询出来的数据只要一条，而将一条数据封装成一个Brand对象即可
- 参数：id
- 编写SQL语句：SQL映射文件
- 执行方法、进行测试
编写接口方法
在 BrandMapper 接口中定义根据id查询数据的方法1
Brand selectById(int id);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 而不是使用 resultType1
2
3
4
5<select id="selectById" resultMap="brandResultMapper">
select *
from tb_brand
where id = #{id}; <!--这个#{id}是占位符，后面会详细说-->
</select>
编写测试方法
在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void testSelectById() throws IOException {
//接收参数，该id以后需要传递过来
int id = 1;
//1. 加载MyBatis核心配置文件，获取SqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
Brand brand = brandMapper.selectById(id);
System.out.println(brand);
//5. 资源关闭
sqlSession.close();
}
参数占位符
mybatis提供了两种参数占位符：
#{}：执行SQL时，会将 #{} 占位符替换为？，将来自动设置参数值。#{}底层使用的是PreparedStatement${}：拼接SQL。底层使用的是Statement，会存在SQL注入问题。关于SQL注入的问题我在上篇JDBC文章中做过详细的说明。
parameterType使用
对于有参数的mapper接口方法，我们在映射配置文件中应该配置 ParameterType 来指定参数类型。只不过该属性都可以省略。1
2
3
4<select id="selectById" parameterType="int" resultMap="brandResultMap">
select *
from tb_brand where id = #{id};
</select>
SQL语句中特殊字段处理
在xml中，”<”、”>”、”&”等字符是不能直接存入的，否则xml语法检查时会报错，如果想在xml中使用这些符号，必须将其转义为实体，如<、>、&，这样才能保存进xml文档。或者使用<![CDATA[]]>，被这个标记所包含的内容将表示为纯文本
但是严格来说，在XML中只有”<”和”&”是非法的，其它三个都是可以合法存在的，但是，把它们都进行转义是一个好的习惯。
不管怎么样，转义前的字符也好，转义后的字符也好，都会被xml解析器解析，为了方便起见，使用<![CDATA[]]>来包含不被xml解析器解析的内容。但要注意的是：
- 此部分不能再包含
]]>； - 不允许嵌套使用；
]]>这部分不能包含空格或者换行。
最后，说说<![CDATA[]]>和xml转移字符的关系，它们两个看起来是不是感觉功能重复了？
- 是的，它们的功能就是一样的，只是应用场景和需求有些不同：
<![CDATA[]]>不能适用所有情况，转义字符可以；- 对于短字符串
<![CDATA[]]>写起来啰嗦，对于长字符串转义字符写起来可读性差； <![CDATA[]]>表示xml解析器忽略解析，所以更快。
1 | <select id="selectById" resultMap="brandResultMapper"> |
1 | <select id="selectById" resultMap="brandResultMapper"> |
多条件查询
在实际问题中，我们经常会遇到如上图所示的多条件查询，将多条件查询的结果展示在下方的数据列表中。而我们做这个功能需要分析最终的SQL语句应该是什么样，思考两个问题
- 条件表达式
- 如何连接
当前状态使用status字段表示，企业名称使用company_name表示，品牌名称使用brand_name表示
条件字段 企业名称 和 品牌名称 需要进行模糊查询，所以条件应该是：1
2
3
4
5select *
from tb_brand
where `status` = #{status}
and company_name like #{companyName}
and brand_name like #{brandName};
简单的分析后，我们来看功能实现的步骤：
- 编写接口方法
- 参数：所有查询条件
- 结果：
List<Brand>
在映射配置文件中编写SQL语句
编写测试方法并执行
编写接口方法
在 BrandMapper 接口中定义多条件查询的方法。
而该功能有三个参数，我们就需要考虑定义接口时，参数应该如何定义。Mybatis针对多参数有多种实现
- 使用
@Param( "SQL参数占位符名称")标记每一个参数，在映射配置文件中就需要使用#{参数名称}进行占位1
List<Brand> selectByCondition( int status, String companyName, String brandName);
- 将多个参数封装成一个
实体对象，将该实体对象作为接口的方法参数。该方式要求在映射配置文件的SQL中使用#{内容}时，里面的内容必须和实体类属性名保持一致。1
List<Brand> selectByCondition(Brand brand);
- 将多个参数封装到map集合中，将map集合作为接口的方法参数。该方式要求在映射配置文件的SQL中使用
#{内容}时，里面的内容必须和map集合中键的名称一致。map.put(“SQL参数占位符名称”,数值);1
List<Brand> selectByCondition(Map map);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写 statement，注意使用 resultMap 替换 resultType1
2
3
4
5
6
7<select id="selectByCondition" resultMap="brandResultMap">
select *
from tb_brand
where status = #{status}
and company_name like #{companyName}
and brand_name like #{brandName}
</select>
编写测试方法
在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法
1 |
|
1 |
|
1 |
|
现在的这种查询方式，只有当用户把三个参数都填上的时候才能查询出来，如果另外两个参数没有填，那么SQL语句就会变成1
where status = null and company_name = null and brand_name = "%华为%"
这样显然是不会查询成功的，下面我们来进行优化
动态SQL
上述功能实现存在很大的问题。用户在输入条件时，肯定不会所有的条件都填写，这个时候我们的SQL语句就不能那样写的
例如用户只输入 当前状态 时，SQL语句就是1
select * from tb_brand where status = #{status}
而用户如果只输入企业名称时，SQL语句就是1
select * from tb_brand where company_name like #{companName}
而用户如果输入了 当前状态 和 企业名称 时，SQL语句又不一样1
select * from tb_brand where status = #{status} and company_name like #{companName}
针对上述的需要，Mybatis对动态SQL有很强大的支撑：
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
我们先学习 if 标签：
- if 标签：条件判断
- test 属性：逻辑表达式
1
2
3
4
5
6
7
8
9
10
11
12
13
14<select id="selectByCondition" resultMap="brandResultMapper">
select *
from tb_brand
where
<if test="status != null">
`status` = #{status}
</if>
<if test="companyName != null and companyName != ''">
and company_name like #{companyName}
</if>
<if test="brandName != null and brandName != ''">
and brand_name like #{brandName};
</if>
</select>
- test 属性：逻辑表达式
如上的这种SQL语句就会根据传递的参数值进行动态的拼接。如果此时status和companyName有值那么就会值拼接这两个条件。SQL语句将变成1
select * from tb_brand where status = ? and company_name like ?
但如果我们只给companyName这一个参数，那么SQL语句会变成下面这样1
select * from tb_brand where and company_name like ?
WHERE关键字后面直接跟了个AND，变成了一条错误的SQL语句，那么最笨的一个解决方案就是在where后面先接一个恒等式1
select * from tb_brand where 1 = 1 and company_name like ?
但MyBatis也料想到了这种情况，所以MyBatis又提供了一个where标签
- where 标签
- 作用：
- 替换where关键字
- 会动态的去掉第一个条件前的 and 或 or
- 如果所有的参数没有值则不加where关键字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15<select id="selectByCondition" resultMap="brandResultMapper">
select *
from tb_brand
<where>
<if test="status != null">
`status` = #{status}
</if>
<if test="companyName != null and companyName != ''">
and company_name like #{companyName}
</if>
<if test="brandName != null and brandName != ''">
and brand_name like #{brandName};
</if>
</where>
</select>
- 作用：
单个条件（动态SQL）
如上图所示，在查询时只能选择 品牌名称、当前状态、企业名称 这三个条件中的一个，但是用户到底选择哪儿一个，我们并不能确定。这种就属于单个条件的动态SQL语句。
这种需求需要使用到 choose（when，otherwise）标签 实现，分别对应Java中的swtich,case,default
编写接口方法
在 BrandMapper 接口中定义单条件查询的方法。1
List<Brand> selectByConditionSingle(Brand brand);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 替换 resultType
将where替换成<where>标签，这样当我们没有选中任何查询方式时，会自动帮我们去掉where，从而查询所有数据
或者保持where不变，在choose中添加<otherwise>标签，在其中写入一个恒等式，这样当没有选中任何查询方式时，SQL语句会变成select * from tb_brand where true，同样实现查询所有数据的效果，但还是推荐前者的方式1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17<select id="selectByConditionSingle" resultType="com.blog.pojo.Brand">
select *
from tb_brand
<where>
<choose>
<when test="status != null">
`status` = #{status}
</when>
<when test="companyName != null and companyName != ''">
companyName = #{companyName}
</when>
<when test="brandName != null and brandName != ''">
brandName = #{brandName}
</when>
</choose>
</where>
</select>
编写测试方法
在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public void testSelectByConditionSingle() throws IOException {
//接收参数
int status = 1;
String companyName = "华为";
String brandName = "华为";
// 处理参数
companyName = "%" + companyName + "%";
brandName = "%" + brandName + "%";
//封装对象
Brand brand = new Brand();
//brand.setStatus(status);
brand.setCompanyName(companyName);
//brand.setBrandName(brandName);
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
List<Brand> brands = brandMapper.selectByConditionSingle(brand);
System.out.println(brands);
//5. 释放资源
sqlSession.close();
}
添加数据
实际开发中，添加数据时会有一个图形化界面，而我们在该页面输入想要的数据后添加 提交 按钮，就会将这些数据添加到数据库中。接下来我们就来实现添加数据的操作。
- 编写接口方法
- 参数：除了id之外的所有的数据。id对应的是表中主键值，而主键我们是 自动增长 生成的。
- 编写SQL语句
- 编写测试方法并执行
编写接口方法
在 BrandMapper 接口中定义添加方法1
void add(Brand brand);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写添加数据的 statement1
2
3
4<insert id="add" >
insert into tb_brand(brand_name, company_name, ordered, description, status)
VALUES (#{brandName},#{companyName},#{ordered},#{description},#{status})
</insert>
编写测试方法
在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void testAdd() throws IOException {
//接收参数
String brandName = "波导";
String companyName = "波导手机";
Integer ordered = 100;
String description = "手机中的战斗机";
int status = 1;
//封装对象
Brand brand = new Brand();
brand.setBrandName(brandName);
brand.setCompanyName(companyName);
brand.setOrdered(ordered);
brand.setDescription(description);
brand.setStatus(status);
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
brandMapper.add(brand);
//提交事务
sqlSession.commit();
//5. 释放资源
sqlSession.close();
}
在第2步获取SqlSession对象时，默认是不会自动提交事务的，我们可以在openSession方法中加上true，这样就能自动提交事务了，不用手动调用commit方法1
//SqlSession sqlSession = sqlSessionFactory.openSession(true); //设置自动提交事务，这种情况不需要手动提交事务了
添加-主键返回
在接收参数的时候，我们没有接收id的参数，而是利用数据库主键自增长来自动赋值，但有时候我们又需要获取这个自增长的id。
解决方案
- 在 insert 标签上添加如下属性：
- useGeneratedKeys：是够获取自动增长的主键值。true表示获取
- keyProperty ：指定将获取到的主键值封装到哪儿个属性里添加主键返回之后，我们再来测试一下
1
2
3
4<insert id="add" useGeneratedKeys="true" keyProperty="id">
insert into tb_brand(brand_name, company_name, ordered, description, status)
VALUES (#{brandName},#{companyName},#{ordered},#{description},#{status})
</insert>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public void testAdd() throws IOException {
//接收参数
String brandName = "波导";
String companyName = "波导手机";
Integer ordered = 100;
String description = "手机中的战斗机";
int status = 1;
//封装对象
Brand brand = new Brand();
brand.setBrandName(brandName);
brand.setCompanyName(companyName);
brand.setOrdered(ordered);
brand.setDescription(description);
brand.setStatus(status);
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
brandMapper.add(brand);
System.out.println(brand.getId()); //在这里输出一下id，看看有没有值输出，我这里是有的
//提交事务
sqlSession.commit();
//5. 释放资源
sqlSession.close();
}
修改
编写接口方法
在 BrandMapper 接口中定义修改方法。int获取修改的行数1
int update(Brand brand);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写修改数据的 statement。1
2
3
4
5
6
7
8
9<update id="update">
update tb_brand
set brand_name = #{brandName},
company_name = #{companyName},
ordered = #{ordered},
`description` = #{description},
`status` = #{status}
where id = #{id}
</update>
编写测试方法
在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public void testUpdate() throws IOException {
//接收参数
int id = 5;
String brandName = "波导";
String companyName = "波导手机";
Integer ordered = 200;
String description = "波导手机,手机中的战斗机";
int status = 5;
//封装对象
Brand brand = new Brand();
brand.setBrandName(brandName);
brand.setCompanyName(companyName);
brand.setOrdered(ordered);
brand.setDescription(description);
brand.setStatus(status);
brand.setId(id);
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象，并设置自动提交事务
SqlSession sqlSession = sqlSessionFactory.openSession(true);
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
int updateCount = brandMapper.update(brand);
System.out.println(updateCount);
//5. 释放资源
sqlSession.close();
}
修改动态字段
解决方案跟上面的类似，也是用if标签来判断用户的输入，然后用set标签来删除额外的逗号（上面是用where标签去除and或or），防止出现SQL语法错误1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21<update id="update">
update tb_brand
<set>
<if test="brandName != null and brandName != ''">
brand_name = #{brandName},
</if>
<if test="companyName != null and companyName != ''">
company_name = #{companyName},
</if>
<if test="ordered != null">
ordered = #{ordered},
</if>
<if test="description != null and description != ''">
`description` = #{description},
</if>
<if test="status != null">
`status` = #{status}
</if>
</set>
where id = #{id}
</update>
删除一行数据
我们在App网购的时候，购物车里都会有删除按钮，，当用户点击了该按钮，就会将改行数据删除掉。那我们就需要思考，这种删除是根据什么进行删除呢？是通过主键id删除，因为id是表中数据的唯一标识。
接下来就来实现该功能。
编写接口方法
在 BrandMapper 接口中定义根据id删除方法。1
void deleteById(int id);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写删除一行数据的 statement1
2
3
4
5<delete id="deleteById">
delete
from tb_brand
where id = #{id};
</delete>
编写测试方法
在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void testDeleteById() throws IOException {
//接收参数
int id = 6;
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession(true);
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
brandMapper.deleteById(id);
//5. 释放资源
sqlSession.close();
}
批量删除
我们在删除购物车订单的时候，都会有个多选按钮，可以选中多条记录进行删除，下面我们来实现这个功能
编写接口方法
在 BrandMapper 接口中定义删除多行数据的方法。1
2// 参数是一个数组，数组中存储的是多条数据的id
void deleteByIds(int[] ids);
编写SQL语句
在 BrandMapper.xml 映射配置文件中编写删除多条数据的 statement。
编写SQL时需要遍历数组来拼接SQL语句。Mybatis 提供了 foreach 标签供我们使用
foreach 标签
用来迭代任何可迭代的对象（如数组，集合）。
- collection 属性：
- mybatis会将数组参数，封装为一个Map集合。
- 默认：array = 数组
- 使用@Param注解改变map集合的默认key的名称
- mybatis会将数组参数，封装为一个Map集合。
- item 属性：本次迭代获取到的元素。
- separator 属性：集合项迭代之间的分隔符。
foreach标签不会错误地添加多余的分隔符。也就是最后一次迭代不会加分隔符。 - open 属性：该属性值是在拼接SQL语句之前拼接的语句，只会拼接一次
- close 属性：该属性值是在拼接SQL语句拼接后拼接的语句，只会拼接一次假如数组中的id数据是{1,2,3}，那么拼接后的sql语句就是：
1
2
3
4
5
6
7<delete id="deleteByIds">
delete from tb_brand
where id in
<foreach collection="ids" item="id" separator="," open="(" close=")">
#{id}
</foreach>
</delete>delete from tb_brand where id in (1,2,3);
编写测试方法
在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void testDeleteByIds() throws IOException {
//接收参数
int[] ids = {1,2,3};
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession(true);
//3. 获取Mapper接口的代理对象
BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
//4. 执行方法
brandMapper.deleteByIds(ids);
//5. 释放资源
sqlSession.close();
}
MyBatis参数传递
Mybatis 接口方法中可以接收各种各样的参数，如下：
- 多个参数
- 单个参数：单个参数又可以是如下类型
- POJO 类型
- Map 集合类型
- Collection 集合类型
- List 集合类型
- Array 类型
- 其他类型
多个参数
如下面的代码，就是接收两个参数，而接收多个参数需要使用 @Param 注解，那么为什么要加该注解呢？这个问题要弄明白就必须来研究Mybatis的底层对于这些参数是如何处理的。1
User select( String username, String password);
1
2
3
4
5
6
7<select id="select" resultType="user">
select *
from tb_user
where
username=#{username}
and password=#{password}
</select>
我们在接口方法中定义多个参数，Mybatis 会将这些参数封装成 Map 集合对象，值就是参数值，而键在没有使用 @Param 注解时有以下命名规则：
- 以 arg 开头 ：第一个参数就叫 arg0，第二个参数就叫 arg1，以此类推。如：
- map.put(“arg0”，参数值1);
- map.put(“arg1”，参数值2);
- 以 param 开头 ： 第一个参数就叫 param1，第二个参数就叫 param2，依次类推。如：
- map.put(“param1”，参数值1);
- map.put(“param2”，参数值2);
下面我们来验证一下
- 在
UserMapper接口中定义如下方法1
User select(String username,String password);
- 在
UserMapper.xml映射配置文件中定义SQL运行代码结果如下1
2
3
4
5
6
7<select id="select" resultType="user">
select *
from tb_user
where
username=#{arg0} <!--username=#{param1}-->
and password=#{arg1} <!--and password=#{param2}-->
</select>在映射配合文件的SQL语句中使用用1
2[DEBU6][main] c.i.m.0.select- ==> Preparing: SELECT * FROM tb_user WHERE username = ? AND PASSWORD = ?
[DEBU6] [main] c.i.m.U.select- ==> Parameters: zhangsan(STRING)，123(STRING)arg开头的和param书写，代码的可读性会变的特别差，此时可以使用@Param注解。
在接口方法参数上使用 @Param 注解，Mybatis 会将 arg 开头的键名替换为对应注解的属性值。
以后接口参数是多个时，在每个参数上都使用 @Param 注解。这样代码的可读性更高。
单个参数
POJO 类型
直接使用。要求
属性名和参数占位符名称一致Map 集合类型
直接使用。要求
map集合的键名和参数占位符名称一致Collection 集合类型
Mybatis 会将集合封装到 map 集合中，如下：
map.put(“arg0”，collection集合);
map.put(“collection”，collection集合;
==可以使用
@Param注解替换map集合中默认的 arg 键名。==List 集合类型
Mybatis 会将集合封装到 map 集合中，如下：
map.put(“arg0”，list集合);
map.put(“collection”，list集合);
map.put(“list”，list集合);
==可以使用
@Param注解替换map集合中默认的 arg 键名。==Array 类型
Mybatis 会将集合封装到 map 集合中，如下：
map.put(“arg0”，数组);
map.put(“array”，数组);
==可以使用
@Param注解替换map集合中默认的 arg 键名。==其他类型
比如int类型，
参数占位符名称叫什么都可以。尽量做到见名知意
注解实现CURD
使用注解开发会比配置文件开发更加方便。如下就是使用注解进行开发1
2
public User select(int id);
Mybatis 针对 CURD 操作都提供了对应的注解，已经做到见名知意。如下：
- 查询 ：@Select
- 添加 ：@Insert
- 修改 ：@Update
- 删除 ：@Delete
接下来我们做一个案例来使用 Mybatis 的注解开发
- 代码实现：
- 将之前案例中
UserMapper.xml中的 根据id查询数据 的statement删掉 - 在
UserMapper接口的selectById方法上添加注解1
2
User selectById(int id); - 测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void testSelect() throws IOException {
//接收参数
int id = 2;
//1. 获取SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//2. 获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession(true);
//3. 获取Mapper接口的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//4. 执行方法
User user = userMapper.selectById(id);
System.out.println(user);
//5. 释放资源
sqlSession.close();
}
- 将之前案例中
注意在官方文档中 入门 中有这样的一段话：
使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。
