Spring容器初始化实现V2 版本

在V1 版本上进了优化，采用了常用的设计模式（工厂模式、单例模式、委派模式、策略模式），将init()方法中的代码进行封装。按照之前的实现思路，先搭基础框架，再填肉注血，具体代码如下：

//初始化阶段
@Override
public void init(ServletConfig config) throws ServletException {

	//1、加载配置文件
	doLoadConfig(config.getInitParameter("contextConfigLocation"));

	//2、扫描相关的类
	doScanner(contextConfig.getProperty("scanPackage"));
	
	//3、初始化扫描到的类，并且将它们放入到ICO容器之中
	doInstance();
	
	//4、完成依赖注入
	doAutowired();

	//5、初始化HandlerMapping
	initHandlerMapping();

	System.out.println("GP Spring framework is init.");

}

声明全局的成员变量，其中IOC 容器就是注册时单例的具体案例：

//保存application.properties配置文件中的内容
private Properties contextConfig = new Properties();

//保存扫描的所有的类名
private List<String> classNames = new ArrayList<String>();

//传说中的IOC容器，我们来揭开它的神秘面纱
//为了简化程序，暂时不考虑ConcurrentHashMap
// 主要还是关注设计思想和原理
private Map<String,Object> ioc = new HashMap<String,Object>();

//保存url和Method的对应关系
private Map<String,Method> handlerMapping = new HashMap<String,Method>();

实现doLoadConfig()方法：

//加载配置文件
private void doLoadConfig(String contextConfigLocation) {
	//直接从类路径下找到Spring主配置文件所在的路径
	//并且将其读取出来放到Properties对象中
	//相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
	InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
	try {
		contextConfig.load(fis);
	} catch (IOException e) {
		e.printStackTrace();
	}finally {
		if(null != fis){
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

实现doScanner()方法：

//扫描出相关的类
private void doScanner(String scanPackage) {
	//scanPackage = com.gupaoedu.demo ，存储的是包路径
	//转换为文件路径，实际上就是把.替换为/就OK了
	//classpath
	URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.","/"));
	File classPath = new File(url.getFile());
	for (File file : classPath.listFiles()) {
		if(file.isDirectory()){
			doScanner(scanPackage + "." + file.getName());
		}else{
			if(!file.getName().endsWith(".class")){ continue;}
			String className = (scanPackage + "." + file.getName().replace(".class",""));
			classNames.add(className);
		}
	}
}

实现doInstance()方法，doInstance()方法就是工厂模式的具体实现：

private void doInstance() {
	//初始化，为DI做准备
	if(classNames.isEmpty()){return;}

	try {
		for (String className : classNames) {
			Class<?> clazz = Class.forName(className);

			//什么样的类才需要初始化呢？
			//加了注解的类，才初始化，怎么判断？
			//为了简化代码逻辑，主要体会设计思想，只举例 @Controller和@Service,
			// @Componment...就一一举例了
			if(clazz.isAnnotationPresent(GPController.class)){
				Object instance = clazz.newInstance();
				//Spring默认类名首字母小写
				String beanName = toLowerFirstCase(clazz.getSimpleName());
				ioc.put(beanName,instance);
			}else if(clazz.isAnnotationPresent(GPService.class)){
				//1、自定义的beanName
				GPService service = clazz.getAnnotation(GPService.class);
				String beanName = service.value();
				//2、默认类名首字母小写
				if("".equals(beanName.trim())){
					beanName = toLowerFirstCase(clazz.getSimpleName());
				}

				Object instance = clazz.newInstance();
				ioc.put(beanName,instance);
				//3、根据类型自动赋值,投机取巧的方式
				for (Class<?> i : clazz.getInterfaces()) {
					if(ioc.containsKey(i.getName())){
						throw new Exception("The “" + i.getName() + "” is exists!!");
					}
					//把接口的类型直接当成key了
					ioc.put(i.getName(),instance);
				}
			}else {
				continue;
			}

		}
	}catch (Exception e){
		e.printStackTrace();
	}

}

为了处理方便，自己实现了toLowerFirstCase 方法，来实现类名首字母小写，具体代码如下：

//如果类名本身是小写字母，确实会出问题
//但是我要说明的是：这个方法是我自己用，private的
//传值也是自己传，类也都遵循了驼峰命名法
//默认传入的值，存在首字母小写的情况，也不可能出现非字母的情况

//为了简化程序逻辑，就不做其他判断了，大家了解就OK
//其实用写注释的时间都能够把逻辑写完了
private String toLowerFirstCase(String simpleName) {
	char [] chars = simpleName.toCharArray();
	//之所以加，是因为大小写字母的ASCII码相差32，
	// 而且大写字母的ASCII码要小于小写字母的ASCII码
	//在Java中，对char做算学运算，实际上就是对ASCII码做算学运算
	chars[0] += 32;
	return String.valueOf(chars);
}

实现doAutowired()方法：

//自动依赖注入
private void doAutowired() {
	if(ioc.isEmpty()){return;}

	for (Map.Entry<String, Object> entry : ioc.entrySet()) {
		//Declared 所有的，特定的 字段，包括private/protected/default
		//正常来说，普通的OOP编程只能拿到public的属性
		Field[] fields = entry.getValue().getClass().getDeclaredFields();
		for (Field field : fields) {
			if(!field.isAnnotationPresent(GPAutowired.class)){continue;}
			GPAutowired autowired = field.getAnnotation(GPAutowired.class);

			//如果用户没有自定义beanName，默认就根据类型注入
			//这个地方省去了对类名首字母小写的情况的判断，这个作为课后作业
			//小伙伴们自己去完善
			String beanName = autowired.value().trim();
			if("".equals(beanName)){
				//获得接口的类型，作为key待会拿这个key到ioc容器中去取值
				beanName = field.getType().getName();
			}

			//如果是public以外的修饰符，只要加了@Autowired注解，都要强制赋值
			//反射中叫做暴力访问， 强吻
			field.setAccessible(true);

			try {
				//用反射机制，动态给字段赋值
				field.set(entry.getValue(),ioc.get(beanName));
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}


		}

	}


}

实现initHandlerMapping()方法，handlerMapping 就是策略模式的应用案例：

//初始化url和Method的一对一对应关系
private void initHandlerMapping() {
	if(ioc.isEmpty()){ return; }

	for (Map.Entry<String, Object> entry : ioc.entrySet()) {
		Class<?> clazz = entry.getValue().getClass();

		if(!clazz.isAnnotationPresent(GPController.class)){continue;}


		//保存写在类上面的@GPRequestMapping("/demo")
		String baseUrl = "";
		if(clazz.isAnnotationPresent(GPRequestMapping.class)){
			GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);
			baseUrl = requestMapping.value();
		}

		//默认获取所有的public方法
		for (Method method : clazz.getMethods()) {
			if(!method.isAnnotationPresent(GPRequestMapping.class)){continue;}

			GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);
			//优化
			// //demo///query
			String url = ("/" + baseUrl + "/" + requestMapping.value())
						.replaceAll("/+","/");
			handlerMapping.put(url,method);
			System.out.println("Mapped :" + url + "," + method);

		}


	}


}

到这里位置初始化阶段就已经完成，接下实现运行阶段的逻辑，来看doPost/doGet 的代码：

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	this.doPost(req,resp);
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

	//6、调用，运行阶段
	try {
		doDispatch(req,resp);
	} catch (Exception e) {
		e.printStackTrace();
		resp.getWriter().write("500 Exection,Detail : " + Arrays.toString(e.getStackTrace()));
	}


}

doPost()方法中，用了委派模式，委派模式的具体逻辑在doDispatch()方法中：

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
	//绝对路径
	String url = req.getRequestURI();
	//处理成相对路径
	String contextPath = req.getContextPath();
	url = url.replaceAll(contextPath,"").replaceAll("/+","/");

	if(!this.handlerMapping.containsKey(url)){
		resp.getWriter().write("404 Not Found!!!");
		return;
	}


	Method method = this.handlerMapping.get(url);


	//从reqest中拿到url传过来的参数
	Map<String,String[]> params = req.getParameterMap();

	//获取方法的形参列表
	Class<?> [] parameterTypes = method.getParameterTypes();

	Object [] paramValues = new Object[parameterTypes.length];

	for (int i = 0; i < parameterTypes.length; i ++) {
		Class parameterType = parameterTypes[i];
		//不能用instanceof，parameterType它不是实参，而是形参
		if(parameterType == HttpServletRequest.class){
			paramValues[i] = req;
			continue;
		}else if(parameterType == HttpServletResponse.class){
			paramValues[i] = resp;
			continue;
		}else if(parameterType == String.class){
			GPRequestParam requestParam = (GPRequestParam)parameterType.getAnnotation(GPRequestParam.class);
			if(params.containsKey(requestParam.value())) {
				for (Map.Entry<String,String[]> param : params.entrySet()){
					String value = Arrays.toString(param.getValue())
							.replaceAll("\\[|\\]","")
							.replaceAll("\\s",",");
					paramValues[i] = value;
				}
			}
		}
	}

	//投机取巧的方式
	//通过反射拿到method所在class，拿到class之后还是拿到class的名称
	//再调用toLowerFirstCase获得beanName
	String beanName  = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
	method.invoke(ioc.get(beanName),paramValues);
}