一起写框架-MVC框架-基础功能-DispacherServlet控制器的实现(三)

实现功能

开发环境配置好，那么我们可以编写代码了

由于BasicMVC框架的对象交由BasicIOC容器托管，所以启动JavaWeb项目时，将程序所有的对象使用Ioc内核的机制加载到容器池里面。

基于这个原因：我们实现DispacherServlet控制器跳转必须首先完成以下三个动作

1.我们必须在Web启动是创建一个ApplicationContext容器操作对象；

2.我们必须需要一个配置类，来获得创建容器的信息

3.根据请求得路径跳转到对应Controller的对应映射路径的方法

实现步骤

第一步：我们必须需要一个配置类，来获得创建容器的信息

1.实现Web程序启动BasicIoc容器

--在用于测试的web项目，创建一个配置类IocCofing，并在web.xml作为DispacherServlet参数配置，以及编写一个用于测试是否启动了Ioc容器的UserController类

--配置类IocConfig代码--

package org.webmvc.cofig;

import ioc.core.annotation.ComponentScan;
import ioc.core.annotation.Configuration;

//使用定义@Configuration定义该类是一个配置类
@Configuration
//使用ComponentScan设置扫描包的路径
@ComponentScan(basePackages={"org.webmvc.controller"})
public class IocConfig {

}

--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/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>webmvc-demo-test-01</display-name>
   <servlet>
     <servlet-name>dispacherServlet</servlet-name>
     <servlet-class>ioc.webmvc.DispacherServlet</servlet-class>
     <init-param>
       <!-- 设置配置类的类全名 -->
       <param-name>cofig</param-name>
       <param-value>org.webmvc.cofig.IocConfig</param-value>
     </init-param>
   </servlet>
   <servlet-mapping>
     <servlet-name>dispacherServlet</servlet-name>
     <url-pattern>*.do</url-pattern>
   </servlet-mapping>
</web-app>

-编写一个用于测试的UserController类--

package org.webmvc.controller;

import ioc.core.annotation.stereotype.Controller;

@Controller
public class UserController {
    
    public void login(){
        System.out.println("-登录Controller-");
    }
}

2.编写BasicMVCMVC框架的DispacherServlet类的init方法。获得配置参数，以及启动BaiscIoC容器。

代码如下：

package ioc.webmvc;

import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import ioc.core.impl.AnntationApplicationContext;

/**
 * 核心控制，用于拦截所有的请求，MVC框架的入口。
 * @author ranger
 * @date 2017-11-08
 *
 */
public class DispacherServlet extends HttpServlet {

    private static final long serialVersionUID = -5969172674760020122L;
    private AnntationApplicationContext contextApplication=null;
    
    
    /**
     * 启动Web程序时，获得配置的参数
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        //1.配置参数是配置类的类全名
        String parameter = config.getInitParameter("config");
        //2.查看是否有参数了
        System.out.println(parameter);
        try {
            //3.将字符串使用反射技术，转成一个Class类
            Class<?> classType = Class.forName(parameter);
            //4.将对象加载到容器里面
            this.contextApplication=new AnntationApplicationContext(classType);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }



    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         System.out.println("-测试成功--");
        super.service(request, response);
    }
}

3.启动index.jsp，点击请求。容器打印出加载的对象内存地址。说明成功。

第二步：根据请求得路径跳转到对应Controller的对应映射路径的方法

确认通过web程序启动就可以使用BaiscIoc容器托管所有对象后。

我们需要理解请求可以找到对应的执行方法这个问题？

要解决这个问题，必须要有一个地方标识请求路径和方法的关系。这里我通过一个@RequestMapping注解来标识请求路径和执行方法的关系。

实现思路：

（1）在业务控制器设置标识方法对应请求路径的注解（@RequestMapping），必须指定映射路径

（2）请求到核心控制器是扫描所有业务控制器。获得对应的方法。

实现步骤：

1. 定义一个注解RequestMapping来声明路径与方法的关系

package ioc.webmvc.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
/*
 * 
 * 指定可以在方法以及类上面使用面使用
 * 1.在方法上面，指定请求路径
 * 2.在类上面用于指定命名空间
 */

@Target(value={ElementType.METHOD,ElementType.TYPE})
@Documented
public @interface RequestMapping {
    /**
     * 没有默认值，表示必须要填写
     * @return
     */
    String value();

}

2.获得所有Controller类型的对象。用于判断路径对应的方法。

在容器的实现类ContextImpl里面增加一个检索业务控制器对象的方法。

实现方式分为两步：标红的代码

（1）在容器定义接口中定义一个方法

package ioc.core;

import java.util.Map;

/**
 * Ioc框架的容器接口
 * @author ranger
 *
 */
public interface Context {
    


     /**
      * 用于获得容器中的所有对象
      * @return
      */
     Map<String,Object> getObjects();
     
     /**
      * 用于获得容器中的所有业务控制器对象
      * @return
      */
     Map<String,Object> getControllerObjects();
     
     /**
      * 用于增加容器中的对象
      * @param key
      * @param value
      */
     void addObject(String key, Object value);
     
     /**
      * 根据类的类型以及设置的对象名返回容器对象
      * 如果传入的类型容器中有对应key的对象，而且返回类型是兼容的，直接返回对应的对象。
      * 如果传入的类型容器中有没有对应key的对象，那么判断传入的类型是否和容器的对象的找到唯一配置的。
      * 如果传入类型唯一匹配，返回对象。如果没有或者配配多个对象，都报一个RuntimeException异常
      * @param classType
      * @return
      */
     Object getObject(Class<?> classType,String key);
     
     

}

（2）在实现类ContextImpl实现该方法，先增加一个getObjectsByComponentType方法编写通过组件注解类型返回对象，再实现getControllerObjects()方法。

/**
     * 用于通过传入标识组件类型的注解，返回对应类型的注解 注解类型分别为： Controller Service Repository
     * Component
     * 
     * @param componentsType
     * @return
     */
    public Map<String, Object> getObjectsByComponentType(Class<? extends Annotation> componentsType) {
        // 1.创建一个存储指定组件类型的Map
        Map<String, Object> componentsObjects = new HashMap<String, Object>();
        // 2.获得所有的容器对象
        Map<String, Object> objects = this.getObjects();
        // 3.获得Map中所有的对象的Set集合
        Set<Entry<String, Object>> entrySet = objects.entrySet();
        // 4.获得Set集合迭代器
        Iterator<Entry<String, Object>> iterator = entrySet.iterator();
        // 5.循环判断
        while (iterator.hasNext()) {
            Entry<String, Object> entry = iterator.next();
            // 6.获得当前对象的类类型，用于获得该类的类结构中的组件注解
            Class<?> classType = entry.getValue().getClass();
            // 7.容器里的对象是否是指定注解类型的,如果是加入到componentsObjects中
            Annotation annotation = classType.getDeclaredAnnotation(componentsType);
            if (annotation != null) {
                componentsObjects.put(entry.getKey(), entry.getValue());
            }

        }
        // 8.返回指定组件类型的对象
        return componentsObjects;
    }

    /**
     * 返回业务控制器Controller注解类型的所有对象
     */
    @Override
    public Map<String, Object> getControllerObjects() {
        return this.getObjectsByComponentType(Controller.class);
    }

3.测试代码获得的getObjectsByComponentType方法是否成功，输出指定的类型对象，说明成功。

package ioc.core.test;

import java.util.Map;

import org.junit.Test;

import ioc.core.annotation.stereotype.Service;
import ioc.core.impl.AnntationApplicationContext;
import ioc.core.impl.ContextImpl;
import ioc.core.test.config.Config;

public class ContextImplTest {
    
    
    @Test
    public void getObjectsByComponentsType(){
        AnntationApplicationContext applicationContext=new AnntationApplicationContext(Config.class);
        ContextImpl context = (ContextImpl) applicationContext.getContext();
        Map<String, Object> componentObjects = context.getObjectsByComponentType(Service.class);
        System.out.println(componentObjects+"==========================");
        
    }

}

--测试结果，输出的就是指定类型的对象

3.获得页面的请求路径匹配Controller对象中的方法的路径。

--创建一个ControllerRelolver类编写，检索方法的@RequestMapping注解

package ioc.webmvc.impl;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import ioc.core.Context;
import ioc.webmvc.annotation.RequestMapping;

public class ControllerRelolver {

    /**
     * 通过传入的参数，执行路径对应的业务控制器（Controller）的方法
     * @param request
     * @param response
     * @param context
     * @return
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    public String execute(HttpServletRequest request,HttpServletResponse response,Context context) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        //1.获得请求过来的路径
        String uri = request.getRequestURI();
        //2.根据路径规则，获得映射路径
        String path = this.pathRule(uri);
        //3.通过路径获得容器中对应的业务控制器的对象和执行方法
        MappingEnttiy mappingEnttiy = this.getRequestMethod(path, context);
        //4.获得执行方法
        Method method = mappingEnttiy.getMethod();
        //5.获得路径对应的业务控制器
        Object controller = mappingEnttiy.getController();
        //6.执行方法，执行方法必须有request,response两个参数
         Object resultObject = method.invoke(controller, request,response);
         if(resultObject!=null){
             //7.返回执行方法返回的映射字符串
             return (String) resultObject;
         }
        return null;
    }
    /**
     * 设置路径的规则
     * 路径规则为，保留/,去掉后缀。
     * 如：
     * 请求路径：http://localhost:8080/webmvc-demo-test-01/test.do
     * 合法的映射路径为：/test
     * 
     * @param url 传入的为请求路径
     * @return  符合规则的路径字符串
     *
     */
    private String pathRule(String url){
        //1.创建一个String构建字符串
        StringBuilder sb=new StringBuilder(url);
        System.out.println(url);
        //2.删除路径最后一个/之前的所有字符
        sb.delete(0, url.lastIndexOf("/"));
        System.out.println(sb.toString()+"删除后的字符串长度："+sb.length());
        //3.删除(.)后面的后缀
        sb.delete(sb.lastIndexOf("."),sb.length());
        return sb.toString();
    }
    
    /**
     * 通过路径获得对应的业务控制器对象和执行方法
     * @param path
     * @param context
     * @return
     */
    private MappingEnttiy getRequestMethod(String path,Context context){
        //1.获得Controller所有的Controller对象
        Map<String, Object> controllerObjects = context.getControllerObjects();
        System.out.println("-getRequestMethod-业务控制器对象池："+controllerObjects);
        //2.获得业务控制器池里面的所有值
        Collection<Object> values = controllerObjects.values();
        //3.遍历
        Iterator<Object> iterator = values.iterator();
        while (iterator.hasNext()) {
            //4.获得业务控制器池中当前对象
            Object object = iterator.next();
            //5.获得当前对象的类类类型
            Class<? extends Object> classType = object.getClass();
            //6.通过对象的类类型，获得对象的方法列表
            Method[] methods = classType.getMethods();
            //7.循环判断方法是否有RequestMapping注解
            for(Method method:methods){
                RequestMapping mapping = method.getDeclaredAnnotation(RequestMapping.class);
                //8.RequestMapping注解存在，而且等于映射路径，返回该方法的方法和当前对象
                if(mapping!=null&&mapping.value().equals(path)){
                    //9.声明内部类MappingEnttiy来封装映射的方法和对象。创建这个类的对象
                    MappingEnttiy entity=new MappingEnttiy();
                    entity.setController(object);
                    entity.setMethod(method);
                    return entity;
                }
            }
            
        }
        
        return null;
    }
    /**
     * 声明一个私有的内部类对象，用于存储执行检索业务控制器时返回的数据
     * @author ranger
     *
     */
    private class MappingEnttiy{
        //1.当前映射路径对应的对象
        private Object controller;
        //2.当前映射路径对应的方法
        private Method method;

        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;
        }
        
    }
}

4.核心控制器（DispacherServlet）调用这个业务控制解释器（ControllerRelolver）,标红处

package ioc.webmvc;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import ioc.core.impl.AnntationApplicationContext;
import ioc.webmvc.impl.ControllerRelolver;

/**
 * 核心控制，用于拦截所有的请求，MVC框架的入口。
 * 
 * @author ranger
 * @date 2017-11-08
 *
 */
public class DispacherServlet extends HttpServlet {

    private static final long serialVersionUID = -5969172674760020122L;
    private AnntationApplicationContext contextApplication = null;

    /**
     * 启动Web程序时，获得配置的参数
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        // 1.配置参数是配置类的类全名
        String parameter = config.getInitParameter("config");
        // 2.查看是否有参数了
        System.out.println(parameter);
        try {
            // 3.将字符串使用反射技术，转成一个Class类
            Class<?> classType = Class.forName(parameter);
            // 4.将对象加载到容器里面
            this.contextApplication = new AnntationApplicationContext(classType);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
       51 
52         ControllerRelolver rs = new ControllerRelolver();
53         try {
54             String result= rs.execute(request, response, contextApplication.getContext());
55             if(result!=null){
56                       //返回执行方法
57                 request.getRequestDispatcher(result).forward(request, response);
58             }
        } 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();
        }
    }
}

测试代码

1.测试的Web项目代码目录

2.代码如下

--IocConfig--

package org.webmvc.cofig;

import ioc.core.annotation.ComponentScan;
import ioc.core.annotation.Configuration;

//使用定义@Configuration定义该类是一个配置类
@Configuration
//使用ComponentScan设置扫描包的路径
@ComponentScan(basePackages={"org.webmvc.controller"})
public class IocConfig {

}

--UserController--

package org.webmvc.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import ioc.core.annotation.stereotype.Controller;
import ioc.webmvc.annotation.RequestMapping;

@Controller
public class UserController {
    
    /**
     * 路径规则：
     * 1.必须包括有/开头
     * 2.后缀必须忽略不写
     * 如：http://localhost:8080/webmvc-demo-test-01/test.do
     * 对应的映射路径为：/test
     *  
     */
    @RequestMapping(value = "/login")
    public String login(HttpServletRequest request,HttpServletResponse response){
        System.out.println("-登录Controller-");
        return "/login.jsp";

    }

}

---请求页面index.jsp--

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
  <a href="${pageContext.request.contextPath }/login.do">test</a>
</body>
</html>

---返回页面login.jsp--

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
  登录成功!
</body>
</html>

2.测试结