@Entity@Table(name = \'users\')public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = \'id\') private UUID userId; @Column(

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private UUID userId;

    @Column(nullable = false)
    @NotBlank(message = "Name is Required")
    private String name;

    @Column(nullable = false)
    @NotBlank(message = "Password hash is required")
    @Size(min = 8, message = " Password must be more than 8 characters and alphanumeric ")
    @Alphanumeric(message = "password must be alpahanumeric")

    private String hash;

    @Column(nullable = false, unique = true)
    @NotBlank(message = "Username is required")
    @Size(min = 5, max = 20, message = "Username must be between 5 and 20 characters")
    private String username;

    // a temporary variable to use in controller to check if roleId is valid in the
    // Role entity
    @Column(name = "user_role", insertable = false, updatable = false)
    private Integer roleId;

    @ManyToOne
    @JoinColumn(name = "user_role", nullable = false, referencedColumnName = "id")
    private Role role;

    public User() {

这就是我在模型包中设置用户类的方法。

 @PostMapping("/register")
    public ResponseEntity<String> registerUser(@RequestBody @Valid User user, BindingResult bindingResult) {

        // Check for validation errors
        if (bindingResult.hasErrors()) {
            String errorMessage = bindingResult.getAllErrors().get(0).getDefaultMessage();
            logger.info("Validation error: {}", errorMessage);
            return new ResponseEntity<>("Validation error: " + errorMessage, HttpStatus.BAD_REQUEST);
        }

        // Check if username already exists
        Optional<User> userOptional = userRepository.findByUsername(user.getUsername());
        if (userOptional.isPresent()) {
            return new ResponseEntity<>("Username already exists", HttpStatus.BAD_REQUEST);
        }

        // Ensure roleId is provided in the JSON request
        Integer roleId = user.getRoleId();
        if (roleId == null) {
            return new ResponseEntity<>("Role ID is required", HttpStatus.BAD_REQUEST);
        }

        // Fetch the Role from repository based on roleId
        Optional<Role> optionalRole = roleRepository.findById(roleId);
        if (!optionalRole.isPresent()) {
            return new ResponseEntity<>("Role not found", HttpStatus.BAD_REQUEST);
        }

        // Set the fetched Role to the User object
        Role role = optionalRole.get();
        user.setUserRole(role);

        // Save the user to the database
        userRepository.save(user);

        return ResponseEntity.ok("User registered successfully");
    }

还有我的注册 Postmapping。看来我的控制器没有运行任何验证并跳过第一个 if 块语句，我能够使用空字段进行注册。我最近开始使用 Java，这是我的第一个 springboot 项目。仍在学习中。

我检查了是否有正确的依赖项

               <?xml version="1.0" encoding="UTF-8"?>
<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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>management_tool</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>management_tool</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency> -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>
        <!-- <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency> -->
         <!-- BCrypt for password hashing -->
    <!-- <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-crypto</artifactId>
    </dependency> -->

    <!-- JWT for token handling -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
    <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.11.5</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.11.5</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.11.5</version>
            <scope>runtime</scope>
        </dependency>

    <dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version> <!-- Adjust version as per your Spring Boot version -->
</dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <version>3.3.0</version> <!-- Ensure this matches your Spring Boot version -->
    <optional>true</optional>
</dependency>

     <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version> <!-- Specify version -->
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>${logback.version}</version> <!-- Specify version -->
    </dependency>

    <dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jbcrypt</artifactId>
    <version>0.4</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
    <!-- Spring Boot manages the version for you -->
</dependency>



    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

还尝试创建一个 UserDto 类，但似乎面临更多问题。

public class UserDto {


    @NotBlank(message = "Name is Required")
    private String name;


    @NotBlank(message = "Password hash is required")
    @Size(min = 8, message = " Password must be more than 8 characters and alphanumeric ")
    @Alphanumeric(message = "password must be alpahanumeric")
    private String hash;


    @NotBlank(message = "Username is required")
    @Size(min = 5, max = 20, message = "Username must be between 5 and 20 characters")
    private String username;

    // a temporary variable to use in controller to check if roleId is valid in the
    // Role entity

    private Integer roleId;

    private Role role;

    public User toUser() {
        return new User()
                .setName(name)
                .setUsername(username)
                .setHash(hash)
                .setRoleId(roleId)
                .setUserRole(role);
    }
}

在我的 public User toUser() 中，setUsername(String) 未解析。我检查了是否正确导入了所有内容，并且在创建此文件时，我从我的 Users 类中删除了验证。不知道该如何解决

我最近开始学习 Asp.net core。我遇到了 DTO 的概念。我正在使用属性进行验证。我在网上读到，DTO 上的验证被认为是

我最近开始学习 Asp.net core。我遇到了 DTO 的概念。我正在使用属性进行验证。我在网上读到，对 DTO 进行验证当然被认为是对模型的常见/良好做法。然而，在大多数情况下，我发现自己只是将模型上的验证复制并粘贴到 DTO 上。这违反了 DRY 原则，当我们为一个模型拥有多个 DTO 时，这可能会非常混乱。

1-我们如何避免重复验证？我们可以遵循什么设计模式来确保“DRY 代码”？

2-有没有办法避免使用属性时的重复，例如：将一组属性按名称分组 PasswordValidation 并在任何地方重复使用？因为我不想自己实现验证逻辑，也不想从其他功能中受益 ModelState （如果可能的话）。

使用 5.016；sub foo（）{说\'foo\'；}sub main（）{foo（42）；}main（）；如果我运行上面的代码，它将显示下面的错误，这是我所期望的，因为 foo 没有参数......

use 5.016;

sub foo() {
    say "foo";
}

sub main() {
    foo(42);
}

main();

如果我运行上面的代码，它将显示 错误 ，这是我所期望的，因为 foo 它没有参数：

Too many arguments for main::foo at b.pl line 8, near "42)"
Execution of b.pl aborted due to compilation errors.

use 5.016;

sub main() {
    foo(42);
}

sub foo() {
    say "foo";
}

main()

但如果我运行上面的代码，它可以 正确 ：

foo

为什么 foo 这次要接受参数？

非常感谢，现在它已经可以正常工作了。我会进一步了解依赖项，也感谢您的提示。感谢您花时间帮助我。

问题在于你的依赖关系。

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version> <!-- Adjust version as per your Spring Boot version -->
</dependency>
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
</dependency>

这些依赖项不是必需的，因为它们都已是 的一部分 spring-boot-starter-validator 。实际上， javax.validation:validation-api 您使用的依赖项与 Spring Boot 3 不兼容。Spring Boot 3 与 JakartaEE 版本兼容，而不是 JavaEE 版本（您包含的）。

删除这些依赖项后，您可能会收到编译错误，指出 package javax.validation not found ，请修复导入问题 jakarta.validation 。

经过这些改变它就应该可以工作了。

其他一些建议：

• 删除 slf4j 和 logback 依赖项，它们已默认包含在内。
• 删除 spring-boot-starter-logging 默认包含的依赖项。
• 从中 <version> 删除 lombok ，两者均 pring-boot-configuration-processor 已为您管理。事实上，如果您升级 Java，您的 Lombok 版本将不再有效。
• 看起来你正在混合 io.jsonwebtoken 依赖项的版本（0.9.1 和 0.11.5），请确保这些版本匹配（或删除你不需要的版本）。混合依赖项的不同版本的模块会带来麻烦。

@M.Deinum，好的，将查找如何正确使用可选项并创建服务类。还添加了我的整个 pom.xml 文件。

首先，您的控制器中的逻辑应该在服务方法中（控制器应该只充当转换层），另外请使用

@SpaceTrucker 我是否可以不使用 UserDto 文件而只在 User 类中进行验证？

您好@Mohammad Alshareef，您可以创建自定义验证属性，封装一组验证规则，并将它们应用于模型和 DTO 中的属性。另一种方法是，您可以使用 FluentValidation 等库将验证逻辑与模型和 DTO 分开，使其更易于维护和重用。

@Lane \'我的代码中不需要原型\'——我认为这通常是一件好事 :)。我会把它留在答案中供其他人使用。糟糕的问题是函数的工作方式不同（使用它们的代码编译方式不同），因此当原型未按预期应用时（如本例所示），可能会导致安静错误。

其实我的代码里是不需要prototype的，我问这个问题只是因为我在一个老项目中看到了这段代码，很奇怪为什么没有错误。

原型会改变用它们声明的函数的解析规则。因此，为了将其考虑在内， 必须 函数的 sub foo(); 预声明 (

如果函数调用出现在函数定义或预声明之前，则只能将其解析为普通（非原型）调用，前提是解释器首先可以确定它是一个函数。（在此示例中，由于括号，因此可以。）

然后，一旦定义出现，指示的原型就不会对已解析的调用产生影响。但是，在函数定义（或预声明）之后，对该函数的进一步调用都是原型化的。另外还添加了一点：

use 5.016;

fun_proto(42);      # runtime warning: 
                    # "called too early to check prototype"

sub fun {
    fun_proto(42);  # parsed as a normal sub as no prototype has been seen
}

sub fun_proto() { 
    say "@_";
}

fun();              # fun_proto(42) call in 'fun' is OK

fun_proto(43);      # compilation error: extra argument by prototype 

函数定义之前的直接调用会在运行时引发警告，但另一个子程序内部的调用不会。我不知道为什么来自子程序的调用不会收到警告。（包含调用的子程序的调用 fun_proto(42) 出现在 fun_proto 定义之后，但所有这些（封闭的子程序和 fun_proto 其中的调用）都在定义之前进行编译。）

要修复^†代码，请在提及函数之前添加预声明（“前向声明”）。在此示例中，这将是一个语句 sub fun_proto();

也许你确切地知道自己在做什么，但我不得不问：你的代码中真的需要原型吗？它们很微妙，但它们的目的仅仅是允许像调用内置函数一样调用用户定义的子函数，而 不是检查参数的数量和类型 .

如果目的是检查参数，那么自 v5.20 perl 以来，它具有适当的 子程序签名 .

^†一个真正的问题是，代码的编译方式取决于原型，因此当它们没有按预期应用时（如这里），可能会导致安静的错误。一个简单的例子：

sub fun() { ... }

当调用该子程序（不带括号）时，其调用之后的任何内容都不会作为其参数——因为它不接受任何参数！——所以

fun + 3     # intended to be compiled with regards to () prototype

稍后（虽然很棘手）运行为

fun() + 3   # sub declared w/ prototype to take no arguments

但是，如果该原型定义不适用于此调用（如本问题中的示例），则表达式中 sub 后面的内容 将 作为其参数列表，因此代码将被编译为

fun(+3)     # oups, not intended (prototype unused by error)

没有警告。

\'... 展示当前问题的解决方案...\' — 完全同意，完全没有其他的意思。在这种情况下，我想说这可能是没有根据的。他们问了一个非常具体和精确的问题，甚至没有一丝怀疑或其他方法。我认为这里只需要一个评论。

@zdim 我同意。我曾考虑过提供纯 perl 替代方案，但我认为从长远来看，展示当前问题的解决方案会更有帮助。

或者使用 qq() 运算符来处理外部引号（perl -wE'say qq(A \'quote\')'），而实际上内部需要双引号。但一般来说，我真的建议将这项工作分解，并在 Perl 中完成……但那是另一回事……

嗨，Ted，谢谢你的回复。我已经尝试过了，但最终出现了以下错误 sed: -e 表达式 #1, char 1: 未知命令: `-'

当您想在双引号字符串中使用双引号时，您需要对双引号进行转义： "...\"foo\"..." 但在这种情况下，您很可能应该将内部的双引号替换为单引号：

system("find  . -type f -name file.txt | xargs sed -i -e '\$ a- - test 0'");
#                                                        ^              ^
#                                                        +---- here ----+

请注意， $ 双引号字符串中需要转义。您还可以单独构建字符串以避免必须转义任何内容：

my $expr='$ a- - test 0';
system("find  . -type f -name file.txt | xargs sed -i -e '$expr'");

一般性评论：一旦进入 Perl 程序，就可以在 Perl 中很好地完成所有这些操作（而不是从中运行复杂的 shell 命令）