001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.dao.orm;
016    
017    import java.io.Serializable;
018    
019    import java.sql.Connection;
020    
021    /**
022     * @author Shuyang Zhou
023     * @author Brian Wing Shun Chan
024     */
025    public class ClassLoaderSession implements Session {
026    
027            public ClassLoaderSession(Session session, ClassLoader classLoader) {
028                    _session = session;
029                    _classLoader = classLoader;
030            }
031    
032            public void clear() throws ORMException {
033                    Thread currentThread = Thread.currentThread();
034    
035                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
036    
037                    try {
038                            if (contextClassLoader != _classLoader) {
039                                    currentThread.setContextClassLoader(_classLoader);
040                            }
041    
042                            _session.clear();
043                    }
044                    finally {
045                            if (contextClassLoader != _classLoader) {
046    
047                                    currentThread.setContextClassLoader(contextClassLoader);
048                            }
049                    }
050            }
051    
052            public Connection close() throws ORMException {
053                    Thread currentThread = Thread.currentThread();
054    
055                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
056    
057                    try {
058                            if (contextClassLoader != _classLoader) {
059                                    currentThread.setContextClassLoader(_classLoader);
060                            }
061    
062                            return _session.close();
063                    }
064                    finally {
065                            if (contextClassLoader != _classLoader) {
066                                    currentThread.setContextClassLoader(contextClassLoader);
067                            }
068                    }
069            }
070    
071            public boolean contains(Object object) throws ORMException {
072                    Thread currentThread = Thread.currentThread();
073    
074                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
075    
076                    try {
077                            if (contextClassLoader != _classLoader) {
078                                    currentThread.setContextClassLoader(_classLoader);
079                            }
080    
081                            return _session.contains(object);
082                    }
083                    finally {
084                            if (contextClassLoader != _classLoader) {
085                                    currentThread.setContextClassLoader(contextClassLoader);
086                            }
087                    }
088            }
089    
090            public Query createQuery(String queryString) throws ORMException {
091                    Thread currentThread = Thread.currentThread();
092    
093                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
094    
095                    try {
096                            if (contextClassLoader != _classLoader) {
097                                    currentThread.setContextClassLoader(_classLoader);
098                            }
099    
100                            return _session.createQuery(queryString);
101                    }
102                    finally {
103                            if (contextClassLoader != _classLoader) {
104                                    currentThread.setContextClassLoader(contextClassLoader);
105                            }
106                    }
107            }
108    
109            public Query createQuery(String queryString, boolean strictName)
110                    throws ORMException {
111    
112                    Thread currentThread = Thread.currentThread();
113    
114                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
115    
116                    try {
117                            if (contextClassLoader != _classLoader) {
118                                    currentThread.setContextClassLoader(_classLoader);
119                            }
120    
121                            return _session.createQuery(queryString, strictName);
122                    }
123                    finally {
124                            if (contextClassLoader != _classLoader) {
125                                    currentThread.setContextClassLoader(contextClassLoader);
126                            }
127                    }
128            }
129    
130            public SQLQuery createSQLQuery(String queryString) throws ORMException {
131                    Thread currentThread = Thread.currentThread();
132    
133                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
134    
135                    try {
136                            if (contextClassLoader != _classLoader) {
137                                    currentThread.setContextClassLoader(_classLoader);
138                            }
139    
140                            return _session.createSQLQuery(queryString);
141                    }
142                    finally {
143                            if (contextClassLoader != _classLoader) {
144                                    currentThread.setContextClassLoader(contextClassLoader);
145                            }
146                    }
147            }
148    
149            public SQLQuery createSQLQuery(String queryString, boolean strictName)
150                    throws ORMException {
151    
152                    Thread currentThread = Thread.currentThread();
153    
154                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
155    
156                    try {
157                            if (contextClassLoader != _classLoader) {
158                                    currentThread.setContextClassLoader(_classLoader);
159                            }
160    
161                            return _session.createSQLQuery(queryString, strictName);
162                    }
163                    finally {
164                            if (contextClassLoader != _classLoader) {
165                                    currentThread.setContextClassLoader(contextClassLoader);
166                            }
167                    }
168            }
169    
170            public void delete(Object object) throws ORMException {
171                    Thread currentThread = Thread.currentThread();
172    
173                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
174    
175                    try {
176                            if (contextClassLoader != _classLoader) {
177                                    currentThread.setContextClassLoader(_classLoader);
178                            }
179    
180                            _session.delete(object);
181                    }
182                    finally {
183                            if (contextClassLoader != _classLoader) {
184                                    currentThread.setContextClassLoader(contextClassLoader);
185                            }
186                    }
187            }
188    
189            public void evict(Object object) throws ORMException {
190                    Thread currentThread = Thread.currentThread();
191    
192                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
193    
194                    try {
195                            if (contextClassLoader != _classLoader) {
196                                    currentThread.setContextClassLoader(_classLoader);
197                            }
198    
199                            _session.evict(object);
200                    }
201                    finally {
202                            if (contextClassLoader != _classLoader) {
203                                    currentThread.setContextClassLoader(contextClassLoader);
204                            }
205                    }
206            }
207    
208            public void flush() throws ORMException {
209                    Thread currentThread = Thread.currentThread();
210    
211                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
212    
213                    try {
214                            if (contextClassLoader != _classLoader) {
215                                    currentThread.setContextClassLoader(_classLoader);
216                            }
217    
218                            _session.flush();
219                    }
220                    finally {
221                            if (contextClassLoader != _classLoader) {
222                                    currentThread.setContextClassLoader(contextClassLoader);
223                            }
224                    }
225            }
226    
227            public Object get(Class<?> clazz, Serializable id) throws ORMException {
228                    Thread currentThread = Thread.currentThread();
229    
230                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
231    
232                    try {
233                            if (contextClassLoader != _classLoader) {
234                                    currentThread.setContextClassLoader(_classLoader);
235                            }
236    
237                            return _session.get(clazz, id);
238                    }
239                    finally {
240                            if (contextClassLoader != _classLoader) {
241                                    currentThread.setContextClassLoader(contextClassLoader);
242                            }
243                    }
244            }
245    
246            public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
247                    throws ORMException {
248    
249                    Thread currentThread = Thread.currentThread();
250    
251                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
252    
253                    try {
254                            if (contextClassLoader != _classLoader) {
255                                    currentThread.setContextClassLoader(_classLoader);
256                            }
257    
258                            return _session.get(clazz, id, lockMode);
259                    }
260                    finally {
261                            if (contextClassLoader != _classLoader) {
262                                    currentThread.setContextClassLoader(contextClassLoader);
263                            }
264                    }
265            }
266    
267            public Object getWrappedSession() throws ORMException {
268                    Thread currentThread = Thread.currentThread();
269    
270                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
271    
272                    try {
273                            if (contextClassLoader != _classLoader) {
274                                    currentThread.setContextClassLoader(_classLoader);
275                            }
276    
277                            return _session.getWrappedSession();
278                    }
279                    finally {
280                            if (contextClassLoader != _classLoader) {
281                                    currentThread.setContextClassLoader(contextClassLoader);
282                            }
283                    }
284            }
285    
286            public Object load(Class<?> clazz, Serializable id) throws ORMException {
287                    Thread currentThread = Thread.currentThread();
288    
289                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
290    
291                    try {
292                            if (contextClassLoader != _classLoader) {
293                                    currentThread.setContextClassLoader(_classLoader);
294                            }
295    
296                            return _session.load(clazz, id);
297                    }
298                    finally {
299                            if (contextClassLoader != _classLoader) {
300                                    currentThread.setContextClassLoader(contextClassLoader);
301                            }
302                    }
303            }
304    
305            public Object merge(Object object) throws ORMException {
306                    Thread currentThread = Thread.currentThread();
307    
308                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
309    
310                    try {
311                            if (contextClassLoader != _classLoader) {
312                                    currentThread.setContextClassLoader(_classLoader);
313                            }
314    
315                            return _session.merge(object);
316                    }
317                    finally {
318                            if (contextClassLoader != _classLoader) {
319                                    currentThread.setContextClassLoader(contextClassLoader);
320                            }
321                    }
322            }
323    
324            public Serializable save(Object object) throws ORMException {
325                    Thread currentThread = Thread.currentThread();
326    
327                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
328    
329                    try {
330                            if (contextClassLoader != _classLoader) {
331                                    currentThread.setContextClassLoader(_classLoader);
332                            }
333    
334                            return _session.save(object);
335                    }
336                    finally {
337                            if (contextClassLoader != _classLoader) {
338                                    currentThread.setContextClassLoader(contextClassLoader);
339                            }
340                    }
341            }
342    
343            public void saveOrUpdate(Object object) throws ORMException {
344                    Thread currentThread = Thread.currentThread();
345    
346                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
347    
348                    try {
349                            if (contextClassLoader != _classLoader) {
350                                    currentThread.setContextClassLoader(_classLoader);
351                            }
352    
353                            _session.saveOrUpdate(object);
354                    }
355                    finally {
356                            if (contextClassLoader != _classLoader) {
357                                    currentThread.setContextClassLoader(contextClassLoader);
358                            }
359                    }
360            }
361    
362            private ClassLoader _classLoader;
363            private Session _session;
364    
365    }