SpringMVC,Ajax集成的后台基础字典信息的通用方法设计

两三年前曾经写过相似的通用方法，后来由于工作忙碌的原因，没有进行后续维护和改进，近来处来项目空闲期，回顾一遍后发现之前的方法过于依赖ExtJS与struts2，耦合性高，并且重用性也不好，对于目前流行的springMVC与Ajax也不能重写或修改，所以这里我决定基于原先的设计思路重新设计出了一套基于springMVC与Ajax的数据字典信息的通用方法。

数据字典，即我们所说的最基本的字典表，该对象仅仅包含id，name两个属性，是最基础的对象。下面就用具体的代码展现设计的通用方法，我也很希望各位技术牛人能在看完后给予我建议或意见，毕竟我仅仅只有两年的工作经验。

1.controller层

该层属于模板层，我用静态属性变量的方式使之成为一种模板，开发时，根据特定的项目约定和规则修改静态变量。

package com.java.controller;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import com.java.business.DictionaryObjectBus;
import com.java.tool.Page;

/**
* 此类用于数据字典表的通用复制粘贴类，
* @author liuyuqin
* @date 2015年2月3日10:01:37
* 说明：
* ①：该方法中包含了分页对象page，所以使用该类时，需要导入page分页对象，如果不使用分页对象Page，则需对遍历方法进行重写
* ②：字典数据对象的id和name的数据类型都是String类型，否则，需要修改添加，修改，删除的字段数据类型
* ③：msg信息包含了操作的返回信息，如果成功，即为SUCCESS，如果失败，会返回String类型的详细信息，前台打印详细信息即可
* ④：遍历和查找对象方法涉及到页面跳转，使用了springMVC的ModelAndView对象
* 	   添加和修改方法没有涉及页面跳转，使用了传统的ajax
*/
@Controller
public class DictionaryObjectController {
private static final Log log = LogFactory
.getLog(DictionaryObjectController.class);

/**类相关信息**/
//输入类对象位置
private static final String OBJECTNAME = "首字母大写的对象名称，例如Xxxx";
//输入类对象包全名
private static final String OBJECTFULLNAME = "包含包名在内的对象全称，例如com.java.bean.XXX";
/*以下是测试用例
private static final String OBJECTNAME = "Dictionary";
private static final String OBJECTFULLNAME = "com.java.bean.Dictionary";
*/

/**requestMapping路径位置**/

private static final String QUERY_REQUESTMAPPING = "Query方法中的requestMapping路径";
private static final String INSERT_REQUESTMAPPING = "Insert方法中的requestMapping路径";
private static final String UPDATE_REQUESTMAPPING = "Update方法中的requestMapping路径";
private static final String FINDBYID_REQUESTMAPPING = "FindById方法中的requestMapping路径";
private static final String DELETE_REQUESTMAPPING = "Delete方法中的requestMapping路径";
private static final String DELETE_BATCH_REQUESTMAPPING = "批量Delete方法中的requestMapping路径";
/*以下是测试用例
private static final String QUERY_REQUESTMAPPING = "admin/dictionary/queryDictionaryObject";
private static final String INSERT_REQUESTMAPPING = "admin/dictionary/insertDictionaryObject";
private static final String UPDATE_REQUESTMAPPING = "admin/dictionary/updateDictionaryObject";
private static final String FINDBYID_REQUESTMAPPING = "admin/dictionary/findDictionaryObjectById";
private static final String DELETE_REQUESTMAPPING = "admin/dictionary/deleteDictionaryObject";
private static final String DELETE_BATCH_REQUESTMAPPING = "admin/dictionary/deleteBatchDictionaryObject";
*/

/**输入跳转url页面位置**/

private static final String QUERY_RETURN_VIEW = "Query方法中返回的跳转url页面";
private static final String FINDBYID_RETURN_VIEW = "FindById方法中返回的跳转url页面";
/*以下是测试用例
private static final String FINDBYID_RETURN_VIEW = "admin/dictionary/dictionaryEdit";
private static final String QUERY_RETURN_VIEW = "admin/dictionary/dictionaryList";
*/

/**输出传输参数**/
private static final String QUERY_RETURN_LIST="Query方法中返回的传输对象List集合";
private static final String FINDBYID_RETURN_OBJECT="FindById方法中返回的传输对象";
/*以下是测试用例
private static final String FINDBYID_RETURN_OBJECT="dictionary";
private static final String QUERY_RETURN_LIST="dictionaryList";
*/

/**输入传输参数**/
private static final String OBJECTID="FindById方法中需要传入的参数";
/*以下是测试用例
private static final String OBJECTID="dictionaryId";
*/

@Autowired
private DictionaryObjectBus dictionaryObjectBus;

/**
* 分页遍历列表显示
* @param page
*/
@RequestMapping(value = QUERY_REQUESTMAPPING)
public ModelAndView queryDictionaryObject(Page page) throws Exception {
ModelAndView mav = new ModelAndView();
Map<String , Object> map = new HashMap<String, Object>();
map = dictionaryObjectBus.queryDictionaryObject(page,OBJECTNAME);
mav.setViewName(QUERY_RETURN_VIEW);
mav.addObject(QUERY_RETURN_LIST,map.get("list"));
mav.addObject("page", map.get("page"));
return mav;
}

/**
* 添加对象
* @param object
* @param session
* @param response
* @throws Exception
*/
@RequestMapping(value = INSERT_REQUESTMAPPING)
public void insertDictionaryObject(String name,HttpSession session,HttpServletResponse response) throws Exception {
JSONObject obj = new JSONObject();
PrintWriter out = null;
String msg = "";
try{
out = response.getWriter();
msg = dictionaryObjectBus.insertDictionaryByCheckRepeatYES(name,OBJECTNAME,OBJECTFULLNAME);
obj.put("msg", msg);
out.print(obj);
}catch (Exception e) {
e.printStackTrace();
}
finally{
out.close();
}
}

/**
* 修改对象
* @param object
* @param session
* @param response
* @throws Exception
*/
@RequestMapping(value = UPDATE_REQUESTMAPPING)
public void updateDictionaryObject(String id,String name,HttpSession session,HttpServletResponse response) throws Exception {
JSONObject obj = new JSONObject();
PrintWriter out = null;
String msg = "";
try{
out = response.getWriter();
msg = dictionaryObjectBus.updateDictionaryObject(id,name,OBJECTNAME,OBJECTFULLNAME);
obj.put("msg", msg);
out.print(obj);
}catch (Exception e){
e.printStackTrace();
}
finally{
out.close();
}
}

/**
* 通过对象ID查找对象集合
* @param object
* @throws Exception
*/
@RequestMapping(value =FINDBYID_REQUESTMAPPING)
public ModelAndView findDictionaryObjectById(
@RequestParam(OBJECTID) String objectId) throws Exception {
ModelAndView mav = new ModelAndView();
Object obj =  dictionaryObjectBus.findDictionaryObjectById(objectId,OBJECTNAME);
mav.setViewName(FINDBYID_RETURN_VIEW);
mav.addObject(FINDBYID_RETURN_OBJECT, obj);
return mav;
}

/**
* 删除对象（单个删除）
* @param OBJECTID
*/
@RequestMapping(value = DELETE_REQUESTMAPPING)
public void deleteDictionaryObject(@RequestParam(OBJECTID) String objectId,
HttpServletResponse response) throws Exception {
PrintWriter out = null;
String msg = "";
try{
out = response.getWriter();
msg = dictionaryObjectBus.deleteDictionaryObject(objectId,OBJECTNAME);
out.print(msg);
}catch (Exception e) {
e.printStackTrace();
}
finally{
out.close();
}
}

/**
* 删除商品分类（批量删除）
* @param idArray
*/
@RequestMapping(value = DELETE_BATCH_REQUESTMAPPING)
public void deleteBatchDictionaryObject(
String idArray,HttpServletResponse response){
PrintWriter out = null;
String msg = "";
try{
out = response.getWriter();
msg = dictionaryObjectBus.deleteDictionaryObject(idArray,OBJECTNAME);
out.print(msg);
}catch (Exception e) {
e.printStackTrace();
}
finally{
out.close();
}
}
}

2.business层

business层是此设计模式的重点java方法，该方法利用反射的设计思路写了一套通用方法

package com.java.business;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.java.dao.DictionaryObjectDao;
import com.java.tool.Page;

/**
* 字典信息通用CRUD方法，适用于id name两个字段的字典数据的CRUD
* @author liuyuqin
* @date 2015年2月3日14:14:27
*
*/
@Service("dictionaryObjectBus")
public class DictionaryObjectBus {

@Resource
private DictionaryObjectDao dictionaryObjectDao;

private static final Logger log = LoggerFactory.getLogger("dictionaryObjectLog");

/**
* 添加字典表信息（加入名称验证重复性验证）
* <字典表结构 必须是 name value属性设置，即键值对设置>
* @return
* @throws Exception
*/
public String insertDictionaryByCheckRepeatYES(String objectName,String OBJECTNAME,String OBJECTFULLNAME) throws Exception{
Object o = null;
Class object  = Class.forName(OBJECTFULLNAME);
//创建动态对象实例
o = object.newInstance();
//通过字典表信息名称查询是否已经存在该字典表信息，如果存在返回重复信息，不存在则进行添加
List<Object> dictionaryObjectList = (List<Object>) dictionaryObjectDao.findSpecificByName(objectName,OBJECTNAME);
//判断添加的对象的属性名称是否与数据库已有数据名称重名
if(dictionaryObjectList.size() == 0){
try {
//将名称值传入
Method tAge = object.getMethod("setName", String.class);
tAge.invoke(o, objectName);
dictionaryObjectDao.save(o);
} catch (Exception e) {
e.printStackTrace();
}
return "SUCCESS";
}
else
return "输入的名称已存在，请重新输入";
}

/**
* 添加字典表信息（不加入名称验证重复性验证）
*  <字典表结构 必须是 name value属性设置，即键值对设置>
* @return
* @throws Exception
*/
public String insertDictionaryByCheckRepeatNO(String objectName,String OBJECTNAME,String OBJECTFULLNAME) throws Exception{
Object o = null;
Class object  = Class.forName(OBJECTFULLNAME);
//创建动态对象实例
o = object.newInstance();
try {
//将名称值传入
Method tAge = object.getMethod("setName", String.class);
tAge.invoke(o, objectName);
dictionaryObjectDao.save(o);
} catch (Exception e) {
e.printStackTrace();
}
return "SUCCESS";
}

/**
* 修改字典表对象信息
* @param Object
* @return
*/
public String updateDictionaryObject(String id,String name,String OBJECTNAME,String OBJECTFULLNAME) throws Exception{
List<Object> dictionaryObjectList = (List<Object>) dictionaryObjectDao.findOtherSpecificByIdAndName(id,name,OBJECTNAME);
if(dictionaryObjectList.size() >0){
return "输入的名称已存在，请重新输入";
}
else{
Object obb = dictionaryObjectDao.findSpecificById(id, OBJECTNAME);
Class c = obb.getClass();
Method sAge = c.getMethod("setName", String.class);
sAge.invoke(obb, name);
//log.info(LogHelper.userLog("update class<"+className+">["+dictionaryObjectName+"]"));
return "SUCCESS";
}
}

/**  删除字典表某条信息（支持多条删除）
* @throws Exception
*/
public String deleteDictionaryObject(String delData,String className) throws Exception{
String[] ids = delData.split(",");
String objectName ="";
for (int i = 0; i < ids.length; i++) {
Object object =dictionaryObjectDao.findSpecificById(ids[i], className);
dictionaryObjectDao.delete(object);
if(objectName.equals("")){
objectName += ids[i] ;
}
else
objectName += "," + ids[i] ;
}
//log.info(LogHelper.userLog("delete class<"+className+">["+objectName+"]"));
return "SUCCESS";
}

/**
* 分页显示所有字典表信息
* @throws Exception
* @return
*/
public Map<String, Object> queryDictionaryObject(Page page,String className){
return dictionaryObjectDao.queryDictionaryObject(page,className);
}

/**
* 根据字典表对象Id找到相应对象
* @return
*/
public Object findDictionaryObjectById(String objectId,String className) throws Exception{
return dictionaryObjectDao.findSpecificById(objectId,className);
}
}

3,dao层

dao层也为通用方法

package com.java.dao;

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

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

import com.java.tool.Page;

/**
* A data access object (DAO) providing persistence and search support for Role
* entities. Transaction control of the save(), update() and delete() operations
* can directly support Spring container-managed transactions or they can be
* augmented to handle user-managed Spring transactions. Each of these methods
* provides additional information for how to configure it for the desired type
* of transaction control.
*
* @see com.donglusoft.rightmanagerment.domain.Role
* @author MyEclipse Persistence Tools
*/

/**
* 字典信息通用CRUD方法，适用于id name两个字段的字典数据的CRUD
* @author liuyuqin
* @date 2015年2月3日14:14:27
*
*/
@Repository("dictionaryObjectDao")
public class DictionaryObjectDao extends EntityDaoImpl {
private static final Logger log = LoggerFactory.getLogger(DictionaryObjectDao.class);

/**********************自定义方法（↓）****************************/
/**
*  通过Id查找特定的对象
*/
public Object findSpecificById(String dictionaryObjectId,String className){
try{
String queryString = "from " + className + " as t where " +
"t.id=:dictionaryObjectId";
Query query = getSession().createQuery(queryString);
query.setString("dictionaryObjectId", dictionaryObjectId);
return query.uniqueResult();
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}

/**
*  通过name查找特定的对象
*/
public List<Object> findSpecificByName(String dictionaryObjectName,String className){
try{
String queryString = "from "+className +" as t where t.name =:name";
Query query = getSession().createQuery(queryString);
query.setString("name", dictionaryObjectName);
return query.list();
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}

/**
*  通过name查找特定的id不是dictionaryObjectId的对象
*/
public List findOtherSpecificByIdAndName(String dictionaryObjectId,String dictionaryObjectName,String className){
try{
String queryString = "from "+className +" as t where t.name =:name and t.id<>:id ";
Query query = getSession().createQuery(queryString);
query.setString("name", dictionaryObjectName);
query.setString("id", dictionaryObjectId);
return query.list();
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}

/**
* 遍历所有可用的DictionaryObject对象
* @param page
* @param className
* @return
*/
public Map<String, Object> queryDictionaryObject(Page page , String className){
Map<String, Object> map = new HashMap<String, Object>();
try {
String queryString = "from " +className;
String countString = "select count(*) from " +className;
Query query = getSession().createQuery(queryString);
Query countquery = getSession().createQuery(countString);
query.setFirstResult(page.getPageNo() * page.getPageLines());
query.setMaxResults(page.getPageLines());
int totalRows = Integer.parseInt(countquery.uniqueResult().toString());
page.setTotalPages(totalRows, page.getPageLines());
map.put("list", query.list());
map.put("page", page);
return map;
} catch (HibernateException e) {
throw e;
}
}

/**********************自定义方法（↑）****************************/

public void save(Object transientInstance) {
log.debug("saving Object instance");
try {
getSession().save(transientInstance);
log.debug("save successful");
} catch (RuntimeException re) {
log.error("save failed", re);
throw re;
}
}

public void delete(Object persistentInstance) {
log.debug("deleting Object instance");
try {
getSession().delete(persistentInstance);
log.debug("delete successful");
} catch (RuntimeException re) {
log.error("delete failed", re);
throw re;
}
}
}

前台利用表单提交insert与update，其他使用ajax提交即可

最后还有Page分页对象，javaBean如下

package com.java.tool;

public class Page {

private int totalRows; // 总记录数

private int pageLines; // 每页显示行数

private int pageNo; // 当前页数

private int totalPages; // 总页数

public Page() {
totalRows = 0;
pageLines = 10;
pageNo = 0;
totalPages = 1;
}

public int getTotalRows() {
return totalRows;
}

public void setTotalRows(int totalRows) {
if (totalRows >= 0)
this.totalRows = totalRows;
}

public int getPageLines() {
return pageLines;
}

public void setPageLines(int pageLines) {
if (pageLines > 0)
this.pageLines = pageLines;
}

public void setPageLines(String pageLines) {
if (pageLines == null || pageLines.length() == 0
|| pageLines.equals("0")) {
this.pageLines = 50;
} else {
this.pageLines = Integer.parseInt(pageLines);
}
}

public int getPageNo() {
return pageNo;
}

public void setPageNo(int pageNo) {
//		if (pageNo > 0)
this.pageNo = pageNo;
}

public void setPageNo(String pageNo) {
//		if (pageNo == null || pageNo.length() == 0) {
//			this.pageNo = 1;
//		} else {
this.pageNo = Integer.parseInt(pageNo);
//		}
}

public int getTotalPages() {
return totalPages;
}

// 总页数 记录数和每页记录数
public void setTotalPages(int totalRows, int pageLines) {
this.totalRows = totalRows;
if (pageLines > 0)
this.pageLines = pageLines;
if (pageLines > 0)
this.totalPages = totalRows % pageLines == 0 ? totalRows
/ pageLines : totalRows / pageLines + 1;
}

public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}

public void validateData() {
if (this.pageNo > this.totalPages)
this.pageNo = this.totalPages;
if (this.pageNo <= 0)
this.pageNo = 1;
if (this.pageLines <= 0)
this.pageLines = 10;
}
}