Spring Boot- 2 (数万字入门教程 ):数据交互篇
JDBC交互框架:
Spring的JDBC操作工具:
依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
JDBC的模版类:JdbcTemplate
引入Mysql的依赖
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
application的配置信息:
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
username: 你的用户名
password: 你的密码
driver-class-name: com.mysql.cj.jdbc.Driver
使用JdbcTemplate来操作
Yml配置
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
我们要操作数据库，最简单直接的方法就是使用JdbcTemplate来完成：
@Resource
JdbcTemplate template;
实例:
@Test
void contextLoads() {
Map<String, Object> map = template.queryForMap(
"select * from user where id = ?", 1
);
System.out.println(map);
}
亦可以查询类:
@Data@AllArgsConstructorpublic class User {
int id;
String name;
String email;
String password;
}
@Testvoid contextLoads() {
User user = template.queryForObject("select * from user where id = ?",
(r, i) -> new User(r.getInt(1), r.getString(2), r.getString(3), r.getString(4)), 1);
System.out.println(user);
}
第一个参数：SQL 查询语句，使用?作为占位符。
第二个参数：RowMapper 接口的实现，用于将查询结果映射到 User 对象。这里使用了 Lambda 表达式：
r.getInt(1)：获取结果集中第一列（id）。
r.getString(2)：获取结果集中第二列（name）。
r.getString(3)：获取结果集中第三列（email）。
r.getString(4)：获取结果集中第四列（password）。
第三个参数：SQL 查询参数，用于替换?占位符。
这个测试方法的功能是从数据库中查询 id 为 1 的用户，并将结果打印输出。
亦可以进行查询,更新,删除,使用update
@Repositorypublic class UserDao {
private final JdbcTemplate template;
public UserDao(JdbcTemplate template) {
this.template = template;
}
// 插入用户
public int insertUser(User user) {
String sql = "INSERT INTO user (id, name, email, password) VALUES (?, ?, ?, ?)";
return template.update(sql,
user.getId(),
user.getName(),
user.getEmail(),
user.getPassword());
}
// 更新用户
public int updateUser(User user) {
String sql = "UPDATE user SET name = ?, email = ?, password = ? WHERE id = ?";
return template.update(sql,
user.getName(),
user.getEmail(),
user.getPassword(),
user.getId());
}
// 删除用户
public int deleteUser(int id) {
String sql = "DELETE FROM user WHERE id = ?";
return template.update(sql, id);
}
// 查询用户（保留原示例）
public User getUserById(int id) {
String sql = "SELECT * FROM user WHERE id = ?";
return template.queryForObject(sql, userRowMapper(), id);
}
// RowMapper 提取为独立方法提高复用性
private RowMapper<User> userRowMapper() {
return (rs, rowNum) -> new User(
rs.getInt("id"),
rs.getString("name"),
rs.getString("email"),
rs.getString("password")
);
}
}
如果是小项目or测试方法,JdbcTemplate可以很快的辅助我们完成操作
Jdbc的简单封装:
SimpleJdbcInsert来处理一些高级的插入:SimpleJdbcInsert 是 Spring 框架提供的一个便捷工具类，用于简化 JDBC 插入操作，尤其适合处理动态插入场景。与直接使用 JdbcTemplate 相比，它提供了更高级的特性，如自动生成主键、基于数据库元数据的表结构感知等。
核心特性
1,自动表结构感知：通过数据库元数据自动获取表结构信息
2,主键生成支持：支持自增主键和序列（如 Oracle）
3,参数类型自动匹配：基于列类型自动转换参数
4,批处理支持：高效处理批量插入操作
5,简化的 API：链式调用风格，代码更简洁
看一看这个的基本使用方法:
@Repositorypublic class AdvancedUserDao {
private final SimpleJdbcInsert jdbcInsert;
public AdvancedUserDao(DataSource dataSource) {
// 初始化 SimpleJdbcInsert，指定数据源和表名
this.jdbcInsert = new SimpleJdbcInsert(dataSource)
.withTableName("user")
.usingGeneratedKeyColumns("id"); // 指定自增主键列
}
// 插入用户并返回生成的主键
public Number insertUser(User user) {
Map<String, Object> parameters = new HashMap<>();
parameters.put("name", user.getName());
parameters.put("email", user.getEmail());
parameters.put("password", user.getPassword());
// 执行插入并返回自动生成的主键
return jdbcInsert.executeAndReturnKey(parameters);
}
public void batchInsertUsers(List<User> users) {
// 1. 创建一个用于存储批量插入参数的列表
List<Map<String, Object>> batch = new ArrayList<>();
// 2. 遍历用户列表，为每个用户创建参数映射
for (User user : users) {
// 3. 为当前用户创建一个键值对映射，键为列名，值为列值
Map<String, Object> parameters = new HashMap<>();
// 4. 添加用户名列
parameters.put("name", user.getName());
// 5. 添加邮箱列
parameters.put("email", user.getEmail());
// 6. 添加密码列
parameters.put("password", user.getPassword());
// 7. 将当前用户的参数映射添加到批量参数列表中
batch.add(parameters);
}
// 8. 执行批量插入操作
// batch.toArray(new Map[0]) 将列表转换为 Map 数组
// executeBatch 方法会将数组中的每个 Map 作为一组参数执行插入
jdbcInsert.executeBatch(batch.toArray(new Map[0]));
}
}
还可以自定义列映射:
public AdvancedUserDao(DataSource dataSource) {
this.jdbcInsert = new SimpleJdbcInsert(dataSource)
.withTableName("user")
.usingColumns("name", "email", "password") // 显式指定要插入的列
.withoutTableColumnMetaDataAccess(); // 禁用元数据访问（提高性能）
}
处理复合主键:
public Number[] insertUserWithCompositeKey(User user) {
Map<String, Object> params = new HashMap<>();
params.put("org_id", user.getOrgId()); // 复合主键字段1
params.put("user_id", user.getUserId()); // 复合主键字段2
params.put("name", user.getName());
// 返回包含所有主键值的 Map
return jdbcInsert.executeAndReturnKeyHolder(params).getKeys();
}
上面的都是一些小型的工具,帮助我们实现一个小项目or测试方法的时候可以用,更复杂的就不建议了
JPA框架:
Spring Data JPA 是 Spring 框架的一部分，旨在简化基于 JPA（Java Persistence API）的数据访问层开发。它通过提供统一的接口和自动实现机制，大幅减少了数据访问层的样板代码，让开发者可以更专注于业务逻辑。
核心思想,将实体类对应一个数据库表
first,引入依赖:
同样的，我们只需要导入stater依赖即可：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
second,创建对应的类:
@Data
public class Account {
int id;
String username;
String password;
}
third添加实体类和数据库表的映射关系:
@Data
@Entity //表示这个类是一个实体类
@Table(name = "account") //对应的数据库中表名称
public class Account {
@GeneratedValue(strategy = GenerationType.IDENTITY) //生成策略，这里配置为自增 @Column(name = "id") //对应表中id这一列
@Id //此属性为主键
int id;
@Column(name = "username") //对应表中
username这一列 String username;
@Column(name = "password") //对应表中password这一列
String password;
}
Fourth:配置yml文件
spring:
jpa:
#开启SQL语句执行日志信息
show-sql: true
hibernate:
#配置为检查数据库表结构，没有时会自动创建
ddl-auto: update
ddl-auto属性用于设置自动表定义，可以实现自动在数据库中为我们创建一个表，表的结构会根据我们定义的实体类决定，它有以下几种：
none: 不执行任何操作，数据库表结构需要手动创建。
create: 框架在每次运行时都会删除所有表，并重新创建。
create-drop: 框架在每次运行时都会删除所有表，然后再创建，但在程序结束时会再次删除所有表。
update: 框架会检查数据库表结构，如果与实体类定义不匹配，则会做相应的修改，以保持它们的一致性。
validate: 框架会检查数据库表结构与实体类定义是否匹配，如果不匹配，则会抛出异常。
这个配置项的作用是为了避免手动管理数据库表结构，使开发者可以更方便地进行开发和测试，但在生产环境中，更推荐使用数据库迁移工具来管理表结构的变更。
fifth:访问表
一个repository类,继承接口JpaRepository<>:
@Repository
public interface AccountRepository extends JpaRepository<Account, Integer> { }
JpaRepository<实体类, ID类型>
注入这个Repository类进行查询就好啦
@Resource
AccountRepository repository;
@Test
void contextLoads() {
Account account = new Account();
account.setUsername("小红");
account.setPassword("1234567");
System.out.println(repository.save(account).getId()); //使用save来快速插入数据，并且会返回插入的对象，如果存在自增ID，对象的自增id属性会自动被赋值，这就很方便了
}
查询就可以使用 findxx():
@Test
void contextLoads() {
//默认通过通过ID查找的方法，并且返回的结果是Optional包装的对象，非常人性化
repository.findById(1).ifPresent(System.out::println);
}
方法名拼接自定义SQL
| 属性 | 拼接方法名称示例 | 执行的语句 |
| Distinct | findDistinctByLastnameAndFirstname | select distinct … where x.lastname = ?1 and x.firstname = ?2 |
| And | findByLastnameAndFirstname | … where x.lastname = ?1 and x.firstname = ?2 |
| Or | findByLastnameOrFirstname | … where x.lastname = ?1 or x.firstname = ?2 |
| Is，Equals | findByFirstname,findByFirstnameIs,findByFirstnameEquals | … where x.firstname = ?1 |
| Between | findByStartDateBetween | … where x.startDate between ?1 and ?2 |
| LessThan | findByAgeLessThan | … where x.age < ?1 |
| LessThanEqual | findByAgeLessThanEqual | … where x.age <= ?1 |
| GreaterThan | findByAgeGreaterThan | … where x.age > ?1 |
| GreaterThanEqual | findByAgeGreaterThanEqual | … where x.age >= ?1 |
| After | findByStartDateAfter | … where x.startDate > ?1 |
| Before | findByStartDateBefore | … where x.startDate < ?1 |
| IsNull，Null | findByAge(Is)Null | … where x.age is null |
| IsNotNull，NotNull | findByAge(Is)NotNull | … where x.age not null |
| Like | findByFirstnameLike | … where x.firstname like ?1 |
| NotLike | findByFirstnameNotLike | … where x.firstname not like ?1 |
| StartingWith | findByFirstnameStartingWith | … where x.firstname like ?1（参数与附加%绑定） |
| EndingWith | findByFirstnameEndingWith | … where x.firstname like ?1（参数与前缀%绑定） |
| Containing | findByFirstnameContaining | … where x.firstname like ?1（参数绑定以%包装） |
| OrderBy | findByAgeOrderByLastnameDesc | … where x.age = ?1 order by x.lastname desc |
| Not | findByLastnameNot | … where x.lastname <> ?1 |
| In | findByAgeIn(Collection<Age> ages) | … where x.age in ?1 |
| NotIn | findByAgeNotIn(Collection<Age> ages) | … where x.age not in ?1 |
| True | findByActiveTrue | … where x.active = true |
| False | findByActiveFalse | … where x.active = false |
| IgnoreCase | findByFirstnameIgnoreCase | … where UPPER(x.firstname) = UPPER(?1) |
关联查询:
一对一关联:
因为我们JPA的核心思想史对象对应一个表,所以关联就可以看做一个对象和对象关联
比如:用户信息和用户详细信息的一对一关联
的依赖关系，比如用户表中包含了用户详细信息的ID字段作为外键，那么实际上就是用户表实体中包括了用户详细信息实体对象：
@Data
@Entity
@Table(name = "users_detail")
public class AccountDetail {
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Id
int id;
@Column(name = "address")
String address;
@Column(name = "email")
String email;
@Column(name = "phone")
String phone;
@Column(name = "real_name")
String realName;
}
@Data
@Entity
@Table(name = "users")
public class Account {
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
@Id
int id;
@Column(name = "username")
String username;
@Column(name = "password")
String password;
@JoinColumn(name = "detail_id") //指定存储外键的字段名称
@OneToOne //声明为一对一关系
AccountDetail detail;
}
还有其他的一对多,多对一,多对多的关系
如果只需要查询用户信息,不需要详细信息就可以设置一个懒加载,这样就不会每次查询都去找详细信息了,只会在需要的时候才会去查
@OneToOne(fetch = FetchType.LAZY) //将获取类型改为LAZY
当然了,如果你想再加入一个表的数据的时候对关联的表也去操作,就可以使用cascade
ALL：所有操作都进行关联操作
PERSIST：插入操作时才进行关联操作
REMOVE：删除操作时才进行关联操作
MERGE：修改操作时才进行关联操作
就变这样了:
@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL) //设置关联操作为ALL AccountDetail detail;
一对多:
@oneTomany:
@manyToone:
比如一个成绩排名对应了很多的学生,学生们都对应的同一个成绩榜单,多对一,这里的学生是多:
@Entitypublic class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private int age;
// 多对一：多个学生关联同一个成绩单
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "transcript_id") // 外键列，指向成绩单ID
private Transcript transcript;
// 构造方法、Getter和Setter
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public Transcript getTranscript() { return transcript; }
public void setTranscript(Transcript transcript) { this.transcript = transcript; }
}
@Entitypublic class Transcript {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String course; // 课程名称
private double score; // 分数（共享的统一分数）
// 一对多：一个成绩单对应多个学生
@OneToMany(mappedBy = "transcript", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Student> students = new ArrayList<>();
// 构造方法、Getter和Setter
public Transcript() {}
public Transcript(String course, double score) {
this.course = course;
this.score = score;
}
// 添加学生的便捷方法
public void addStudent(Student student) {
students.add(student);
student.setTranscript(this);
}
// 移除学生的便捷方法
public void removeStudent(Student student) {
students.remove(student);
student.setTranscript(null);
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getCourse() { return course; }
public void setCourse(String course) { this.course = course; }
public double getScore() { return score; }
public void setScore(double score) { this.score = score; }
public List<Student> getStudents() { return students; }
public void setStudents(List<Student> students) { this.students = students; }
}
多对多:
@ManyToMany:
学生（Student）与课程（Course） 的关系。一个学生可以选修多门课程，一门课程也可以被多个学生选修。
一、实体类设计
1. 学生实体（Student）
@Entity
@Table(name = "students")
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private int age;
// 多对多关系：学生选修多门课程
@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@JoinTable(
name = "student_course", // 中间表名
joinColumns = @JoinColumn(name = "student_id"), // 指向当前实体（学生）的外键
inverseJoinColumns = @JoinColumn(name = "course_id") // 指向关联实体（课程）的外键
)
private List<Course> courses = new ArrayList<>();
// 构造方法、Getter和Setter
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 添加课程的便捷方法
public void addCourse(Course course) {
courses.add(course);
course.getStudents().add(this);
}
// 移除课程的便捷方法
public void removeCourse(Course course) {
courses.remove(course);
course.getStudents().remove(this);
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public List<Course> getCourses() { return courses; }
public void setCourses(List<Course> courses) { this.courses = courses; }
}
2. 课程实体（Course）
@Entity
@Table(name = "courses")
public class Course {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String courseName;
private int credits;
// 多对多关系：课程被多个学生选修
@ManyToMany(mappedBy = "courses") // 映射到 Student 实体的 courses 字段
private List<Student> students = new ArrayList<>();
// 构造方法、Getter和Setter
public Course() {}
public Course(String courseName, int credits) {
this.courseName = courseName;
this.credits = credits;
}
// 添加学生的便捷方法
public void addStudent(Student student) {
students.add(student);
student.getCourses().add(this);
}
// 移除学生的便捷方法
public void removeStudent(Student student) {
students.remove(student);
student.getCourses().remove(this);
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getCourseName() { return courseName; }
public void setCourseName(String courseName) { this.courseName = courseName; }
public int getCredits() { return credits; }
public void setCredits(int credits) { this.credits = credits; }
public List<Student> getStudents() { return students; }
public void setStudents(List<Student> students) { this.students = students; }
}
二、数据库表结构
多对多关系通过 中间表（Join Table） 实现：
1. students 表
| 字段名 | 类型 | 描述 |
| id | BIGINT | 主键 |
| name | VARCHAR | 学生姓名 |
| age | INT | 学生年龄 |
2. courses 表
| 字段名 | 类型 | 描述 |
| id | BIGINT | 主键 |
| course_name | VARCHAR | 课程名称 |
| credits | INT | 学分 |
3. student_course 中间表
| 字段名 | 类型 | 描述 |
| student_id | BIGINT | 外键，关联 students 表 |
| course_id | BIGINT | 外键，关联 courses 表 |
| PRIMARY KEY | (student_id, course_id) | 复合主键 |
三.Repository 接口
public interface StudentRepository extends JpaRepository<Student, Long> {}
public interface CourseRepository extends JpaRepository<Course, Long> {}
四、业务逻辑示例
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class StudentCourseService {
@Autowired
private StudentRepository studentRepository;
@Autowired
private CourseRepository courseRepository;
// 创建学生并分配课程
@Transactional
public Student createStudentWithCourses(String name, int age, List<Course> courses) {
Student student = new Student(name, age);
courses.forEach(course -> student.addCourse(course));
return studentRepository.save(student);
}
// 创建课程并分配学生
@Transactional
public Course createCourseWithStudents(String courseName, int credits, List<Student> students) {
Course course = new Course(courseName, credits);
students.forEach(student -> course.addStudent(student));
return courseRepository.save(course);
}
// 为学生添加课程
@Transactional
public void addCourseToStudent(Long studentId, Long courseId) {
Student student = studentRepository.findById(studentId)
.orElseThrow(() -> new IllegalArgumentException("Student not found"));
Course course = courseRepository.findById(courseId)
.orElseThrow(() -> new IllegalArgumentException("Course not found"));
student.addCourse(course);
}
// 获取学生及其选修的课程
@Transactional(readOnly = true)
public Student getStudentWithCourses(Long studentId) {
return studentRepository.findById(studentId)
.orElseThrow(() -> new IllegalArgumentException("Student not found"));
}
// 删除学生及其选课记录
@Transactional
public void deleteStudent(Long studentId) {
studentRepository.deleteById(studentId);
}
}
有时候过于复杂的语句还是只有使用SQl语句,为了不让我们再次去使用Mybatis框架,可以使用@Query(原生sql语句进行查询)
@Query("update xxx set xxx = ?2 where xxx = ?1")
int updatexxxbyxxx(第一个参数,第二个参数)
这里的?后面的数字表示填入第几个参数
MybatisPlus框架:
一、MyBatis-Plus 框架全解析
1. 基本信息
MyBatis-Plus (简称 MP) 是一个 MyBatis 的增强工具，旨在简化开发过程，提供零配置、CRUD 自动化和强大的条件构造器，使开发者能够更高效地使用 MyBatis。
核心优势：
无需编写 XML 或大量 SQL 语句
提供丰富的条件构造器，替代复杂 SQL
支持自动填充、逻辑删除、乐观锁等高级特性
内置分页插件，简化分页操作
代码生成器快速生成基础代码
二、引入依赖
Maven 依赖：
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
</dependency>
<!-- MySQL 驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
三、配置 application.yml
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306
username: root
password: yourpassword
mybatis-plus:
mapper-locations: classpath:mapper/*.xml # mapper XML 文件位置
global-config:
db-config:
id-type: auto # 主键类型
logic-delete-field: deleted # 逻辑删除字段名
logic-not-delete-value: 0 # 未删除值
logic-delete-value: 1 # 已删除值
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # SQL 日志打印
map-underscore-to-camel-case: true # 下划线转驼峰
四、示例实体类定义
@Data
@TableName("user") // 对应数据库表名
public class User {
@TableId(type = IdType.AUTO) // 主键自增
private Long id;
@TableFeild(“对应的字段”)
private String username;
@TableFeild(“对应的字段”)
private String email;
@TableFeild(“对应的字段”)
private Integer age;
@TableField(对应的字段,fill = FieldFill.INSERT) // 插入时自动填充
private LocalDateTime createTime;
@TableField(对应的字段,fill = FieldFill.INSERT_UPDATE) // 插入和更新时自动填充
private LocalDateTime updateTime;
@TableLogic // 逻辑删除字段
private Integer deleted;
@Version // 乐观锁版本号
private Integer version;
}
五、Mapper 接口定义
@Mapper
public interface UserMapper extends BaseMapper<User> {
// 继承 BaseMapper 后，自动拥有 CRUD 方法
// 可添加自定义方法
}
六、简单测试方法
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectById() {
User user = userMapper.selectById(1L);
System.out.println(user);
}
}
七、条件构造器处理复杂查询
@SpringBootTest
public class QueryWrapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testComplexQuery() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper
.like("username", "张") // 用户名包含"张"
.ge("age", 20) // 年龄大于等于20
.le("age", 30) // 年龄小于等于30
.orderByDesc("create_time") // 按创建时间降序
.last("LIMIT 10"); // 追加SQL片段
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}
}
八、批处理操作
@SpringBootTest
public class BatchOperationTest {
@Autowired
private UserMapper userMapper;
@Test
@Transactional // 批量操作建议在事务中执行
public void testBatchInsert() {
List<User> userList = new ArrayList<>();
for (int i = 0; i < 100; i++) {
User user = new User();
user.setUsername("test" + i);
user.setEmail("test" + i + "@example.com");
user.setAge(20 + i % 10);
userList.add(user);
}
// 批量插入
userList.forEach(userMapper::insert);
}
}
九、分页查询
先配置:
@Configuration
public class MybatisConfiguration {
@Bean
public MybatisPlusInterceptor paginationInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); //添加分页拦截器到MybatisPlusInterceptor中
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor; }
}
@SpringBootTest
public class PaginationTest {
@Autowired
private UserMapper userMapper;
@Test
public void testPagination() {
// 创建分页对象，查询第1页，每页10条
Page<User> page = new Page<>(1, 10);
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.gt("age", 18);
// 执行分页查询
Page<User> result = userMapper.selectPage(page, wrapper);
System.out.println("总记录数: " + result.getTotal());
System.out.println("总页数: " + result.getPages());
System.out.println("当前页数据: " + result.getRecords());
}
}
Page.of(1,2)
一共2页,查看第一页
十、增删改操作
1. 新增数据
User user = new User();
user.setUsername("doubao");
user.setEmail("doubao@example.com");
user.setAge(25);
int rows = userMapper.insert(user); // 返回影响行数
System.out.println("新增用户ID: " + user.getId());
2. 删除数据
// 物理删除
int rows = userMapper.deleteById(1L);
// 逻辑删除（更新deleted字段）
int logicRows = userMapper.deleteById(2L);
3. 更新数据
User user = new User();
user.setId(1L);
user.setAge(26); // 只更新age字段
int rows = userMapper.updateById(user);
也可以使用UpdateWrapper<>来处理
UpdateWrapper<User> wrapper = new UpdateWrapper<>();
wrapper.set(xxx,xxx).eq(xxx,xx)
mapper.update(null,wrapper)
十一、IService 接口的继承与实现
1. 定义 Service 接口
public interface UserService extends IService<User> {
// 继承 IService 后，自动拥有基础 CRUD 方法
// 自定义方法
List<User> findByAgeGreaterThan(Integer age);}
2. 实现 Service 接口
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Override
public List<User> findByAgeGreaterThan(Integer age) {
return baseMapper.selectList(new QueryWrapper<User>().gt("age", age));
}
}
3. 使用示例
@Autowired
private UserService userService;
@Test
public void testCustomServiceMethod() {
List<User> users = userService.findByAgeGreaterThan(20);
users.forEach(System.out::println);
}
MyBatis-Plus 通过 BaseMapper 和 IService 接口提供了强大的 CRUD 能力，同时通过 条件构造器 简化了复杂查询。开发者可以在继承基础接口的同时，添加自定义方法，实现灵活扩展。
关键组件：
BaseMapper：提供基础 CRUD 方法
IService：提供更高级的业务层方法（如批量操作）
ServiceImpl：默认实现类，集成 BaseMapper
Wrapper：强大的条件构造器，替代复杂 SQL
通过这种方式，MyBatis-Plus 大幅减少了样板代码，提高了开发效率，同时保留了 MyBatis 的灵活性。