功能设计源码以及思路-字典篇

功能说明：在项目中，将一些简单的需要高频率的使用的字段加载在缓存中，减少与数据库的连接！
具体设计：
总体分为两块：
第一块是数据的加载：
1，首先是xml

<servlet>
<servlet-name>dhservlet</servlet-name>
<servlet-class>***.***.cache.servlet.DictionaryHelperServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

2然后是该指定类：
public class DictionaryHelperServlet extends HttpServlet{
/**
* 系统启动初始化加载字典缓存
*/
@Override
public void init() throws ServletException {
DictionaryHelper dictionaryHelper = new DictionaryHelper();
dictionaryHelper.joinCache();
}

@Override
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// TODO Auto-generated method stub
doPost(request, response);
}
}

3然后在调用数据库中的数据存入缓存中
public class DictionaryHelper {
private int t = 0;
/**
* 加入缓存
*/
public void joinCache(){
Map map = getDictCacheMap();
LoginCache.put(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER, map, 3600);
}

public static String toJson(String dictId){
DictionaryHelper dh = new DictionaryHelper();
return StringUtil.getSelectJson(dh.getDictById(dictId), false);
}

/**
* 重新封装字典
* @return
*/
private Map getDictCacheMap(){
Map<String,List<DictDataInfo>> retMap = new HashMap<String, List<DictDataInfo>>();
List<DictManagerInfo> dmList = getDictionaryHelper();
List<DictDataInfo> ddList = getDictInfoList();
if(dmList != null){
List<DictDataInfo> retList = null;
for (int i = 0; i < dmList.size(); i++) {
DictManagerInfo managerInfo = dmList.get(i);
for(int j = 0; j < ddList.size(); j++){
DictDataInfo dataInfo = ddList.get(j);
if(managerInfo.getDict_code().equals(dataInfo.getDict_code())){
retList = retMap.get(managerInfo.getDict_code());
if(retList == null){
retList = new ArrayList<DictDataInfo>();
}
retList.add(dataInfo);
System.out.println("a"+managerInfo.getDict_code());
retMap.put(managerInfo.getDict_code(), retList);
}
}
}
}
return retMap;
}

/**
* 取所有父字典信息
* @return
*/
private List<DictManagerInfo> getDictionaryHelper(){
CompService com = BaseDAOFactory.getCompService();
Map dictmap = (Map)com.invoke("DictManagerData", "getDictManagerLists");
String rnt = "";
if(dictmap!=null){
rnt = StringUtil.toString(dictmap.get("rnt"));
}
List<DictManagerInfo> list = null;
if("1".equals(rnt)){
list = (List<DictManagerInfo>) dictmap.get("dmList");
}
return list;
}

/**
* 取所有子字典信息
* @return
*/
private List<DictDataInfo> getDictInfoList(){
CompService com = BaseDAOFactory.getCompService();
Map dictmap = (Map)com.invoke("DictManagerData", "getAllDictDataInfo");
String rnt = "";
if(dictmap!=null){
rnt = StringUtil.toString(dictmap.get("rnt"));
}
List<DictDataInfo> list = null;
if("1".equals(rnt)){
list = (List<DictDataInfo>) dictmap.get("ddList");
}
return list;

}

/**
* 取字典缓存
* @return
*/
private Map getDictCacheList(){
Map dictmap = (Map) LoginCache.get(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER);
if(dictmap == null){
joinCache();
t ++;
if(t < 3){
return getDictCacheList();
}
}

return dictmap;
}

/**
* 查询指定表的信息，返回的两列数据作为菜单的optionValue 和optionText
* @param tableTag 要查询的表的别名
* @param optionValue optionValue的列名
* @param optionText optionText的列名
* @param filterSql 其他约束条件 缺省值是“1=1”
* @return
*/
public List<CustomDictInfo> getCustonDict(String tableTag,String optionValue,String optionText,String filterSql){
List<CustomDictInfo> list = null;

if(tableTag!=null && !"".equals(tableTag)){
if(filterSql==null || "".equals(filterSql)){
filterSql = " 1=1 ";
}
CompService com = BaseDAOFactory.getCompService();
com.addParameter(tableTag);
com.addParameter(optionValue);
com.addParameter(optionText);
com.addParameter(filterSql);
Map dictmap = (Map)com.invoke("DictionaryHelperData", "getCustomDictList");

String rnt = "";
if(dictmap!=null){
rnt = StringUtil.toString(dictmap.get("rnt"));
}
if("1".equals(rnt)){
list = (List<CustomDictInfo>) dictmap.get("cdList");
}
}

return list;
}

/**
* 根据父字典ID查询子项列表
* @param dictId
* @return
*/
public List<DictDataInfo> getDictById(String dictId){
Map dictmap = getDictCacheList();
List<DictDataInfo> dataInfos = (List<DictDataInfo>) dictmap.get(dictId);
return dataInfos;
}

/**
* 根据父字典ID和子字典ID查询文本内容
* @param dictId
* @param id
* @return
*/
public String getDictTextById(String dictId,String id){
Map dictmap = getDictCacheList();
List<DictDataInfo> dataInfos = (List<DictDataInfo>) dictmap.get(dictId);
String text = "";
if(dataInfos != null){
for (int i = 0; i < dataInfos.size(); i++) {
DictDataInfo dataInfo = dataInfos.get(i);
if(id.equals(dataInfo.getDict_small_code())){
text = dataInfo.getDict_text();
break;
}
}
}
return text;
}

/**
* 根据父字典ID和子字典文本内容查询子字典ID
* @param dictId
* @param id
* @return
*/
public String getDictIdByText(String dictId,String text){
Map dictmap = getDictCacheList();
List<DictDataInfo> dataInfos = (List<DictDataInfo>) dictmap.get(dictId);
String id = "";
if(dataInfos != null){
for (int i = 0; i < dataInfos.size(); i++) {
DictDataInfo dataInfo = dataInfos.get(i);
if(text.equals(dataInfo.getDict_text())){
id = dataInfo.getDict_code();
break;
}
}
}
return id;
}
/**
* 加入缓存
* @return
*/
public void setDictInfo(DictDataInfo dataInfo){
if(dataInfo != null){
Map dictmap = getDictCacheList();
String dictid = dataInfo.getParient_id();
String id = dataInfo.getDict_code();
List<DictDataInfo> dataInfos = (List<DictDataInfo>) dictmap.get(dictid);
if(dataInfos != null){
boolean b = true;
for (int i = 0; i < dataInfos.size(); i++) {
DictDataInfo info = dataInfos.get(i);
if(id.equals(info.getDict_code())){
b = false;
break;
}
}
if(b){
dataInfos.add(dataInfo);
}
LoginCache.remove(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER);
LoginCache.put(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER, dictmap, 3600);
}
}
}

/**
* 修改缓存字典内容
* @param dataInfo
*/
public void modifyDictInfo(DictDataInfo dataInfo){
if(dataInfo != null){
Map dictmap = getDictCacheList();
String dictid = dataInfo.getParient_id();
String id = dataInfo.getDict_code();
List<DictDataInfo> dataInfos = (List<DictDataInfo>) dictmap.get(dictid);
if(dataInfos != null){
boolean b = false;
for (int i = 0; i < dataInfos.size(); i++) {
DictDataInfo info = dataInfos.get(i);
if(id.equals(info.getDict_code())){
dataInfos.remove(i);
b = true;
break;
}
}
if(b){
dataInfos.add(dataInfo);
}
LoginCache.remove(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER);
LoginCache.put(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER, dictmap, 3600);
}
}
}

/**
* 删除缓存字典内容
* @param dataInfo
*/
public void removeDictInfo(String dict_id,String id){
if(dict_id != null && !"".equals(dict_id) && id != null && !"".equals(id)){
Map dictmap = getDictCacheList();
List<DictDataInfo> dataInfos = (List<DictDataInfo>) dictmap.get(dict_id);
if(dataInfos != null){
for (int i = 0; i < dataInfos.size(); i++) {
DictDataInfo info = dataInfos.get(i);
if(id.equals(info.getDict_code())){
dataInfos.remove(i);
break;
}
}
LoginCache.remove(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER);
LoginCache.put(LoginConfig.USER_DICTIONARY_HELPER, LoginConfig.DICTIONARY_HELPER, dictmap, 3600);
}
}
}

public static void main(String[] args) {
DictionaryHelper dh = new DictionaryHelper();
DictDataInfo dataInfo = new DictDataInfo();
dataInfo.setParient_id("anticoagulant");
dataInfo.setDict_text("sssssssssssssssssss");
dataInfo.setDict_code("sda");
dh.setDictInfo(dataInfo);

List<DictDataInfo> list = dh.getDictById("anticoagulant");
for (int i = 0; i < list.size(); i++) {
DictDataInfo d = list.get(i);
System.out.println(d.getDict_text());
}

String text = dh.getDictIdByText("anticoagulant", "无肝素");
System.out.println("text:"+text);

String id = dh.getDictTextById("sys_sex", "1");
System.out.println("id:"+id);
}
}

public class LoginCache {
private static CacheManager singleton = CacheManager.getInstance();
/**
* 存入缓存
* @param cacheName 主缓存名称
* @param key 子缓存主键名称
* @param value 需要缓存的数据
* @param timeToIdleSeconds 缓存时间
*/
public static synchronized void put(String cacheName, Object key, Object value, int timeToIdleSeconds){
Cache cache = null;
if(StringHelper.isEmpty(cacheName)){
return;
}
if(key == null){
return;
}
if(!singleton.cacheExists(cacheName)){
singleton.addCache(cacheName);
cache = singleton.getCache(cacheName);
}
cache = singleton.getCache(cacheName);

Element e = new Element(key, value);
e.setTimeToIdle(timeToIdleSeconds);
cache.put(e);

}

/**
* 根据主键缓存获取全部缓存内容
* @param cacheName 主键
* @return
*/
public static synchronized List<Map> getAllUserMessage(String cacheName){
List<Map> userlist = null;
try{
Cache cache = null;
if(StringHelper.isEmpty(cacheName)){
return userlist;
}
if(!singleton.cacheExists(cacheName))
return null;
cache = singleton.getCache(cacheName);
List list = cache.getKeys();
if(list != null && list.size() > 0){
userlist = new ArrayList<Map>();
int s = list.size();
for (int j = 0; j < s; j++) {
String key = (String)list.get(j);
Element e = cache.get(key);
if(e != null){
Map user = (Map)e.getObjectValue();
if(user != null)
userlist.add(user);
}
}

}
}catch(Exception e){
e.printStackTrace();
}
return userlist;
}

/**
* 删除子项缓存
* @param cachename 主键缓存名称
* @param key 子项缓存名称
*/
public static synchronized void remove(String cachename, Object key){
try{
if(StringHelper.isEmpty(cachename)){
return;
}
if(!singleton.cacheExists(cachename)){
return;
}
Cache cache = singleton.getCache(cachename);
cache.remove(key);
}catch(Exception e){
e.printStackTrace();
}
}

/**
* 获取缓存
* @param cachename 主键缓存名称
* @param key 子项缓存名称
* @return
*/
public static Object get(String cachename,Object key){
Object o = null;
if(!singleton.cacheExists(cachename)){
return o;
}
Cache cache = singleton.getCache(cachename);
if(!cache.isKeyInCache(key)){
return o;
}
Element e = cache.get(key);
if(e != null)
o = e.getObjectValue();
return o;
}

/**
* 获取缓存子项
* @param cachename 主键缓存名称
* @return
*/
public static Ehcache getCache(String cachename){
Cache cache = null;
if(!singleton.cacheExists(cachename)){
return cache;
}
cache = singleton.getCache(cachename);
return cache;
}
}

4在项目应用中，调用该类的changeDictValWithBeanList()方法，将数据库中的比如（1,2，3等数字）转化成对应的字典数据

/**
* 测试处理Bean多列字典的问题
* @author DongChao
*
*/
public class DictionaryUtil {

/**
* 依次将beanList中的项目（beanParams）用指定的字典（dictNames）替换
* beanParams 的顺序要和dictNames一致
* @param beanList
* @param beanParams
* @param dictNames
* @return
*/
public static List changeDictValWithBeanList(List beanList,String [] beanParams,String[] dictNames){

DictionaryHelper dh = new DictionaryHelper();

if(beanList!=null && beanList.size()>0){// 入股list为空，无法处理，原样返回list

if(beanParams==null){//如果参数名为空则无法处理，原样返回list
return beanList;
}if(dictNames==null){//如果字典为空则无法处理，原样返回list
return beanList;
}
if(beanParams.length!=dictNames.length){//bean的内容和字典数量不匹配则无法处理，原样返回list
return beanList;
}

HashMap paramsAndDicts = StringArrToHashMap(beanParams,dictNames);

for(int i=0;i<beanList.size();i++){
Object bean = beanList.get(i);
PropertyDescriptor[] props = null;
try {
props = Introspector.getBeanInfo(bean.getClass(), Object.class).getPropertyDescriptors();
} catch (IntrospectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

if (props != null) {

for(int j=0;j<props.length;j++){
String name = props[j].getName();//bean中的成员变量的名字
//Arrays.sort(beanParams);
String dictName = (String)paramsAndDicts.get(name);

if(dictName!=null && !"".equals(dictName)){

//取出原始值
try {
String oriaValue = props[j].getReadMethod().invoke(bean).toString() ;

//将value转换成字典的文本值
//System.out.println(dictName+"=="+oriaValue);
String dictText=dh.getDictTextById(dictName, oriaValue);
//将转换后的文本写会到Bean中
Method methodSet=props[j].getWriteMethod();
methodSet.invoke(bean, dictText);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

}

}
}

return beanList;
}

private static HashMap StringArrToHashMap(String [] beanParams,String[] dictNames){
HashMap map = new HashMap();
for(int i=0;i<beanParams.length;i++){
map.put(beanParams[i], dictNames[i]);
}
return map ;
}

}

5.实际的调用的例子：
DictionaryUtil dt = new DictionaryUtil();
String []beanParams = new String []{"sex","blood_type","rh_blood_type","charge_type","insurance_type","patient_state"};
String []dictNames = new String []{"sys_sex","sys_blood_type","sys_rh_blood_type","sys_charge_type","sys_insurance_type","sys_patient_state"};
list = dt.changeDictValWithBeanList(list, beanParams, dictNames);//获取缓存中对应的数据值
DictionaryHelper dh = new DictionaryHelper();