Java注解之@NotBlank，一文掌握@NotBlank注解知识(1)

2024-01-08 00:26:15

在这里插入图片描述

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
🎉欢迎 👍点赞?评论?收藏

Java注解知识专栏学习

Java注解知识云集	访问地址	备注
Java注解知识点(1)	https://blog.csdn.net/m0_50308467/article/details/135240536	Java注解专栏
Java注解知识点(2)	https://blog.csdn.net/m0_50308467/article/details/135263693	Java注解专栏
Java注解知识点(3)	https://blog.csdn.net/m0_50308467/article/details/135278911	Java注解专栏
Java注解知识点(4)	https://blog.csdn.net/m0_50308467/article/details/135302054	Java注解专栏
Java注解知识点(5)	https://blog.csdn.net/m0_50308467/article/details/135402918	Java注解专栏

文章目录

🏆 学习Java 校验注解之@NotNull、@NotEmpty 和 @NotBlank
- 🔎 Java 校验注解 @NotNull、@NotEmpty 和 @NotBlank

🏆 学习Java 校验注解之@NotNull、@NotEmpty 和 @NotBlank

🔎 Java 校验注解 @NotNull、@NotEmpty 和 @NotBlank

🍁 01、解释一下 @NotNull、@NotEmpty 和 @NotBlank 注解的区别？

当对于字段或方法参数的非空性进行验证时，@NotNull、@NotEmpty 和 @NotBlank 是三个常见的验证注解。

1. @NotNull 注解用于验证 对象 是否为 null，它可以应用于字段和方法参数上。如果被注解的字段为 null，则验证失败。

2. @NotEmpty 注解用于验证 字符串、集合或数组 是否为空。它可以应用于字符串、集合和数组类型的字段和方法参数上。如果被注解的字符串为空字符串 “”，或集合/数组为空，则验证失败。

3. @NotBlank 注解用于验证 字符串 是否为空格或不为空。 注意：它只可以应用于字符串类型的字段和方法参数上 。如果被注解的字符串为空或只包含空格，则验证失败。

三者的主要区别在于验证的对象类型不同。@NotNull 验证对象，@NotEmpty 验证字符串、集合或数组，而 @NotBlank 仅验证字符串。因此，你应该根据验证的对象类型选择合适的注解进行使用。

此外，在使用 @NotEmpty 和 @NotBlank 进行字符串验证时，需要注意它们之间的区别。@NotEmpty 只验证为空，而 @NotBlank 验证的是字符串除去空格后是否还有内容。如果字符串只包含空格，请使用 @NotBlank 验证注解。

验证注解	作用对象	验证内容	错误情况
@NotNull	字段和方法参数	对象是否为 null	如果被注解的字段为 null，则验证失败
@NotEmpty	字符串、集合和数组类型的字段和方法参数	字符串、集合或数组是否为空	如果被注解的字符串为空字符串 “”，或集合/数组为空，则验证失败
@NotBlank	字符串类型的字段和方法参数	字符串是否为空格或不为空	如果被注解的字符串为空或只包含空格，则验证失败

表格中显示了 @NotNull、@NotEmpty 和 @NotBlank 的区别。这些注解的作用对象、验证的内容以及验证失败的情况有所不同。

需要注意的是，@NotBlank 注解只适用于字符串类型的字段和方法参数，并且也验证空格字符。因此，它在检查表单字段等情况时特别有用。同时，@NotEmpty 验证是否为空，但不验证空格。如果要同时验证空格和空，需要使用 @NotBlank 注解。

下面是 Java 中使用 @NotNull、@NotEmpty 和 @NotBlank 的代码示例：

// 使用 @NotNull 验证参数不为 null
public void exampleMethod(@NotNull String name) {
    // 方法内容
}

// 使用 @NotEmpty 验证字符串不为空
public void exampleMethod2(@NotEmpty String name) {
    // 方法内容
}

// 使用 @NotBlank 验证字符串不为空或空格
public void exampleMethod3(@NotBlank String name) {
    // 方法内容
}

在上面的代码示例中，我们可以看到如何使用 @NotNull、@NotEmpty 和 @NotBlank 进行验证。每个注解都采用简单的方式标注需要进行验证的方法参数或字段。如果不符合验证条件，将抛出异常并中断程序。

另一种使用 @NotEmpty 的方式是使用 Bean Validation API 验证实体对象。下面是示例代码：

import jakarta.validation.constraints.NotEmpty;

public class User {

    @NotEmpty
    private String name;

    public User(String name) {
        this.name = name;
    }
}

在这个示例中，我们使用 @NotEmpty 注解来标注“name”字段，在使用 Bean Validation API 验证这个实体对象时，它将验证“name”字段是否为空。

当使用这些注解时，可以根据具体的情况和需要进行灵活的配置。以下是更多的使用示例：

1.配合校验框架使用：可以使用流行的校验框架，如 Hibernate Validator 或 Spring Validation，以在 JavaBean 上进行注解驱动的验证。例如，使用 Hibernate Validator 的验证示例：

import jakarta.validation.constraints.NotEmpty;
import org.hibernate.validator.constraints.Length;

public class User {

    @NotEmpty
    @Length(min = 3, max = 20)
    private String username;

    public User(String username) {
        this.username = username;
    }

    // Getters and setters
}

在上述示例中，我们使用了 @NotEmpty 注解来验证 username 字段不为空，并使用 @Length 注解来限制 username 字段的长度为 3 到 20 个字符之间。

2.集合和数组验证：@NotEmpty 注解可以用于验证集合或数组是否为空。以下是示例代码：

import jakarta.validation.constraints.NotEmpty;

public class MyClass {

    @NotEmpty
    private List<String> myList;

    public MyClass(List<String> myList) {
        this.myList = myList;
    }

    // Getters and setters
}

在上述示例中，我们使用 @NotEmpty 注解来验证 myList 集合不为空。同样的规则也适用于数组类型。

注意：上述示例中使用的是 jakarta.validation.constraints.NotEmpty 注解，该注解是在 Jakarta Bean Validation 规范中定义的，相当于以前的 javax.validation.constraints.NotEmpty 注解。

总结起来，通过对方法参数、实体对象字段或集合/数组应用 @NotNull、@NotEmpty 和 @NotBlank 注解，可以在开发过程中在关键位置对数据的有效性进行验证和保护。这样可以避免不必要的错误，提高代码的健壮性和可靠性。

🍁 02、怎样使用 @NotNull、@NotEmpty 和 @NotBlank 注解验证方法参数？

@NotNull、@NotEmpty和@NotBlank这些注解都可以用于验证方法参数的有效性。它们的使用方式如下：

1.@NotNull：用于检查参数是否为null。如果参数为null，则验证失败。例如：

public void updateUser(@NotNull String username) {
    // 更新用户的逻辑
}

2.@NotEmpty：用于检查字符串、集合或数组类型参数是否为空。如果参数为空或null，则验证失败。例如：

public void createUser(@NotEmpty List<String> permissions) {
    // 创建用户的逻辑
}

3.@NotBlank：用于检查字符串类型参数是否为空或只包含空白字符。如果参数为空、null或只含有空白字符，则验证失败。例如：

public void createPost(@NotBlank String content) {
    // 创建帖子的逻辑
}

在上述示例中，我们在方法的参数上添加了相应的校验注解，以确保输入的参数满足特定的条件。如果参数不满足校验规则，则验证框架会抛出相应的异常，例如 javax.validation.ConstraintViolationException。

需要注意的是，使用这些校验注解时，需要在方法或类上声明为校验可用，可以使用 @Validated 注解开启方法参数的校验。例如：

@RestController
@Validated
public class UserController {
    //...
}

上述示例中，在 UserController 类上添加了 @Validated 注解，以开启方法参数的校验功能。

通过使用这些校验注解，可以方便地进行方法参数的有效性验证，避免无效或不符合要求的参数进入方法的处理逻辑中。这有助于提高代码的可靠性和健壮性。

🍁 03、什么情况下应该使用 @NotEmpty，而不是使用 @NotNull 注解？

@NotEmpty 和 @NotNull 注解是用于进行参数校验的注解，但它们在校验的对象上有所区别。下面是它们的主要区别和适用情况：

1.@NotEmpty：用于检查字符串、集合或数组类型参数是否为空。如果参数为空或null，则验证失败。适用于需要确保参数不为空，且长度或大小必须大于0的情况。例如，要求一个列表不能为null或空，或者要求一个字符串必须包含至少一个非空格字符。

public void createUser(@NotEmpty List<String> permissions) {
    // 创建用户的逻辑
}

public void updateUsername(@NotEmpty String newUsername) {
    // 更新用户名的逻辑
}

2.@NotNull：用于检查参数是否为null。如果参数为null，则验证失败。适用于需要确保参数不为null，但**不对参数的长度、大小或内容进行进一步的校验**。例如，要求一个对象参数不为null。

public void updateUser(@NotNull User user) {
    // 更新用户信息的逻辑
}

public void sendEmailToUser(@NotNull String userEmail) {
    // 发送邮件给用户的逻辑
}

因此，在选择使用 @NotEmpty 还是 @NotNull 注解时，主要考虑校验的要求。如果需要确保参数不为空，并且需要对参数的长度、大小或内容进行进一步校验，使用 @NotEmpty 注解。如果只需要确保参数不为null，而不需要进一步校验其长度或内容，使用 @NotNull 注解。

注意，这些注解通常与参数的数据类型相关。例如，@NotEmpty 注解适用于字符串、集合或数组类型的参数，而 @NotNull 注解适用于对象类型的参数。选择注解时，应根据具体的参数类型和校验需求来进行选择。

🍁 04、如何在 Spring Boot 中使用 @NotBlank 注解？

在 Spring Boot 中，使用 @NotBlank 注解需要先引入依赖。@NotBlank 注解属于 Hibernate Validator（也称为 Bean Validation）库的一部分，因此需要添加相应的依赖。

首先，在 Maven 项目中，可以在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

其中，spring-boot-starter-validation 是 Spring Boot 提供的用于集成 Hibernate Validator 的依赖。

然后，在需要进行参数校验的地方，可以使用 @NotBlank 注解进行校验。@NotBlank 注解适用于字符串类型的参数，它会验证参数是否非null且至少包含一个非空格字符。

以下是一个使用 @NotBlank 注解的示例：

import javax.validation.constraints.NotBlank;

@RestController
public class MyController {
    
    @PostMapping("/my-api")
    public ResponseEntity<String> myApi(@RequestBody @NotBlank String input) {
        // 处理业务逻辑
        return ResponseEntity.ok("Success");
    }
}

上述示例代码中，我们在 input 参数上使用了 @NotBlank 注解，用于确保接收到的字符串参数不为空且至少包含一个非空格字符。如果不满足校验条件，将抛出验证异常。而使用 @RequestBody 注解可以将请求体中的数据绑定到 input 参数上。

需要注意的是，为了使参数校验生效，必须在 Controller 或方法上添加 @Validated 注解，以启用验证。

import org.springframework.validation.annotation.Validated;

@RestController
@Validated
public class MyController {
    
    // ...
}

使用 @NotBlank 注解时，也可以结合其他的验证注解一起使用，以满足具体的校验需求。同时，可以自定义错误消息，以便更好地向用户反馈校验信息。

当在 Spring Boot 中使用 @NotBlank 注解时，可以根据需要自定义错误消息。可以通过使用 message 属性来指定自定义错误消息。

以下是一个示例：

import javax.validation.constraints.NotBlank;

@RestController
public class MyController {
    
    @PostMapping("/my-api")
    public ResponseEntity<String> myApi(@RequestBody @NotBlank(message = "输入不能为空") String input) {
        // 处理业务逻辑
        return ResponseEntity.ok("Success");
    }
}

在上述示例中，我们在 @NotBlank 注解的 message 属性上指定了自定义错误消息 “输入不能为空”。如果输入参数为空或只包含空格字符，则校验将失败，并返回该自定义错误消息。

此外，可以通过在 application.properties 或 application.yml 配置文件中进行全局配置来自定义 Bean Validation 的错误消息。例如，在 application.properties 文件中添加以下配置：

# 自定义错误消息
spring.messages.basename=validation-messages

然后，可以在 validation-messages.properties 文件中定义自定义错误消息，其中的键应与特定注解相关联。对于 @NotBlank 注解，可以添加以下内容：

NotBlank=my custom not blank message

这将覆盖默认的错误消息并显示为 “my custom not blank message”。

通过自定义错误消息，您可以更好地控制校验失败时向用户返回的信息，并提供更具体和可读性的错误消息。

🍁 05、你有使用 @NotNull、@NotEmpty 或 @NotBlank 注解的实际经验吗？

当这些注解被应用在项目中时，通常需要配合使用一些验证框架或库来实现真正的校验功能。以下是几个常见的验证框架和库示例：

1.Hibernate Validator：它是一个基于 Java Bean 标准的验证框架，可以在对象的字段级别做校验。它支持多种注解，其中包括 @NotNull、@NotEmpty 和 @NotBlank。可以通过在类上加 @Validated 注解或在方法参数上加 @Valid 注解来启用校验功能。

2.Spring Validation：这是 Spring 框架提供的一个验证框架，使用了 JSR 303 和 JSR 349 标准的注解来进行数据校验。除了 @NotNull、@NotEmpty 和 @NotBlank 注解外，还有其他常用的注解，如 @Min、@Max、@Email 等。可以在 Controller 的方法参数上使用 @Valid 注解来启用校验功能。

3.Apache Commons Validator：这是一个独立的 Java 类库，提供了各种验证方法和工具类。它提供了一系列的验证注解，如 @NotNull、@NotEmpty、@NotBlank 等，可以用于字段级别的校验。

使用这些验证框架和注解的好处是可以在编译时或运行时自动进行数据校验，减少了手动编写校验逻辑的工作量，并提供了更加统一和可读性强的校验错误信息。

下面以用一个示例来说明这些注解的使用情况。

在一个电商网站中，用户可以通过提交订单来购买商品。对于提交的订单数据，需要进行一些基本的校验，比如订单号不能为空、商品列表不能为空、收货人联系方式不能为空等。

对于每个校验条件，可以使用不同的注解来实现校验：

1.使用 @NotNull 校验订单号不能为 null

import javax.validation.constraints.NotNull;

public class Order {
    
    @NotNull(message = "订单号不能为空")
    private Long orderId;

    // Getters and setters
}

2.使用 @NotEmpty 校验商品列表不能为空

import javax.validation.constraints.NotEmpty;

public class Order {
    
    @NotEmpty(message = "商品列表不能为空")
    private List<Item> itemList;

    // Getters and setters
}

3.使用 @NotBlank 校验收货人联系方式不能为空

import javax.validation.constraints.NotBlank;

public class Order {
    
    @NotBlank(message = "联系电话不能为空")
    private String phone;

    // Getters and setters
}

在 Controller 中，可以使用 @Valid 注解启用参数校验，并将待校验数据作为方法的输入参数，如下所示：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
public class OrderController {

    @PostMapping("/order")
    public String submitOrder(@RequestBody @Valid Order order) {
        // 处理业务逻辑
        return "success";
    }
}

在上述代码中，我们在 Order 类上使用了 @Valid 注解，表示启用参数校验。接收到的 order 数据将首先进行校验。如果数据校验不通过，将抛出验证异常。否则，将处理业务逻辑并返回 “success” 成功信息。

使用这些注解，能够有效地对参数进行基本校验。当校验失败时，可以向用户提供更具体和可读性的错误消息，从而保障系统的安全性、稳定性和可用性。同时，在使用这些注解后，还可以通过一些插件和工具自动生成验证框架代码。这样可以提高生产效率和代码质量。

🍁 06、在使用 @NotNull 注解验证数据类型为 Long 的字段时，遇到的问题？

在使用 @NotNull 注解验证 Long 类型字段时，由于 Long 是一个包装类型，可能会遇到一些问题。

以下是一些常见的问题和解决方法：

1.非空校验失败：如果使用 @NotNull 注解验证 Long 类型字段，当传入的字段值为 null 时，校验将会失败，并且会抛出验证异常。这可能是因为在接收请求参数时，Long 类型字段被解析为了其对应的基本类型 long ，而不是 Long 类型。解决此问题的方法是将参数类型设置为 Long 类型而不是 long 类型。

2.默认值问题：使用 @NotNull 注解进行非空校验时，如果传入的字段的值为 null，将会抛出验证异常。但有时候我们可能希望设置一个默认值来替代 null 值。为了实现该功能，可以使用 @NotNull 注解的 message 属性配合 Spring 框架的 SpEL 表达式来设置默认值。 例如，可以定义一个默认值方法，并在 message 中使用 SpEL 表达式引用该方法：

import javax.validation.constraints.NotNull;

public class Order {
    
    @NotNull(message = "订单号不能为空", payload = DefaultOrderNumberProvider.class)
    private Long orderId;

    // Getters and setters
    
    public Long getOrderId() {
        // 返回默认值
        return DefaultOrderNumberProvider.getDefaultOrderNumber();
    }
}

在上述代码中，我们在 @NotNull 注解中设置了 payload 属性为 DefaultOrderNumberProvider.class，并在 getOrderId() 方法中返回了默认订单号值。

3.数据转换问题：如果传入的参数类型与目标字段类型不匹配，例如，传入的是字符串类型而不是 Long 类型，可能会导致数据转换异常。在这种情况下，可以使用其他的数据校验注解（如 @Pattern、@Size 等）来指定更具体的校验规则，并使用数据转换和转换错误处理机制来解决类型转换异常。

当使用 @NotNull 注解验证 Long 类型字段时，还可以遇到以下问题：

1.默认值无法区分：在某些情况下，我们希望将 null 值和0或其他特定值区分开来。但是，@NotNull 注解无法实现此功能，因为它只能校验字段是否为 null，而无法检查非零值。解决此问题的一种方式是使用 @Min 注解来指定最小值，并设置一个大于该最小值的默认值。 例如：

import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

public class Order {
    
    @NotNull(message = "订单号不能为空")
    @Min(value = 1, message = "订单号必须大于等于1")
    private Long orderId;

    // Getters and setters
    
    public Long getOrderId() {
        // 返回默认值
        return 0L;
    }
}

在上述代码中，我们使用了 @Min 注解来限制 orderId 的最小值为1，这样就可以区分 null 值和零值。

2.验证顺序问题：在使用验证框架时，字段的验证顺序非常重要。如果在字段级别的验证注解上定义了多个验证规则，例如 @NotNull 和 @Min，那么它们的验证顺序将成为关键。默认情况下，框架会根据验证注解的定义顺序来验证字段，但在某些情况下，可能希望根据业务逻辑指定不同的验证顺序。为了解决此问题，可以使用验证框架提供的组（Groups）功能，将不同的验证规则分组，并按照需要指定验证顺序。

在 Spring Validation 中，可以通过 @GroupSequence 注解来解决验证顺序问题。通过 @GroupSequence 注解，我们可以定义一个验证分组的顺序，验证时会按照定义的顺序依次进行验证。

以下是一个示例代码：

import javax.validation.constraints.*;

public class User {
    
    @NotNull(message = "用户名不能为空")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, max = 20, message = "密码长度必须在6-20位之间")
    private String password;
    
    @NotNull(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @NotNull(message = "手机号不能为空")
    @Pattern(regexp = "^1\\d{10}$", message = "手机号格式不正确")
    private String phone;
    
    // Getters and setters
    // ...
    
    /**
     * 定义更严格的验证分组规则
     */
    public interface ValidateSequence {
        interface Group1 {}
        interface Group2 {}
    }
    
    @GroupSequence({ValidateSequence.Group1.class, ValidateSequence.Group2.class, User.class})
    public interface Group {
    }
}

上述代码中，我们定义了一个 User 类，其中的各个属性都添加了一些验证注解。

在 User 类中，我们定义了一个 ValidateSequence 接口，分别定义了 Group1 和 Group2 两个分组。

然后我们使用 @GroupSequence 注解来定义验证分组的顺序。在这里，我们定义了首先验证 Group1 分组，然后验证 Group2 分组，最后再进行默认分组验证。这里默认的分组就是 User 类自身。

这样，当我们使用 javax.validation.Validator 的 validate(…) 方法进行 User 对象验证时，就会先按照 Group1 分组的验证规则进行验证，如果验证通过，则进行 Group2 分组的验证规则，最后进行默认分组的验证规则。

以下是一个示例代码：

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.util.Set;

public class Test {

    public static void main(String[] args) {

        User user = new User();
        user.setUsername(null);
        user.setPassword("123");
        user.setEmail("test@com");
        user.setPhone("12345678901");

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        // 先进行 Group1 分组的验证
        Set<ConstraintViolation<User>> group1 = validator.validate(user, User.ValidateSequence.Group1.class);
        group1.forEach(violation -> System.out.println(violation.getMessage()));

        // 如果 Group1 验证成功，则再进行 Group2 分组的验证
        if (group1.isEmpty()) {
            Set<ConstraintViolation<User>> group2 = validator.validate(user, User.ValidateSequence.Group2.class);
            group2.forEach(violation -> System.out.println(violation.getMessage()));
        }

        // 如果 Group1 和 Group2 都验证成功，则再进行默认分组的验证
        Set<ConstraintViolation<User>> violations = validator.validate(user);
        violations.forEach(violation -> System.out.println(violation.getMessage()));
    }
}

在上述代码中，我们首先创建一个 User 对象，其中 username 字段是空值，password 字段的长度小于 6，email 字段不符合邮箱格式，phone 字段不符合手机号格式。

然后，我们使用 javax.validation.Validator 的 validate(…) 方法进行验证。在进行验证的时候，我们按照 Group1 分组进行验证。如果验证通过，则进行 Group2 分组的验证。如果 Group1 和 Group2 都验证通过，则再进行默认分组的验证。最后，我们将验证结果输出到控制台上。

需要注意的是，如果我们在验证的时候指定了分组，那么只会验证指定分组中的注解。因此，我们需要把所有需要验证的注解都定义在相应的分组接口中。在上述代码中，我们把所有注解都定义在了默认分组中。

总之，使用 @NotNull 注解验证 Long 类型字段时，需要注意 参数类型、默认值设置、数据转换和默认值的区分性、验证顺序等问题，以确保校验的正确性和可靠性 。在处理数据类型转换异常时，可以结合其他数据校验注解和相应的异常处理机制来处理异常情况。

🍁 07、如果你要验证一个对象里的属性是否为 null，你会使用哪个注解？

在Java语言中，如果你要验证一个对象的属性是否为null，你可以使用@Nullable注解。@Nullable注解可以用于方法参数、方法返回值和类的字段上，表示这个元素可以为空。这个注解可以帮助开发者更好地理解代码，并且在静态分析工具中可以用于进行空指针检查。

当使用@Nullable注解时，可以用一个简单的示例来说明。

假设有一个名为Person的类，其中有一个名为name的属性。我们可以使用@Nullable注解来表示name属性可以为null：

public class Person {
    private String name;

    public Person(@Nullable String name) {
        this.name = name;
    }

    public void setName(@Nullable String name) {
        this.name = name;
    }

    @Nullable
    public String getName() {
        return name;
    }
}

在上述示例中，在构造函数、setName方法和getName方法中，我们都使用了@Nullable注解来标记传入或返回的name参数或属性可以为null。

这样做的好处是，当其他开发者使用这个类时，他们会明确知道name属性可以为null，并且在处理该属性时会有相应的处理方式，避免空指针异常的发生。

请注意，@Nullable注解只是一种提供代码提示和静态分析的方式，并不代表在运行时会进行空指针检查，所以在使用这个注解时，仍然需要自行进行空指针检查。

🍁 08、在使用 @NotEmpty 注解验证字符串类型的字段时，遇到的问题？

在使用@NotEmpty注解验证字符串类型的字段时，可能会遇到一些问题。这些问题可能包括：

1.错误的验证结果：@NotEmpty注解只能验证字符串不为空，但它不会验证字符串是否只包含空格或制表符等空白字符。如果字符串只包含空白字符，而不是实际字符，那么验证结果可能会出现错误。

2.配置问题：@NotEmpty注解需要正确地配置，以确保它能够被正确地应用于目标字段或方法参数。如果配置错误，注解可能无法正常工作，导致验证失效。

3.国际化支持：@NotEmpty注解的默认错误消息是英文的，如果需要国际化支持，需要自定义错误消息，并且使用合适的国际化资源进行翻译。

4.字段长度问题：@NotEmpty注解只关注字符串是否为空，但是对于长度限制相关的验证，比如最小长度或最大长度的验证，需要使用其他的注解，比如@Size注解。

总之，在使用@NotEmpty注解验证字符串类型的字段时，需要注意其局限性，并结合其他的验证注解来进行更全面和准确的验证。

针对使用 @NotEmpty 注解验证字符串类型的字段时可能会遇到的问题

解决方案可以有：

1.使用@NotBlank注解替代：@NotBlank注解不仅会验证字符串非空，还会验证字符串不仅仅由空格或制表符等空白字符组成，可以避免@NotEmpty注解验证中出现的特定问题。

2.配置@NotEmpty注解的trim属性：可以将@NotEmpty(trim=true)应用于目标字段或方法参数上，这样验证时会在检查字符串是否为空之前去掉字符串两端的空格和制表符等空白字符。

3.使用其他的验证注解：对于长度限制相关的验证，可以使用@Size注解，比如@Size(min=1, max=10)来验证字符串的长度是否在1到10之间。

4.自定义错误消息和国际化支持：需要在应用程序中定义正确的国际化资源，以便在需要时自动选择正确的资源文本为用户显示错误消息。使用@NotEmpty(message = "{custom.message}")来自定义错误消息，并使用合适的国际化资源进行翻译。

当使用@NotEmpty注解和其他解决方案时，下面是一些示例代码：

1.使用@NotBlank注解替代@NotEmpty：

public class User {
    @NotBlank
    private String username;
    
    // Getter and Setter
}

2.配置@NotEmpty注解的trim属性：

public class User {
    @NotEmpty(trim = true)
    private String username;
    
    // Getter and Setter
}

3.使用@Size注解进行长度限制验证：

public class User {
    @NotEmpty
    @Size(min = 1, max = 10)
    private String username;
    
    // Getter and Setter
}

4.自定义错误消息和国际化支持：

public class User {
    @NotEmpty(message = "{user.username.notEmpty}")
    private String username;
    
    // Getter and Setter
}

上述代码中，@NotEmpty、@NotBlank和@Size注解用于验证字符串类型的字段，@NotBlank注解还会验证字符串不仅仅由空格或制表符等空白字符组成。同时，可以通过trim属性配置@NotEmpty注解在验证之前是否去掉字符串两端的空白字符。另外，message属性可以用于自定义错误消息，{user.username.notEmpty}是一个占位符，应根据实际需求提供对应的国际化资源文件，并提供一个键为user.username.notEmpty的消息。

🍁 09、你是否知道哪些其他常用的验证注解？

知道一些，除了@NotEmpty、@NotBlank和@Size之外，还有许多其他常用的验证注解。下面列举几个常见的验证注解及其作用：

1.@NotNull：用于验证字段值不为空，对于任何类型的字段都适用，但不能验证字符串是否只包含空格或制表符等空白字符。

2.@Email：用于验证字段值是否符合邮箱格式，可以验证字符串类型的字段。

3.@Pattern：根据正则表达式验证字段值的格式是否匹配，可以验证字符串类型的字段。

4.@Min和@Max：用于验证数字类型字段的最小值和最大值。

5.@Digits：用于验证数字类型字段的整数位数和小数位数是否符合要求。

6.@Range：用于验证数字类型字段的取值范围是否在指定范围内。

7.@Past和@Future：用于验证日期类型字段是否是过去的日期或未来的日期。

8.@Valid：用于嵌套验证，可以对字段为对象类型的关联对象进行级联验证。

以下是一些示例代码来展示这些验证注解的使用：

public class User {
    @NotEmpty
    private String username;

    @NotBlank
    @Email
    private String email;

    @Pattern(regexp = "\\d{9}")
    private String phone;

    @Min(18)
    @Max(60)
    private int age;

    @Digits(integer = 3, fraction = 2)
    private BigDecimal salary;

    @Range(min = 1, max = 100)
    private int score;

    @Past
    private Date birthDate;

    @Future
    private Date expirationDate;

    @Valid
    private Address address;

    // Getter and Setter
}

public class Address {
   @NotEmpty
   private String city;
   
   @NotEmpty
   private String street;
   
   // Getter and Setter
}

在上述示例代码中，User类包含了多个字段，并使用了不同的验证注解来对这些字段进行验证。Address类作为User类的关联对象，使用了@Valid注解来进行嵌套验证。这样，在验证User对象时，也会对关联的Address对象进行验证。

🍁 10、为什么使用验证注解可以提高代码质量？

使用验证注解可以提高代码质量的原因如下：

1. 数据合法性保证： 验证注解可以确保输入的数据符合预期的格式和要求。通过验证注解，可以在数据进入系统之前对其进行验证，避免了后续处理过程中因为数据不合法而引发的错误。

2. 编译时验证： 验证注解是在编译时进行验证的，这意味着在代码提交到版本控制系统之前就能够发现数据错误，减少了在运行时出现的错误，提高了开发效率。

3. 增加可读性和维护性： 通过在代码中使用验证注解，可以清晰地看到数据应该满足的限制和要求，使代码更具可读性。同时，验证注解可以将验证逻辑集中在一个地方，方便维护、修改和复用，避免了散落在代码中的重复验证逻辑。

4. 提前捕获错误： 使用验证注解可以在尽可能早的阶段捕获错误。通过在输入接口处进行验证，可以尽早地发现和处理错误，减少错误传播的风险，提高系统的稳定性和可靠性。

5. 逻辑清晰化： 通过使用验证注解，可以将验证逻辑直观地体现在代码中，使代码的意图更加明确和清晰，降低了误解和错误的发生。

综上所述，验证注解能够帮助开发人员在编码的早期阶段就发现并修复数据错误，提高代码质量，减少错误和问题的出现，同时提高可读性、可维护性和系统的稳定性。

在这里插入图片描述

文章来源:https://blog.csdn.net/m0_50308467/article/details/135402918
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！