我有2个问题，它们是通过Hibernate将数据插入MySQL表中的。有4个表：
客户，帐户，银行和Bank_Client。客户与银行设置多对多关联，与帐户设置一对多关联。 Bank_Client是Client和Bank之间的中间联接表。这是问题：
一种。如果仅保存clientA和clientB（请查看Main.java），则仅将其属性的值保存在表中。我在@ManyToMany中指出了层叠属性，如果我正确理解的话，它有义务save（）持久保存客户机实体具有引用的所有实体。但事实并非如此。如果我保存所有对象（clientA，clientB，bankA，bankB，accountAClientA，accountBClientA），则一切正常。但是问题是-如何仅通过保存客户端实体来保存所有引用的对象；
b。在上述任何情况下，数据都不会保存在Bank_Account中。
我将不胜感激任何建议。先感谢您。
CREATE TABLE client(client_id INT(3) AUTO_INCREMENT,
first_name VARCHAR(15) NOT NULL,
second_name VARCHAR(15) NOT NULL,
PRIMARY KEY(client_id));
CREATE TABLE account(account_id INT(3) AUTO_INCREMENT,
account_number VARCHAR(12) NOT NULL,
amount DECIMAL(10,2) NOT NULL,
currency VARCHAR(3) NOT NULL,
client_id INT(3) NOT NULL,
PRIMARY KEY(account_id),
FOREIGN KEY(client_id) REFERENCES client(client_id));
CREATE TABLE bank(bank_id INT(3) AUTO_INCREMENT,
bank_name VARCHAR(15) NOT NULL,
PRIMARY KEY(bank_id));
CREATE TABLE bank_client(client_id INT(3) NOT NULL,
bank_id INT(3) NOT NULL,
PRIMARY KEY(client_id, bank_id),
FOREIGN KEY(client_id) REFERENCES client(client_id),
FOREIGN KEY(bank_id) REFERENCES bank(bank_id));
Account.java
@Entity
@Table(name = "account")
public class Account {
private int accountID;
private String accountNumber;
private float amount;
private String currency;
private Client clientID;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "account_id")
public int getAccountID() {
return accountID;
}
public void setAccountID(int accountID) {
this.accountID = accountID;
}
@Column(name = "account_number")
public String getAccountNumber() {
return accountNumber;
}
public void setAccountNumber(String accountNumber) {
this.accountNumber = accountNumber;
}
@Column(name = "amount")
public float getAmount() {
return amount;
}
public void setAmount(float amount) {
this.amount = amount;
}
@Column(name = "currency")
public String getCurrency() {
return currency;
}
public void setCurrency(String currency) {
this.currency = currency;
}
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "client_id")
public Client getClientID() {
return clientID;
}
public void setClientID(Client clientID) {
this.clientID = clientID;
}
}
Bank.java
@Entity
@Table(name = "bank")
public class Bank {
private int bankID;
private String bankName;
private Set<Client> setOfClients;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "bank_id")
public int getBankID() {
return bankID;
}
public void setBankID(int bankID) {
this.bankID = bankID;
}
@Column(name = "bank_name")
public String getBankName() {
return bankName;
}
public void setBankName(String bankName) {
this.bankName = bankName;
}
@ManyToMany(mappedBy = "setOfBanks")
public Set<Client> getSetOfClients() {
return setOfClients;
}
public void setSetOfClients(Set<Client> setOfClients) {
this.setOfClients = setOfClients;
}
}
客户端.java
@Entity
@Table(name = "client")
public class Client {
private int clientID;
private String firstName;
private String secondName;
private Set<Account> setOfAccounts;
private Set<Bank> setOfBanks;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "client_id")
public int getClientID() {
return clientID;
}
public void setClientID(int clientID) {
this.clientID = clientID;
}
@Column(name = "first_name")
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
@Column(name = "second_name")
public String getSecondName() {
return secondName;
}
public void setSecondName(String secondName) {
this.secondName = secondName;
}
@OneToMany(mappedBy = "clientID")
public Set<Account> getSetOfAccounts() {
return setOfAccounts;
}
public void setSetOfAccounts(Set<Account> setOfAccounts) {
this.setOfAccounts = setOfAccounts;
}
@ManyToMany(targetEntity = Bank.class, cascade = {CascadeType.ALL})
@JoinTable(
name = "bank_client",
joinColumns = {@JoinColumn(name = "client_id", nullable = false, referencedColumnName = "client_id")},
inverseJoinColumns = {@JoinColumn(name = "bank_id", nullable = false, referencedColumnName = "bank_id")}
)
public Set<Bank> getSetOfBanks() {
return setOfBanks;
}
public void setSetOfBanks(Set<Bank> setOfBanks) {
this.setOfBanks = setOfBanks;
}
}
Main.java
public class Main {
public static void main(final String[] args) throws Exception {
Session session = SessionFactoryUtil.getSessionFactory().openSession();
Bank bankA = new Bank();
Bank bankB = new Bank();
Client clientA = new Client();
Client clientB = new Client();
Account accountAClientA = new Account();
Account accountBClientA = new Account();
bankA.setBankID(1);
bankA.setBankName("Deutch Bank AG");
bankA.setBankID(2);
bankB.setBankName("Barclays");
clientA.setClientID(1);
clientA.setFirstName("Alex");
clientA.setSecondName("Modoro");
clientB.setClientID(2);
clientB.setFirstName("Fedor");
clientB.setSecondName("Fokin");
accountAClientA.setAccountID(1);
accountAClientA.setAccountNumber("123456789120");
accountAClientA.setAmount(12000.00f);
accountAClientA.setCurrency("USD");
accountAClientA.setClientID(clientA);
accountBClientA.setAccountID(2);
accountBClientA.setAccountNumber("123456789156");
accountBClientA.setAmount(56020.00f);
accountBClientA.setCurrency("EUR");
accountBClientA.setClientID(clientA);
HashSet<Account> setOfAccountsClientA = new HashSet<Account>();
HashSet<Bank> setOfBanksClientA = new HashSet<Bank>();
HashSet<Account> setOfAccountsClientB = new HashSet<Account>();
HashSet<Bank> setOfBanksClientB = new HashSet<Bank>();
HashSet<Client> setOfClientsBankA = new HashSet<Client>();
HashSet<Client> setOfClientsBankB = new HashSet<Client>();
setOfAccountsClientA.add(accountAClientA);
setOfAccountsClientA.add(accountBClientA);
setOfBanksClientA.add(bankA);
setOfBanksClientA.add(bankB);
setOfClientsBankA.add(clientA);
setOfClientsBankA.add(clientB);
try {
session.getTransaction().begin();
// session.save(bankA);
// session.save(bankB);
session.save(clientA);
session.save(clientB);
// session.save(accountAClientA);
// session.save(accountBClientA);
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
} finally {
session.close();
}
}
}
SessionFactoryUtil.java
public class SessionFactoryUtil {
private static SessionFactory sessionFactory;
private static ServiceRegistry serviceRegistry;
private static ServiceRegistryBuilder registryBuilder;
private static SessionFactory buildSessionFactory() {
try {
Configuration configuration = new Configuration().configure();
registryBuilder = new ServiceRegistryBuilder().applySettings(configuration.getProperties());
serviceRegistry = registryBuilder.buildServiceRegistry();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
} catch (HibernateException e) {
e.printStackTrace();
}
return sessionFactory;
}
public static SessionFactory getSessionFactory() {
return buildSessionFactory();
}
public static void closeSessionFactory() {
if (sessionFactory != null) {
sessionFactory.close();
}
}
}
最佳答案
回答您的问题。要进行级联工作，您需要将所有相关对象设置为彼此。您没有将任何银行添加到客户。我想您应该具有将Bank添加到Client的setOfBanks的方法，并在保存clientA之前执行clientA.addBank（bankA）。
您确实需要考虑一下对象之间的关系。在通常情况下，您首先获得银行，然后人们成为银行的客户并在其中开设帐户。因此，不应通过级联来保存银行。保存客户端之前它应该已经存在。
关于java - 多对多关联不适用于级联属性，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/25513513/