public class PageData extends HashMap implementsMap {private static final long serialVersionUID = 1L;
 
Map map= null;
 
HttpServletRequest request;publicPageData(HttpServletRequest request) {this.request =request;
 
Map properties=request.getParameterMap();
 
Map returnMap= newHashMap();
 
Iterator entries=properties.entrySet().iterator();
 
Map.Entry entry;
 
String name= "";
 
String value= "";while(entries.hasNext()) {
 
entry=(Map.Entry) entries.next();
 
name=(String) entry.getKey();
 
Object valueObj=entry.getValue();if (null ==valueObj) {
 
value= "";
 
}else if (valueObj instanceofString[]) {
 
String[] values=(String[]) valueObj;for (int i = 0; i < values.length; i++) {
 
value= values[i] + ",";
 
}
 
value= value.substring(0, value.length() - 1);
 
}else{
 
value=valueObj.toString();
 
}if (name.equals("timeEnd")) {if (!value.equals("")) {
 
value= value + " 23:59:59";
 
}else{
 
}
 
}
 
returnMap.put(name, value);
 
}
 
map=returnMap;
 
}publicPageData(JSONObject jo) {
 
Map returnMap= newHashMap();for (Iterator keys =jo.keys(); keys.hasNext();) {try{
 
String key1=keys.next();//System.out.println("key1---" + key1 + "------" + jo.get(key1) + (jo.get(key1) instanceof JSONObject)//+ jo.get(key1) + (jo.get(key1) instanceof JSONArray));//System.out.println("key1:" + key1 + "----------jo.get(key1):" + jo.get(key1));
 
returnMap.put(key1.toUpperCase(), jo.get(key1));
 
}catch(JSONException e) {
 
e.printStackTrace();
 
}
 
}
 
map=returnMap;
 
}publicPageData() {
 
map= newHashMap();
 
}
 
@OverridepublicObject get(Object key) {
 
Object obj= null;if (map.get(key) instanceofObject[]) {
 
Object[] arr=(Object[]) map.get(key);
 
obj= request == null ? arr : (request.getParameter((String) key) == null ? arr : arr[0]);
 
}else{
 
obj=map.get(key);
 
}returnobj;
 
}publicString getString(Object key) {if (null != get(key) && "null" !=get(key)) {returnString.valueOf(get(key));
 
}return "";
 
}public doublegetDouble(Object key) {
 
Object value=get(key);if (null != value && !"null".equals(value) && !"".equals(value)) {if (value instanceofString) {returnDouble.parseDouble(value.toString());
 
}else if (value instanceofDouble) {return (double) value;
 
}//return (double) get(key);
 
}return 0.0;
 
}public intgetInt(Object key) {
 
Object value=get(key);if (null != value && !"null".equals(value) && !"".equals(value)) {if (value instanceofString) {returnInteger.parseInt(value.toString());
 
}else if (value instanceofInteger) {return (int) value;
 
}
 
}return 0;
 
}

 我们可以看到,Java后台接受值的时候，是通过一个一个属性来进行接收，虽然现在才3个属性，但是如果有上百种属性需要接收,是不是写起来就非常麻烦.
 
解决方法
 

 
 控制台输出:
 
TbSchool{, id=null, name=1111, type=2, phone=11111111111}
 
前台传的值都通过对象的方式传递后台，不管多少值我们在后台都不需要进行修改。
 如果需要用哪个值，我们直接可以通过TbSchool.值 来进行使用。
 也可以直接通过对象来直接使用,根据情况而定

首先需要在传参的bean实体类中添加注解。
 
public class People {
	/** 姓名.*/
    @ApiModelProperty(value = "姓名, 长度: 10", required = false)
    @NotNull
    @Valid
    @Size(max = 10, message = "姓名长度不能超过10")
    private String name;
    /** 年龄.*/
    @ApiModelProperty(value = "年龄, 长度: 10", required = false)
    @Max(value = 150, message = "年龄不允许超过150岁且必须为数字")
    private Integer age;
      /** 手机号.*/
 	@ApiModelProperty(value = "手机号, 长度: 11", required = false)
 	@Pattern(regexp = "^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$" ,message = "手机号不合法")
   private Integer phone;
     /** 邮箱.*/
    @ApiModelProperty(value = "邮箱, 长度: 30", required = false)
    @Email(regexp = "^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$" ,message = "email不合法")
    private String email;
	/** 资产.*/
    @ApiModelProperty(value = "资产, 长度: 100", required = false)
    @Digits(integer=20, fraction=6,,message = "资产最多26位，包含6位小数")
    private Double money;

}
 
接着需要在Controller的请求参数写入注解实体类
 
@ApiOperation("添加")
@RequestMapping(value = "", method = RequestMethod.POST)
public BaseResult<String> create(@RequestBody @Valid People input, BindingResult br) {
	//校验参数
    verifyParams(br);
    People people= new People ();
    BeanUtils.copyProperties(input, people);
    busAnalyzePeriodService.saveBusAnalyzePeriod(busAnalyzePeriod);
    return BaseResult.SUCCESS;
}
 
写一些参数校验的方法
 
/**
* 参数检查
*/
protected void verifyParams(BindingResult br) {
   if (br.hasErrors()) {
       StringBuilder sb = new StringBuilder();
       List<ObjectError> allErrors = br.getAllErrors();
       for (int i = 0; i < allErrors.size(); i++) {
           sb.append(allErrors.get(i).getDefaultMessage());
           if (i != allErrors.size() - 1) {
               sb.append("|");
           }
       }
       throw new GlobalException(BaseResultEnum.PARAMERROR, sb.toString());
   }
}

/**
* 检查分页参数的正确性
*/
protected void checkPage(Page page) {
   long current = page.getCurrent();
   if (current <= 0) {
       page.setCurrent(DEFAULT_PAGE_CURRENT);
   }
   long size = page.getSize();
   if (size > DEFAULT_PAGE_SIZE_MAX) {
       page.setSize(DEFAULT_PAGE_SIZE_MAX);
   }
   if (size < DEFAULT_PAGE_SIZE_MIN) {
       page.setSize(DEFAULT_PAGE_SIZE_MIN);
   }
}
 
Spring的相关注解
 
注解
类型
描述
@AssertFalse
Boolean,boolean
验证注解的元素值是false
@AssertTrue
Boolean,boolean
验证注解的元素值是true
@NotNull
任意类型
验证注解的元素值不是null
@Null
任意类型
验证注解的元素值是null
@Min(value=值)
任何Number或CharSequence（存储的是数字）子类型
验证注解的元素值大于等于@Min指定的value值
@Max（value=值）
和@Min要求一样
验证注解的元素值小于等于@Max指定的value值
@DecimalMin(value=值)
和@Min要求一样
验证注解的元素值大于等于@ DecimalMin指定的value值
@DecimalMax(value=值)
和@Min要求一样
验证注解的元素值小于等于@ DecimalMax指定的value值
@Digits(integer=整数位数, fraction=小数位数)
和@Min要求一样
验证注解的元素值的整数位数和小数位数上限
@Size(min=下限, max=上限)
字符串、Collection、Map、数组等
的元素值的在min和max（包含）指定区间之内，如字符长度、集合大小
@Past
Date,Calendar;Time类库的日期类型
验证注解的元素值（日期类型）比当前时间早
@Future
与@Past要求一样
验证注解的元素值（日期类型）比当前时间晚
@NotBlank
CharSequence子类型
验证注解的元素值不为空（不为null、去除首位空格后长度为0），不同于@NotEmpty，@NotBlank只应用于字符串且在比较时会去除字符串的首位空格
@Length(min=下限, max=上限)
CharSequence子类型
验证注解的元素值长度在min和max区间内
@NotEmpty
值不为null且不为空（字符串长度不为0、集合大小不为0）
@Range(min=最小值, max=最大值)
原子类型和包装类型
验证注解的元素值在最小值和最大值之间
@Email(regexp=正则表达式,flag=标志的模式)
CharSequence子类型(如String)
验证注解的元素值是Email，也可以通过regexp和flag指定自定义的email格式
@Pattern(regexp=正则表达式,flag=标志的模式)
String,任何子类型验证
注解的元素值与指定的正则表达式匹配
@Valid
任何非原子类型
指定递归验证关联的对象,如用户对象中有个地址对象属性，如果想在验证用户对象时一起验证地址对象的话，在地址对象上加@Valid注解即可级联验证

 
1、初试牛刀：筛选绿苹果
 
第一个解决方案可能是下面这样的：
 
public static List filterGreenApples(List inventory){
 
List result=new ArrayList<>();
 
//仅仅筛选出绿苹果
 
for (Apple apple : inventory) {
 
if ("green".equals(apple.getColor())){
 
result.add(apple);
 
}
 
}
 
return result;
 
}上面代码只针对绿苹果进行筛选，现在，我还想筛选出红苹果，该怎么做呢？简单的解决办法就是重复写一个方法，再改条件为红苹果，但是，要筛选的颜色有多种的情况，这样写会导致代码十分冗余，所以我们第一步尝试将其抽象化。
 
2、再展身手：把颜色作为参数
 
public static List filterGreenApples(List inventory,String color){
 
List result=new ArrayList<>();
 
//颜色作为参数
 
for (Apple apple : inventory) {
 
if (color.equals(apple.getColor())){
 
result.add(apple);
 
}
 
}
 
return result;
 
}但是现在又想根据苹果的重量对苹果进行筛选，那是不是也要用另外一个参数表示苹果重量呢？之后我又想加个标志区分对颜色和重量的查询呢？下面是展示一般写法，但是很傻。
 
3、第三次尝试：对你能想到的每个属性做筛选
 
public static List filterGreenApples(List inventory,String color,int weight,boolean flag){
 
List result=new ArrayList<>();
 
for (Apple apple : inventory) {
 
if (flag && color.equals(apple.getColor())|| (!flag && apple.getWeight()>weight)){
 
result.add(apple);
 
}
 
}
 
return result;
 
}
 
4、柳暗花明：行为参数化我们可以把行为进行参数化，来达到更高层次的抽象，首先定义一个统一的标准接口，再通过不同子类对其进行实现，这有点类似于策略设计模式的赶脚。
 
//封装了对选择苹果的策略
 
public interface ApplePredicate {
 
//具体算法交给子类去实现
 
boolean test (Apple apple);
 
}
 
//颜色算法
 
public class AppleGreenColorPredicate implements ApplePredicate {
 
@Override
 
public boolean test(Apple apple) {
 
return "green".equals(apple.getColor());
 
}
 
}
 
//重量算法
 
public class AppleHeavyWeightPredicate implements ApplePredicate {
 
@Override
 
public boolean test(Apple apple) {
 
return apple.getWeight()>150;
 
}
 
}
 
5、第四次尝试：根据抽象条件筛选
 
public static List filterApples(List inventory,ApplePredicate p){
 
List result = new ArrayList<>();
 
//行为参数化
 
for (Apple apple : inventory) {
 
if (p.test(apple)){
 
result.add(apple);
 
}
 
}
 
return result;
 
}我们在使用的时候可以传递不同的策略实现来达到目的
 
List heavyApples = filterApples(inventory, new AppleHeavyWeightPredicate());
 
List greenApples = filterApples(inventory, new AppleGreenColorPredicate());但是这样有个问题，就是每个策略我都要定义一个实现类去实现某个算法，导致后面如果有很多策略，会增加很多的类，我们知道使用匿名类也是一种不错的选择
 
6、第五次尝试：使用匿名类
 
List redApples = filterApples(inventory, new ApplePredicate() {
 
@Override
 
public boolean test(Apple apple){
 
return "red".equals(apple.getColor());
 
}
 
});但是问题又来了，匿名类还是不够好，第一，它往往很笨重，占用了很多的空间，第二，使用起来让人费解，导致代码可读性不高，即使匿名类处理在某种程度上改善了为一个接口声明好几个实体类的啰嗦问题，但是还是不能令人满意，自java8引入的lambda表达式——一种更简洁的传递代码的方式解决了这个问题。下面我们利用lambda表达式来改写前面的代码吧
 
7、第六次尝试：使用Lambda表达式
 
Listresult= filterApples(inventory, (Apple apple)-> "red".equals(apple.getColor()));不得不承认，使用lambda表达式改写之前的代码确实干净很多，因为它看起来更像问题陈诉本身了，解决了啰嗦的问题
 
8、第七次尝试：将List类型抽象化在通往抽象的路上，我们还可以进一步。目前filterApples方法还只适用Apple，我们还可以尝试适用在其他水果上。
 
public interface Predicate {
 
boolean test(T t);
 
}
 
//映入类型参数T
 
public static List filter(List list,Predicate p){
 
List result =new ArrayList<>();
 
for (T e : list) {
 
if (p.test(e)){
 
result.add(e);
 
}
 
}
 
return result;
 
}现在你可以吧filter方法作用在橘子，香蕉等列表上了。
 
9、小结行为参数化，就是一个方法接收不同的行为作为参数，并在内部使用他们，完成不同行为的能力。
 
行为参数化可以让代码更好的适应不断变化的要求，减轻未来的工作量。
 
传递代码，就是将新行为作为参数传递给方法，但是在java8之前实现起来很啰嗦。为接口声明许多只用一次的实体类而造成的啰嗦代码，在java8之前可以用匿名类来减少。
 
java API 包含很多可以用不同行为进行参数化的方法，包括排序、线程等。