ERRO. org.hibernate.LazyInitializationException: could not initialize proxy - no Session

@Entity
@Table(name="Cliente", schema="Tecnicos")
public class Cliente implements Serializable {

    @Id
    @SequenceGenerator(name="SEQ_CLI", sequenceName="SEQ_CLIENTE", allocationSize=1)
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_CLI")
    @Column(name="cli_id", nullable=false)
    private Integer Id;

    @Column(name="cli_codext")
    private Integer codigoExterno;

    @Column(name="cli_fili")
    private Integer filial;

    @Column(name="cli_razaosocial", length=80)
    private String razaoSocial;

    @Column(name="cli_nomefantasia", length=80)
    private String nomeFantasia;

    @Column(name="cli_cnpj", length=20)
    private String cnpj;

    @Column(name="cli_inscest", length=30)
    private String InscEst;

    @Column(name="cli_endereco", length=200)
    private String endereco;

    @Column(name="cli_bairro", length=45)
    private String bairro;

    @Column(name="cli_cidade", length=50)
    private String cidade;

    @Column(name="cli_estado", length=2)
    private String estado;

    @Column(name="cli_cep", length=20)
    private String cep;

    @Column(name="cli_telefone", length=20)
    private String telefone;

    @Column(name="cli_situreg", length=20)
    private String situ_reg;

    @OneToMany(mappedBy="cliente", fetch=FetchType.LAZY)
    @Cascade(CascadeType.ALL)
    private Collection<EmailCliente> email;

    @ManyToMany(fetch=FetchType.EAGER)
    @JoinTable(name="tecnico_cliente", schema="Tecnicos",
            joinColumns=@JoinColumn(name="teccli_cli_id"),
            inverseJoinColumns=@JoinColumn(name="teccli_tec_id"))
    private Collection<Tecnicos> tecnicos;

    @ManyToMany(fetch=FetchType.LAZY)
    @JoinTable(name="questionario_cliente", schema="Tecnicos",
            joinColumns=@JoinColumn(name="cli_id"),
            inverseJoinColumns=@JoinColumn(name="ques_id"))
    private Collection<Questionario> questionarios;

public class GenericDAO<T> implements DAO<T>{
 
    private Session session = HibernateUtil.getSessionFactory().openSession();
    private Transaction tx;
    private Class<T> classe;

    public GenericDAO(Class<T> classe){
        this.classe = classe;
    }
  
    @Override
    public void insert(T classe) {
        try{
            tx = session.beginTransaction();
            session.save(classe);
            tx.commit();
        }
        catch(HibernateException ex){
            tx.rollback();
            throw ex;
        }
        finally{
            session.close();
        }
    }

    @Override
    public void update(T classe) {
        try{
            tx = session.beginTransaction();
            session.update(classe);
            tx.commit();
        }
        catch(HibernateException ex){
            tx.rollback();
            throw ex;
        }finally{
            session.close();
        }
    }

    @Override
    public void delete(T classe) {
        try{
            tx = session.beginTransaction();
            session.update(classe);
            tx.commit();
        }
        catch(HibernateException ex){
            tx.rollback();
            throw ex;
        }finally{
            session.close();
        }
    }

    @Override
    public List<T> findAll() {
        try{
            Criteria c = session.createCriteria(this.classe);
            return c.list();
        }
        catch(HibernateException ex){
            tx.rollback();
            throw ex;            
        }finally{
            session.close();
        }
    }

    public List<T> findByName(Object coluna ,Object d) {
        try{
            Criteria c = session.createCriteria(this.classe);
            c.add(Restrictions.ilike(coluna.toString(), "%"+d.toString()+"%"));
            c.addOrder(Order.asc(coluna.toString()));
            return c.list();
        }
        catch(HibernateException ex){
            throw ex;
        }
        finally{
            session.close();
        }
    }

    public T findByID(Integer id) throws HibernateException {
         try{
            return (T) session.load(this.classe, id);
        }
        catch(HibernateException ex){
            throw ex;
        }finally{
            session.close();
        }
    }

    public void saveOrUpdate(T clazz) throws HibernateException {
        try{
            tx = session.beginTransaction();
            session.saveOrUpdate(clazz);
            tx.commit();
        }
        catch(HibernateException ex){
            tx.rollback();
            throw ex;
        }finally{
            session.close();
        }
    }
}

class ListenerAbas implements ChangeListener{

        public void stateChanged(ChangeEvent e) {
            Integer id = Integer.parseInt(tabela.getValueAt(linha, 0).toString());
            GenericDAO<Cliente> dao = new GenericDAO<Cliente>(Cliente.class);
            if(abas.getSelectedIndex() == 1){
                try{
                    Cliente cli = dao.findByID(id);
                    
                    codExt.setText(cli.getCodigoExterno().toString());
                    razaoSocial.setText(cli.getRazaoSocial());
                    nomeFantasia.setText(cli.getNomeFantasia());
                    cnpj.setText(cli.getCnpj());
                    inscEst.setText(cli.getInscEst());
                    filial.setText(cli.getFilial().toString());
                    endereco.setText(cli.getEndereco());
                    bairro.setText(cli.getBairro());
                    cidade.setText(cli.getCidade());
                    cep.setText(cli.getCep());
                    estado.setText(cli.getEstado());
                    telefone.setText(cli.getTelefone());

                }
                catch(HibernateException ex){
                    JOptionPane.showMessageDialog(null, ex);
                    ex.printStackTrace();
                }
            }
        }
    }