如何洗掉多對多關系？

我有一個多對多的關系（汽車和司機）洗掉司機時如何洗掉driver_car表中的鏈接并洗掉系結到該司機的汽車，反之亦然，洗掉汽車時只需洗掉一個car 和 driver_car 表中與汽車無關的鏈接？

我的基本物體：

 @MappedSuperclass
    public abstract class BaseEntity {
    
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private Long id;
    
        @Temporal(TemporalType.TIMESTAMP)
        private Date created;
    
        @Temporal(TemporalType.TIMESTAMP)
        private Date updated;
    
    
        private Boolean visible;
    
        @Column(name = "image_url")
        private String imageUrl;
    
        public BaseEntity() {
            this.created = new Date();
            this.updated = new Date();
            this.visible = true;
        }
    
        @PreUpdate
        public void preUpdate() {
            this.updated = new Date();
        }
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public Date getCreated() {
            return created;
        }
    
        public void setCreated(Date created) {
            this.created = created;
        }
    
        public Date getUpdated() {
            return updated;
        }
    
        public void setUpdated(Date updated) {
            this.updated = updated;
        }
    
        public Boolean getVisible() {
            return visible;
        }
    
        public void setVisible(Boolean visible) {
            this.visible = visible;
        }
    
        public String getImageUrl() {
            return imageUrl;
        }
    
        public void setImageUrl(String imageUrl) {
            this.imageUrl = imageUrl;
        }
    }

我的司機：

@Entity
@Table(name = "drivers")
public class Driver extends BaseEntity {

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    private String notes;
    private double balance;

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(
            name = "driver_car",
            joinColumns = @JoinColumn(name = "driver_id"),
            inverseJoinColumns = @JoinColumn(name = "car_id"))
    private Set<Car> cars;

    public Driver() {
        super();
        this.cars = new HashSet<>();
    }

    public Set<Car> getCars() {
        return cars;
    }

    public void setCars(Set<Car> cars) {
        this.cars = cars;
    }

    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 getNotes() {
        return notes;
    }

    public void setNotes(String notes) {
        this.notes = notes;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

我的車：

@Entity
@Transactional
public class Car extends BaseEntity {

@Column(name = "cars_name")
private String carName;

private String color;

@Column(name = "engine_of_capacity")
private double engineCapacity;

@Column(name = "years_of_issue")
private Integer yearsOfIssue;

@Column(name = "car_number")
private String carNumber;

@ManyToMany(mappedBy = "cars", cascade = CascadeType.ALL)
private Set<Driver> drivers;

public Car() {
    super();
    drivers = new HashSet<>();
}

public Set<Driver> getDrivers() {
    return drivers;
}

public void setDrivers(Set<Driver> drivers) {
    this.drivers = drivers;
}

public String getCarNumber() {
    return carNumber;
}

public void setCarNumber(String carNumber) {
    this.carNumber = carNumber;
}

public String getCarName() {
    return carName;
}

public void setCarName(String carName) {
    this.carName = carName;
}

public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
}

public double getEngineCapacity() {
    return engineCapacity;
}

public void setEngineCapacity(double engineCapacity) {
    this.engineCapacity = engineCapacity;
}

public Integer getYearsOfIssue() {
    return yearsOfIssue;
}

public void setYearsOfIssue(Integer yearsOfIssue) {
    this.yearsOfIssue = yearsOfIssue;
}
}

洗掉汽車：

@Override
public void delete(Long id) {
    entityManager.createQuery("delete from Car s where s.id = :id")
            .setParameter("id", id)
            .executeUpdate();
}

洗掉驅動程式：

@Override
public void delete(Long id) {
    entityManager.createQuery("delete from Driver d where d.id = :id")
            .setParameter("id", id)
            .executeUpdate();
}

uj5u.com熱心網友回復：

每個人都應該是關于使用非常謹慎CascadeType.ALL的@ManyToMany如如這里所描述的關聯，因為這可能會產生意想不到的結果：
https://thorben-janssen.com/best-practices-for-many-to-many-associations-with-hibernate-and -jpa/#The_CascadeType_you_should_avoid_at_all_costs

在最好的情況下，它只會產生性能問題，但在最壞的情況下，它還可能洗掉比您預期更多的記錄。

因此，更好的方法是，例如，擁有一個專門的服務邏輯，它準確地指定要洗掉哪些物體，當然還負責同步關聯的雙方。
這樣，還可以簡單地檢查一個先前關聯的在洗掉后是否Car沒有更多關聯的Drivers，以便Car隨后也可以洗掉“孤兒” 。

標籤：

上一篇：如何洗掉物體

下一篇：如何修復無法延遲初始化集合