001    /**
002     * Copyright (c) 2000-2013 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 com.liferay.portal.kernel.security.pacl.DoPrivileged;
018    import com.liferay.portal.kernel.security.pacl.NotPrivileged;
019    
020    import java.io.Serializable;
021    
022    import java.sql.Connection;
023    
024    /**
025     * @author Shuyang Zhou
026     * @author Brian Wing Shun Chan
027     */
028    @DoPrivileged
029    public class ClassLoaderSession implements Session {
030    
031            public ClassLoaderSession(Session session, ClassLoader classLoader) {
032                    _session = session;
033                    _classLoader = classLoader;
034            }
035    
036            @NotPrivileged
037            @Override
038            public void clear() throws ORMException {
039                    Thread currentThread = Thread.currentThread();
040    
041                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
042    
043                    try {
044                            if (contextClassLoader != _classLoader) {
045                                    currentThread.setContextClassLoader(_classLoader);
046                            }
047    
048                            _session.clear();
049                    }
050                    finally {
051                            if (contextClassLoader != _classLoader) {
052                                    currentThread.setContextClassLoader(contextClassLoader);
053                            }
054                    }
055            }
056    
057            @NotPrivileged
058            @Override
059            public Connection close() throws ORMException {
060                    Thread currentThread = Thread.currentThread();
061    
062                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
063    
064                    try {
065                            if (contextClassLoader != _classLoader) {
066                                    currentThread.setContextClassLoader(_classLoader);
067                            }
068    
069                            return _session.close();
070                    }
071                    finally {
072                            if (contextClassLoader != _classLoader) {
073                                    currentThread.setContextClassLoader(contextClassLoader);
074                            }
075                    }
076            }
077    
078            @NotPrivileged
079            @Override
080            public boolean contains(Object object) throws ORMException {
081                    Thread currentThread = Thread.currentThread();
082    
083                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
084    
085                    try {
086                            if (contextClassLoader != _classLoader) {
087                                    currentThread.setContextClassLoader(_classLoader);
088                            }
089    
090                            return _session.contains(object);
091                    }
092                    finally {
093                            if (contextClassLoader != _classLoader) {
094                                    currentThread.setContextClassLoader(contextClassLoader);
095                            }
096                    }
097            }
098    
099            @Override
100            public Query createQuery(String queryString) throws ORMException {
101                    Thread currentThread = Thread.currentThread();
102    
103                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
104    
105                    try {
106                            if (contextClassLoader != _classLoader) {
107                                    currentThread.setContextClassLoader(_classLoader);
108                            }
109    
110                            return _session.createQuery(queryString);
111                    }
112                    finally {
113                            if (contextClassLoader != _classLoader) {
114                                    currentThread.setContextClassLoader(contextClassLoader);
115                            }
116                    }
117            }
118    
119            @Override
120            public Query createQuery(String queryString, boolean strictName)
121                    throws ORMException {
122    
123                    Thread currentThread = Thread.currentThread();
124    
125                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
126    
127                    try {
128                            if (contextClassLoader != _classLoader) {
129                                    currentThread.setContextClassLoader(_classLoader);
130                            }
131    
132                            return _session.createQuery(queryString, strictName);
133                    }
134                    finally {
135                            if (contextClassLoader != _classLoader) {
136                                    currentThread.setContextClassLoader(contextClassLoader);
137                            }
138                    }
139            }
140    
141            @Override
142            public SQLQuery createSQLQuery(String queryString) throws ORMException {
143                    Thread currentThread = Thread.currentThread();
144    
145                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
146    
147                    try {
148                            if (contextClassLoader != _classLoader) {
149                                    currentThread.setContextClassLoader(_classLoader);
150                            }
151    
152                            return _session.createSQLQuery(queryString);
153                    }
154                    finally {
155                            if (contextClassLoader != _classLoader) {
156                                    currentThread.setContextClassLoader(contextClassLoader);
157                            }
158                    }
159            }
160    
161            @Override
162            public SQLQuery createSQLQuery(String queryString, boolean strictName)
163                    throws ORMException {
164    
165                    Thread currentThread = Thread.currentThread();
166    
167                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
168    
169                    try {
170                            if (contextClassLoader != _classLoader) {
171                                    currentThread.setContextClassLoader(_classLoader);
172                            }
173    
174                            return _session.createSQLQuery(queryString, strictName);
175                    }
176                    finally {
177                            if (contextClassLoader != _classLoader) {
178                                    currentThread.setContextClassLoader(contextClassLoader);
179                            }
180                    }
181            }
182    
183            @NotPrivileged
184            @Override
185            public void delete(Object object) throws ORMException {
186                    Thread currentThread = Thread.currentThread();
187    
188                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
189    
190                    try {
191                            if (contextClassLoader != _classLoader) {
192                                    currentThread.setContextClassLoader(_classLoader);
193                            }
194    
195                            _session.delete(object);
196                    }
197                    finally {
198                            if (contextClassLoader != _classLoader) {
199                                    currentThread.setContextClassLoader(contextClassLoader);
200                            }
201                    }
202            }
203    
204            @NotPrivileged
205            @Override
206            public void evict(Object object) throws ORMException {
207                    Thread currentThread = Thread.currentThread();
208    
209                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
210    
211                    try {
212                            if (contextClassLoader != _classLoader) {
213                                    currentThread.setContextClassLoader(_classLoader);
214                            }
215    
216                            _session.evict(object);
217                    }
218                    finally {
219                            if (contextClassLoader != _classLoader) {
220                                    currentThread.setContextClassLoader(contextClassLoader);
221                            }
222                    }
223            }
224    
225            @NotPrivileged
226            @Override
227            public void flush() 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                            _session.flush();
238                    }
239                    finally {
240                            if (contextClassLoader != _classLoader) {
241                                    currentThread.setContextClassLoader(contextClassLoader);
242                            }
243                    }
244            }
245    
246            @NotPrivileged
247            @Override
248            public Object get(Class<?> clazz, Serializable id) throws ORMException {
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);
259                    }
260                    finally {
261                            if (contextClassLoader != _classLoader) {
262                                    currentThread.setContextClassLoader(contextClassLoader);
263                            }
264                    }
265            }
266    
267            @NotPrivileged
268            @Override
269            public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
270                    throws ORMException {
271    
272                    Thread currentThread = Thread.currentThread();
273    
274                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
275    
276                    try {
277                            if (contextClassLoader != _classLoader) {
278                                    currentThread.setContextClassLoader(_classLoader);
279                            }
280    
281                            return _session.get(clazz, id, lockMode);
282                    }
283                    finally {
284                            if (contextClassLoader != _classLoader) {
285                                    currentThread.setContextClassLoader(contextClassLoader);
286                            }
287                    }
288            }
289    
290            @NotPrivileged
291            @Override
292            public Object getWrappedSession() throws ORMException {
293                    Thread currentThread = Thread.currentThread();
294    
295                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
296    
297                    try {
298                            if (contextClassLoader != _classLoader) {
299                                    currentThread.setContextClassLoader(_classLoader);
300                            }
301    
302                            return _session.getWrappedSession();
303                    }
304                    finally {
305                            if (contextClassLoader != _classLoader) {
306                                    currentThread.setContextClassLoader(contextClassLoader);
307                            }
308                    }
309            }
310    
311            @NotPrivileged
312            @Override
313            public Object load(Class<?> clazz, Serializable id) throws ORMException {
314                    Thread currentThread = Thread.currentThread();
315    
316                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
317    
318                    try {
319                            if (contextClassLoader != _classLoader) {
320                                    currentThread.setContextClassLoader(_classLoader);
321                            }
322    
323                            return _session.load(clazz, id);
324                    }
325                    finally {
326                            if (contextClassLoader != _classLoader) {
327                                    currentThread.setContextClassLoader(contextClassLoader);
328                            }
329                    }
330            }
331    
332            @NotPrivileged
333            @Override
334            public Object merge(Object object) throws ORMException {
335                    Thread currentThread = Thread.currentThread();
336    
337                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
338    
339                    try {
340                            if (contextClassLoader != _classLoader) {
341                                    currentThread.setContextClassLoader(_classLoader);
342                            }
343    
344                            return _session.merge(object);
345                    }
346                    finally {
347                            if (contextClassLoader != _classLoader) {
348                                    currentThread.setContextClassLoader(contextClassLoader);
349                            }
350                    }
351            }
352    
353            @NotPrivileged
354            @Override
355            public Serializable save(Object object) throws ORMException {
356                    Thread currentThread = Thread.currentThread();
357    
358                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
359    
360                    try {
361                            if (contextClassLoader != _classLoader) {
362                                    currentThread.setContextClassLoader(_classLoader);
363                            }
364    
365                            return _session.save(object);
366                    }
367                    finally {
368                            if (contextClassLoader != _classLoader) {
369                                    currentThread.setContextClassLoader(contextClassLoader);
370                            }
371                    }
372            }
373    
374            @NotPrivileged
375            @Override
376            public void saveOrUpdate(Object object) throws ORMException {
377                    Thread currentThread = Thread.currentThread();
378    
379                    ClassLoader contextClassLoader = currentThread.getContextClassLoader();
380    
381                    try {
382                            if (contextClassLoader != _classLoader) {
383                                    currentThread.setContextClassLoader(_classLoader);
384                            }
385    
386                            _session.saveOrUpdate(object);
387                    }
388                    finally {
389                            if (contextClassLoader != _classLoader) {
390                                    currentThread.setContextClassLoader(contextClassLoader);
391                            }
392                    }
393            }
394    
395            private ClassLoader _classLoader;
396            private Session _session;
397    
398    }