SpringMVC 底层机制的简易实现
- 项目基础
- 配置 xml 文件
- 开发指南
- 开发步骤
- 1.初始化数据
- 2.中央控制器 - 分发请求
- 3.开发者角度
- 4.视图解析器
- 开发总结
项目基础
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--原生 Servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<!--作用范围-->
<!--provided：表示该项目在打包放在生产环境的时候不用带上 servlet-api.jar 包-->
<!--目的: 防止和 tomcat 中该jar冲突-->
<scope>provided</scope>
</dependency>
<!--引入 xml 解析工具-->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<!--引入常用工具-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.5</version>
</dependency>
</dependencies>
配置 xml 文件
mySpringMVC.xml 文件：用来指定扫描包路径
<?xml version="1.0" encoding="utf-8" ?>
<beans>
<component-scan base-package="com.al_tair"></component-scan>
</beans>
web.xml 文件
- 指定要操作的 spring 容器配置文件名
- 配置自动加载
- 路径全部访问中央控制器
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>MyDispatcherServlet</servlet-name>
<servlet-class>com.al_tair.servlet.MyDispatcherServlet</servlet-class>
<!--指定要操作的 spring 容器配置文件-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:mySpringMVC.xml</param-value>
</init-param>
<!--自动加载-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>MyDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
开发指南
开发步骤
MyDispatcherServlet 本质就是一个 Servlet ，那么我们就知道他的基本特性，刚启动服务的时候，我们会进行初始化，然后每进行 http 请求，就会访问 Service 方法（这里交给 Servet 的父类来实现，我们只需要实现 doPost 和 doGet 的方法）
1.初始化数据
@Override
public void init(ServletConfig config) throws ServletException {
// 需要将 config 传给父类，才可以获取工程路径
super.init(config);
// 上述 web.xml 文件中指定了该参数为 Spring 容器的文件名 mySpringMVC.xml
String contextConfigLocation = config.getInitParameter("contextConfigLocation");
// 分成两步骤进行理解
// 1.通过 xml 解析获取到该 mySpringMVC.xml 的包路径
// 2.将该路径进行扫描，生成 ioc 容器
ioc = new SpringIocApplicationContext(XmlParser.getBasePackage(contextConfigLocation.split(":")[1]));
// 初始化映射器
initHandlerMapper();
}
-
XmlParser 解析器
public class XmlParser { public static String getBasePackage(String fileName){ // 解析器 SAXReader saxReader = new SAXReader(); // 获取到资源路径 InputStream in = XmlParser.class.getClassLoader().getResourceAsStream(fileName); String basePackage = null; try { Document read = saxReader.read(in); // 获取到 component-scan 元素 Element element = read.getRootElement().element("component-scan"); // 扫描包路径 basePackage = element.attribute("base-package").getText(); } catch (Exception e) { e.printStackTrace(); } return basePackage; } } -
初始化 ioc 容器（我主要介绍实现过程）
- 获取扫描包的全路径
- 通过类加载器获取到对应包的资源路径
- 扫描资源路径，将 java 文件生成的 .class 文件路径保存到 List 集合中
- 遍历每个 java 文件路径，并进行类加载，通过判断是否有注解（MyController 、MyService、MyMapper、MyComponent）
- 然后通过注解上的值来获取对应 id（默认方法名首字母小写），并划分单例还是多例（用于判断是否当下就创建对象并放入 ioc 容器中）
- ioc 容器用于存储 id <=> BeanDefinition对象（属性有 scope、Class对象）
- singletonObject 单例池用于存储 id <=> 单例对象
-
初始化映射器
private void initHandlerMapper() { // 默认所有映射都是非懒加载的单例池中 ConcurrentHashMap<String, Object> singletonObject = ioc.getSingletonObject(); if (singletonObject.isEmpty()) { return; } else { for (Map.Entry<String, Object> entry : singletonObject.entrySet()) { // 拿到加载的类对应的 Class 类 Class<?> aClass = entry.getValue().getClass(); // 判断是否是控制类 if (aClass.isAnnotationPresent(MyController.class)) { // 1.获取类注解值 String classValue = ""; // 2.获取类上路径地址 if (aClass.isAnnotationPresent(MyRequestMapping.class)) { MyRequestMapping annotation = aClass.getAnnotation(MyRequestMapping.class); classValue = annotation.value(); } // 3.获取到控制类中的所有方法 Method[] declaredMethods = aClass.getDeclaredMethods(); for (Method declaredMethod : declaredMethods) { if (declaredMethod.isAnnotationPresent(MyRequestMapping.class)) { MyRequestMapping MyRequestMappingAnnotation = declaredMethod.getAnnotation(MyRequestMapping.class); // getServletContext().getContextPath() 获取工程路径 String url = getServletContext().getContextPath() + classValue + MyRequestMappingAnnotation.value(); // 创建 HandlerMapper 对象(用于存储 访问的 url、controller 对象、对应的方法) HandlerMapper handlerMapper = new HandlerMapper(url, entry.getValue(), declaredMethod); // HandlerList 集合用来保存每个能够访问到的对应类的对应方法信息 HandlerList.add(handlerMapper); } } } } } }
2.中央控制器 - 分发请求
刚开始讲到了中央控制器本质就是 Servlet，每次请求都会访问 Service，然后分发到对应的请求类型比如 get、post等等
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 防止乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
// 分发请求
executeDispatch(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
}
分发请求（同时也会接收返回的结果，这个后续讲解）
<!-- 用于获取请求参数名（默认为 args0、args1等）-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArgs>
<arg>-parameters</arg>
</compilerArgs>
<encoding>utf-8</encoding>
</configuration>
</plugin>
private void executeDispatch(HttpServletRequest req, HttpServletResponse resp) {
HandlerMapper handler = getHandler(req);
// 判断路径是否匹配成功
if (handler == null) {
try {
resp.getWriter().print("<h1>404 not found</h1>");
} catch (IOException e) {
log.print(e.getMessage());
}
} else {
// 1.获取请求的方法
Method method = handler.getMethod();
// 2.获取请求方法的参数类型列表
Class<?>[] parameterTypes = method.getParameterTypes();
// 用于匹配对应方法的参数，可以自动化装配
Object[] params = new Object[parameterTypes.length];
// 3.遍历每个参数，并填充数据
for (int i = 0; i < parameterTypes.length; i++) {
Class<?> parameterType = parameterTypes[i];
// 4.获取类型的简单名称，就是类名（原来名称全包名）
String simpleName = parameterType.getSimpleName();
if ("HttpServletRequest".equals(simpleName)) {
params[i] = req;
} else if ("HttpServletResponse".equals(simpleName)) {
params[i] = resp;
}
}
// 5.传入的参数的 key - value
Map<String, String[]> parameterMap = req.getParameterMap();
// 6.对应方法参数上的信息
Parameter[] parameters = method.getParameters();
// 7.遍历方法的每个参数并根据参数名或者注解值来填入数据
for (int i = 0; i < params.length; i++) {
if(params[i] == null){
boolean isMyRequestParam = parameters[i].isAnnotationPresent(MyRequestParam.class);
// 参数名
String paramName = "";
if(isMyRequestParam){
paramName = parameters[i].getDeclaredAnnotation(MyRequestParam.class).value();
}else{
// 注意获取参数名必须添加脚本文件在 pom.xml 中
paramName = parameters[i].getName();
}
for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
if(paramName.equals(entry.getKey())){
// 根据类型来判断是否是数组或者集合等等
if("List".equals(parameterTypes[i].getSimpleName())){
params[i] = Arrays.asList(entry.getValue());
}else if(parameterTypes[i].getSimpleName().contains("[]")){
params[i] = entry.getValue();
}else{
params[i] = entry.getValue()[0];
}
break;
}
}
}
}
try {
// 匹配成功，通过反射来调用对应的类(返回结果暂时就是默认 String 类型)
Object result = method.invoke(handler.getController(), params);
// 重定向或者请求转发（视图解析操作）
viewParser(req,resp,method,result);
} catch (Exception e) {
log.print(e.getMessage());
}
}
}
3.开发者角度
开发控制层、服务层、Dao层，用于接口的开发等等…
4.视图解析器
主要用于方法调用完之后接下来的操作（重定向、请求转发、或者返回 json 格式数据等等操作）
<!--引入jackson 使用他的工具类可以进行json操作 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.4</version>
</dependency>
public void viewParser(HttpServletRequest request,HttpServletResponse response,Method method,Object result){
if(result instanceof String){
// 返回结果: forward:/200_ok.jsp(例子)
String res = (String)result;
if(res.contains(":")){
String[] split = res.split(":");
if("forward".equals(split[0])){
try {
request.getRequestDispatcher(split[1]).forward(request,response);
} catch (Exception e) {
System.out.println("请求转发异常" + e.getMessage());
}
}else if("redirect".equals(split[0])){
try {
// 重定向需要获取工程路径
response.sendRedirect(getServletContext().getContextPath() + split[1]);
} catch (IOException e) {
System.out.println("重定向异常" + e.getMessage());
}
}
// 默认请求转发
}else{
try {
request.getRequestDispatcher(res).forward(request,response);
} catch (Exception e) {
System.out.println("请求转发异常" + e.getMessage());
}
}
}else {
// 判断是否需要解析成 json 格式的数据
if(method.isAnnotationPresent(MyResponseBody.class)){
if(result instanceof List){
// jackson 工具类
ObjectMapper objectMapper = new ObjectMapper();
try {
String res = objectMapper.writeValueAsString(result);
PrintWriter writer = null;
try {
writer = response.getWriter();
writer.write(res);
} catch (IOException e) {
System.out.println(e.getMessage());
}finally {
writer.flush();
writer.close();
}
} catch (JsonProcessingException e) {
System.out.println("json 解析错误" + e.getMessage());
}
}
}
}
}
开发总结
我简易实现 SpringMVC 底层机制，主要是为了熟悉该框架的流程，加深编程的思想深度，可能存在很多问题，希望大家能够帮忙提出，感谢！
