This article will focus on the configuration and implementation of the persistence layer with Spring 3.1, JPA and Spring Data<\/strong>. For a step by step introduction about setting up the Spring context using Java based configuration and the basic Maven pom for the project, see this article<\/a>.<\/p>\n The Persistence with Spring<\/strong> series<\/a>: As discussed in an earlier article, the DAO layer<\/a> usually consists of a lot of boilerplate code that can and should be simplified. The advantages of such a simplification are many fold: a decrease in the number of artifacts that need to be defined and maintained, simplification and\u00a0consistency of data access patterns and consistency of configuration.<\/p>\n Spring Data takes this simplification one step forward and makes it possible to remove the DAO implementations entirely<\/strong> \u2013 the interface of the DAO is now the only artifact that need to be explicitly defined.<\/p>\n In order to start leveraging the Spring Data programming model with JPA, a DAO interface needs to extend the JPA specific Repository<\/em> interface –\u00a0JpaRepository<\/em> \u2013 in Spring\u2019s interface hierarchy. This will enable Spring Data to find this interface and automatically create an implementation for it.<\/p>\n Also, by extending the interface we get most if not all relevant CRUD generic methods for standard data access available in the DAO.<\/p>\n As discussed, by implementing one of the Repository<\/em> interfaces, the DAO will already have some basic CRUD methods (and queries) defined and implemented. To define more specific access methods, Spring JPA supports quite a few options \u2013 you can either simply define a new method<\/strong> in the interface, or you can provide the actual JPQ query<\/strong> by using the @Query<\/em> annotation. A third option to define custom queries is to make use of\u00a0JPA Named Queries, but this has the disadvantage that it either involves XML or burdening the domain class with the queries.<\/p>\n In addition to these, Spring Data introduces<\/a> a more flexible and convenient API, similar to the JPA Criteria API, only more readable and reusable. The advantages of this API will become more pronounced when dealing with a large number of fixed queries that could potentially be more concisely expressed through a smaller number of reusable blocks that keep occurring in different combinations.<\/p>\n When Spring Data creates a new Repository<\/em> implementation, it analyses all the methods defined by the interfaces and tries to automatically generate queries from the method name<\/strong>. While this has limitations, it is a very powerful and elegant way of defining new custom access methods with very little effort.<\/p>\n For example, if the managed entity has a name <\/em>field (and the Java Bean standard getter and setter for that field), defining the findByName<\/em> method<\/strong> in the DAO interface will automatically generate the correct query:<\/p>\n This is a relatively simple example; a much larger set of keywords<\/a> is supported by query creation mechanism.<\/p>\n In the case that the parser cannot match the property with the domain object field, the following exception is thrown:<\/p>\n java.lang.IllegalArgumentException: No property nam<\/strong> found for type class org.rest.model.Foo<\/p>\n In addition to deriving the query from the method name, a custom query can be manually specified with the method level @Query<\/em> annotation.<\/p>\n For even more fine grained control over the creation of queries, such as using named parameters or modifying existing queries, the reference<\/a> is a good place to start.<\/p>\n The actual implementation of the Spring Data managed DAO \u2013 SimpleJpaRepository<\/em> \u2013 uses annotations to define and configure transactions<\/strong>. A read only @Transactional<\/em> annotation is used at the class level, which is then overridden for the non read-only methods. The rest of the transaction semantics are default, but these can be easily overridden manually per method.<\/p>\n One of the responsibilities of Spring ORM templates (JpaTemplate<\/em>, HibernateTemplate<\/em>) is exception translation<\/strong> \u2013 translating JPA exceptions \u2013 which tie the API to JPA \u2013 to Spring\u2019s DataAccessException<\/em> hierarchy.<\/p>\n Without the template to do that, exception translation can still be enabled by annotating the DAOs with the @Repository<\/em> annotation. That, coupled with a Spring bean postprocessor will advice all @Repository<\/em> beans with all the implementations of PersistenceExceptionTranslator<\/em> found in the Container \u2013 to provide exception translation without using the template.<\/p>\n The fact that exception translation is indeed active can easily be verified with an integration test<\/strong>:<\/p>\n Exception translation is done through proxies; in order for Spring to be able to create proxies around the DAO classes, these must not be declared final<\/strong><\/em>.<\/p>\n To activate the Spring JPA repository support, the jpa<\/em> namespace<\/strong> is defined and used to specify the package where to DAO interfaces are located:<\/p>\n At this point, there is no equivalent Java based configuration \u2013 support for it is however in the works<\/a>.<\/p>\n The previous article of the series already discussed in great detail how to configure JPA in Spring 3<\/a>. Spring Data also takes advantage of the Spring support for the JPA @PersistenceContext<\/em> annotation which it uses to wire the EntityManager<\/em> into the Spring factory bean responsible with creating the actual DAO implementations \u2013 JpaRepositoryFactoryBean<\/em>.<\/p>\n In addition to the already discussed configuration, there is one last missing piece \u2013 including the Spring Data XML configuration in the overall persistence configuration:<\/p>\n In addition to the Maven configuration for JPA defined in a previous article<\/a>, the spring-data-jpa<\/em> dependency is added:<\/p>\n This article covered the configuration and implementation of the persistence layer with Spring 3.1, JPA 2 and Spring JPA (part of the Spring Data umbrella project), using both XML and Java based configuration. The various method of defining more advanced custom queries<\/strong> are discussed, as well as configuration with the new jpa<\/em> namespace<\/strong> and transactional semantics. The final result is a new and elegant take on data access with Spring, with almost no actual implementation work. You can check out the full implementation in the github project<\/a>. 1. Overview This article will focus on the configuration and implementation of the persistence layer with Spring 3.1, JPA and Spring Data. For a step by step introduction about setting up the Spring context using Java based configuration and the basic Maven pom for the project, see this article. The Persistence with Spring series: …<\/p>\n","protected":false},"author":104,"featured_media":240,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[33,30,321],"class_list":["post-16832","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-jpa","tag-spring","tag-spring-data"],"yoast_head":"\n
\n
\n
\n <\/p>\n\n
2. No More DAO implementations<\/h2>\n
3. The Spring Data managed DAO<\/h2>\n
4. Defining custom access method and queries<\/h2>\n
4.1. Automatic Custom Queries<\/h4>\n
public interface IFooDAO extends JpaRepository< Foo, Long >{\r\n\r\n Foo findByName( final String name );\r\n\r\n}<\/pre>\n4.2. Manual Custom Queries<\/h4>\n
5. Spring Data transaction configuration<\/h2>\n
5.1. Exception Translation without the template<\/h4>\n
@Test( expected = DataAccessException.class )\r\npublic void whenAUniqueConstraintIsBroken_thenSpringSpecificExceptionIsThrown(){\r\n String name = \"randomName\";\r\n service.save( new Foo( name ) );\r\n service.save( new Foo( name ) );\r\n}<\/pre>\n6. Spring Data Configuration<\/h2>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<beans\r\n xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"\r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xmlns:jpa=\"http:\/\/www.springframework.org\/schema\/data\/jpa\"\r\n xsi:schemaLocation=\"\r\n http:\/\/www.springframework.org\/schema\/beans\r\n http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.2.xsd\r\n http:\/\/www.springframework.org\/schema\/data\/jpa\r\n http:\/\/www.springframework.org\/schema\/data\/jpa\/spring-jpa.xsd\">\r\n\r\n<jpa:repositories base-package=\"org.rest.dao.spring\" \/>\r\n\r\n<\/beans><\/pre>\n
7. The Spring Java or XML configuration<\/h2>\n
@Configuration\r\n@EnableTransactionManagement\r\n@ImportResource( \"classpath*:*springDataConfig.xml\" )\r\npublic class PersistenceJPAConfig{\r\n ...\r\n}<\/pre>\n8. The Maven configuration<\/h2>\n
<dependency>\r\n <groupId>org.springframework.data<\/groupId>\r\n <artifactId>spring-data-jpa<\/artifactId>\r\n <version>1.3.2.RELEASE<\/version>\r\n<\/dependency><\/pre>\n
9. Conclusion<\/h2>\n
\n <\/p>\n