Java Hibernate：如何处理DAO中的会话以正确设置关联？

我找不到使用DAO设置关联的解决方案。这需要解释。有3个实体：银行、客户和账户。银行和客户有双向多对多关联，客户和账户有一对多关联。有一个GenericDAO接口，由每个实体的DAO实现。由于应用程序不是多线程的，我决定通过在DAO接口实现的每个方法中打开和关闭会话来实现每个请求的会话“模式”。请看一下代码。代码下面描述了该问题

银行POJO

@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", fetch = FetchType.EAGER)
    public Set<Client> getSetOfClients() {
        return setOfClients;
    }

    public void setSetOfClients(Set<Client> setOfClients) {
        this.setOfClients = setOfClients;
    }
}**

@实体
@表（名称=“银行”）
公营银行{
私人银行ID；
私有字符串bankName；
一组专用客户机；
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
@列（name=“银行id”）
public int getBankID（）{
返回bankID；
}
公共银行ID（内部银行ID）{
this.bankID=bankID；
}
@列（name=“银行名称”）
公共字符串getBankName（）{
返回银行名称；
}
公共银行名称（字符串银行名称）{
this.bankName=银行名称；
}
@ManyToMany（mappedBy=“setOfBanks”，fetch=FetchType.EAGER）
公共集GetSetOfClient（）{
返回客户端集合；
}
公共无效SetSetToFClients（SetOfClient）{
this.setOfClients=setOfClients；
}
}**

客户POJO

@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", cascade = {CascadeType.ALL})
    public Set<Account> getSetOfAccounts() {
        return setOfAccounts;
    }

    public void setSetOfAccounts(Set<Account> setOfAccounts) {
        this.setOfAccounts = setOfAccounts;
    }

    @ManyToMany(targetEntity = Bank.class, cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)
    @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;
    }
}

public class ClientDAO<Client> implements GenericDAO<Client>{

    private Session session;

    @Override
    public void saveEntity(Client entity) {
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            session.save(entity);
            session.getTransaction().commit();
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    @Override
    public void deleteEntity(Client entity) {
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            session.delete(entity);
            session.getTransaction().commit();
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

    }

    @Override
    public void updateEntity(Object entity) {
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            session.update(entity);
            session.getTransaction().commit();
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    @Override
    public Client getEntityByID(int id) {
        Client client = null;
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            client = (Client) session.get(model.entity.Client.class, id);
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
        return client;
    }

    @Override
    public List<Client> getAllEntities() {
        List<Client> result = null;
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            result = session.createQuery("from Client").list();
            session.getTransaction().commit();
        } catch (HibernateException e) {
            if (session != null) {
                session.getTransaction().rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
        return result;
    }
}

@实体
@表（name=“客户”）
公共类客户端{
私人int客户ID；
私有字符串名；
私有字符串secondName；
私有集合计数；
私人银行集合；
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
@列（name=“client\u id”）
public int getClientID（）{
返回客户ID；
}
public void setClientID（int clientID）{
this.clientID=clientID；
}
@列（name=“first_name”）
公共字符串getFirstName（）{
返回名字；
}
public void setFirstName（字符串firstName）{
this.firstName=firstName；
}
@列（name=“second_name”）
公共字符串getSecondName（）{
返回secondName；
}
public void setSecondName（字符串secondName）{
this.secondName=secondName；
}
@OneToMany（mappedBy=“clientID”，cascade={CascadeType.ALL}）
公共集GetSetOfcounts（）{
返回集合计数；
}
公共无效集合集合失效计数（集合失效计数）{
this.setOfAccounts=setOfAccounts；
}
@ManyToMany（targetEntity=Bank.class，cascade={CascadeType.ALL}，fetch=FetchType.EAGER）
@可接合(
name=“银行客户”，
joinColumns={@JoinColumn（name=“client\u id”，nullable=false，referencedColumnName=“client\u id”）}，
inverseJoinColumns={@JoinColumn（name=“bank\u id”，nullable=false，referencedColumnName=“bank\u id”）}
)
公共集getSetOfBanks（）{
返回银行集合；
}
公共作废集合银行（集合银行）{
this.setOfBanks=setOfBanks；
}
}

ClientDAO

@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", cascade = {CascadeType.ALL})
    public Set<Account> getSetOfAccounts() {
        return setOfAccounts;
    }

    public void setSetOfAccounts(Set<Account> setOfAccounts) {
        this.setOfAccounts = setOfAccounts;
    }

    @ManyToMany(targetEntity = Bank.class, cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)
    @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;
    }
}

public class ClientDAO<Client> implements GenericDAO<Client>{

    private Session session;

    @Override
    public void saveEntity(Client entity) {
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            session.save(entity);
            session.getTransaction().commit();
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    @Override
    public void deleteEntity(Client entity) {
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            session.delete(entity);
            session.getTransaction().commit();
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

    }

    @Override
    public void updateEntity(Object entity) {
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            session.update(entity);
            session.getTransaction().commit();
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    @Override
    public Client getEntityByID(int id) {
        Client client = null;
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            client = (Client) session.get(model.entity.Client.class, id);
        } catch (HibernateException e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
        return client;
    }

    @Override
    public List<Client> getAllEntities() {
        List<Client> result = null;
        try {
            session = SessionFactoryUtil.getSessionFactory().openSession();
            session.getTransaction().begin();
            result = session.createQuery("from Client").list();
            session.getTransaction().commit();
        } catch (HibernateException e) {
            if (session != null) {
                session.getTransaction().rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
        return result;
    }
}

public类ClientDAO实现GenericDAO{
非公开会议；
@凌驾
公共实体（客户实体）{
试一试{
session=SessionFactoryUtil.getSessionFactory（）.openSession（）；
session.getTransaction（）.begin（）；
session.save（实体）；
session.getTransaction（）.commit（）；
}捕获（休眠异常e）{
session.getTransaction（）.rollback（）；
e、 printStackTrace（）；
}最后{
session.close（）；
}
}
@凌驾
公共实体（客户实体）{
试一试{
session=SessionFactoryUtil.getSessionFactory（）.openSession（）；
session.getTransaction（）.begin（）；
删除（实体）；
session.getTransaction（）.commit（）；
}捕获（休眠异常e）{
session.getTransaction（）.rollback（）；
e、 printStackTrace（）；
}最后{
session.close（）；
}
}
@凌驾
公共void updateEntity（对象实体）{
试一试{
session=SessionFactoryUtil.getSessionFactory（）.openSession（）；
session.getTransaction（）.begin（）；
更新（实体）；
session.getTransaction（）.commit（）；
}捕获（休眠异常e）{
session.getTransaction（）.rollback（）；
e、 printStackTrace（）；
}最后{
session.close（）；
}
}
@凌驾
公共客户端getEntityByID（int id）{
Client=null；
试一试{
session=SessionFactoryUtil.getSessionFactory（）.openSession（）；
session.getTransaction（）.begin（）；
client=（client）session.get（model.entity.client.class，id）；
}捕获（休眠异常e）{
session.getTransaction（）.rollback（）；
e、 printStackTrace（）；
}最后{
session.close（）；
}
返回客户；
}
@凌驾
公共列表getAllenties（）{
列表结果=空；
试一试{
session=SessionFactoryUtil.getSessionFactory（）.openSession（）；
session.getTransaction（）.begin（）；
结果=session.createQuery（“来自客户端”）.list（）；
session.getTransaction（）.commit（）；
}捕获（休眠异常e）{
if（会话！=null）{
session.getTransaction（）.rollback（）；
}
e、 printStackTrace（）；
}最后{
session.close（）；
}
返回结果；
}
}

BankDAO具有类似的方法实现，但与银行实体规范相关

@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", fetch = FetchType.EAGER)
    public Set<Client> getSetOfClients() {
        return setOfClients;
    }

    public void setSetOfClients(Set<Client> setOfClients) {
        this.setOfClients = setOfClients;
    }
}**

主要方法

public class Main {
        public static void main(final String[] args) {

            ClientDAO<Client> clientDAO = new ClientDAO<Client>();
            BankDAO<Bank> bankDAO = new BankDAO<Bank>();

            Client client = clientDAO.getEntityByID(11);
            Bank bank = bankDAO.getEntityByID(3);

            Set<Bank> setOfBanks = client.getSetOfBanks();
            setOfBanks.add(bank);

            Set<Client> setOfClients = bank.getSetOfClients();
            setOfClients.add(client);
        }
}

公共类主{
公共静态void main（最终字符串[]args）{
克莱