Nous utilisons Spring @Configurable (avec un nouvel opérateur régulier) qui fonctionne comme un charme. Plus de anemic domain models. Enfin, c'est beaucoup plus la conception orientée objet, n'est-ce pas:
Person person = new Person(firstname, lastname);
// weird
peopleService.save(person);
// good (save is @Transactional)
person.save();
Mail mail = new Mail(to, subject, body);
// weird
mailService.send(mail);
// good (send is @Transactional)
mail.send();
Cependant, nous n'avons fait aucune comparaison de performance. Jusqu'à présent, nous n'avons tout simplement pas ressenti le besoin de le faire.
EDIT: voilà comment la classe personne ressemblerait à ceci:
@Configurable("person")
public class Person {
private IPersonDAO _personDAO;
private String _firstname;
private String _lastname;
// SNIP: some constructors, getters and setters
@Transactional(rollbackFor = DataAccessException.class)
public void save() {
_personDAO.save(this);
}
@Transactional(readOnly = true)
public List<Role> searchRoles(Company company) void{
return _personDAO.searchRoles(this, company);
}
// it's getting more interesting for more complex methods
@Transactional(rollbackFor = DataAccessException.class)
public void resignAllRoles(Company company) {
for (Role role : searchRoles(company)) {
role.resign();
}
}
}
// the implementation now looks like this
personService.getPerson(id).resignAllRoles(company);
// instead of this
roleService.resignAll(personService.searchRoles(personService.getPerson(id), company));
Et c'est la configuration Spring:
<context:spring-configured />
<bean id="person" class="org.example.model.Person" lazy-init="true">
<property name="personDAO" ref="personDAO" />
</bean>
Note: comme vous le voyez, il y a des services toujours là, par exemple pour rechercher des objets (personService.getPerson (id)) mais toutes les méthodes qui opèrent sur un objet passé (par exemple une personne) sont déplacées vers cette classe elle-même (c'est-à-dire person.save() au lieu de personService.save (personne)). La méthode reste la même et fonctionne avec n'importe quelle couche d'accès aux données sous-jacente (JDBC pur, Hibernate, JPA, ...). Il a simplement déménagé là où il appartient.
http://stackoverflow.com/questions/2091749/domain-driven-design-and-transactions-in-spring-environment – Bozho