HTTP请求的数据映射到封装的DAO
一、业务背景
web前端发送一系列数据给后台，这些数据包含字符串和字符串数组，现在的业务需求就是怎样动态的把这些数据动态映射到DAO的字段中，而dao中的字段有java的基本类型，数组类型还有集合类型，后台应该怎样处理？
封装带来的好处：HTTP传过来的字符串自动的映射到dao中相应字段的类型，其字段类型包括java基本类型、数组类型、集合类型
二、代码详解
这个是测试代码
package com.hewen.java.frame;
/**
* 测试类，因为httpRequest请求一般都是以字符串，或者是字符串数组传过来的
* @author Administrator
*
*/
public class DTOTest {
public static void main(String[] args) {
MyRequest request = new MyRequest();
request.setParameter("id", "9527");
request.setParameter("name", "name9527");
request.setParameterValues("friendsIds", new String[]{"1", "2", "3", "4", "5"});
request.setParameterValues("memTimes", new String[]{"2000-01-02 03:04:05", "2012-06-07 08:09:10"});
//UserQueryDTO dto = new UserQueryDTO();
//dto.initFromRequest(request);
//DTOUtil.initFromRequest(request, dto);
UserQueryDTO dto = (UserQueryDTO) DTOUtil.initFromRequest(request, UserQueryDTO.class);
System.out.println(dto);
}
}
把所有的httpRequest请求都放到Map中,这个类是MyRequest,实现了HttpServletRequest接口
package com.hewen.java.frame;
import java.io.BufferedReader;
/**
* 这个是一个测试的request请求
* @author Administrator
*
*/
public class MyRequest implements HttpServletRequest{
private Map<String, String> parameters = new HashMap<String, String>();
private Map<String, String[]> listParameters = new HashMap<String, String[]>();
//这个是设置键值对给request,key是String ,value-String
public void setParameter(String key, String value){
parameters.put(key, value);
}
//这个是给request设置键值对，key-String,value-String[]
public void setParameterValues(String key, String[] value){
listParameters.put(key, value);
}
// @Override
//获取设置request的键值对value-String
public String getParameter(String name) {
return parameters.get(name);
}
//获取设置request的键值对value-String[]
// @Override
public String[] getParameterValues(String name) {
return listParameters.get(name);
}
}
封装的DAO类
package com.hewen.java.frame;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.List;
//public class UserQueryDTO extends BaseDTO{
public class UserQueryDTO {
private long id;
private String name;
private long[] friendsIds;
private List<Timestamp> memTimes;
public List<Timestamp> getMemTimes() {
return memTimes;
}
public void setMemTimes(List<Timestamp> memTimes) {
this.memTimes = memTimes;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long[] getFriendsIds() {
return friendsIds;
}
public void setFriendsIds(long[] friendsIds) {
this.friendsIds = friendsIds;
}
public String toString(){
StringBuilder sb = new StringBuilder();
sb.append("id:" + id).append("\nname:").append(name);
sb.append("\nfriendsIds:[");
for(long fid: friendsIds){
sb.append(fid).append(" ");
}
sb.deleteCharAt(sb.length() - 1);
sb.append("]");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sb.append("\nmemTimes:[");
for(Timestamp mem: memTimes){
sb.append(sdf.format(mem)).append(" ");
}
sb.deleteCharAt(sb.length() - 1);
sb.append("]");
return sb.toString();
}
}
后台是怎么样把请求的值映射到封装的dao类中，这个类是DTOUtil，用了反射机制
package com.hewen.java.frame;
import java.lang.reflect.Method;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Vector;
import javax.servlet.http.HttpServletRequest;
public class DTOUtil {
private static final String SETFLAG = "set";
private static final int ARRAY_TYPE_VECTOR =1;//dao类中字段的集合是Vector,List,ArrayList
private static final int ARRAY_TYPE_LIST = 2;
private static final int ARRAY_TYPE_ARRAYLIST = 3;
/**
* 为request请求初始数据至dao
* @param request Http请求
* @param dto Http请求所有数据，映射到相应的Dao类中
* @return
*/
public static Object initFromRequest(HttpServletRequest request, Object dto){
Method []methods = dto.getClass().getMethods();//得到dao中所有的方法
for(Method method: methods){
//因为要对dao中各个字段进行映射，所以要过滤掉get开头的方法，
//只需要判断带有set开头的方法
if(method.getName().startsWith(SETFLAG)){
/*
* 得到set开头方法字符串对应的字段值，如setName,转变后name
*/
String fieldName = method.getName().substring(SETFLAG.length());
fieldName = fieldName.replaceFirst(fieldName.substring(0, 1), fieldName.substring(0, 1).toLowerCase());
if(isArrayField(method)){//判断dao映射的字段是否是数组字段或者是集合类型
String[] fieldValue = request.getParameterValues(fieldName);
//System.out.println("==initFromRequest==fieldName:" + fieldName + "\tfieldValue:" + fieldValue);
//检查得到的request的值是否是数组类型
if(fieldValue == null || !checkArrayField(fieldValue)){
System.err.println("null value when initFromRequest,fieldName:" + fieldName + " fieldValue:" + fieldValue);
continue;
}
//把request所传过来的数组值映射到dao字段
initArrayField(dto, method, fieldValue);
}else{
String fieldValue = request.getParameter(fieldName);
//System.out.println("==initFromRequest==fieldName:" + fieldName + "\tfieldValue:" + fieldValue);
if(fieldValue == null){
System.err.println("null value when initFromRequest,fieldName:" + fieldName + " fieldValue:" + fieldValue);
continue;
}
initField(dto, method, fieldValue);
}
}
}
return dto;
}
public static Object initFromRequest(HttpServletRequest request, Class<?> dtoClass){
Object dto;
try {
dto = dtoClass.newInstance();
} catch (Exception e) {
throw new RuntimeException("exception when newInstance:" + dtoClass.getName());
}
initFromRequest(request, dto);
return dto;
}
//检查得到的request的值是否是数组类型
private static boolean checkArrayField(String[] fieldValue){
if(fieldValue.length == 1 && fieldValue[0].trim().length() == 0){
return false;
}
return true;
}
//初始化非数组类型
private static void initField(Object o, Method method, String fieldValue){
Class<?> pType = method.getParameterTypes()[0];
try
{
if(pType.equals(int.class) || pType.equals(Integer.class)){
method.invoke(o, Integer.parseInt(fieldValue));
}else if(pType.equals(float.class) || pType.equals(Float.class)){
method.invoke(o, Float.parseFloat(fieldValue));
}else if(pType.equals(double.class) || pType.equals(Double.class)){
method.invoke(o, Double.parseDouble(fieldValue));
}else if(pType.equals(long.class) || pType.equals(Long.class)){
method.invoke(o, Long.parseLong(fieldValue));
}else if(pType.equals(String.class)){
method.invoke(o, fieldValue);
}else if(pType.equals(Timestamp.class)){
method.invoke(o, Timestamp.valueOf(fieldValue));
}else if(pType.equals(Date.class)){
method.invoke(o, Date.valueOf(fieldValue));
}else if(pType.equals(Time.class)){
method.invoke(o, Time.valueOf(fieldValue));
}else{
throw new RuntimeException("unsupport type exception when initField, method is:" + method.getName());
}
}catch(Exception e){
//e.printStackTrace();
System.err.println("exception when initFromRequest,method is:" + method.getName() + " fieldValue:" + fieldValue);
}
}
/**
* 判断dao映射的字段是否是数组字段或者是集合类型
* @param m 该字段对应的set方法
* @return
*/
private static boolean isArrayField(Method m){
if(m.getParameterTypes().length < 1){
return false;
}
//得到该字段对应的set方法参数类型
Class<?> p0 = m.getParameterTypes()[0];
//判断set方法对应的参数类型是数组或者是集合类型
return p0.isArray() || Collection.class.isAssignableFrom(p0);
}
/**
* 把request所传过来的值映射到dao字段
* @param obj 需要映射的dao对象
* @param m dao字段对应的set方法如：setName(String name)
* @param fieldValue request请求所得到的值，要映射到dao字段里
*/
private static void initArrayField(Object obj, Method m, String[] fieldValue){
Class<?> p0 = m.getParameterTypes()[0];
try {
if(p0.isArray()){
//p0.getComponentType()返回数组类型中包含哪个基本类型
m.invoke(obj, getArray(p0.getComponentType(), fieldValue));
}else if(Collection.class.isAssignableFrom(p0)){
//因为dao中set方法参数中有List、vector，ArrayList，故需知道集合里面中包含的是什么数据基本类型
//ArrayList.class.isAssignableFrom(p0)判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，
//或是否是其超类或超接口。如果是则返回 true；否则返回 false。
// 如果该 Class 表示一个基本类型，且指定的 Class 参数正是该 Class 对象，
//则该方法返回 true；否则返回 false。
String innerType = getInnerType(m.getGenericParameterTypes()[0].toString());
if(Vector.class.isAssignableFrom(p0)){
m.invoke(obj, getArray(innerType, fieldValue, ARRAY_TYPE_VECTOR));
}else if(ArrayList.class.isAssignableFrom(p0)){
m.invoke(obj, getArray(innerType, fieldValue, ARRAY_TYPE_ARRAYLIST));
}else if(List.class.isAssignableFrom(p0)){
m.invoke(obj, getArray(innerType, fieldValue, ARRAY_TYPE_LIST));
}
}
} catch (Exception e) {
throw new RuntimeException("exception when init arrayField, method is:" + m.getName());
}
}
/***
*
* @param componentType 数组是哪个基本类型
* @param fieldValue request请求的数据值
* @return 请求的数据值转换成数组中
*/
private static Object getArray(Class<?> componentType, String[] fieldValue){
int i;
if(componentType.equals(int.class) || componentType.equals(Integer.class)){
int []a = new int[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Integer.parseInt(fieldValue[i]);
}
return a;
}else if(componentType.equals(short.class) || componentType.equals(Short.class)){
short []a = new short[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Short.parseShort(fieldValue[i]);
}
return a;
}else if(componentType.equals(float.class) || componentType.equals(Float.class)){
float []a = new float[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Float.parseFloat(fieldValue[i]);
}
return a;
}else if(componentType.equals(double.class) || componentType.equals(Double.class)){
double []a = new double[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Double.parseDouble(fieldValue[i]);
}
return a;
}else if(componentType.equals(long.class) || componentType.equals(Long.class)){
long []a = new long[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Long.parseLong(fieldValue[i]);
}
return a;
}else if(componentType.equals(String.class)){
String []a = new String[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = fieldValue[i];
}
return a;
}else if(componentType.equals(Timestamp.class)){
Timestamp []a = new Timestamp[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Timestamp.valueOf(fieldValue[i]);
}
return a;
}else if(componentType.equals(Date.class)){
Date []a = new Date[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Date.valueOf(fieldValue[i]);
}
return a;
}else if(componentType.equals(Time.class)){
Time []a = new Time[fieldValue.length];
for(i = 0; i < fieldValue.length; i++){
a[i] = Time.valueOf(fieldValue[i]);
}
return a;
}else{
throw new RuntimeException("unsupport type exception when get array, type:" + componentType);
}
}
/***
* 初始化集合类型数据包含Vector=ARRAY_TYPE_VECTOR=1,
* ARRAY_TYPE_ARRAYLIST=ArrayList=3
* ARRAY_TYPE_LIST=List=2
* @param innerType 集合类型包含的基本数据类型
* @param fieldValue request请求的数据值
* @param arrayType 是集合类型的哪个类型
* @return 请求的数据方法集合类中
*/
private static Object getArray(String innerType, String[] fieldValue, int arrayType){
/**
* 判断集合里面是哪种类型如：
* "java.sql.Time"，"java.sql.Date"，"java.sql.Timestamp","java.lang.String",
* "java.lang.Double","java.lang.Long","java.lang.Float","java.lang.Integer","java.lang.Short"
* 然后把fieldValue值添加到指定的集合(arrayType)中
*/
if(innerType == null){
// default type: String
List<String> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<String>();
}else{
l = new ArrayList<String>();
}
for(String value: fieldValue){
l.add(value);
}
return l;
}else if(innerType.equals("java.lang.Short")){
List<Short> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Short>();
}else{
l = new ArrayList<Short>();
}
for(String value: fieldValue){
l.add(Short.parseShort(value));
}
return l;
}else if(innerType.equals("java.lang.Integer")){
List<Integer> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Integer>();
}else{
l = new ArrayList<Integer>();
}
for(String value: fieldValue){
l.add(Integer.parseInt(value));
}
return l;
}else if(innerType.equals("java.lang.Float")){
List<Float> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Float>();
}else{
l = new ArrayList<Float>();
}
for(String value: fieldValue){
l.add(Float.parseFloat(value));
}
return l;
}else if(innerType.equals("java.lang.Double")){
List<Double> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Double>();
}else{
l = new ArrayList<Double>();
}
for(String value: fieldValue){
l.add(Double.parseDouble(value));
}
return l;
}else if(innerType.equals("java.lang.Long")){
List<Long> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Long>();
}else{
l = new ArrayList<Long>();
}
for(String value: fieldValue){
l.add(Long.parseLong(value));
}
return l;
}else if(innerType.equals("java.lang.String")){
List<String> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<String>();
}else{
l = new ArrayList<String>();
}
for(String value: fieldValue){
l.add(value);
}
return l;
}else if(innerType.equals("java.sql.Timestamp")){
List<Timestamp> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Timestamp>();
}else{
l = new ArrayList<Timestamp>();
}
for(String value: fieldValue){
l.add(Timestamp.valueOf(value));
}
return l;
}else if(innerType.equals("java.sql.Date")){
List<Date> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Date>();
}else{
l = new ArrayList<Date>();
}
for(String value: fieldValue){
l.add(Date.valueOf(value));
}
return l;
}else if(innerType.equals("java.sql.Time")){
List<Time> l;
if(arrayType == ARRAY_TYPE_VECTOR){
l = new Vector<Time>();
}else{
l = new ArrayList<Time>();
}
for(String value: fieldValue){
l.add(Time.valueOf(value));
}
return l;
}else{
throw new RuntimeException("unsupport type exception when get list, type:" + innerType);
}
}
/**
* 获取List、Vector，ArrayList中包含的具体类型，
* 如gp="java.util.List<java.sql.Timestamp>",装换成"java.sql.Timestamp"
* @param gp
* @return
*/
private static String getInnerType(String gp){
int startIndex = gp.indexOf("<");
int endIndex = gp.indexOf(">");
if(startIndex == -1 || endIndex == -1 || startIndex >= endIndex){
return null;
}
return gp.substring(startIndex + 1, endIndex);
}
}
id:9527 name:name9527 friendsIds:[1 2 3 4 5] memTimes:[2000-01-02 03:04:05 2012-06-07 08:09:10]