{"id":20172,"date":"2014-01-03T10:00:42","date_gmt":"2014-01-03T08:00:42","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=20172"},"modified":"2014-01-02T17:37:02","modified_gmt":"2014-01-02T15:37:02","slug":"project-student-persistence-with-spring-data","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2014\/01\/project-student-persistence-with-spring-data.html","title":{"rendered":"Project Student: Persistence With Spring Data"},"content":{"rendered":"

This is part of Project Student<\/a>. Other posts are Webservice Client With Jersey<\/a>, Webservice Server with Jersey<\/a> and Business Layer<\/a>.<\/p>\n

The final layer of the RESTful webapp onion is the persistence layer.<\/p>\n

There are two philosophies for persistence layers. One camp sees the database as a simple store and wants to keep this layer extremely thin. The other camp knows it\u2019s often much faster to perform tasks in the database than to hit the database for the data, do the necessary work in java, and possibly hit the database a second time with the results. This camp often wants a fairly thick persistence layer.<\/p>\n

The second camp also has a group of exiles that wants to use stored procedures extensively. This makes the database much more powerful but at the cost of a bit of additional complexity in the persistence layer. It has a major drawback in that stored procedures are database-specific.<\/p>\n

A second group of exiles just uses stored procedures for security. I\u2019ve discussed this earlier, e.g., the idea that you should call a stored procedure with username and password and get an \u201caccept\u201d or \u201cdeny\u201d response instead of retrieving the hashed password and doing the comparison in the application. The first approach allows you to use the database\u2019s GRANT and REVOKE privileges to store hashed passwords in a table that\u2019s inaccessible even if an attacker can perform arbitrary SQL injection as the application user.<\/p>\n

(Sidenote: you can often write your stored procedures in Java! Oracle supports it, PostgreSQL supports it (via PL\/Java extension), H2 supports it (via the classpath). I don\u2019t know if MySQL supports it. This approach has definite costs but it may be the best solution for many problems.)<\/p>\n

Anyway this project only supports CRUD operations at the moment and they\u2019re a classic example of using a thin persistence layer. It\u2019s easy to add \u2018thick\u2019 methods though \u2013 simply create a CourseRepositoryImpl class with them. (This class should NOT implement the CourseRepository interface!)<\/p>\n

Design Decisions<\/h2>\n

Spring Data<\/strong> \u2013 we\u2019re using Spring Data because it autogenerates the persistence layer classes.<\/p>\n

Limitations<\/h2>\n

Pagination<\/strong> \u2013 there is no attempt to support pagination. This isn\u2019t a big issue since Spring Data already supports it \u2013 we only need to write the glue.<\/p>\n

Configuration<\/h2>\n

The basic configuration only requires the @EnableJpaRepositories<\/em> annotation.<\/p>\n

The integration test using a pure in-memory embedded database requires a bit more work. Using the Spring embedded database directly doesn\u2019t work even if you use the H2 url that tells it to leave the database server up. The database is properly initialized but then closed before the tests actually run. The result is failures since the database schema is missing.<\/p>\n

It would be trivial to use an in-memory database backed by a file but that could cause problems with concurrent runs, accidently pulling in old test data, etc. The obvious solution is using a random temporary backing file but that approach introduces its own problems.<\/p>\n

The approach below is to cache the embedded database in the configuration class and only destroy it as the app shuts down. This introduces some non-obvious behavior that forces us to explicitly create a few additional beans as well.

<\/div> <\/div><\/p>\n

(IIRC if you create the embedded database in a configuration class and the transaction beans in a configuration file then spring was creating a phantom datasource in the configuration file and initialization failed. This problem went away when I started to create the transaction beans in the same place as the datasource.)<\/p>\n

@Configuration\r\n@EnableJpaRepositories(basePackages = { \"com.invariantproperties.sandbox.student.repository\" })\r\n@EnableTransactionManagement\r\n@PropertySource(\"classpath:test-application.properties\")\r\n@ImportResource(\"classpath:applicationContext-dao.xml\")\r\npublic class TestPersistenceJpaConfig implements DisposableBean {\r\n    private static final Logger log = LoggerFactory.getLogger(TestPersistenceJpaConfig.class);\r\n\r\n    private static final String PROPERTY_NAME_HIBERNATE_DIALECT = \"hibernate.dialect\";\r\n    private static final String PROPERTY_NAME_HIBERNATE_FORMAT_SQL = \"hibernate.format_sql\";\r\n    private static final String PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY = \"hibernate.ejb.naming_strategy\";\r\n    private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = \"hibernate.show_sql\";\r\n    private static final String PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO = \"hibernate.hbm2ddl.auto\";\r\n    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN = \"entitymanager.packages.to.scan\";\r\n    \/\/ private static final String PROPERTY_NAME_PERSISTENCE_UNIT_NAME =\r\n    \/\/ \"persistence.unit.name\";\r\n\r\n    @Resource\r\n    private Environment environment;\r\n\r\n    private EmbeddedDatabase db = null;\r\n\r\n    @Bean\r\n    public DataSource dataSource() {\r\n        final EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();\r\n        db = builder.setType(EmbeddedDatabaseType.H2).build(); \/\/ .script(\"foo.sql\")\r\n        return db;\r\n    }\r\n\r\n    @Bean\r\n    public LocalContainerEntityManagerFactoryBean entityManagerFactory() throws ClassNotFoundException {\r\n        LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();\r\n\r\n        bean.setDataSource(dataSource());\r\n        bean.setPackagesToScan(environment.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN));\r\n        bean.setPersistenceProviderClass(HibernatePersistence.class);\r\n        \/\/ bean.setPersistenceUnitName(environment\r\n        \/\/ .getRequiredProperty(PROPERTY_NAME_PERSISTENCE_UNIT_NAME));\r\n\r\n        HibernateJpaVendorAdapter va = new HibernateJpaVendorAdapter();\r\n        bean.setJpaVendorAdapter(va);\r\n\r\n        Properties jpaProperties = new Properties();\r\n        jpaProperties.put(PROPERTY_NAME_HIBERNATE_DIALECT,\r\nenvironment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));\r\n        jpaProperties.put(PROPERTY_NAME_HIBERNATE_FORMAT_SQL,\r\n                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_FORMAT_SQL));\r\n        jpaProperties.put(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY,\r\n                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY));\r\n        jpaProperties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL,\r\n                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));\r\n        jpaProperties.put(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO,\r\n                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO));\r\n\r\n        bean.setJpaProperties(jpaProperties);\r\n\r\n        return bean;\r\n    }\r\n\r\n    @Bean\r\n    public PlatformTransactionManager transactionManager() {\r\n        JpaTransactionManager tm = new JpaTransactionManager();\r\n\r\n        try {\r\n            tm.setEntityManagerFactory(this.entityManagerFactory().getObject());\r\n        } catch (ClassNotFoundException e) {\r\n            \/\/ TODO: log.\r\n        }\r\n\r\n        return tm;\r\n    }\r\n\r\n    @Bean\r\n    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {\r\n        return new PersistenceExceptionTranslationPostProcessor();\r\n    }\r\n\r\n    @Override\r\n    public void destroy() {\r\n        if (db != null) {\r\n            db.shutdown();\r\n        }\r\n    }\r\n}<\/pre>\n
The applicationContext.xml file is empty. The properties file is:<\/p>\n
# hibernate configuration\r\nhibernate.dialect=org.hibernate.dialect.H2Dialect\r\nhibernate.ejb.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy\r\nhibernate.show_sql=false\r\nhibernate.format_sql=true\r\nhibernate.hbm2ddl.auto=create\r\n\r\n# jpa configuration\r\nentitymanager.packages.to.scan=com.invariantproperties.sandbox.student.domain\r\npersistence.unit.dataSource=java:comp\/env\/jdbc\/ssDS\r\npersistence.unit.name=ssPU<\/pre>\n
Unit Testing<\/h2>\n
There are no unit tests since all of the code is autogenerated. This will change as custom methods are added.<\/p>\n
Integration Testing<\/h2>\n
We can now write the integration tests for the business layer:<\/p>\n
@RunWith(SpringJUnit4ClassRunner.class)\r\n@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,\r\n        TestPersistenceJpaConfig.class })\r\n@Transactional\r\n@TransactionConfiguration(defaultRollback = true)\r\npublic class CourseServiceIntegrationTest {\r\n\r\n    @Resource\r\n    private CourseService dao;\r\n\r\n    @Test\r\n    public void testCourseLifecycle() throws Exception {\r\n        final String name = \"Calculus 101\";\r\n\r\n        final Course expected = new Course();\r\n        expected.setName(name);\r\n\r\n        assertNull(expected.getId());\r\n\r\n        \/\/ create course\r\n        Course actual = dao.createCourse(name);\r\n        expected.setId(actual.getId());\r\n        expected.setUuid(actual.getUuid());\r\n        expected.setCreationDate(actual.getCreationDate());\r\n\r\n        assertThat(expected, equalTo(actual));\r\n        assertNotNull(actual.getUuid());\r\n        assertNotNull(actual.getCreationDate());\r\n\r\n        \/\/ get course by id\r\n        actual = dao.findCourseById(expected.getId());\r\n        assertThat(expected, equalTo(actual));\r\n\r\n        \/\/ get course by uuid\r\n        actual = dao.findCourseByUuid(expected.getUuid());\r\n        assertThat(expected, equalTo(actual));\r\n\r\n        \/\/ update course\r\n        expected.setName(\"Calculus 102\");\r\n        actual = dao.updateCourse(actual, expected.getName());\r\n        assertThat(expected, equalTo(actual));\r\n\r\n        \/\/ delete Course\r\n        dao.deleteCourse(expected.getUuid());\r\n        try {\r\n            dao.findCourseByUuid(expected.getUuid());\r\n            fail(\"exception expected\");\r\n        } catch (ObjectNotFoundException e) {\r\n            \/\/ expected\r\n        }\r\n    }\r\n\r\n    \/**\r\n     * @test findCourseById() with unknown course.\r\n     *\/\r\n    @Test(expected = ObjectNotFoundException.class)\r\n    public void testfindCourseByIdWhenCourseIsNotKnown() {\r\n        final Integer id = 1;\r\n        dao.findCourseById(id);\r\n    }\r\n\r\n    \/**\r\n     * @test findCourseByUuid() with unknown Course.\r\n     *\/\r\n    @Test(expected = ObjectNotFoundException.class)\r\n    public void testfindCourseByUuidWhenCourseIsNotKnown() {\r\n        final String uuid = \"missing\";\r\n        dao.findCourseByUuid(uuid);\r\n    }\r\n\r\n    \/**\r\n     * Test updateCourse() with unknown course.\r\n     * \r\n     * @throws ObjectNotFoundException\r\n     *\/\r\n    @Test(expected = ObjectNotFoundException.class)\r\n    public void testUpdateCourseWhenCourseIsNotFound() {\r\n        final Course course = new Course();\r\n        course.setUuid(\"missing\");\r\n        dao.updateCourse(course, \"Calculus 102\");\r\n    }\r\n\r\n    \/**\r\n     * Test deleteCourse() with unknown course.\r\n     * \r\n     * @throws ObjectNotFoundException\r\n     *\/\r\n    @Test(expected = ObjectNotFoundException.class)\r\n    public void testDeleteCourseWhenCourseIsNotFound() {\r\n        dao.deleteCourse(\"missing\");\r\n    }\r\n}<\/pre>\n
Source Code<\/h2>\n