com.weicoder.frame.service.SuperService Maven / Gradle / Ivy

package com.weicoder.frame.service;

import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import com.weicoder.frame.cache.Cache;
import com.weicoder.frame.cache.impl.CacheEmpty;
import com.weicoder.frame.context.Context;
import com.weicoder.frame.dao.Dao;
import com.weicoder.frame.entity.Entity;
import com.weicoder.frame.bean.Pagination;
import com.weicoder.common.lang.Conversion;
import com.weicoder.common.lang.Lists;
import com.weicoder.common.lang.Maps;
import com.weicoder.common.util.BeanUtil;
import com.weicoder.common.util.EmptyUtil;

/**
 * 超级通用业务hibernate实现
 * @author WD
 * @since JDK7
 * @version 1.0 2012-07-02
 */
@Service
public class SuperService {
	// Context
	@Resource
	private Context															context;
	// Hibernate Dao
	@Resource
	private Dao																dao;
	// 缓存
	private ConcurrentMap, Cache>	caches;
	// 缓存加载
	private ConcurrentMap, Boolean>					loads;
	// 空缓存
	private Cache											empty;

	/**
	 * 初始化
	 */
	@SuppressWarnings("unchecked")
	@PostConstruct
	protected void init() {
		// 获得所有带缓存实体
		Map map = context.getBeansWithAnnotation(com.weicoder.frame.annotation.Cache.class);
		// 实例化缓存
		caches = Maps.getConcurrentMap();
		// 实例化缓存加载
		loads = Maps.getConcurrentMap();
		// 实例化空缓存
		empty = new CacheEmpty();
		// 循环赋值
		for (Map.Entry e : map.entrySet()) {
			// 声明Class
			Class c = (Class) e.getValue().getClass();
			// 声明cached
			Cache cache = context.getCache();
			cache.setClass(c);
			// 设置有缓存的实体Map
			caches.put(c, cache);
			loads.put(c, false);
		}
	}

	/**
	 * 添加
	 * @param entity 实体
	 * @return ID
	 */
	public  E insert(E entity) {
		return getCache(entity).set(dao.insert(entity));
	}

	/**
	 * 添加
	 * @param entitys 实体
	 * @return ID
	 */
	public  List insert(List entitys) {
		return getCache(entitys).set(dao.insert(entitys));
	}

	/**
	 * 更新
	 * @param entity 实体
	 * @return 是否成功
	 */
	public  E update(E entity) {
		return getCache(entity).set(dao.update(entity));
	}

	/**
	 * 更新
	 * @param entitys 实体
	 * @return 是否成功
	 */
	public  List update(List entitys) {
		return getCache(entitys).set(dao.update(entitys));
	}

	/**
	 * 添加或更新
	 * @param entitys 实体
	 * @return 影响行数
	 */
	public  E insertOrUpdate(E entity) {
		return getCache(entity).set(dao.insertOrUpdate(entity));
	}

	/**
	 * 添加或更新
	 * @param entitys 实体
	 * @return 影响行数
	 */
	public  List insertOrUpdate(List entitys) {
		return getCache(entitys).set(dao.insertOrUpdate(entitys));
	}

	/**
	 * 删除
	 * @param list 实体列表
	 * @return 是否成功
	 */
	public  List delete(E entity) {
		// 查询出符合删除实体列表
		List list = list(entity, -1, -1);
		// 删除列表为空
		if (EmptyUtil.isEmpty(list)) {
			return Lists.emptyList();
		}
		// 删除
		list = dao.delete(list);
		// 返回结果
		return isCache(entity.getClass()) ? getCache(entity).remove(list) : list;
	}

	/**
	 * 删除
	 * @param list 实体列表
	 * @return 是否成功
	 */
	public  List delete(List entitys) {
		// 删除
		List list = dao.delete(entitys);
		// 返回结果
		return isCache(entitys.get(0).getClass()) ? getCache(entitys).remove(list) : list;
	}

	/**
	 * 根据ID数组删除 完全删除
	 * @param entity 要查询的实体
	 * @param pk 主键数组
	 * @return 是否成功
	 */
	public  List delete(Class entity, Serializable... pks) {
		return delete(gets(entity, pks));
	}

	/**
	 * 根据ID 获得实体
	 * @param entityClass 要查询的实体
	 * @param pk 主键
	 * @return 实体
	 */
	public  E get(Class entityClass, Serializable pk) {
		pk = key(pk);
		// 获得缓存
		Cache cache = getCache(entityClass);
		// 返回查询结果
		return cache.isValid() ? cache.get(pk) : dao.get(entityClass, pk);
	}

	/**
	 * 根据ID 获得实体
	 * @param entityClass 要查询的实体
	 * @param pk 主键
	 * @return 实体
	 */
	public  List gets(Class entityClass, Serializable... pks) {
		// 如果主键为空
		if (EmptyUtil.isEmpty(pks)) {
			return Lists.emptyList();
		}
		// 转换主键
		pks = keys(pks);
		// 获得缓存
		Cache cache = getCache(entityClass);
		// 缓存存在
		if (cache.isValid()) {
			// 声明列表
			List list = Lists.getList();
			// 循环赋值
			for (Serializable pk : pks) {
				list.add(cache.get(key(pk)));
			}
			// 返回列表
			return list;
		} else {
			// 无缓存 返回查询结果
			return dao.gets(entityClass, pks);
		}
	}

	/**
	 * 根据传入的条件，返回唯一的实体 如果有多个返回第一个实体
	 * @param entity 实体,
	 * @return 实体
	 */
	public  E get(E entity) {
		return dao.get(entity);
	}

	/**
	 * 获得持久化对象
	 * @param entityClass 要查询的实体
	 * @param property 属性名
	 * @param value 属性值
	 * @return 要获得的持久化对象，如果不存在返回null
	 */
	public  E get(Class entityClass, String property, Object value) {
		return dao.get(entityClass, property, value);
	}

	/**
	 * 获得持久化对象
	 * @param entityClass 实体类
	 * @param map 属性键值
	 * @return 要获得的持久化对象，如果不存在返回null
	 */
	public  E get(Class entityClass, Map map) {
		return dao.get(entityClass, map);
	}

	/**
	 * 查询全部数据
	 * @param entityClass 要查询的实体
	 * @return 全部实体
	 */
	public  List all(Class entityClass) {
		return list(entityClass, -1, -1);
	}

	/**
	 * 查询指定条数
	 * @param entityClass 要查询的实体
	 * @param firstResult 开始查询的条数
	 * @param maxResults 最多查询多少条
	 * @return 全部实体
	 */
	public  List list(Class entityClass, int firstResult, int maxResults) {
		// 获得缓存
		Cache cache = getCache(entityClass);
		// 判断有缓存
		if (cache.isValid()) {
			// 返回新列表
			return Lists.subList(cache.list(), firstResult, firstResult + maxResults);
		} else {
			// 查询数据库
			return toString(dao.list(entityClass, firstResult, maxResults));
		}
	}

	/**
	 * 获得查询的对象实体列表 分页功能
	 * @param entityClass 要查询的实体
	 * @param page 分页Bean
	 * @return 返回这个对象的列表
	 */
	public  List list(Class entityClass, Pagination page) {
		// 获得数据列表
		List list = list(entityClass, getFirstResult(page), getMaxResults(page));
		// 判断列表
		if (EmptyUtil.isEmpty(list)) {
			// 为空 设置总数为 0
			page.setTotalSize(0);
		} else {
			// 不为空 查询出总数
			page.setTotalSize(count(entityClass));
		}
		// 返回列表
		return list;
	}

	/**
	 * 根据实体查询
	 * @param entity 要查询的实体
	 * @param entity 实体
	 * @param firstResult 开始查询的条数
	 * @param maxResults 最多查询多少条
	 * @return 列表
	 */
	public  List list(E entity, int firstResult, int maxResults) {
		return dao.list(entity, firstResult, maxResults);
	}

	/**
	 * 获得查询的对象实体列表 分页功能
	 * @param entity 需要获得的对象，会查询出实体中封装的相等的条件
	 * @param page 分页Bean
	 * @return 返回这个对象的列表
	 */
	public  List list(E entity, Pagination page) {
		// 获得数据列表
		List list = list(entity, getFirstResult(page), getMaxResults(page));
		// 判断列表
		if (EmptyUtil.isEmpty(list)) {
			// 为空 设置总数为 0
			page.setTotalSize(0);
		} else {
			// 不为空 查询出总数
			page.setTotalSize(count(entity));
		}
		// 返回列表
		return list;
	}

	/**
	 * 查询属性名等值的实体列表
	 * @param entityClass 实体类
	 * @param property 属性名
	 * @param value 属性值
	 * @param firstResult 重第几条开始查询
	 * @param maxResults 一共查回多少条
	 * @return 数据列表
	 */
	public  List like(Class entityClass, String property, Object value, int firstResult, int maxResults) {
		return dao.like(entityClass, property, value, firstResult, maxResults);
	}

	/**
	 * 查询属性名含有列表的实体列表
	 * @param entityClass 要查询的实体
	 * @param map 键值表
	 * @param firstResult 重第几条开始查询
	 * @param maxResults 一共查回多少条
	 * @return 数据列表
	 */
	public  List eq(Class entityClass, Map map, int firstResult, int maxResults) {
		return dao.eq(entityClass, map, firstResult, maxResults);
	}

	/**
	 * 查询属性名等值的实体列表
	 * @param entityClass 要查询的实体
	 * @param property 属性名
	 * @param value 属性值
	 * @param firstResult 重第几条开始查询
	 * @param maxResults 一共查回多少条
	 * @return 数据列表
	 */
	public  List eq(Class entityClass, String property, Object value, int firstResult, int maxResults) {
		return dao.eq(entityClass, property, Conversion.to(value, BeanUtil.getField(entityClass, property).getType()), firstResult, maxResults);
	}

	/**
	 * 查询属性名等值的实体列表
	 * @param entityClass 要查询的实体
	 * @param property 属性名
	 * @param values 属性值
	 * @param pager 分页Bean
	 * @return 数据列表
	 */
	public  List in(Class entityClass, String property, List