第四章 数据访问：MyBAtis-Plus&Druid数据源

(如果没有了解可以去我主页看看 第一至三章的内容来学习)通过前面两章的学习，我们已经对数据访问层两大核心框架JPA(Hibernate)和MyBAtis进行了学习，这两大框架一个是全自动ORM，一个是半自动ORM，且各有优势及应用场景。
  本章我们继续学习数据访问层技术：MyBAtis-Plus。MyBAtis-Plus是一个MyBAtis的增强工具，在MyBAtis的基础上只做增强不做改变，原MyBAtis的用法和功能在MyBAtis-Plus中依然可以继续使用；同时MyBAtis-Plus仅仅通过少量配置即可实现单表大部分CRUD操作，内置分页插件，复杂查询提供了条件构造器，这与JPA又非常相似。所以，MyBAtis-Plus可说是结合了JPA和MyBAtis两个框架的优点。
  本章在最后我们还会学习SpringBoot集成Druid数据源，Druid数据源是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成，功能强大，应用广泛。

4.1 Spring Boot 集成 MyBAtis-Plus

4.1.1 MyBAtis-Plus简介

  MyBAtis-Plus(简称MP)是一个 MyBAtis 的增强工具，在MyBAtis的基础上只做增强不做改变，为简化开发、提高效率而生。它继承了 MyBatis 的所有特性并加入了自己的功能，比如内置的分页插件、乐观锁插件、性能分析插件、条件构造器等等，极大地简化了 CRUD 操作，让开发者能够更专注于业务逻辑的实现。

下面是一个简单的 MyBatis-Plus 的 Java 代码示例，演示了如何使用 MyBatis-Plus 进行数据的增删改查操作。

首先，确保你的项目中已经加入了 MyBatis-Plus 的依赖。以下是一个 Maven 依赖示例：

<dependency>  
    <groupId>com.baomidou</groupId>  
    <artifactId>mybatis-plus-boot-starter</artifactId>  
    <version>你的MyBatis-Plus版本号</version>  
</dependency>

实体类（Entity）
假设我们有一个用户表 user，对应的实体类 User 如下：

import com.baomidou.mybatisplus.annotation.IdType;  
import com.baomidou.mybatisplus.annotation.TableId;  
import com.baomidou.mybatisplus.annotation.TableName;  
  
@TableName("user")  
public class User {  
    @TableId(type = IdType.AUTO)  
    private Long id;  
    private String name;  
    private Integer age;  
    private String email;  
  
    // 省略getter和setter方法  
}

Mapper 接口
MyBatis-Plus 会根据 Mapper 接口自动生成 SQL 语句，因此通常我们不需要编写具体的 SQL 语句。

import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
  
public interface UserMapper extends BaseMapper<User> {  
    // 继承BaseMapper后，已经拥有了很多CRUD方法，如果需要特殊SQL，可以在这里扩展  
}

Service 层
在 Service 层中，我们可以注入 Mapper 接口来进行业务逻辑处理。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
  
@Service  
public class UserService {  
  
    @Autowired  
    private UserMapper userMapper;  
  
    public User getUserById(Long id) {  
        return userMapper.selectById(id);  
    }  
  
    // 其他业务逻辑...  
}

Controller 层
在 Controller 层中，我们可以调用 Service 层的方法，并返回相应的结果给前端。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.PathVariable;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class UserController {  
  
    @Autowired  
    private UserService userService;  
  
    @GetMapping("/user/{id}")  
    public User getUserById(@PathVariable Long id) {  
        return userService.getUserById(id);  
    }  
  
    // 其他接口...  
}

这个示例简单展示了 MyBatis-Plus 的基本使用方式，通过继承 BaseMapper 接口，你可以很方便地进行 CRUD 操作，而无需编写大量的 SQL 语句。MyBatis-Plus 还提供了很多强大的功能，如分页插件、条件构造器等，可以帮助你更高效地开发。

MyBAtis-Plus特性：

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作
• 支持Lambda形式调用：通过Lambda表达式，方便的编写各类查询条件，无需再担心字段写错
• 支持多种数据库：支持MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer等多种数据库
• 强大的CRUD操作：内置通用Mapper、通用Service，仅仅通过少量配置即可实现单表大部分CRUD操作，更有强大的条件构造器，满足各类使用需求
• 内置分页插件：基于MyBAtis物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通List查询

4.1.2 Lombok简介和安装

Lombok是一个Java库，它通过注解的方式自动插入编辑器并构建工具中，从而简化Java代码。它自动化了Java对象的生成，如getter、setter、equals、hashCode、toString方法等，从而减少了样板代码的数量，使得代码更加简洁。Lombok通过注解的方式，在编译时期自动生成这些方法，而不需要开发者手动编写。

Lombok的安装
Lombok的安装主要涉及两个步骤：

1. 添加Lombok依赖：在你的项目中添加Lombok的Maven或Gradle依赖。
2. IDE插件安装：大多数流行的Java IDE（如IntelliJ IDEA, Eclipse, NetBeans等）都支持Lombok，但需要安装相应的插件。

Maven依赖
在pom.xml文件中添加Lombok的Maven依赖：

<dependency>  
    <groupId>org.projectlombok</groupId>  
    <artifactId>lombok</artifactId>  
    <version>最新版本号</version>  
    <scope>provided</scope>  
</dependency>

请确保将最新版本号替换为Lombok的当前版本。

Gradle依赖
在build.gradle文件中添加Lombok的Gradle依赖：

dependencies {  
    compileOnly 'org.projectlombok:lombok:最新版本号'  
    annotationProcessor 'org.projectlombok:lombok:最新版本号'  
    testCompileOnly 'org.projectlombok:lombok:最新版本号'  
    testAnnotationProcessor 'org.projectlombok:lombok:最新版本号'  
}

同样，请将最新版本号替换为Lombok的当前版本。

IDE插件安装
以IntelliJ IDEA为例，安装Lombok插件的步骤如下：

1. 打开IDEA，进入File -> Settings（Windows）或IntelliJ IDEA -> Preferences（Mac）。
2. 在设置窗口中，选择Plugins。
3. 在Marketplace标签页中搜索Lombok。
4. 找到Lombok插件后，点击Install按钮进行安装。
5. 安装完成后，重启IDEA以使插件生效。

Java代码示例
使用Lombok注解的Java类示例：

import lombok.Data;  
  
@Data // 自动生成getter、setter、equals、hashCode和toString方法  
public class User {  
    private Long id;  
    private String name;  
    private Integer age;  
    // 无需手动编写getter、setter等方法  
}  
  
public class Main {  
    public static void main(String[] args) {  
        User user = new User();  
        user.setId(1L);  
        user.setName("John Doe");  
        user.setAge(30);  
  
        System.out.println(user.toString()); // 自动生成的toString方法  
    }  
}

在这个例子中，@Data注解自动为User类生成了getter、setter、equals、hashCode和toString方法，从而减少了样板代码。在Main类中，我们可以直接调用这些方法而无需手动编写它们。

4.1.3 快速上手

MyBatis-Plus 是一个 MyBatis 的增强工具，它简化了 CRUD 操作，提供了许多便利的功能，如内置的分页插件、乐观锁插件、自动填充字段等。下面是一个简单的 MyBatis-Plus 快速上手的 Java 代码示例，展示如何使用 MyBatis-Plus 进行数据库操作。

1. 添加依赖
   首先，确保你的项目中已经加入了 MyBatis-Plus 的依赖。以下是一个 Maven 依赖示例：

<dependency>  
    <groupId>com.baomidou</groupId>  
    <artifactId>mybatis-plus-boot-starter</artifactId>  
    <version>你的MyBatis-Plus版本号</version>  
</dependency>  
<!-- 如果你使用的是 Spring Boot，可能还需要添加数据库连接池等依赖 -->  
<dependency>  
    <groupId>com.h2database</groupId>  
    <artifactId>h2</artifactId>  
    <scope>runtime</scope>  
</dependency>

请将 你的MyBatis-Plus版本号 替换为当前最新的或你项目中指定的 MyBatis-Plus 版本号。

2. 配置 MyBatis-Plus
   在 Spring Boot 的 application.properties 或 application.yml 文件中配置 MyBatis-Plus 和数据库连接信息。

# application.properties 示例  
spring.datasource.url=jdbc:h2:mem:testdb  
spring.datasource.driverClassName=org.h2.Driver  
spring.datasource.username=sa  
spring.datasource.password=  
spring.jpa.show-sql=true  
  
# MyBatis-Plus 配置  
mybatis-plus.mapper-locations=classpath:/mapper/**/*.xml  
mybatis-plus.type-aliases-package=com.example.demo.entity  
mybatis-plus.global-config.db-config.id-type=auto

注意：上面的 mybatis-plus.mapper-locations 和 mybatis-plus.type-aliases-package 需要根据你的项目结构调整。

3. 实体类
   创建一个实体类，使用 MyBatis-Plus 提供的注解来标记字段。

package com.example.demo.entity;  
  
import com.baomidou.mybatisplus.annotation.IdType;  
import com.baomidou.mybatisplus.annotation.TableId;  
import com.baomidou.mybatisplus.annotation.TableName;  
  
@TableName("user")  
public class User {  
    @TableId(type = IdType.AUTO)  
    private Long id;  
    private String name;  
    private Integer age;  
    // 省略getter和setter方法  
}

4. Mapper 接口
   继承 BaseMapper 接口，无需编写任何方法。

package com.example.demo.mapper;  
  
import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
import com.example.demo.entity.User;  
  
public interface UserMapper extends BaseMapper<User> {  
    // 继承BaseMapper后，已经拥有了很多CRUD方法  
}

5. Service 层
   在 Service 层中注入 Mapper 接口，并进行业务逻辑处理。

package com.example.demo.service;  
  
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;  
import com.example.demo.entity.User;  
import com.example.demo.mapper.UserMapper;  
import org.springframework.stereotype.Service;  
  
@Service  
public class UserService extends ServiceImpl<UserMapper, User> {  
    // 继承ServiceImpl后，已经拥有了很多CRUD方法，也可以自定义方法  
}

6. Controller 层
   在 Controller 层中调用 Service 层的方法。

package com.example.demo.controller;  
  
import com.example.demo.entity.User;  
import com.example.demo.service.UserService;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class UserController {  
  
    @Autowired  
    private UserService userService;  
  
    @GetMapping("/user")  
    public User getUserById(Long id) {  
        return userService.getById(id);  
    }  
  
    // 其他接口...  
}

7. 运行和测试
   启动你的 Spring Boot 应用，并使用 Postman 或其他 API 测试工具来测试 /user 接口，看看是否能够正确返回用户信息。

以上就是 MyBatis-Plus 快速上手的简单示例。根据你的项目需求，你可能还需要配置分页插件、乐观锁插件等高级功能。

4.1.4 核心功能

MyBatis-Plus 作为 MyBatis 的增强工具，在保持 MyBatis 强大功能的基础上，增加了一系列核心功能，以简化开发流程和提高开发效率。以下是一些 MyBatis-Plus 核心功能的 Java 代码示例：

1. CRUD 操作简化
   MyBatis-Plus 提供了非常简便的 CRUD 操作接口，你只需要继承 BaseMapper 接口即可拥有完整的 CRUD 操作能力。

Mapper 接口示例

import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
import your.package.entity.User;  
  
public interface UserMapper extends BaseMapper<User> {  
    // 这里不需要编写任何方法，BaseMapper 已经包含了CRUD方法  
}

使用 Mapper 进行 CRUD 操作

@Autowired  
private UserMapper userMapper;  
  
// 插入操作  
User user = new User();  
user.setName("John Doe");  
userMapper.insert(user);  
  
// 查询操作  
User userById = userMapper.selectById(1L);  
  
// 更新操作  
user.setAge(30);  
userMapper.updateById(user);  
  
// 删除操作  
userMapper.deleteById(1L);

2. 条件构造器
   MyBatis-Plus 提供了强大的条件构造器，如 QueryWrapper 和 UpdateWrapper，用于构造复杂的查询和更新条件。

使用 QueryWrapper 进行查询

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;  
  
List<User> users = userMapper.selectList(new QueryWrapper<User>()  
    .like("name", "John")  
    .or()  
    .eq("age", 30)  
);

使用 UpdateWrapper 进行更新

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;  
  
userMapper.update(new User().setAge(31), new UpdateWrapper<User>()  
    .eq("name", "John Doe")  
);

3. 分页插件
   MyBatis-Plus 的分页插件可以非常方便地实现分页查询，而不需要编写复杂的 SQL 语句。

配置分页插件（已在问题中的前一个回答中给出）

使用分页查询

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;  
  
Page<User> page = new Page<>(1, 10); // 第一页，每页10条数据  
Page<User> userPage = userMapper.selectPage(page, null);  
List<User> users = userPage.getRecords();  
long total = userPage.getTotal();

4. 逻辑删除
   逻辑删除是通过在数据库中标记记录为已删除（而不是真正地删除记录）来实现的。

实体类配置逻辑删除（已在问题中的前一个回答中给出）

使用逻辑删除

无需特别编码，当你调用 deleteById 方法时，MyBatis-Plus 会自动将记录的逻辑删除字段（如 is_deleted）设置为指定的值（默认为 1）。

5. 自动填充
   自动填充允许你在插入或更新记录时自动设置某些字段的值。

实体类配置自动填充（已在问题中的前一个回答中给出）

实现自动填充逻辑（已在问题中的前一个回答中给出）

6. 乐观锁
   乐观锁用于解决并发修改时的数据一致性问题。

实体类配置乐观锁（已在问题中的前一个回答中给出）

使用乐观锁

当多个事务尝试更新同一条记录时，MyBatis-Plus 会通过 version 字段（或其他你指定的乐观锁字段）来确保数据的一致性。如果在更新过程中发现 version 字段的值已经改变，则更新操作会失败。

7. 性能分析插件
   MyBatis-Plus 提供了性能分析插件，用于输出 SQL 语句及其执行时间，帮助开发者分析和优化 SQL 性能。

配置性能分析插件（此处省略具体代码，因为它涉及 Spring Boot 配置）

以上代码示例展示了 MyBatis-Plus 的一些核心功能，这些功能能够大大提高开发效率，并减少数据库操作的复杂性和出错率。

4.1.4.1 CRUD接口

在MyBatis-Plus中，CRUD（Create, Read, Update, Delete）操作被极大地简化了，主要得益于BaseMapper接口。当你为你的实体类创建一个Mapper接口，并让它继承BaseMapper时，你就已经拥有了针对该实体类的完整CRUD操作能力，而无需编写任何具体的CRUD方法实现。

下面是一个具体的例子，展示了如何使用MyBatis-Plus的CRUD接口。

首先，假设你有一个实体类User，它映射到了数据库中的user表：

public class User {  
    private Long id;  
    private String name;  
    private Integer age;  
    // 省略getter和setter方法  
}

然后，你为这个实体类创建一个Mapper接口，继承自BaseMapper：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
import your.package.entity.User; // 替换your.package.entity为你的实际包名  
  
public interface UserMapper extends BaseMapper<User> {  
    // 这里不需要添加任何方法，因为BaseMapper已经包含了CRUD方法  
}

现在，你可以在你的服务层或控制器中注入UserMapper，并使用它来进行CRUD操作了。

以下是一个服务层类的示例，展示了如何使用UserMapper进行CRUD操作：

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import your.package.entity.User; // 替换your.package.entity为你的实际包名  
import your.package.mapper.UserMapper; // 替换your.package.mapper为你的Mapper接口所在的包名  
  
@Service  
public class UserService {  
  
    @Autowired  
    private UserMapper userMapper;  
  
    // 插入操作  
    public void addUser(User user) {  
        userMapper.insert(user);  
    }  
  
    // 根据ID查询操作  
    public User getUserById(Long id) {  
        return userMapper.selectById(id);  
    }  
  
    // 更新操作  
    public void updateUser(User user) {  
        userMapper.updateById(user);  
    }  
  
    // 删除操作  
    public void deleteUser(Long id) {  
        userMapper.deleteById(id);  
    }  
  
    // 其他业务逻辑...  
}

请注意：上面的代码示例假设你正在使用Spring Boot和MyBatis-Plus的集成。如果你没有使用Spring Boot，那么注入UserMapper的方式可能会有所不同，但基本的CRUD操作逻辑是相同的。

BaseMapper接口为CRUD操作提供了丰富的方法，包括但不限于insert、deleteById、updateById、selectById、selectList等。你可以根据需要选择使用这些方法，或者通过条件构造器（如QueryWrapper、UpdateWrapper）来构造更复杂的查询和更新条件。

此外，MyBatis-Plus还提供了分页插件、性能分析插件、乐观锁插件等高级功能，这些功能可以进一步提高你的开发效率和系统的健壮性。不过，这些高级功能的使用已经超出了简单的CRUD操作范畴，需要你在实际的项目中根据需要进行学习和应用。

4.1.4.2 条件构造器

MyBatis-Plus 的条件构造器（如 QueryWrapper 和 UpdateWrapper）提供了一种灵活的方式来构建 SQL 查询和更新条件，无需编写复杂的 SQL 语句。以下是一些使用条件构造器的 Java 代码示例。

QueryWrapper 示例
QueryWrapper 用于构建查询条件。

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;  
import your.package.entity.User; // 替换 your.package.entity 为你的包名  
import your.package.mapper.UserMapper; // 替换 your.package.mapper 为你的 Mapper 接口所在的包名  
  
// 假设 userMapper 已经被注入  
  
// 简单的等于条件查询  
QueryWrapper<User> queryWrapper = new QueryWrapper<>();  
queryWrapper.eq("name", "John Doe");  
List<User> users = userMapper.selectList(queryWrapper);  
  
// 使用lambda表达式（推荐，因为类型安全）  
QueryWrapper<User> lambdaQueryWrapper = new QueryWrapper<>();  
lambdaQueryWrapper.eq(User::getName, "John Doe");  
List<User> lambdaUsers = userMapper.selectList(lambdaQueryWrapper);  
  
// 组合条件  
QueryWrapper<User> complexQueryWrapper = new QueryWrapper<>();  
complexQueryWrapper.like("name", "John")  
                   .or()  
                   .eq("age", 30);  
List<User> complexUsers = userMapper.selectList(complexQueryWrapper);  
  
// 使用lambda表达式进行组合条件  
QueryWrapper<User> lambdaComplexQueryWrapper = new QueryWrapper<>();  
lambdaComplexQueryWrapper.like(User::getName, "John")  
                         .or()  
                         .eq(User::getAge, 30);  
List<User> lambdaComplexUsers = userMapper.selectList(lambdaComplexQueryWrapper);  
  
// 分页查询（需要结合分页插件）  
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;  
Page<User> page = new Page<>(1, 10); // 第一页，每页10条  
page = userMapper.selectPage(page, lambdaComplexQueryWrapper);  
List<User> pageUsers = page.getRecords();

UpdateWrapper 示例
UpdateWrapper 用于构建更新条件。

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;  
  
// 更新操作  
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();  
updateWrapper.eq("name", "John Doe") // 设置更新条件  
             .set("age", 31); // 设置要更新的字段和值  
userMapper.update(null, updateWrapper); // 这里传入null是因为我们直接在UpdateWrapper中指定了更新条件和要更新的字段  
  
// 使用lambda表达式（推荐）  
UpdateWrapper<User> lambdaUpdateWrapper = new UpdateWrapper<>();  
lambdaUpdateWrapper.eq(User::getName, "John Doe")  
                   .set(User::getAge, 31);  
userMapper.update(null, lambdaUpdateWrapper);  
  
// 注意：在实际应用中，通常会传入一个User对象作为update方法的第一个参数，  
// 然后使用UpdateWrapper来指定哪些字段需要被更新（而不是全部字段），  
// 以及这些字段更新的条件是什么。但在这个例子中，为了演示UpdateWrapper的用法，  
// 我们传入了null作为update方法的第一个参数。

注意：在 update 方法中，虽然示例中传入了 null 作为第一个参数，但在实际应用中，你通常会传入一个 User 对象（或你的实体类对象），该对象包含了要更新的字段值（但不是全部字段，只包括你希望更新的那些字段）。UpdateWrapper 则用于指定哪些记录需要被更新（即更新条件）。然而，在某些情况下，如果你只想通过 UpdateWrapper 来更新字段，并且不想传入一个包含字段值的对象，你也可以像示例中那样传入 null。但请注意，这种做法可能会使代码的可读性和可维护性降低。

4.1.4.3 分页插件

MyBatis-Plus 的分页插件是一个非常实用的功能，它允许你以非常简单的方式实现分页查询，而无需在 SQL 语句中手动编写分页逻辑。以下是如何在 Java 项目中使用 MyBatis-Plus 分页插件的步骤和示例代码。

1. 添加依赖
   首先，确保你的项目中已经添加了 MyBatis-Plus 的相关依赖。对于分页插件，你通常不需要额外添加依赖，因为分页功能已经包含在 MyBatis-Plus 的核心库中。但是，为了使用分页功能，你可能需要添加 MyBatis-Plus 的扩展库（mybatis-plus-extension），它包含了分页插件等扩展功能。

<!-- MyBatis-Plus -->  
<dependency>  
    <groupId>com.baomidou</groupId>  
    <artifactId>mybatis-plus-boot-starter</artifactId>  
    <version>你的MyBatis-Plus版本</version>  
</dependency>

2. 配置分页插件
   然后，你需要在 Spring Boot 的配置中注册分页插件。这通常是通过实现一个配置类来完成的，该类使用 @Configuration 注解，并在其中通过 @Bean 方法创建并返回分页插件的实例。

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;  
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class MybatisPlusConfig {  
  
    /**  
     * 分页插件  
     */  
    @Bean  
    public MybatisPlusInterceptor mybatisPlusInterceptor() {  
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();  
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());  
        return interceptor;  
    }  
}

3. 使用分页功能
   配置好分页插件后，你就可以在 Mapper 接口中调用分页查询方法了。不过，通常你不需要在 Mapper 接口中显式地编写分页查询方法，因为 MyBatis-Plus 的 BaseMapper 已经为你提供了分页查询的支持。你只需要在调用 selectPage 方法时传入分页参数即可。

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;  
import your.package.entity.User; // 替换 your.package.entity 为你的包名  
import your.package.mapper.UserMapper; // 替换 your.package.mapper 为你的 Mapper 接口所在的包名  
  
// 假设 userMapper 已经被注入  
  
// 创建分页对象，传入当前页码和每页显示的记录数  
Page<User> page = new Page<>(1, 10);  
  
// 执行分页查询  
// 注意：这里直接调用了 userMapper 的 selectPage 方法，并且传入了分页对象和查询条件（如果有的话）  
// 在这个例子中，我们没有传递查询条件，所以将查询第一页的数据，每页显示10条记录  
page = userMapper.selectPage(page, null); // null 表示没有额外的查询条件  
  
// 获取分页查询结果  
List<User> userList = page.getRecords();  
long total = page.getTotal(); // 总记录数  
boolean hasPrevious = page.hasPrevious(); // 是否有上一页  
boolean hasNext = page.hasNext(); // 是否有下一页  
// ... 其他分页信息

注意：在上面的示例中，selectPage 方法的第二个参数是查询条件，这里我们传递了 null，表示没有额外的查询条件。在实际应用中，你可以使用 QueryWrapper 或 LambdaQueryWrapper 来构建查询条件，并将其作为第二个参数传递给 selectPage 方法。

另外，Page 对象不仅包含了分页查询的结果列表（通过 getRecords 方法获取），还包含了其他分页信息，如总记录数（getTotal）、是否有上一页（hasPrevious）、是否有下一页（hasNext）等。你可以根据需要使用这些信息来构建分页导航。

4.1.4.4 代码生成器

MyBatis-Plus 的代码生成器是一个非常强大的工具，它可以根据数据库表自动生成对应的实体类（Entity）、Mapper 接口、Mapper XML 文件、Service 接口、Service 实现类以及 Controller 等。这大大减少了开发者的重复性工作，提高了开发效率。

以下是一个基本的 MyBatis-Plus 代码生成器的 Java 配置示例。请注意，这个示例假设你已经在项目中添加了 MyBatis-Plus 和相关依赖（如 MyBatis-Plus-Generator）。

首先，添加 MyBatis-Plus-Generator 的依赖到你的 pom.xml 文件中（如果你使用的是 Maven）：

<dependency>  
    <groupId>com.baomidou</groupId>  
    <artifactId>mybatis-plus-generator</artifactId>  
    <version>你的MyBatis-Plus-Generator版本</version>  
</dependency>  
  
<!-- 数据库驱动，根据你的数据库类型添加 -->  
<dependency>  
    <groupId>mysql</groupId>  
    <artifactId>mysql-connector-java</artifactId>  
    <version>你的MySQL驱动版本</version>  
</dependency>

然后，创建一个 Java 类来配置和运行代码生成器。以下是一个简单的示例：

import com.baomidou.mybatisplus.annotation.DbType;  
import com.baomidou.mybatisplus.annotation.IdType;  
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;  
import com.baomidou.mybatisplus.core.toolkit.StringPool;  
import com.baomidou.mybatisplus.core.toolkit.StringUtils;  
import com.baomidou.mybatisplus.generator.AutoGenerator;  
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;  
import com.baomidou.mybatisplus.generator.config.GlobalConfig;  
import com.baomidou.mybatisplus.generator.config.PackageConfig;  
import com.baomidou.mybatisplus.generator.config.StrategyConfig;  
import com.baomidou.mybatisplus.generator.config.po.TableInfo;  
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;  
  
import java.util.Scanner;  
  
public class CodeGenerator {  
  
    /**  
     * <p>  
     * 读取控制台内容  
     * </p>  
     */  
    public static String scanner(String tip) {  
        Scanner scanner = new Scanner(System.in);  
        System.out.println("请输入" + tip + "：");  
        if (scanner.hasNext()) {  
            String ipt = scanner.next();  
            if (StringUtils.isNotBlank(ipt)) {  
                return ipt;  
            }  
        }  
        throw new MybatisPlusException("请输入正确的" + tip + "！");  
    }  
  
    public static void main(String[] args) {  
        // 代码生成器  
        AutoGenerator mpg = new AutoGenerator();  
  
        // 全局配置  
        GlobalConfig gc = new GlobalConfig();  
        String projectPath = System.getProperty("user.dir");  
        gc.setOutputDir(projectPath + "/src/main/java");  
        gc.setAuthor("你的作者名");  
        gc.setOpen(false);  
        gc.setFileOverride(true); // 是否覆盖文件  
        gc.setServiceName("%sService"); // 默认服务接口风格  
        mpg.setGlobalConfig(gc);  
  
        // 数据源配置  
        DataSourceConfig dsc = new DataSourceConfig();  
        dsc.setUrl("jdbc:mysql://localhost:3306/你的数据库名?useUnicode=true&useSSL=false&characterEncoding=utf8");  
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");  
        dsc.setUsername("你的数据库用户名");  
        dsc.setPassword("你的数据库密码");  
        mpg.setDataSource(dsc);  
  
        // 包配置  
        PackageConfig pc = new PackageConfig();  
        pc.setModuleName(scanner("模块名"));  
        pc.setParent("com.你的公司名.你的项目名");  
        mpg.setPackageInfo(pc);  
  
        // 策略配置  
        StrategyConfig strategy = new StrategyConfig();  
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));  
        strategy.setNaming(NamingStrategy.underline_to_camel);  
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);  
        strategy.setEntityLombokModel(true);  
        strategy.setRestControllerStyle(true);  
        mpg.setStrategy(strategy);  
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());  
  
        // 执行生成  
        mpg.execute();  
    }  
}

注意：这个示例中的代码生成器配置是基本的，并且包含了一些通过控制台输入来动态获取的配置项（如模块名和表名）。你可以根据自己的需求调整这些配置项。

在运行这个类之前，请确保你的数据库已经运行，并且 MyBatis-Plus-Generator 能够成功连接到你的数据库。运行这个类后，它会根据你在控制台输入的信息以及你在代码中配置的其他选项来生成代码。

注意：代码生成器生成的代码可能需要根据你的具体项目结构或编码规范进行一定的调整或修改。

4.2 Spring Boot 集成 Druid数据源

4.2.1 Druid简介

Druid 是阿里巴巴开源的一个数据库连接池（Database Connection Pool）实现，它提供了强大的监控和扩展功能，是 Java 应用程序中常用的数据库连接池之一。Druid 不仅能够替代其他数据库连接池如 HikariCP、C3P0、DBCP 等，而且在很多方面表现更优，特别是在监控和扩展性上。

Druid 的主要特性包括：

• 强大的监控和扩展性： Druid 提供了内建的监控功能，包括 SQL 监控、URI 监控、Session 监控、JDBC 监控等。
• 高性能： 通过一些优化手段，如 SQL 解析、预处理等，提高了性能。
• 灵活的扩展性： 提供了很多扩展点，方便进行自定义开发。
• 丰富的连接池配置选项： 包括最大活跃连接数、最小空闲连接数、获取连接时最大等待时间等。

Java 代码中配置和使用 Druid
下面是一个简单的 Java 示例，展示了如何在 Java 项目中配置和使用 Druid 数据库连接池。

首先，你需要在项目的 pom.xml 文件中添加 Druid 的依赖（如果你使用 Maven）：

<dependency>  
    <groupId>com.alibaba</groupId>  
    <artifactId>druid</artifactId>  
    <version>你的Druid版本号</version>  
</dependency>

然后，你可以通过以下方式配置和使用 Druid：

import com.alibaba.druid.pool.DruidDataSource;  
import javax.sql.DataSource;  
import java.sql.Connection;  
import java.sql.SQLException;  
  
public class DruidExample {  
  
    public static void main(String[] args) {  
        // 创建 Druid 数据源  
        DruidDataSource dataSource = new DruidDataSource();  
          
        // 设置数据库连接信息  
        dataSource.setUrl("jdbc:mysql://localhost:3306/your_database?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC");  
        dataSource.setUsername("your_username");  
        dataSource.setPassword("your_password");  
          
        // 设置连接池的一些其他属性  
        dataSource.setInitialSize(5);  
        dataSource.setMaxActive(10);  
        dataSource.setMaxWait(10000);  
  
        // 使用数据源获取连接  
        try (Connection conn = dataSource.getConnection()) {  
            // 在这里执行你的数据库操作  
            System.out.println("数据库连接成功！");  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
  
        // 注意：在实际应用中，数据源对象通常是作为单例在整个应用中共享的，而不是每次使用时都创建。  
    }  
}

这个示例展示了如何创建 Druid 数据源对象，并设置一些基本的连接池参数，然后通过这个数据源对象获取数据库连接并执行操作。在实际的项目中，你可能会将 Druid 数据源配置在一个配置文件中（如 properties 或 yml 文件），并在应用程序启动时加载这些配置来创建数据源对象。

此外，Druid 还提供了很多其他的配置选项和强大的监控功能，你可以通过查看 Druid 的官方文档来了解更多详情。

4.2.2 SpringBoot集成Druid数据源

在Spring Boot中集成Druid数据源相对简单，因为Spring Boot提供了自动配置的功能，可以很容易地集成第三方库。下面是一个基本的步骤和示例代码，展示了如何在Spring Boot项目中集成Druid数据源。

1. 添加依赖
   首先，你需要在pom.xml中添加Druid的依赖。Spring Boot 2.x及以后版本推荐使用druid-spring-boot-starter来替代直接添加Druid依赖，因为它提供了更好的集成和自动配置。

<dependency>  
    <groupId>com.alibaba</groupId>  
    <artifactId>druid-spring-boot-starter</artifactId>  
    <version>你的Druid版本号</version>  
</dependency>

2. 配置数据源
   然后，你需要在application.properties或application.yml文件中配置Druid数据源。Spring Boot会自动读取这些配置来创建和配置数据源。

使用application.yml配置示例：

spring:  
  datasource:  
    type: com.alibaba.druid.pool.DruidDataSource  
    driver-class-name: com.mysql.cj.jdbc.Driver  
    url: jdbc:mysql://localhost:3306/your_database?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC  
    username: your_username  
    password: your_password  
    # Druid特有配置  
    druid:  
      initial-size: 5  
      max-active: 10  
      min-idle: 5  
      max-wait: 10000  
      stat-view-servlet:  
        enabled: true  
        url-pattern: /druid/*  
        # 登录用户名和密码  
        login-username: admin  
        login-password: admin  
      filter:  
        stat:  
          enabled: true  
        wall:  
          enabled: true  
          config:  
            multi-statement-allow: true

3. 使用数据源
   由于Spring Boot的自动配置功能，你通常不需要编写任何代码来创建或配置数据源。Spring Boot会自动根据application.yml或application.properties中的配置来创建并配置数据源。

你可以在Spring Boot的组件或服务中注入DataSource接口来使用数据源，如下所示：

import javax.sql.DataSource;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyDatabaseService {  
  
    @Autowired  
    private DataSource dataSource;  
  
    public void someDatabaseOperation() {  
        // 使用dataSource进行数据库操作...  
    }  
}

4. 监控页面
   如果你启用了Druid的监控功能（如上application.yml中所示），你可以通过访问http://localhost:8080/druid/（假设你的应用运行在8080端口）来查看数据库的监控信息。你需要使用配置中指定的用户名和密码（在本例中是admin/admin）进行登录。

注意

• 确保你的数据库驱动与你的数据库版本兼容。
• Druid提供了很多配置选项，你可以在官方文档中找到它们并根据需要进行配置。
• 如果你使用的是Spring Boot的较新版本，并且你的IDE或构建工具（如Maven或Gradle）配置正确，那么你可能不需要执行任何额外的步骤来集成Druid，因为druid-spring-boot-starter已经为你处理了很多事情。