MyBatis学习
如果不喜欢博客样式，可以查看文档：MyBatis学习文档
MyBatis学习
1. MyBatis介绍
中文官网：MyBatis
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
MyBatis是一个半自动化的ORM框架。
名词解释
- 持久化 ： 数据从瞬时状态变为持久状态。
- 持久层 ： 完成持久化工作的代码块。（DAO层）
- ORM：（Objec Relationship Mapp）对象关系映射。
2. 入门
2.1 导入Jar包
使用Maven构建项目，将以下的依赖代码放置于pom.xml中
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.72version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.16version>
dependency>
2.2 编写mybatis核心配置文件
mybatis-config.xml
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/MybatisDemo?serverTimezone=Asia/Shanghai"/>
<property name="username" value="wyp"/>
<property name="password" value="LabiXiaoxin@01"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="mapper/user.mapper.xml"/>
mappers>
configuration>
2.3 创建SqlSessionFactory与获取SqlSession
MyBatisUtil.java
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;
public class MyBatisUtil {
/**
* 创建SqlSessionFactory
* @return SqlSessionFactory
* @throws IOException
*/
public static SqlSessionFactory getSqlSessionFactory() throws IOException {
//核心配置文件的路径
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
return sqlSessionFactory;
}
/**
* 获得SqlSession
* @return SqlSession
* @throws IOException
*/
public static SqlSession getSession() throws IOException {
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
return sqlSessionFactory.openSession();
}
}
2.4 创建实体类
User.java
public class User {
private int id;
private String name;
private String pwd;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public User() {
}
public User(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.pwd = pwd;
}
}
2.5 SQL映射文件
user.mapper.xml
<mapper namespace="edu.mju.entity.UserMapper">
<select id="selectUser" resultType="edu.mju.entity.User" >
select * from Users where id = #{id}
select>
<insert id="insertUser" parameterType="edu.mju.entity.User" useGeneratedKeys="true">
insert into Users(name,pwd) values(#{name},#{pwd})
insert>
<update id="updateUser" parameterType="edu.mju.entity.User">
update Users set name=#{name},pwd=#{pwd} where id=#{id} ;
update>
<delete id="deleteUser" parameterType="edu.mju.entity.User">
delete from Users where id = #{id}
delete>
<select id="selectAll" resultType="edu.mju.entity.User">
select * from Users
select>
mapper>
2.6 UserDao
public class UserDao {
public User getById(int id) throws IOException {
SqlSession session = MyBatisUtil.getSession();
//selectOne(String statement, Object parameter):
// statement:匹配要使用的语句的唯一标识符
// parameter:传递给语句的参数对象。
User user = session.selectOne("edu.mju.entity.UserMapper.selectUser",id);
session.close();
return user;
}
public int insertUser(User user) throws IOException {
SqlSession session = MyBatisUtil.getSession();
int result = session.insert("edu.mju.entity.UserMapper.insertUser",user);
session.commit();
session.close();
return result;
}
public int updateUser(User user) throws IOException {
SqlSession session = MyBatisUtil.getSession();
int result = session.update("edu.mju.entity.UserMapper.updateUser",user);
session.commit();
session.close();
return result;
}
public int deleteUser(int id) throws IOException {
SqlSession session = MyBatisUtil.getSession();
int result = session.delete("edu.mju.entity.UserMapper.deleteUser",id);
session.commit();
session.close();
return result;
}
public List<User> selectAllUser() throws IOException {
SqlSession session = MyBatisUtil.getSession();
List<User> list = session.selectList("edu.mju.entity.UserMapper.selectAll");
session.close();
return list;
}
/**
*
* @param currentPage 当前页
* @param pageSize 页面大小
* @return 返回结果集
* @throws IOException
*/
public List<User> getByPage(int currentPage,int pageSize) throws IOException {
SqlSession session = MyBatisUtil.getSession();
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("startIndex",(currentPage-1)*pageSize);
map.put("pageSize",pageSize);
List<User> list = session.selectList("edu.mju.entity.UserMapper.selectPage",map);
session.close();
return list;
}
/**
*
* @param currentPage 当前页
* @param pageSize 页面大小
* @return 返回结果集
* @throws IOException
*/
public List<User> getByPageTwo(int currentPage,int pageSize) throws IOException {
SqlSession session = MyBatisUtil.getSession();
RowBounds rowBounds = new RowBounds((currentPage-1)*pageSize,pageSize);
List<User> list = session.selectList("edu.mju.entity.UserMapper.selectPageTwo",null,rowBounds);
session.close();
return list;
}
}
2.7 测试类
UserDaoTest.java
public class UserDaoTest {
@Test
public void UserDaoTest() throws IOException {
UserDao userDao = new UserDao();
System.out.println(JSONObject.toJSON(userDao.getById(1)));
}
@Test
public void UserAdd() throws IOException {
UserDao userDao = new UserDao();
User user = new User();
user.setName("labi");
user.setPwd("123");
int result = userDao.insertUser(user);
System.out.println(result);
}
@Test
public void UserUpdate() throws IOException {
UserDao userDao = new UserDao();
User user = userDao.getById(3);
user.setName("change");
user.setPwd("change");
int result = userDao.UpdateUser(user);
System.out.println(result);
}
@Test
public void UserDelete() throws IOException {
UserDao userDao = new UserDao();
int result = userDao.DeleteUser(3);
System.out.println(result);
}
@Test
public void UserSelectAll() throws IOException {
UserDao userDao = new UserDao();
List<User> list = userDao.selectAllUser();
System.out.println(JSONObject.toJSONString(list));
}
}
测试结果：
-- UserDaoTest()结果：
{
"name":"labixiaoxin","id":1,"pwd":"123"}
-- UserAdd()结果：
1
-- UserUpdate()结果：
1
-- UserDelete()结果：
1
-- UserSelectAll()结果：
[{
"id":1,"name":"labixiaoxin","pwd":"123"},{
"id":2,"name":"a","pwd":"123"},{
"id":3,"name":"change","pwd":"change"},{
"id":4,"name":"labi","pwd":"123"}]
3. 配置文件解析
3.1 环境配置（environments）
MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。而如果是三个数据库，就需要三个实例，依此类推，记起来很简单：
- 每个数据库对应一个 SqlSessionFactory 实例
为了指定创建哪种环境，只要将它作为可选的参数传递给 SqlSessionFactoryBuilder 即可。可以接受环境配置的两个方法签名是：
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, properties);
environments 元素定义了如何配置环境。
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">
<property name="..." value="..."/>
transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
注意一些关键点：
- 默认使用的环境 ID（比如：default=“development”）。
- 每个 environment 元素定义的环境 ID（比如：id=“development”）。
- 事务管理器的配置（比如：type=“JDBC”）。
- 数据源的配置（比如：type=“POOLED”）。
默认环境和环境 ID 顾名思义。 环境可以随意命名，但务必保证默认的环境 ID 要匹配其中一个环境 ID。
3.1.1 事务管理器（transactionManager）
在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：
- JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
- MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如:
<transactionManager type="MANAGED"> <property name="closeConnection" value="false"/> transactionManager>
如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
如果有需要自定义MyBatis对事务的处理，请前往：https://mybatis.org/mybatis-3/zh/configuration.html
3.1.2 数据源（dataSource）
有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：
1. **UNPOOLED**– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。 性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。UNPOOLED 类型的数据源仅仅需要配置以下 5 种属性：
- `driver` – 这是 JDBC 驱动的 Java 类全限定名（并不是 JDBC 驱动中可能包含的数据源类）。
- `url` – 这是数据库的 JDBC URL 地址。
- `username` – 登录数据库的用户名。
- `password` – 登录数据库的密码。
- `defaultTransactionIsolationLevel` – 默认的连接事务隔离级别。
- `defaultNetworkTimeout` – 等待数据库操作完成的默认网络超时时间（单位：毫秒）。查看 `java.sql.Connection#setNetworkTimeout()` 的 API 文档以获取更多信息。
作为可选项，你也可以传递属性给数据库驱动。只需在属性名加上“driver.”前缀即可，例如：
- `driver.encoding=UTF8`
这将通过 DriverManager.getConnection(url, driverProperties) 方法传递值为 `UTF8` 的 `encoding` 属性给数据库驱动。
1. **POOLED**– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。
除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：
- `poolMaximumActiveConnections` – 在任意时间可存在的活动（正在使用）连接数量，默认值：10
- `poolMaximumIdleConnections` – 任意时间可能存在的空闲连接数。
- `poolMaximumCheckoutTime` – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
- `poolTimeToWait` – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直失败且不打印日志），默认值：20000 毫秒（即 20 秒）。
- `poolMaximumLocalBadConnectionTolerance` – 这是一个关于坏连接容忍度的底层设置， 作用于每一个尝试从缓存池获取连接的线程。 如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新的连接，但是这个重新尝试的次数不应该超过 `poolMaximumIdleConnections` 与 `poolMaximumLocalBadConnectionTolerance` 之和。 默认值：3（新增于 3.4.5）
- `poolPingQuery` – 发送到数据库的侦测查询，用来检验连接是否正常工作并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动出错时返回恰当的错误消息。
- `poolPingEnabled` – 是否启用侦测查询。若开启，需要设置 `poolPingQuery` 属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
- `poolPingConnectionsNotUsedFor` – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。
1. **JNDI** 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。这种数据源配置只需要两个属性：
- `initial_context` – 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）。这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。
- `data_source` – 这是引用数据源实例位置的上下文路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。
和其他数据源配置类似，可以通过添加前缀“env.”直接把属性传递给 InitialContext。比如：
- `env.encoding=UTF8`
这就会在 InitialContext 实例化时往它的构造方法传递值为 `UTF8` 的 `encoding` 属性。
你可以通过实现接口 `org.apache.ibatis.datasource.DataSourceFactory` 来使用第三方数据源实现：
```java
public interface DataSourceFactory {
void setProperties(Properties props);
DataSource getDataSource();
}
```
`org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory` 可被用作父类来构建新的数据源适配器，比如下面这段插入 C3P0 数据源所必需的代码：
```java
import org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3P0DataSourceFactory extends UnpooledDataSourceFactory {
public C3P0DataSourceFactory() {
this.dataSource = new ComboPooledDataSource();
}
}
```
3.1.3 映射器（mappers）
既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。例如：
<mappers>
<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
<mapper resource="org/mybatis/builder/BlogMapper.xml"/>
<mapper resource="org/mybatis/builder/PostMapper.xml"/>
mappers>
<mappers>
<mapper url="file:///var/mappers/AuthorMapper.xml"/>
<mapper url="file:///var/mappers/BlogMapper.xml"/>
<mapper url="file:///var/mappers/PostMapper.xml"/>
mappers>
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
mappers>
<mappers>
<package name="org.mybatis.builder"/>
mappers>
mapper.xml解析
<mapper namespace="edu.mju.entity.UserMapper">
<select id="selectUser" resultType="edu.mju.entity.User" >
select * from Users where id = #{id}
select>
<insert id="insertUser" parameterType="edu.mju.entity.User" useGeneratedKeys="true">
insert into Users(name,pwd) values(#{name},#{pwd})
insert>
<update id="updateUser" parameterType="edu.mju.entity.User">
update Users set name=#{name},pwd=#{pwd} where id=#{id} ;
update>
<delete id="deleteUser" parameterType="edu.mju.entity.User">
delete from Users where id = #{id}
delete>
<select id="selectAll" resultType="edu.mju.entity.User">
select * from Users
select>
mapper>
namespace:命名空间，防止sql语句的Id命名重复。
namespace命名规则：包名+类名 / 包名+mapper文件名
Select元素的属性
| 属性 | 描述 |
|---|---|
| id | 在命名空间中唯一的标识符，可以被用来引用这条语句。 |
| parameterType | 将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。 |
| resultType | 期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。 |
| resultMap | 对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。 |
| flushCache | 将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。 |
| useCache | 将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。 |
| timeout | 这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。 |
| fetchSize | 这是一个给驱动的建议值，尝试让驱动程序每次批量返回的结果行数等于这个设置值。 默认值为未设置（unset）（依赖驱动）。 |
| statementType | 可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。 |
| resultSetType | FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE 或 DEFAULT（等价于 unset） 中的一个，默认值为 unset （依赖数据库驱动）。 |
| databaseId | 如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。 |
| resultOrdered | 这个设置仅针对嵌套结果 select 语句：如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用。 这就使得在获取嵌套结果集的时候不至于内存不够用。默认值：false。 |
| resultSets | 这个设置仅适用于多结果集的情况。它将列出语句执行后返回的结果集并赋予每个结果集一个名称，多个名称之间以逗号分隔。 |
Insert, Update, Delete 元素的属性
| 属性 | 描述 |
|---|---|
| id | 在命名空间中唯一的标识符，可以被用来引用这条语句。 |
| parameterType | 将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。 |
| flushCache | 将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：（对 insert、update 和 delete 语句）true。 |
| timeout | 这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。 |
| statementType | 可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。 |
| useGeneratedKeys | （仅适用于 insert 和 update）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。 |
| keyProperty | （仅适用于 insert 和 update）指定能够唯一识别对象的属性，MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值，默认值：未设置（unset）。如果生成列不止一个，可以用逗号分隔多个属性名称。 |
| keyColumn | （仅适用于 insert 和 update）设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。如果生成列不止一个，可以用逗号分隔多个属性名称。 |
| databaseId | 如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。 |
3.2 执行流程分析
3.3 配置文件优化
3.3.1 db.properties
创建一个db.properties文件
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/MybatisDemo?serverTimezone=Asia/Shanghai
username=xiaoxin
password=LabiXiaoxin@01
在nybatis-config.xml文件中，添加
<configuration>
<properties resource="db.properties"/>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="mapper/user.mapper.xml"/>
mappers>
configuration>
3.3.2 别名优化
在mybatis-config.xml添加
<typeAliases>
<package name="edu.mju.entity" />
typeAliases>
3.3.3 解决属性名与列名不一致问题
当数据库的字段名如下：
| id | name | pwd |
|---|
而java中User()实体类代码如下：
public class User {
private int id;
private String name;
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public User() {
}
public User(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
}
通过之前的获取我们会发现：pwd获取的结果为null
这是由于：MyBatis会根据查询的列名去进行设值（setter方法）
解决方案如下
- 一、在mapper.xml查询语句中为列名指定别名，别名与实体类一致
<select id="selectUser" resultType="User" >
select id,name,pwd as password from Users where id = #{id}
select>
- 二、设置结果映射类型
<select id="selectUser" resultMap="UserMap" >
select * from Users where id = #{id}
select>
<resultlMap type="User" id="UserMap">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="pwd" property="password"/>
resultMap>
4. 分页实现
4.1 通过sql语句实现分页
4.1.1 mapper.xml映射文件
<select id="selectPage" resultType="User" parameterType="Map">
select * from Users limit #{startIndex},#{pageSize}
select>
4.1.2 UserDao.java
/**
*
* @param currentPage 当前页
* @param pageSize 页面大小
* @return 返回结果集
* @throws IOException
*/
public List<User> getByPage(int currentPage,int pageSize) throws IOException {
SqlSession session = MyBatisUtil.getSession();
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("startIndex",(currentPage-1)*pageSize);
map.put("pageSize",pageSize);
List<User> list = session.selectList("edu.mju.entity.UserMapper.selectPage",map);
session.close();
return list;
}
4.1.3 测试类
@Test
public void UserPageSelect() throws IOException {
UserDao userDao = new UserDao();
List<User> list = userDao.getByPage(2,2);
System.out.println(JSONObject.toJSONString(list));
}
运行结果：
[{
"id":3,"name":"change","pwd":"change"},{
"id":4,"name":"labi","pwd":"123"}]
4.2 通过RowBounds实现分页
4.2.1 mapper.xml
该文件无需修改
```xml
```
4.2.2 UserDao.java
Dao中新建
RowBounds（）对象参数如下（int offset, int limit）
|offset|limit|
|------|-----|
|下标 |页面大小|
java /** * * @param currentPage 当前页 * @param pageSize 页面大小 * @return 返回结果集 * @throws IOException */ public ListgetByPageTwo(int currentPage,int pageSize) throws IOException { SqlSession session = MyBatisUtil.getSession(); RowBounds rowBounds = new RowBounds((currentPage-1)*pageSize,pageSize); List list = session.selectList("edu.mju.entity.UserMapper.selectPageTwo",null,rowBounds); session.close(); return list; }
5. 注解开发
注解开发不需要映射文件，如：
user.mapper.xml
### 5.1 `UserDaoByAnnotation()`接口
```java
public interface UserDaoByAnnotation {
@Select("select * from Users")
List selectAllUser();
}
```
### 5.2 `mybatis-config.xml`配置
```xml
```
### 5.3 测试类
```java
//使用注解方式实现MyBatis
@Test
public void UserSelectAllByAnnotation() throws IOException {
SqlSession session = MyBatisUtil.getSession();
UserDaoByAnnotation userDaoByAnnotation = session.getMapper(UserDaoByAnnotation.class);
List list = userDaoByAnnotation.selectAllUser();
System.out.println(JSONObject.toJSONString(list));
}
```
运行结果
```bash
[{"id":1,"name":"labixiaoxin","pwd":"123"},{"id":2,"name":"a","pwd":"123"},{"id":3,"name":"change","pwd":"change"},{"id":4,"name":"labi","pwd":"123"}]
```
6 多表查询案例
6.1 多对一的处理
6.1.1 按结果嵌套处理
-
1.表结构如下图
-
2.对应实体类
Student.java
public class Student {
private int id;
private String name;
private Teacher teacher;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
}
Teacher.java
public class Teacher {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- 3.映射文件编写
student.mapper.xml
<mapper namespace="edu.mju.entity.Student.mapper">
<select id="getStudent" resultMap="StudentTeacher">
select s.id sid,s.name sname,s.tId,t.id tid,t.name tname from Student s,Teacher t where s.tId=t.id;
select>
<resultMap id="StudentTeacher" type="Student">
<id column="sid" property="id">id>
<result column="sname" property="name"/>
<association property="teacher" javaType="Teacher">
<id column="tid" property="id"/>
<result column="tname" property="name"/>
association>
resultMap>
mapper>
- 4.DAO代码编写
StudentDao.java
public class StudentDao {
public List<Student> getAll() throws IOException {
List<Student> list = null;
SqlSession session = MyBatisUtil.getSession();
list = session.selectList("edu.mju.entity.Student.mapper.getStudent");
return list;
}
}
- 5.Mybatis配置文件
mybatis-config.xml
<configuration>
<properties resource="db.properties"/>
<typeAliases>
<package name="edu.mju.entity" />
typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="mapper/student.mapper.xml"/>
mappers>
configuration>
- 6.测试类
StudentTest.java
public class StudentTest {
@Test
public void getAll() throws IOException {
StudentDao studentDao = new StudentDao();
List<Student> list = studentDao.getAll();
System.out.println(JSONObject.toJSONString(list));
}
}
运行结果
[{
"id":1,"name":"小新同学","teacher":{
"id":1,"name":"李阳"}},{
"id":2,"name":"小明同学","teacher":{
"id":1,"name":"李阳"}},{
"id":3,"name":"张三","teacher":{
"id":1,"name":"李阳"}}]
6.1.2 按查询嵌套处理
- 1.映射文件
studentT.mapper.xml
<mapper namespace="edu.mju.entity.StudentT.mapper">
<select id="getStudents" resultMap="StudentTeacher">
select * from Student
select>
<resultMap id="StudentTeacher" type="Student">
<association property="teacher" column="tid" javaType="Teacher" select="edu.mju.entity.Teacher.mapper.getTeacher">
association>
resultMap>
mapper>
teacher.mapper.xml
<mapper namespace="edu.mju.entity.Teacher.mapper">
<select id="getTeacher" resultType="Teacher">
select * from Teacher where id=#{id};
select>
mapper>
- 2.核心文件
mybatis-config.xml
<configuration>
<properties resource="db.properties"/>
<typeAliases>
<package name="edu.mju.entity" />
typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="mapper/teacher.mapper.xml"/>
<mapper resource="mapper/studentT.mapper.xml"/>
mappers>
configuration>
- 3.DAO文件
StudentDao.java
public class StudentDao {
public List<Student> getAllT() throws IOException {
List<Student> list;
SqlSession session = MyBatisUtil.getSession();
list = session.selectList("edu.mju.entity.StudentT.mapper.getStudents");
return list;
}
}
- 4.测试类
@Test
public void getAllT() throws IOException {
StudentDao studentDao = new StudentDao();
List<Student> list = studentDao.getAllT();
System.out.println(JSONObject.toJSONString(list));
}
测试结果
[{
"id":1,"name":"小新同学","teacher":{
"id":1,"name":"李阳"}},{
"id":2,"name":"小明同学","teacher":{
"$ref":"$[0].teacher"}},{
"id":3,"name":"张三","teacher":{
"$ref":"$[0].teacher"}}]
6.2 一对多的处理
6.2.1 按结果嵌套处理
-
- 实体类
Teacher.java
public class Teacher {
private int id;
private String name;
private List<Student> students;
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Student.java
public class Student {
private int id;
private String name;
private Teacher teacher;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
}
-
- 映射文件编写
teacher.mapper.xml
<mapper namespace="edu.mju.entity.Teacher.mapper">
<select id="getTeacher" resultMap="TeacherStudent" >
select s.id sid,s.name sname,s.tId,t.id tid,t.name tname from Student s,Teacher t where s.tId=t.id and t.id=#{id}
select>
<resultMap id="TeacherStudent" type="Teacher">
<id column="tid" property="id"/>
<result column="tname" property="name"/>
<collection property="students" ofType="Student">
<id column="sid" property="id"/>
<result column="sname" property="name"/>
collection>
resultMap>
mapper>
-
- DAO编写
TeacherDao.java
public class TeacherDao {
public Teacher getTeacher(int id) throws IOException {
SqlSession session = MyBatisUtil.getSession();
Teacher teacher = session.selectOne("edu.mju.entity.Teacher.mapper.getTeacher",id);
session.close();
return teacher;
}
}
-
- 测试类编写
TeacherTest.java
public class TeacherTest {
@Test
public void teacherTest() throws IOException {
TeacherDao teacherDao = new TeacherDao();
Teacher teacher = teacherDao.getTeacher(1);
List<Student> students = teacher.getStudents();
System.out.println("教师名："+teacher.getName());
System.out.println("所教学生："+ JSONObject.toJSONString(students));
}
}
运行结果
教师名：李阳
所教学生：[{
"id":1,"name":"小新同学"},{
"id":2,"name":"小明同学"},{
"id":3,"name":"张三"}]
6.2.1 按查询嵌套处理
-
- 映射文件编写
teacher.mapper.xml
<mapper namespace="edu.mju.entity.Teacher.mapper">
<select id="getTeacher" resultMap="TeacherStudent">
select * from Teacher where id=#{id}
select>
<resultMap id="TeacherStudent" type="Teacher">
<collection property="students" javaType="ArrayList" ofType="Student"
column="id" select="edu.mju.entity.Student.mapper.getStudentByTid"/>
resultMap>
mapper>
student.mapper.xml
<mapper namespace="edu.mju.entity.Student.mapper">
<select id="getStudentByTid" resultType="Student" >
select * from Student where tid=#{tid}
select>
mapper>
-
- 测试结果
测试类
@Test
public void teacherTestT() throws IOException {
TeacherDao teacherDao = new TeacherDao();
Teacher teacher = teacherDao.getTeacher(2);
List<Student> students = teacher.getStudents();
System.out.println("教师名："+teacher.getName());
System.out.println("所教学生："+ JSONObject.toJSONString(students));
}
教师名：冯诺依曼
所教学生：[{
"id":4,"name":"小爱同学"}]
7 动态SQL
动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。
使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。
如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
7.1 if
包含
<select id="getUserByCondition" resultType="User" parameterType="Map">
select * from Users
<where>
<if test="name!=null">
name like concat('%',#{name},'%')
if>
<if test="pwd!=null">
And pwd like concat('%',#{pwd},'%')
if>
where>
select>
语句解释如下：如果不传入"name"或者"pwd"，那么所有结果都会返回。如果传入了相应参数，则模糊查询，并返回结果。
7.2 choose、when、otherwise
有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。
还是上面的例子，但是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若两者都没有传入，就返回标记为 featured 的 BLOG（这可能是管理员认为，与其返回大量的无意义随机 Blog，还不如返回一些由管理员挑选的 Blog）。
<select id="findActiveBlogLike"
resultType="Blog">
SELECT * FROM BLOG WHERE state = ‘ACTIVE’
<choose>
<when test="title != null">
AND title like #{title}
when>
<when test="author != null and author.name != null">
AND author_name like #{author.name}
when>
<otherwise>
AND featured = 1
otherwise>
choose>
select>
7.3 trim、where、set
以下代码当没有匹配条件时，查询失败
<select id="findActiveBlogLike"
resultType="Blog">
SELECT * FROM BLOG
WHERE
<if test="state != null">
state = #{state}
if>
<if test="title != null">
AND title like #{title}
if>
<if test="author != null and author.name != null">
AND author_name like #{author.name}
if>
select>
MyBatis 有一个简单且适合大多数场景的解决办法。而在其他场景中，可以对其进行自定义以符合需求。而这，只需要一处简单的改动：
<select id="findActiveBlogLike"
resultType="Blog">
SELECT * FROM BLOG
<where>
<if test="state != null">
state = #{state}
if>
<if test="title != null">
AND title like #{title}
if>
<if test="author != null and author.name != null">
AND author_name like #{author.name}
if>
where>
select>
where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。
用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。比如：
<update id="updateAuthorIfNecessary">
update Author
<set>
<if test="username != null">username=#{username},if>
<if test="password != null">password=#{password},if>
<if test="email != null">email=#{email},if>
<if test="bio != null">bio=#{bio}if>
set>
where id=#{id}
update>
与set元素等价的自定义
<trim prefix="SET" suffixOverrides=",">
...
trim>
与where元素等价的自定义
<trim prefix="WHERE" prefixOverrides="AND |OR ">
...
trim>
prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）
7.4 foreach
动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。比如：
<select id="selectPostIn" resultType="domain.blog.Post">
SELECT *
FROM POST P
WHERE ID in
<foreach item="item" index="index" collection="list"
open="(" separator="," close=")">
#{item}
foreach>
select>
7.5 注解的映射器接口类使用动态SQL
可以使用 script 元素。比如:
@Update({
""})
void updateAuthorValues(Author author);
7.6 bind、多数据库支持、动态SQL中插入脚本语言
以上请自行查看官方文档
https://mybatis.org/mybatis-3/zh/dynamic-sql.html
喜欢的朋友，欢迎帮我点个star:docsify——gitee地址