Source code

001package springdao;
002
003import java.io.Serializable;
004import java.util.Collection;
005import java.util.List;
006import java.util.Map;
007import org.apache.logging.log4j.Logger;
008import org.apache.logging.log4j.LogManager;
009import org.springframework.transaction.annotation.Propagation;
010import org.springframework.transaction.annotation.Transactional;
011
012/**
013 * Do everything that {@link DaoRepository } do, it's main purpose is
014 * transaction management.<br/>
015 * Standard JPA does not support custom isolation levels, So we must declare
016 * {@link Transactional @Transactional} here.<br/>
017 * 封裝{@link DaoRepository}的功能，只是為了交易控制.
018 *
019 * @author Kent Yeh
020 * @param <E>
021 */
022@Transactional(readOnly = true)
023public class RepositoryManager<E> {
024
025    private DaoRepository<E> dao;
026    protected static Logger logger = LogManager.getLogger(RepositoryManager.class);
027
028    public DaoRepository<E> getDao() {
029        return dao;
030    }
031
032    public void setDao(DaoRepository<E> dao) {
033        this.dao = dao;
034    }
035
036    public E instanate() throws InstantiationException, IllegalAccessException {
037        return dao.instanate();
038    }
039
040    public E findByPrimaryKey(Serializable primaryKey) {
041        return dao == null ? null : dao.findByPrimaryKey(primaryKey);
042    }
043
044    public E findByPrimaryKey(Serializable primaryKey, String lockMode) {
045        return dao == null ? null : dao.findByPrimaryKey(primaryKey, lockMode);
046    }
047
048    public E findByPrimaryKey(Serializable primaryKey, Map<String, Object> properties) {
049        return dao == null ? null : dao.findByPrimaryKey(primaryKey, properties);
050    }
051
052    /**
053     * @param properties Not used.不使用
054     */
055    public E findByPrimaryKey(Serializable primaryKey, String lockMode, Map<String, Object> properties) {
056        return dao == null ? null : dao.findByPrimaryKey(primaryKey, lockMode, properties);
057    }
058
059    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
060    public E save(E entity) {
061        return dao == null ? null : dao.save(entity);
062    }
063
064    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
065    public Collection<E> save(Collection<E> entities) {
066        return dao == null ? null : dao.save(entities);
067    }
068
069    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
070    public E persist(E entity) {
071        return dao == null ? null : dao.persist(entity);
072    }
073
074    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
075    public E update(E entity) {
076        return dao == null ? null : dao.update(entity);
077    }
078
079    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
080    public Collection<E> update(Collection<E> entities) {
081        return dao == null ? null : dao.update(entities);
082    }
083
084    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
085    public E merge(E entity) {
086        return dao == null ? null : dao.merge(entity);
087    }
088
089    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
090    public Collection<E> merge(Collection<E> entity) {
091        return dao == null ? null : dao.merge(entity);
092    }
093
094    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
095    public E saveOrUpdate(E entity) {
096        return dao == null ? null : dao.saveOrUpdate(entity);
097    }
098
099    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
100    public Collection<E> saveOrUpdate(Collection<E> entities) {
101        return dao == null ? null : dao.saveOrUpdate(entities);
102    }
103
104    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
105    public void delete(Serializable primaryKey) {
106        dao.delete(primaryKey);
107    }
108
109    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
110    public void delete(Serializable primaryKey, String lockMode) {
111        dao.delete(primaryKey, lockMode);
112    }
113
114    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
115    public void delete(Collection<? extends Serializable> primaryKeys) {
116        dao.delete(primaryKeys);
117    }
118
119    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
120    public E remove(E entity) {
121        return dao.remove(entity);
122    }
123
124    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
125    public E remove(E entity, String lockMode) {
126        return dao.remove(entity, lockMode);
127    }
128
129    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
130    public Collection<E> remove(Collection<E> entities) {
131        return dao.remove(entities);
132    }
133
134    public E refresh(E entity) {
135        return dao == null ? null : dao.refresh(entity);
136    }
137
138    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
139    public E refresh(E entity, String lockMode) {
140        return dao == null ? null : dao.refresh(entity, lockMode);
141    }
142    
143    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
144    public int sqlUpdate(String sql) {
145        return dao == null ? null : dao.sqlUpdate(sql);
146    }
147    
148    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
149    public int sqlUpdate(String sql, Object... parameters) {
150        return dao == null ? null : dao.sqlUpdate(sql, parameters);
151    }
152    
153    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
154    public int sqlUpdate(String sql, Map<String, ?>parameters) {
155        return dao == null ? null : dao.sqlUpdate(sql, parameters);
156    }
157    
158    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
159    public List<Integer> sqlUpdate(List<String> sqls) {
160        return dao == null ? null : dao.sqlUpdate(sqls);
161    }
162    
163    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
164    public int bulkUpdate(String QL) {
165        return dao == null ? null : dao.bulkUpdate(QL);
166    }
167
168    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
169    public List<Integer> bulkUpdate(List<String> QLs) {
170        return dao == null ? null : dao.bulkUpdate(QLs);
171    }
172
173    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
174    public int bulkUpdate(String QL, Object... parameters) {
175        return dao == null ? null : dao.bulkUpdate(QL, parameters);
176    }
177    
178    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
179    public int bulkUpdate(String QL, Map<String, ?> parameters) {
180        return dao == null ? null : dao.bulkUpdate(QL, parameters);
181    }
182
183    public String getEntityName() {
184        return dao == null ? "" : dao.getEntityName();
185    }
186
187    public String $e() {
188        return getEntityName();
189    }
190
191    public String getAliasName() {
192        return dao == null ? "" : dao.getAliasName();
193    }
194
195    public String $a() {
196        return getAliasName();
197    }
198
199    public String $a(String field) {
200        return getAliasName() + "." + field;
201    }
202
203    public String $ea() {
204        return getEntityName() + " AS " + getAliasName();
205    }
206
207    public List<E> findByCriteria(String qlCriteria) {
208        return dao == null ? null : dao.findByCriteria(qlCriteria);
209    }
210
211    public List<E> findByCriteria(String qlCriteria, Object... parameters) {
212        return dao == null ? null : dao.findByCriteria(qlCriteria, parameters);
213    }
214
215    public List<E> findByCriteria(String qlCriteria, Map<String, ?> parameters) {
216        return dao == null ? null : dao.findByCriteria(qlCriteria, parameters);
217    }
218
219    public List<E> findByCriteria(String qlCriteria, int startPageNo, int pageSize, Object... parameters) {
220        return dao == null ? null : dao.findByCriteria(qlCriteria, startPageNo, pageSize, parameters);
221    }
222
223    public List<E> findByCriteria(String qlCriteria, int startPageNo, int pageSize, Map<String, ?> parameters) {
224        return dao == null ? null : dao.findByCriteria(qlCriteria, startPageNo, pageSize, parameters);
225    }
226
227    public List<E> findByCriteria(String qlCriteria, int startPageNo, int pageSize) {
228        return dao == null ? null : dao.findByCriteria(qlCriteria, startPageNo, pageSize);
229    }
230
231    public E findFirstByCriteria(String qlCriteria) {
232        List<E> result = findByCriteria(qlCriteria, 1, 1);
233        return result.isEmpty() ? null : result.get(0);
234    }
235
236    public E findFirstByCriteria(String qlCriteria, Object... parameters) {
237        List<E> result = findByCriteria(qlCriteria, 1, 1, parameters);
238        return result.isEmpty() ? null : result.get(0);
239    }
240
241    public List<E> findByNamedQuery(String name) {
242        return dao == null ? null : dao.findByNamedQuery(name);
243    }
244
245    public List<E> findByNamedQuery(String name, Object... parameters) {
246        return dao == null ? null : dao.findByNamedQuery(name, parameters);
247    }
248
249    public List<E> findByNamedQuery(String name, Map<String, ?> parameters) {
250        return dao == null ? null : dao.findByNamedQuery(name, parameters);
251    }
252
253    public List<E> findBySQLQuery(String sql) {
254        return dao == null ? null : dao.findBySQLQuery(sql);
255    }
256
257    public List<E> findBySQLQuery(String sql, Object... parameters) {
258        return dao == null ? null : dao.findBySQLQuery(sql, parameters);
259    }
260
261    public List<E> findBySQLQuery(String sql, Map<String, ?> parameters) {
262        return dao == null ? null : dao.findBySQLQuery(sql, parameters);
263    }
264
265    public List<E> findBySQLQuery(String sql, String entityAlias) {
266        return dao == null ? null : dao.findBySQLQuery(sql, entityAlias);
267    }
268
269    public List<E> findBySQLQuery(String sql, String entityAlias, Object... parameters) {
270        return dao == null ? null : dao.findBySQLQuery(sql, entityAlias, parameters);
271    }
272
273    public <T> T findUniqueByQL(String QL) {
274        if (dao == null) {
275            return null;
276        } else {
277            return dao.findUniqueByQL(QL);
278        }
279    }
280
281    public <T> T findUniqueByQL(Class<T> clazz, String QL) {
282        return findUniqueByQL(QL);
283    }
284
285    public <T> T findUniqueByQL(String QL, Object... parameters) {
286        if (dao == null) {
287            return null;
288        } else {
289            return dao.findUniqueByQL(QL, parameters);
290        }
291    }
292
293    public <T> T findUniqueByQL(Class<T> clazz, String QL, Object... parameters) {
294        return findUniqueByQL(QL, parameters);
295    }
296
297    public <T> T findUniqueByQL(String QL, Map<String, ?> parameters) {
298        if (dao == null) {
299            return null;
300        } else {
301            return dao.findUniqueByQL(QL, parameters);
302        }
303    }
304
305    public <T> T findUniqueByQL(Class<T> clazz, String QL, Map<String, ?> parameters) {
306        return findUniqueByQL(QL, parameters);
307    }
308
309    public <T> List<T> findListByQL(String QL) {
310        if (dao == null) {
311            return null;
312        } else {
313            return dao.findListByQL(QL);
314        }
315    }
316
317    public <T> List<T> findListByQL(Class<T> clazz, String QL) {
318        return findListByQL(QL);
319    }
320
321    public <T> List<T> findListByQL(String QL, Object... parameters) {
322        if (dao == null) {
323            return null;
324        } else {
325            return dao.findListByQL(QL, parameters);
326        }
327    }
328
329    public <T> List<T> findListByQL(Class<T> clazz, String QL, Object... parameters) {
330        return findListByQL(QL, parameters);
331    }
332
333    public <T> List<T> findListByQL(String QL, Map<String, ?> parameters) {
334        if (dao == null) {
335            return null;
336        } else {
337            return dao.findListByQL(QL, parameters);
338        }
339    }
340
341    public <T> List<T> findListByQL(Class<T> clazz, String QL, Map<String, ?> parameters) {
342        return findListByQL(QL, parameters);
343    }
344
345    public <T> List<T> findListByNamedQuery(String name) {
346        if (dao == null) {
347            return null;
348        } else {
349            return dao.findListByNamedQuery(name);
350        }
351    }
352
353    public <T> List<T> findListByNamedQuery(Class<T> clazz, String name) {
354        return findListByNamedQuery(name);
355    }
356
357    public <T> List<T> findListByNamedQuery(String name, Object... parameters) {
358        if (dao == null) {
359            return null;
360        } else {
361            return dao.findListByNamedQuery(name, parameters);
362        }
363
364    }
365
366    public <T> List<T> findListByNamedQuery(Class<T> clazz, String name, Object... parameters) {
367        return findListByNamedQuery(name, parameters);
368    }
369
370    public <T> List<T> findListByNamedQuery(String name, Map<String, ?> parameters) {
371        if (dao == null) {
372            return null;
373        } else {
374            return dao.findListByNamedQuery(name, parameters);
375        }
376
377    }
378
379    public <T> List<T> findListByNamedQuery(Class<T> clazz, String name, Map<String, ?> parameters) {
380        return findListByNamedQuery(name, parameters);
381    }
382
383    public E initLazyCollection(E entity, String collectionFieldName) {
384        return dao == null ? null : dao.initLazyCollection(entity, collectionFieldName);
385    }
386
387    public void clear() {
388        if (dao != null) {
389            dao.clear();
390        }
391    }
392}