1. Meu Batis
MyBatis é uma camada de persistência baseada em java ORM (Object Relational Mapping)
A estrutura encapsula o jdbc internamente. Os desenvolvedores só precisam se concentrar na instrução SQL em si e não precisam lidar com processos complicados, como carregar drivers, criar conexões, criar instruções, fechar conexões e recursos.
MyBatis configura várias instruções sql para serem executadas por meio de xml ou anotações e gera a instrução sql final executada por meio de mapeamento entre objetos java e parâmetros dinâmicos sql. Finalmente, a estrutura mybatis executa sql e mapeia os resultados para objetos java. e retorna.
1. Código que não usa MyBatis
(1) Registrar motorista
(2) Obtenha conexão
(3) Obtenha o objeto de operação do banco de dados
(4) Executar instruções SQL
(5) Processar o conjunto de resultados da consulta
(6) Liberar recursos
Estes levam a
(1) Há muito código e baixa eficiência de desenvolvimento
(2) É necessário prestar atenção à criação e destruição de objetos Connection, Statement, 9ResultSet
(3) Os resultados da consulta ResultSet precisam ser encapsulados como List por você mesmo
(4) Existem códigos mais repetidos
(5) O código comercial e as operações de banco de dados são misturados.
String driver = "com.mysql.cj.jdbc.Driver";
String url = "jdbc:mysql://127.0.0.1:3306/mydb";
String user = "root";
String pwd = "123456";
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1、注册驱动（连接的数据库）
Class.forName(driver);
//2、获取连接
conn = DriverManager.getConnection(url,user,pwd);
//3、获取数据库操作对象（专门执行sql语句的对象）
stmt = conn.createStatement();
//4、执行SQL语句（DQL DML....）
String sql = "select empno,empname as name,sal from emp2 where empno=7369";
rs = stmt.executeQuery(sql);
//5、处理查询结果集（只有当第四步执行的是select语句的时候，才有处理查询结果集）
while (rs.next()){
/*
（1）下标取值；下标从 1 开始
*/
String empno = rs.getString(1);
String empname = rs.getString(2);
String sal = rs.getString(3);
System.out.println(empno + " " + empname + " " + sal);
/*
（2）数据类型取值
*/
int empno1 = rs.getInt(1);
String empname1 = rs.getString(2);
Double sal1 = rs.getDouble(3);
System.out.println(empno1 + " " + empname1 + " " + sal1);
/*
（3）字段名取值
*/
String empno2 = rs.getString("empno");
//如果执行的SQL语句中有别名，需要使用别名字段取值
String empname2 = rs.getString("name");
String sal2 = rs.getString("sal");
System.out.println(empno2 + " " + empname2 + " " + sal2);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
//6、释放资源；从小到大关闭
if (rs != null) {
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (stmt != null) {
try {
stmt.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
2. Use o código MyBatis
mybatis é MyBatis SQL Mapper Framework para Java (estrutura de mapeamento sql)
(1) mapeador sql: mapeamento sql
Mapeie uma linha de dados na tabela do banco de dados em um objeto java
Uma linha de dados pode ser considerada um objeto Java; operar esse objeto é equivalente a operar os dados na tabela
(2) Data Access Objects (DAOs): acesso a dados, realização de adições, exclusões, modificações e consultas no banco de dados
Estrutura MyBatis
[1] Fornece a capacidade de criar, destruir e fechar Connection, Statement, ResultSet e outros objetos
【2】 Fornece a capacidade de executar instruções SQL
[3] Fornece a capacidade de fazer loop de SQL e converter resultados de SQL em objetos Java e coleções de listas.
2. Primeiros passos com MyBatis SqlSession
Primeiro use a estrutura mybatis na forma de SqlSession
Primeiro, vamos configurar o armazém local do maven
1. Crie um novo usuário de tabela de banco de dados
CREATE TABLE `user` (
`user_id` int(10) NOT NULL COMMENT '用户名ID',
`user_name` varchar(100) DEFAULT NULL COMMENT '用户名',
`email` varchar(80) DEFAULT NULL COMMENT '用户邮箱',
`age` int(5) DEFAULT NULL COMMENT '年龄',
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;2.Configurar pom.xml
<?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>org.example</groupId>
<artifactId>maven-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<!-- <modules>-->
<!-- <module>untitled</module>-->
<!-- </modules>-->
<properties>
<!-- 源码编译 jdk 版本 -->
<maven.compiler.source>1.8</maven.compiler.source>
<!-- 运行代码的 jdk 版本 -->
<maven.compiler.target>1.8</maven.compiler.target>
<!-- 项目构建使用的编码，避免中文乱码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!--项目引入插件所需要的额外依赖 -->
<dependencies>
<!--参见dependencies/dependency元素 -->
<!-- 单元测试依赖 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- <dependency>-->
<!-- <groupId>org.junit.jupiter</groupId>-->
<!-- <artifactId>junit-jupiter</artifactId>-->
<!-- <version>RELEASE</version>-->
<!-- <scope>compile</scope>-->
<!-- </dependency>-->
<!-- json转换依赖-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.3</version>
</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>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/java</directory><!--所在的目录-->
<includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<!-- filtering 选项 false 不启用过滤器， *.property 已经起到过滤的作用了 -->
<filtering>false</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>16</source>
<target>16</target>
</configuration>
</plugin>
</plugins>
</build>
</project>3. Crie o usuário da classe de entidade java
package com.example.domain;
public class User {
private int userId;// 对应数据表User user_id
private String userName;// 对应数据表User user_name
private String email; // 对应数据表User email
private int age;// 对应数据表User age
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}4. Crie a interface dao da camada de persistência
UserDao.java
Usado para definir métodos de operação do banco de dados
package org.example.dao;
import org.example.domain.User;
import java.util.List;
/**
* 用户的持久层接口
* 继承该接口的类，实现接口中的方法，就可以实现对user表的增删改查
*/
public interface UserDao {
/**
* 查询user列表
* @param user 单个user用户 [入参是user对象]
* @return user的list
*/
List<User> selectUserList(User user); // 方法名和mapper.xml中的id值一致
/**
* 插入user
* @param user
* @return
*/
int insertUser(User user);// 方法名和mapper.xml中的id值一致
}A interface UserDao define dois métodos e as classes que herdam essa interface devem implementar esses dois métodos de interface.
Para os métodos nas duas interfaces acima, o parâmetro de entrada é um objeto de usuário da classe de entidade, ou seja, a etapa 3 anterior define uma linha de dados da tabela correspondente a um objeto java, e operar o objeto é operar a linha de dados em a tabela de dados.
5. Arquivo de mapeamento
Crie um arquivo de mapeamento SQL de arquivo de configuração usado por mybatis
Para escrever instruções SQL, geralmente uma tabela corresponde a um arquivo de mapeamento SQL, que é um arquivo xml.
arquivo de mapeamento sql (mapeador sql)
Escreva instruções SQL e mybatis será responsável por executar essas instruções SQL.
UserDao.xml
<?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">
<!--
sql映射文件（sql mapper）：编写SQL语句，mybatis负责执行这些SQL语句
1、指定约束文件
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
mybatis-3-mapper.dtd：约束文件名称
2、约束文件作用：限制，检查当前文件中出现的标签，属性必须符合mybatis的要求
3、<mapper>：当前文件根标签（必须的）
namespace：命名空间（唯一值，自定义字符串；要求使用dao接口的全限定名称）
全限定类名：就是类名全称，带包路径的用点隔开，如: java.lang.String
即全限定名 = 包名 + 类型
非限定类名也叫短名，就是我们平时说的类名，不带包的，如：String
4、数据库增删改查特定标签
<select>：查询，select语句
<update>：更新，update语句
<insert>：插入，insert语句
<delete>：删除，delete语句
-->
<mapper namespace="com.example.dao.UserDao">
<!--
<select>标签：查询操作
id：执行SQL语法的唯一标识，mybatis会根据这个id的值来找到要执行的SQL语句
可以自定义，一般要求使用接口中的方法名称
resultType：表示结果类型，SQL语句执行后得到ResultSet结果集，遍历这个结果集得到的Java对象类型
值写Java对象的全限定名称
-->
<select id="selectUserList" resultType="com.example.domain.User">
select user_Id,user_Name,email,age
from user
order by user_Id asc
</select>
<!--插入操作，字段名和Java实体类中字段保持一致-->
<insert id="insertUser">
insert into user values(#{userId},#{userName},#{email},#{age})
</insert>
</mapper>6. Crie o arquivo de configuração principal do mybatis
O arquivo de configuração principal fornece informações de conexão com o banco de dados e informações de localização do arquivo de mapeamento SQL . Existe um arquivo de configuração principal para cada projeto.
mybatis-config.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">
<!--
mybatis的主配置文件：主要定义了数据库的配置信息，SQL映射文件的位置
1、约束文件
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
mybatis-3-config.dtd：约束文件名称
2、configuration：根标签
-->
<configuration>
<!-- settings：mybatis全局行为 -->
<settings>
<!-- 设置mybatis输出日志 -->
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>
<!--
环境配置：数据库的连接信息
default：必须和某个environment的id值一样
告诉mybatis使用哪个数据库的连接信息（访问哪个数据库）
-->
<environments default="development">
<!--
environment：一个数据库的配置，环境
id：一个唯一值（可自定义，表示环境的名称）
-->
<environment id="development">
<!--
transactionManaer：mybatis的事务类型
type：JDBC（表示使用JDBC中的Connection对象的commit，rollback做事务处理）
-->
<transactionManager type="JDBC"/>
<!--
dataSource：表示数据源，连接数据库的
type：表述数据源的类型，POOLED表示使用连接池
-->
<dataSource type="POOLED">
<!--
driver, user, username, password 是固定的，不能自定义。
-->
<!-- 数据库驱动类名 -->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!-- 连接数据库的URL字符串 -->
<property name="url" value="jdbc:mysql://localhost:3306/mybatis_test"/>
<!-- 访问数据库的用户名 -->
<property name="username" value="root"/>
<!-- 访问数据库的密码 -->
<property name="password" value="lyc123456"/>
</dataSource>
</environment>
<!--表示线上的数据库，是项目真实使用的库-->
<environment id="online">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis_test"/>
<property name="username" value="root"/>
<property name="password" value="lyc123456"/>
</dataSource>
</environment>
</environments>
<!-- sql mapper（SQL映射文件）的位置 -->
<mappers>
<!--
一个mapper标签指定一个文件的位置
从类路径开始的路径信息（target/classes）类路径
-->
<mapper resource="org/mybatis/example/UserDao.xml"/>
</mappers>
</configuration>Cada tabela será configurada com um mapeador, que é um arquivo xml.
7. Crie uma classe de teste usando mybatis
Acesse o banco de dados através do mybatis
package org.example;
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.example.domain.User;
import org.example.utils.MyBatisUtil;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class TestMyBatis {
/**
* 查询user列表
*/
@Test
public void testSelectUserList(){
try {
//访问mybatis读取user数据
//1、定义mybatis主配置文件名称，从类路径的根开始（target/clasess）
String config = "mybatis-config.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 = "org.example.dao.UserDao.selectUserList";
//7、执行sql语句，通过sqlId找到语句
List<User> userList = sqlSession.selectList(sqlId);
//8、输出结果
for (User user:userList){
System.out.println("查询用户="+user);
}
//9、关闭SQLSession对象
sqlSession.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 查询user列表
*/
@Test
public void testMyBatisUtil(){
try {
SqlSession sqlSession = MyBatisUtil.getSqlSession();
String sqlId = "com.example.dao.UserDao.selectUserList";
//7、执行sql语句，通过sqlId找到语句
List<User> userList = sqlSession.selectList(sqlId);
//8、输出结果
for (User user:userList){
System.out.println("查询用户="+user);
}
//9、关闭SQLSession对象
sqlSession.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 插入
*/
@Test
public void testInsertUser(){
SqlSession sqlSession = null;
try {
sqlSession = MyBatisUtil.getSqlSession();
String sqlId = "com.mycompany.dao.UserDao.insertUser";
//7、执行sql语句，通过sqlId找到语句
User user = new User();
user.setUserId(5);
user.setUserName("zhangfei");
user.setEmail("[email protected]");
user.setAge(16);
int nums = sqlSession.insert(sqlId,user);
//mybatis默认不是自动提交事务的， 所以在insert ，update ，delete后要手工提交事务
sqlSession.commit();
System.out.println("更新用户条数="+nums);
//9、关闭SQLSession对象
sqlSession.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
7. Extraia SqlSession na classe de ferramenta MyBatisUtil
MeuBatisUtil.java
package org.example.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 {
public MyBatisUtil() {
}
public static SqlSession getSqlSession() throws IOException {
String config = "mybatis-config.xml";
InputStream ins = Resources.getResourceAsStream(config);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(ins);
SqlSession sqlSession = factory.openSession();
return sqlSession;
}
}O uso subsequente de sqlSession instancia esta classe de ferramenta Classe MyBatisUtils
（1）Recursos
Uma classe em mybatis, responsável por ler o arquivo de configuração principal
// 1、定义mybatis主配置文件名称，从类路径的根开始（target/clasess）
String config = "mybatis-config.xml";
// 2、读取config表示的文件
InputStream in = Resources.getResourceAsStream(config);(2) SqlSessionFactoryBuilder
Criar objeto SqlSessionFactory
// 3、创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 4、创建SqlSessionFactory对象
SqlSessionFactory factory = builder.build(in);Catálogo completo
10. Problemas comuns de relatório de erros
(1) O arquivo mybatis-config.xml ou os arquivos de mapeamento dao e SQL correspondentes não podem ser encontrados
Três soluções:
【1】Maven limpa e depois compila, o diretório de destino será regenerado
【2】Reconstrua o projeto e execute-o novamente, o arquivo mybatis-config.xml aparecerá no diretório de destino.
[3] Se os dois métodos acima não funcionarem, copie diretamente o arquivo src/resources/mybatis-config.xml para o diretório target/classes manualmente.
(2) Os métodos da interface dao devem ser consistentes com o id no arquivo de mapeamento dao.xml (ponto chave)
(3) Os nomes das colunas na tabela do banco de dados devem ser consistentes com os campos na classe de entidade Java e os campos de atributos no arquivo de mapeamento dao.xml (pontos-chave)
11. junit: teste de unidade
junit: teste unitário, uma biblioteca de ferramentas usada para métodos de teste. Unidade: especifica um método. Existem muitos métodos em uma classe e um método é chamado de unidade.
Use testes unitários
(1) Necessidade de adicionar dependência junit
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>(2) Criar classe de teste
Crie uma classe no diretório src/test/java
(3) Criar métodos de teste
【1】método público
【2】Nenhum valor de retorno nulo
【3】Personalize o nome do método. O nome recomendado é teste + nome do método de teste.
【4】O método não possui parâmetros
【5】Adicione @Test acima do método, o método pode ser executado separadamente; não há necessidade de usar o método principal