如何基于 Servlet 进行开发
随着 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 文件中引入依赖（省略了少部分属性）：
org.springframework.boot spring-boot-starter-parent 2.4.0 org.springframework.boot spring-boot-starter org.springframework.boot spring-boot-starter-web 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：双子孤狼。 我们可以看到，利用 springboot 来完成一个简单的应用开发非常简单，可以不需要任何配置完成一个简单的应用，这是因为 springboot 内部已经做好了约定（约定优于配置思想），包括容器 tomcat 都被默认集成，所以我们不需要任何配置文件就可以完成一个简单的 demo 应用。 # 假如没有了 spring 通过上面的例子我们可以发现，利用 spring 来完成一个 hello world 非常简单，但是假如没有了 spring，我们又该如何完成这样的一个 hello world 接口呢？ # 基于 servlet 开发 在还没有框架之前，编程式基于原始的 servlet 进行开发，下面我们就基于原生的 servlet 来完成一个简单的接口调用。 1、pom 文件引入依赖，需要注意的是，package 属性要设置成 war 包，为了节省篇幅，这里没有列出 pom 完整的信息： war javax.servlet servlet-api 2.4 org.apache.commons commons-lang3 3.7 com.alibaba fastjson 1.2.72 2、在 src/main 下面新建文件夹 webapp/web-inf，然后在 web-inf 下面新建一个 web.xml 文件： lonely wolf web application helloservlet com.lonely.wolf.mini.spring.servlet.helloservlet helloservlet /hello/* 这里面定义了 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：
mydispatcherservlet com.lonely.wolf.mini.spring.v1.mydispatcherservlet defaultconfig application.properties mydispatcherservlet /* 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)@documentedpublic @interface wolfautowired { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.type})@retention(retentionpolicy.runtime)@documentedpublic @interface wolfcontroller { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.method})@retention(retentionpolicy.runtime)@documentedpublic @interface wolfgetmapping { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.parameter})@retention(retentionpolicy.runtime)@documentedpublic @interface wolfrequestparam { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.type})@retention(retentionpolicy.runtime)@documentedpublic @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 classnamelist = new arraylist(); private map ioccontainermap = new hashmap(); private map 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 初始化配置文件，拿到配置文件中配置的参数信息（对应方法：doloadconfig）。
拿到第 1 步加载出来的配置文件，获取到需要扫描的包路径，然后将包路径进行转换成实际的磁盘路径，并开始遍历磁盘路径下的所有 class 文件，最终经过转换之后得到扫描路径下的所有类的全限定类型，存储到全局变量 classnamelist 中（对应方法：doscanpacakge）。
根据第 2 步中得到的全局变量 classnamelist 中的类通过反射进行初始化（需要注意的是只会初始化加了指定注解的类）并将得到的对应关系存储到全局变量 ioccontainermap 中（即传说中的 ioc 容器），其中 key 值为注解中的 value 属性，如 value 属性为空，则默认取首字母小写的类名作为 key 值进行存储（对应方法：doinitializedclass）。
这一步比较关键，需要对 ioc 容器中的所有类的属性进行赋值并且需要对 controller 中的请求路径进行映射存储，为了确保最后能顺利调用 controller 中的方法，还需要将方法的参数进行存储 。对属性进行映射时只会对加了注解的属性进行映射，映射时会从 ioc 容器中取出第 3 步中已经初始化的实例对象进行赋值，最后将请求路径和 controller 中方法的映射关系存入变量 handlermappingmap，key 值为请求路径，value 为方法的相关信息 （对应方法：dodependencyinjection）。
6、存储请求路径和方法的映射关系时，需要用到 handlermapping 类来进行存储：
package com.lonely.wolf.mini.spring.v1;import java.lang.reflect.method;import java.util.map;//省略了getter/setter方法public class handlermapping { private string requesturl; private object target;//保存方法对应的实例 private method method;//保存映射的方法 private map methodparams;//记录方法参数} 7、初始化完成之后，因为拦截了 /* ，所以调用任意接口都会进入 mydispatcherservlet ，而且最终都会执行方法 dodispatch，执行这个方法时会拿到请求的路径，然后和全局变量 handlermappingmap 进行匹配，匹配不上则返回 404，匹配的上则取出必要的参数进行赋值，最后通过反射调用到 controller 中的相关方法。 8、新建一个 hellocontroller 和 helloservice 来进行测试： package com.lonely.wolf.mini.spring.controller;import com.lonely.wolf.mini.spring.annotation.wolfautowired;import com.lonely.wolf.mini.spring.annotation.wolfcontroller;import com.lonely.wolf.mini.spring.annotation.wolfgetmapping;import com.lonely.wolf.mini.spring.annotation.wolfrequestparam;import com.lonely.wolf.mini.spring.service.helloservice;import javax.servlet.http.httpservletrequest;import javax.servlet.http.httpservletresponse;import java.io.ioexception;@wolfcontrollerpublic class hellocontroller { @wolfautowired private helloservice helloservice; @wolfgetmapping(/hello) public void query(httpservletrequest request,httpservletresponse response, @wolfrequestparam(name) string name) throws ioexception { response.setcontenttype(text/html;charset=utf-8); response.getwriter().write(hello： + name); }}package com.lonely.wolf.mini.spring.service;import com.lonely.wolf.mini.spring.annotation.wolfservice;@wolfservice(value = hello_service)//为了演示能否正常取value属性public class helloservice {} 9、输入测试路径：http://localhost:8080////hello?name=双子孤狼， 进行测试发现可以正常输出：hello：双子孤狼。 上面这个例子只是一个简单的演示，通过这个例子只是希望在没有任何框架的情况下，我们也能知道如何完成一个简单的应用开发。例子中很多细节都没有进行处理，仅仅只是为了体验一下 spring 的核心思想，并了解 spring 到底帮助我们做了什么，实际上 spring 能帮我们做的事情远比这个例子中多得多，spring 体系庞大，设计优雅，经过了多年的迭代优化，是一款非常值得研究的框架。 # 总结 本文从介绍 spring 核心功能开始入手，从如何利用 spring 完成一个应用开发，讲述到假如没有 spring 我们该如何基于 servlet 进行开发，最后再通过一个简单的例子体验了 spring 的核心思想。
LTE是关键 2014将成博通重要一年
工控机比普通计算机更有优势的原因是什么
五分钟教学ZNB8校准和衰减器测试
爱特梅尔推出取得Windows 8认证的触控屏控制器
广州虹科电子致力汽车电子和工业控制测试解决方案
如何基于 Servlet 进行开发
区块链与分布式分类帐技术有何不同？
云端EDA已准备就绪_是否要用？
OPTEK开发POF组件 支持工业控制应用
蓝思科技在2020年第一季度业绩预告提出的募资扩充智能穿戴/车载显示等产业
物联网将在医疗领域大有作为！这些就是依据
中国为何突然禁售苹果
SAP适合医疗器械行业的公司、工厂吗？
智己汽车将携手CATL推出1000km电池
如何规避 Secret 泄露风险
面向5G时代 中国移动蓄力缔造“内容帝国”
2023是否会成为Multi-Die的腾飞之年？
物联网卡如何应用在定位跟踪器上
23个LM358典型应用电路图分享
安徽蚌埠：着力打造新布局新模式新平台，构建智能传感器产业集群
# 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 文件中引入依赖（省略了少部分属性）：
org.springframework.boot spring-boot-starter-parent 2.4.0 org.springframework.boot spring-boot-starter org.springframework.boot spring-boot-starter-web 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：双子孤狼。 我们可以看到，利用 springboot 来完成一个简单的应用开发非常简单，可以不需要任何配置完成一个简单的应用，这是因为 springboot 内部已经做好了约定（约定优于配置思想），包括容器 tomcat 都被默认集成，所以我们不需要任何配置文件就可以完成一个简单的 demo 应用。 # 假如没有了 spring 通过上面的例子我们可以发现，利用 spring 来完成一个 hello world 非常简单，但是假如没有了 spring，我们又该如何完成这样的一个 hello world 接口呢？ # 基于 servlet 开发 在还没有框架之前，编程式基于原始的 servlet 进行开发，下面我们就基于原生的 servlet 来完成一个简单的接口调用。 1、pom 文件引入依赖，需要注意的是，package 属性要设置成 war 包，为了节省篇幅，这里没有列出 pom 完整的信息： war javax.servlet servlet-api 2.4 org.apache.commons commons-lang3 3.7 com.alibaba fastjson 1.2.72 2、在 src/main 下面新建文件夹 webapp/web-inf，然后在 web-inf 下面新建一个 web.xml 文件： lonely wolf web application helloservlet com.lonely.wolf.mini.spring.servlet.helloservlet helloservlet /hello/* 这里面定义了 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：
mydispatcherservlet com.lonely.wolf.mini.spring.v1.mydispatcherservlet defaultconfig application.properties mydispatcherservlet /* 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)@documentedpublic @interface wolfautowired { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.type})@retention(retentionpolicy.runtime)@documentedpublic @interface wolfcontroller { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.method})@retention(retentionpolicy.runtime)@documentedpublic @interface wolfgetmapping { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.parameter})@retention(retentionpolicy.runtime)@documentedpublic @interface wolfrequestparam { string value() default ;}package com.lonely.wolf.mini.spring.annotation;import java.lang.annotation.*;@target({elementtype.type})@retention(retentionpolicy.runtime)@documentedpublic @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 classnamelist = new arraylist(); private map ioccontainermap = new hashmap(); private map 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
拿到第 1 步加载出来的配置文件，获取到需要扫描的包路径，然后将包路径进行转换成实际的磁盘路径，并开始遍历磁盘路径下的所有 class 文件，最终经过转换之后得到扫描路径下的所有类的全限定类型，存储到全局变量 classnamelist 中（对应方法：doscanpacakge）。
根据第 2 步中得到的全局变量 classnamelist 中的类通过反射进行初始化（需要注意的是只会初始化加了指定注解的类）并将得到的对应关系存储到全局变量 ioccontainermap 中（即传说中的 ioc 容器），其中 key 值为注解中的 value 属性，如 value 属性为空，则默认取首字母小写的类名作为 key 值进行存储（对应方法：doinitializedclass）。
这一步比较关键，需要对 ioc 容器中的所有类的属性进行赋值并且需要对 controller 中的请求路径进行映射存储，为了确保最后能顺利调用 controller 中的方法，还需要将方法的参数进行存储 。对属性进行映射时只会对加了注解的属性进行映射，映射时会从 ioc 容器中取出第 3 步中已经初始化的实例对象进行赋值，最后将请求路径和 controller 中方法的映射关系存入变量 handlermappingmap，key 值为请求路径，value 为方法的相关信息 （对应方法：dodependencyinjection）。
6、存储请求路径和方法的映射关系时，需要用到 handlermapping 类来进行存储：
package com.lonely.wolf.mini.spring.v1;import java.lang.reflect.method;import java.util.map;//省略了getter/setter方法public class handlermapping { private string requesturl; private object target;//保存方法对应的实例 private method method;//保存映射的方法 private map methodparams;//记录方法参数} 7、初始化完成之后，因为拦截了 /* ，所以调用任意接口都会进入 mydispatcherservlet ，而且最终都会执行方法 dodispatch，执行这个方法时会拿到请求的路径，然后和全局变量 handlermappingmap 进行匹配，匹配不上则返回 404，匹配的上则取出必要的参数进行赋值，最后通过反射调用到 controller 中的相关方法。 8、新建一个 hellocontroller 和 helloservice 来进行测试： package com.lonely.wolf.mini.spring.controller;import com.lonely.wolf.mini.spring.annotation.wolfautowired;import com.lonely.wolf.mini.spring.annotation.wolfcontroller;import com.lonely.wolf.mini.spring.annotation.wolfgetmapping;import com.lonely.wolf.mini.spring.annotation.wolfrequestparam;import com.lonely.wolf.mini.spring.service.helloservice;import javax.servlet.http.httpservletrequest;import javax.servlet.http.httpservletresponse;import java.io.ioexception;@wolfcontrollerpublic class hellocontroller { @wolfautowired private helloservice helloservice; @wolfgetmapping(/hello) public void query(httpservletrequest request,httpservletresponse response, @wolfrequestparam(name) string name) throws ioexception { response.setcontenttype(text/html;charset=utf-8); response.getwriter().write(hello： + name); }}package com.lonely.wolf.mini.spring.service;import com.lonely.wolf.mini.spring.annotation.wolfservice;@wolfservice(value = hello_service)//为了演示能否正常取value属性public class helloservice {} 9、输入测试路径：http://localhost:8080////hello?name=双子孤狼， 进行测试发现可以正常输出：hello：双子孤狼。 上面这个例子只是一个简单的演示，通过这个例子只是希望在没有任何框架的情况下，我们也能知道如何完成一个简单的应用开发。例子中很多细节都没有进行处理，仅仅只是为了体验一下 spring 的核心思想，并了解 spring 到底帮助我们做了什么，实际上 spring 能帮我们做的事情远比这个例子中多得多，spring 体系庞大，设计优雅，经过了多年的迭代优化，是一款非常值得研究的框架。 # 总结 本文从介绍 spring 核心功能开始入手，从如何利用 spring 完成一个应用开发，讲述到假如没有 spring 我们该如何基于 servlet 进行开发，最后再通过一个简单的例子体验了 spring 的核心思想。
LTE是关键 2014将成博通重要一年
工控机比普通计算机更有优势的原因是什么
五分钟教学ZNB8校准和衰减器测试
爱特梅尔推出取得Windows 8认证的触控屏控制器
广州虹科电子致力汽车电子和工业控制测试解决方案
如何基于 Servlet 进行开发
区块链与分布式分类帐技术有何不同？
云端EDA已准备就绪_是否要用？
OPTEK开发POF组件 支持工业控制应用
蓝思科技在2020年第一季度业绩预告提出的募资扩充智能穿戴/车载显示等产业
物联网将在医疗领域大有作为！这些就是依据
中国为何突然禁售苹果
SAP适合医疗器械行业的公司、工厂吗？
智己汽车将携手CATL推出1000km电池
如何规避 Secret 泄露风险
面向5G时代 中国移动蓄力缔造“内容帝国”
2023是否会成为Multi-Die的腾飞之年？
物联网卡如何应用在定位跟踪器上
23个LM358典型应用电路图分享
安徽蚌埠：着力打造新布局新模式新平台，构建智能传感器产业集群