io.pelle.mango.db.dao.BaseEntityDAODelegate Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mango-db Show documentation
mango web framework
The newest version!
/**
 * Copyright (c) 2013 Christian Pelster.
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Christian Pelster - initial API and implementation
 */
package io.pelle.mango.db.dao;

import static com.codahale.metrics.MetricRegistry.name;
import io.pelle.mango.client.base.vo.IBaseEntity;
import io.pelle.mango.client.base.vo.query.AggregateQuery;
import io.pelle.mango.client.base.vo.query.CountQuery;
import io.pelle.mango.client.base.vo.query.DeleteQuery;
import io.pelle.mango.client.base.vo.query.SelectQuery;
import io.pelle.mango.db.util.DBUtil;
import io.pelle.mango.db.util.EntityVOMapper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.google.common.base.Optional;
import com.google.common.collect.Iterables;

@Component
public class BaseEntityDAODelegate extends BaseEntityVODelegate implements IBaseEntityDAO {

	private static final String CREATE_METRIC_KEY = "create";

	private static final String SAVE_METRIC_KEY = "save";

	private static final String READ_METRIC_KEY = "read";

	private Map, Timer> createTimers = new HashMap, Timer>();

	private Map, Timer> saveTimers = new HashMap, Timer>();

	private Map, Timer> readTimers = new HashMap, Timer>();

	private Map, IVOEntityDAO> entityDAOs = new HashMap, IVOEntityDAO>();

	private List> genericCallbacks = new ArrayList>();

	private Map, List>> entityCallbacks = new HashMap, List>>();

	@Autowired
	private BaseEntityDAO baseEntityDAO;

	@Override
	public  T create(T entity) {

		Timer.Context context = getCreateContext(entity.getClass());

		fireOnCreateCallbacks(entity);

		try {

			IVOEntityDAO entityDAO = getVOEntityDAO(entity);

			if (entityDAO != null) {
				return entityDAO.create(entity);
			} else {
				return baseEntityDAO.create(entity);
			}

		} finally {
			if (context != null) {
				context.stop();
			}
		}

	}

	@SuppressWarnings("unchecked")
	private  IVOEntityDAO getVOEntityDAO(Object entity) {

		Class entityClass = null;

		if (Class.class.isAssignableFrom(entity.getClass())) {
			entityClass = (Class) entity;
		} else {
			entityClass = entity.getClass();
		}

		return (IVOEntityDAO) entityDAOs.get(entityClass);
	}

	@Override
	public  T save(T entity) {

		Timer.Context context = getSaveContext(entity.getClass());

		IVOEntityDAO entityDAO = getVOEntityDAO(entity);

		T result = null;

		if (entityDAO != null) {
			result = entityDAO.save(entity);
		} else {
			result = baseEntityDAO.save(entity);
		}

		if (context != null) {
			context.stop();
		}

		return result;
	}

	@Override
	public  T read(long id, Class entityClass) {

		Timer.Context context = getReadTimerContext(entityClass);

		try {

			IVOEntityDAO entityDAO = getVOEntityDAO(entityClass);

			if (entityDAO != null) {
				return entityDAO.read(id);
			} else {
				return baseEntityDAO.read(id, entityClass);
			}
		} finally {
			if (context != null) {
				context.stop();
			}
		}

	}

	@Override
	public  List filter(SelectQuery query) {

		Timer.Context context = getFilterContext(EntityVOMapper.getInstance().getEntityClass(DBUtil.getQueryClass(query)));

		try {

			IVOEntityDAO entityDAO = getVOEntityDAO(DBUtil.getQueryClass(query));

			if (entityDAO != null) {
				return entityDAO.filter(query);
			} else {
				return baseEntityDAO.filter(query);
			}

		} finally {
			if (context != null) {
				context.stop();
			}
		}

	}

	@Override
	public  Optional read(SelectQuery query) {
		IVOEntityDAO entityDAO = getVOEntityDAO(DBUtil.getQueryClass(query));

		if (entityDAO != null) {
			return entityDAO.read(query);
		} else {
			return baseEntityDAO.read(query);
		}
	}

	@Override
	public  void deleteAll(Class entityClass) {
		IVOEntityDAO entityDAO = getVOEntityDAO(entityClass);

		if (entityDAO != null) {
			entityDAO.deleteAll();
		} else {
			baseEntityDAO.deleteAll(entityClass);
		}
	}

	@Override
	public  void delete(T entity) {

		IVOEntityDAO entityDAO = getVOEntityDAO(entity);

		fireOnDeleteCallbacks(entity);

		if (entityDAO != null) {
			entityDAO.delete(entity);
		} else {
			baseEntityDAO.delete(entity);
		}

	}

	@Override
	public  long count(CountQuery query) {
		IVOEntityDAO entityDAO = getVOEntityDAO(DBUtil.getQueryClass(query));

		if (entityDAO != null) {
			return entityDAO.count(query);
		} else {
			return baseEntityDAO.count(query);
		}
	}

	@Override
	public  long aggregate(AggregateQuery query) {
		IVOEntityDAO entityDAO = getVOEntityDAO(DBUtil.getQueryClass(query));

		if (entityDAO != null) {
			return entityDAO.aggregate(query);
		} else {
			return baseEntityDAO.aggregate(query);
		}
	}

	@Override
	public  List searchByNaturalKey(Class entityClass, String naturalKey) {
		IVOEntityDAO entityDAO = getVOEntityDAO(entityClass);

		if (entityDAO != null) {
			return entityDAO.getByNaturalKey(naturalKey);
		} else {
			return baseEntityDAO.searchByNaturalKey(entityClass, naturalKey);
		}
	}

	@Override
	public  void deleteQuery(DeleteQuery query) {
		IVOEntityDAO entityDAO = getVOEntityDAO(DBUtil.getQueryClass(query));

		if (entityDAO != null) {
			entityDAO.deleteQuery(query);
		} else {
			baseEntityDAO.deleteQuery(query);
		}
	}

	@Autowired(required = false)
	public void setEntityDAOs(List> entityDAOList) {
		for (IVOEntityDAO voEntityDAO : entityDAOList) {
			Class baseEntityClass = EntityVOMapper.getInstance().getEntityClass(voEntityDAO.getVOEntityClass());
			entityDAOs.put(baseEntityClass, voEntityDAO);
		}
	}

	@Override
	public  void delete(Class entityClass, long id) {
		IVOEntityDAO entityDAO = getVOEntityDAO(entityClass);

		if (entityDAO != null) {
			entityDAO.delete(id);
		} else {
			baseEntityDAO.delete(entityClass, id);
		}
	}

	@Override
	public  long count(Class entityClass) {
		IVOEntityDAO entityDAO = getVOEntityDAO(entityClass);

		if (entityDAO != null) {
			return entityDAO.count();
		} else {
			return baseEntityDAO.count(entityClass);
		}
	}

	@Override
	public  List getAll(Class entityClass) {
		IVOEntityDAO entityDAO = getVOEntityDAO(entityClass);

		if (entityDAO != null) {
			return entityDAO.getAll();
		} else {
			return baseEntityDAO.getAll(entityClass);
		}
	}

	private Timer.Context getReadTimerContext(Class entityClass) {

		Timer timer = readTimers.get(entityClass);

		if (timer != null) {
			return timer.time();
		}

		return null;
	}

	private Timer.Context getCreateContext(Class entityClass) {

		Timer timer = createTimers.get(entityClass);

		if (timer != null) {
			return timer.time();
		}

		return null;
	}

	private Timer.Context getSaveContext(Class entityClass) {

		Timer timer = saveTimers.get(entityClass);

		if (timer != null) {
			return timer.time();
		}

		return null;
	}

	@Autowired(required = false)
	public void setMetricRegistry(MetricRegistry metricRegistry, EntityVOMapper entityVOMapper) {

		for (Class entityClass : entityVOMapper.getEntityClasses()) {
			createTimers.put(entityClass, metricRegistry.timer(name(entityClass, CREATE_METRIC_KEY)));
			saveTimers.put(entityClass, metricRegistry.timer(name(entityClass, SAVE_METRIC_KEY)));
			readTimers.put(entityClass, metricRegistry.timer(name(entityClass, READ_METRIC_KEY)));
		}

	}

	private  Iterable> getEntityCallbacks(T entity) {
		if (entityCallbacks.get(entity.getClass()) == null) {
			entityCallbacks.put(entity.getClass(), new ArrayList>());
		}

		return entityCallbacks.get(entity.getClass());
	}

	private  Iterable> getCallbacks(T entity) {
		return Iterables.concat(genericCallbacks, getEntityCallbacks(entity));
	}

	private  void fireOnDeleteCallbacks(T entity) {
		for (IDAOCallback daoCallback : getCallbacks(entity)) {
			daoCallback.onDelete(entity);
		}
	}

	private  void fireOnCreateCallbacks(T entity) {
		for (IDAOCallback daoCallback : getCallbacks(entity)) {
			daoCallback.onCreate(entity);
		}
	}

	private  void fireNewInstanceCallbacks(T entity, Map properties) {
		for (IDAOCallback daoCallback : getCallbacks(entity)) {
			daoCallback.onNewInstance(entity, properties);
		}
	}

	@Override
	public void registerCallback(IDAOCallback callback) {
		genericCallbacks.add(callback);
	}

	@Override
	public  T getNewVO(String className, Map properties) {

		T result = null;
		
		IVOEntityDAO entityDAO = getVOEntityDAO(EntityVOMapper.getInstance().getEntityClass(className));

		if (entityDAO != null) {
			result = entityDAO.getNewEntity(className, properties);
		} else {
			result = baseEntityDAO.getNewVO(className, properties);
		}
		
		fireNewInstanceCallbacks(result, properties);
		
		return result;
	}
}