Ola
Tempos atrás eu tive algumas discussões aqui no fórum e isso me esclareceu algumas duvidas. Porem após dois meses ainda me falta compreender alguns assuntos.
Eu andei lendo alguns comentários aqui no fórum, e fiquei com algumas duvidas se estou aplicando corretamente DAOs, Repository, Service, Entity e Aggregate.
Eu tenho as seguintes situações, uma fabrica de Repositório que coleta o DAO correspondente através de IoC, segue código abaixo:
public abstract class RepositoryFactory {
public abstract LoginRepository getLoginRepository();
public static RepositoryFactory getRepositoryFactory(){
Properties resource = Util.readResource();
int whichRepository = Integer.parseInt(resource.getProperty("whichRepository"));
switch(whichRepository){
case 1:
return new HibernateRepositoryFactory();
default:
return null;
}
}
}
public class HibernateRepositoryFactory extends RepositoryFactory{
private static final ApplicationContext context;
static {
try {
context = new ClassPathXmlApplicationContext("iocForHibernate.xml");
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public LoginRepository getLoginRepository() {
return (LoginRepository) context.getBean("loginDAO");
}
}Eu não quero transpor a injeção de dependência para o Cliente, então faço uso de uma fabrica para abstrair isso, como demonstrei no código acima.
Portanto o Service do Usuário pode verificar se um determinado login existe no banco de dados da seguinte forma:
public class UserService {
private static final LoginRepository loginRepository;
static{
RepositoryFactory factory = RepositoryFactory.getRepositoryFactory();
loginRepository = factory.getLoginRepository();
}
public static boolean verifyLogin(Login login){
List<Login> list = loginRepository.listByExample(login);
if(list.size() > 0)
return true;
else
return false;
}
}Feito isso eu tenho tudo preparado para o Cliente verificar se o login existe, da seguinte maneira:
public class LogonBean {
public String verifyLogin(){
Login user = new Login();
user.setLogin(login);
user.setPassword(password);
boolean exist = UserService.verifyLogin(user);
if(!exist)
return "login_fail";
else
return "home";
}
}Conclusão:
1)A injeção de dependência foi adicionado para que eu não precise ficar controlando as transações, como vc pode perceber eu não precisei ficar escrevendo begin transaction, rollback e etc.
2)A Fabrica serve para esconder do cliente a injeção de dependência.
3)O Service não fez muito sentido, pois o contexto aqui é muito pequeno, mas imagine uma situação de cadastro de usuário, nessa situação o Service poderia fazer uso de outros Repository, e novamente eu não quero transpor essa lógica para o cliente, portanto digamos que o Service contém parte da lógica.
4)A Entity esta espalhada por todos os cantos, uso esta dentro do Service para passar o critério de busca, uso ela também no Cliente para popular os dados que são coletados da interface web.
5)Creio que esteja faltando o Aggregate, dessa forma não teríamos a Entity trafegando entre as camadas, mas eu particularmente acho muito trabalhoso ficar criando esses Aggregate e estes não me traz muitos benefícios.
6)Eu estou pensando em juntar o Entity com o Service, mas usando IoC para isso, assim o nosso Cliente poderia usar algo semelhante ao ActiveRecord dentro da Entity
7)Apesar de adicionar essas implementações eu ainda acho que estou caindo no problema do Modelo Anemico, e que ainda preciso me aprofundar mais nos conceitos de DDD. O DDD me ajudou mais na forma de conceber o projeto do que no código em sí. Aprendemos a não usar Waterfall, criamos uma linguagem comum de comunicação com os clientes, procuramos definir quem são os Peritos do Domínio e etc, porem acho que no código em si eu não evolui muito e percebi que os problemas de software estavam mais relacionados na concepção do projeto do que código fonte do projeto.