001/*
002 *    Copyright 2024-2025, Warm-Flow (290631660@qq.com).
003 *
004 *    Licensed under the Apache License, Version 2.0 (the "License");
005 *    you may not use this file except in compliance with the License.
006 *    You may obtain a copy of the License at
007 *
008 *       https://www.apache.org/licenses/LICENSE-2.0
009 *
010 *    Unless required by applicable law or agreed to in writing, software
011 *    distributed under the License is distributed on an "AS IS" BASIS,
012 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 *    See the License for the specific language governing permissions and
014 *    limitations under the License.
015 */
016package org.dromara.warm.flow.solon.jpa;
017
018import org.noear.solon.data.tran.TranListener;
019import org.noear.solon.data.tran.TranUtils;
020
021import javax.persistence.*;
022import javax.persistence.criteria.CriteriaBuilder;
023import javax.persistence.criteria.CriteriaDelete;
024import javax.persistence.criteria.CriteriaQuery;
025import javax.persistence.criteria.CriteriaUpdate;
026import javax.persistence.metamodel.Metamodel;
027import java.util.List;
028import java.util.Map;
029
030/**
031 * @author vanlin
032 * @className EntityManagerProxy
033 * @description
034 * @since 2024/7/5 15:16
035 */
036public class EntityManagerProxy implements EntityManager {
037    private final EntityManager entityManager;
038
039    public EntityManagerProxy(final EntityManager entityManager) {
040        this.entityManager = entityManager;
041    }
042
043    private <T extends EntityManager> T tranTry(T entityManager){
044        if(TranUtils.inTrans()){
045            EntityTransaction transaction = entityManager.getTransaction();
046
047            if(!transaction.isActive()) {
048                transaction.begin();
049
050                TranUtils.listen(new TranListener() {
051                    @Override
052                    public void beforeCommit(boolean readOnly) throws Throwable {
053                        if (readOnly) {
054                            transaction.setRollbackOnly();
055                        }
056                        transaction.commit();
057                    }
058
059                    @Override
060                    public void afterCompletion(int status) {
061                        if (status == TranListener.STATUS_ROLLED_BACK) {
062                            transaction.rollback();
063                        }
064                    }
065                });
066            }
067        }
068
069        return entityManager;
070    }
071
072    @Override
073    public void persist(Object entity) {
074        tranTry(entityManager);
075        entityManager.persist(entity);
076    }
077
078    @Override
079    public <T> T merge(T entity) {
080        tranTry(entityManager);
081        return entityManager.merge(entity);
082    }
083
084    @Override
085    public void remove(Object entity) {
086        tranTry(entityManager);
087        entityManager.remove(entity);
088    }
089
090    @Override
091    public <T> T find(Class<T> entityClass, Object primaryKey) {
092        tranTry(entityManager);
093        return entityManager.find(entityClass, primaryKey);
094    }
095
096    @Override
097    public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties) {
098        tranTry(entityManager);
099        return entityManager.find(entityClass, primaryKey, properties);
100    }
101
102    @Override
103    public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode) {
104        tranTry(entityManager);
105        return entityManager.find(entityClass, primaryKey, lockMode);
106    }
107
108    @Override
109    public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties) {
110        tranTry(entityManager);
111        return entityManager.find(entityClass, primaryKey, lockMode, properties);
112    }
113
114    @Override
115    public <T> T getReference(Class<T> entityClass, Object primaryKey) {
116        tranTry(entityManager);
117        return entityManager.getReference(entityClass, primaryKey);
118    }
119
120    @Override
121    public void flush() {
122        tranTry(entityManager);
123        entityManager.flush();
124    }
125
126    @Override
127    public void setFlushMode(FlushModeType flushMode) {
128        entityManager.setFlushMode(flushMode);
129    }
130
131    @Override
132    public FlushModeType getFlushMode() {
133        return entityManager.getFlushMode();
134    }
135
136    @Override
137    public void lock(Object entity, LockModeType lockMode) {
138        tranTry(entityManager);
139        entityManager.lock(entity, lockMode);
140    }
141
142    @Override
143    public void lock(Object entity, LockModeType lockMode, Map<String, Object> properties) {
144        tranTry(entityManager);
145        entityManager.lock(entity, lockMode, properties);
146    }
147
148    @Override
149    public void refresh(Object entity) {
150        tranTry(entityManager);
151        entityManager.refresh(entity);
152    }
153
154    @Override
155    public void refresh(Object entity, Map<String, Object> properties) {
156        tranTry(entityManager);
157        entityManager.refresh(entity, properties);
158    }
159
160    @Override
161    public void refresh(Object entity, LockModeType lockMode) {
162        tranTry(entityManager);
163        entityManager.refresh(entity, lockMode);
164    }
165
166    @Override
167    public void refresh(Object entity, LockModeType lockMode, Map<String, Object> properties) {
168        tranTry(entityManager);
169        entityManager.refresh(entity, lockMode, properties);
170    }
171
172    @Override
173    public void clear() {
174        tranTry(entityManager);
175        entityManager.clear();
176    }
177
178    @Override
179    public void detach(Object entity) {
180        tranTry(entityManager);
181        entityManager.detach(entity);
182    }
183
184    @Override
185    public boolean contains(Object entity) {
186        tranTry(entityManager);
187        return entityManager.contains(entity);
188    }
189
190    @Override
191    public LockModeType getLockMode(Object entity) {
192        tranTry(entityManager);
193        return entityManager.getLockMode(entity);
194    }
195
196    @Override
197    public void setProperty(String propertyName, Object value) {
198        tranTry(entityManager);
199        entityManager.setProperty(propertyName, value);
200    }
201
202    @Override
203    public Map<String, Object> getProperties() {
204        tranTry(entityManager);
205        return entityManager.getProperties();
206    }
207
208    @Override
209    public Query createQuery(String qlString) {
210        tranTry(entityManager);
211        return entityManager.createQuery(qlString);
212    }
213
214    @Override
215    public <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery) {
216        tranTry(entityManager);
217        return entityManager.createQuery(criteriaQuery);
218    }
219
220    @Override
221    public Query createQuery(CriteriaUpdate updateQuery) {
222        tranTry(entityManager);
223        return entityManager.createQuery(updateQuery);
224    }
225
226    @Override
227    public Query createQuery(CriteriaDelete deleteQuery) {
228        tranTry(entityManager);
229        return entityManager.createQuery(deleteQuery);
230    }
231
232    @Override
233    public <T> TypedQuery<T> createQuery(String qlString, Class<T> resultClass) {
234        tranTry(entityManager);
235        return entityManager.createQuery(qlString, resultClass);
236    }
237
238    @Override
239    public Query createNamedQuery(String name) {
240        tranTry(entityManager);
241        return entityManager.createNamedQuery(name);
242    }
243
244    @Override
245    public <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass) {
246        tranTry(entityManager);
247        return entityManager.createNamedQuery(name, resultClass);
248    }
249
250    @Override
251    public Query createNativeQuery(String sqlString) {
252        tranTry(entityManager);
253        return entityManager.createNativeQuery(sqlString);
254    }
255
256    @Override
257    public Query createNativeQuery(String sqlString, Class resultClass) {
258        tranTry(entityManager);
259        return entityManager.createNativeQuery(sqlString, resultClass);
260    }
261
262    @Override
263    public Query createNativeQuery(String sqlString, String resultSetMapping) {
264        tranTry(entityManager);
265        return entityManager.createNativeQuery(sqlString, resultSetMapping);
266    }
267
268    @Override
269    public StoredProcedureQuery createNamedStoredProcedureQuery(String name) {
270        tranTry(entityManager);
271        return entityManager.createNamedStoredProcedureQuery(name);
272    }
273
274    @Override
275    public StoredProcedureQuery createStoredProcedureQuery(String procedureName) {
276        tranTry(entityManager);
277        return entityManager.createStoredProcedureQuery(procedureName);
278    }
279
280    @Override
281    public StoredProcedureQuery createStoredProcedureQuery(String procedureName, Class... resultClasses) {
282        tranTry(entityManager);
283        return entityManager.createStoredProcedureQuery(procedureName, resultClasses);
284    }
285
286    @Override
287    public StoredProcedureQuery createStoredProcedureQuery(String procedureName, String... resultSetMappings) {
288        tranTry(entityManager);
289        return entityManager.createStoredProcedureQuery(procedureName, resultSetMappings);
290    }
291
292    @Override
293    public void joinTransaction() {
294        entityManager.joinTransaction();
295    }
296
297    @Override
298    public boolean isJoinedToTransaction() {
299        return entityManager.isJoinedToTransaction();
300    }
301
302    @Override
303    public <T> T unwrap(Class<T> cls) {
304        return entityManager.unwrap(cls);
305    }
306
307    @Override
308    public Object getDelegate() {
309        return entityManager.getDelegate();
310    }
311
312    @Override
313    public void close() {
314        entityManager.close();
315    }
316
317    @Override
318    public boolean isOpen() {
319        return entityManager.isOpen();
320    }
321
322    @Override
323    public EntityTransaction getTransaction() {
324        return entityManager.getTransaction();
325    }
326
327    @Override
328    public EntityManagerFactory getEntityManagerFactory() {
329        return entityManager.getEntityManagerFactory();
330    }
331
332    @Override
333    public CriteriaBuilder getCriteriaBuilder() {
334        return entityManager.getCriteriaBuilder();
335    }
336
337    @Override
338    public Metamodel getMetamodel() {
339        return entityManager.getMetamodel();
340    }
341
342    @Override
343    public <T> EntityGraph<T> createEntityGraph(Class<T> rootType) {
344        return entityManager.createEntityGraph(rootType);
345    }
346
347    @Override
348    public EntityGraph<?> createEntityGraph(String graphName) {
349        return entityManager.createEntityGraph(graphName);
350    }
351
352    @Override
353    public EntityGraph<?> getEntityGraph(String graphName) {
354        return entityManager.getEntityGraph(graphName);
355    }
356
357    @Override
358    public <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> entityClass) {
359        return entityManager.getEntityGraphs(entityClass);
360    }
361}