在JavaSpring中删除对象

我在Spring Jpa中使用复合主键构建了多对多关联。我的实体为客户和枪型，桥梁实体为租赁。我的问题是，我想删除一个租赁（我想保持获取类型的急切性）。代码运行时没有异常，但没有结果

这些实体是：

public class Client extends BaseEntity<Long> {

    private String name;

    @Embedded
    private Address address;

    @OneToMany(mappedBy = "client",
            cascade ={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH},
            fetch = FetchType.EAGER)
    @ToString.Exclude
    private Set<Rental> rentalSet = new HashSet<>();
}

在服务中的delete方法中，我尝试从两个集合中删除租金，但仍然没有任何效果：

@Override
    @Transactional
    public void deleteRental(Long clientId, Long gunTypeId) {
        logger.trace("deleteRental - method entered; clientId = {}, gunTypeId={}", clientId, gunTypeId);
        Client client = clientRepository.findById(clientId).orElseThrow();
        Optional<Rental> rentalOptional = client
                .getRentalSet()
                .stream()
                .filter(rental -> rental.getGunType().getId().equals(gunTypeId))
                .findFirst();
        rentalOptional.ifPresent(
                rental -> {
                    client.getRentalSet().remove(rental);
                }
        );
        GunType gunType = gunTypeRepository.findById(gunTypeId).orElseThrow();
        rentalOptional = gunType
                .getRentalSet()
                .stream()
                .filter(rental -> rental.getClient().getId().equals(clientId))
                .findFirst();
        rentalOptional.ifPresent(
                rental -> {
                    gunType.getRentalSet().remove(rental);
                }
        );
        logger.trace("deleteRental - method finished");
    }

@覆盖
@交易的
公共租赁（长客户ID、长gunTypeId）{
trace（“deleteRent-输入的方法；clientId={}，gunTypeId={}”，clientId，gunTypeId）；
Client Client=clientRepository.findById（clientId.orelsetrow（）；
可选rentalOptional=客户端
.getRentalSet（）
.stream（）
.filter（rental->rental.getGunType（）.getId（）.equals（gunTypeId））
.findFirst（）；
出租可选的(
租金->{
client.getRentalSet（）.remove（rental）；
}
);
GunType GunType=gunTypeRepository.findById（gunTypeId.orElseThrow（）；
rentalOptional=枪型
.getRentalSet（）
.stream（）
.filter（出租->出租.getClient（）.getId（）.equals（clientId））
.findFirst（）；
出租可选的(
租金->{
gunType.getRentalSet（）.remove（出租）；
}
);
logger.trace（“deleteRental-方法完成”）；
}

我还尝试使用诸如ophanRemoval或CascadeType.ALL之类的注释，但这些注释并没有改变任何东西

public class Rental implements Serializable {
    @Id
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    @JoinColumn(name = "client_id")
    private Client client;

    @Id
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    @JoinColumn(name = "guntype_id")
    private GunType gunType;

    @Column(name = "price")
    private Integer price;
}

@Override
    @Transactional
    public void deleteRental(Long clientId, Long gunTypeId) {
        logger.trace("deleteRental - method entered; clientId = {}, gunTypeId={}", clientId, gunTypeId);
        Client client = clientRepository.findById(clientId).orElseThrow();
        Optional<Rental> rentalOptional = client
                .getRentalSet()
                .stream()
                .filter(rental -> rental.getGunType().getId().equals(gunTypeId))
                .findFirst();
        rentalOptional.ifPresent(
                rental -> {
                    client.getRentalSet().remove(rental);
                }
        );
        GunType gunType = gunTypeRepository.findById(gunTypeId).orElseThrow();
        rentalOptional = gunType
                .getRentalSet()
                .stream()
                .filter(rental -> rental.getClient().getId().equals(clientId))
                .findFirst();
        rentalOptional.ifPresent(
                rental -> {
                    gunType.getRentalSet().remove(rental);
                }
        );
        logger.trace("deleteRental - method finished");
    }