Estaba leyendo la referencia de Spring Data JPA y me he quedado asombrado. ¡Te da todo prácticamente hecho para el Repository(equivalente a DAO)!
Simplemente creas una intefaz que extienda de JpaRepository, por ejemplo:
|
1 2 3 4 |
public interface UserRepository extends JpaRepository<User, Integer> { List<User> findByName(String name) ; User findByEmail(String email) ; } |
Después lo inyectas (no se puede inyectar una interfaz, sino que Spring crea en tiempo de ejecución una clase que cumple dicha interfaz) donde quieras:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@Service("userService") @Transactional public class JpaUserService implements UserService { @Autowired private UserRepository userRepository ; @Transactional(readOnly=true) @Override public List<User> findAll() { return Lists.newArrayList(this.userRepository.findAll()) ; } ... } |
(La clase Lists pertenece a guava)
¡Y ya está! ¡No hay que implementar nada más!
Pero eso no es todo. Spring no sólo implementa todos los métodos de JpaRepository siguientes:
|
1 2 3 4 5 6 7 8 9 10 11 |
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> { List<T> findAll(); List<T> findAll(Sort sort); List<T> findAll(Iterable<ID> ids); <S extends T> List<S> save(Iterable<S> entities); void flush(); <S extends T> S saveAndFlush(S entity); void deleteInBatch(Iterable<T> entities); void deleteAllInBatch(); T getOne(ID id); } |
sino que, además, implementa automáticamente los métodos que poseen un nombre según unas reglas, como por ejemplo en UserRepository:
|
1 2 3 4 5 6 7 8 9 |
public interface UserRepository extends JpaRepository<User, Integer> { List<User> findByName(String name) ; List<User> findByEmail(String email) ; List<User> findByEmailOrName(String email, String name) ; List<User> findByEmailAndName(String email, String name) ; Slice<User> findByName(String name, Pageable pageable) ; Page<User> queryFirst10ByLastname(String lastname, Pageable pageable) ; List<User> findByNameAndLastnameAllIgnoreCase(String name, String lastname) ; } |
La sintaxis aparece en la referencia de Spring Data JPA sobre los keyworks soportados en nombres de métodos.
Casi como en Ruby On Rails :)
Bueno… hay que configurar JPA y Spring Data JPA (en la referencia), claro :)
Llevo trabajando una temporada con él, y va genial. Tiene algún que otro bug pequeño, sobre todo en Spring Data Mongo, pero mucho mejor que Morphia u otras librerías que hay por ahí.
También es interesante la anotación @Async, los @Query para los Streams… Un gran paso hacia delante.
Buen artículo,
Saludos
Me alegra tener noticias tuyas! :)
Estoy probándolo en el TFG y qué maravilla…