EMMA Coverage Report (generated Thu May 22 12:08:10 CDT 2014)
[all classes][org.springframework.batch.item.database]

COVERAGE SUMMARY FOR SOURCE FILE [HibernateItemReaderHelper.java]

nameclass, %method, %block, %line, %
HibernateItemReaderHelper.java100% (1/1)100% (13/13)95%  (225/237)96%  (59.8/62)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class HibernateItemReaderHelper100% (1/1)100% (13/13)95%  (225/237)96%  (59.8/62)
readPage (int, int, int, Map): Collection 100% (1/1)83%  (20/24)83%  (5/6)
createQuery (): Query 100% (1/1)92%  (67/73)94%  (15/16)
afterPropertiesSet (): void 100% (1/1)94%  (32/34)96%  (5.8/6)
HibernateItemReaderHelper (): void 100% (1/1)100% (12/12)100% (4/4)
clear (): void 100% (1/1)100% (7/7)100% (3/3)
close (): void 100% (1/1)100% (20/20)100% (7/7)
getForwardOnlyCursor (int, Map): ScrollableResults 100% (1/1)100% (15/15)100% (4/4)
jumpToItem (ScrollableResults, int, int): void 100% (1/1)100% (21/21)100% (5/5)
setQueryName (String): void 100% (1/1)100% (4/4)100% (2/2)
setQueryProvider (HibernateQueryProvider): void 100% (1/1)100% (4/4)100% (2/2)
setQueryString (String): void 100% (1/1)100% (4/4)100% (2/2)
setSessionFactory (SessionFactory): void 100% (1/1)100% (4/4)100% (2/2)
setUseStatelessSession (boolean): void 100% (1/1)100% (15/15)100% (3/3)

1/*
2 * Copyright 2006-2013 the original author or authors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.springframework.batch.item.database;
17 
18import java.util.Collection;
19import java.util.List;
20import java.util.Map;
21 
22import org.hibernate.Query;
23import org.hibernate.ScrollMode;
24import org.hibernate.ScrollableResults;
25import org.hibernate.Session;
26import org.hibernate.SessionFactory;
27import org.hibernate.StatelessSession;
28import org.springframework.batch.item.database.orm.HibernateQueryProvider;
29import org.springframework.beans.factory.InitializingBean;
30import org.springframework.util.Assert;
31import org.springframework.util.StringUtils;
32 
33/**
34 * Internal shared state helper for hibernate readers managing sessions and
35 * queries.
36 *
37 * @author Dave Syer
38 *
39 */
40public class HibernateItemReaderHelper<T> implements InitializingBean {
41 
42        private SessionFactory sessionFactory;
43 
44        private String queryString = "";
45 
46        private String queryName = "";
47 
48        private HibernateQueryProvider queryProvider;
49 
50        private boolean useStatelessSession = true;
51 
52        private StatelessSession statelessSession;
53 
54        private Session statefulSession;
55 
56        /**
57         * @param queryName name of a hibernate named query
58         */
59        public void setQueryName(String queryName) {
60                this.queryName = queryName;
61        }
62 
63        /**
64         * @param queryString HQL query string
65         */
66        public void setQueryString(String queryString) {
67                this.queryString = queryString;
68        }
69 
70        /**
71         * @param queryProvider Hibernate query provider
72         */
73        public void setQueryProvider(HibernateQueryProvider queryProvider) {
74                this.queryProvider = queryProvider;
75        }
76 
77        /**
78         * Can be set only in uninitialized state.
79         *
80         * @param useStatelessSession <code>true</code> to use
81         * {@link StatelessSession} <code>false</code> to use standard hibernate
82         * {@link Session}
83         */
84        public void setUseStatelessSession(boolean useStatelessSession) {
85                Assert.state(statefulSession == null && statelessSession == null,
86                                "The useStatelessSession flag can only be set before a session is initialized.");
87                this.useStatelessSession = useStatelessSession;
88        }
89 
90        /**
91         * @param sessionFactory hibernate session factory
92         */
93        public void setSessionFactory(SessionFactory sessionFactory) {
94                this.sessionFactory = sessionFactory;
95        }
96 
97        @Override
98        public void afterPropertiesSet() throws Exception {
99 
100                Assert.state(sessionFactory != null, "A SessionFactory must be provided");
101 
102                if (queryProvider == null) {
103                        Assert.notNull(sessionFactory, "session factory must be set");
104                        Assert.state(StringUtils.hasText(queryString) ^ StringUtils.hasText(queryName),
105                                        "queryString or queryName must be set");
106                }
107                // making sure that the appropriate (Hibernate) query provider is set
108                else {
109                        Assert.state(queryProvider != null, "Hibernate query provider must be set");
110                }
111 
112        }
113 
114        /**
115         * Get a cursor over all of the results, with the forward-only flag set.
116         *
117         * @param fetchSize the fetch size to use retrieving the results
118         * @param parameterValues the parameter values to use (or null if none).
119         *
120         * @return a forward-only {@link ScrollableResults}
121         */
122        public ScrollableResults getForwardOnlyCursor(int fetchSize, Map<String, Object> parameterValues) {
123                Query query = createQuery();
124                if (parameterValues != null) {
125                        query.setProperties(parameterValues);
126                }
127                return query.setFetchSize(fetchSize).scroll(ScrollMode.FORWARD_ONLY);
128        }
129 
130        /**
131         * Open appropriate type of hibernate session and create the query.
132         */
133        public Query createQuery() {
134 
135                if (useStatelessSession) {
136                        if (statelessSession == null) {
137                                statelessSession = sessionFactory.openStatelessSession();
138                        }
139                        if (queryProvider != null) {
140                                queryProvider.setStatelessSession(statelessSession);
141                        }
142                        else {
143                                if (StringUtils.hasText(queryName)) {
144                                        return statelessSession.getNamedQuery(queryName);
145                                }
146                                else {
147                                        return statelessSession.createQuery(queryString);
148                                }
149                        }
150                }
151                else {
152                        if (statefulSession == null) {
153                                statefulSession = sessionFactory.openSession();
154                        }
155                        if (queryProvider != null) {
156                                queryProvider.setSession(statefulSession);
157                        }
158                        else {
159                                if (StringUtils.hasText(queryName)) {
160                                        return statefulSession.getNamedQuery(queryName);
161                                }
162                                else {
163                                        return statefulSession.createQuery(queryString);
164                                }
165                        }
166                }
167 
168                // If queryProvider is set use it to create a query
169                return queryProvider.createQuery();
170 
171        }
172 
173        /**
174         * Scroll through the results up to the item specified.
175         *
176         * @param cursor the results to scroll over
177         */
178        public void jumpToItem(ScrollableResults cursor, int itemIndex, int flushInterval) {
179                for (int i = 0; i < itemIndex; i++) {
180                        cursor.next();
181                        if (i % flushInterval == 0 && !useStatelessSession) {
182                                statefulSession.clear(); // Clears in-memory cache
183                        }
184                }
185        }
186 
187        /**
188         * Close the open session (stateful or otherwise).
189         */
190        public void close() {
191                if (statelessSession != null) {
192                        statelessSession.close();
193                        statelessSession = null;
194                }
195                if (statefulSession != null) {
196                        statefulSession.close();
197                        statefulSession = null;
198                }
199        }
200 
201        /**
202         * Read a page of data, clearing the existing session (if necessary) first,
203         * and creating a new session before executing the query.
204         *
205         * @param page the page to read (starting at 0)
206         * @param pageSize the size of the page or maximum number of items to read
207         * @param fetchSize the fetch size to use
208         * @param parameterValues the parameter values to use (if any, otherwise
209         * null)
210         * @return a collection of items
211         */
212        public Collection<? extends T> readPage(int page, int pageSize, int fetchSize, Map<String, Object> parameterValues) {
213 
214                clear();
215 
216                Query query = createQuery();
217                if (parameterValues != null) {
218                        query.setProperties(parameterValues);
219                }
220                @SuppressWarnings("unchecked")
221                List<T> result = query.setFetchSize(fetchSize).setFirstResult(page * pageSize).setMaxResults(pageSize).list();
222                return result;
223 
224        }
225 
226        /**
227         * Clear the session if stateful.
228         */
229        public void clear() {
230                if (statefulSession != null) {
231                        statefulSession.clear();
232                }
233        }
234 
235}

[all classes][org.springframework.batch.item.database]
EMMA 2.0.5312 (C) Vladimir Roubtsov