在权限管理中的一些通用的包

JsonData

这个类用来作为一个Json的工具类来使用里面有下面几个方法:

String msg
Integer id
Object data
static success(Object data,String msg)
static success(Object data)
static faill(String msg)
static Map toMap()

这个类的主要作用是把它作为对异常的处理。还有可以作为一个Map来存储我们需要的信息 ，id和Message

SpringExceptionHandler

这个类用来用来对异常进行处理，需要注意的是要实现 HandlerExceptionHandler并且将这个这个处理类注册到SpringMVC当中去。这样在Spring的运行过程中就可以来捕捉异常并且按照我们的方式来处理异常。
设计这个类的主要的想法是想让这个类：

1. 根据请求的url的类型，针对于不同的请求路径，返回不同的视图解析器，也就是不同的页面。
2. 在这里有两种形式的请求一中的是对于.json基于json的请求，一种是基于页面的请求所以我们需要提取里面的url来判断内容。

具体的使用的步骤如下：
首先重载下 resolveException（HttpPServletRequest request,HttpServletResponse response,Object o,Exception e）这个方法。
具体的实现的代码

	String url = request.getRequestURL().toString();
	ModelAndView mv;//这个是返回值的类型
	String msg = "System Error";//我们默认的信息
		if(rul.endsWith(".json")){
			if( ex instanceof PermissionException || ex instanceof ParameterException){
				JsonData data = JsonData.fail(ex.getMessage);
				mv = new ModelAndView("jsonView",data.toMap;());//注意这个ModelAndView这个类，这个的第一个字符串是表示要返回的视图的名称，如果没有在SpringMvc中分注册则返回默认的名称，如果有这个视图解析的名称，那么就用该视图解析字符串。
			}else{
				JsonData data = JsonData.fail(msg);
				mv = new ModelAndView("jsonView",data.toMap());
			}
		}else if(url.endsWith(".page")){
				JsonData data = JsonData.fail(msg);
				mv = new ModelAndView("exception",data.toMap());
		}else{
				JsonData data  = JsonData.fail(msg);
				mb = new ModelAndView("jsonView",data.toMap());
		}
	return mv;

PermissionException ParameterException

这两个异常是自定义的两个异常在后面的逻辑设计中如果出现个相应的异常则抛出对应的异常。并没有对其实现新的用法。

继承自RuntimeException 然后重写内部的方法便可以啦

BeanValidator

这是一个验证的工具类，这个类可以验证我们传入的参数是否符合我们的要求。主要用的jar包包括

javaX.validation validation-api
org.hibernate.hibernate-validator

这个类的大概的使用的逻辑是：

1. 首先我们在创建的对象的参数前面加上注解。例如@NotNull @NotBlank @NotEmpty @Max @Min 这种类似限制参数的值，其中NotEmpty修饰的是对象，NotNull 修饰的是Integer类型 NotBlank修饰的是String类型
2. 通过Validation-api中包提供的一些报的内容进行验证对象中的内容是否满足我们的定义的类。

下面是关于BeanValidator的具体实现：

1. 首先是通过Validation.buildDefaultValidatorFactory() 得到一个工厂类的对象
2. 然后用这个工厂类得到一个Validator
3. 真正验证是用validator的validator.validate（T t,Class…groups);

有四个方法：一个是针对一个对象，一个针对一个数组，一个是针对不定数目的，还有是直接提供外部使用的

	private ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
	public static Map<String,String> validate(T t,Class...groups){
		Validator validator = validatorFactory.getValidator();
		Set result = validator.validate(t,groups);
		Map map;
		if(result.isEmpty()){
			return new HashMap<String,String>();
		}else{
			Iterator iterator = result.iterator();
			LinkedHashMap<String,String> errors = new LinkedHashMap<String,String>();
			while(iterator.hasNext()){
				ConstraintViolation vilolation = iterator.next();//这是真正的错误信息
				errors.put(violation.getPropertyPath().toString(),violation.getMessage());//前一个参数保存的是路径，后面一个是错误的信息这就是我们注解中的内容
			}
			return errrors;
		}
	}
	/**
		验证集合的方法
		这个验证的方式其实很有意思
		他在验证的时候的逻辑是：
		一个一个参数去验证得到一个errors判断这个errors是否为空，如果为空的话那么便继续下一个，直到到达集合的最后则返回一个
		空集合。
	*/
	public static Map<String,String> validateList(Collection<?> collection){
		Map errors;
		Iterator iterator = collection.iterator();
		do{
			if(i!terator.hasNext()){
				return Collections.emptyMap();
			}
			errors = validate(iterator.next(),new Class[0]);
		}while(errors.isEmpty())
		return errors;
	}
	//验证不确定个数的对象
	public static Map<String,Stringh> validateObject(Object first,Object..args){
		if(args != null  && args.length>0){
			return validateList(Lists.asList(first,args));
		}else{
			return validate(first);
		}
	}
	//提供给外界使用的接口
	public void Map<String,String> check(Object obj) throws ParamterException{
		Map<String,String> map = validateObject(obj);
		if(map.isEmpty()){
		}else{
			throw ParameterException();
		}
	}

在这个的实际写的时候遇到的问题：

1. 对于不定项参数的理解：不定项参数便是 Class…groups这个用法，这个用法的有点在于区分与数组并且可以冲入一个null并且不会导致异常。

例如代码是这样的：
	public  void test(int... arr){
		int sum = 0;
		for(int a:arr){
			sum += a;
		}
		System.out.println(sum);
	}
	public void test1(int[] arr){
		int sum = 0;
		for(int a:arr){
			sum += a;
		}
		System.out.println(sum);
	}
	对于test如果传入一个null值，那么可以继续运行并不报错
	而对于test1如果传入一个NULL值，那么便会报错，编译不通过。
	另外一个有点就是在test（1,2，3）这样的传入参数。

JsonMapper

需要导入的依赖文件为 org.codehaus.jackson jackson-core-asl
org.corehaus.jackson jackson-mapper-asl
这个类的作用是把Object和Json之间进行交换

具体的代码是
		private static ObjectMapper objectMapper = new ObjectMapper();
		static{
					//配置文件 这部分还不是很了解
			        objectMapper.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
    		  	   objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
      			   objectMapper.setFilters(new SimpleFilterProvider().setFailOnUnknownId(false));
      			   objectMapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_EMPTY);
		}
		/**
			这个方法的主要的作用是要把把对象转换成为字符串使用的ObejectMapper.writeValueAsString(obj);
		*/
		public static <T> String obj2String(T src){
			if(src == null){
				return null;
			}
			try{
				return (String) src instancof String ? src: objectMapper.writeValueAsString(src);
			}catch(Exception e){
				return null;
			}
		}
		public static <T> Tstring2Obj(String src,TypeReference typeReference){
			if(src == null || typeReference == null){
				return  null;
			}
			try{
				return (T)src instanceof String ? (String)src:objectMapper.readValue(src,typeReference);
			}catch(Exception e){//必须捕捉异常因为这个上面的方法会产生异常
				return null;
			}
		}

ApplicationContextHelper

这个类需要注册到SpringMVC当中去，bean class="" laze-init=“false”
这个类是用来直接获取当前Spring中的上下文。
这个类需要实现一个叫做 ApplicationContextAware的接口并且重写里面的setApplicationContext（）的方法，这个类的主要的作用是可以让我们直接通过类名获得我们需要的Spring中的Bean

 	private static ApplicationContex context;
 	public void setApplicationContext(Applicationcontex context) throws BeansException{
		this.context = context;
	}
	public static <T> popBean(Class<T> clazz){
		if(context == null){
		return null;
	}
	return context.getBean(clazz);
	}
	public static <T> popBean(String name,Class<T> clazz){
		if(context == null){
			return null;
		}
		return context.getBean(name,clazz);
	}

懒加载：
所谓懒加载(lazy)就是延时加载，延迟加载。

在spring的IOC容器中，可以通过设置来设置是否为懒加载模式，懒加载的意思就是说是否在spring容器加载的时候将bean加载到容器中。在没有设置的情况下，默认是false的，就是说不使用懒加载模式。

至于为什么要用懒加载呢，就是当我们要访问的数据量过大时，明显用缓存不太合适，
因为内存容量有限 ，为了减少并发量，减少系统资源的消耗，
我们让数据在需要的时候才进行加载，这时我们就用到了懒加载

这个类我的理解是：
在初始化Spring的时候存在这个类，spring自动的把自己的ApplicationContext赋值给这个类，然后便可以直接通过自己定义的类或者字符串去找到相应的bean去。

HttpInterceptor

http拦截器。