devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

自己动手实现简易的springmvc_如何实现springmvc

作者：Gausst松鼠会 | 2024-02-07 22:16:42

赞

踩

如何实现springmvc

目录

实现过程思路分析

自定义注解

中央控制器DispatcherServlet

总结

实现过程思路分析

1、创建Maven工程
2、创建控制层、业务层代码(Controller、Service、自定义注解)、准备SpringMvc核心配置文件
3、准备前端控制器 ，创建一个Servlet，同时在web.xml文件中声明该前端控制器
4、创建Spring容器，通过DOM4J解析springmvc的XML文件
5、扫描springmvc中的控制器以及service类并实例化对象放入容器中
6、实现容器中对象的注入，比如将服务层对象注入至控制层
7、建立请求映射地址与控制器以及方法之间的映射关系
8、接收用户请求并进行分发操作
9、用户请求参数处理
10、控制器方法调用以及不同返回值数据处理

作业：封装用户请求参数

Springmvc核心配置文件：springmvc.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans>
  3.  
  4.     <!-- 配置创建容器时要扫描的包-->
  5.     <component-scan base-package="com.baiqi.controller,com.baiqi.service"></component-scan>
  6.  
  7. </beans>

web项目核心配置文件：web.xml

  1. <!DOCTYPE web-app PUBLIC
  2.  "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  3.  "http://java.sun.com/dtd/web-app_2_3.dtd" >
  4.  
  5. <web-app>
  6.   <display-name>Archetype Created Web Application</display-name>
  7.  
  8.  
  9.     <!--配置前端控制器-->
  10.   <servlet>
  11.     <servlet-name>DispatcherServlet</servlet-name>
  12.     <servlet-class>com.springmvc.servlet.DispatcherServlet</servlet-class>
  13.     <init-param>
  14.       <param-name>contextConfigLocation</param-name>
  15.       <param-value>classpath:springmvc.xml</param-value>
  16.     </init-param>
  17.     <!--Web服务器一旦启动，Servlet就会实例化创建对象，然后初始化(预备创建对象)-->
  18.     <load-on-startup>1</load-on-startup>
  19.   </servlet>
  20.  
  21.   <servlet-mapping>
  22.     <servlet-name>DispatcherServlet</servlet-name>
  23.     <url-pattern>/</url-pattern>
  24.   </servlet-mapping>
  25. </web-app>

 

 

自定义注解

Controller.java

  1. package cn.huangyan.spring.annotation;
  2.  
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  8.  
  9. @Documented
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Target({ElementType.TYPE})
  12. public @interface Controller {
  13. 	String value() default "";
  14. }

Service.java

  1. package cn.huangyan.spring.annotation;
  2.  
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  8.  
  9. @Documented
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Target({ElementType.TYPE})
  12. public @interface Service {
  13. 	String value() default "";
  14. }

Autowired.java

  1. package cn.huangyan.spring.annotation;
  2.  
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  8.  
  9. @Documented
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Target(ElementType.FIELD)
  12. public @interface Autowired {
  13. 	String value() default "";
  14. }

RequestMapping.java

  1. package cn.huangyan.spring.annotation;
  2.  
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  8.  
  9. @Documented
  10. @Retention(RetentionPolicy.RUNTIME) // 
  11. @Target({ElementType.TYPE,ElementType.METHOD})
  12. public @interface RequestMapping {
  13. 	String value() default "";
  14. }

注意：

  1. ElementType.TYPE表示定义的这个注解以后可以用在类上；
  2. ElementType.METHOD表示这个注解可以用在方法上；
  3. @Retention(RetentionPolicy.RUNTIME)  表示保留到运行时，运行时能通过反射获取到注解的相关信息

中央控制器DispatcherServlet

  1. package com.springmvc.servlet;
  2.  
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import com.springmvc.annotation.Controller;
  5. import com.springmvc.annotation.RequestMapping;
  6. import com.springmvc.annotation.ResponseBody;
  7. import com.springmvc.context.WebApplicationContext;
  8. import com.springmvc.handler.MyHandler;
  9.  
  10. import javax.servlet.ServletException;
  11. import javax.servlet.annotation.WebServlet;
  12. import javax.servlet.http.HttpServlet;
  13. import javax.servlet.http.HttpServletRequest;
  14. import javax.servlet.http.HttpServletResponse;
  15. import java.io.IOException;
  16. import java.io.PrintWriter;
  17. import java.lang.reflect.Method;
  18. import java.util.ArrayList;
  19. import java.util.List;
  20. import java.util.Map;
  21.  
  22. public class DispatcherServlet extends HttpServlet {
  23.  
  24.     //指定SpringMvc容器
  25.     private WebApplicationContext webApplicationContext;
  26.  
  27.     //创建集合  用于存放  映射关系    映射地址  与  控制器.方法，用于发送请求直接从该集合中进行匹配
  28.     List<MyHandler>  handList = new ArrayList<>();
  29.  
  30.  
  31.     @Override
  32.     public void init() throws ServletException {
  33.  
  34.         //1、加载初始化参数   classpath:springmvc.xml
  35.        String  contextConfigLocation =  this.getServletConfig().getInitParameter("contextConfigLocation");
  36.  
  37.         //2、创建Springmvc容器
  38.         webApplicationContext = new WebApplicationContext(contextConfigLocation);
  39.  
  40.         //3、进行初始化操作
  41.         webApplicationContext.onRefresh();
  42.  
  43.         //4、初始化请求映射关系   /findUser   ===》控制器.方法
  44.         initHandlerMapping();
  45.     }
  46.  
  47.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  48.  
  49.           //进行请求分发处理
  50.           doDispatcher(request,response);
  51.     }
  52.  
  53.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  54.               this.doPost(request,response);
  55.     }
  56.  
  57.     //进行请求分发处理
  58.     public void  doDispatcher(HttpServletRequest req, HttpServletResponse resp){
  59.  
  60.             //根据用户的请求地址  /findUser   查找Handler|Controller
  61.             MyHandler myHandler = getHandler(req);
  62.  
  63.             try{
  64.  
  65.                 if(myHandler == null){
  66.                     resp.getWriter().print("<h1>404 NOT  FOUND!</h1>");
  67.                 }else{
  68.  
  69.                     //调用处理方法之前 进行参数的注入
  70.  
  71.                     //调用目标方法
  72.                    Object result = myHandler.getMethod().invoke(myHandler.getController());
  73.  
  74.                     if(result instanceof String){
  75.                         //跳转JSP
  76.                         String viewName=(String)result;
  77.                         // forward:/success.jsp
  78.                         if(viewName.contains(":")){
  79.                             String viewType=viewName.split(":")[0];
  80.                             String viewPage=viewName.split(":")[1];
  81.                             if(viewType.equals("forward")){
  82.                                 req.getRequestDispatcher(viewPage).forward(req,resp);
  83.                             }else{
  84.                                 // redirect:/user.jsp
  85.                                 resp.sendRedirect(viewPage);
  86.                             }
  87.                         }else{
  88.                             //默认就转发
  89.                             req.getRequestDispatcher(viewName).forward(req,resp);
  90.                         }
  91.                     }else{
  92.                         //返回JSON格式数据
  93.                         Method method = myHandler.getMethod();
  94.                         if(method.isAnnotationPresent(ResponseBody.class)){
  95.                             //将返回值转换成 json格式数据
  96.                             ObjectMapper objectMapper = new ObjectMapper();
  97.                             String json = objectMapper.writeValueAsString(result);
  98.                             resp.setContentType("text/html;charset=utf-8");
  99.                             PrintWriter writer = resp.getWriter();
  100.                             writer.print(json);
  101.                             writer.flush();
  102.                             writer.close();
  103.  
  104.                         }
  105.                     }
  106.  
  107.                 }
  108.             }catch(Exception e){
  109.                e.printStackTrace();
  110.         }
  111.  
  112.  
  113.     }
  114.  
  115.     //根据用户请求查找对应的Handler
  116.     /***
  117.      * 获取请求对应的handler
  118.      * @param req
  119.      * @return
  120.      */
  121.     public MyHandler getHandler(HttpServletRequest req) {
  122.         // /findUser
  123.         String requestURI = req.getRequestURI();
  124.         for (MyHandler myHandler : handList) {
  125.             //从容器的Handle取出URL  和  用户的请求地址进行匹配，找到满足条件的Handler
  126.             if (myHandler.getUrl().equals(requestURI)) {
  127.                 return myHandler;
  128.             }
  129.         }
  130.         return null;
  131.     }
  132.  
  133.     //初始化请求映射关系
  134.     public void  initHandlerMapping(){
  135.  
  136.         for (Map.Entry<String, Object> entry : webApplicationContext.iocMap.entrySet()) {
  137.             //获取bean的class类型
  138.             Class<?> clazz =  entry.getValue().getClass();
  139.  
  140.             if(clazz.isAnnotationPresent(Controller.class)){
  141.                 //获取bean中所有的方法，为这些方法建立映射关系
  142.                 Method[] methods =  clazz.getDeclaredMethods();
  143.                 for (Method method : methods) {
  144.  
  145.                     if(method.isAnnotationPresent(RequestMapping.class)){
  146.                         RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
  147.                         //获取注解中的值   /findUser
  148.                         String url = requestMapping.value();
  149.  
  150.                         //建立  映射地址  与  控制器.方法
  151.                         MyHandler myHandler = new MyHandler(url,entry.getValue(),method);
  152.                         handList.add(myHandler);
  153.                     }
  154.                 }
  155.  
  156.             }
  157.         }
  158.             
  159.     }
  160. }

  1. package com.springmvc.context;
  2.  
  3. import com.springmvc.annotation.AutoWired;
  4. import com.springmvc.annotation.Controller;
  5. import com.springmvc.annotation.Service;
  6. import com.springmvc.xml.XmlPaser;
  7.  
  8. import java.io.File;
  9. import java.lang.reflect.Field;
  10. import java.net.URL;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.Map;
  14. import java.util.concurrent.ConcurrentHashMap;
  15.  
  16. /**
  17.  * springMvc容器
  18.  */
  19. public class WebApplicationContext {
  20.  
  21.     //classpath:springmvc.xml
  22.     String contextConfigLocation;
  23.  
  24.     //定义集合  用于存放 bean 的权限名|包名.类名
  25.     List<String> classNameList = new ArrayList<String>();
  26.  
  27.     //创建Map集合用于扮演IOC容器：  key存放bean的名字   value存放bean实例
  28.     public Map<String,Object> iocMap = new ConcurrentHashMap<>();
  29.  
  30.     public WebApplicationContext() {
  31.     }
  32.  
  33.     public WebApplicationContext(String contextConfigLocation) {
  34.            this.contextConfigLocation = contextConfigLocation;
  35.     }
  36.  
  37.     /**
  38.      * 初始化Spring容器
  39.      */
  40.     public void onRefresh(){
  41.  
  42.         //1、进行解析springmvc配置文件操作  ==》 com.baiqi.controller,com.baiqi.service
  43.          String pack = XmlPaser.getbasePackage(contextConfigLocation.split(":")[1]);
  44.  
  45.          String[] packs = pack.split(",");
  46.          //2、进行包扫描
  47.          for(String pa : packs){
  48.              excuteScanPackage(pa);
  49.          }
  50.  
  51.          //3、实例化容器中bean
  52.         executeInstance();
  53.  
  54.          //4、进行 自动注入操作
  55.         executeAutoWired();
  56.     }
  57.  
  58.     //进行自动注入操作
  59.     public void executeAutoWired(){
  60.  
  61.         try {
  62.             //从容器中 取出  bean  ，然后判断 bean中是否有属性上使用 AutoWired，如果使用了搞注解，就需要进行自动注入操作
  63.             for (Map.Entry<String, Object> entry : iocMap.entrySet()) {
  64.                 //获取容器中的bean
  65.                 Object bean = entry.getValue();
  66.                 //获取bean中的属性
  67.                 Field[] fields = bean.getClass().getDeclaredFields();
  68.                 for (Field field : fields) {
  69.                     if(field.isAnnotationPresent(AutoWired.class)){
  70.                         //获取注解中的value值|该值就是bean的name
  71.                         AutoWired autoWiredAno =  field.getAnnotation(AutoWired.class);
  72.                         String beanName = autoWiredAno.value();
  73.                         //取消检查机制
  74.                         field.setAccessible(true);
  75.                         field.set(bean,iocMap.get(beanName));
  76.  
  77.                     }
  78.                 }
  79.  
  80.  
  81.             }
  82.         }catch(Exception e){
  83.             e.printStackTrace();
  84.         }
  85.  
  86.     }
  87.  
  88.     /**
  89.      * 实例化容器中的bean
  90.      */
  91.     public void executeInstance(){
  92.  
  93.         try{
  94.             // com.baiqi.controller.UserController      com.baiqi.service.impl.UserServiceImpl
  95.             for (String className : classNameList) {
  96.  
  97.                 Class<?> clazz =   Class.forName(className);
  98.  
  99.                 if(clazz.isAnnotationPresent(Controller.class)){
  100.                     //控制层 bean
  101.  
  102.                     String beanName = clazz.getSimpleName().substring(0,1).toLowerCase()+ clazz.getSimpleName().substring(1);
  103.                     iocMap.put(beanName,clazz.newInstance());
  104.  
  105.                 }else if(clazz.isAnnotationPresent(Service.class)){
  106.                     //Service层  bean
  107.                     Service serviceAn = clazz.getAnnotation(Service.class);
  108.                     String beanName = serviceAn.value();
  109.                     iocMap.put(beanName,clazz.newInstance());
  110.                 }
  111.             }
  112.         }catch(Exception e){
  113.             e.printStackTrace();
  114.         }
  115.  
  116.  
  117.     }
  118.  
  119.     /**
  120.      * 扫描包
  121.      */
  122.     public void excuteScanPackage(String pack){
  123.         //   com.baiqi.controller   ==> com/baiqi/controller
  124.         URL url = this.getClass().getClassLoader().getResource("/" + pack.replaceAll("\\.", "/"));
  125.         String path = url.getFile();
  126.         // /com/bruce/service
  127.         File dir=new File(path);
  128.         for(File f:dir.listFiles()){
  129.             if(f.isDirectory()){
  130.                 //当前是一个文件目录  com.baiqi.service.impl
  131.                 excuteScanPackage(pack+"."+f.getName());
  132.             }else{
  133.                 //文件目录下文件  获取全路径   UserController.class  ==> com.baiqi.controller.UserController
  134.                 String className=pack+"."+f.getName().replaceAll(".class","");
  135.                 classNameList.add(className);
  136.             }
  137.         }
  138.     }
  139.  
  140. }

URL url = getClass().getClassLoader().getResource(path); //  注意path最前面没有/，path = cn/huangyan/spring
        String filePath = url.getFile();
        File[] files = new File(filePath).listFiles();

  1. package com.springmvc.xml;
  2.  
  3. import org.dom4j.Attribute;
  4. import org.dom4j.Document;
  5. import org.dom4j.DocumentException;
  6. import org.dom4j.Element;
  7. import org.dom4j.io.SAXReader;
  8.  
  9. import java.io.InputStream;
  10.  
  11. /**
  12.  * @BelongsProject: SpringMvc
  13.  * @Description: 解析springmvc.xml
  14.  */
  15. public class XmlPaser {
  16.  
  17.  
  18.     public static String getbasePackage(String xml){
  19.         try {
  20.             SAXReader saxReader=new SAXReader();
  21.             InputStream inputStream = XmlPaser.class.getClassLoader().getResourceAsStream(xml);
  22.             //XML文档对象
  23.             Document document = saxReader.read(inputStream);
  24.             Element rootElement = document.getRootElement();
  25.             Element componentScan = rootElement.element("component-scan");
  26.             Attribute attribute = componentScan.attribute("base-package");
  27.             String basePackage = attribute.getText();
  28.             return  basePackage;
  29.         } catch (DocumentException e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.         }
  33.         return "";
  34.     }
  35.  
  36. }

用于存储url和处理器的映射关系的基础组件

  1. package com.springmvc.handler;
  2.  
  3.  
  4. import java.lang.reflect.Method;
  5.  
  6. /**
  7.  * @BelongsProject: SpringMvc
  8.  * @Description: TODO
  9.  */
  10.  
  11. public class MyHandler {
  12.  
  13. 	//请求URL地址
  14.     private String url;
  15.  
  16.     //后台控制器
  17.     private Object controller;
  18.  
  19.     //控制器中指定的方法
  20.     private Method method;
  21.     
  22. 	public MyHandler() {
  23. 		super();
  24. 		// TODO Auto-generated constructor stub
  25. 	}
  26. 	
  27. 	
  28. 	public MyHandler(String url, Object controller, Method method) {
  29. 		super();
  30. 		this.url = url;
  31. 		this.controller = controller;
  32. 		this.method = method;
  33. 	}
  34.  
  35. 	// 省略getter/setter方法
  36. }

总结

  • 学习如何通过包名，扫描定位到包名下的具体一个个的类文件，并对这些类文件进行解析
  • 学习如何通过反射获取字段的注解属性值，并通过反射给bean字段设值值

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号