一、MyBatis概述
首先就是之前Java web中的三层结构
界面层： 和用户打交道的， 接收用户的请求参数， 显示处理结果的。（jsp ，html ，servlet）
业务逻辑层： 接收了界面层传递的数据，计算逻辑，调用数据库，获取数据
数据访问层： 就是访问数据库， 执行对数据的查询，修改，删除等等的
三层中对应的包：
界面层： controller包 （servlet）
业务逻辑层： service 包（XXXService类）
数据访问层： dao包（XXXDao类）
三层中类的交互
用户使用界面层--> 业务逻辑层--->数据访问层（持久层）-->数据库（mysql）
三层对应的处理框架
- 界面层---servlet---springmvc（框架）
- 业务逻辑层---service类--spring（框架）
- 数据访问层---dao类--mybatis（框架）
1. MyBatis 解决的主要问题
减轻使用 JDBC 的复杂性，不用编写重复的创建 Connetion , Statement ; 不用编写关闭资源代码。
直接使用 java 对象，表示结果数据。让开发者专注 SQL 的处理。 其他分心的工作由 MyBatis 代劳
总的来说，mybatis就是增强版的JDBC
二、快速开始一个 MyBatis
首先就是搭建MyBatis的环境
1. 创建mysql数据库和表
数据库名：ssm，表名：student
2. 创建maven工程
这个就不详细的说了，可以看之前写的文章
https://www.cnblogs.com/mengd/p/13436355.html
3. 在pom.xml文件中添加信息
主要就是mybatis依赖，和mysql驱动
还有就是在build标签里添加maven插件，方便之后使用
|
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
|
<?xml version="1.0" encoding="UTF-8"?><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.0</modelVersion> <groupId>com.md</groupId> <artifactId>01-hello-mybatis</artifactId> <version>1.0-SNAPSHOT</version> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <!--mybatis依赖--> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.1</version> </dependency> <!--mysql驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.9</version> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/java</directory><!--所在的目录--> <includes><!--包括目录下的.properties,.xml 文件都会扫描到--> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>false</filtering> </resource> </resources> </build></project> |
4. 编写对应的实体类
创建包com.md.domain，创建Student类
|
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
|
package com.md.domain;/** * @author MD * @create 2020-08-05 9:04 */// 和数据库的表名一样，public class Student { // 定义属性，属性名和列名一致 private Integer id; private String name; private String email; private Integer age; public Student() { } public Student(Integer id, String name, String email, Integer age) { this.id = id; this.name = name; this.email = email; this.age = age; } // 对应的set和get方法以及toString() } |
5. 编写Dao接口：StudentDao
创建包：com.md.dao
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package com.md.dao;import com.md.domain.Student;import java.util.List;/** * @author MD * @create 2020-08-05 9:07 */public interface StudentDao { // 查询Student表中所有数据 public List<Student> selectStudents();} |
6. 编写 Dao 接口 Mapper 映射文件 StudentDao.xml
注意：
在接口所在的包：com.md.dao里创建文件 StudentDao.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
25
26
27
28
29
30
31
32
33
|
<?xml version="1.0" encoding="UTF-8" ?><!--指定的约束文件，mybatis-3-mapper.dtd是约束文件的名称，扩展名是dtd约束文件的作用：限制、检查当前文件中出现的标签，属性必须符号mybatis的要求--><!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><!--mapper：是当前文件的根标签namespace ：必须有值，自定义的唯一字符串，推荐使用： dao 接口的全限定名称--><mapper namespace="com.md.dao.StudentDao"> <!-- <select>: 查询数据， 标签中必须是 select 语句 id: sql 语句的自定义名称，推荐使用 dao 接口中方法名称， 使用名称表示要执行的 sql 语句 resultType: 查询语句的返回结果数据类型，使用全限定类名 --> <select id="selectStudents" resultType="com.md.domain.Student"> <!-- 要执行的 sql 语句 --> select id,name,email,age from student </select> <!-- <update>:表示更新数据库的操作，里面写的是update sql语句 <insert>: <delete>: --></mapper> |
7. 创建 MyBatis 主配置文件
注意：
-
在项目 src/main 下创建 resources 目录，设置 resources 目录为 resources root - 创建主配置文件：名称为 mybatis.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
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
|
<?xml version="1.0" encoding="UTF-8" ?><!--mybatis的主配置文件，上面还是约束文件的说明--><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"><!--根标签 --><configuration> <!-- 配置 mybatis 环境 数据库的连接信息，default：必须和某个environment的id值一样 ，告诉mybatis使用那个数据库的连接信息，也就是访问那个数据库 --> <environments default="mysql"> <!-- 一个数据库的配置信息 id: 数据源的名称，可以自定义 --> <environment id="mysql"> <!-- 配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚） --> <transactionManager type="JDBC"/> <!-- 数据源 dataSource ：创建数据库 Connection 对象 type: POOLED 使用数据库的连接池 --> <dataSource type="POOLED"> <!-- 连接数据库的四个要素,是固定的 --> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/ssm"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> <!--sql映射文件的位置--> <mappers> <!-- 告诉 mybatis 要执行的 sql 语句的位置 一个标签指定一个文件的位置 --> <mapper resource="com/md/dao/StudentDao.xml"/> </mappers></configuration> |
如果是高版本的mysql，中文乱码可以使用下面的
支持中文的 url
jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8
基本就是如下的结构
8. 创建测试类 TestMybatis
在src/test/java/com/md/ 创建TestMybatis
特别注意里面写的备注信息
主要关心第六步和第七步，前面的都是一样的，后面直接封装方法
|
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
|
package com.md;import com.md.domain.Student;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 org.junit.Test;import java.io.IOException;import java.io.InputStream;import java.util.List;/** * @author MD * @create 2020-08-05 10:27 */public class TestMybatis { // 测试方法 @Test public void testSelect() 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 = "com.md.dao.StudentDao"+"."+"selectStudents"; String sqlId = "com.md.dao.StudentDao.selectStudents"; //7.【重要】执行sql语句，通过sqlId找到语句 List<Student> studentList = sqlSession.selectList(sqlId); //8.输出结果 studentList.forEach( stu -> System.out.println(stu)); //9.关闭SqlSession对象 sqlSession.close(); }} |
如果运行找不到mybatis.xml文件，先检查是否在pom.xml中配置下面的信息没，
在pom.xml下的build标签中
|
1
2
3
4
5
6
7
8
9
10
|
<resources> <resource> <directory>src/main/java</directory><!--所在的目录--> <includes><!--包括目录下的.properties,.xml 文件都会扫描到--> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>false</filtering> </resource></resources> |
不行的话就重启项目，通常就可以解决问题
9. 配置日志功能
mybatis.xml 文件加入日志配置，可以在控制台输出执行的 sql 语句和参数
在根标签里面添加
|
1
2
3
4
|
<settings> <!-- 设置mybatis的输出日志--> <setting name="logImpl" value="STDOUT_LOGGING" /> </settings> |
然后运行项目，就可以在控制台看到输出了
三、总结
实现步骤
- 新建一个student表
- 加入maven的mybatis坐标，以及mysql驱动的坐标，看pom.xml文件中的信息
- 创建实体类，Student，保存表中一行的数据
- 创建持久层的dao接口，定义操作数据库的方法
- 创建一个mybatis使用的配置文件，叫做sql映射文件(mapper文件)，一般一个表一个sql的映射文件，是xml文件，并且这个文件是在接口所在的目录，文件名和接口名一致
- 创建mybatis的主配置文件，一个项目就一个主配置文件，主配置文件提供了数据库的连接信息和sql映射文件的位置信息
- 创建测试类，使用mybatis访问数据库
四、insert
1. StudentDao 接口中增加方法
|
1
2
|
// 插入方法 public int insertStudent(Student student); |
2. StudentDao.xml 加入 sql 语句
|
1
2
3
4
5
6
|
<!-- 插入的时候要注意占位符，就是你传入对象的属性值--> <insert id="insertStudent" > insert into student values(#{id},#{name},#{email},#{age}) </insert> |
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
29
30
31
32
33
|
package com.md;public class TestMybatis { // 测试方法 @Test public void testInsert() throws IOException { String config = "mybatis.xml"; InputStream in = Resources.getResourceAsStream(config); SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder.build(in); SqlSession sqlSession = factory.openSession(); //6.【重要】指定要执行的sql语句的标识。 sql映射文件中的namespace + "." + 标签的id值// String sqlId = "com.md.dao.StudentDao"+"."+"selectStudents"; String sqlId = "com.md.dao.StudentDao.insertStudent"; //7.【重要】执行sql语句，通过sqlId找到语句 // 第一个参数是执行的sql语句，第二个是对象 int i = sqlSession.insert(sqlId,new Student(1004,"刘桑","ls@qq.com",18)); // 需要注意，mybatis默认不是自动提交事务，所以在写完insert、update、delete之后，手动的提交事务 sqlSession.commit(); //8.输出结果 System.out.println("执行insert影响的行数："+i); //9.关闭SqlSession对象 sqlSession.close(); }} |
需要注意，mybatis默认不是自动提交事务，所以在写完insert、update、delete之后，手动的提交事务
五、update
和上面的都差不多，就直接写主要的步骤
1. StudentDao 接口中增加方法
|
1
|
int updateStudent(Student student); |
2. StudentDao.xml 增加 sql 语句
|
1
2
3
|
<update id="updateStudent">update student set age = #{age} where id=#{id}</update> |
3. 增加测试方法
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//5. 创建保存数据的对象Student student = new Student();student.setId(1005);// 要修改的 idstudent.setAge(30); // 要修改的年龄值//6. 执行 更新 updateint rows = session.update("com.bjpowernode.dao.StudentDao.updateStudent",student);//7. 提交事务session.commit();System.out.println(" 修改记录的行数:"+rows);//8. 关闭 SqlSessionsession.close(); |
六、delete
1. StudentDao 接口中增加方法
|
1
|
int deleteStudent(int id); |
2. StudentDao.xml 增加 sql 语句
|
1
2
3
|
<delete id="deleteStudent">delete from student where id=#{studentId}</delete> |
3. 增加测试方法
|
1
2
3
4
5
6
7
8
9
10
|
//5. 删除的 idint id = 1001;//6. 执行删除 deleteint rows = session.delete("com.bjpowernode.dao.StudentDao.deleteStudent",id);//7. 提交事务session.commit();System.out.println(" 修改记录的行数:"+rows);//8. 关闭 SqlSessionsession.close(); |
总结
到此这篇关于搭建MyBatis开发环境及基本的CURD的文章就介绍到这了,更多相关搭建MyBatis开发环境及基本的CURD内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.cnblogs.com/mengd/p/13443162.html
