package com.demo.demo.services.data;
import com.demo.demo.factories.demo.*;
import com.demo.demo.model.obj.demo.Customer;
import com.demo.demo.model.obj.demo.Line;
import com.demo.demo.model.obj.demo.Order;
import com.demo.demo.model.obj.demo.Stock;
import java.io.Serializable;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.ReplicationMode;
import org.hibernate.Session;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;
import com.demo.persistence.GenericDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.hibernate.SessionFactory;
import org.hibernate.proxy.HibernateProxy;
@org.springframework.stereotype.Component
public class DataLayerDemoImpl implements DataLayerDemo {
private SessionFactory sessionFactory = null;
private static DataLayerDemo instance;
private static Object daoMapLock = new Object();
@SuppressWarnings("unchecked")
private static Map<Class<?>, GenericDAO<?, ?>> daoMap = null;
private static ApplicationContext context;
@Autowired
public void setApplicationContext(ApplicationContext context) {
DataLayerDemoImpl.context = context;
}
@Autowired
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@SuppressWarnings("unchecked")
private <T> GenericDAO<T, ?> getDAO(final T persistentObject) {
T persistent = persistentObject;
synchronized(daoMapLock){
if (daoMap == null) {
daoMap = new ConcurrentHashMap<Class<?>, GenericDAO<?, ?>>();
daoMap.put(Customer.class, HibernateDemoDaoFactory.getCustomerDao());
daoMap.put(Line.class, HibernateDemoDaoFactory.getLineDao());
daoMap.put(Order.class, HibernateDemoDaoFactory.getOrderDao());
daoMap.put(Stock.class, HibernateDemoDaoFactory.getStockDao());
}
}
if (persistentObject instanceof HibernateProxy) {
persistent = (T)((HibernateProxy)persistentObject).getHibernateLazyInitializer().getImplementation();
}
GenericDAO<T, ?> result = (GenericDAO<T, ?>) daoMap.get(persistent.getClass());
if (result == null) {
throw new IllegalAccessError("The given object is of an incorrect type. ");
}
return result;
}
public <T> void delete(T persistentObject) {
getDAO(persistentObject).delete(persistentObject);
}
public <T> void refresh(T persistentObject) {
getDAO(persistentObject).refresh(persistentObject);
}
public <T> Serializable save(T persistentObject) {
return getDAO(persistentObject).save(persistentObject);
}
public <T> void saveOrUpdate(T persistentObject) {
getDAO(persistentObject).saveOrUpdate(persistentObject);
}
public <T> void update(T persistentObject) {
getDAO(persistentObject).update(persistentObject);
}
public void deleteCustomer(final Serializable id) {
HibernateDemoDaoFactory.getCustomerDao().delete(loadCustomer(id));
}
public Customer loadCustomer(final Serializable id) {
return HibernateDemoDaoFactory.getCustomerDao().load(id);
}
public Customer getCustomer(final Serializable id) {
return HibernateDemoDaoFactory.getCustomerDao().get(id);
}
public void deleteLine(final Serializable id) {
HibernateDemoDaoFactory.getLineDao().delete(loadLine(id));
}
public Line loadLine(final Serializable id) {
return HibernateDemoDaoFactory.getLineDao().load(id);
}
public Line getLine(final Serializable id) {
return HibernateDemoDaoFactory.getLineDao().get(id);
}
public void deleteOrder(final Serializable id) {
HibernateDemoDaoFactory.getOrderDao().delete(loadOrder(id));
}
public Order loadOrder(final Serializable id) {
return HibernateDemoDaoFactory.getOrderDao().load(id);
}
public Order getOrder(final Serializable id) {
return HibernateDemoDaoFactory.getOrderDao().get(id);
}
public void deleteStock(final Serializable id) {
HibernateDemoDaoFactory.getStockDao().delete(loadStock(id));
}
public Stock loadStock(final Serializable id) {
return HibernateDemoDaoFactory.getStockDao().load(id);
}
public Stock getStock(final Serializable id) {
return HibernateDemoDaoFactory.getStockDao().get(id);
}
public static synchronized DataLayerDemo getInstance() {
if (instance == null) {
instance = (DataLayerDemo) context.getBean("dataLayerDemoImpl");
}
return instance;
}
public Query createQuery(final String query) {
return sessionFactory.getCurrentSession().createQuery(query);
}
public Criteria createCriteria(final String criteria) {
return sessionFactory.getCurrentSession().createCriteria(criteria);
}
public Query getNamedQuery(final String query) {
return sessionFactory.getCurrentSession().getNamedQuery(query);
}
@SuppressWarnings("unchecked")
public Criteria createCriteria(Class persistentObject) {
return sessionFactory.getCurrentSession().createCriteria(persistentObject);
}
public void flushSession() {
sessionFactory.getCurrentSession().flush();
}
public void clearSession() {
sessionFactory.getCurrentSession().clear();
}
public void flushAndClearSession() {
flushSession();
clearSession();
}
public void replicate(Object obj, ReplicationMode replicationMode) {
sessionFactory.getCurrentSession().replicate(obj, replicationMode);
}
public Object merge(Object obj) {
return sessionFactory.getCurrentSession().merge(obj);
}
public Session getCurrentSession() {
return sessionFactory.getCurrentSession();
}
public SQLQuery createSQLQuery(final String query) {
return sessionFactory.getCurrentSession().createSQLQuery(query);
}
public void evict(Object obj) {
sessionFactory.getCurrentSession().evict(obj);
}}