Project

General

Profile

Sample-spring-hibernate » History » Version 14

Henning Blohm, 17.10.2015 20:20

1 1 Henning Blohm
h1. A sample using Hibernate and Spring on Z2
2
3 2 Henning Blohm
This sample is very similar to [[Sample-hibernate-basic]] but differs in that we use the Spring framework throughout...
4
5
* for assembly within the modules and to wire services between modules
6
* for declarative transaction demarcation
7
* for JPA entity manager injection 
8
9 3 Henning Blohm
This is another practical application of [[How to Spring]].
10
11 2 Henning Blohm
This sample is stored in "z2-samples.spring-hibernate":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate.
12
13 12 Henning Blohm
Check out [[How to transaction management]] for more infos on transaction management on Z2. See related examples 
14
15
* [[Sample-springds-hibernate]] for an even tighter Spring embrace, 
16
* [[Sample-jta-spring]] for integration with a third-party transaction manager
17
* [[Sample-spring-basic]] for a starter on Spring integration with Z2
18
 
19 2 Henning Blohm
h2. Prerequisites
20
21 14 Henning Blohm
{{include(Java Version Requirements)}}
22 13 Henning Blohm
23 11 Henning Blohm
You need to run Java DB as network server on localhost. This is explained next.
24 2 Henning Blohm
25 11 Henning Blohm
The application will create a database "z2-samples"
26
27
{{include(How to run Java db)}}
28
29 2 Henning Blohm
30
h2. Run it
31
32
Like all samples, also this sample can be run as in [[How to run a sample]]. If you have the database, the fastest way to verify whether it runs is:
33
34
<pre><code class="ruby">
35
mkdir install
36
cd install 
37
git clone -b master http://git.z2-environment.net/z2-base.core
38
git clone -b master http://git.z2-environment.net/z2-samples.spring-hibernate
39
40
# on Linux / Mac OS:
41
cd z2-base.core/run/bin
42
./gui.sh
43
44
# on Windows:
45
cd z2-base.core\run\bin
46
gui.bat
47
</code></pre>
48
49
When running, go to http://localhost:8080/spring-hibernate. You should see this:
50
51
!spring-hibernate.png!
52 3 Henning Blohm
53
h2. Details
54
55
Similar to [[Sample-hibernate-basic]], the assumption of this example is that of a re-use domain module *com.zfabrik.samples.spring-hibernate.domain* that implements a "Thingy Repository" and is used from a web application that is in another module *com.zfabrik.samples.spring-hibernate.web*. The domain module exposes the Thingy Repository as a Z2 component - from a Spring application context defined bean -  that is imported into the application context of the Web application and injected into the controller filter by Spring. The controller uses declarative transaction demarcation.
56
57
The domain module makes use of Hibernate's JPA implementation using Spring's entity manager injection and integrates with the transaction management provided by *com.zfabrik.jta*.
58
59
h3. The domain module and its persistence context
60
61
The domain module *com.zfabrik.samples.spring-hibernate.domain* defines a persistence unit "thingies" in "java/src.impl/META-INF/persistence.xml":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/java/src.impl/META-INF/persistence.xml, i.e. in its implementation. That makes sense, as the XML file will be looked up with a class loader and we do not intent to retrieve from another module. Or, put differently, the persistence unit is not part of the module's API.
62
63
In order to integrate with the built-in transaction management the <code>persistence.xml</code> declares the JTA data source 
64
65
<pre><code class="xml">
66 8 Henning Blohm
<jta-data-source>components:com.zfabrik.samples.spring-hibernate.domain/DB</jta-data-source>
67 3 Henning Blohm
</code></pre>
68
69
and the _Transaction Manager Lookup_ 
70
71
<pre><code class="xml">
72
<property name="hibernate.transaction.manager_lookup_class" value="com.zfabrik.hibernate.TransactionManagerLookup" />
73
</code></pre>
74
75 8 Henning Blohm
The former points to the data source component "com.zfabrik.samples.spring-hibernate.domain/DB":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/DB.properties, while the latter makes sure Hibernate can register with the transaction manager implementation. 
76 3 Henning Blohm
77
The persistence unit defines only one entity. The Thingy as in "Thingy.java":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/java/src.api/com/zfabrik/samples/spring_hibernate/thingies/Thingy.java. That is an API-exposed type. We use the simplified pattern of exposing persistent objects in the API rather than using Data Transfer Objects (DTOs).
78
79
The application context of the module is defined in "java/src.impl/META-INF/applicationContext.xml":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/java/src.impl/META-INF/applicationContext.xml and looks like this:
80
81
<pre><code class="xml">
82
<?xml version="1.0" encoding="UTF-8"?>
83
<beans xmlns="http://www.springframework.org/schema/beans"
84
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
85
	xmlns:context="http://www.springframework.org/schema/context"
86
	xmlns:aop="http://www.springframework.org/schema/aop"
87
	xsi:schemaLocation="
88
	http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
89
	http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-3.0.xsd  
90
	http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
91
	http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
92
93
	<!-- annotation based config -->
94
	<context:component-scan base-package="com.zfabrik.samples.spring_hibernate" />
95
	<context:annotation-config />
96
97
	<!-- EntityManager injection -->
98
	<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
99
100
	<!-- The actual EMF we use -->
101
	<bean id="entityManagerFactory"	class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
102
		<property name="persistenceUnitName" value="thingies" />
103
	</bean>
104
    
105
</beans>
106
</code></pre>
107
108
In short: 
109
* We make sure we can use annotations
110
* We enable entity manager injection
111
* We initialize the entity manager factory from Spring
112
113 8 Henning Blohm
In the implementation class "ThingyRepositoryImpl":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/java/src.impl/com/zfabrik/samples/spring_hibernate/impl/thingies/ThingyRepositoryImpl.java we make use of these capabilities and declare a Spring bean "thingyRepository":
114 3 Henning Blohm
115
<pre><code class="java">
116 9 Henning Blohm
@Repository("thingyRepository")
117 3 Henning Blohm
public class ThingyRepositoryImpl implements ThingyRepository {
118
	@PersistenceContext
119
	private EntityManager em;
120
121
	@Override
122
	public void store(Thingy thingy) {
123
		this.em.persist(thingy);
124
	}
125
126
	@SuppressWarnings("unchecked")
127
	@Override
128
	public Collection<Thingy> findAll() {
129
		return this.em.createQuery("select t from Thingy t").getResultList();
130
	}
131
132
	@Override
133
	public void delete(int id) {
134
		Thingy t = this.em.find(Thingy.class, id);
135
		if (t != null) {
136
			this.em.remove(t);
137
		}
138
	}
139
}
140
</code></pre>
141
142
In order to expose that bean as a Z2 component for re-use from other modules, we declare a component "com.zfabrik.samples.spring-hibernate/repository":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/repository.properties:
143
144
<pre><code class="ruby"> 
145
com.zfabrik.component.type=org.springframework.bean
146
147
#
148
# Expose Spring defined data source
149
#
150
151
#
152
# the context that defines the bean (more than one
153
# bean can be exposed like this)
154
#
155
bean.context=com.zfabrik.samples.spring-hibernate.domain/applicationContext
156
157
#
158
# the bean name
159
#
160 10 Henning Blohm
bean.name=thingyRepository
161 3 Henning Blohm
</code></pre>
162
163
that is based on the application context component "com.zfabrik.samples.spring-hibernate/applicationContext":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.domain/applicationContext.properties:
164
165
<pre><code class="ruby"> 
166
com.zfabrik.component.type=org.springframework.context
167
168
#
169
# context config location is where the context is 
170
# actually defined. 
171
#
172
context.contextConfigLocation=classpath:META-INF/applicationContext.xml
173
</code></pre>
174
175
See also [[How to Spring]] for more details on these component types.
176 4 Henning Blohm
177
h3. The web module, transaction boundaries, and service re-use
178
179
Let's turn to the Web application in *com.zfabrik.samples.spring-hibernate.web/web*. This one is also Spring configured. In contrast to the service module, its application context is not initialized from a Z2 component but rather from the Web app context (see "web/WebContent/WEB-INF/web.xml":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.web/web/WebContent/WEB-INF/web.xml). It is stored in "web/WebContent/WEB-INF/applicationContext.xml":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.web/web/WebContent/WEB-INF/applicationContext.xml and looks like this:
180
181
<pre><code class="xml">
182
<?xml version="1.0" encoding="UTF-8"?>
183
<beans xmlns="http://www.springframework.org/schema/beans"
184
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
185
	xmlns:context="http://www.springframework.org/schema/context"
186
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:security="http://www.springframework.org/schema/security"
187
	xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
188
	http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-3.0.xsd  
189
	http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
190
	http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
191
	http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.3.xsd">
192
193
	<!-- Annotation Support -->
194
	<context:component-scan base-package="com.zfabrik.samples.spring_hibernate" />
195
	<context:spring-configured />
196
	<context:annotation-config />		
197
198
	<!--  
199
	This binds to java:comp/UserTransaction, which is ok in a Web app and considering
200
	that we configured Jetty JTA (see the transaction manager how-to in the Z2 Wiki and check environment/webServer/jetty.xml)
201
    -->
202
	
203
	<tx:jta-transaction-manager/>
204
205
    <!-- outside of a web app we would bind to com.zfabrik.jta transaction manager like this
206
207
	<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
208
	    <property name="userTransaction">
209
	        <bean class="com.zfabrik.tx.UserTransaction"/>
210
	    </property>
211
	</bean>
212
	 -->
213
214 8 Henning Blohm
	<!-- make sure we can use @Transactional with the Spring aspect -->
215 4 Henning Blohm
	<tx:annotation-driven transaction-manager="transactionManager" mode="aspectj"/>
216
217
	<!-- import external services -->
218
    <bean id="thingyRepository" class="com.zfabrik.springframework.ComponentFactoryBean">
219
        <property name="componentName"  value="com.zfabrik.samples.spring-hibernate.domain/repository" />
220
        <property name="className"  value="com.zfabrik.samples.spring_hibernate.thingies.ThingyRepository" />
221
    </bean>
222
	
223
</beans>
224
225
</code></pre>
226
227
In short:
228
229
* We enable annotation based configuration
230 7 Henning Blohm
* We make the transaction manager available (for in-depth details see [[How to transaction management]])
231 8 Henning Blohm
* We enabled annotation based transaction demarcation (i.e. the use of <code>@Transactional</code>)
232 4 Henning Blohm
* We import the Thingy Repository as a bean into this context.
233
234 8 Henning Blohm
The "ControllerFilter":http://redmine.z2-environment.net/projects/z2-samples/repository/z2-samples-spring-hibernate/revisions/master/entry/com.zfabrik.samples.spring-hibernate.web/java/src.impl/com/zfabrik/samples/spring_hibernate/impl/web/ControllerFilter.java is configured by Spring, although it is instantiated by the Jetty Web container. That is happening because we use the Spring aspect (see [[How to Spring]] once more) and it is annotated with <code>@Configurable</code>. We let Spring inject the Thingy Repository and we mark the <code>doFilter</code> method as transactional. Here is its skeleton:
235 4 Henning Blohm
236 5 Henning Blohm
<pre><code class="java">
237
@Configurable
238
public class ControllerFilter implements Filter {
239 4 Henning Blohm
240 5 Henning Blohm
  @Autowired
241
  private ThingyRepository thingyRepository;
242
	
243
  @Transactional
244
  public void doFilter(ServletRequest sreq, ServletResponse sres,	FilterChain chain) throws IOException, ServletException {
245
    
246
    // do some work here
247 1 Henning Blohm
248 5 Henning Blohm
  }
249
250
  @Override
251
  public void init(FilterConfig cfg) throws ServletException {}
252
  
253
  @Override
254
  public void destroy() {}
255
}
256
</code></pre>
257 6 Henning Blohm
258
h2. A final word
259
260
A lot of what happens here requires the right libraries to be available in the sample modules. These are provided via the references in the <code>z.properties</code> files in the respective Java modules. 
261
In other words: There is some non-trivial mechanics going on here that - in the long run - you should be aware of and try to read carefully through [[How to Spring]]. As a result you get a lot of coding and modularization convenience in the combination of Spring and Z2.