通过反射获取属性修改值

package com.bootdo.utils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

public class CheckDemo {
	/*通过反射获取对象的属性并赋值*/
	
	/*	工具类，将传入的对象的数据进行安全处理*/
	
	public static void checkDemo(Object bean){
		Class<?> cls = bean.getClass();  
        Map<String, String> valueMap = new HashMap<String, String>();  
        // 取出bean里的所有方法  
        Method[] methods = cls.getDeclaredMethods();  
        Field[] fields = cls.getDeclaredFields();
        
        
        for (Field field : fields) {  
            try {
            	
            	//获取值  
            	String fieldType = field.getType().getSimpleName();  
                String fieldGetName = parGetName(field.getName());  
                if (!checkGetMet(methods, fieldGetName)) {  
                    continue;  
                }
                String fieldSetName = parSetName(field.getName());  
                
             
                
                if (!checkSetMet(methods, fieldSetName)) {  
                    continue;  
                } 
                                                
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {}); 
                Method fieldSetMet = cls.getMethod(fieldSetName, field.getType());
                
                Object fieldVal = fieldGetMet.invoke(bean, new Object[] {});                    
                
                if (null != fieldVal && !"".equals(fieldVal)){
                	//判断类型  这里值处理spring类型的吧
                	if ("String".equals(fieldType)) {
                		
                		String str=(String) fieldVal;
                		//将编码走自已转码
                		str=CheckChar.b_trans_q(str);  //处理string的一个方法，有兴趣的可以看一下
                		fieldSetMet.invoke(bean, str);
                		
                	}
                	
                } 	
            } catch (Exception e) {  
                continue;  
            }
        }
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	/* 首先写获取属性的方法*/
	 public static Map<String, String> getFieldValueMap(Object bean) {  
	        Class<?> cls = bean.getClass();  
	        Map<String, String> valueMap = new HashMap<String, String>();  
	        // 取出bean里的所有方法  
	        Method[] methods = cls.getDeclaredMethods();  
	        Field[] fields = cls.getDeclaredFields();  
	  
	        for (Field field : fields) {  
	            try {  
	                String fieldType = field.getType().getSimpleName();  
	                String fieldGetName = parGetName(field.getName());  
	                if (!checkGetMet(methods, fieldGetName)) {  
	                    continue;  
	                }  
	                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});  
	                Object fieldVal = fieldGetMet.invoke(bean, new Object[] {});  
	                String result = null;  
	                if ("Date".equals(fieldType)) {  
	                    result = fmtDate((Date) fieldVal);  
	                } else {  
	                    if (null != fieldVal) {  
	                        result = String.valueOf(fieldVal);  
	                    }  
	                }  
	                valueMap.put(field.getName(), result);  
	            } catch (Exception e) {  
	                continue;  
	            }  
	        }  
	        return valueMap;  
	  
	    }  
	  
	
	
	/*注入属性
*/	
    public static void setFieldValue(Object bean, Map<String, String> valMap) {  
        Class<?> cls = bean.getClass();  
        // 取出bean里的所有方法  
        Method[] methods = cls.getDeclaredMethods();  
        Field[] fields = cls.getDeclaredFields();  
  
        for (Field field : fields) {  
            try {  
                String fieldSetName = parSetName(field.getName());  
                if (!checkSetMet(methods, fieldSetName)) {  
                    continue;  
                }  
                Method fieldSetMet = cls.getMethod(fieldSetName, field.getType());  
                String value = valMap.get(field.getName());  
                if (null != value && !"".equals(value)) {  
                    String fieldType = field.getType().getSimpleName();  
                    if ("String".equals(fieldType)) {  
                        fieldSetMet.invoke(bean, value);  
                    } else if ("Date".equals(fieldType)) {  
                        Date temp = parseDate(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else if ("Integer".equals(fieldType) || "int".equals(fieldType)) {  
                        Integer intval = Integer.parseInt(value);  
                        fieldSetMet.invoke(bean, intval);  
                    } else if ("Long".equalsIgnoreCase(fieldType)) {  
                        Long temp = Long.parseLong(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else if ("Double".equalsIgnoreCase(fieldType)) {  
                        Double temp = Double.parseDouble(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {  
                        Boolean temp = Boolean.parseBoolean(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else {  
                        System.out.println("not supper type" + fieldType);  
                    }  
                }  
            } catch (Exception e) {  
                continue;  
            }  
        }  
  
    }  
	
	
	
	
	
	 /*
     * 格式化string为Date 
     */  
    private static Date parseDate(String datestr) {  
        if (null == datestr || "".equals(datestr)) {  
            return null;  
        }  
        try {  
            String fmtstr = null;  
            if (datestr.indexOf(':') > 0) {  
                fmtstr = "yyyy-MM-dd HH:mm:ss";  
            } else {  
                fmtstr = "yyyy-MM-dd";  
            }  
            SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK);  
            return sdf.parse(datestr);  
        } catch (Exception e) {  
            return null;  
        }  
    }  
    /*
     * 日期转化为String 
     *
     */  
    private static String fmtDate(Date date) {  
        if (null == date) {  
            return null;  
        }  
        try {  
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);  
            return sdf.format(date);  
        } catch (Exception e) {  
            return null;  
        }  
    }  
  
    /* 
     * 判断是否存在某属性的 set方法 
     * 
     */  
    private static boolean checkSetMet(Method[] methods, String fieldSetMet) {  
        for (Method met : methods) {  
            if (fieldSetMet.equals(met.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
    /*
     * 判断是否存在某属性的 get方法 
     * 
     */  
    private static boolean checkGetMet(Method[] methods, String fieldGetMet) {  
        for (Method met : methods) {  
            if (fieldGetMet.equals(met.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    /*
     * 拼接某属性的 get方法 
     * 
     */  
    private static String parGetName(String fieldName) {  
        if (null == fieldName || "".equals(fieldName)) {  
            return null;  
        }  
        return "get" + fieldName.substring(0, 1).toUpperCase()  
                + fieldName.substring(1);  
    }  
    /*
     * 拼接在某属性的 set方法 
     *
     */  
    private static String parSetName(String fieldName) {  
        if (null == fieldName || "".equals(fieldName)) {  
            return null;  
        }  
        return "set" + fieldName.substring(0, 1).toUpperCase()  
                + fieldName.substring(1);  
    } 
	
	

	
	
	
}

有兴趣的可以看上string中的脚本注入处理
处理字符串中注入脚本的方法：

//半角转全角
		public static String b_trans_q(String b){
			 char[] c =b.toCharArray();
			StringBuffer sb = new StringBuffer();
			
			for(int i=0;i<c.length;i++){
				switch(c[i]){
				case '>':
					sb.append("＞");
					break;
				case '<':
					sb.append("＜");
					break;
				case '\'':
					sb.append("＇");
					break;
				case '\"':
					sb.append("＂");
					break;
				case '&':
					sb.append("＆");
					break;
				case '#':
					sb.append("＃");
					break;
				case '\\':
					sb.append("＼");
					break;
				case '%':
					processUrlEncode(sb,b,i);
					break;
				
				default:
					sb.append(c[i]);
					break;
				}
		
			}
			
			
			return sb.toString();
		}
		
		
		//解决encoder问题
		
		public  static void  processUrlEncode(StringBuffer sb,String b,int i){
			char[] c =b.toCharArray();
			
			if(b.length()>i+2){
				//%3c
				if(c[i+1]=='3' &&(c[i+2]=='c'||c[i+2]=='C')){
					sb.append('＜');
					return;
				}
				//%3c (0x3c=60)
				if(c[i+1]=='6' &&c[i+2]=='0'){
					sb.append('＜');
					return;
				}
				//%3e
				if(c[i+1]=='3' &&(c[i+2]=='e'||c[i+2]=='E')){
					sb.append('＞');
					return;
				}
				//&3e (0x3e=62)
				if(c[i+1]=='6' &&c[i+2]=='2'){
					sb.append('＞');
					return;
				}
		
			}
			sb.append(c[i]);
			
		}

完毕