001
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
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 }