用一个类（300行）手写Spring框架中已经基本实现了一个Spring框架，但是所有功能都放在了PIGDispatcherServlet一个类中，十分臃肿，违背了单一职责原则，因此需要将其中的功能进行分离。
首先考虑分离 IOC部分，先了解一下Spring源码中，负责这部分的几个比较重要的类——
ApplicationContext
上下文
BeanDefinition
Bean的定义，保存了Bean的定义方式（从配置文件中获取）
BeanWrapper
Bean的包装，由于spring中的对象可能是原生对象，也可能是代理对象，因此需要一个统一的包装类用来保存真实的实例。
BeanDefinitionReader
用来读取配置文件的工具类。
那么我们使用这几个类将IOC功能进行分离，新建类如下：
原servlet中需要分离的代码：
工具类，负责加载配置文件、解析与扫描相关类
package com.zhu.framework.beans.support;
import com.zhu.framework.beans.config.PigBeanDefinition;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* 读取配置文件的工具类
*/
public class PigBeanDefinitionReader {
// 配置文件的Properties类
private Properties contextConfig = new Properties();
// 扫描到的类名(需要注册到ioc容器的class)
private List<String> registryBeanClasses = new ArrayList<String>();
public PigBeanDefinitionReader(String[] configLocations) {
// 1.读取配置文件
doLoadConfig(configLocations[0]);
// 2.扫描相关类
doScanner(contextConfig.getProperty("scanPackage"));
}
public List<PigBeanDefinition> loadBeanDefinitions() {
List<PigBeanDefinition> result = new ArrayList<PigBeanDefinition>();
try {
for (String className : registryBeanClasses) {
Class<?> beanClass = Class.forName(className);
// 如果扫描到的是一个接口则不处理
if (beanClass.isInterface()) {continue;}
// 将信息封装为PigBeanDefinition对象，并添加到列表中
result.add(doCreateBeanDefinition(toLowerFirstCase(beanClass.getSimpleName()), beanClass.getName()));
// 如果这个类实现了某个接口，也需要将接口名+类名封装存入
for (Class<?> i : beanClass.getInterfaces()) {
result.add(doCreateBeanDefinition(i.getName(), beanClass.getName()));
}
}
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
private PigBeanDefinition doCreateBeanDefinition(String factoryBeanName, String beanClassName) {
PigBeanDefinition pigBeanDefinition = new PigBeanDefinition();
pigBeanDefinition.setFactoryBeanName(factoryBeanName);
pigBeanDefinition.setBeanClassName(beanClassName);
return pigBeanDefinition;
}
private void doLoadConfig(String contextConfigLocation) {
// 直接从ClassPath下找spring的配置文件
// 相当于把application.properties文件读到了内存中(contextConfig这个对象)
InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation.replaceAll("classpath:",""));
try {
contextConfig.load(is);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != is) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private void doScanner(String scanPackage) {
// 到ClassPath下找相关的.class文件
// scanPackage包路径对应一个文件夹
// 下面转为文件路径
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().replaceAll(".class", "");
// 可以在实例化阶段通过调用Class.forName(className)反射创建实例
registryBeanClasses.add(className);
}
}
}
private String toLowerFirstCase(String simpleName) {
char[] chars = simpleName.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
}
用于保存bean的定义信息，两个属性factoryBeanName保存短类名，beanClassName保存全类名。
在上面的工具类中，加了相关注解的bean被扫描后，类名信息被保存在BeanDefinition中。所有bean的定义信息，最后保存在beanDefinitionMap中，这是一个伪容器，因为并没有保存bean的实例。
package com.zhu.framework.beans.config;
/**
* 保存bean的配置信息
*/
public class PigBeanDefinition {
// 类名
private String factoryBeanName;
// 全类名
private String beanClassName;
public String getFactoryBeanName() {
return factoryBeanName;
}
public void setFactoryBeanName(String factoryBeanName) {
this.factoryBeanName = factoryBeanName;
}
public String getBeanClassName() {
return beanClassName;
}
public void setBeanClassName(String beanClassName) {
this.beanClassName = beanClassName;
}
}
负责在servlet初始化方法中，对bean进行实例化。
beanDefinitionMap中的所有bean将通过getBean()方法进行实例化与依赖注入。
package com.zhu.framework.context;
import com.zhu.framework.annotation.PIGAutowired;
import com.zhu.framework.annotation.PIGController;
import com.zhu.framework.annotation.PIGService;
import com.zhu.framework.beans.PigBeanWrapper;
import com.zhu.framework.beans.config.PigBeanDefinition;
import com.zhu.framework.beans.support.PigBeanDefinitionReader;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* IOC容器的主入口
*/
public class PigApplicationContext {
private String[] configLocations;
private PigBeanDefinitionReader reader;
private final Map<String, PigBeanDefinition> beanDefinitionMap = new HashMap<String, PigBeanDefinition>();
private Map<String, PigBeanWrapper> factoryBeanInstanceCache = new HashMap<String, PigBeanWrapper>();
// 单例bean的容器
private Map<String, Object> factoryBeanObjectCache = new HashMap<String, Object>();
public PigApplicationContext(String... configLocations) {
this.configLocations = configLocations;
try {
// 1.读取配置文件
reader = new PigBeanDefinitionReader(configLocations);
// 2.解析配置文件，将配置信息转为BeanDefinition对象
List<PigBeanDefinition> beanDefinitions = reader.loadBeanDefinitions();
// 3.把BeanDefinition对应实例注册到beanDefinitionMap key：beanName,value: beanDefinition对象
doRegisterBeanDefinition(beanDefinitions);
// 配置信息初始化阶段完成
// 4.完成依赖注入，时机为调用getBean()时
doAutowrited();
} catch (Exception e) {
e.printStackTrace();
}
}
public int getBeanDefinitionCount() {
return factoryBeanInstanceCache.size();
}
// 只处理非延时加载的情况
private void doAutowrited() {
for (Map.Entry<String, PigBeanDefinition> beanDefinitionEntry : this.beanDefinitionMap.entrySet()) {
String beanName = beanDefinitionEntry.getKey();
// 真正的注入需要在getBean方法中完成
// getBean方法：1.创建实例 2.依赖注入
getBean(beanName);
}
}
private void doRegisterBeanDefinition(List<PigBeanDefinition> beanDefinitions) throws Exception {
for (PigBeanDefinition beanDefinition : beanDefinitions) {
if (this.beanDefinitionMap.containsKey(beanDefinition.getFactoryBeanName())) {
throw new Exception("The " + beanDefinition.getFactoryBeanName() + " is exists!");
}
this.beanDefinitionMap.put(beanDefinition.getFactoryBeanName(), beanDefinition);
this.beanDefinitionMap.put(beanDefinition.getBeanClassName(), beanDefinition);
}
}
public Object getBean(Class beanClass) {
return getBean(beanClass.getName());
}
public Object getBean(String beanName) {
// 1.获取BeanDefinition配置信息
PigBeanDefinition beanDefinition = this.beanDefinitionMap.get(beanName);
// 2.反射进行实例化
Object instance = instantiateBean(beanName, beanDefinition);
// 3.将创建出来的实例包装为BeanWrapper对象
PigBeanWrapper beanWrapper = new PigBeanWrapper(instance);
// 4.把BeanWrapper对象存入真正的IoC容器中
this.factoryBeanInstanceCache.put(beanName, beanWrapper);
// 5.执行依赖注入
populateBean(beanName, beanDefinition, beanWrapper);
return this.factoryBeanInstanceCache.get(beanName).getWrapperInstance();
}
// 创建实例化对象
private Object instantiateBean(String beanName, PigBeanDefinition beanDefinition) {
// 全类名
String className = beanDefinition.getBeanClassName();
Object instance = null;
try {
Class<?> clazz = Class.forName(className);
instance = clazz.getDeclaredConstructor().newInstance();
// spring内部的容器不止一个
factoryBeanObjectCache.put(beanName, instance);
} catch (Exception e) {
e.printStackTrace();
}
return instance;
}
// 完成依赖注入
private void populateBean(String beanName, PigBeanDefinition beanDefinition, PigBeanWrapper beanWrapper) {
Object instance = beanWrapper.getWrapperInstance();
Class<?> clazz = beanWrapper.getWrapperClass();
// 只有加了注解的才进行依赖注入
// @Component
if (!(clazz.isAnnotationPresent(PIGController.class) || clazz.isAnnotationPresent(PIGService.class))) {
return;
}
// 拿到实例的所有字段（属性）
// 只能拿到public的属性
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
// 如果没有加Autowired注解则跳过
if (!field.isAnnotationPresent(PIGAutowired.class)) {
continue;
}
PIGAutowired autowired = field.getAnnotation(PIGAutowired.class);
String autowiredBeanName = autowired.value().trim();
// 若注解未指定值，则取其类型作为beanName
if ("".equals(autowiredBeanName)) {
autowiredBeanName = field.getType().getName();
}
// 暴力访问，保证所有访问类型都可注入成功
field.setAccessible(true);
try {
// 以下举例说明
// field相当于@PIGAutowired private IDemoService demoService (为DemoAction类中的一个字段)
// instance相当于DemoAction的实例
// this.factoryBeanInstanceCache.get(autowiredBeanName).getWrapperInstance()相当于从容器中拿到key为IDemoService（全类名)对应的实例，即demoService的实例
if (this.factoryBeanObjectCache.get(autowiredBeanName) == null) {
continue;
}
// 关键步骤
field.set(instance, this.factoryBeanInstanceCache.get(autowiredBeanName).getWrapperInstance());
} catch (IllegalAccessException e) {
e.printStackTrace();
continue;
}
}
}
public String[] getBeanDefinitionNames() {
return this.beanDefinitionMap.keySet().toArray(new String[this.beanDefinitionMap.size()]);
}
}
IOC容器实例的包装类，在getBean方法中，反射创建的实例被包装为BeanWrapper对象，然后存入到真正的IoC容器：factoryBeanInstanceCache中。
/**
* IOC容器实例的包装类
*/
public class PigBeanWrapper {
private Object wrapperInstance;
private Class<?> wrapperClass;
public PigBeanWrapper(Object wrapperInstance) {
this.wrapperClass = wrapperInstance.getClass();
this.wrapperInstance = wrapperInstance;
}
public Object getWrapperInstance() {
return wrapperInstance;
}
public Class<?> getWrapperClass() {
return wrapperClass;
}
}
由于四个步骤中的代码被分离出去，现在的DispatcherServlet简洁了不少，只有MVC功能将在下一章继续拆分。
package com.zhu.framework.servlet;
import com.zhu.framework.annotation.*;
import com.zhu.framework.context.PigApplicationContext;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.*;
public class PIGDispatcherServlet extends HttpServlet {
// 初始化ioc容器
private Map<String, Object> ioc = new HashMap<String, Object>();
// RequestMapping映射关系
private Map<String, Method> handlerMapping = new HashMap<String, Method>();
private PigApplicationContext applicationContext;
@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. 根据URL完成方法的调度
try {
doDispatch(req, resp);
} catch (Exception e) {
e.printStackTrace();
resp.getWriter().write("500 Exception Detail " + Arrays.toString(e.getStackTrace()));
}
}
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
// 获取URI：统一资源标识符 如/HttpStudy/demo1
String url = req.getRequestURI();
// 获取虚拟目录 如/HttpStudy
String contextPath = req.getContextPath();
// 将 /HttpStudy/demo1 替换为 /demo1
url = url.replaceAll(contextPath, "").replaceAll("/+", "/");
if (!this.handlerMapping.containsKey(url)) {
resp.getWriter().write("404 Not Found !!");
return;
}
Method method = this.handlerMapping.get(url);
// 获取请求中所有参数的map集合
Map<String,String[]> paramsMap = req.getParameterMap();
// 拿到方法的形参列表
Class<?>[] parameterTypes = method.getParameterTypes();
// 声明实参列表
Object[] paramValues = new Object[parameterTypes.length];
// 根据形参列表的配置 给实参列表赋值
for (int i = 0; i < parameterTypes.length; i++) {
Class paramterType = parameterTypes[i];
if (paramterType == HttpServletRequest.class) {
paramValues[i] = req;
continue;
} else if (paramterType == HttpServletResponse.class) {
paramValues[i] = resp;
continue;
} else if (paramterType == String.class) {
// 二维数组：一个方法有多个注解，一个注解有多个值
Annotation[][] pa = method.getParameterAnnotations();
for (int j = 0; j < pa.length; j++) {
for (Annotation annotation : pa[i]) {
if (annotation instanceof PIGRequestParam) {
// 从注解配置中取出参数名称
String paramName = ((PIGRequestParam) annotation).value();
if (!"".equals(paramName.trim())) {
// 从请求体中取出参数的值
String value = Arrays.toString(paramsMap.get(paramName))
.replaceAll("\\[|\\]","")
.replaceAll("\\s","");
paramValues[i] = value;
}
}
}
}
}
}
// 反射调用方法
// 第一个参数，Method所在的实例
// 第二个参数，Method的实参列表
method.invoke(applicationContext.getBean(method.getDeclaringClass()), paramValues);
}
// 初始化阶段
@Override
public void init(ServletConfig config) throws ServletException {
// ================== IoC =======================
applicationContext = new PigApplicationContext(config.getInitParameter("contextConfigLocation"));
// ================== MVC =======================
// 初始化HandlerMapping
doInitHandlerMapping();
System.out.println("PIG Spring framework is initialized!");
}
private void doInitHandlerMapping() {
if (applicationContext.getBeanDefinitionCount() == 0) {
return;
}
String [] beanNames = applicationContext.getBeanDefinitionNames();
for (String beanName : beanNames) {
Object instance = applicationContext.getBean(beanName);
Class<?> clazz = instance.getClass();
// 只针对加了Controller注解的类
if (!clazz.isAnnotationPresent(PIGController.class)) {
continue;
}
// 处理类上的url
String baseUrl = "";
if (clazz.isAnnotationPresent(PIGRequestMapping.class)) {
PIGRequestMapping requestMapping = clazz.getAnnotation(PIGRequestMapping.class);
baseUrl = requestMapping.value();
}
// 默认只获取public方法
for (Method method : clazz.getMethods()) {
// 只处理加了PIGRequestMapping注解的方法
if (!method.isAnnotationPresent(PIGRequestMapping.class)) {
continue;
}
// 拼接URL
PIGRequestMapping requestMapping = method.getAnnotation(PIGRequestMapping.class);
String url = ("/" + baseUrl + "/" + requestMapping.value()).replaceAll("/+","/");
// 存入map中
handlerMapping.put(url, method);
System.out.println("Mapped " + url +"," + method);
}
}
}
}