MyBatis增删改查(步骤详细，由浅入深，适合初学者,只看这一篇就够了)
MyBatis目录
-
- java（后端框架）MyBatis的使用
- 1.mybatis基本使用
- 2.mybatis工具类的封装和实现增删改查
- 3.mybatis中主要类的介绍
- 4.nybatis实现动态代理:(使用的是反射机制,重点掌握)
- 5.mybatis参数传递:
- 6.$和#的区别(重点掌握)
- 7.ResultType的使用
- 8.动态sql
- 9.代码片段(sql语句重复使用)
- 10.mybatis配置文件中,使用配置文件的方式获取连接
- 11.mybatis分页查询
java（后端框架）MyBatis的使用
mybatis的简介这里就不多说了,百度一大堆,我们只需要这是一个JDBC的升级版,让我们更好的操作数据库,减少不必要的代码,让我们专注于实现自己的业务逻辑.
web开发的三层架构 (mvc )
-
三层架构
界面层： 和用户打交道的， 接收用户的请求参数， 显示处理结果的。（jsp ，html ，servlet）
业务逻辑层： 接收了界面层传递的数据，计算逻辑，调用数据库，获取数据
数据访问层： 就是访问数据库， 执行对数据的查询，修改，删除等等的。三层对应的包
界面层： controller包 （servlet）
业务逻辑层： service 包（XXXService类）
数据访问层： dao包（XXXDao类）三层中类的交互
用户使用界面层–> 业务逻辑层—>数据访问层（持久层）–>数据库（mysql）三层对应的处理框架
界面层—servlet—springmvc（框架）
业务逻辑层—service类–spring（框架）
数据访问层—dao类–mybatis（框架）
使用 JDBC 的缺陷
- 代码比较多，开发效率低
- 需要关注 Connection ,Statement, ResultSet 对象创建和销毁
- 对 ResultSet 查询的结果，需要自己封装为 List
- 重复的代码比较多些
- 业务代码和数据库的操作混在一起
MyBatis 解决的主要问题
mybatis完全是一个升级版的JDBC,他是可以完全独立抽取出来的使用的.
MyBatis 可以完成：
- 注册数据库的驱动，
- 创建 JDBC 中必须使用的 Connection ， Statement， ResultSet 对象
- 从 xml 中获取 sql，并执行 sql 语句，把 ResultSet 结果转换 java 对象
4.关闭资源
ResultSet.close() , Statement.close() , Conenection.close()
mybatis使用步骤:
1.导入maven环境
2.创建dao接口,里面定了你需要对数据库执行什么操作
3.编写mapper文件,sql映射文件,写上你的sql语句
4.创建mybatis主配置文件,读取配置文件中的内容,连接到数据库
5.使用mybatis对象执行sql语句:sqlSession对象
6.关闭连接:sqlSession.close();
1.mybatis基本使用
新建数据库表
CREATE TABLE t_user (
id int NOT NULL AUTO_INCREMENT,
username varchar(255) DEFAULT NULL,
password varchar(255) DEFAULT NULL,
email varchar(255) DEFAULT NULL,
phone varchar(255) DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
1.使用maven新建一个项目(项目 目录结构)
1.1准备一个java Use 类
public class User {
private Integer id;
private String username;
private String password;
private String email;
private String phone;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public User() {
}
public User(Integer id, String username, String password, String email, String phone) {
this.id = id;
this.username = username;
this.password = password;
this.email = email;
this.phone = phone;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
", phone='" + phone + '\'' +
'}';
}
}
2.配置pom.xml文件导入相应的依赖包
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>org.examplegroupId>
<artifactId>mybaisartifactId>
<version>1.0-SNAPSHOTversion>
<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<maven.compiler.source>1.9maven.compiler.source>
<maven.compiler.target>1.9maven.compiler.target>
properties>
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.11version>
<scope>testscope>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.19version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.4version>
dependency>
<dependency>
<groupId>org.junit.jupitergroupId>
<artifactId>junit-jupiterartifactId>
<version>RELEASEversion>
<scope>compilescope>
dependency>
dependencies>
<build>
<resources>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>falsefiltering>
resource>
resources>
build>
project>
3.编写dao接口
public interface UserManagerDao {
/**
* 查询所有的数据 用于视图展示
* @return 返回一个List集合
*/
public List<User> queryUser();
/**
* 添加
* @param user 一个user对象
* @return 成功返回true 失败返回false
*/
public Boolean addUser(User user);
/**
* 删除用户
* @param id 需要删除的用户id
* @return 成功返回true 失败返回false
*/
public Boolean delUser(String id);
/**
* 修改用户信息
* @param user 需要一个user对象
* @return 成功返回true 失败返回false
*/
public Boolean updateUser(User user);
/**
* 按照用户名查找用户
* @param name 需要查找的用户名
* @return 返回一个List集合
*/
public List<User> likeUser(String name);
}
4.编写dao接口的xml文件
<mapper namespace="bookMall.dao.UserManagerDao">
<select id="queryUser" resultType="bookMall.bean.User" >
select id,username,password,email,phone from t_user where id>0
select>
<select id="likeUser" resultType="bookMall.bean.User" >
select id,username,password,email,phone from t_user where username=#{username}
select>
<insert id="addUser" >
insert into t_user values(#{id},#{username},#{username},#{email},#{phone})
insert>
mapper>
5.资源目录下的 mybatis.xml文件
<configuration>
<environments default="mydev">
<environment id="mydev">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/book_ctiy?serverTimezone=GMT%2B8"/>
<property name="username" value="root"/>
<property name="password" value="2732195202"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="bookMall\dao\UserManagerDao.xml"/>
mappers>
configuration>
6.测试是否可以用
@Test
void queryUser() throws IOException {
//访问mybatis读取student数据
//1.定义mybatis主配置文件的名称, 从类路径的根开始（target/clasess）
String config="mybatis.xml";
//2.读取这个config表示的文件
InputStream in = Resources.getResourceAsStream(config);
//3.创建了SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//4.创建SqlSessionFactory对象
SqlSessionFactory factory = builder.build(in);
//5.获取SqlSession对象，从SqlSessionFactory中获取SqlSession
SqlSession sqlSession = factory.openSession();
//6.【重要】指定要执行的sql语句的标识。 sql映射文件中的namespace + "." + 标签的id值
String sqlId = "bookMall.dao.UserManagerDao" + "." + "queryUser";
// String sqlId = "bookMall.dao.UserManagerDao";
//7. 重要】执行sql语句，通过sqlId找到语句
List<User> studentList = sqlSession.selectList(sqlId);
//8.输出结果
//studentList.forEach( stu -> System.out.println(stu));
for(User user : studentList){
System.out.println("查询的学生="+user);
}
//9.关闭SqlSession对象
sqlSession.close();
}
7.测试结果:
注意事项:
1:target目录下一定要有这两个文件,如果没有,手动复制进去也行
2.mysql的依赖配置如果是高版本的:
driver的值是:com.mysql.cj.jdbc.Driver
3.mysql的依赖配置如果是高版本的,url是这样的:
dbc:mysql://localhost/book_ctiy?serverTimezone=GMT%2B8
一定要加上时区,不然会报错
4.在pom.xml配置文件中需要加上,才能更好的将pom.xml和UserManagerDao.xml文件映射出去
2.mybatis工具类的封装和实现增删改查
项目的目录结构: :
需要注意的是target目录下必须有标记红色框的那两个文件,否则执行的时候回报错
1.准备数据库表
CREATE TABLE `t_user` (
`id` int NOT NULL AUTO_INCREMENT,
`username` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
`email` varchar(255) DEFAULT NULL,
`phone` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
INSERT INTO `t_user`(`id`, `username`, `password`, `email`, `phone`) VALUES (1, 'admin', 'admin', '[email protected]', '1008611');
INSERT INTO `t_user`(`id`, `username`, `password`, `email`, `phone`) VALUES (2, 'root', 'root', '[email protected]', '1008622');
INSERT INTO `t_user`(`id`, `username`, `password`, `email`, `phone`) VALUES (19, 'admin2', 'root2', '[email protected]', '1008644');
2.创建实体类
public class User {
private Integer id;
private String username;
private String password;
private String email;
private String phone;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public User() {
}
public User(Integer id, String username, String password, String email, String phone) {
this.id = id;
this.username = username;
this.password = password;
this.email = email;
this.phone = phone;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
", phone='" + phone + '\'' +
'}';
}
}
3.创建maven项目,大多数配置一样,但是某些配置根据自己的来
注意:
因为我的jdk9,所以我写的就是9,你们根据自己的jdk版本来写.
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>org.examplegroupId>
<artifactId>mybatisartifactId>
<version>1.0-SNAPSHOTversion>
<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<maven.compiler.source>1.9maven.compiler.source>
<maven.compiler.target>1.9maven.compiler.target>
properties>
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.11version>
<scope>testscope>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.19version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.4version>
dependency>
<dependency>
<groupId>org.junit.jupitergroupId>
<artifactId>junit-jupiterartifactId>
<version>RELEASEversion>
<scope>compilescope>
dependency>
dependencies>
<build>
<resources>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>falsefiltering>
resource>
resources>
build>
project>
4.配置mybatis的主配置文件
注意点:
mysql驱动包如果是高版本的:
driver的值需要些成:com.mysql.cj.jdbc.Driver 否则会报异常
url需要加上时区:否则执行会报错
url= jdbc:mysql://主机名/数据库名?serverTimezone=GMT%2B8
<configuration>
<setting name="logImpl" value="STDOUT_LOGGING"/>
settings>
-->
<environments default="localhost">
<environment id="localhost">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/book_ctiy?serverTimezone=GMT%2B8"/>
<property name="username" value="root"/>
<property name="password" value="2732195202"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="com\mybatis\dao\UserManagerDao.xml"/>
mappers>
configuration>
5.编写mybatis工具类
工具类就是为了简化代码,因为有很多重复写,而且没有意义的代码,可以创建工具类,有工具类完成,使我们的代码更加简洁.
public class MyBatisUtils {
private static SqlSessionFactory factory = null;
static {
//读取mybatis.xml配置文件
String config="mybatis.xml";
try {
//将配置文件加入到流中
InputStream in = Resources.getResourceAsStream(config);
//创建factory对象
factory = new SqlSessionFactoryBuilder().build(in);
} catch (IOException e) {
e.printStackTrace();
}
}
public static SqlSession getSqlSession(){
SqlSession sqlSession = null;
if (factory!=null){
//如果 factory!=null 就创建 sqlSession对象
sqlSession = factory.openSession(false);//非自动提交事务
}
return sqlSession;
}
}
5.定义dao接口,看我们需要实现哪些功能
public interface UserManagerDao {
/**
* 查询所有的数据 用于视图展示
* @return 返回一个List集合
*/
public List<User> queryUser();
/**
* 添加
* @param user 一个user对象
* @return 成功返回true 失败返回false
*/
public Boolean addUser(User user);
/**
* 删除用户
* @param id 需要删除的用户id
* @return 成功返回true 失败返回false
*/
public Boolean delUser(String id);
/**
* 修改用户信息
* @param user 需要一个user对象
* @return 成功返回true 失败返回false
*/
public Boolean updateUser(User user);
/**
* 按照用户名查找用户
* @param name 需要查找的用户名
* @return 返回一个List集合
*/
public List<User> likeUser(String name);
}
6.编写Dao.xml文件.让这个xml文件去代替我们的JDBC
注意点:
mapper 标签的namespace的值
尽量按照这个规范:com.mybatis.dao.UserManagerDao
方便后面使用动态代理,使用反射机制.
模糊查询的sql语句参数是$不是#
是这样
select * from t_user where username like '%${username}%'
而不是这样
select * from t_user where username like '%#{username}%'
<mapper namespace="com.mybatis.dao.UserManagerDao">
<select id="queryUser" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user
select>
<select id="likeUser" parameterType="String" resultType="com.mybatis.bean.User">
select * from t_user where username like '%${username}%'
select>
<insert id="addUser">
insert into t_user values(#{id},#{username},#{username},#{email},#{phone})
insert>
<delete id="delUser">
delete from t_user where id=#{id}
delete>
<update id="updateUser">
update t_user set username=#{username},password=#{password},email=#{email},phone=#{phone} where id=#{id}
update>
mapper>
7.编写daoImpl
注意点:
执行完sql语句之后一定要几点关闭数据库连接
sqlSession.close();
在执行增删改的时候mybatis是默认手动提交事务,需要我们手动设置为自动提交事务
方法1: sqlSession.commit();
方法2:在工具类中设置:sqlSession = factory.openSession(true);//自动提交事务
public class UserManagerDaoImpl implements UserManagerDao {
/**
* 查询所有的数据 用于视图展示
*
* @return 返回一个List集合
*/
@Override
public List<User> queryUser() {
//获取sqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
String sqlId = "com.mybatis.dao.UserManagerDao.queryUser";
//执行sql语句
List<User> userList = sqlSession.selectList(sqlId);
// sqlSession.commit(); //mybatis默认不会手动提交事务,在修改数据之后要 提交事务
//关闭连接
sqlSession.close();
return userList;
}
/**
* 添加
*
* @param user 一个user对象
* @return 成功返回true 失败返回false
*/
@Override
public Boolean addUser(User user) {
//获取sqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
String sqlId = "com.mybatis.dao.UserManagerDao.addUser";
//执行sql语句
int updateCount = sqlSession.update(sqlId,user);
sqlSession.commit(); //mybatis默认不会手动提交事务,在修改数据之后要 提交事务
//关闭连接
sqlSession.close();
if(updateCount>0){
return true;
}else{
return false;
}
}
/**
* 删除用户
*
* @param id 需要删除的用户id
* @return 成功返回true 失败返回false
*/
@Override
public Boolean delUser(String id) {
//获取sqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
String sqlId = "com.mybatis.dao.UserManagerDao.delUser";
//执行sql语句
int delete = sqlSession.delete(sqlId, id);
sqlSession.commit(); //设置为自动提交事务
//关闭连接
sqlSession.close();
if(delete>0){
return true;
}else {
return false;
}
}
/**
* 修改用户信息
*
* @param user 需要一个user对象
* @return 成功返回true 失败返回false
*/
@Override
public Boolean updateUser(User user) {
//获取sqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
String sqlId = "com.mybatis.dao.UserManagerDao.updateUser";
//执行sql语句
int updateCount = sqlSession.update(sqlId,user);
sqlSession.commit(); //设置为自动提交事务
//关闭连接
sqlSession.close();
if(updateCount>0){
return true;
}else {
return false;
}
}
/**
* 按照用户名查找用户
*
* @param name 需要查找的用户名
* @return 返回一个List集合
*/
@Override
public List<User> likeUser(String name) {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
String sqlId = "com.mybatis.dao.UserManagerDao.likeUser";
List<User> userList = sqlSession.selectList(sqlId, name);
sqlSession.commit();
//关闭连接
sqlSession.close();
return userList;
}
}
8.编写Test类 测试我们的方法是否可用
class UserManagerDaoImplTest {
UserManagerDaoImpl userManagerDao = new UserManagerDaoImpl();
@Test
void queryUser() {
List<User> userList = userManagerDao.queryUser();
for (User user : userList) {
System.out.println(user);
}
}
@Test
void ListUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao userDao = sqlSession.getMapper(UserManagerDao.class);
List<User> userList = userDao.queryUser();
for (User user : userList) {
System.out.println(user);
}
}
@Test
void addUser() {
User user = new User(null,"admin","root","[email protected]","1008644");
Boolean flag = userManagerDao.addUser(user);
System.out.println(flag);
}
@Test
void delUser() {
Boolean flag = userManagerDao.delUser("23");
System.out.println(flag);
}
@Test
void updateUser() {
User user = new User(19,"admin2","root2","[email protected]","1008644");
Boolean flag = userManagerDao.updateUser(user);
System.out.println(flag);
}
@Test
void likeUser() {
List<User> userList = userManagerDao.likeUser("admin");
for (User user : userList) {
System.out.println(user);
}
}
}
3.mybatis中主要类的介绍
- Resources： mybatis中的一个类， 负责读取主配置文件
InputStream in = Resources.getResourceAsStream(“mybatis.xml”);
2.SqlSessionFactoryBuilder : 创建SqlSessionFactory对象，
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//创建SqlSessionFactory对象
SqlSessionFactory factory = builder.build(in);
3.SqlSessionFactory ： 重量级对象， 程序创建一个对象耗时比较长，使用资源比较多。
SqlSessionFactory:接口 ， 接口实现类： DefaultSqlSessionFactory
SqlSessionFactory作用： 获取SqlSession对象。
SqlSession sqlSession = factory.openSession();
openSession()方法说明：
1. openSession() ：无参数的， 获取是非自动提交事务的SqlSession对象
2. openSession(boolean): openSession(true) 获取自动提交事务的SqlSession.
openSession(false) 非自动提交事务的SqlSession对象
4.SqlSession: 执行sql语句的对象
SqlSession接口 ：定义了操作数据的方法 例如 selectOne() ,selectList() ,insert(),update(), delete(), commit(), rollback()
SqlSession接口的实现类DefaultSqlSession。
使用要求： SqlSession对象不是线程安全的，需要在方法内部使用， 在执行sql语句之前，使用openSession()获取SqlSession对象。
在执行完sql语句后，需要关闭它，执行SqlSession.close(). 这样能保证他的使用是线程安全的
4.nybatis实现动态代理:(使用的是反射机制,重点掌握)
在mybatis增删改查的基础上,我们只需要删除daoImpl实现类就好了,其余的不变
使用mybatis动态代理的注意事项:
测试userManagerDao中的接口方法
class UserManagerDaoImplTest {
//mybatis动态代理
@Test
void queryUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<User> userList = mapper.queryUser();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
@Test
void addUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
sqlSession.commit();
User user = new User(null,"admin","root","[email protected]","1008644");
Boolean flag = mapper.addUser(user);
System.out.println(flag);
sqlSession.close();
}
@Test
void delUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
Boolean flag = mapper.delUser("19");
sqlSession.commit();
System.out.println(flag);
sqlSession.close();
}
@Test
void updateUser() {
User user = new User(19,"admin","root","[email protected]","1008644");
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
Boolean flag = mapper.updateUser(user);
sqlSession.commit();
System.out.println(flag);
sqlSession.close();
}
@Test
void likeUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
sqlSession.commit();
List<User> userList = mapper.likeUser("admin");
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
}
5.mybatis参数传递:
其实传参的方式有很多种，我们掌握以下三种，已经完全够用，如果不够用可以上网查看更多的传参方式。
使用@Param进行传参:
1.1接口中的写法
/**
* 使用@Param自定义传值
* @return 返回一个List集合
*/
public List<User> queryUserList(@Param("myId") String id);
1.2.dao.xml文件中的写法 @Param(“myId”) 和我们的参数是相对应的
<select id="queryUserList" parameterType="int" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user where id=#{myId}
select>
1.3.使用动态代理的时候传参方式
//使用@Param 自定义参数传值
@Test
void queryUserList() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<User> userList = mapper.queryUserList("1");
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
使用java对象进行传参:
2.dao接口
/**
* 修改用户信息 使用对象传值
* @param user 需要一个user对象
* @return 成功返回true 失败返回false
*/
public Boolean updateUser(User user);
2.2.dao.xml文件配置
<update id="updateUser">
update t_user set username=#{username},password=#{password},email=#{email},phone=#{phone} where id=#{id}
update>
2.3.调用dao接口方法
@Test
void updateUser() {
User user = new User(19,"admin","root","[email protected]","1008644");
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
Boolean flag = mapper.updateUser(user); //参数类型无限制,底层使用泛型
sqlSession.commit();
System.out.println(flag);
sqlSession.close();
}
3：使用map集合传参
3.1集合中传map集合
/**
* 使用map集合传值
* @return 返回一个List集合
*/
public List<User> queryUserMap(Map<String,Object> map);
3.2dao.xml中使用map的key值进行传参
<select id="queryUserMap" parameterType="map" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user where id=#{id}
select>
3.3测试类的实现
//使用map集合传递参数
@Test
void queryUserMap() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
Map<String,Object> map = new HashMap<>();
map.put("id",1);
List<User> userList = mapper.queryUserMap(map);
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
6.$和#的区别(重点掌握)
select id,name, email,age from student where id=#{studentId}
(#) 的结果： select id,name, email,age from student where id=?
select id,name, email,age from student where id=${studentId}
( $) 的结果：select id,name, email,age from student where id=1001
String sql=“select id,name, email,age from student where id=” + “1001”;
使用的Statement对象执行sql， 效率比PreparedStatement低。
$:可以替换表名或者列名， 你能确定数据是安全的。可以使用$
# 和 $ 区别
1. #使用 ？在sql语句中做站位的， 使用PreparedStatement执行sql，效率高
2. #能够避免sql注入，更安全。
3. $不使用占位符，是字符串连接方式，使用Statement对象执行sql，效率低
4. $有sql注入的风险，缺乏安全性。
5. $:可以替换表名或者列名
7.ResultType的使用
mybatis返回值类型支持的别名机制对应表
resultType：的返回值可以是别名，也可以是返回值类型的全限定义名称（可以是任意类型）
自定义 resultType：的返回值类型
第一种方式：
1.在mybatis主配置文件中加上typeAliases标签
<typeAliases>
<typeAlias type="com.mybatis.bean.User" alias="User">typeAlias>
typeAliases>
2.在dao.xml文件中使用即可
<select id="queryUser" resultType="User">
select id,username,password,email,phone from t_user
select>
第二种方式：
1.在mybatis主配置文件中：
<typeAliases>
<package name="com.mybatis.bean"/>
typeAliases>
2.在dao.xml文件中使用即可
<select id="queryUser" resultType="User">
select id,username,password,email,phone from t_user
select>
查询结果的返回值
1.返回map类型
1.1dao接口
/**
* 返回map集合
* @return
*/
public Map<Object,Object> queryResultMap(Integer id);
1.2dao.xml配置文件
<select id="queryResultMap" resultType="java.util.HashMap" >
select username,password from t_user where id=#{id}
select>
1.3测试类
//设置返回值为Map类型
@Test
void queryResultMap() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
Map<Object, Object> objectMap = mapper.queryResultMap(1);
System.out.println(objectMap);
sqlSession.close();
}
2.返回对象
2.1 dao接口
/**
* 按照用户名查找用户
* @param name 需要查找的用户名
* @return 返回一个List集合
*/
public List<User> likeUser( @Param("username") String name);
2.2dao接口配置文件
<select id="likeUser" parameterType="String" resultType="com.mybatis.bean.User">
select * from t_user where username like '%${username}%'
select>
2.3测试方法
@Test
void likeUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
sqlSession.commit();
List<User> userList = mapper.likeUser("admin");
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
使用Map映射关系解决数据库列名和实体类对象属性名不一致，
导致反射异常无法赋值的解决方案：一 （重点掌握）
1.1dao接口方法
/**
* 使用Map定义映射关系 解决数据库列名和对象属性名不一致的方法1
* @return 返回list集合
*/
public List<Student> selectStudents();
1.2dao接口配置文件
<resultMap id="studentMap" type="com.mybatis.bean.Student">
<id column="id" property="idStudent">id>
<result column="username" property="usernameStudent">result>
<result column="password" property="passwordStudent">result>
<result column="email" property="emailStudent">result>
<result column="phone" property="phoneStudent">result>
resultMap>
<select id="selectStudents" resultMap="studentMap">
select id,username,password,email,phone from t_user
select>
1.3测试是否可行
//使用map映射解决数据库列名和对象属性名不一致导致反射异常无法赋值的解决方案1
@Test
void selectStudents() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<Student> students = mapper.selectStudents();
for (Student student : students) {
System.out.println(student);
}
sqlSession.close();
}
数据库表：
实体类对象属性：
测试结果 ： ok 可行
使用给列名起别名解决数据库列名和实体类对象属性名不一致，
导致反射异常无法赋值的解决方案：2 （重点掌握）
2.1dao接口方法
/**
* 使用列别名的方式 解决数据库列名和对象属性名不一致的方法2
* @return 返回list集合
*/
public List<Student> queryStudents();
2.2 dao接口配置文件
<select id="queryStudents" resultType="com.mybatis.bean.Student">
select id as idStudent ,username as usernameStudent,password as passwordStudent,email as emailStudent,phone as phoneStudent from t_user
select>
2.3 测试方法
//使用列别名解决数据库列名和对象属性名不一致导致反射异常无法赋值的解决方案1
@Test
void queryStudents() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<Student> students = mapper.queryStudents();
for (Student student : students) {
System.out.println(student);
}
sqlSession.close();
}
总结:两种都可以 :不过第二种要简单一些;
8.动态sql
if , where, Foreach的使用
MyBatis工具类
public class MyBatisUtils {
private static SqlSessionFactory factory = null;
static {
//读取mybatis.xml配置文件
String config="mybatis.xml";
try {
//将配置文件加入到流中
InputStream in = Resources.getResourceAsStream(config);
//创建factory对象
factory = new SqlSessionFactoryBuilder().build(in);
} catch (IOException e) {
e.printStackTrace();
}
}
public static SqlSession getSqlSession(){
SqlSession sqlSession = null;
if (factory!=null){
//如果 factory!=null 就创建 sqlSession对象
sqlSession = factory.openSession(false);//非自动提交事务
}
return sqlSession;
}
}
1.1 dao接口
public interface UserManagerDao {
/**
* 动态sql的使用 在使用动态sql 的时候 需要使用java对象作为参数
* @param user 传入一个user对象
* @return
*/
public List <User> selectUserIf( User user);
/**
* 动态sql的使用 在使用动态sql 的时候 需要使用java对象作为参数
* @param user 传入一个user对象
* @return
*/
public List <User> selectUserWhere( User user);
/**
* 动态sql的使用 在使用动态sql 的时候 需要使用java对象作为参数
* @param idList 传入一个int List集合
* @return
*/
public List <User> selectUserForeachInteger(List<Integer> idList);
/**
* 动态sql的使用 在使用动态sql 的时候 需要使用java对象作为参数
* @param studentList 传入一个int List集合
* @return
*/
public List <User> selectUserForeachUser(List<User> studentList);
}
1.2 dao.xml配置文件
<mapper namespace="com.mybatis.dao.UserManagerDao">
<select id="selectUserIf" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user where
<if test="username !=null and username !='' ">
username = #{username}
if>
<if test="id >0 ">
and id>#{id}
if>
select>
<select id="selectUserWhere" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user
<where>
<if test="username !=null and username !='' ">
username = #{username}
if>
<if test="id >0 ">
or id>#{id}
if>
where>
select>
<select id="selectUserForeachInteger" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user where id in
<foreach collection="list" item="myId" open="(" close=")" separator=",">
#{myId}
foreach>
select>
<select id="selectUserForeachUser" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user where id in
<foreach collection="list" item="user" open="(" close=")" separator=",">
#{user.id}
foreach>
select>
mapper>
1.3 测试方法
class UserManagerDaoImplTest {
//mybatis动态sql
@Test
void selectUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
User user = new User();
user.setUsername("admin");
user.setId(0);
List<User> userList = mapper.selectUserIf(user);
for (User users : userList) {
System.out.println(users);
}
}
@Test
void selectUserWhere() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
User user = new User();
user.setUsername("");
user.setId(2);
List<User> userList = mapper.selectUserWhere(user);
for (User users : userList) {
System.out.println(users);
}
}
@Test
void selectUserForeachInteger() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
List<User> userList = mapper.selectUserForeachInteger(list);
for (User user : userList) {
System.out.println(user);
}
}
@Test
void selectUserForeachUser() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<User> userList = new ArrayList<User>();
User userOne = new User();
userOne.setId(1);
userList.add(userOne);
User userTwo = new User();
userOne.setId(2);
userList.add(userTwo);
List<User> userLists = mapper.selectUserForeachUser(userList);
for (User user : userList) {
System.out.println(user);
}
}
}
9.代码片段(sql语句重复使用)
1.先定义 <sql id="自定义名称唯一"> sql语句， 表名，字段等 </sql>
2.再使用， <include refid="id的值" />
1.1 dao接口
/**
* sql 语句重复使用
* @param studentList 传入一个int List集合
* @return
*/
public List <User> sqlRepeat(List<User> studentList);
1.2 dao.xml配置文件
<sql id="userSql" >
select id,username,password,email,phone from t_user where id in
sql>
<select id="sqlRepeat" resultType="com.mybatis.bean.User">
<include refid="userSql">include>
<foreach collection="list" item="user" open="(" close=")" separator=",">
#{user.id}
foreach>
select>
1.3 测试方法
//重复使用sql
@Test
void sqlRepeat() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
List<User> userList = new ArrayList<User>();
User userOne = new User();
userOne.setId(1);
userList.add(userOne);
User userTwo = new User();
userOne.setId(2);
userList.add(userTwo);
List<User> userLists = mapper.selectUserForeachUser(userList);
for (User user : userList) {
System.out.println(user);
}
}
10.mybatis配置文件中,使用配置文件的方式获取连接
1.mybatis.xml配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 使用读取配置文件的方式 从类路径跟开始找文件-->
<properties resource="jdbc.properties"/>
<environments default="localhost">
<environment id="localhost">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<!--数据库的驱动类名-->
<property name="driver" value="${jdbc.driver}"/>
<!--连接数据库的url字符串-->
<property name="url" value="${jdbc.url}"/>
<!--访问数据库的用户名-->
<property name="username" value="${jdbc.user}"/>
<!--密码-->
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
<!-- sql mapper(sql映射文件)的位置-->
<mappers>
<mapper resource="com\mybatis\dao\UserManagerDao.xml"/>
</mappers>
</configuration>
2.配置文件
jdbc.driver=com.mysql.cj.jdbc.Driver
#连接数据库的URL
jdbc.url=jdbc:mysql://localhost/book_ctiy?serverTimezone=GMT%2B8
#用户名
jdbc.user=root
#密码
jdbc.password=2732195202
mapper文件映射的2中方式
<mappers>
<mapper resource="com\mybatis\dao\UserManagerDao.xml"/>
<package name="com.mybatis.dao"/>
mappers>
11.mybatis分页查询
1.pom.xml中导入依赖
<!-- 分页插件-->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version> 5.1.10</version>
</dependency>
2.在mybatis配置文件中配置插件environments标签之前
<!--配置分页插件-->
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
3.dao接口方法
/**
* 使用pageHelper 分页查询数据
* @return
*/
public List<User> selectAll();
4.dao.xml配置文件
<select id="selectAll" resultType="com.mybatis.bean.User">
select id,username,password,email,phone from t_user
select>
5.测试方法
//分页查询
@Test
void selectAll() {
SqlSession sqlSession = MyBatisUtils.getSqlSession();
UserManagerDao mapper = sqlSession.getMapper(UserManagerDao.class);
// pageNum:从第几页开始 pageSize:一页中有多少条数据
PageHelper.startPage(1,3);
List<User> userList = mapper.selectAll();
List<User> userLists = mapper.selectUserForeachUser(userList);
for (User user : userList) {
System.out.println(user);
}
}
扩展资料
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="multipleResultSetsEnabled" value="true"/>
<setting name="useColumnLabel" value="true"/>
<setting name="useGeneratedKeys" value="false"/>
<setting name="autoMappingBehavior" value="PARTIAL"/>
<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
<setting name="defaultExecutorType" value="SIMPLE"/>
<setting name="defaultStatementTimeout" value="25"/>
<setting name="defaultFetchSize" value="100"/>
<setting name="safeRowBoundsEnabled" value="false"/>
<setting name="mapUnderscoreToCamelCase" value="false"/>
<setting name="localCacheScope" value="SESSION"/>
<setting name="jdbcTypeForNull" value="OTHER"/>
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
settings>