I have developed two tables in Spring Boot, User and UserMeta. User is the parent and UserMeta is the child table. The foreign-key is user_id. I may be looking at it the wrong way, but I want to be able to first create an entity of User. Then, I want to create an entity of UserMeta. Simply UserMeta should contain additional data to User.

However, when first creating a User and then a UserMeta entity, I get e new User entity (ending up with two User entities and one UserMeta entity.)

The problem I think is that I create a UserMeta object with a User, since I want to have a relationship between User and UserMeta. But if I want to be able to first create a User and then a UserMeta, should I simply ignore a foreign-key? Or, does it exists another way of creating a UserMeta entity without creating a new User?

User

public class User {

    @Id
    @SequenceGenerator(name = "user_sequence", sequenceName = "user_sequence", allocationSize = 1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_sequence")
    //@OneToOne(optional=false)
    private Long userId;
    private String username;
    private String password;
    private String email;
    
    @OneToOne(mappedBy = "user")
    private UserMeta userMeta;
    
    public User(String username, String email, String password) {
        this.username = username;
        this.email = email;
        this.password = password;
    }   
}

UserMeta

public class UserMeta {
    @Id
    @SequenceGenerator(name = "user_meta_sequence", sequenceName = "user_meta_sequence", allocationSize = 1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_meta_sequence")
    private Long userMeta_Id;
    private String lastname;
    private int age;

    @OneToOne(
            cascade = CascadeType.ALL,
            fetch = FetchType.LAZY,
            optional = false
    )
    @JoinColumn(
            name = "user_Id",
            referencedColumnName="userId"
            )
    private User user;

    public UserMeta(String lastName, int age, User user){
        this.lastname = lastName;
        this.age = age;
        this.user = user;
    }
}

UserRepository

public interface UserRepository extends CrudRepository<User, Long> {
} 

UserService

public interface UserService {
    User saveUser(User user);
}

UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    private UserRepository userRepository;

    public UserServiceImpl(UserRepository userRepository) {
        super();
        this.userRepository = userRepository;
    }

@Override
    public User saveUser(User user) {
        // TODO Auto-generated method stub
        return this.userRepository.save(user);
    }

UserController

@RestController
public class UserController {
    
    private UserService userService; 
    
    public UserController(UserService userService) {
        super();
        this.userService = userService;
    }
@PostMapping("/user")
    public ResponseEntity<User> saveUser(@RequestBody User user) {
        return new ResponseEntity<User>(userService.saveUser(user), HttpStatus.CREATED);
    }
}

UserMetaRepository

public interface UserMetaRepository extends CrudRepository<UserMeta, Long> {
}

UserMetaService

public interface UserMetaService {
    UserMeta saveUserMeta(UserMeta userMeta); 
}

UserMetaServiceImpl

@Service
public class UserMetaServiceImpl implements UserMetaService{
    
    private UserMetaRepository userMetaRepo; 
    
    public UserMetaServiceImpl(UserMetaRepository userMetaRepo) {
        super(); 
        this.userMetaRepo = userMetaRepo; 
    }

    @Override
    public UserMeta saveUserMeta(UserMeta userMeta) {
        return this.userMetaRepo.save(userMeta); 
    }

}

UserMetaController

@RestController
public class UserMetaController {

    public UserMetaService userMetaService; 

    public UserMetaController(UserMetaService service) {
        super();
        this.userMetaService = service;
    }

    @PostMapping("/userMeta")
    public ResponseEntity<UserMeta> saveUserMeta(@RequestBody UserMeta userMeta) {
        return new ResponseEntity<UserMeta>(this.userMetaService.saveUserMeta(userMeta), HttpStatus.CREATED);
    }
}

CodePudding user response：

you should use this constructor in the User class,

 public User(String username, String email, String password, UserMeta userMeta) {
        this.username = username;
        this.email = email;
        this.password = password;
        this.userMeta = userMeta;
    }  

now when you save your user the user Meta will be added to your UserMeta table,

If you want to add a user Meta to an existing user you will only need to set the userMeta and save it with a simple userRepository.save(theUpdatedUser)

you can also create userMeta seperately with your code above, and if you want to assign it to a user already in data base or not you can allows use the power of spring data and use simple userRepository.save(userWithTheAssignedMeta)

the same logic applies the other way for metaUser.

CodePudding user response：

The problem here is that your UserMetadata creation logic is using incomplete JSON:

{ "lastName":"foo", "age":1, "user":{ "username":"foo", "password":"bar", "email":"foo-bar" } }

Within this, the problem is the 'user' has all the data, duplicating what was already created the the database, but does not identify it. Since the mapping has cascade.ALL set on it, Spring/JPA will persist the UserMetadata and find this User instance that doesn't have identity, so persist it - giving it identity from the sequence.

There are a few ways you might correct this. First and easiest is to send the User ID in the json from the previously created instance:

{ "lastName":"foo", "age":1, "user":{ "userId":1, "username":"foo", "password":"bar", "email":"foo-bar" } }

This will allow Spring/JPA to recognize the user's identity and merge it and the data provided into the database. It means though that you must send complete data for the User - it will push incomplete data into the DB.

If that is a concern, you can change the cascade options. You may not want cascading persist/merge at all on this relationship, and I suspect when you delete userMetadata you don't really want to delete the User instance, so I think this might have been done incorrectly (maybe put it on the user->UserMetadata relationship instead?). If you remove the cascade settings, spring/JPA will let you just pass in JSON with the USER id specified, as this gives it enough to set the fk:

{ "lastName":"foo", "age":1, "user":{ "userId":1} }