java后端开发系列学习总结

最新推荐文章于 2024-04-04 13:21:10 发布

白了少秃头

最新推荐文章于 2024-04-04 13:21:10 发布

阅读量401

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_53874326/article/details/132434183

版权

一、Spring

（1）Spring中的一些常见标签

Spring框架中有多个标签用于配置和管理应用程序的组件和功能。以下是一些常见的Spring标签及其作用：

<bean> 标签：用于定义和配置一个Java对象，也称为bean。它包含bean的类名、属性、依赖和其他配置信息。
<context:component-scan> 标签：用于自动扫描并注册带有特定注解（如@Component、@Controller、@Service等）的bean。
<context:annotation-config> 标签：用于启用基于注解的配置，允许在bean类中使用注解配置，例如@Autowired、@Value等。
<mvc:annotation-driven> 标签：用于启用Spring MVC的注解驱动功能，使得在控制器类中可以使用@RequestMapping、@ModelAttribute以及其他注解来处理HTTP请求。
<aop:config> 标签：用于配置面向切面编程（AOP）的相关内容，例如切面、切点、通知等。
<tx:annotation-driven> 标签：用于启用基于注解的事务管理，使得可以在方法或类级别使用@Transactional注解来管理事务。
<util:properties> 标签：用于加载和管理属性文件，可以在应用程序中使用<property name="..." value="..." />语法来引用属性值。
<mvc:view-resolvers> 标签：用于配置视图解析器，将逻辑视图名称解析为实际视图。
<mvc:resources> 标签：用于配置静态资源处理，可以指定静态资源的位置和URL映射规则。

以上只是Spring框架中一些常用的标签，还有其他标签可用于配置不同的功能和扩展。具体使用哪些标签取决于应用程序需求。

（2）Spring的一些常见注解

Spring框架中有许多注解，用于在应用程序中配置和管理各种组件和功能。以下是一些常见的Spring注解及其作用：

@Component：标记一个类作为组件，让Spring自动创建bean并进行管理。
@Controller：标记一个类作为MVC控制器，用于处理用户请求。
@Service：标记一个类作为服务层组件，通常用于定义业务逻辑。
@Repository：标记一个类作为数据访问层组件，用于访问数据库或其他持久化机制。
@Autowired：自动注入依赖关系，通过类型匹配自动将合适的bean注入到属性、构造函数或方法参数中。
@Qualifier：与@Autowired一起使用，通过指定bean的名称或标识符来指定具体的依赖注入。
@Value：用于注入外部配置文件中的值，类似于@Autowired，但主要用于注入简单的值而不是依赖关系。
@RequestMapping：用于映射URL路径到控制器的方法，指定HTTP请求方法、请求参数和其他条件。
@ResponseBody：将方法的返回值直接作为HTTP响应的内容返回给客户端，常用于RESTful风格的控制器。
@PathVariable：用于从URL路径中提取参数值，用于动态地处理RESTful风格的URL。
@Transactional：标记一个方法或类需要进行事务管理，Spring将自动管理事务的开始、提交、回滚等操作。
@Configuration：标记一个类作为配置类，用于替代XML配置文件，定义bean和其他配置信息。
@Bean：在配置类中使用，用于声明一个bean，并指定其创建和初始化的方法。
@Profile：根据不同的环境或配置文件选择性地加载bean，可用于实现不同环境下的配置切换。

以上只是Spring框架中一些常用的注解，还有其他注解用于实现不同的功能和特性。具体使用哪些注解取决于应用程序需求和Spring版本。

二、Spring Boot

Spring Boot 是一个基于 Spring 框架的开发框架，简化了 Spring 应用程序的配置和部署。下面是一些在 Spring Boot 中常用的注解及其作用：

@SpringBootApplication：标记一个主启动类，表示这是一个 Spring Boot 应用程序的入口点。它包含了@Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解。
@RestController：组合了 @Controller 和 @ResponseBody，用于创建 RESTful 风格的控制器，返回结果可以直接以 JSON 或 XML 形式输出。
@RequestMapping：用于映射 URL 路径到控制器的方法，指定 HTTP 请求方法、请求参数和其他条件。
@Autowired：自动注入依赖关系，通过类型匹配自动将合适的 Bean 注入到属性、构造函数或方法参数中。
@Value：用于注入外部配置文件中的值，类似于 @Autowired，但主要用于注入简单的值而不是依赖关系。
@ConfigurationProperties：将配置文件中的属性绑定到一个类上，用于读取和管理应用程序的配置。
@Component：将一个类标记为组件，让 Spring Boot 自动创建 Bean 并进行管理。
@EnableAutoConfiguration：启用 Spring Boot 的自动配置机制，根据类路径和依赖关系自动配置 Spring 应用程序。
@EnableWebMvc：启用 Spring MVC 的注解驱动功能，用于处理 Web 请求和构建 RESTful 服务。
@Entity：标记一个类作为 JPA 实体类，用于与数据库表进行映射。
@Repository：标记一个类作为数据访问层组件，用于访问数据库或其他持久化机制。
@Service：标记一个类作为服务层组件，通常用于定义业务逻辑。
@Transactional：标记一个方法或类需要进行事务管理，Spring Boot 将自动管理事务的开始、提交、回滚等操作。
@ComponentScan：扫描指定包及其子包，将符合条件的类注册为 Bean。

三、Lombook

Lombok 是一个Java库，它通过注解来帮助开发人员简化Java类的编写。Lombok 通过在编译时自动生成代码，减少了样板代码的编写，提高了开发效率。以下是 Lombok 中一些常用的注解及其作用：

@Data：生成所有属性的 getter、setter、equals、hashCode 和 toString 方法。通常用于简化 POJO 类的编写。
@Getter / @Setter：生成属性的 getter / setter 方法。
@ToString：生成 toString 方法，输出对象的字符串表示形式。
@EqualsAndHashCode：生成 equals 和 hashCode 方法，用于比较对象的相等性。
@NoArgsConstructor：生成无参构造函数。
@AllArgsConstructor：生成全参构造函数。
@RequiredArgsConstructor：生成必需的参数构造函数。
@Builder：使用 Builder 模式生成构造对象的代码。
@Slf4j：生成一个 log 属性，用于在类中使用日志记录。
@NonNull：为属性添加非空检查，如果为空，则抛出空指针异常。
@Value：生成不可变的类，所有属性默认为 final，且只提供 getter 方法。
@Cleanup：自动关闭资源（如流、数据库连接等）。
@Synchronized：在方法或代码块上加锁。
@NoArgsConstructor, @AllArgsConstructor, @RequiredArgsConstructor 这三个注解可以与 @Data、@Value 等注解一起使用，用于生成构造函数。

Lombok 还有其他许多注解可以用于生成代码、处理异常、进行日志记录等。可以根据具体需求选择适合的注解来简化和优化代码编写过程。使用 Lombok 可以有效地减少样板代码，提高开发效率。

四、Spring Security

Spring Security 是一个功能强大且灵活的身份验证和授权框架，用于保护基于 Spring 的应用程序的安全性。它提供了一组开箱即用的特性和可配置的选项，用于管理用户认证、授权以及处理常见的安全问题。下面是 Spring Security 的一些关键功能和相关内容的详细介绍：

身份验证（Authentication）：Spring Security 提供了各种方式来进行用户身份验证，例如基于表单登录、HTTP 基本认证、Remember-Me 认证等。可以轻松地配置不同类型的身份验证机制，并支持自定义身份验证逻辑。
授权（Authorization）：Spring Security 支持基于角色或权限的访问控制，通过定义角色和权限的层次结构，可以精确控制用户对资源的访问权限。可以使用注解、表达式或编程方式来实现授权规则。
攻击防护（Protection against Attacks）：Spring Security 提供了多种防护机制来应对常见的安全攻击，如跨站点脚本攻击（XSS）、跨站点请求伪造（CSRF）、点击劫持等。它还支持密码存储的安全散列算法，如密码加盐、BCrypt 等。
Session 管理（Session Management）：Spring Security 提供了对用户会话的管理和控制，包括并发登录限制、Session 注销等。可以轻松地配置 Session 的存储方式和过期策略。
Remember-Me 记住我（Remember-Me）：通过 Remember-Me 功能，用户可以选择在下一次访问时自动登录，而无需重新进行身份验证。
安全事件和日志（Security Events and Logging）：Spring Security 提供了安全事件监听器和日志记录功能，可以监视和记录与安全相关的事件，以便进行审计和故障排查。
集成其他认证和授权机制（Integration with Other Authentication and Authorization Mechanisms）：Spring Security 支持与其他认证和授权机制的集成，如 LDAP、OAuth、OpenID 等。

（*）安全过滤器链（Security Filter Chain）

Spring Security 是一个用于身份验证和授权的强大安全框架，它提供了一组用于保护 Web 应用程序的库、API 和工具。Spring Security 的核心概念之一是安全过滤器链（Security Filter Chain），也称为 Spring Security 链路（Security Chain）。

Spring Security 的链路是由一系列的安全过滤器组成的，这些过滤器按照特定的顺序依次执行，每个过滤器都负责处理不同的安全任务。通过配置和定制这些过滤器，我们可以实现自定义的身份验证和授权逻辑。

下面将详细介绍其中的14个常用的链路类及其功能。

ChannelProcessingFilter：这个过滤器用于处理请求的安全通道（HTTP 或 HTTPS）。它检查请求的协议是否与配置要求的协议一致。
SecurityContextPersistenceFilter：该过滤器负责在请求之间持久化用户的安全上下文。它将安全上下文存储在会话、Cookie 或请求头中，以便在后续请求中进行访问。
ConcurrentSessionFilter：当用户尝试通过一个会话进行身份验证时，该过滤器用于检查当前用户是否已在其他地方登录，并且已经达到最大会话数。如果超过了最大会话数，该过滤器将阻止用户继续进行身份验证。
LogoutFilter：这个过滤器负责处理用户的注销操作。它接收注销请求并执行相关的操作，例如清除会话信息、删除身份验证凭证等。
UsernamePasswordAuthenticationFilter：该过滤器用于处理基于用户名和密码的身份验证请求。它接收用户的登录表单，并进行身份验证。
BasicAuthenticationFilter：当用户尝试通过 HTTP 基本认证进行身份验证时，该过滤器负责检查请求头中是否包含有效的基本认证凭证。
DigestAuthenticationFilter：这个过滤器用于处理 HTTP 摘要认证。它负责验证摘要信息，并与存储在后端的用户凭证进行比对。
RememberMeAuthenticationFilter：当用户选择记住我功能时，该过滤器负责处理使用记住我功能进行身份验证的请求。
AnonymousAuthenticationFilter：如果没有其他身份验证过滤器对请求进行身份验证，或者用户请求匿名访问，该过滤器将为用户提供一个匿名身份。
ExceptionTranslationFilter：这个过滤器负责处理 Spring Security 中的异常。它捕获并处理访问拒绝、身份验证失败等异常，并根据配置进行适当的处理。
FilterSecurityInterceptor：这是 Spring Security 链路中最重要的过滤器之一。它负责执行访问控制决策，即基于配置的权限验证。该过滤器与 AccessDecisionManager 和 AuthenticationManager 一起工作，判断用户是否有权限访问请求的资源。
SwitchUserFilter：当管理员希望以其他用户身份登录并执行操作时，可以使用该过滤器。它允许管理员在已经登录的情况下切换到其他用户身份来执行特定任务。
SessionManagementFilter：这个过滤器用于管理用户的会话。它可以配置会话固定保护、会话并发控制等功能，以增强会话的安全性。
CsrfFilter：该过滤器用于防止跨站请求伪造（CSRF）攻击。它通过验证请求中的 CSRF 令牌来确保请求的合法性。

通过配置 Spring Security，我们可以根据应用程序的需求来实现各种复杂的安全场景。它提供了一套强大的工具和功能，使开发人员能够专注于应用程序的业务逻辑而不必过多关注安全性。

五、UUID

UUID（Universally Unique Identifier）是一个128位长的标识符，用于唯一地标识信息或实体。它在计算机系统和网络中广泛应用，具有以下作用：

唯一性：UUID 的设计目标是保证全球范围内的唯一性。几乎可以忽略重复的概率，在分布式系统中使用 UUID 可以避免主键冲突的问题。
无序性：UUID 是基于时间戳、MAC 地址和随机数等因素生成的，因此没有特定的顺序。这在需要对数据进行匿名化处理或隐藏真实标识时非常有用。
私密性：UUID 没有规律可循，不容易被猜测和猜测到。这对于需要保护用户隐私或防范恶意攻击非常重要。

下面是一个 Java 中使用 UUID 的简单示例：

import java.util.UUID;

public class UUIDExample {
    public static void main(String[] args) {
        // 随机生成一个 UUID
        UUID uuid = UUID.randomUUID();
        System.out.println("UUID: " + uuid.toString());

        // 解析字符串形式的 UUID
        String uuidString = "550e8400-e29b-41d4-a716-446655440000";
        UUID parsedUUID = UUID.fromString(uuidString);
        System.out.println("Parsed UUID: " + parsedUUID.toString());

        // 获取 UUID 的各个部分
        System.out.println("Most Significant Bits: " + uuid.getMostSignificantBits());
        System.out.println("Least Significant Bits: " + uuid.getLeastSignificantBits());

        // 比较两个 UUID 是否相等
        UUID anotherUUID = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");
        System.out.println("UUID equals: " + uuid.equals(anotherUUID));
    }
}

以上代码示例展示了随机生成 UUID、解析字符串形式的 UUID、获取 UUID 的各个部分以及比较两个 UUID 是否相等的操作。

总之，UUID 是一种用于唯一标识信息的标识符。它具有全球范围内的唯一性和无序性，并且可以保护用户隐私和防范恶意攻击。在分布式系统、数据库、面向公众的应用等领域广泛应用。

六、JWT

JWT（JSON Web Token）是一种用于身份验证和授权的开放标准。它是一种轻量级的、基于 JSON 的令牌，由三个部分组成：头部（Header）、载荷（Payload）和签名（Signature）。下面详细介绍 JWT 的各个部分和使用方式：

头部（Header）：头部通常包含两部分信息：令牌的类型（typ）和所使用的签名算法（alg）。这部分信息会进行 Base64Url 编码后与载荷一起构成 JWT 的第一部分。
载荷（Payload）：载荷是 JWT 的主要内容，包含了一些被称为声明（Claims）的信息。声明可以分为三种类型：注册声明（Registered Claims）、公共声明（Public Claims）和私有声明（Private Claims）。
- 注册声明：这些声明是在 JWT 规范中定义的一些标准声明，如 iss（签发者）、exp（过期时间）、sub（面向用户）等。
- 公共声明：这些声明是自定义的声明，可以根据需要添加，但建议避免冲突。
- 私有声明：这些声明是用于在双方之间共享自定义的信息，但不属于 JWT 规范的部分。
签名（Signature）：签名是为了验证 JWT 是否被篡改，防止伪造。签名通常是通过将头部、载荷和一个密钥使用特定的签名算法（如 HMAC、RSA）进行加密生成的。接收者在验证 JWT 时，会重新计算签名并与原始签名进行比较，以确保 JWT 的完整性。

使用 JWT 的典型流程如下：

身份验证：用户提供有效的凭证（如用户名和密码），服务器验证凭证的正确性后，生成一个包含所需信息的 JWT 并返回给客户端。
请求授权：客户端将 JWT 包含在请求的头部或参数中发送给服务器，用于证明其身份。
验证授权：服务器接收到 JWT 后，首先对其进行签名验证，然后解析出有效载荷中的信息进行验证，例如验证过期时间是否过期、验证签发者等。

JWT 的优点包括：

无状态性：服务器不需要保存任何会话信息，所有的信息都包含在 JWT 中，简化了服务端的管理和扩展。
可扩展性：载荷中可以包含自定义的声明信息，具有高度的灵活性。
安全性：通过签名机制保证了 JWT 的完整性，防止伪造和篡改。

但也要注意以下几点：

敏感信息：避免将敏感信息直接存储在 JWT 中，因为 JWT 是可解码的，而签名只保证了完整性，并不能保证机密性。
过期时间：适当设置 JWT 的过期时间，避免 JWT 被滥用。

总之，JWT 是一种简单且安全的身份验证和授权解决方案，通过将相关信息以令牌形式进行传递和验证，使得跨系统、跨平台的身份验证变得更加便捷和可靠。

（*）JWT案例实现

下面是一个使用 Java 实现 JWT 的简单示例：

首先，你需要添加 Java JWT 库的依赖。可以使用 Maven 或 Gradle 进行管理，以下是使用 Maven 进行配置的示例

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.1</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.1</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.1</version>
    <scope>runtime</scope>
</dependency>

接下来是一个简单的使用示例:

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;

import java.security.Key;
import java.util.Date;

public class JwtExample {

    public static void main(String[] args) {
        // 生成秘钥
        Key key = Keys.secretKeyFor(SignatureAlgorithm.HS256);

        // 构建 JWT
        String jwt = Jwts.builder()
                .setSubject("user123") // 设置主题（面向用户）
                .setIssuer("example.com") // 设置签发者
                .setIssuedAt(new Date()) // 设置签发时间
                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 设置过期时间为 1 小时后
                .claim("role", "admin") // 添加自定义声明
                .signWith(key) // 使用秘钥进行签名
                .compact(); // 生成 JWT 字符串

        System.out.println("生成的 JWT：" + jwt);

        // 解析 JWT
        Jws<Claims> claimsJws = Jwts.parserBuilder()
                .setSigningKey(key) // 设置秘钥
                .build()
                .parseClaimsJws(jwt);

        Claims claims = claimsJws.getBody();

        System.out.println("解析得到的主题：" + claims.getSubject());
        System.out.println("解析得到的签发者：" + claims.getIssuer());
        System.out.println("解析得到的签发时间：" + claims.getIssuedAt());
        System.out.println("解析得到的过期时间：" + claims.getExpiration());
        System.out.println("解析得到的自定义声明 role：" + claims.get("role"));
    }
}

述示例中，我们使用了 Java JWT 库（jjwt）来生成 JWT。通过 Jwts.builder() 可以构建一个 JWT，然后设置相关的声明信息，最后使用 signWith(key) 方法来使用指定的秘钥进行签名，compact() 方法用于生成最终的 JWT 字符串。

在解析 JWT 时，我们使用 Jwts.parserBuilder() 设置秘钥，并通过 parseClaimsJws(jwt) 方法来解析 JWT。得到 Claims 对象后，可以获取其中的各个声明信息。

请注意替换示例中的主题、签发者、自定义声明以及过期时间等信息，根据实际需求进行使用。

七、mybatis

MyBatis 是一款开源的持久层框架，它简化了数据库访问的过程，通过将 SQL 语句与 Java 代码进行解耦，使开发人员能够更加专注于业务逻辑而不必过多关注数据访问的细节。以下是 MyBatis 的相关实现内容的详细介绍：

数据库连接配置（Database Connection Configuration）：在 MyBatis 中，首先需要配置数据库连接信息，包括数据库驱动、连接地址、用户名、密码等。可以使用 XML 或 Java 代码来进行配置。
SQL 映射文件（SQL Mapping File）：SQL 映射文件是 MyBatis 的核心部分，它定义了 SQL 语句与 Java 方法之间的映射关系。在 SQL 映射文件中，可以编写原生的 SQL 语句，也可以使用 MyBatis 提供的动态 SQL 功能，如 if、choose、foreach 等标签。
SQL 会话工厂（SQL Session Factory）：SQL 会话工厂是 MyBatis 的核心接口，用于创建和管理 SQL 会话（SQL Session）。SQL 会话工厂可以通过 XML 配置文件或 Java 代码进行配置，并且可以支持连接池技术。
数据对象映射（Data Object Mapping）：MyBatis 支持将查询结果映射到 Java 对象上，简化了数据结果的处理过程。可以使用 ResultMap 来配置对象与数据库表之间的映射关系，并且支持一对一、一对多、多对一等复杂的对象关系。
动态 SQL（Dynamic SQL）：MyBatis 提供了丰富的动态 SQL 功能，可以根据条件来动态生成 SQL 语句，以灵活地满足不同的查询需求。通过使用 if、choose、foreach 等标签，可以实现条件判断、分支选择、迭代循环等复杂的查询逻辑。
缓存（Caching）：MyBatis 内置了一级缓存和二级缓存机制，可以提高数据库访问性能。一级缓存是会话级别的缓存，用于缓存会话期间的查询结果；二级缓存是应用级别的缓存，可以在多个会话之间共享缓存数据。
插件（Plugins）：MyBatis 支持插件机制，允许开发人员在 SQL 执行过程中进行拦截和修改。通过自定义插件，可以实现日志记录、数据加密、性能监控等功能。

(*)mybatis案例示例

创建数据库表和数据：假设有一个名为 student 的表，包含 id、name 和 age 字段。

引入相关依赖：在项目的 Maven 或 Gradle 配置文件中添加 MyBatis 相关的依赖。

编写 MyBatis 配置文件：在资源目录下创建 mybatis-config.xml 文件，并配置数据源以及其他 MyBatis 相关的属性。

创建 Student 实体类：创建一个 Student 类，包含 id、name 和 age 属性，并为它们提供相应的 getter 和 setter 方法。

创建 Mapper 接口：创建一个 StudentMapper 接口，并定义一个查询方法，例如 selectById 方法。
public interface StudentMapper {
    Student selectById(int id);
}
6.编写 Mapper XML 文件：在与 StudentMapper 接口对应的目录下创建 StudentMapper.xml 文件，并编写 SQL 查询语句。
<?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 namespace="com.example.mapper.StudentMapper">
    <select id="selectById" resultType="com.example.entity.Student">
        SELECT * FROM student WHERE id = #{id}
    </select>
</mapper>
7.创建 MyBatis 接口实现类：创建一个实现 StudentMapper 接口的实现类，并注入需要的依赖。
public class StudentMapperImpl implements StudentMapper {

    private final SqlSessionFactory sqlSessionFactory;

    public StudentMapperImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    @Override
    public Student selectById(int id) {
        try (SqlSession session = sqlSessionFactory.openSession()) {
            StudentMapper mapper = session.getMapper(StudentMapper.class);
            return mapper.selectById(id);
        }
    }
}
8.创建 MyBatis 配置类：创建一个用于初始化 MyBatis 相关对象的配置类，例如 MyBatisConfig。
public class MyBatisConfig {

    public SqlSessionFactory sqlSessionFactory() throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }

    public StudentMapper studentMapper() throws Exception {
        SqlSessionFactory sqlSessionFactory = sqlSessionFactory();
        return new StudentMapperImpl(sqlSessionFactory);
    }
}
9.测试查询操作：编写一个测试类，通过 MyBatis 的接口来查询数据。
public class Main {
    public static void main(String[] args) throws Exception {
        MyBatisConfig config = new MyBatisConfig();
        StudentMapper studentMapper = config.studentMapper();
        Student student = studentMapper.selectById(1);
        System.out.println(student);
    }
}

八、mybatis-plus

MyBatis-Plus 是基于 MyBatis 的增强工具库，提供了一系列简化开发的功能和增加的特性，下面是 MyBatis-Plus 与 MyBatis 的区别以及 MyBatis-Plus 的相关功能介绍：

区别：
- 构建层级：MyBatis 是持久层框架，而 MyBatis-Plus 则是在 MyBatis 的基础上构建的增强工具库。
- 抽象封装：MyBatis 提供了基本的 SQL 映射功能，需要手动编写 SQL，而 MyBatis-Plus 在此基础上封装了更高层次的抽象，提供更便捷的 CRUD（增删改查）操作。
MyBatis-Plus 的相关功能介绍：
- 自动代码生成：MyBatis-Plus 提供了代码生成器，能够根据数据库表结构自动生成对应的实体类、Mapper 接口和 XML 映射文件，大幅度减少了手动编写重复代码的工作量。
- 通用 CRUD 操作：MyBatis-Plus 提供了通用的 Mapper 接口，通过继承该接口，即可获得常见的增删改查方法，无需手动编写 SQL，大大简化了数据访问层的开发。
- 条件构造器：MyBatis-Plus 提供了强大的条件构造器，可以通过编程方式灵活拼接查询条件，避免了繁琐的手动拼接 SQL。
- 分页查询：MyBatis-Plus 提供了内置的分页插件，支持各种数据库的分页查询功能，使用起来非常方便。
- 逻辑删除：MyBatis-Plus 支持逻辑删除功能，可以通过注解方式标记逻辑删除字段，并自动将删除操作转换为更新操作。
- 更多特性：MyBatis-Plus 还提供了乐观锁支持、性能分析 SQL 打印、动态表名等一系列增强功能，极大地简化了开发过程。

总之，MyBatis-Plus 在 MyBatis 的基础上提供了更高层次的抽象和更丰富的功能，使得开发者能够更加轻松地进行数据库访问层的开发，减少了重复劳动，提高了开发效率。同时，MyBatis-Plus 可以与原生 MyBatis 共同使用，不会造成冲突，具有很好的兼容性。

（*）mybatis-plus案例示例

假设有一个实体类 User，对应数据库中的 user 表，包含以下字段：
public class User {
    private Long id;
    private String username;
    private Integer age;
    // 其他字段...
    // getter 和 setter 方法...
}
配置 MyBatis-Plus：
添加 MyBatis-Plus 依赖：可以在 Maven 或 Gradle 中添加以下依赖，版本号根据实际情况选择。

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-core</artifactId>
    <version>3.x.x</version>
</dependency>

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.x.x</version>
</dependency>
代码示例：
定义 Mapper 接口：
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
编写 Service 类：
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 可以自定义扩展方法...
}
编写 Controller 类:
@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getById(id);
    }
    
    @PostMapping("/users")
    public boolean createUser(@RequestBody User user) {
        return userService.save(user);
    }
    
    @PutMapping("/users/{id}")
    public boolean updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userService.updateById(user);
    }
    
    @DeleteMapping("/users/{id}")
    public boolean deleteUser(@PathVariable Long id) {
        return userService.removeById(id);
    }
}
运行测试：启动 Spring Boot 应用，然后可以使用 Postman 或其他工具来调用上述接口进行用户数据的增删改查操作。

以上是一个简单的 MyBatis-Plus 的示例案例，通过继承 BaseMapper 接口，可以获得常见的 CRUD 操作方法。同时，也可以在 Service 类中自定义扩展方法，以满足特定的业务需求

（*）

如果需要在 MyBatis-Plus 中新增一些其没有提供的查询条件，可以通过自定义 SQL 来实现。下面是在以上示例代码基础上扩展一个自定义查询条件的案例：

假设我们需要根据用户的性别（gender）和年龄（age）来进行查询，可以按照以下步骤进行操作：

在 UserMapper 接口中新增一个方法用于自定义查询：

@Mapper
public interface UserMapper extends BaseMapper<User> {
    List<User> selectByGenderAndAge(@Param("gender") Integer gender, @Param("age") Integer age);
}

在 UserService 接口中声明该方法：

public interface UserService extends IService<User> {
    List<User> selectByGenderAndAge(Integer gender, Integer age);
}

在 UserServiceImpl 类中实现该方法：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    
    @Override
    public List<User> selectByGenderAndAge(Integer gender, Integer age) {
        return userMapper.selectByGenderAndAge(gender, age);
    }
}

在 UserController 类中添加对应的接口方法：

@RestController
public class UserController {
    // 省略其他代码...
    
    @GetMapping("/users")
    public List<User> getUsersByGenderAndAge(@RequestParam Integer gender, @RequestParam Integer age) {
        return userService.selectByGenderAndAge(gender, age);
    }
}

通过以上步骤，我们就可以通过 /users 接口来实现根据性别和年龄进行查询的功能。注意，这里的查询条件是自定义的，并不是 MyBatis-Plus 提供的默认方法。在 UserMapper 中编写相应的 SQL 语句，可以使用注解 @Select 或在 XML 映射文件中编写对应的 SQL。

(*)mybatis与mybatis-plus集成

MyBatis-Plus 与 MyBatis 集成，仍然支持使用 mapper.xml 文件来编写自定义 SQL。

使用 MyBatis-Plus 进行开发时，可以选择两种方式编写 SQL：

注解方式：可以在 Mapper 接口方法上使用注解 @Select、@Update、@Insert、@Delete 等来编写对应的 SQL。这种方式适合编写简单的 SQL 语句。
XML 映射文件方式：可以将 SQL 语句写在独立的 mapper.xml 文件中，通过 <mapper> 标签与接口进行映射。这种方式适合编写复杂的 SQL 语句，提高可维护性和可读性。

如果你希望使用 mapper.xml 文件编写 SQL，可以按照以下步骤进行操作：

创建 mapper.xml 文件：在资源目录下创建一个与 Mapper 接口相对应的目录，然后在该目录下创建一个与接口同名的 mapper.xml 文件。
编写 SQL 语句：在 mapper.xml 文件中编写对应的 SQL 语句，可以像使用传统的 MyBatis 一样进行编写。
在接口中添加对应的方法：在 Mapper 接口中声明与 mapper.xml 文件中的 SQL 语句相对应的方法。
配置 mapper.xml 的加载：在 application.yml（或 application.properties）中配置 MyBatis 的 mapper.xml 文件的加载路径。

通过以上步骤，就可以在 MyBatis-Plus 中使用 mapper.xml 文件来编写自定义 SQL 语句了。

需要注意的是，如果你只需要执行简单的增删改查操作，而不需要定制化的 SQL，那么 MyBatis-Plus 提供的默认方法已经足够满足需求，无需编写额外的 SQL 语句。

希望以上解答能对你有所帮助！如果你有任何其他问题，请随时提问。

九、Druid

Druid 是一个开源的数据库连接池和监控平台。它提供了更加高效、可靠的数据库连接管理，以及丰富的监控和统计功能。下面我将介绍一下 Druid 的相关配置和方法实现。

引入依赖：在项目的 Maven 或 Gradle 配置文件中添加 Druid 相关的依赖。

配置数据源：在 Spring Boot 项目中，可以通过在 application.properties 或 application.yml 文件中进行配置。以下是一个示例的 Druid 数据源配置信息：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    initial-size: 5
    min-idle: 5
    max-active: 20
    max-wait: 30000
    time-between-eviction-runs-millis: 60000
    min-evictable-idle-time-millis: 300000
    validation-query: SELECT 1
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    filters: stat,wall,log4j
    connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

这里配置了数据库的 URL、用户名、密码、驱动类等信息。另外，还配置了连接池的一些属性，包括初始连接数、最小空闲连接数、最大活跃连接数、连接的最长等待时间等。

配置 Druid 监控界面（可选）：使用 Druid 提供的监控功能，可以通过浏览器访问一个监控页面来查看数据库连接池的统计信息。在 Spring Boot 项目中，可以通过添加以下依赖和配置来启用监控页面：

<!-- 引入 Druid 监控页面依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.6</version>
</dependency>

# 开启 Druid 的监控页面
spring:
  datasource:
    druid:
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*

配置完成后，可以通过访问 http://localhost:port/druid 来查看监控页面。

使用 Druid 连接池：在需要使用数据库连接的地方，可以直接注入 Druid 提供的 DruidDataSource 对象，并使用它获取数据库连接。以下是一个示例：

import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class Main {
    private final DruidDataSource dataSource;

    public Main(DruidDataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void executeQuery() throws SQLException {
        Connection connection = dataSource.getConnection();
        // 执行查询操作
        // ...
        connection.close();
    }
}

在上述示例中，通过注入 DruidDataSource 对象，可以使用 getConnection() 方法获取数据库连接对象。

Druid 不仅提供了高效的数据库连接池，还具备了丰富的监控和统计功能，可以帮助我们更好地管理和优化数据库连接。以上是一个简单的 Druid 配置和使用示例，你可以根据自己的需求进行修改和扩展。

白了少秃头

关注

1
点赞
踩
11

收藏

觉得还不错? 一键收藏
1
评论
java后端开发系列学习总结

Spring框架中有多个标签用于配置和管理应用程序的组件和功能。标签：用于定义和配置一个Java对象，也称为bean。它包含bean的类名、属性、依赖和其他配置信息。标签：用于自动扫描并注册带有特定注解（如@Component@Service等）的bean。标签：用于启用基于注解的配置，允许在bean类中使用注解配置，例如@Autowired@Value等。标签：用于启用Spring MVC的注解驱动功能，使得在控制器类中可以使用以及其他注解来处理HTTP请求。
复制链接

扫一扫