在前面介绍了原生JDBC的缺陷，那么对于弥补相应缺陷的框架：就是目前最流行的————Mybatis框架
Mybatis框架介绍及其入门
Mybatis框架介绍
Mybatis原本是Apache软件基金会的一个开源项目叫做iBatis，2010年这个项目由Apache迁移到了goole code管理才改名为Mybatis，2013年又迁移到了GitHub。
#Github代码托管平台：就是互联网网站，上面放东西的
注意：如果以后想从事开发工作的话，在招聘信息和面试时候可能问你会ibatis吗 ？记得它就是Mybatis
Mybatis是一个优秀的持久层框架（Dao层框架），它是对JDBC的封装，使得开发者只需要关注Sql语句（业务）本身即可，无需开发者处理加载驱动、获取连接、创建Statement等繁琐的过程。
Mybatis最大的特点是把Sql语句写在XML配置文件当中。而且Mybatis执行完Sql语句之后可以以对象形式返回（实体类/实体类集合等）
ORM：Object/Relation Mapping 对象/关系映射
ORM思想：将数据库中的关系数据表映射为JAVA中的对象，把对数据表的操作转换为对对象的操作，实现面向对象编程。因此ORM的目的是使得开发人员以面向对象的思想来操作数据库
Hibernate框架是一个全自动的ORM持久层框架，只需要编写POJO，在xml中定义好Pojo属性和数据表字段的映射/对应关系，就可以在java中实现类似 insert(User)的操作。Sql语句都不用写。但是因为性能等问题，市场占有率越来越低
Mybatis框架是一个半自动的ORM持久层框架，也可以在Java中实现类似 insert(User)的操作最终操作数据库，但是需要我们自己写Sql语句。Mybatis是目前比较流行的Dao层框架
Mybatis入门
首先我们创建一个java项目，博主是用Idea和配置Maven进行管理
要想使用Mybatis，就需要导入Mybatis的jar包，因为这里是使用Maven进行管理项目的，所以就直接使用依赖将其导入了。
其次还需要一个连接数据库的jar包，还需要一个进行测试类的jar包，还有方便实体类搭建的jar包都一并导入了：
<?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.yht</groupId>
<artifactId>mydatis01</artifactId>
<version>1.0.0</version>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.20</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
现在，准备工作就做完了，我们的项目中已经导入了Mybatis的jar包，然后进行Mybatis的核心配置：
<?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文件来保存进行数据库连接的驱动，url，用户名和方法
里面的值为：
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///dbmaven?serverTimezone=UTC&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=
因为博主的数据库是跳过密码登录的，所以这里没有填写，其他的配置也都按你自己的数据库信息来进行配置
其实下面相应配置的地方也可以直接写上相应的字符串，用这个配置文件看起来是多次一举，但是可以观察到我
url的配置后面多了两个属性，第一个是解决在项目运行中的一个BUG，会因为时区的错误来什么也进行不了，
具体原因还没有搞清楚，后面的是解决在程序中向数据库中插入或者更改数据，中文乱码的问题，如果出现乱码就加上
如果没有出现乱码的话也可以不加，因为博主在运行的过程中出现了两个BUG,导致需要加上两个参数，但是这个配置文件中
url的路径中不允许有&字符的出现，所以不得已进行创建了又一个配置文件，来解决这个问题。
-->
<properties resource="jdbc.properties" />
<!-- 下面这几行意义都比较重要，所以这里讲不清楚，所以暂时可以直接复制 -->
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<!-- 这下面就是连接数据库的语句，其中value属性中也可以直接把之前连接jdbc相应的字符串写进去
博主是因为出现了问题才进行分开配置的操作，这里需要重新导入一遍参数
${}里面加上key参数，就是获取上面导入的properties文件的属性的格式-->
<property name="driver" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>
<!-- 上面是必要的连接数据库的配置
下面的这个是进行连接一个mapper配置文件
上面介绍到，Mybatis的最大特点就是SQL语句和Java程序分开存储了
而这里链接的文件，就是存储SQL语句的文件，注意这里是用/来分隔文件夹的-->
<mappers>
<mapper resource="com/yht/mapper/EmpMapper.xml"/>
</mappers>
</configuration>
我们进行创建的是Maven管理的项目，上面的配置文件和jdbc.properties文件都放在main下的resources文件夹下：
然后上面配置的mapper配置文件最好是放在一个文件夹下，因为我们在以后的开发或者学习过程中可能要对很多的表做不同的mapper，所以我们最好在最开始就养好习惯，创建的resorces文件夹下：
上面对com.yht.bean包创建的时候要一个包一个包的进行创建，就是先创建com,然后创建yht,然后再创建mapper，然后再创建mapper文件
然后我们对mapper文件进行配置：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--上面的为声明，可以直接照抄-->
<!--下面一行是mapper的根节点，所有的查询语句都放在里面，名字可以像下面的一样（这里是为mapper开发模式做铺垫）
如果用dao开发模式的话暂时还是可以随意起名字，不过在后面实现类进行调用的时候要进行对应-->
<mapper namespace="com.yht.mapper.EmpMapper">
<!-- 在mapper中，可以定义的根节点直接就是和查询语句的类型相对应，
id属性值，是这条语句的一个名字，如果后面使用我们之前经常使用dao模式的话，这里名字还是可以随意写的，不过在后面调用的时候进行对应就好
parameterType属性，是传入参数的属性，比如我们这条查询语句的作用是根据id值查出这条语句的信息，那么需要一个id值，这个id值是int型的，所以这里就是int型的
resultType属性，这条语句执行结束后会返回一条数据，在之前我们是用一个结果集然后获取出来值才能够使用，这里因为框架的强大，可以直接返回一个对象
-->
<select id="findEmpById" parameterType="int" resultType="com.yht.bean.Emp">
select id, name, age,birthday, salary FROM emp WHERE id = #{id}
</select>
<select id="findAllEmp" resultType="com.yht.bean.Emp">
select id, name, age,birthday, salary FROM emp
</select>
<insert id="insertEmp" parameterType="com.yht.bean.Emp">
insert into emp (name,age,birthday,salary) values (#{name},#{age},#{birthday},#{salary})
</insert>
<update id="updateEmp" parameterType="com.yht.bean.Emp">
update emp set name = #{name},age = #{age},salary = #{salary} where id = #{id}
</update>
<delete id="deleteEmp" parameterType="int">
delete from emp where id = #{id}
</delete>
</mapper>
回忆一下之前学习JDBC，或者后面的DButils，都有一串连接数据库的语句，当然，Mybatis也不例外，因为以后每个方法都要连接，所以像之前一样，直接把连接的语句封装在一个工具类中：
package com.yht.utils;
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 {
//设置一个静态变量，方便下面使用
private static SqlSessionFactory factory = null;
static {
//这里是连接核心的配置文件
String resource = "mybatis-config.xml";
//设置一个流，下面会用到
InputStream inputStream = null;
try {
//这里就是会将配置文件中的内容转化为流进行传输
inputStream = Resources.getResourceAsStream(resource);
} catch (IOException e) {
e.printStackTrace();
}
//这里是获取一个连接池
factory = new SqlSessionFactoryBuilder().build(inputStream);
}
public static SqlSession getSession(){
//这里相当于获得一个连接
return factory.openSession();
}
}
到了这里，算是准备工作进行完成了。我们来进行其他组件的布置：
这里介绍两种开发模式：
一种是我们之前一直使用的Dao模式，构造的结构为：
Bean：
package com.yht.bean;
import lombok.*;
import java.math.BigDecimal;
import java.util.Date;
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Emp {
private int id ;
private String name ;
private int age ;
private Date birthday ;
private BigDecimal salary ;
}
DAO
package com.yht.dao;
import com.yht.bean.Emp;
import java.util.List;
public interface EmpDao {
Emp findEmpById(int id);
List<Emp> findAllEmp();
void insertEmp(Emp emp);
void updateEmp(Emp emp);
void deleteEmp(int id);
}
Impl
package com.yht.dao.impl;
import com.yht.bean.Emp;
import com.yht.dao.EmpDao;
import com.yht.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import java.util.ArrayList;
import java.util.List;
public class EmpDaoImpl implements EmpDao {
public Emp findEmpById(int id){
SqlSession session = MybatisUtil.getSession();
//这里调用的方法就是针对返回条语句的方法，然后写入相应的方法，和参数
Emp emp = session.selectOne("com.yht.mapper.EmpMapper.findEmpById",id);
//关闭sqlSession
session.close();
return emp;
}
public List<Emp> findAllEmp() {
SqlSession session = MybatisUtil.getSession();
List<Emp> list = new ArrayList();
list = session.selectList("com.yht.mapper.EmpMapper.findAllEmp");
session.close();
return list;
}
public void insertEmp(Emp emp) {
SqlSession session = MybatisUtil.getSession();
session.insert("com.yht.mapper.EmpMapper.insertEmp",emp);
session.commit();
session.close();
}
public void updateEmp(Emp emp) {
SqlSession session = MybatisUtil.getSession();
session.update("com.yht.mapper.EmpMapper.updateEmp",emp);
session.commit();
session.close();
}
public void deleteEmp(int id) {
SqlSession session = MybatisUtil.getSession();
session.delete("com.yht.mapper.EmpMapper.deleteEmp",id);
session.commit();
session.close();
}
}
test
package com.yht.test;
import com.xj.bean.Emp;
import com.xj.dao.EmpDao;
import com.xj.dao.impl.EmpDaoImpl;
import org.junit.Test;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
public class testMyBatisTest {
@Test
public void testfindEmpById(){
EmployeeDao dao = new EmployeeDaoImpl();
Employee employee = dao.findEmpById(1);
System.out.println(employee);
}
@Test
public void testfindEmpAll(){
EmpDao dao = new EmpDaoImpl();
List<Emp> list = dao.findAllEmp();
for(Emp emp:list){
System.out.println(emp);
}
}
@Test
public void testinsertEmp(){
EmpDao dao = new EmpDaoImpl();
Emp emp = new Emp();
emp .setName("哒哒哒");
emp .setAge(45);
emp .setBirthday(new Date());
emp .setSalary(new BigDecimal(4444));
dao.insertEmp(emp );
}
@Test
public void testdeleteEmp(){
EmpDao dao = new EmpDaoImpl();
dao.deleteEmpById(1);
}
@Test
public void testupdateEmp(){
EmpDao dao = new EmpDaoImpl();
Emp employee = new Emp();
emp.setId(2);
emp.setName("得得得");
emp.setAge(12);
emp.setBirthday(new Date());
emp.setSalary(new BigDecimal(5555));
dao.updateEmp(employee);
}
}
我们观察上面的代码，发现DAO和Impl的作用和功能虽然也很完善，但是对其代码有限制性，但是其中重复的代码太多了，真正有用的代码只有那一句SQL查询语句。
所以我们换另外一种开发模式：mapper模式。
这种模式代码十分简单，只需要在之前dao相同的位置创建一个mapper文件夹，然后创建一个mapper借口，然后把之前dao里面的代码粘贴过去就行了。而且不用再去写实现类。
但是mapper模式下代码简单了，要求也就变得严格了，需要满足下面四个规范：
- sql映射文件的namespace必须和mapper接口的全限定类名保持一致
- mapper接口的接口方法名必须和xml中的sql语句id保持一致
- mapper接口的接口方法形参类型必须和sql语句的输入参数类型保持一致
- mapper接口的接口方法返回类型必须和sql语句的resultType保持一致
注意：全限定类名=包名+类名（比如：com.yht.bean.Emp）
原始的Dao形式和Mapper开发方式在企业中都很常见，推荐使用Mapper开发模式
相比Dao模式，获取连接的操作要放在测试类中：
package com.yht.test;
import com.yht.bean.Emp;
import com.yht.mapper.EmpMapper;
import com.yht.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
public class MybatisTest {
@Test
public void testGetSession(){
SqlSession session = MybatisUtil.getSession();
}
@Test
public void testFindEmpById(){
Emp emp = null;
SqlSession sqlSession = MybatisUtil.getSession();
//这里需要获取一个class文件来对应其中的方法
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
try {
//这里直接通过文件中语句的id值进行调用方法。
emp = empMapper.findEmpById(1);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(emp);
}
@Test
public void testFindAllEmp(){
List<Emp> list = null;
SqlSession sqlSession = MybatisUtil.getSession();
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
list = empMapper.findAllEmp();
for(Emp emp : list){
System.out.println(emp);
}
}
@Test
public void testInsertEmp(){
Emp emp = new Emp();
emp.setName("艾斯");
emp.setAge(100);
emp.setBirthday(new Date());
emp.setSalary(new BigDecimal(1000.0));
SqlSession sqlSession = MybatisUtil.getSession();
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
empMapper.insertEmp(emp);
sqlSession.commit();
}
@Test
public void testUpdateEmp(){
Emp emp = new Emp();
emp.setId(14);
emp.setName("弗兰奇");
emp.setSalary(new BigDecimal(10000));
emp.setAge(30);
SqlSession sqlSession = MybatisUtil.getSession();
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
empMapper.updateEmp(emp);
sqlSession.commit();
}
@Test
public void testDeleteEmp(){
SqlSession sqlSession = MybatisUtil.getSession();
EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
empMapper.deleteEmp(14);
sqlSession.commit();
}
}
来源：CSDN
作者：好吃的都给你呀
链接：https://blog.csdn.net/qq_39565202/article/details/103602683