0
点赞
收藏
分享

微信扫一扫

04 MyBati数据操作

天际孤狼 2022-01-20 阅读 44
springjavaintellij-idea

1 初识MyBatis

1.1 MyBatis框架简介

MyBatis框架可以简化数据库编程！MyBatis底层封装的是JDBC，使用起来比JDBC大大简化。

在使用MyBatis实现数据库编程时，只需要定义每个数据操作功能的抽象方法，并配置这个抽象方法对应的SQL语句即可！

当然，MyBatis框架还实现了数据库编程的其他细节，例如对查询结果的缓存等等。

1.2 导入SSM组件

MyBatis经常和Spring，Spring MVC一起使用，简称为SSM框架。

创建Maven Web项目，添加web.xml，目标服务器运行环境，以及Spring MVC依赖。

在项目中使用MyBatis需要在pom.xml中添加多项依赖，首先应该添加MyBatis依赖：

<!-- MyBatis框架-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

MyBatis本身是可以独立使用的，但是推荐使用Spring框架一起使用，所以，还需要添加mybatis-spring依赖：

<!-- MyBatis整合spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>

整合后，框架的底层实现需要使用到spring-jdbc的依赖：

<!-- spring-jdbc依赖，必须和其他spring依赖使用完全相同的版本 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.14</version>
</dependency>

注意：同一个项目中添加多个spring为前缀的依赖，这些依赖必须使用相同的版本！！

由于本次将使用MySql数据库，所以还需要添加MySql数据库连接的mysql-connector-java依赖：

<!-- 连接mysql数据库的依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>

然后，还需要添加数据库连接池的druid的依赖：

<!-- 数据库连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.6</version>
</dependency>

最后，在编程时，为了及时检测代码，还应该添加单元测试junit的依赖：

<!-- 单元测试的依赖 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
</dependency>

所以，项目中需要添加的完整的依赖代码是：

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>cn.tedu</groupId>
	<artifactId>MyBatis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<properties>
		<!-- 设置 JDK 版本为 1.8 -->
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.source>1.8</maven.compiler.source>
		<!-- 设置编码为 UTF-8 -->
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8
		</project.reporting.outputEncoding>
		<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
	</properties>
	<dependencies>
		<!-- SpringMVC -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.2.2.RELEASE</version>
		</dependency>
		<!-- Spring JDBC依赖，必须与其它Spring依赖使用完全相同的版本 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.2.2.RELEASE</version>
		</dependency>
		<!-- Mybatis框架 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.0</version>
		</dependency>
		<!-- MyBatis整合Spring -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>2.0.1</version>
		</dependency>
		<!-- Thymeleaf -->
		<dependency>
			<groupId>org.thymeleaf</groupId>
			<artifactId>thymeleaf</artifactId>
			<version>3.0.11.RELEASE</version>
		</dependency>
		<!-- Thymeleaf整合Spring -->
		<dependency>
			<groupId>org.thymeleaf</groupId>
			<artifactId>thymeleaf-spring5</artifactId>
			<version>3.0.11.RELEASE</version>
		</dependency>
		<!-- 连接MySQL数据库的依赖 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.15</version>
		</dependency>
		<!-- 数据库连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.21</version>
		</dependency>
		<!-- 单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.13</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.25</version>
		</dependency>
	</dependencies>
</project>

1.3 配置MyBatis数据库连接池

MyBatis是数据库访问框架，必须连接到数据库才能使用其强大的功能，所以要先配置数据库连接才行。

首先创建数据库链接配置文件：resources/jdbc.properties

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mysql?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
db.username=root
db.password=root
db.maxActive=10
db.initialSize=2

创建Spring配置类，配置数据库连接池：

package cn.tedu.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration
@PropertySource("classpath:jdbc.properties")
public class MyBatisConfig {
	
	@Bean
	public DataSource dataSource (
			@Value("${db.driver}")String driver,
			@Value("${db.url}")String url,
			@Value("${db.username}")String username,
			@Value("${db.password}")String password,
			@Value("${db.maxActive}")int maxActive,
			@Value("${db.initialSize}")int initialSize) {
			DruidDataSource ds = new DruidDataSource();
			ds.setDriverClassName(driver);
			ds.setUrl(url);
			ds.setUsername(username);
			ds.setPassword(password);
			ds.setMaxActive(maxActive);
			ds.setInitialSize(initialSize);
			return ds;
	}
	
}

测试数据库连接池：

package cn.tedu.test;


import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import javax.sql.DataSource;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import cn.tedu.config.MyBatisConfig;

public class TestCase {
	
	AnnotationConfigApplicationContext ctx;
	
	@Before
	public void init() {
		ctx = new AnnotationConfigApplicationContext(MyBatisConfig.class);
	}

	@After
	public void destroy() {
		ctx.close();
	}
	
	@Test
	public void testDataSource() {
		DataSource ds = ctx.getBean("dataSource",DataSource.class);
		String sql = "SELECT 'hELLO wORLD!'";
		try (Connection conn = ds.getConnection()){
			Statement st = conn.createStatement();
			ResultSet rs = st.executeQuery(sql);
			while (rs.next()) {
				System.out.println(rs.getString(1));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

1.4 MyBatis Hello World

按照惯例，第一次使用API或者框架都要写一个最小功能的案例“Hello World”，下面就使用MyBatis实现一个"Hello World"。

首先声明数据库访问接口DemoMapper,MyBatis会自动的创建这个接口的具体子类实现例，利用这个实例就可以访问数据库了：

package cn.tedu.mapper;

import org.apache.ibatis.annotations.Select;

public interface DemoMapper {
	
	@Select("Select 'Hello World!'")
	String hello();
			
}

然后在Spring配置类中配置Mapper接口扫描功能：

package cn.tedu.config;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import com.alibaba.druid.pool.DruidDataSource;

import javassist.expr.NewArray;

@Configuration
@PropertySource("classpath:jdbc.properties")
@MapperScan("cn.tedu.mapper")
public class MyBatisConfig {
	
	@Bean
	public DataSource dataSource (
			@Value("${db.driver}")String driver,
			@Value("${db.url}")String url,
			@Value("${db.username}")String username,
			@Value("${db.password}")String password,
			@Value("${db.maxActive}")int maxActive,
			@Value("${db.initialSize}")int initialSize) {
			DruidDataSource ds = new DruidDataSource();
			ds.setDriverClassName(driver);
			ds.setUrl(url);
			ds.setUsername(username);
			ds.setPassword(password);
			ds.setMaxActive(maxActive);
			ds.setInitialSize(initialSize);
			return ds;
	}
	
	@Bean
	public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		return bean.getObject();
	}
	
}

上述配置中的SqlSessionFactory是MyBatis 核心功能的工厂，需要将数据库连接池dataSource注入给它，这样MyBatis才能正确连接到数据库。

配置@MapperScan(basePackages = “cn.tedu.mapper”)的目的是自动查找DemoMapper接口，并且自动创建DemoMapper接口实现类的实例，这个功能特别好，这样就可以之间使用接口中的功能。

利用JUnit测试：

	@Test
	public void testSqlSessionFactory() {
		SqlSessionFactory factory = ctx.getBean("sqlSessionFactory",SqlSessionFactory.class);
		System.out.println(factory);
	}
	
	@Test
	public void testHelloWorld() {
		DemoMapper mapper = ctx.getBean("demoMapper",DemoMapper.class);
		String str = mapper.hello();
		System.out.println(str);
	}

测试结果：
testSqlSessionFactory运行结果：
在这里插入图片描述

testHelloWorld运行结果：
在这里插入图片描述

这个测试结果说明Spring成功的创建了SqlSessionFactory对象和demoMapper对象，并且成功访问了数据库，得到查询的结果。
在这里插入图片描述

运行原理：
在DemoMapper接口中抽象方法hello前面标注了@Select注解，这个注解为hello方法声明了SQL语句。MyBatis会自动处理这个注解，这个注解为hello方法声明了SQL语句。MyBatis会自动处理这个注解：在调用hello方法时候，MyBatis会自动向数据库发送注解中的SQL语句SELECT “Hello World”,接着数据库执行SQL返回 “Hello World”，MyBatis还会自动的将SQL返回结果作为hello方法的返回值。

2 利用MyBatis实现数据表CRUD操作

2.1 初始化数据库

MyBatis用于操作数据库，为了便于演示MyBatis强大功能，先在MySql中初始化一套数据表。

在MySql中创建名为tedu_ums的数据库，并使用这个数据库：

CREATE DATABASE tedu_ums;
USE tedu_ums;

在以上数据库中创建名为t_user的数据表，该数据表至少包含：用户id(id)，用户名（username)，密码(password)，年龄(age)，手机号码(phone)，邮箱(email)：

CREATE TABLE t_user(
	id INT(11) AUTO_INCREMENT COMMENT '用户id',
	username VARCHAR(20) UNIQUE NOT NULL COMMENT '用户名',
	PASSWORD VARCHAR(20) NOT NULL COMMENT '密码',
	age INT COMMENT '年龄',
	phone VARCHAR(20) COMMENT '手机号码',
	email VARCHAR(20) COMMENT '电子邮箱',
	PRIMARY KEY (id)
	) DEFAULT CHARSET=utf8;

向表中插入不少于10条数据：

insert into t_user (username,password,phone,age,email) values
('Frank01','1234','18800000001',21,'Frank01@163.com'),
('Frank02','1234','18800000002',22,'Frank02@163.com'),
('Frank03','1234','18800000003',23,'Frank03@163.com'),
('Frank04','1234','18800000004',24,'Frank04@163.com'),
('Frank05','1234','18800000005',25,'Frank05@163.com'),
('Frank06','1234','18800000006',26,'Frank06@163.com'),
('Frank07','1234','18800000007',27,'Frank07@163.com'),
('Frank08','1234','18800000008',28,'Frank08@163.com'),
('Frank09','1234','18800000019',29,'Frank09@163.com'),
('Frank10','1234','18800000010',30,'Frank10@163.com'),
('Frank11','1234','18800000011',31,'Frank11@163.com'),
('Frank12','1234','18800000012',32,'Frank12@163.com'),
('Frank13','1234','18800000013',33,'Frank13@163.com'),
('Frank14','1234','18800000014',34,'Frank14@163.com'),
('Frank15','1234','18800000015',35,'Frank15@163.com'),
('Frank16','1234','18800000016',36,'Frank16@163.com'),
('Frank17','1234','18800000017',37,'Frank17@163.com'),
('Frank18','1234','18800000018',38,'Frank18@163.com'),
('Frank19','1234','18800000019',39,'Frank19@163.com'),
('Frank20','1234','18800000020',40,'Frank20@163.com');

测试：
在这里插入图片描述

更新数据库连接参数，将resources/jdbc.properties中数据库名从mysql改为tedu_ums：

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/tedu_ums?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
db.username=root
db.password=root
db.maxActive=10
db.initialSize=2

2.2 查询功能

MyBatis会自动的将数据库的信息加载到JavaBean对象中，为了测试这个功能，就需要定要一个JavaBean类型User，这个User类型的数据结构与数据库t_user表的结构一致。

在cn.tedu.entity包下创建User类，并且根据t_user数据表的字段来设计User类中的属性：

package cn.tedu.entity;

import java.io.Serializable;

public class User implements Serializable{

	private Integer id;
	private String username;
	private String password;
	private Integer age;
	private String phone;
	private String email;
	
	public User () {
		
	}

	public User(Integer id, String username, String password, Integer age, String phone, String email) {
		super();
		this.id = id;
		this.username = username;
		this.password = password;
		this.age = age;
		this.phone = phone;
		this.email = email;
	}

	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 Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", password=" + password + ", age=" + age + ", phone="
				+ phone + ", email=" + email + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}
}

声明数据库访问接口UserMapper，在接口中声明数据访问方法，这个接口并不需要实现，MyBatis最强大的功能就是自动实现这个接口，并且实现相应的功能。

在UserMapper接口中设计一个根据用户的ID查询一个用户信息的方法findUserById，参数就是用户的主键ID：

package cn.tedu.mapper;

import org.apache.ibatis.annotations.Select;

import cn.tedu.entity.User;

public interface UserMapper {

	/*
	 *	根据id查询一个用户信息
	 */	
	
	@Select("SELECT id,username,password,age,phone,email FROM t_user Where id = #{id}")
	User findUserById(Integer id);
	
}

利用JUnit测试：

	@Test
	public void testFindUserById() {
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		User user = mapper.findUserById(1);
		System.out.println(user);
	}

测试结果：
在这里插入图片描述

这个测试结果说明使用userMapper对象的findUserById方法可以查询数据库，并且成功得到查询结果。原理是MyBatis利用JDBC查询数据库，并将查询结果映射到User对象属性，然后将User对象作为findUserById方法结果返回。也就是需要写出接口方法和SQL语句就能够访问数据库了。
在这里插入图片描述

2.3 查询多条数据

如果有这样的需求：

SELECT id,username,password,age,phone,email FROM T_USER

显然查询结果应该是这些内容：
在这里插入图片描述

然后怎么使用MyBatis映射查询结果呢？查询单条会了，查询多条也不难，只需要将方法返回值改成集合即可：

@Select ("SELECT id,username,password,age,phone,email FROM t_user")
List<User> findAllUser();

MyBatis会将SQL查询结果的每行存储到一个User对象，然后将全部User对象存储返回值List中，遍历List集合就能得到数据库查询的结果。
在这里插入图片描述

测试：

	@Test
	public void testFindAllUser() {
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		List<User> list = mapper.findAllUser();
		list.forEach(user -> System.out.println(user));
	}

测试结果：
在这里插入图片描述

2.4 插入功能

插入功能SQL语句

INSERT INTO t_user (username,password,age,phone,email)
VALUES (?, ?, ?, ?, ?)

然后将SQL语句中的参数？替换为#{}占位，并且使#{}中的名字于User对象的属性名一致：

INSERT INTO t_user (username,password,age,phone,email)
VALUES (#{username}, #{password}, #{age}, #{phone}, #{email})

最后在UserMapper接口中声明抽象方法，使用@Insert映射SQL语句于方法的对应关系：

@Insert("INSERT INTO t_user (username,password,age,phone,email) VALUES (#{username}, #{password}, #{age}, #{phone}, #{email})")
Integer insertUser(User user);

MyBatis执行时候就会自动读取参数User的属性填充到对应占位符号#{}。比如会读取User的username属性填充到#{username}的位置，按照这个规则执行SQL就可以将User对象中的数据存储到数据库中。方法返回值是整数表示更新行的数量，如果是1就表示更新了1行。

原理：
在这里插入图片描述

测试案例：

	@Test
	public void testInsertUser() {
		User user = new User(null,"蟑螂恶霸","123456",17,"13131313131","13131313131@163.com");
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		Integer n = mapper.insertUser(user);
		System.out.println(n);	
	}

测试结果：
返回1表示有一天记录被更改了

在这里插入图片描述

上述案例中User对象的ID插入之后也是null的：

	@Test
	public void testInsertUser() {
		User user = new User(null,"蝎子莱莱","123456",17,"13131313131","13131313131@163.com");
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		Integer n = mapper.insertUser(user);
		System.out.println(n);	
		System.out.println(user);
	}

在这里插入图片描述

如果希望插入以后获得插入的ID，则增加一个@Option注解就可以，其中keyProperty = "id"中的id是User的id属性：

@Insert("INSERT INTO t_user (username,password,age,phone,email) VALUES (#{username}, #{password}, #{age}, #{phone}, #{email})")
@Options(useGeneratedKeys = true,keyProperty = "id")
Integer insertUser(User user);

测试结果：
在这里插入图片描述因为主键设置为username，所以username不能重复，不然会插入失败

2.5 更新功能

如果要实现根据ID更新一行全部列数据其SQL如下：

UPDATE t_user
	SET username=?, password=?, age=?, phone=?, email=? 
	WHERE id=？

与插入功能类似，先将？全部替换为占位符：

UPDATE t_user
	SET username=#{username}, password=#{password}, age=#{age}, phone=#{phone}, email=#{email} 
	WHERE id=#{id}

在接口方法上使用@Update声明更新语句，就可以完成更新功能。更新过程中的数据绑定都是自动完成的，返回值如果是大于1表示成功更新了几行数据，返回0表示更新失败。如下方法是根据ID更新一行的功能：

	@Update("UPDATE t_user "
			+ "SET username=#{username}, password=#{password}, age=#{age}, phone=#{phone}, email=#{email} "
			+ "WHERE id=#{id}")
	int updateUser(User user);

测试案例：返回1表示更新了一行

	@Test
	public void testUpdataUser() {
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		User user = mapper.findUserById(2);
		user.setAge(56);
		int n = mapper.updateUser(user);
		System.out.println(n);
		
	}

在数据库中检查更新结果：
在这里插入图片描述

2.6 抽象方法中使用多个参数的问题

假设需要实现”将id=？的用户邮箱改为？“，则需要执行的SQL语句大致是：

UPDATE t_user SET email=? WHERE id = ?

由于以上SQL语句中有2个参数，所以在设计抽象方法时，抽象方法的参数列表中应该也有2个参数，例如：

@Update("UPDATE t_user SET email=? WHERE id = ?")
Integer updateEmailById(Integer id,String email);

然后，编写并执行单元测试：

	@Test
	public void testUpdateEmailById() {
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		int n = mapper.updateEmailById("kabuda@163.com", 25);
		System.out.println(n);
	}

以上代码执行时会出现错误：
在这里插入图片描述

也就是说，在调用抽象方法时，给出了2个参数的值，分别是id的值和email的值，这2个值在MyBatis处理时，参数名称其实分别是arg0和arg1，或者，使用param1和param2也可以访问到这俩个参数！

关于以上问题，其根本原因在于Java语言源代码.java文件在执行之前，需要被编译为.class字节码文件，在这个编译过程中，如果没有特殊的干预的情况下，所有局部变量的变量名都是不会被保存的，所以即使在设计抽象方法时，使用了id，email这样的参数名，其实，在最终运行的.class文件中，根本就没有这样的名称。

当抽象方法的参数只有一个时，MyBatis会自动的使用唯一的那一个参数，所以在配置SQL映射时，使用的#{}占位符中的名称根本就不重要！在开发时，推荐使用规范的名称，但是从代码是否可以运行的角度来说，这个占位符写什么都不重要。

在MyBatis的处理过程中，可以根据arg或param作为前缀，按照顺序来确定参数的值，所以，使用第1个参数时，可以使用arg0或param1作为名称，第2个可以使用arg1或param2作为名称，如果有更多参数，顺序编号即可，序号可惨开抽象方法的声明。

当然，在配置SQL映射时，使用arg0，arg1或param1，param2这样的名称，并不利用代码的阅读和理解，MyBatis框架提供了@Param注解，可以在抽象方法的参数列表中，在每个参数之前添加该注解，并在注解中配置参数的名称：

@Update("UPDATE t_user SET email=#{email} WHERE id = #{id}")
Integer updateEmailById(
@Param("id") Integer id,
@Param("email") String email);

后续，在配置SQL映射时，使用的#{}格式的占位符中是使用的而名字就必须是以上@Param注解中配置的名称！

MyBatis实现以上做法的本质其实就是基于注解中配置的参数和调用方法时给出的参数值封装了1个Map。

当然，以上实现原理可以不必过于关心，只需要记住：在使用MyBatis框架，设计抽象方法时，如果参数的数量超过1个（有2个或者更多个），就为每一个参数都添加@Param注解，并且，在后续配置SQL映射时，使用的#{}中就使用@Param注解中配置的名称。

2.7 删除功能

删除功能就更加简便，也是在Mapper接口中删除方法前面用@Delete定义SQL语句即可：

	@Delete("DELETE FROM t_user WHERE id=#{id}")
	Integer deleteUserById(Integer id);

测试案例：
返回值为1表示删除了1行记录

	@Test
	public void testDeleteUserById() {
		UserMapper mapper = ctx.getBean("userMapper",UserMapper.class);
		int n = mapper.deleteUserById(25);
		System.out.println(n);
	}

在数据库中检查数据是否被删除。

3 总结

关于MyBatis配置：

  1. 利用Maven导入SSM相关组件；
  2. 配置DataSource，使DataSource连接到数据库；
  3. 配置SqlSessionFactory，将DataSource注入给SqlSessionFactory，目的是通知MyBatis连接到哪个数据库；
  4. 配置MapperScan这样可以自动创建Mapper接口实例；

关于映射规则：

  1. 关于注解：

    • @Select注解用于映射查询语句到Mapper接口抽象方法
    • @Insert注解用于映射插入语句到Mapper接口抽象方法
    • @Options注解可以与@Insert配合，用于读取刚刚生产的ID
    • @Update注解用于映射更新语句到Mapper接口抽象方法
    • @Delete注解用于映射删除语句到Mapper接口抽象方法

  2. 参数映射规则

    • 如果抽象方法只有一个简单参数，就会自动与SQL中的一个参数自动映射
    • 如果抽象方法参数是一个Java Bean对象，MyBatis就会将JavaBean属性与SQL参数映射
    • 如果抽象方法是多个参数，就需要使用@Param声明参数名字然后再映射到SQL参数。
举报

相关推荐

mybati mapper标签

xmlmavenjavamybatis

mybati快速入门（图解）

springUsermysqlC/C++后端开发

SQL数据库入门04：数据查询操作

SQL数据库SQL ServerMySQL数据库查询yyds干货盘点

04（数据结构考研）串相关操作代码

算法字符串数据结构子串i++编程语言

Mybati通过collection实现级联列表查询，实现自动封装List数据

list数据结构

2021-04-07 基于PL/pgSQL操作地理数据

日记本开源

2-04 Series 操作

Python

Python 学习04 文件操作

python软件研发

Flutter Dart语言（04）库操作

golang开发语言

Fiddler04--抓包操作

html图形界面JSONLinux系统/运维
0 条评论