Oi pessoal, esse mes eu terminei meu primero programa (finalmente) e usei annotations e DAO… mas eu fiz pra cada entidade q eu tenho no programa… entao busquei sobre um DAO generico que pudesse aplicar futuramente, e me peguei pensando se meu DAO estava correto, pq meio que fiz olhando 1 de um amigo que ja estava pronto, entao venho aqui pra pedir q vcs olhem minhas classes e digam se fiz corretamente, se for possivel.
Classe CTR_ManterCurso:
public class CTR_ManterCurso {
FactoryDAO factory;
CursoHibernateDAO cursoHibernateDAO = new CursoHibernateDAO();
public CTR_ManterCurso(FactoryDAO factory) {
this.factory = factory;
}
public boolean excluirCurso(Curso curso) {
try {
cursoHibernateDAO.excluir(curso);
return true;
} catch (ConstraintViolationException e) {
JOptionPane.showMessageDialog(null, "Não foi possivel excluir o cursoo. Existem referencias a ele em outras tabelas.");
return false;
}catch (HibernateException e) {
e.printStackTrace();
return false;
}
}
public boolean alterarCurso(Curso curso) {
try {
cursoHibernateDAO.alterar(curso);
return true;
} catch (HibernateException e) {
e.printStackTrace();
return false;
}
}
public boolean gravarCurso(Curso curso) {
try {
cursoHibernateDAO.gravar(curso);
return true;
} catch (HibernateException e) {
e.printStackTrace();
return false;
}
}
public List listarCursos(String ordem) {
List<Curso> cursos;
try {
return cursos = cursoHibernateDAO.listarCursos(ordem);
} catch (HibernateException e) {
return null;
}
}
public List removerCursos(String ordem) {
List<Curso> cursos;
try {
return cursos = cursoHibernateDAO.removerCursos(ordem);
} catch (HibernateException e) {
return null;
}
}
public Curso carregarUmCurso(Integer codigo) {
try {
Curso curso = new Curso();
return curso = (Curso) cursoHibernateDAO.carregarUm(codigo);
} catch (HibernateException e) {
e.printStackTrace();
return null;
}
}
public Curso carregarUmCurso(String nome) {
try {
Curso curso = new Curso();
return curso = (Curso) cursoHibernateDAO.carregarUm(nome);
} catch (HibernateException e) {
e.printStackTrace();
return null;
}
}
}
Classe CursoDAO
public interface CursoDAO {
public Curso carregarUm(Integer idCurso) throws HibernateException;
public Curso carregarUm(String nomeCurso) throws HibernateException;
public void alterar(Curso curso1) throws HibernateException;
public void excluir(Curso curso1) throws HibernateException;
public void gravar(Curso curso1) throws HibernateException;
public List listarCursos(String ordem) throws HibernateException;
public List removerCursos(String ordem) throws HibernateException;
}
Classe CursoHibernateDAO
public class CursoHibernateDAO implements CursoDAO {
private HibernateConfiguracao hibernateConfiguracao;
/** Creates a new instance of ClienteHibernateDAO */
public CursoHibernateDAO() {
super();
hibernateConfiguracao = new HibernateConfiguracao();
}
public Curso carregarUm(Integer idCurso) throws HibernateException {
Session session = new HibernateFactory().getSession();
session.getTransaction().begin();
Criteria criteria = session.createCriteria(Curso.class);
criteria.add(Expression.eq("cod_curso", idCurso));
Curso curso1 = (Curso) criteria.uniqueResult();
session.getTransaction().commit();
session.close();
return curso1;
}
public Curso carregarUm(String nomeCurso) throws HibernateException {
Session session = new HibernateFactory().getSession();
session.getTransaction().begin();
Criteria criteria = session.createCriteria(Curso.class);
criteria.add(Expression.eq("nome", nomeCurso));
Curso curso1 = (Curso) criteria.uniqueResult();
session.getTransaction().commit();
session.close();
return curso1;
}
public List listarCursos(String ordem) throws HibernateException {
Session session = new HibernateFactory().getSession();
Criteria criteria = session.createCriteria(Curso.class);
criteria.addOrder(Order.asc(ordem));
return criteria.list();
}
public List removerCursos(String ordem) throws HibernateException {
Session session = new HibernateFactory().getSession();
Criteria criteria = session.createCriteria(Curso.class);
criteria.addOrder(Order.asc(ordem));
return criteria.list();
}
public void gravar(Curso curso1) throws HibernateException {
// Session session = new HibernateFactory().getSession();
// session.getTransaction().begin();
// session.save(curso);
// session.getTransaction().commit();
// session.close();
Session session = new HibernateFactory().getSession();
Transaction tx = session.beginTransaction();
session.save(curso1);
tx.commit();
session.close();
}
public void alterar(Curso curso1) throws HibernateException {
Session session = new HibernateFactory().getSession();
Transaction tx = session.beginTransaction();
Curso curso2 = new Curso();
curso2 = (Curso) session.get(Curso.class, curso1.getCodigo());
curso2.setNome(curso1.getNome());
curso2.setReferencia(curso1.getReferencia());
tx.commit();
session.close();
}
public void excluir(Curso curso1) throws HibernateException {
Session session = new HibernateFactory().getSession();
session.getTransaction().begin();
try {
session.delete(curso1);
} catch (ConstraintViolationException e) {
JOptionPane.showMessageDialog(null, "Não foi possivel excluir o curso. Existem referencias a ele em outras tabelas.");
}
session.delete(curso1);
session.getTransaction().commit();
session.close();
}
}
n sei se to pedindo dimais, mas kero ter certeza de que estou fazendo certo
Vlw
Li por cima e acho que você poderia usar a DAOFactory para obter o seu Dao Hibernate. Desta forma vc não atrela o controle com a sua estratégia de persistência.
Abs!
Danilo
agora q vc falo, tem 1 FactoryDAO sim, pelo q eu intendi eh isso mesmo q ela faz, a ela ai:
public interface FactoryDAO {
public CursoDAO criarCursoDAO();
public DepartamentoDAO criarDepartamentoDAO();
public DiaDAO criarDiaDAO();
public DisciplinaDAO criarDisciplinaDAO();
public HorarioDAO criarHorarioDAO();
public PlanejamentoDAO criarPlanejamentoDAO();
public ProfessorDAO criarProfessorDAO();
public SalaDAO criarSalaDAO();
public TurmaDAO criarTurmaDAO();
}
e essa classe implementa ela:
public class HibernateFactoryDAO implements FactoryDAO {
public HibernateFactoryDAO() {
super();
}
public ProfessorDAO criarProfessorDAO() {
return new ProfessorHibernateDAO();
}
public CursoDAO criarCursoDAO(){
return new CursoHibernateDAO();
}
public DepartamentoDAO criarDepartamentoDAO(){
return new DepartamentoHibernateDAO();
}
public DiaDAO criarDiaDAO(){
return new DiaHibernateDAO();
}
public DisciplinaDAO criarDisciplinaDAO(){
return new DisciplinaHibernateDAO();
}
public HorarioDAO criarHorarioDAO(){
return new HorarioHibernateDAO();
}
public PlanejamentoDAO criarPlanejamentoDAO(){
return (PlanejamentoDAO) new PlanejamentoHibernateDAO();
}
public SalaDAO criarSalaDAO(){
return new SalaHibernateDAO();
}
public TurmaDAO criarTurmaDAO(){
return new TurmaHibernateDAO();
}
v se eh isso mesmo q vc falo q eu posso ter intendido errado
Você pegou o conceito básico do DAO. Está ótimo para um iniciante.
Tem muitas melhorias que você ainda pode fazer, mas vai fundo que você chega lá.
Entao, eu queria saber que melhorias sao essas que eu poderia fazer, que eu ja poderia aplica no proximo programa q eu fizer
As melhorias são:
DAO genérico
Injeção de dependências
Com esses dois, você reutiliza o desenvolvido em dezenas de projetos, pois eles minimizam uns 65% a 75% do trabalho.
eu começei a tenta monta 1 DAO generico, mas to sbarrando na alteração:
public void alterar(Curso curso1) throws HibernateException {
Session session = new HibernateFactory().getSession();
Transaction tx = session.beginTransaction();
Curso curso2 = new Curso();
curso2 = (Curso) session.get(Curso.class, curso1.getCodigo());
curso2.setNome(curso1.getNome());
curso2.setReferencia(curso1.getReferencia());
tx.commit();
session.close();
}
pq quando eu usei session.update(curso1) ele nao alterava, intaum como eu faço essa parte fika generica? sem contar que eu ns ei como generalizar os locais onde tem campo de tabela, como na função carregaUm… Eu procurei DAOs genericos no google, axei alguns mas eles usam Spring, que eu nao conheço, dae fikei boiando…
Tem um aqui bem mais simples, mas é com Spring:
http://www.urubatan.com.br/dao-generico-um-exemplo-a-pedidos/
Somente com Hibernate vc terá que fazer algumas coisas a mais, ou injetar manualmente. Porém, num compensa, uma vez que o Spring é super simples de entender e dá um “plus” a mais de diversos itens do seu “cinto de utilidades”.
Aqui no forum tem algum tutorial de spring? kero intende como funciona e tentar usar ele aki
se tiver tá ultrapassado. O spring hoje usa anotações, o que o torna bem simples.
Pega no site do framework que tem tudo que precisa.
A documentação é bárbara. Mas tem livros tb. Spring in Action e o da Apress, Spring Pro (se num me engano). Gosto mais da Apress, bem mais abrangente.
Agora se quiser um livro com essas coisas na prática, em projeto passo a passo, eu até posso indicar um.
Amigo seu DAO ficou meio fora do padrão … como você sabe ele é uma classe extremamente especializada … ou seja uma classe burra … se você mandar ele fazer ele vai fazer … então conferencias estão eliminadas dessa lista … classes CRUD não checam nada … uma outra classe realiza a mesma … se for seguir a risca os Desinger Pather para auxiliar o DAO precisa-se também de um objeto para transferencia … (TO) …
bom mais se tah funcionando segue em frente =) …
abraço tenha uma otima noite
djemacao, eu dei uma olhada nesse site, mas ta tudo voltado pra web, e eu ainda n começei a mexer com web ainda, to so desktop mesmo, fiko meio complicado de separar o q eu posso usar, devido ao meu pouco conhecimento
Não, olhe a base do funcionamento pq é independente disso. É que IoC é mais usado em Web.
@jgavazzisp, ele tá aprendendo ainda a usar, então vai colocar um Generic ali, um IoC aqui e então vai começar a desacoplar de coisas mais específicas.
blz, vo da 1 olhada la no site do spring mesmo e vejo q q eu consigu entender la, vlw ae
Ae pessoal, eu dei uma estudada no spring e dei umas mexidas aki, saiu isso:
GenericDao:
import java.util.List;
public interface GenericDao {
public void save(Object ob);
public void update(Object ob);
public void delete(Object ob);
public List listAll(Class classe, String ordem);
public Object findOne(Class classe, String coluna_codigo, int cod);
public Object findOne(Class classe, String coluna, String nome);
}
GenericHibernateDao:
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
public class GenericHibernateDao implements GenericDao {
private SessionFactory sessionFactory;
private Session getSession() {
Session session = null;
try {
session = getSessionFactory().openSession();
} catch (HibernateException e) {
e.printStackTrace();
}
return session;
}
public void save(Object ob) {
Session session = this.getSession();
session.save(ob);
session.flush();
session.close();
}
public void update(Object ob) {
Session session = this.getSession();
session.update(ob);
session.flush();
session.close();
}
public void delete(Object ob) {
Session session = this.getSession();
session.delete(ob);
session.flush();
session.close();
}
public List listAll(Class classe, String ordem) {
Session session = this.getSession();
Criteria criteria = session.createCriteria(classe);
criteria.addOrder(Order.asc(ordem));
List lista = criteria.list();
return lista;
}
public Object findOne(Class classe, String coluna_codigo, int cod) {
Session session = this.getSession();
Criteria criteria = session.createCriteria(classe);
criteria.add(Restrictions.eq(coluna_codigo, cod));
Object ob = criteria.uniqueResult();
session.close();
return ob;
}
public Object findOne(Class classe, String coluna, String texto) {
Session session = this.getSession();
Criteria criteria = session.createCriteria(classe);
criteria.add(Restrictions.eq(coluna, texto));
Object ob = criteria.uniqueResult();
session.close();
return ob;
}
public SessionFactory getSessionFactory() {
return sessionFactory;
}
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
}
Controller_Aluno, por exemplo:
import hibernate.dao.GenericDao;
import hibernate.model.Aluno;
import java.util.List;
public class Controller_Aluno {
private GenericDao genericDao;
public GenericDao getGenericDao() {
return genericDao;
}
public void setGenericDao(GenericDao genericDao) {
this.genericDao = genericDao;
}
public void salvarAluno(Aluno aluno) {
getGenericDao().save(aluno);
}
public void alterarAluno(Aluno aluno) {
getGenericDao().update(aluno);
}
public void excluirAluno(Aluno aluno) {
getGenericDao().delete(aluno);
}
public List listarTodosAlunos(String ordem) {
return getGenericDao().listAll(Aluno.class,ordem);
}
public Aluno carregarUmAluno(int codigo) {
return (Aluno) getGenericDao().findOne(Aluno.class, "codigo", codigo);
}
}
applicationContext.xml:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<!-- Instância de DriverManagerDataSource do bean sessionFactory !-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/urso</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>root</value>
</property>
</bean>
<!-- Instância de AnnotationSessionFactoryBean usada pelo bean genericDao !-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource"/>
</property>
<property name="annotatedClasses">
<list>
<value>hibernate.model.Aluno</value>
<value>hibernate.model.Turma</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}
</prop>
<prop key="hibernate.hbm2ddl.auto">update
</prop>
</props>
</property>
</bean>
<!-- Instância de GenericHibernateDao !-->
<bean id="genericDao" class="hibernate.dao.GenericHibernateDao">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- Instância de AnnotationConfiguration !-->
<bean id="cfg" class="org.hibernate.cfg.AnnotationConfiguration">
</bean>
<!-- Instância de Controller_Aluno !-->
<bean id="ctrAluno" class="hibernate.control.Controller_Aluno">
<property name="genericDao" ref="genericDao">
</property>
</bean>
<!-- Instância de Controller_Turma !-->
<bean id="ctrTurma" class="hibernate.control.Controller_Turma">
<property name="genericDao" ref="genericDao">
</property>
</bean>
<!-- Instância de HibernateTransactionManager !-->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- Faz a busca de metodos que usam Transactions !-->
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>
pra acessar o genericDao eu fiz 1 classe de controle, pra adiciona as especificidades de cada classe do model e o transactions ali to testando, nem sei se eu preciso mas to testando… q q vcs axam? tem alguma coisa q da pra melhora???