SpringMVC浅析 - 20181226

时间 2019-11-19

原文原文链接

【面试题】在浏览器输入登陆地址后，浏览器作了什么？
六步：①域名解析、②tcp握手、③创建链接、④发送报文、⑤服务器应答、⑥解析html
域名解析：将英文的网址名转换成ip地址
tcp链接创建：创建通讯信道，通过三次握手
创建链接
发送报文：就是消息头，消息体那些东西
服务器应答：(能够扩充nginx，服务器集群等等)
解析html：
（渲染）：html
再来看看SpringMVC工做流程
DispatcherServlet：在web.xml理配置的servlet，前端控制器，起到一个路由的功能。
HandlerMapping：以后找到映射控制器，这样就能够找到对应的controller了
HandlerAdatper：经过处理器适配器，能够找到controller中的方法
拼装成视图再返回前端

手写一个`迷你版的SpringMVC`

依赖

<dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
       </dependency>
       <dependency>
           <groupId>javax.servlet</groupId>
           <artifactId>javax.servlet-api</artifactId>
           <version>4.0.0</version>
       </dependency>

大体流程思路
①、自定义注解，模拟：@Controller/@Service/@RequestMapping/@Autowired
②、包扫描，类加载实例化，实现@Controller、@Service功能
③、依赖注入，实现@Autowired功能
④、映射处理，实现@RequestMapping功能java
自定义注解，模拟：@Controller/@Service/@RequestMapping/@Autowirednginx

/** * 自注解的Controller * Created by Turing on 2018/12/26 11:38 */
@Documented //注解包含在javadoc中
@Retention(RetentionPolicy.RUNTIME) //注解保留策略，注解在哪一个阶段生效【source源码保存、class字节码文件保存、runtime运行时仍获取注解信息(反射须要用到)】
@Target({ElementType.TYPE}) //注解做用的范围
public @interface Controller {

    String value() default "";  //经过反射，取出@Controller("xxx"),里的xxx
}

/** * Created by Turing on 2018/12/26 12:37 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE}) //注解做用的范围——类上
public @interface Service {

    String value() default "";
}

/** * Created by Turing on 2018/12/26 12:46 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD}) //注解做用的范围——类上，方法上
public @interface RequestMapping {

    String value() default "";
}

/** * Created by Turing on 2018/12/26 12:51 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD}) //注解做用的范围——成员变量上
public @interface Autowired {

    String value() default "";
}

Controller 和 Service

/** * Created by Turing on 2018/12/26 13:43 */
@Controller
@RequestMapping(value = "/test")
public class TestController {

    @Autowired("testService")
    TestService testService;

    @RequestMapping("/index")
    public String index(){
        System.out.println(testService.test()+": index");
        return testService.test()+"index";
    }
}

/** * Created by Turing on 2018/12/26 13:44 */
@Service
public class TestService {

    public String test(){
        return "service test";
    }
}

在web.xml中配置，自定义的DispatcherServlet

<!--前端控制器-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>com.mvc.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup> <!--随着容器启动，进行初始化-->
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

DispatcherServlet

import com.mvc.annotation.Autowired;
import com.mvc.annotation.Controller;
import com.mvc.annotation.RequestMapping;
import com.mvc.annotation.Service;

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.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/** * 一、想完成Controller和Service的包扫描 * 二、类加载并实例化 * 三、依赖注入 * 四、url和方法关系映射 * Created by Turing on 2018/12/26 13:48 */
public class DispatcherServlet extends HttpServlet {
    //扫描到的类名，存入list集合中
    private List<String> classNames = new ArrayList<String>();

    //Controller和Service的实例化，暂存缓存
    private Map<String,Object> beans=new HashMap<String,Object>();

    //找到方法的映射缓存，暂存
    private Map<String,Object> handlerMapping=new HashMap<String,Object>();


    @Override
    //重写init方法，才能完成目标四步
    public void init() throws ServletException {
        System.out.println("======容器启动======");

        //一、包扫描【正常应该是xml将解析，如今是模拟】
        scanPackage("com.mvc");

        for (String str : classNames) {//打印，测试下
            System.err.println(str);
        }

        //二、类加载并实例化
        try {
            createInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }

        for(Map.Entry<String,Object> entry:beans.entrySet()){//打印，测试下
            System.out.println(entry.getKey()+"<=======>"+entry.getValue());
        }

        //三、依赖注入
        try {
            injection();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        //四、URL和方法的关系映射，handlerMapping做用
        handlerMapping();
    }

    //一、
    private void scanPackage(String packageName) {
        //类加载的时候,将包结构.替换成/,\\.是正则表达式中的关键字符，表明任意字符
        String path = packageName.replaceAll("\\.","/");

        //classLoader 进行资源加载，
        URL url = this.getClass().getClassLoader().getResource("/"+path);

        //递归目录，查找class文件
        File[] files = new File(url.getFile()).listFiles();

        for (File file : files) {
            //判断是否为目录
            if(file.isDirectory()){
                //遍历目录
                scanPackage(packageName+"."+file.getName());
            }else {
                //扫描到类，先缓存起来，包+类名 拼成 全限定名
                classNames.add(packageName+"."+file.getName());
            }
        }
    }

    //二、
    private void createInstance() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //判断,没有扫描到类
        if(classNames.isEmpty()){
            System.out.println("没有扫描到类。。。");
            return;
        }
        //遍历,类名缓存，加载并初始化
        for(String name:classNames){
            //类加载时，将类名去调后缀.class
            String className=name.replace(".class","");
            //完成类加载
            Class<?> clazz = Class.forName(className);

            //只关注controller和service,判断类上是否有对应注解
            if(clazz.isAnnotationPresent(Controller.class)){
                //实例化类
                Object controller = clazz.newInstance();
                RequestMapping rm = clazz.getAnnotation(RequestMapping.class);
                String value = rm.value();  //运行时，取出括号中的值

                //保存了RequestMapping括号里的东西，到对应Controller的映射
                beans.put(value,controller);
            }

            //拿到servcie
            if(clazz.isAnnotationPresent(Service.class)){
                Object service = clazz.newInstance();
                RequestMapping rm = clazz.getAnnotation(RequestMapping.class);
                String value = rm.value();

                beans.put(value,service);
            }
        }
    }
    //三、
    private void injection() throws IllegalAccessException {
        //判断,没有实例化
        if(beans.isEmpty()){
            System.out.println("没有实例化。。。");
            return;
        }

        //遍历，找到controller，并找到全部字段
        for(Map.Entry<String,Object> entry:beans.entrySet()){
            //取出对象
            Object obj = entry.getValue();
            //取出字段
            Field[] fields=obj.getClass().getDeclaredFields();
            //遍历，找到@Autowired
            for (Field field : fields) {
                if(field.isAnnotationPresent(Autowired.class)){
                    Autowired autowired = field.getAnnotation(Autowired.class);
                    //取出注解上的值
                    String value = autowired.value();

                    //完成注入
                    field.setAccessible(true);//打开私有，令其能够访问
                    //经过value拿到@Autowired括号里的实例
                    field.set(obj,beans.get(value));
                }
            }
        }
    }
    //四、
    private void handlerMapping() {
        //判断,没有实例化
        if(beans.isEmpty()){
            System.out.println("没有实例化。。。");
            return;
        }
        //遍历，找到RequestMapping，并完成映射
        for(Map.Entry<String,Object> entry:beans.entrySet()){
            //取出对象
            Object obj = entry.getValue();

            if(obj.getClass().isAnnotationPresent(RequestMapping.class)){
                //先拿类上的值
                RequestMapping rm = obj.getClass().getAnnotation(RequestMapping.class);
                String classValue = rm.value();

                //再拿方法上的值
                Method[] methods=obj.getClass().getMethods();

                //遍历，找到方法上的@RequestMapping
                for (Method method : methods) {

                    if(method.isAnnotationPresent(RequestMapping.class)){
                        RequestMapping mapping = method.getAnnotation(RequestMapping.class);
                        String methodValue = mapping.value();

                        //进行组合，并缓存起来,这样拿到去到方法的映射
                        handlerMapping.put(classValue+methodValue,method);
                    }
                }
            }
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String uri = request.getRequestURI();
        String context = request.getContextPath();
        String path = uri.replaceAll(context, "");

        System.err.println(uri+","+context+","+path);

        //根据"类/方法"路径，获取对应的方法
        Method method = (Method) handlerMapping.get(path);
        //获取对象
        Object instance = beans.get("/" + path.split("/")[1]);  //分割拿到后边的方法

        try {
            //反射调用
            method.invoke(instance,null);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        super.doGet(request, response);
    }
}

SpringMVC浅析 - 20181226

手写一个迷你版的SpringMVC

手写一个`迷你版的SpringMVC`