Java SpringBoot&x2B；建造师

它一直给我那个错误，我不知道如何关注这个问题，或者在哪里搜索它一直在问我关于构造函数的问题，但我使用的是lombok，所以我为什么要做构造函数，我真的不知道代码有什么问题

以下是用户型号代码：

package com.muskiltak.v1.model;

import lombok.*;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "users")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@ToString
public class User {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;

@Column(name = "username")
private String username;

@Column(name = "email")
private String email;

@Column(name = "phone")
private Integer phone;

@Column(name = "password")
private String password;

@ManyToMany(fetch = FetchType.LAZY)
@JoinTable( name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id"))
private Set<Role> roles = new HashSet<>();
}

这是AuthController代码：

package com.muskiltak.v1.controller;

import com.muskiltak.v1.utility.enums.Roles;
import com.muskiltak.v1.model.Role;
import com.muskiltak.v1.model.User;
import com.muskiltak.v1.repository.RoleRepo;
import com.muskiltak.v1.repository.UserRepo;
import com.muskiltak.v1.service.UserDetailsImpl;
import com.muskiltak.v1.utility.JWT.JwtUtils;
import com.muskiltak.v1.utility.payload.request.LoginRequest;
import com.muskiltak.v1.utility.payload.request.RegisterRequest;
import com.muskiltak.v1.utility.payload.response.JwtResponse;
import com.muskiltak.v1.utility.payload.response.MessageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@CrossOrigin(origins = "*", maxAge = 3600)
@RestController
@RequestMapping("/api/v1")
public class AuthController {

@Autowired
AuthenticationManager authenticationManager;

@Autowired
UserRepo userRepository;

@Autowired
RoleRepo roleRepository;

@Autowired
PasswordEncoder encoder;

@Autowired
JwtUtils jwtUtils;


@PostMapping("/login")
public ResponseEntity<?> authenticateUser(@Valid @RequestBody LoginRequest loginRequest) {

    Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword()));

    SecurityContextHolder.getContext().setAuthentication(authentication);
    String jwt = jwtUtils.generateJwtToken(authentication);

    UserDetailsImpl userDetails = (UserDetailsImpl) authentication.getPrincipal();
    List<String> roles = userDetails.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.toList());

    return ResponseEntity.ok(new JwtResponse(jwt,
            userDetails.getId(),
            userDetails.getUsername(),
            userDetails.getEmail(),
            userDetails.getPhone(),
            roles));
}

@PostMapping("/register")
public ResponseEntity<?> registerUser(@Valid @RequestBody RegisterRequest registerRequest) {
    if (userRepository.existsByUsername(registerRequest.getUsername())) {
        return ResponseEntity
                .badRequest()
                .body(new MessageResponse("Error: Username is already taken!"));
    }

    if (userRepository.existsByEmail(registerRequest.getEmail())) {
        return ResponseEntity
                .badRequest()
                .body(new MessageResponse("Error: Email is already in use!"));
    }

    if (userRepository.existsByPhone(registerRequest.getPhone())) {
        return ResponseEntity
                .badRequest()
                .body(new MessageResponse("Error: Phone Number is already in use!"));
    }

    // Create new user's account
    User user = new User(
            registerRequest.getUsername(),
            registerRequest.getEmail(),
            registerRequest.getPhone(),
            encoder.encode(
                    registerRequest.getPassword()
            )
    );

    Set<String> strRoles = registerRequest.getRole();
    Set<Role> roles = new HashSet<>();

    if (strRoles == null) {
        Role userRole = roleRepository.findByName(Roles.USER)
                .orElseThrow(() -> new RuntimeException("Error: Role is not found."));
        roles.add(userRole);
    } else {
        strRoles.forEach(role -> {
            switch (role) {
                case "admin":
                    Role adminRole = roleRepository.findByName(Roles.ADMIN)
                            .orElseThrow(() -> new RuntimeException("Error: Role is not found."));
                    roles.add(adminRole);

                    break;
                case "moderator":
                    Role moderatorRole = roleRepository.findByName(Roles.MODERATOR)
                            .orElseThrow(() -> new RuntimeException("Error: Role is not found."));
                    roles.add(moderatorRole);

                    break;
                case "corp":
                    Role corpRole = roleRepository.findByName(Roles.CORP)
                            .orElseThrow(() -> new RuntimeException("Error: Role is not found."));
                    roles.add(corpRole);

                    break;
                default:
                    Role userRole = roleRepository.findByName(Roles.USER)
                            .orElseThrow(() -> new RuntimeException("Error: Role is not found."));
                    roles.add(userRole);
            }
        });
    }

    user.setRoles(roles);
    userRepository.save(user);

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

package com.muskiltak.v1.controller；
导入com.muskiltak.v1.utility.enums.Roles；
导入com.muskiltak.v1.model.Role；
导入com.muskiltak.v1.model.User；
导入com.muskiltak.v1.repository.RoleRepo；
导入com.muskiltak.v1.repository.UserRepo；
导入com.muskiltak.v1.service.userdetailsiml；
导入com.muskiltak.v1.utility.JWT.JwtUtils；
导入com.muskiltak.v1.utility.payload.request.LoginRequest；
导入com.muskiltak.v1.utility.payload.request.RegisterRequest；
导入com.muskiltak.v1.utility.payload.response.JwtResponse；
导入com.muskiltak.v1.utility.payload.response.MessageResponse；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.http.ResponseEntity；
导入org.springframework.security.authentication.AuthenticationManager；
导入org.springframework.security.authentication.UsernamePasswordAuthenticationToken；
导入org.springframework.security.core.Authentication；
导入org.springframework.security.core.GrantedAuthority；
导入org.springframework.security.core.context.SecurityContextHolder；
导入org.springframework.security.crypto.password.PasswordEncoder；
导入org.springframework.web.bind.annotation.*；
导入javax.validation.Valid；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
导入java.util.stream.collector；
@交叉原点（原点=“*”，最大值=3600）
@RestController
@请求映射（“/api/v1”）
公共类授权控制器{
@自动连线
AuthenticationManager AuthenticationManager；
@自动连线
UserRepo用户存储库；
@自动连线
RoleRepo roleRepository；
@自动连线
密码编码器；
@自动连线
JwtUtils JwtUtils；
@后映射（“/login”）
公共响应身份验证者（@Valid@RequestBody LoginRequest LoginRequest）{
Authentication=authenticationManager.authenticate(
新的UsernamePasswordAuthenticationToken（loginRequest.getUsername（），loginRequest.getPassword（））；
SecurityContextHolder.getContext（）.setAuthentication（身份验证）；
字符串jwt=jwtUtils.generateJwtToken（身份验证）；
UserDetailsImpl userDetails=（UserDetailsImpl）身份验证。getPrincipal（）；
List roles=userDetails.getAuthorities（）.stream（）
.map（GrantedAuthority:：getAuthority）
.collect（Collectors.toList（））；
返回响应正确（新jwt响应（jwt，
userDetails.getId（），
userDetails.getUsername（），
userDetails.getEmail（），
userDetails.getPhone（），
角色);；
}
@后映射（“/寄存器”）
公共响应注册器（@Valid@RequestBody RegisterRequest RegisterRequest）{
if（userRepository.existsByUsername（registerRequest.getUsername（）））{
返回响应性
.badRequest（）文件
.body（新的MessageResponse（“错误：用户名已被使用！”）；
}
if（userRepository.existsByEmail（registerRequest.getEmail（）））{
返回响应性
.badRequest（）文件
.body（新的MessageResponse（“错误：电子邮件已在使用！”）；
}
if（userRepository.existsByPhone（registerRequest.getPhone（）））{
返回响应性
.badRequest（）文件
.body（新消息响应（“错误：电话号码已在使用！”）；
}
//创建新用户的帐户
用户=新用户(
registerRequest.getUsername（），
registerRequest.getEmail（），
registerRequest.getPhone（），
编码器(
registerRequest.getPassword（）
)
);
Set stroles=registerRequest.getRole（）；
Set roles=new HashSet（）；
如果（strRoles==null）{
Role userRole=roleRepository.findByName（Roles.USER）
.orelsetrow（（）->new RuntimeException（“错误：找不到角色”）；
roles.add（userRole）；
}否则{
strRoles.forEach（角色->{
交换机（角色）{
案例“管理”：
Role adminRole=roleRepository.findByName（Roles.ADMIN）
.orelsetrow（（）->new RuntimeException（“错误：找不到角色”）；
roles.add（adminRole）；
打破
案例“主持人”：
Role慢化剂Role=roleRepository.findByName（Roles.慢化剂）
.orelsetrow（（）->new RuntimeException（“错误：找不到角色”）；
添加（主持人角色）；
打破
案例“公司”：
Role corpRole=roleRepository.findByName（Roles.CORP）
.orelsetrow（（）->new RuntimeException（“错误：找不到角色”）；
添加（corpRole）；
打破
违约：
Role userRole=roleRepository.findByName（Roles.USER）
.orelsetrow（（）->new RuntimeException（“错误：找不到角色”）；
roles.add（userRole）；
}
});
}
user.setRoles（角色）；
userRepository.save（用户）；
returnresponseEntity.ok（新消息response（“用户注册成功！”）；
}
}

一直以来都在给我一个错误，就像你在下图中看到的一样，即使我在调试模式下运行它，它也一直要求我生成构造函数，而我正在使用lombok，正如你所看到的

---

根据lombok，将创建的构造函数的所有属性类型的顺序与定义的相同。因此，@AllArgsConstructor注释将创建一个如下所示的构造函数：

public User(long id, String username, Integer phone, String password, HashSet<Role> roles);

公共用户（长id、字符串用户名、，
public User(long id, String username, Integer phone, String password, HashSet<Role> roles);