使用过spring mvc的小伙伴都知道，mvc在使用的时候，我们只需要在controller上注解上@controller跟@requestMapping（“URL”）,当我们访问对应的路径的时候，框架便会帮我们去映射到指定的controller里面的指定方法，那么这一切都是怎么做到的呢？还有我们所传递过去的参数，为什么通过request.getParam就能轻易地 拿到呢？大家都知道mvc的核心控制器DispacherServlet的基本运行流程，那么他的内部是怎么运行的呢，我们来做一下简单的实现，让我们能进一步的了解MVC。以助于我们今后的开发。
SpringMVC流程：
1、 用户发送请求至前端控制器DispatcherServlet。
2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3、 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4、 DispatcherServlet调用HandlerAdapter处理器适配器。
5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6、 Controller执行完成返回ModelAndView。
7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9、 ViewReslover解析后返回具体View。
10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
11、 DispatcherServlet响应用户。
此次实现基于Servlet 3.0，SpringBoot 2.0.1,采用注解的方式实现.这里我先把我的demo的工程包结构先贴出来：
pom文件：
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.</version>
</dependency>
首先，我们先从注解入手，为什么在类上面标注一下@controller以及@RequestMapping,他就能其效果呢？ 我们先来定义出这两个注解 @Controller :
@Target(ElementType.TYPE)//表示注解运行在哪里 这里表示只能注解再类上面
@Retention(RetentionPolicy.RUNTIME)//表示注解的(生命周期)哪来出现
public @interface WuzzController {
}
@RequestMapping :
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface WuzzRequestMapping {
String value();
}
@Service
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WuzzService {
String value() default "";
}
@Autowired
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WuzzAutowired {
String value() default "";
}
定义完注解后，那么我们创建一个TestController 来测试一下我们自己定义的注解
@WuzzController
@WuzzRequestMapping("/wuzz")
public class TestController extends BaseController{ @WuzzAutowired
private ServiceDemo serviceDemo; @WuzzRequestMapping("/index.do")
public void index() {
try {
response.getWriter().write("index"+serviceDemo.get("wuzz"));
} catch (IOException e) {
e.printStackTrace();
}
} @WuzzRequestMapping("/index1.do")
public void index1() {
try {
response.getWriter().write("index1");
} catch (IOException e) {
e.printStackTrace();
}
} @WuzzRequestMapping("/index2.do")
public void index2() {
try {
response.getWriter().write("index2");
} catch (IOException e) {
e.printStackTrace();
}
} @WuzzRequestMapping("/index3.do")
public void index3() {
try {
response.getWriter().write("index3");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Service：
public interface ServiceDemo {
String get(String name);
}
@WuzzService
public class ServiceDemoImpl implements ServiceDemo {
@Override
public String get(String name) {
return "service demo" + name;
}
}
很显然，现在我们虽然能在类，方法上注解上我们自己定义的注解，但是他们现在是起不到我们MVC框架中的效果的，在框架的内部肯定是需要有一系列操作，才能使得这些注解起效果，我们注意到，要使用MVC的时候我们通常需要配置一个注解扫描包。然后肯定是将有这些特定注解的类扫描出来，并创建出映射的路径，才能达到我们预期的效果。
现在我们可以做一个小小的测试：所以我这里建了一个Test类来做简单的获取指定类（TestController）里面有没有我们的注解：
public class Test {
private static final Logger LOGGER = LogManager.getLogger(Test.class);
public static void main(String[] args) {
// Class
Class clazz = TestController.class;
//判断这个类是否存在 @WuzzController
if (clazz.isAnnotationPresent(WuzzController.class)) {
LOGGER.info(clazz.getName() + "被标记为controller");
String path = "";
//判断clazz是否存在注解@WuzzRequestMapping
if (clazz.isAnnotationPresent(WuzzRequestMapping.class)) {
//取出注解的值 放入path
WuzzRequestMapping reqAnno =
(WuzzRequestMapping)clazz.getAnnotation(WuzzRequestMapping.class);
path = reqAnno.value().toString();
}
Method[] ms = clazz.getMethods();//拿到控制类所有公开方法遍历
for (Method method : ms) {
//如果不存在该注解 就进入下一轮
if (!method.isAnnotationPresent(WuzzRequestMapping.class)) {
continue;
}
LOGGER.info("方法"+method.getName()+",映射的对外路径：" + path
+ method.getAnnotation(WuzzRequestMapping.class).value().toString());
}
}
}
}
这里我们运行后的结果为：
这样我们就可以拿到指定的类里面的指定的一些注解的值，还可以做一系列的操作。好，那么现在我们需要想到的就是核心控制器DispacherServlet了。既然是servlet,我们先来看一下servlet的生命周期。Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：
- Servlet 通过调用 init () 方法进行初始化。
- Servlet 调用 service() 方法来处理客户端的请求。
- Servlet 通过调用 destroy() 方法终止（结束）。
- 最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
既然知道了servlet的生命周期，那就好办了，我们可以通过servlet的初始化，将指定包下的类都扫描起来，然后再重写service()方法去处理这些请求，不久可以了么？接下去我们试一试。
创建自己的DispacherServlet：我是再spring boot环境下去操作的。我们要配置好拦截路径，基准包并重写init(),service()方法
@WebServlet(urlPatterns = {"*.do"},loadOnStartup = ,initParams = {@WebInitParam(name = "basePackage", value = "com.wuzz.demo")})
public class WuzzDispacherServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
//保存url和Method的对应关系
private Map<String, Method> handlerMapping = new HashMap<String, Method>();
//保存扫描的所有的类名
private List<String> classNames = new ArrayList<String>();
//存放所扫描出来的类及其实例
private Map<String, Object> ioc = new HashMap<String, Object>();
public WuzzDispacherServlet() {
super();
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//访问地址http://localhost:8081/wuzz/index.do
//这里拿到uri : /wuzz/index.do
String uri = req.getRequestURI();
//从方法map里获取到映射到的方法实例 : public void com.example.demo.annotation.TestController.index()
//处理成相对路径
if (!this.handlerMapping.containsKey(uri)) {
resp.getWriter().write("404 Not Found!!!");
return;
}
Method method = this.handlerMapping.get(uri);
//通过反射拿到method所在class，拿到class之后还是拿到class的名称
//再调用toLowerFirstCase获得beanName
String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
BaseController controller;
try {
//获取实例
controller = (BaseController) ioc.get(beanName);
//初始化该controller的请求与响应
//也就是我们的请求中参数怎么通过requset.getParam方法拿到的原因
System.out.println(req.getRequestURI());
controller.init(req, resp);
//然后调用该方法
method.invoke(controller);
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void init(ServletConfig config) throws ServletException {
//获取基础扫描包： 这里设定为com.wuzz.demo
String basePackage = config.getInitParameter("basePackage");
//1 扫描包得到所有的class 并且注入ioc
doScanner(basePackage);
//2、初始化扫描到的类，并且将它们放入到ICO容器之中
doInstance();
//3.实际上这里中间可以扫描@Service @Autowired 注解实现自动的依赖注入
//可参考DispacherServlet 的初始化流程
//可参考DispacherServlet#initStrategies(ApplicationContext context)
doAutowired();
//4、初始化HandlerMapping
initHandlerMapping();
}
//扫描出相关的类
private void doScanner(String scanPackage) {
//scanPackage = com.gupaoedu.demo ，存储的是包路径
//转换为文件路径，实际上就是把.替换为/就OK了
//classpath
URL url = this.getClass().getClassLoader().getResource("" + scanPackage.replaceAll("\\.", "/"));
File classPath = new File(url.getFile());
for (File file : classPath.listFiles()) {
if (file.isDirectory()) {
doScanner(scanPackage + "." + file.getName());
} else {
if (!file.getName().endsWith(".class")) {
continue;
}
String className = (scanPackage + "." + file.getName().replace(".class", ""));
classNames.add(className);
}
}
}
private void doInstance() {
//初始化，为DI做准备
if (classNames.isEmpty()) {
return;
}
try {
for (String className : classNames) {
Class<?> clazz = Class.forName(className);
//什么样的类才需要初始化呢？
//加了注解的类，才初始化，怎么判断？
//为了简化代码逻辑，主要体会设计思想，只举例 @Controller和@Service,
// @Componment...就一一举例了
if (clazz.isAnnotationPresent(WuzzController.class)) {
Object instance = clazz.newInstance();
//Spring默认类名首字母小写
String beanName = toLowerFirstCase(clazz.getSimpleName());
ioc.put(beanName, instance);
} else if (clazz.isAnnotationPresent(WuzzService.class)) {
//1、自定义的beanName
WuzzService service = clazz.getAnnotation(WuzzService.class);
String beanName = service.value();
//2、默认类名首字母小写
if ("".equals(beanName.trim())) {
beanName = toLowerFirstCase(clazz.getSimpleName());
}
Object instance = clazz.newInstance();
ioc.put(beanName, instance);
//3、根据类型自动赋值,投机取巧的方式
for (Class<?> i : clazz.getInterfaces()) {
if (ioc.containsKey(i.getName())) {//接口若有多个实现
throw new Exception("The “" + i.getName() + "” is exists!!");
}
//把接口的类型直接当成key了
ioc.put(i.getName(), instance);
}
} else {
continue;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//如果类名本身是小写字母，确实会出问题
//但是我要说明的是：这个方法是我自己用，private的
//传值也是自己传，类也都遵循了驼峰命名法
//默认传入的值，存在首字母小写的情况，也不可能出现非字母的情况
//为了简化程序逻辑，就不做其他判断了，大家了解就OK
//其实用写注释的时间都能够把逻辑写完了
private String toLowerFirstCase(String simpleName) {
char[] chars = simpleName.toCharArray();
//之所以加，是因为大小写字母的ASCII码相差32，
// 而且大写字母的ASCII码要小于小写字母的ASCII码
//在Java中，对char做算学运算，实际上就是对ASCII码做算学运算
chars[] += ;
return String.valueOf(chars);
}
//自动依赖注入
private void doAutowired() {
if (ioc.isEmpty()) {
return;
}
for (Map.Entry<String, Object> entry : ioc.entrySet()) {
//Declared 所有的，特定的 字段，包括private/protected/default
//正常来说，普通的OOP编程只能拿到public的属性
Field[] fields = entry.getValue().getClass().getDeclaredFields();
for (Field field : fields) {
if (!field.isAnnotationPresent(WuzzAutowired.class)) {
continue;
}
WuzzAutowired autowired = field.getAnnotation(WuzzAutowired.class);
//如果用户没有自定义beanName，默认就根据类型注入
//这个地方省去了对类名首字母小写的情况的判断，这个作为课后作业
//小伙伴们自己去完善
String beanName = autowired.value().trim();
if ("".equals(beanName)) {
//获得接口的类型，作为key待会拿这个key到ioc容器中去取值
beanName = field.getType().getName();
}
//如果是public以外的修饰符，只要加了@Autowired注解，都要强制赋值
//反射中叫做暴力访问， 强吻
field.setAccessible(true);
try {
//用反射机制，动态给字段赋值
field.set(entry.getValue(), ioc.get(beanName));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
//初始化url和Method的一对一对应关系
private void initHandlerMapping() {
if (ioc.isEmpty()) {
return;
}
for (Map.Entry<String, Object> entry : ioc.entrySet()) {
Class<?> clazz = entry.getValue().getClass();
if (!clazz.isAnnotationPresent(WuzzController.class)) {
continue;
}
//保存写在类上面的@GPRequestMapping("/demo")
String baseUrl = "";
if (clazz.isAnnotationPresent(WuzzRequestMapping.class)) {
WuzzRequestMapping requestMapping = clazz.getAnnotation(WuzzRequestMapping.class);
baseUrl = requestMapping.value();
}
//默认获取所有的public方法
for (Method method : clazz.getMethods()) {
if (!method.isAnnotationPresent(WuzzRequestMapping.class)) {
continue;
}
WuzzRequestMapping requestMapping = method.getAnnotation(WuzzRequestMapping.class);
//优化
// //demo///query
String url = ("/" + baseUrl + "/" + requestMapping.value())
.replaceAll("/+", "/");
handlerMapping.put(url, method);
System.out.println("Mapped :" + url + "," + method);
}
}
}
}
最后要使这个@WebServlet 起效果，需要配置启动类：
@SpringBootApplication
@ServletComponentScan
public class App {
private final static Logger log = LoggerFactory.getLogger(App.class); public static void main(String[] args) {
SpringApplication.run(App.class, args);
log.info("服务启动成功");
}
}
经过以上的这些操作，我们自己定义的注解就能生效了，那么现在我们需要考虑的是，这个controller里面，我需要获取请求参数和响应要怎么做呢，其实，我们只要在初始化controller的时候将requset跟response给他塞进去不久好了嘛？我们可以创建一个controller的基类
public class BaseController {
protected HttpServletRequest request;
protected HttpServletResponse response;
public void init(HttpServletRequest request, HttpServletResponse response) {
this.request = request;
this.response = response;
}
public HttpServletRequest getRequest() {
return request;
}
public void setRequest(HttpServletRequest request) {
this.request = request;
}
public HttpServletResponse getResponse() {
return response;
}
public void setResponse(HttpServletResponse response) {
this.response = response;
}
}
这样子，我们在service()方法内去获取该controller实例的时候controller.init(req, resp); 给他插进去这两个东西，就完事了。最后启动主类，你会发现它真的就调用了controller下的方法。
如果启用XML的形式去做的话，大致大逻辑还是一样的，只不过需要如下修改：
1.添加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>Gupao Web Application</display-name>
<servlet>
<servlet-name>gpmvc</servlet-name>
<servlet-class>com.gupaoedu.mvcframework.v2.servlet.GPDispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>application.properties</param-value>
</init-param>
<load-on-startup></load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>gpmvc</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
2.去掉 @WebServlet 注解，添加 application.properties 内容如下：
basePackage = com.wuzz.demo
3.既然添加了配置文件，那么我们需要扫描配置文件获取配置信息
//保存application.properties配置文件中的内容
private Properties contextConfig = new Properties();
//加载配置文件
private void doLoadConfig(String contextConfigLocation) {
//直接从类路径下找到Spring主配置文件所在的路径
//并且将其读取出来放到Properties对象中
//相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
try {
contextConfig.load(fis);
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null != fis){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
加载配置文件
doLoadConfig(config.getInitParameter("contextConfigLocation")); 扫描相关的类
doScanner(contextConfig.getProperty("scanPackage"));
4.修改pom文件为war包形式
contextConfigLocation 是我们在web.xml中配置的。然后用Tomcat启动即可。