锐客网

  1. 首页 > 睿知 > it技术 > >

Spring中毒太深，离开Spring我居然连最基本的接口都不会写了

IT知识离开接口

知是行的主意,行是知的功夫。这篇文章主要讲述Spring中毒太深，离开Spring我居然连最基本的接口都不会写了相关的知识，希望能为你提供帮助。
前言随着  ??Spring??  的崛起以及其功能的完善，现在可能绝大部分项目的开发都是使用  ??Spring（全家桶）??  来进行开发，??Spring??也确实和其名字一样，是开发者的春天，??Spring??  解放了程序员的双手，而等到  ??SpringBoot??出来之后配置文件大大减少，更是进一步解放了程序员的双手，但是也正是因为??Spring??家族产品的强大，使得我们习惯了面向  ??Spring??  开发，那么假如有一天没有了  ??Spring??，是不是感觉心里一空，可能一下子连最基本的接口都不会写了，尤其是没有接触过??Servlet??编程的朋友。因为加入没有了  ??Spring??  等框架，那么我们就需要利用最原生的  ??Servlet??  来自己实现接口路径的映射，对象也需要自己进行管理。
Spring 能帮我们做什么
??Spring??  是为解决企业级应用开发的复杂性而设计的一款框架，??Spring??  的设计理念就是：简化开发。
在  ??Spring??  框架中，一切对象都是  ??bean??，所以其通过面向  ??bean??  编程（BOP），结合其核心思想依赖注入（DI）和面向切面 (（AOP）编程，??Spring??  实现了其伟大的简化开发的设计理念。
控制反转（IOC）
??IOC??  全称为：Inversion of Control。控制反转的基本概念是：不用创建对象，但是需要描述创建对象的方式。
简单的说我们本来在代码中创建一个对象是通过  ??new??  关键字，而使用了  ??Spring??  之后，我们不在需要自己去  ??new??  一个对象了，而是直接通过容器里面去取出来，再将其自动注入到我们需要的对象之中，即：依赖注入。
也就说创建对象的控制权不在我们程序员手上了，全部交由  ??Spring??  进行管理，程序要只需要注入就可以了，所以才称之为控制反转。
依赖注入（DI）
依赖注入（Dependency Injection，DI）就是  ??Spring??  为了实现控制反转的一种实现方式，所有有时候我们也将控制反转直接称之为依赖注入。
面向切面编程（AOP）
??AOP??  全称为：Aspect Oriented Programming。??AOP??是一种编程思想，其核心构造是方面（切面），即将那些影响多个类的公共行为封装到可重用的模块中，而使原本的模块内只需关注自身的个性化行为。
??AOP??  编程的常用场景有：Authentication（权限认证）、Auto Caching（自动缓存处理）、Error Handling（统一错误处理）、Debugging（调试信息输出）、Logging（日志记录）、Transactions（事务处理）等。
利用 Spring 来完成 Hello World
最原生的  ??Spring??  需要较多的配置文件，而  ??SpringBoot??  省略了许多配置，相比较于原始的  ??Spring??  又简化了不少，在这里我们就以  ??SpringBoot??  为例来完成一个简单的接口开发。

  • 1、新建一个  ??maven??  项目，??pom??  文件中引入依赖（省略了少部分属性）：
< parent>
        < groupId> org.springframework.boot< /groupId>
        < artifactId> spring-boot-starter-parent< /artifactId>
        < version> 2.4.0< /version>
        < relativePath/>
< /parent>
< dependencies>
        < dependency>
                < groupId> org.springframework.boot< /groupId>
                < artifactId> spring-boot-starter< /artifactId>
        < /dependency>

        < dependency>
                < groupId> org.springframework.boot< /groupId>
                < artifactId> spring-boot-starter-web< /artifactId>
        < /dependency>
< /dependencies>

  • 2、新建一个  ??HelloController??  类：
package  com.lonely.wolf.note.springboot.demo;

import  org.springframework.web.bind.annotation.GetMapping;
import  org.springframework.web.bind.annotation.RequestMapping;
import  org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/hello")
public  class  HelloController 
        @GetMapping("/demo")
        public  String  helloWorld(String  name)
                return  "Hello："  +  name;
       

  • 3、最后新建一个  ??SpringBoot??  启动类：
package  com.lonely.wolf.note.springboot;

import  org.springframework.boot.SpringApplication;
import  org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages  =  "com.lonely.wolf.note.springboot")
class  MySpringBootApplication 
        public  static  void  main(String[]  args) 
                SpringApplication.run(MySpringBootApplication.class,  args);
       

  • 4、现在就可以输入测试路径：??http://localhost:8080/hello/demo?name=双子孤狼??  进行测试，正常输出：??Hello：双子孤狼??。
【Spring中毒太深，离开Spring我居然连最基本的接口都不会写了】我们可以看到，利用  ??SpringBoot??  来完成一个简单的应用开发非常简单，可以不需要任何配置完成一个简单的应用，这是因为  ??SpringBoot??  内部已经做好了约定（约定优于配置思想），包括容器  ??Tomcat??  都被默认集成，所以我们不需要任何配置文件就可以完成一个简单的  ??demo??  应用。
假如没有了 Spring通过上面的例子我们可以发现，利用  ??Spring??  来完成一个  ??Hello World??  非常简单，但是假如没有了  ??Spring??，我们又该如何完成这样的一个  ??Hello World??  接口呢？
基于 Servlet 开发
在还没有框架之前，编程式基于原始的  ??Servlet??  进行开发，下面我们就基于原生的  ??Servlet??  来完成一个简单的接口调用。
  • 1、??pom??  文件引入依赖，需要注意的是，??package??  属性要设置成  ??war??  包，为了节省篇幅，这里没有列出  ??pom??  完整的信息：
< packaging> war< /packaging>  
< dependencies>
                < dependency>
                        < groupId> javax.servlet< /groupId>
                        < artifactId> servlet-api< /artifactId>
                        < version> 2.4< /version>
                < /dependency>

                < dependency>
                        < groupId> org.apache.commons< /groupId>
                        < artifactId> commons-lang3< /artifactId>
                        < version> 3.7< /version>
                < /dependency>

                < dependency>
                        < groupId> com.alibaba< /groupId>
                        < artifactId> fastjson< /artifactId>
                        < version> 1.2.72< /version>
                < /dependency>
        < /dependencies>

  • 2、在  ??src/main??  下面新建文件夹  ??webapp/WEB-INF??，然后在  ??WEB-INF??  下面新建一个  ??web.xml??  文件：
< ?xml  version="1.0"  encoding="UTF-8"?>
< web-app  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/j2ee"  xmlns:javaee="http://java.sun.com/xml/ns/javaee"
  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
  version="2.4">
  < display-name> Lonely  Wolf  Web  Application< /display-name>
  < servlet>
    < servlet-name> helloServlet< /servlet-name>
    < servlet-class> com.lonely.wolf.mini.spring.servlet.HelloServlet< /servlet-class>
  < /servlet>
  < servlet-mapping>
    < servlet-name> helloServlet< /servlet-name>
    < url-pattern> /hello/*< /url-pattern>
  < /servlet-mapping>
< /web-app>

这里面定义了  ??selvlet??  和  ??servlet-mapping??  两个标签，这两个标签必须一一对应，上面的标签定义了  ??servlet??  的位置，而下面的  ??servlet-mapping??  文件定义了路径的映射，这两个标签通过  ??servlet-name??  标签对应。
  • 3、新建一个  ??HelloServlet??  类继承  ??HttpServlet??：
package  com.lonely.wolf.mini.spring.servlet;

import  javax.servlet.ServletException;
import  javax.servlet.http.HttpServlet;
import  javax.servlet.http.HttpServletRequest;
import  javax.servlet.http.HttpServletResponse;
import  java.io.IOException;

/**
  *  原始Servlet接口编写，一般需要实现GET和POST方法，其他方法可以视具体情况选择性继承
  */
public  class  HelloServlet  extends  HttpServlet 
        @Override
        protected  void  doGet(HttpServletRequest  request,  HttpServletResponse  response)  throws  ServletException,  IOException 
                this.doPost(request,response);
       

        @Override
        protected  void  doPost(HttpServletRequest  request,  HttpServletResponse  response)  throws  ServletException,  IOException 
                response.setContentType("text/html; charset=utf-8");
                response.getWriter().write("Hello："  +  request.getParameter("name"));
       

  • 4、执行  ??maven??  打包命令，确认成功打包成  ??war??  包：

  • 5、??RUN--> Edit Configurations??，然后点击左上角的  ??+??  号，新建一个  ??Tomcat Server??，如果是第一次配置，默认没有  ??Tomcat Server??  选项，需要点击底部的  ??xx more items...??：

  • 6、点击右边的  ??Deployment??，然后按照下图依次点击，最后在弹框内找到上面打包好的  ??war??  包文件：

  • 7、选中之后，需要注意的是，下面  ??Application Context??  默认会带上  ??war??  包名，为了方便，我们需要把它删掉，即不用上下文路径，只保留一个根路径  ??/??  （当然上下文也可以保留，但是每次请求都要带上这一部分）， 再选择  ??Apply??，点击  ??OK??，即可完成部署：

  • 8、最后我们在浏览器输入请求路径??http://localhost:8080/hello?name=双子孤狼??，即可得到返回：??Hello：双子孤狼??。
上面我们就完成了一个简单的 基于??Servlet??  的接口开发，可以看到，配置非常麻烦，每增加一个  ??Servlet??  都需要增加对应的配置，所以才会有许多框架的出现来帮我们简化开发，比如原来很流行的  ??Struts2??  框架，当然现在除了一些比较老的项目，一般我们都很少使用，而更多的是选择  ??Spring??  框架来进行开发。
模仿 Spring
??Spring??  的源码体系非常庞大，大部分人对其源码都敬而远之。确实，??Spring??  毕竟经过了这么多年的迭代，功能丰富，项目庞大，不是一下子就能看懂的。虽然  ??Spring??  难以理解，但是其最核心的思想仍然是我们上面介绍的几点，接下来就基于  ??Spring??  最核心的部分来模拟，自己动手实现一个超级迷你版本的  ??Spring??（此版本并不包含  ??AOP??  功能）。
  • 1、??pom??  依赖和上面保持不变，然后  ??web.xml??  作如下改变，这里会拦截所有的接口  ??/*??，然后多配置了一个参数，这个参数其实也是为了更形象的模拟  ??Spring??：
< servlet>
        < servlet-name> myDispatcherServlet< /servlet-name>
        < servlet-class> com.lonely.wolf.mini.spring.v1.MyDispatcherServlet< /servlet-class>
        < init-param>
                < param-name> defaultConfig< /param-name>
                < param-value> application.properties< /param-value>
        < /init-param>
< /servlet>

< servlet-mapping>
        < servlet-name> myDispatcherServlet< /servlet-name>
        < url-pattern> /*< /url-pattern>
< /servlet-mapping>

  • 2、在  ??respurces??  下面新建一个配置文件  ??application.properties??，用来定义扫描的基本路径：
basePackages=com.lonely.wolf.mini.spring

  • 3、创建一些相关的注解类：
package  com.lonely.wolf.mini.spring.annotation;

import  java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @interface  WolfAutowired 
        String  value()  default  "";

package  com.lonely.wolf.mini.spring.annotation;

import  java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @interface  WolfController 
        String  value()  default  "";

package  com.lonely.wolf.mini.spring.annotation;

import  java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @interface  WolfGetMapping 
        String  value()  default  "";

package  com.lonely.wolf.mini.spring.annotation;

import  java.lang.annotation.*;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @interface  WolfRequestParam 
        String  value()  default  "";

package  com.lonely.wolf.mini.spring.annotation;

import  java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @interface  WolfService 
        String  value()  default  "";

  • 4、这个时候最核心的逻辑就是  ??MyDispatcherServlet??  类了：
package  com.lonely.wolf.mini.spring.v1;

import  com.lonely.wolf.mini.spring.annotation.*;
import  com.lonely.wolf.mini.spring.v1.config.MyConfig;
import  org.apache.commons.lang3.StringUtils;

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.File;
import  java.io.IOException;
import  java.io.InputStream;
import  java.lang.annotation.Annotation;
import  java.lang.reflect.Field;
import  java.lang.reflect.Method;
import  java.net.URL;
import  java.util.*;

public  class  MyDispatcherServlet  extends  HttpServlet 
        private  MyConfig  myConfig  =  new  MyConfig();
        private  List< String>   classNameList  =  new  ArrayList< String> ();

        private  Map< String,Object>   iocContainerMap  =  new  HashMap< > ();
        private  Map< String,HandlerMapping>   handlerMappingMap  =  new  HashMap< > ();

        @Override
        protected  void  doGet(HttpServletRequest  request,  HttpServletResponse  response)  throws  ServletException,  IOException 
                this.doPost(request,response);
       

        @Override
        protected  void  doPost(HttpServletRequest  request,  HttpServletResponse  response)  throws  ServletException,  IOException 
                try 
                        this.doDispatch(request,  response);
                  catch  (Exception  e) 
                        e.printStackTrace();
               
       

        private  void  doDispatch(HttpServletRequest  request,  HttpServletResponse  response)  throws  Exception
                String  requestUrl  =  this.formatUrl(request.getRequestURI());
                HandlerMapping  handlerMapping  =  handlerMappingMap.get(requestUrl);
                if  (null  ==  handlerMapping)
                        response.getWriter().write("404  Not  Found");
                        return;
               

                //获取方法中的参数类型
                Class< ?> []  paramTypeArr  =  handlerMapping.getMethod().getParameterTypes();
                Object[]  paramArr  =  new  Object[paramTypeArr.length];

                for  (int  i=0; i< paramTypeArr.length; i++)
                        Class< ?>   clazz  =  paramTypeArr[i];
                        //参数只考虑三种类型，其他不考虑
                        if  (clazz  ==  HttpServletRequest.class)
                                paramArr[i]  =  request;
                        else  if  (clazz  ==  HttpServletResponse.class)
                                paramArr[i]  =  response;
                          else  if  (clazz  ==  String.class)
                                Map< Integer,String>   methodParam  =  handlerMapping.getMethodParams();
                                paramArr[i]  =  request.getParameter(methodParam.get(i));
                        else
                                System.out.println("暂不支持的参数类型");
                       
               
                //反射调用controller方法
                handlerMapping.getMethod().invoke(handlerMapping.getTarget(),  paramArr);
       

        private  String  formatUrl(String  requestUrl) 
                requestUrl  =  requestUrl.replaceAll("/+","/");
                if  (requestUrl.lastIndexOf("/")  ==  requestUrl.length()  -1)
                        requestUrl  =  requestUrl.substring(0,requestUrl.length()  -1);
               
                return  requestUrl;
       

        @Override
        public  void  init(ServletConfig  config)  throws  ServletException 
                //1.加载配置文件
                try 
                        doLoadConfig(config.getInitParameter("defaultConfig"));
                  catch  (Exception  e) 
                        System.out.println("加载配置文件失败");
                        return;
               

                //2.根据获取到的扫描路径进行扫描
                doScanPacakge(myConfig.getBasePackages());

                //3.将扫描到的类进行初始化，并存放到IOC容器
                doInitializedClass();

                //4.依赖注入
                doDependencyInjection();

                System.out.println("DispatchServlet  Init  End..."  );
       

        private  void  doDependencyInjection() 
                if  (iocContainerMap.size()  ==  0)
                        return;
               
                //循环IOC容器中的类
                Iterator< Map.Entry< String,Object> >   iterator  =  iocContainerMap.entrySet().iterator();

                while  (iterator.hasNext())
                        Map.Entry< String,Object>   entry  =  iterator.next();
                        Class< ?>   clazz  =  entry.getValue().getClass();
                        Field[]  fields  =  clazz.getDeclaredFields();

                        //属性注入
                        for  (Field  field  :  fields)
                                //如果属性有WolfAutowired注解则注入值（暂时不考虑其他注解）
                                if  (field.isAnnotationPresent(WolfAutowired.class))
                                        String  value  =  toLowerFirstLetterCase(field.getType().getSimpleName()); //默认bean的value为类名首字母小写
                                        if  (field.getType().isAnnotationPresent(WolfService.class))
                                                WolfService  wolfService  =  field.getType().getAnnotation(WolfService.class);
                                                value  =  wolfService.value();
                                       
                                        field.setAccessible(true);
                                        try 
                                                Object  target  =  iocContainerMap.get(beanName);
                                                if  (null  ==  target)
                                                        System.out.println(clazz.getName()  +  "required  bean:"  +  beanName  +  ",but  we  not  found  it");
                                               
                                                field.set(entry.getValue(),iocContainerMap.get(beanName)); //初始化对象，后面注入
                                          catch  (IllegalAccessException  e) 
                                                e.printStackTrace();
                                       
                               
                       

                        //初始化HanderMapping
                        String  requestUrl  =  "";
                        //获取Controller类上的请求路径
                        if  (clazz.isAnnotationPresent(WolfController.class))
                                requestUrl  =  clazz.getAnnotation(WolfController.class).value();
                       

                        //循环类中的方法，获取方法上的路径
                        Method[]  methods  =  clazz.getMethods();
                        for  (Method  method  :  methods)
                                //假设只有WolfGetMapping这一种注解
                                if(!method.isAnnotationPresent(WolfGetMapping.class))
                                        continue;
                               
                                WolfGetMapping  wolfGetMapping  =  method.getDeclaredAnnotation(WolfGetMapping.class);
                                requestUrl  =  requestUrl  +  "/"  +  wolfGetMapping.value(); //拼成完成的请求路径

                                //不考虑正则匹配路径/xx/*  的情况，只考虑完全匹配的情况
                                if  (handlerMappingMap.containsKey(requestUrl))
                                        System.out.println("重复路径");
                                        continue;
                               

                                Annotation[][]  annotationArr  =  method.getParameterAnnotations(); //获取方法中参数的注解

                                Map< Integer,String>   methodParam  =  new  HashMap< > (); //存储参数的顺序和参数名
                                retryParam:
                                for  (int  i=0; i< annotationArr.length; i++)
                                        for  (Annotation  annotation  :  annotationArr[i])
                                                if  (annotation  instanceof  WolfRequestParam)
                                                        WolfRequestParam  wolfRequestParam  =  (WolfRequestParam)  annotation;
                                                        methodParam.put(i,wolfRequestParam.value()); //存储参数的位置和注解中定义的参数名
                                                        continue  retryParam;
                                               
                                       
                               

                                requestUrl  =  this.formatUrl(requestUrl); //主要是防止路径多了/导致路径匹配不上
                                HandlerMapping  handlerMapping  =  new  HandlerMapping();
                                handlerMapping.setRequestUrl(requestUrl); //请求路径
                                handlerMapping.setMethod(method); //请求方法
                                handlerMapping.setTarget(entry.getValue()); //请求方法所在controller对象
                                handlerMapping.setMethodParams(methodParam); //请求方法的参数信息
                                handlerMappingMap.put(requestUrl,handlerMapping); //存入hashmap
                       
               
       

        /**
          *  初始化类，并放入容器iocContainerMap内
          */
        private  void  doInitializedClass() 
                if  (classNameList.isEmpty())
                        return;
               
                for  (String  className  :  classNameList)
                        if  (StringUtils.isEmpty(className))
                                continue;
                       
                        Class  clazz;
                        try 
                                clazz  =  Class.forName(className); //反射获取对象
                                if  (clazz.isAnnotationPresent(WolfController.class))
                                        String  value  =  ((WolfController)clazz.getAnnotation(WolfController.class)).value();
                                        //如果直接指定了value则取value，否则取首字母小写类名作为key值存储类的实例对象
                                        iocContainerMap.put(StringUtils.isBlank(value)  ?  toLowerFirstLetterCase(clazz.getSimpleName())  :  value,clazz.newInstance());
                                else  if(clazz.isAnnotationPresent(WolfService.class))
                                        String  value  =  ((WolfService)clazz.getAnnotation(WolfService.class)).value();
                                        iocContainerMap.put(StringUtils.isBlank(value)  ?  toLowerFirstLetterCase(clazz.getSimpleName())  :  value,clazz.newInstance());
                                else
                                        System.out.println("不考虑其他注解的情况");
                               
                          catch  (Exception  e) 
                                e.printStackTrace();
                                System.out.println("初始化类失败，className为"  +  className);
                       
               

       

        /**
          *  将首字母转换为小写
          *  @param  className
          *  @return
          */
        private  String  toLowerFirstLetterCase(String  className) 
                if  (StringUtils.isBlank(className))
                        return  "";
               
                String  firstLetter  =  className.substring(0,1);
                return  firstLetter.toLowerCase()  +  className.substring(1);
       

        /**
          *  扫描包下所有文件获取全限定类名
          *  @param  basePackages
          */
        private  void  doScanPacakge(String  basePackages) 
                if  (StringUtils.isBlank(basePackages))
                        return;
               
      &n

    推荐阅读


    上一篇：#yyds干货盘点# Python Opencv实战之图像阈值和模糊处理，万字实战，收藏起来吧~

    下一篇：#yyds干货盘点#JUnit5学习之八（综合进阶（终篇））