SpringMVC 包扫描+ C的模拟

今天在回顾代理模式时，发现了一些问题，联想到annotation，结合springMVC以往的使用经历，就写了下面这写代码。

       1. 简单实现spring包扫描

       2. 对之前代理模式，做了下修改，可以对比 ActionProxy 类的实现。(之前把代理模式概念和jdk自带InvocationHandler胡拼乱凑，错误结合。) 

      知识点:  java 类加载器, java反射相关API，代理，annotation，一个内部内实现的单例，代理模式和工厂模式结合。就这些小知识点。

代码结构：

代码介绍:

代码介绍:
action类:
     UserAction.java  用户管理的相关C
annotation（自定义注解）:
     UAction ：控制类标记
     UParamAttr: 方法参数绑定注解
     URequestMapper: 请求URL路径注解
mapper(用来存储注解配置):
     ActionMapper
proxy(代理和代理工厂类):
     ActionProxy.java
     ActionProxyFactory.java
scan(注解扫描):
     Scan.java
service:
     DB.java  假的service
servlet：假的dispatchServlet
     Servlet.java
vo(实体对象):
     ActionMapperVo.java  方法映射
     ParamMapper.java     方法参数映射
     URequest.java         请求实体，假HttpServletRequest
     User.java             用户实体
 TestMain.java  测试类

详细代码:

扫描二维码关注公众号，回复： 3027488 查看本文章

UserAction.java  用户管理的相关C:
package com.bo.example.action;

import java.util.List;

import com.bo.example.annotation.UAction;
import com.bo.example.annotation.UParamAttr;
import com.bo.example.annotation.URequestMapper;
import com.bo.example.service.DB;
import com.bo.example.vo.User;

@UAction
@URequestMapper("/user")
public class UserAction  {
	 @URequestMapper("/list")
	  public List<User> list(){
		  return DB.queryUserList();
	  }
	 @URequestMapper("/add")
	 public Object addUser(@UParamAttr("userinfo") User u){
		 return DB.addUser(u);
	 }
	 @URequestMapper("/remove")
	 public Object removeUser(@UParamAttr("userinfo") User u){
		 return DB.removeUser(u);
	 }
}

annotation（自定义注解）:
     UAction ：控制类标记
	package com.bo.example.annotation;

	import java.lang.annotation.ElementType;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.lang.annotation.Target;
	/*
	 * @Target 说明了Annotation所修饰的对象范围：
	 * 	Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、
	 * 			类型成员（方法、构造方法、成员变量、枚举值）、
	 *          方法参数和本地变量（如循环变量、catch参数）。
	 *       	在Annotation类型的声明中使用了target可更加明晰其修饰的目标
	 *       
	 *  @Retention定义了该Annotation被保留的时间长短：
	 *  				某些Annotation仅出现在源代码中，而被编译器丢弃；
	 *  				而另一些却被编译在class文件中；
	 *  				编译在class文件中的Annotation可能会被虚拟机忽略，
	 *  				而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。
	 *  				使用这个meta-Annotation可以对 Annotation的“生命周期”限制。     
	 */
	@Retention(value=RetentionPolicy.RUNTIME)
	@Target(value=ElementType.TYPE)
	/**
	 * action标记
	 * @author 波
	 *
	 */
	public @interface UAction { 
		public String value() default ""; 
	}

      UParamAttr: 方法参数绑定注解
	package com.bo.example.annotation;

	import java.lang.annotation.ElementType;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.lang.annotation.Target;

	/**
	 * 参数绑定注解
	 * @author 波
	 *
	 */
	@Retention(value=RetentionPolicy.RUNTIME)
	@Target(value=ElementType.PARAMETER)
	public @interface UParamAttr {
		public String value() default ""; 
	}
     URequestMapper: 请求URL路径注解
	package com.bo.example.annotation;

	import java.lang.annotation.ElementType;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.lang.annotation.Target;

	/**
	 * 请求路径注解
	 * @author 波
	 *
	 */
	@Retention(value=RetentionPolicy.RUNTIME)
	@Target(value={ElementType.METHOD,ElementType.TYPE})
	public @interface URequestMapper {
		String value() default "";
	}

mapper(用来存储注解配置): ActionMapper
package com.bo.example.mapper;

import java.util.Hashtable;

import com.bo.example.vo.ActionMapperVo;
/**
 * 单例模式
 * @author 波
 *
 */
public class ActionMapper {
	private ActionMapper(){}
	
	static class ActionMapperFactory{
		private static final ActionMapper mapper = new ActionMapper();
	}
	public static final ActionMapper instance = ActionMapperFactory.mapper;
	private Hashtable<String,ActionMapperVo> hashtable = new Hashtable<>();
	
	public void put(String key,ActionMapperVo vo){
		this.hashtable.put(key, vo);
	}
	
	public ActionMapperVo get(String key){
		return this.hashtable.get(key);
	}
}

proxy(代理和代理工厂类): ActionProxy.java
package com.bo.example.proxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * 代理模式
 * @author 波
 *
 */
public class ActionProxy {
		private Object obj;

		public ActionProxy(Object obj) {
			super();
			this.obj = obj;
		}
		
		public Object execute(Method method,Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
			before();
			Object obj= method.invoke(this.obj, args);
			after();
			return obj;
		}
		
		public void before(){
			System.out.println("before ----");
		}
		
		public void after(){
			System.out.println("after----");
		}
}

proxy(代理和代理工厂类): ActionProxyFactory.java
package com.bo.example.proxy;
/**
 * 工厂模式
 * @author 波
 *
 */
public class ActionProxyFactory {
	public static ActionProxy getProxy(Class<?> cls) throws InstantiationException, IllegalAccessException{
		 return new ActionProxy(cls.newInstance());
	}
}

scan(注解扫描): Scan.java
package com.bo.example.scan;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import com.bo.example.annotation.UAction;
import com.bo.example.annotation.UParamAttr;
import com.bo.example.annotation.URequestMapper;
import com.bo.example.mapper.ActionMapper;
import com.bo.example.vo.ActionMapperVo;
import com.bo.example.vo.ParamMapper;
import com.bo.util.Constant;
/**
 * 实现包扫描
 * @author 波
 *
 */
public class Scan {
	//要扫描的包路径
	private static String scan_package_path = null;
	private static String classloader_rootpath =null;//当前类加载器加载的文件路径
	private static ClassLoader loader = null;//类加载器
	private static String class_file_path=null;//class文件路径
	static {
		Scan.scan_package_path="com.bo.example.action";//可以从配置文件读取。
		loader = ClassLoader.getSystemClassLoader();//获得当前系统类加载器。
		Scan.classloader_rootpath = Scan.loader.getResource(Constant.POINT).getFile();//
		Scan.class_file_path =loader.getResource("./com/bo/example/action/").getFile();
	}
	/**
	 * 扫描指定路径下的类,并将注解配置放入内存。
	 * @throws ClassNotFoundException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public void scan() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
		System.out.println("扫描开始---");
		List<Class<?>> lst = new ArrayList<>();
		File directory = new File(Scan.class_file_path);
		if(directory.exists()){
			String _rootPath = Scan.classloader_rootpath.replaceAll(Constant.SPECIAL_BIAS_LINE_0, Constant.POINT)
					 .replaceAll(Constant.SPECIAL_BIAS_LINE_1, Constant.POINT);
			this.listDirectory(_rootPath, directory, lst);
			
			for (Class<?> cls : lst) {
				this.initActionMapper(cls);
			}
		}
		System.out.println("扫描结束---");
	}
	/**
	 *    递归获取目录下所有.class文件
	 * @throws ClassNotFoundException 
	 */
	private void listDirectory(String rootPath,File directory,List<Class<?>> lst) throws ClassNotFoundException{
			if(!directory.isDirectory()) return;
			if(!directory.exists()) return;
			if(!directory.canRead()) return;
			
			File[]	fileList  = directory.listFiles();
			for (File file : fileList) {
				 if(!file.isDirectory()){
					 String filePath = file.getPath().replaceAll(Constant.SPECIAL_BIAS_LINE_0, Constant.POINT)
							 .replaceAll(Constant.SPECIAL_BIAS_LINE_1, Constant.POINT);
					 String classPath = filePath.replace(rootPath.substring(1, rootPath.length()),"");
					 Class<?> cls = Scan.loader.loadClass(classPath.substring(0, classPath.length()-6));
					 lst.add(cls);
				 }else{
					 this.listDirectory(rootPath, file, lst);
				 }
			}
	}
	
	private void initActionMapper(Class<?> cls) throws InstantiationException, IllegalAccessException{
			//获取Action类标记注解
		   UAction uAction = cls.getAnnotation(UAction.class);
		   if(uAction!=null){
			     //获取类的URequestMapper注解(功能域 例如:用户管理控制类/user)
			    URequestMapper uRequestMapper = cls.getAnnotation(URequestMapper.class);
			    String requestDomainUrl = "";
			    if(uRequestMapper!=null){
			    	requestDomainUrl = uRequestMapper.value();
			    }
			    //获取所有的方法
			    Method[] methodList=cls.getMethods();
			    for (Method method : methodList) {
			    	//获取method方法的注解
			    	URequestMapper mURequestMapper = method.getAnnotation(URequestMapper.class);
			    	if(mURequestMapper == null) continue;
			    	//方法请求路径 例如: /add 等
			    	String mURequestUrl = mURequestMapper.value();
			    	//获取参数列表
			    	Class<?>[] parameterTypes = method.getParameterTypes();
			    	//参数列表
			    	ParamMapper[] paramArray =null;
			    	if(parameterTypes.length>0){
			    		paramArray = new ParamMapper[parameterTypes.length];
				    	//获取方法参数注解
				    	Annotation[][] parameterAnnotationArray = method.getParameterAnnotations();
				    	int param_type_index = 0;
				    	for (Annotation[] annotations : parameterAnnotationArray) {
				    		ParamMapper paramMapper = new ParamMapper();
				    		paramMapper.setParamType(parameterTypes[param_type_index]);
				    		for (Annotation annotation : annotations) {
								if(annotation instanceof UParamAttr){
									UParamAttr uParamAttr = (UParamAttr)annotation;
									paramMapper.setMapper(true);
									paramMapper.setParamKey(uParamAttr.value());
								}
							}
				    		paramArray[param_type_index] = paramMapper;
				    		param_type_index++;
						}
			    	}
			    	ActionMapperVo vo  = new ActionMapperVo();
		    		vo.setCls(cls);
		    		vo.setArgs(paramArray);
		    		vo.setMethod(method);
		    		vo.setRequestMapperUrl(requestDomainUrl+mURequestUrl);
		    		ActionMapper.instance.put(requestDomainUrl+mURequestUrl, vo);
				}
		   }
			
	}
}

service: DB.java  假的service
package com.bo.example.service;

import java.util.ArrayList;
import java.util.List;

import com.bo.example.vo.User;

public class DB {
	private static List<User> userList = new ArrayList<>();
			
	static{
		userList = (userList!=null? userList:new ArrayList<User>());
		for(int i=0;i<5;i++){
			User u = new User();
			u.setUid("uid00"+i);
			u.setUname("uname00"+i);
			userList.add(u);
		}
	}	
	
	public static List<User> queryUserList(){
		return DB.userList;
	}
	
	public static boolean removeUser(User u){
		return DB.userList.remove(u);
	}
	
	public static boolean addUser(User u){
		return DB.userList.add(u);
	}
}

servlet：假的dispatchServlet  Servlet.java
package com.bo.example.servlet;

import java.util.Map;

import com.bo.example.mapper.ActionMapper;
import com.bo.example.proxy.ActionProxy;
import com.bo.example.scan.Scan;
import com.bo.example.vo.ActionMapperVo;
import com.bo.example.vo.ParamMapper;
import com.bo.example.vo.URequest;
/**
 * 简单是个意思，别太介意。哈哈 ,类似：dispatchServlet假的。
 * @author 波
 *
 */
public class Servlet {
	public Servlet(){
		init();
	}
	public void init(){
		//包扫描-----Spring启动初始化
		Scan scan = new Scan();
		try {
			scan.scan();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public Object doPost(URequest request) throws Exception{
		String path = request.getPath();
		Object result = null; 
		Map<String,Object> requestParam =  request.getRequestParam();
		ActionMapperVo vo = ActionMapper.instance.get(path);
		if(vo!=null){
			ActionProxy proxy = (ActionProxy) com.bo.example.proxy.ActionProxyFactory.getProxy(vo.getCls());
			Object[] args = null;
			ParamMapper[] paramArray=	vo.getArgs();
			if(paramArray!=null){
				int args_index = 0;
				args = new Object[paramArray.length];
				for (ParamMapper paramMapper : paramArray) {
						if(paramMapper.isMapper()){
							args[args_index] = requestParam.get(paramMapper.getParamKey());
						}else{
							Object _obj = paramMapper.getParamType().newInstance();
							if(_obj instanceof URequest){
								args[args_index] =  request;
							}else{
								args[args_index] = _obj;
							}
							
						}
						args_index++;
				}
			}
			result = proxy.execute(vo.getMethod(), args);
		}else{
			System.out.println("没有找到处理类");
		}
		return result;
	}
}

vo(实体对象):  ActionMapperVo.java  方法映射
package com.bo.example.vo;

import java.lang.reflect.Method;

public class ActionMapperVo {
	private Class<?> cls; //类描述
	private String requestMapperUrl;//请求路径
	private Method method;//映射的方法
	private ParamMapper[] args;//方法参数列表
	public Class<?> getCls() {
		return cls;
	}
	public void setCls(Class<?> cls) {
		this.cls = cls;
	}
	public String getRequestMapperUrl() {
		return requestMapperUrl;
	}
	public void setRequestMapperUrl(String requestMapperUrl) {
		this.requestMapperUrl = requestMapperUrl;
	}
	public Method getMethod() {
		return method;
	}
	public void setMethod(Method method) {
		this.method = method;
	}
	public ParamMapper[] getArgs() {
		return args;
	}
	public void setArgs(ParamMapper[] args) {
		this.args = args;
	}
}

vo(实体对象):  ParamMapper.java     方法参数映射
package com.bo.example.vo;

public class ParamMapper {
	private Class<?> paramType;
	private String paramKey;
	private boolean isMapper;
	
	public ParamMapper() {
		// TODO Auto-generated constructor stub
		this.isMapper = false;
	}

	public Class<?> getParamType() {
		return paramType;
	}

	public void setParamType(Class<?> paramType) {
		this.paramType = paramType;
	}

	public String getParamKey() {
		return paramKey;
	}

	public void setParamKey(String paramKey) {
		this.paramKey = paramKey;
	}

	public boolean isMapper() {
		return isMapper;
	}

	public void setMapper(boolean isMapper) {
		this.isMapper = isMapper;
	}

	@Override
	public String toString() {
		return "ParamMpper [paramType=" + paramType.getName() + ", paramKey=" + paramKey + ", isMapper=" + isMapper + "]";
	}
}

vo(实体对象): URequest.java         请求实体，假HttpServletRequest
package com.bo.example.vo;

import java.util.Map;

public class URequest {
	private String path ;
	private Map<String,Object> requestParam ;
	public String getPath() {
		return path;
	}
	public void setPath(String path) {
		this.path = path;
	}
	public Map<String, Object> getRequestParam() {
		return requestParam;
	}
	public void setRequestParam(Map<String, Object> requestParam) {
		this.requestParam = requestParam;
	}
}

vo(实体对象): User.java             用户实体
package com.bo.example.vo;

public class User {
	private String uid;
	private String uname;
	public String getUid() {
		return uid;
	}
	public void setUid(String uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	@Override
	public String toString() {
		return "User [uid=" + uid + ", uname=" + uname + "]";
	}
}
 

测试类:
package com.bo.example;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.bo.example.servlet.Servlet;
import com.bo.example.vo.URequest;
import com.bo.example.vo.User;

public class TestMain {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		Servlet servlet = new Servlet();
		
		System.out.println("添加用户:");
		URequest  	addRequest = new URequest();
		addRequest.setPath("/user/add");
		Map<String,Object> userInfo = new HashMap<>();
		User u = new User();
		u.setUid("uid-0001");
		u.setUname("uname-0001");
		userInfo.put("userinfo", u);
		addRequest.setRequestParam(userInfo);
		Boolean result = (Boolean) servlet.doPost(addRequest);
		if(result){
			System.out.println("添加成功");
		}else{
			System.err.println("添加失败");
		}
		
		System.out.println("-------------------------------------------");
		System.out.println("所有用户列表:");
		URequest  	request = new URequest();
		request.setPath("/user/list");
		List<User> list = (List<User>)  servlet.doPost(request);
		
		for(int index = 0;index<list.size();index++){
			System.out.println(list.get(index).toString());
		}
	}

}

输出:
扫描开始---
扫描结束---
添加用户:
before ----
after----
添加成功
-------------------------------------------
所有用户列表:
before ----
after----
User [uid=uid000, uname=uname000]
User [uid=uid001, uname=uname001]
User [uid=uid002, uname=uname002]
User [uid=uid003, uname=uname003]
User [uid=uid004, uname=uname004]
User [uid=uid-0001, uname=uname-0001]