java Hibernate在用户注册后在角色表中添加不必要的行

Question

我正在尝试通过用户注册向我的webapp添加功能。Webapp基于spring boot、hibernate和mysql数据库，前端为angular。一般来说，用户创建过程工作正常，用户数据通过json从前端正确发送到后端，并保存到shop_user表中的数据库（包含所有用户数据，如姓名、姓氏、地址等），但没有角色列

我还有表“角色”，应该是：

id     name
1      USER
2      ADMIN

和joined table user_role，它由table shop_user的用户id和table role的角色id组成，所以它应该如下所示：

id_user    id_role
1          2
2          1
3          1

在网站上创建用户时，默认情况下硬编码为将角色设置为用户。这似乎工作得很好，因为它在shop\u user中添加了一行，并在user\u角色中添加了一行，但是。。。它还在“角色”表中创建新行

因此，最后的“角色”表如下所示：

id     name
1      ADMIN
2      USER
3      USER
4      USER
5      USER
99     USER

`

虽然这不是阻止应用程序工作的阻塞性错误，但不幸的是，它不是“应该工作的”。。。因为该表应该只包含两个角色行（将来可能还有更多的角色行），而不是针对每个用户进行乘法

以下是有缺陷的用户代码：

使用者

@Entity
@Table(name = "shop_user")
public class User extends AbstractEntity {

@Column
private String firstName;

@Column
private String lastName;

@Column
private String addressLine;

@Column
private String city;

@Column
private String country;

@Column
private String zipCode;

@Column
private String phoneNumber;

@Column
private String email;

@Column
private String password;

@ManyToMany(cascade = CascadeType.ALL,  fetch = FetchType.EAGER)
@JoinTable(name = "user_role",
        joinColumns = @JoinColumn(name = "id_user", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "id_role", referencedColumnName = "id"),
        uniqueConstraints = {@UniqueConstraint(columnNames = {"id_user", "id_role"})})
private List<Role> roles;

public User() {
}

public User(User user) {
    setId(user.getId());
    this.firstName = user.getFirstName();
    this.lastName = user.getLastName();
    this.addressLine = user.getAddressLine();
    this.city = user.getCity();
    this.country = user.getCountry();
    this.zipCode = user.getZipCode();
    this.phoneNumber = user.getPhoneNumber();
    this.email = user.getEmail();
    this.password = user.getPassword();
    this.roles= user.getRoles();
}

public List<Role> getRoles() {
    return roles;
}

public void setRoles(List<Role> roles) {
    this.roles = roles;
}

public String getFirstName() {
    return firstName;
}

public void setFirstName(String firstName) {
    this.firstName = firstName;
}

public String getLastName() {
    return lastName;
}

public void setLastName(String lastName) {
    this.lastName = lastName;
}

public String getAddressLine() {
    return addressLine;
}

public void setAddressLine(String addressLine) {
    this.addressLine = addressLine;
}

public String getCity() {
    return city;
}

public void setCity(String city) {
    this.city = city;
}

public String getCountry() {
    return country;
}

public void setCountry(String country) {
    this.country = country;
}

public String getZipCode() {
    return zipCode;
}

public void setZipCode(String zipCode) {
    this.zipCode = zipCode;
}

public String getPhoneNumber() {
    return phoneNumber;
}

public void setPhoneNumber(String phoneNumber) {
    this.phoneNumber = phoneNumber;
}

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
}
}

角色实施：

角色

@Entity
@Table(name = "role")
public class Role extends AbstractEntity {

    @Column
    private String name;

    @ManyToMany(mappedBy = "roles", cascade = CascadeType.PERSIST)
    private List<User> users;

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

    public String getName() {
        return name;
    }

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

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }
}

抽象实体：

抽象实体

@MappedSuperclass
public abstract class AbstractEntity implements Persistable<Long> {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    public void setId(Long id) {
        this.id = id;
    }

    @Override
    public Long getId() {
        return id;
    }

    @Override
    public boolean isNew() {
        return id == null;
    }
}

用户服务：

UserServiceImpl

@Service
public class UserServiceImpl extends AbstractServiceImpl<User, UserDTO> implements UserService {

    private final UserRepository userRepository;
    private final UserConverter userConverter;

    public UserServiceImpl(UserRepository userRepository, UserConverter 
userConverter) {
        this.userRepository = userRepository;
        this.userConverter = userConverter;
    }

    @Override
    protected JpaRepository<User, Long> getRepository() {
        return userRepository;
    }

    @Override
    protected Converter<User, UserDTO> getConverter() {
        return userConverter;
    }

    @Override
    @Transactional
    public User registerUser(User user) {
        List<Role> roles = new LinkedList<>();
        roles.add(new Role("USER"));
        user.setRoles(roles);
        return userRepository.save(user);
    }}

我几乎可以肯定，这涉及到Hibernate和对象创建中的关系映射，但我还不能完全弄清楚

任何帮助都将不胜感激，谢谢

Answer 1

问题在于：

@Override
@Transactional
public User registerUser(User user) {
    List<Role> roles = new LinkedList<>();
    roles.add(new Role("USER"));
    user.setRoles(roles);
    return userRepository.save(user);
}}

因为关系用户->；角色是cascade persist，（新）角色new Role("USER")也会被持久化，最终为每个用户提供一个新角色，而不是重用现有角色

解决方案是检查name=USER的角色是否存在。如果不存在，请插入它。否则，将现有的添加到roles集合中