Spring+SpringMVC企业快速开发架构搭建2-web端封装

使用SpringMVC进行开发，主要优势很多；我们主要看中的有以下几点：

1、代码量少

2、学习简单，与我们之前使用的框架风格相似

3、能够支持多种视图

为了将以上几点发挥的更好，我选择将web层的Controller进行封装，目的也很明确：为了让我们的开发人员使用起来更简单，封装工作分为三部分

1、请求参数处理、响应值处理

我们默认支持的视图是html，选择json作为前台到后台的数据传输格式，因此我们选择将请求参数封装为JSONRequest类，该类可以完成多参数、javaBean的转换；将返回值封装成JSONResponse类，该类包含返回值（可以是多个）、操作消息、是否操作成功等信息

1、JSONReqest类

package com.jl.net.framework.web;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.jdom.IllegalTargetException;

import com.alibaba.fastjson.JSONObject;
import com.jl.net.framework.util.DateUtils;
import com.jl.net.framework.util.JLAssertUtil;
import com.jl.net.framework.util.PageBean;

/**
 * <pre>
 * 功能： 用于封装用户的请求，将请求转换为相应的VO、VOList对象
 * </pre>
 * @author mrh
 * 2015年1月22日
 */
public class JSONRequest extends LinkedHashMap<String, Object>{
	/**
	 * 序列号
	 */
	private static final long serialVersionUID = -9005858241290023408L;

	/**
	 * LOGGER - log4j
	 */
	private static final Logger LOGGER = Logger.getLogger(JSONRequest .class);
	
	
	/**
	 * 根据Class获取对应的VO对象
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public <T> T getVO(Class<T> clazz, String voName) {
		if (!JLAssertUtil.hasValue(this.values())) {
			LOGGER.debug("the val is null");
			return null;
		}
		Object obj =  this.get(voName);
		if (obj instanceof Map) {
			Map<String, Object> map = (Map<String, Object>) this.get(voName);
			return this.getVOFormMap(clazz, map);
		} else {
			throw new IllegalTargetException(voName + "的目标值的数据类型不是" + clazz.getName() + "，请确认数据类型!");
		}
	}
	
	/**
	 * 根据Class获取对应的VO对象
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public <T> List<T> getVOList(Class<T> clazz, String listName) {
		if (!JLAssertUtil.hasValue(this.values())) {
			LOGGER.debug("the val is null");
			return null;
		}
		List<Map<String, Object>> list = (List<Map<String, Object>>)this.get(listName);
		if (!JLAssertUtil.hasValue(list)) {
			return null;
		}
		List<T> result = new ArrayList<T>();
		for (int index = 0; index < list.size(); index++) {
			result.add(this.getVOFormMap(clazz, list.get(index)));
		}
		return result;
	}
	
	/**
	 * 返回String类型的请求参数 
	 * @param parameter
	 * @return
	 */
	public String getString(String parameter) {
		if (!JLAssertUtil.hasValue(this.values())) {
			return null;
		}
		Object obj = this.get(parameter);
		if (!JLAssertUtil.hasValue(obj)) {
			return null;
		}
		if (!(obj instanceof String)) {
			throw new IllegalTargetException("目标值的数据类型不是String，请确认目标值的数据类型！");
		}
		return obj.toString(); 
	}
	
	/**
	 * 返回String类型的请求参数 
	 * @param parameter
	 * @return
	 */
	public int getInt(String parameter) {
		if (!JLAssertUtil.hasValue(this.values())) {
			return 0;
		}
		Object obj = this.get(parameter);
		if (!JLAssertUtil.hasValue(obj)) {
			return 0;
		}
		if (obj instanceof String) {
			return Integer.parseInt(obj.toString()); 
		}
		if (obj instanceof Integer) {
			return ((Integer)obj).intValue(); 
		} 
		return Integer.parseInt(obj.toString()); 
	}
	/**
	 * 获取前台的 BigDecimal 类型的参数
	 * @param parameter String
	 * @return BigDecimal
	 */
	public BigDecimal getBigDecimal(String parameter) {
		if (!JLAssertUtil.hasValue(this.values())) {
			LOGGER.debug("the val is null");
			return null;
		}
		Object obj = this.get(parameter);
		if (!JLAssertUtil.hasValue(obj)) {
			return null;
		}
		if (obj instanceof String) {
			return new BigDecimal(this.getString(parameter));
		}
		if (obj instanceof BigDecimal) {
			return (BigDecimal)obj;
		}
		throw new IllegalTargetException("目标值的数据类型不是BigDecimal，请确认目标值的数据类型！");
	}
	
	/**
	 * 获取前台的 Timestamp 类型的参数
	 * @param parameter
	 * @return
	 */
	public Timestamp getTimestamp(String parameter) {
		if (!JLAssertUtil.hasValue(this.values())) {
			LOGGER.debug("the val is null");
			return null;
		}
		Object obj = this.get(parameter);
		if (!JLAssertUtil.hasValue(obj)) {
			return null;
		}
		if (obj instanceof String) {
			return DateUtils.parseDate(this.getString(parameter));
		}
		if (obj instanceof Timestamp) {
			return (Timestamp)obj;
		}
		throw new IllegalTargetException("目标值的数据类型不是Timestamp，请确认目标值的数据类型！");
	}
	
	/**
	 * 分页组件使用的javaBean<br/>
	 * 返回一个包含 draw、  start、 length值的对象
	 * @return PageBean
	 */
	public PageBean getPageBean() {
		int draw = this.getInt("draw");
		int start = this.getInt("start");
		int length = this.getInt("length");
		PageBean bean = new PageBean(draw, start, length);
		return bean;
	}
	/**
	 * 从Map集合中获取javaBean对象
	 * @param clazz Class
	 * @param map Map<String, Object> 
	 * @return T
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 * @throws Exception
	 */
	protected <T> T getVOFormMap(Class<T> clazz, Map<String, Object> map) {
		if (!JLAssertUtil.hasValue(map)) {
			LOGGER.debug("the map is null");
			return null;
		}
		JSONObject json = new JSONObject();
		json.putAll(map);
		return JSONObject.toJavaObject(json, clazz);
	}
}

 2、JSONResponse类

package com.jl.net.framework.web;

import java.util.LinkedHashMap;
import java.util.Map;

import com.jl.net.framework.util.PageBean;

/**
 * <pre>
 * 返回结结果集 包含的信息(用于返回json的数据对象)：
 * 1、操作是否成功（默认为true）
 * 2、是否需要登陆（默认为false， 除特殊场景外不需要开发人员设定）
 * 3、返回结果集 Map
 * </pre>
 * @author mrh2015年1月22日
 *
 */
public class JSONResponse {
	
	private boolean success = true;
	
	private boolean relogin = false;
	
	private Map<String, Object> values = new LinkedHashMap<String, Object>();;
	
	private String message;

	
	public JSONResponse () {
		super();
	}

	/**
	 * 构造方法-用于框架权限、资源验证不通过时，拒绝用户请求时使用
	 * @param relogin
	 */
	public JLJsonResponse(boolean relogin) {
		super();
		this.relogin = relogin;
	}

	/**
	 * @return the success
	 */
	public boolean isSuccess() {
		return success;
	}

	/**
	 * @param success the success to set
	 */
	public void setSuccess(boolean success) {
		this.success = success;
	}

	/**
	 * @return the relogin
	 */
	public boolean isRelogin() {
		return relogin;
	}

	/**
	 * @return the value
	 */
	public Map<String, Object> getValues() {
		return values;
	}

	/**
	 * @param the value Object
	 */
	@SuppressWarnings("unchecked")
	public <T> T get(String key) {
		return (T)this.values.get(key);
	}
	
	public void setPageBean(PageBean page) {
		this.values.put(PageBean.PAGE_BEAN_KEY, page);
	}
	
	/**
	 * @param value the value to set
	 */
	public void put(String key, Object value) {
		this.values.put(key, value);
	}

	/**
	 * @return the message
	 */
	public String getMessage() {
		return message;
	}

	/**
	 * @param message the message to set
	 */
	public void setMessage(String message) {
		this.message = message;
	}
}

 

 

2、方法风格规范

方法分类两种，框架提供的页面初始化方法以及开发人员根据业务需求自定义的方法

具体规范如下

1、初始化方法，有抽象类定义抽象方法，指定默认的urlMapping为"/init"，无请求参数，返回值为JSONResponse

@Override
	public JSONResponse init(JSONResponse response) {
		try {
			List<Acjc001VO> list = this.service.getAcjc001List();
			response.put("ac001", list);
		} catch (Exception e){
			response.setSuccess(false);
			response.setMessage("初始化失败！");
			LOGGER.error(e.getMessage(), e);
		}
		response.setMessage("操作成功！");
		return response;
	}

  方法参数中的Response对象是为了用于返回到前台，这样做的摸底就是为了让开发人员减少实例化的过程，同时避免使用全局变量

2、自定义方法

 

/**
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value="/ac001", method=RequestMethod.POST)
	@ResponseBody
	public JSONResponse getAc001s(@RequestBody JSONRequest request, JSONResponse response) {
		try {
			System.out.println(request);
			PageBean page = new PageBean(1,2,3);
			List<Acjc001VO> list = this.service.getAcjc001List();
			page.setList(list);
			response.setPageBean(page);
			response.setMessage("查询成功！");
		} catch (CheckException e){
			System.out.println(e);
			response.setSuccess(false);
			response.setMessage(e.getMessage());
			LOGGER.error(e.getMessage(), e);
		} catch (Exception e){
			System.out.println(e);
			response.setSuccess(false);
			response.setMessage("系统异常！");
			LOGGER.error(e.getMessage(), e);
		}
		return response;
	}

 自定义方法全部使用POST方式，需要开发人员指定urlMapping

 

3、自定义方法的参数列表规范，自定义方法规定方法参数为

@RequestBody JSONRequest request, JSONResponse response

 

下面看一下Controller的抽象类以及按照规范创建的Controller

1、AbstractController

package com.jl.net.framework.web;

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.ResponseBody;

@Controller
public abstract class AbstractController {
	
	/**
	 * 抽象方法，由子类实现，用于实现页面的初始化操作
	 * @param request JLAbstractRequest 用户的请求方法
	 * @return
	 */
	@RequestMapping(value="/init", method=RequestMethod.GET)
	public abstract @ResponseBody JLJsonResponse init(JLJsonResponse response);
}

 

 2、 Demo2Controller代码

package com.jl.net.demo.web.controller;

import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.jl.net.demo.dao.Acjc001VO;
import com.jl.net.demo.service.IAc001Servcie;
import com.jl.net.framework.exception.CheckException;
import com.jl.net.framework.util.PageBean;
import com.jl.net.framework.web.AbstractController;
import com.jl.net.framework.web.JSONRequest;
import com.jl.net.framework.web.JSONResponse;

/**
 * Controller示例代码
 * @author 100807
 */
@Controller
@RequestMapping(value="/demo2")
public class Demo2Controller extends AbstractController {
	/**
	 * LOGGER
	 */
	private static final Logger LOGGER = Logger.getLogger(Demo2Controller.class);
	private IAc001Servcie service;
	public void setService(IAc001Servcie service) {
		this.service = service;
	}
	@Override
	public JSONResponse init(JSONResponse response) {
		try {
			List<Acjc001VO> list = this.service.getAcjc001List();
			response.put("ac001", list);
		} catch (Exception e){
			response.setSuccess(false);
			response.setMessage("初始化失败！");
			LOGGER.error(e.getMessage(), e);
		}
		response.setMessage("操作成功！");
		return response;
	}
	/**
	 * 成本中心
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value="/ac001", method=RequestMethod.POST)
	@ResponseBody
	public JSONResponse getAc001s(@RequestBody JSONRequest request, JSONResponse response) {
		try {
			System.out.println(request);
			PageBean page = new PageBean(1,2,3);
			List<Acjc001VO> list = this.service.getAcjc001List();
			page.setList(list);
			response.setPageBean(page);
			response.setMessage("查询成功！");
		} catch (CheckException e){
			System.out.println(e);
			response.setSuccess(false);
			response.setMessage(e.getMessage());
			LOGGER.error(e.getMessage(), e);
		} catch (Exception e){
			System.out.println(e);
			response.setSuccess(false);
			response.setMessage("系统异常！");
			LOGGER.error(e.getMessage(), e);
		}
		return response;
	}
	
}

 

 由此完成web端的封装，这样减少的前台formBean的开发，并且还能固定方法参数，开发人员在编写Controller代码时就更简单了