闭关修炼180天 -- 手写SpringMVC框架(迷你版)
SpringMvc知识须知
MVC设计模式
- Model（模型）：模型包含业务模型和数据模型，数据模型⽤于封装数据，业务模型⽤于处理业 务。
- View（视图）： 通常指的就是我们的 jsp 或者 html。作⽤⼀般就是展示数据的。通常视图是依据 模型数据创建的。
- Controller（控制器）： 是应⽤程序中处理⽤户交互的部分。作⽤⼀般就是处理程序逻辑的。
springMvc请求执行流程
- ⽤户发送请求⾄前端控制器DispatcherServlet
- DispatcherServlet收到请求调⽤HandlerMapping处理器映射器
- 处理器映射器根据请求Url找到具体的Handler（后端控制器），⽣成处理器对象及处理器拦截 器(如果 有则⽣成)⼀并返回DispatcherServlet
- DispatcherServlet调⽤HandlerAdapter处理器适配器去调⽤Handler
- 处理器适配器执⾏Handler
- Handler执⾏完成给处理器适配器返回ModelAndView
- 处理器适配器向前端控制器返回 ModelAndView，ModelAndView 是SpringMVC 框架的⼀个 底层对 象，包括 Model 和 View
- 前端控制器请求视图解析器去进⾏视图解析，根据逻辑视图名来解析真正的视图。
- 视图解析器向前端控制器返回View
- 前端控制器进⾏视图渲染，就是将模型数据（在 ModelAndView 对象中）填充到 request 域
- 前端控制器向⽤户响应结果
SpringMVC九大核心组件
- 1.HandlerMapping（处理器映射器）：找到请求响应的处理器Handler和Interceptor
- 2.HandlerAdapter（处理器适配器）：要让固定的Servlet处理方法调用Handler来处理
- 3.HandlerExceptionResolver(异常处理器)，用于处理Handler产生的异常情况
- 4.ViewResolver(视图解析器),将Sting类型的视图名解析为View类型的视图
- 5.RequestToViewNameTranslator,在请求域中获取ViewName，当Handler处理完后，没有设置View,那便从这个组件中从请求中获取ViewName
- 6.LocaleResolver，区域化国际化组件
- 7.ThemeResolver 主题解析器
- 8.MultipartResolver多文件上传解析器
- 9.FlashMapManager，用于重定向时的参数传递
自定义SpringMVC框架
大致流程
- 引进javax.servlet坐标，创建servlet包，创建HttpServlet的实现类MyServlet
- 创建annotation包，创建四个注解：@MyController,@MyRequestMapping,@MyService,@MyAutowired
- 重写HttpServlet的几个方法init(),doPost(),doGet()
- 在init()方法中加载解析springMvc.xml文件
- 在init()方法中完成注解的功能增强。
- 在init()方法中初始化ioc容器
- 在init()方法中完成依赖的注入
- 构造一个处理器映射器HandlerMapping，将我们处理好的url和Method建立映射关系
- 处理权限关系
项目结构
代码实现
1.pom文件主要内容
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.9</version> </dependency> </dependencies> <build> <plugins> <!--编译插件定义编译细节--> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.1</version> <configuration> <source>8</source> <target>8</target> <encoding>utf-8</encoding> <!--告诉编译器，编译的时候记录下形参的真实名称--> <compilerArgs> <arg>-parameters</arg> </compilerArgs> </configuration> </plugin> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <port>8080</port> <path>/</path> </configuration> </plugin> </plugins> </build>
2.web.xml 以及 springmvc.properties
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" > <web-app> <display-name>Archetype Created Web Application</display-name> <servlet> <servlet-name>MyServlet</servlet-name> <servlet-class>com.zae.frame.servlet.MyServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>springmvc.properties</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>MyServlet</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> </web-app>
scanPackage=com.zae
3.五个注解的定义
import java.lang.annotation.*; @Documented @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface MyAutowired { String value() default ""; }
import java.lang.annotation.*; @Documented @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface MyController { String value() default ""; }
import java.lang.annotation.*; @Documented @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface MyRequestMapping { String value() default ""; }
@Documented @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface MyService { String value() default ""; }
/** * 1.当未添加该注解时，表明该方法不加入权限控制，所有请求均可访问 * 2.当该注解放置在某个类上，则表明该类下的所有方法都可以被该注解指定的用户访问 * 3.当该注解放置在某个方法时，则以该方法上的用户指定为准 */ @Target({ElementType.TYPE,ElementType.METHOD}) @Documented @Retention(RetentionPolicy.RUNTIME) public @interface Security { //配置用户名称，指定的用户可以访问 String [] value() default {"/"}; }
4.handler实体的定义
import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; import java.util.regex.Pattern; /** * 封装映射关系 */ public class Handler { //controller private Object controller; //方法 private Method method; //url的正则表达式 private Pattern pattern; //存储参数字段以及其的入参位置 private Map<String,Integer> handlerMapping; //存储有权限访问的用户 private String [] securityUser; public Handler(Object controller, Method method, Pattern pattern) { this.controller = controller; this.method = method; this.pattern = pattern; this.handlerMapping = new HashMap<String, Integer>(); } public String[] getSecurityUser() { return securityUser; } public void setSecurityUser(String[] securityUser) { this.securityUser = securityUser; } public Object getController() { return controller; } public void setController(Object controller) { this.controller = controller; } public Method getMethod() { return method; } public void setMethod(Method method) { this.method = method; } public Pattern getPattern() { return pattern; } public void setPattern(Pattern pattern) { this.pattern = pattern; } public Map<String, Integer> getHandlerMapping() { return handlerMapping; } public void setHandlerMapping(Map<String, Integer> handlerMapping) { this.handlerMapping = handlerMapping; } }
5.MyServlet核心类的实现
import com.zae.frame.annotation.*; import com.zae.frame.pojo.Handler; import org.apache.commons.lang3.StringUtils; import javax.servlet.ServletConfig; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Parameter; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; public class MyServlet extends HttpServlet { //配置文件信息：springmvc.xml Properties properties = new Properties(); //存放扫描包下的全限类名 List<String> classList = new ArrayList<String>(); //ioc容器，存放实例对象 Map<String,Object> beanMap = new HashMap<String,Object>(); //存放Handler的集合 List<Handler> handlerList = new ArrayList<Handler>(); @Override public void init(ServletConfig config){ //1.加载配置文件：springmvc.xml String path = config.getInitParameter("contextConfigLocation"); doLoanConfig(path); //2.扫描包下所有的类 doScan(properties.getProperty("scanPackage")); //3.初始化bean对象，基于注解，加入ioc容器 doInstance(); //4.完成依赖的注入@MyAutowired doAutowired(); //5.构建好一个HandlerMapping，完成url和method之间的映射关系 initHandleMapping(); //6.处理用户权限问题 doSecurity(); System.out.println("迷你版SpringMvc初始化完成...."); } /** * 完成Controller层的用户访问权限问题 */ private void doSecurity() { if (handlerList.size() == 0){return;} for(Handler handler:handlerList){ Class<?> aClass = handler.getController().getClass(); String [] securityUserArr = null; //1.当controller类上有@Security注解时，则改类中所有的方法都加入权限控制，以类上的@Security里面的value为准 if(aClass.isAnnotationPresent(Security.class)){ Security annotation = aClass.getAnnotation(Security.class); securityUserArr = annotation.value(); } //2.当方法上存在@Security注解时，则以方法的@Security中的value为准，覆盖类上声明的那个权限注解 Method method = handler.getMethod(); if(method.isAnnotationPresent(Security.class)){ Security annotation = method.getAnnotation(Security.class); securityUserArr = annotation.value(); } //3.如果无论controller类还是其中的方法都没有加Security注解，此时securityUserArr==null,那么可以任意访问，不会拦截， //4.如果controller层加了Security注解，但是没有重新定义value值或者value值声明为{"/"}，那么此时securityUserArr=={"/"}，会拦截所有用户的请求 handler.setSecurityUser(securityUserArr); } } /** * 完成url与方法之间的映射 */ private void initHandleMapping() { if(beanMap.size() == 0){return;} for(Map.Entry<String,Object> map:beanMap.entrySet()){ Class<?> aClass = map.getValue().getClass(); String baseUrl = ""; //当controller类上有MyRequestMapping注解时，基础url为value值 if(aClass.isAnnotationPresent(MyRequestMapping.class)){ MyRequestMapping annotation = aClass.getAnnotation(MyRequestMapping.class); baseUrl = annotation.value(); } //获取Controller的所有方法 Method[] methods = aClass.getMethods(); for (Method method : methods) { //当方法上有MyRequestMapping注解时，获取其value值 if(method.isAnnotationPresent(MyRequestMapping.class)){ MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class); //请求url String url = baseUrl+annotation.value(); Pattern compile = Pattern.compile(url); Handler handler = new Handler(map.getValue(),method,compile); //计算方法的参数位置信息 Parameter[] parameters = method.getParameters(); for (int i = 0; i < parameters.length; i++) { //当参数为HttpServletRequest和HttpServletResponse时，key存储的是参数的类型名 if(parameters[i].getType() == HttpServletRequest.class || parameters[i].getType() == HttpServletResponse.class){ handler.getHandlerMapping().put(parameters[i].getType().getSimpleName(),i); }else{ //当其他情况的时候，key存储的是参数名称 handler.getHandlerMapping().put(parameters[i].getName(),i); } } //将handler存储起来 handlerList.add(handler); } } } } /** * 依赖注入 */ private void doAutowired() { if(beanMap.size()==0){return;} for(Map.Entry<String,Object> mapEntry:beanMap.entrySet()){ String key = mapEntry.getKey(); Object value = mapEntry.getValue(); Class<?> aClass = value.getClass(); //获取该类下所有的属性 Field[] declaredFields = aClass.getDeclaredFields(); for (Field declaredField : declaredFields) { //判断属性上是否存在MyAutowired注解 if(declaredField.isAnnotationPresent(MyAutowired.class)){ MyAutowired annotation = declaredField.getAnnotation(MyAutowired.class); //获取注解里面的value值 String name = annotation.value(); //设置暴力访问 declaredField.setAccessible(true); if("".equals(name.trim())){ //当注解的value值为空时，获取属性类型的全限类名，使用类型注入依赖 name = declaredField.getType().getName(); } try { //给该属性赋值 declaredField.set(value,beanMap.get(name)); } catch (IllegalAccessException e) { e.printStackTrace(); } } } //依赖赋值结束后，重新加入map集合中 beanMap.put(key,value); } } /** * 基于注解完成ioc的初始化 */ private void doInstance() { if(classList.size()==0){return;} for (String className : classList) { try { //根据全限类名获取类对象 Class<?> aClass = Class.forName(className); if(aClass.isAnnotationPresent(MyService.class)){ MyService annotation = aClass.getAnnotation(MyService.class); String value = annotation.value(); Object beanObj = aClass.newInstance(); if("".equals(value)){ //当service注解为空时，使用首字母小写的类名 value = firstToLower(aClass.getSimpleName()); beanMap.put(value,beanObj); }else{ //当service的value不为空时，使用注解里面的value值 beanMap.put(value,beanObj); } //面向接口开发，以接口全限类名作为id放入容器(针对service层存在接口) Class<?>[] interfaces = aClass.getInterfaces(); if(interfaces!=null){ for (Class<?> anInterface : interfaces) { beanMap.put(anInterface.getName(),aClass.newInstance()); } } }else if(aClass.isAnnotationPresent(MyController.class)){ //MyController注解的类使用首字母小写的类名 Object beanObj = aClass.newInstance(); beanMap.put(firstToLower(aClass.getSimpleName()),beanObj); }else{ continue; } } catch (Exception e) { e.printStackTrace(); } } } private String firstToLower(String source){ if(source==null){return null;} char[] chars = source.toCharArray(); if(chars[0]>='A' && chars[0]<='Z'){ chars[0] += 32; } return String.valueOf(chars); } /** * 扫描包下所有的类 * @param scanPackage */ private void doScan(String scanPackage) { String scanPackagePath =Thread.currentThread().getContextClassLoader().getResource("").getPath()+scanPackage.replaceAll("\\.","/"); File fileScan = new File(scanPackagePath); File[] files = fileScan.listFiles(); for (File file : files) { if(file.isDirectory()){ //如果是文件夹，就继续递归 doScan(scanPackage+"."+file.getName()); }else if(file.getName().endsWith(".class")){ String className = scanPackage+"."+file.getName().replaceAll(".class",""); classList.add(className); } } } /** * 加载springmvc.properties配置文件 * @param path */ private void doLoanConfig(String path) { InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(path); try { properties.load(resourceAsStream); } catch (IOException e) { e.printStackTrace(); } } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException { //设置中文编码格式 resp.setContentType("text/html;charset=UTF-8"); doPost(req,resp); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException { Handler handler = getHandler(req); if(handler == null){ resp.getWriter().write("404 No fount"); return; } //检查用户权限问题 if(!checkSecurity(handler,req,resp)){return;} //参数绑定工作 Class<?>[] parameterTypes = handler.getMethod().getParameterTypes(); //根据上述长度创建一个新的数组，参数传递时反射调用 Object[] objParam = new Object[parameterTypes.length]; //为了向参数数组中塞值，保证形参和方法的参数顺序一致 Map<String, String[]> parameterMap = req.getParameterMap(); //拿到方法的入参顺序 Map<String, Integer> handlerMapping = handler.getHandlerMapping(); for(Map.Entry<String,String[]> map:parameterMap.entrySet()){ String join = StringUtils.join(map.getValue(), ","); String key = map.getKey(); //如果字段名字匹配上了，则进行赋值操作 if(parameterMap.containsKey(key)){ objParam[handlerMapping.get(key)] = join; } } //处理HttpServletRequest和HttpServletResponse int reqIndex = handlerMapping.get(HttpServletRequest.class.getSimpleName()); int respIndex = handlerMapping.get(HttpServletResponse.class.getSimpleName()); objParam[reqIndex] = req; objParam[respIndex] = resp; Method method =handler.getMethod(); Object controllerObj = handler.getController(); try { //进行方法调用 method.invoke(controllerObj,objParam); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } /** * 检查用户权限问题 * @param req * @return */ private Boolean checkSecurity(Handler handler,HttpServletRequest req,HttpServletResponse resp) throws IOException { //当securityUser == null时，没有加权限控制，任意请求都能访问 if(handler.getSecurityUser() == null){ return true; } //当securityUser == {/}，任意请求都不能访问 if("/".equals(handler.getSecurityUser()[0])){ resp.getWriter().write("您无权访问！请联系管理员"); return false; } //前端的参数，访问的用户 String username = req.getParameter("username"); //当securityUser存在值时，则进行校验 List<String> userList = Arrays.asList(handler.getSecurityUser()); if(userList.contains(username)){ return true; }else{ resp.getWriter().write("您无权访问！请联系管理员"); return false; } } /** * 根据请求获取Handler对象 * @param req * @return */ private Handler getHandler(HttpServletRequest req){ if(handlerList.isEmpty()){return null;} String url = req.getRequestURI(); for (Handler handler : handlerList) { //判断url和正则是否匹配 Matcher matcher = handler.getPattern().matcher(url); if(!matcher.matches()){continue;} return handler; } return null; } }
6.使用端Service以及Controller（测试使用，不再关联数据库了）
public interface TestService { String start(String username); }
import com.zae.demo.service.TestService; import com.zae.frame.annotation.MyService; @MyService public class TestServiceImpl implements TestService { @Override public String start(String username) { System.out.println("访问的用户为："+username); return username; } }
import com.zae.demo.service.TestService; import com.zae.frame.annotation.MyAutowired; import com.zae.frame.annotation.MyController; import com.zae.frame.annotation.MyRequestMapping; import com.zae.frame.annotation.Security; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @Security({"wangsulong","xuezhiqian"}) @MyController @MyRequestMapping("/demoSecurity") public class TestSecurityController { @MyAutowired private TestService testService; /** * 方法中有@Security，则覆盖类定义的权限注解 * @param request * @param response * @param username * @return */ @Security({"xusong"}) @MyRequestMapping("/startSecurityOne") public String startSecurityOne(HttpServletRequest request, HttpServletResponse response,String username){ return testService.start(username); } /** * 方法中没有@Security，则使用类里面的权限注解定义的 * @param request * @param response * @param username * @return */ @MyRequestMapping("/startSecurityTwo") public String startSecurityTwo(HttpServletRequest request, HttpServletResponse response,String username){ return testService.start(username); } /** * @Security中的value没有设定值，则拦截所欲 * @param request * @param response * @param username * @return */ @Security @MyRequestMapping("/startSecurityThree") public String startSecurityThree(HttpServletRequest request, HttpServletResponse response,String username){ return testService.start(username); } }
自定义SpringMvc框架至此结束
文章知识点输出来源：拉勾教育Java高薪训练营
2021第一天，我是帝莘，期待和你的技术交流以及思想碰撞
