手写SpringMVC底层原理实现

手写SpringMVC首先理清思路，具体要做什么 我分为以下几个步骤

1.扫描包下带有@Controller @Service注解的类

2.实例化:将扫描的类通过反射实例化并保存到ioc容器中

3.依赖注入:将存在依赖的bean进行注入:列如被@Autowired修饰的属性进行注入

4.urlMapping:http请求路径与方法建立映射关系

理清思路我们就开始快乐之旅吧~~~~~~

1.新建一个web工程添加servlet jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.work</groupId>
    <artifactId>StudySpring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>  
</project>

1.1 web.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <servlet>
        <servlet-name>DisparcherServlet</servlet-name>
        <servlet-class>com.work.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>0</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>DisparcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

2 .新建注解(@Controller,@Awtowired,@RequestMapping,@Service,@RequestParams)（为了区分Spring框架我这里注解前缀都会有Zp）

@Target(ElementType.TYPE) //表示只能作用在类上
@Retention(RetentionPolicy.RUNTIME) //表示可以在运行时通过反射获取
@Documented //javadoc
public @interface ZpController {

    String value() default "";
}

 

@Target(ElementType.FIELD) //表示只能作用在属性上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ZpAutowired {
    String value() default "";
}

@Target({ElementType.TYPE,ElementType.METHOD}) //表示可以作用在类上和方法上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ZpRequestMapping {
    String value() default "";
}

 

@Target(ElementType.TYPE) //表示可以作用在类上
@Retention(RetentionPolicy.RUNTIME) //表示可以在运行时通过反射获取
@Documented
public @interface ZpService {
    String value() default "";
}

@Target(ElementType.PARAMETER) //表示只能作用在参数上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ZpRequestParams {
    String value() default "";
}

3.新建接口类

public interface  StudentBiz {
    String helloSpring();
}

4.接口实现类

@ZpService("studentBizImpl")
public class StudentBizImpl implements StudentBiz{

    public String helloSpring() {
        return "hello Spring";
    }
}

5.新建controller控制层

@ZpController
@ZpRequestMapping("/student")
public class StudentController {

    @ZpAutowired("studentBizImpl")
    public StudentBiz studentBiz;

    @ZpRequestMapping("/query.do")
    public void queryInfo(HttpServletRequest req, HttpServletResponse resp,@ZpRequestParams("name") String name){
        try {
            resp.setContentType("application/json;charset=utf-8");
            PrintWriter pw=resp.getWriter();
            //调用业务层方法
            String str = studentBiz.helloSpring();
            pw.print(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.新建DispatcherServlet处理器

package com.work.servlet;
import com.work.annotation.*;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
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.annotation.Annotation;
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;


/**
 * @ProjectName: SpringPrinciple
 * @Package: PACKAGE_NAME
 * @ClassName: DispatcherServlet
 * @Description: java类作用描述: 模仿springMVC处理器
 * @Author: 祝平
 * @CreateDate: 2019-02-26 17:21
 * @UpdateUser: 更新者
 * @UpdateDate: 2019-02-26 17:21
 * @UpdateRemark: 更新说明
 * @Version: 1.0
 */
public class DispatcherServlet extends HttpServlet{

    //保存class文件地址
    List<String> classPaths=new ArrayList<String>();

    //IOC容器
    Map<String,Object> beans=new HashMap<String, Object>();

    //存储方法的容器
    Map<String,Object> handlerMap=new HashMap<String, Object>();


    @Override
    public void init() throws ServletException {
        //扫描所有类
        doScanPackage("com.work");
        //实例化
        doInstance();
        //依赖注入
        doAutowired();
        //请求地址和方法映射
        urlMapping();
    }

    /**
     *  扫描所有带有@ZpController,@ZpService的类进行装载
     * @param basePackage 类的路径
     */
    public void doScanPackage(String basePackage){
        //获取com.work下所有的类文件地址
        //对于java来说只认识com/work格式,所以需要把.转换成/
        URL url=this.getClass().getClassLoader().getResource("/"+basePackage.replaceAll("\\.","/"));
        String fileStr=url.getFile(); //相当于获取到com/work..
        File file=new File(fileStr); //根据获取到的地址转成文件
        String[] filesStr=file.list(); //获取所有文件
        //遍历所有文件判断是否是.class结尾的
        for(String path:filesStr){
            File filePath=new File(fileStr+path);
            //判断是否是路径,如果是就递归,直至拿到class文件
            if(filePath.isDirectory()){
                doScanPackage(basePackage+"."+path);
            }else{
                // .class文件
                classPaths.add(basePackage+"."+path); //其实就是com.work.controller...下的类路径
            }
        }

    }

    /**
     *  进行实例化
     */
    public void doInstance(){
        //遍历所有地址进行类加载，判断是否被@ZpController和@ZpService注解修饰的类
        for (String classPath:classPaths){
            try {
                //拿到的地址是com.work.controller.类.class所以需要把.class转换一下
                Class<?> clazz=Class.forName(classPath.replace(".class",""));
                //判断是否被@ZpController修饰
                if (clazz.isAnnotationPresent(ZpController.class)){
                    //说明是控制类
                    beans.put(lowerFirstChar(clazz.getSimpleName()),clazz.newInstance());
                }else if (clazz.isAnnotationPresent(ZpService.class)){
                    //说明是Service
                    ZpService zpService=clazz.getAnnotation(ZpService.class);
                    String key=zpService.value();
                    if(!"".equals(key)){
                        beans.put(key,clazz.newInstance());
                        continue;
                    }
                    //如果@ZpService注解没设置值就用接口的名字接口的名字首字母小写
                    Class[] inters=clazz.getInterfaces();
                    //此处简单处理了，假定ServiceImpl只实现了一个接口
                    for (Class c : inters) {
                        //举例 modifyService->new ModifyServiceImpl（）
                        beans.put(lowerFirstChar(c.getSimpleName()), clazz.newInstance());
                        break;
                    }

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

    }

    /**
     * 依赖注入
     */
    public void doAutowired(){
        for (Map.Entry<String,Object> bean:beans.entrySet()){
            Class<?> clazz=bean.getValue().getClass();
            if(clazz.isAnnotationPresent(ZpController.class)){
                //获取private修饰的属性
                Field[] fields=clazz.getDeclaredFields();
                //遍历所有属性是否被@ZpAutowired修饰
                for(Field field:fields){
                    if(!field.isAnnotationPresent(ZpAutowired.class)){
                        continue;
                    }
                    //获取@ZpAutowired的值进行匹配注入
                    ZpAutowired zpAutowired=field.getAnnotation(ZpAutowired.class);
                    String beanName;
                    if("".equals(zpAutowired.value())){
                        beanName = lowerFirstChar(field.getType().getSimpleName());
                    }else{
                        beanName = zpAutowired.value();
                    }
                    //因为是private修饰  需要开启权限才能注入实例
                    field.setAccessible(true);
                    if(beans.get(beanName) != null){
                        try {
                            //注入实例
                            field.set(bean.getValue(),beans.get(beanName));
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    /**
     * 进行请求地址和方法映射
     */
    public void urlMapping(){
        for(Map.Entry<String,Object> entry:beans.entrySet()){
            Class<?> clazz=entry.getValue().getClass();
            //判断是否是控制类
            if(clazz.isAnnotationPresent(ZpController.class)){
                //获取ZpController注解上的值
                ZpRequestMapping zrm=clazz.getAnnotation(ZpRequestMapping.class);
                String classPath=zrm.value();
                //获取方法上ZpRequestMapping注解的值
                Method[] methods=clazz.getDeclaredMethods();//获取所有方法
                //遍历方法
                for (Method method:methods){
                    if(method.isAnnotationPresent(ZpRequestMapping.class)){
                        ZpRequestMapping zpRequestMapping=method.getAnnotation(ZpRequestMapping.class);
                        String methodPath=zpRequestMapping.value();
                        //进行拼接
                        handlerMap.put(classPath+methodPath,method);
                    }else{
                        continue;
                    }
                }
            }
        }
    }


    /**
     * tomcat启动完成后做得处理
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取请求的地址
        String url=req.getRequestURI();
        int index=url.indexOf("/",1);
        String controllerURL=url.substring(0,index);//截取到/hello
        Method method=(Method) handlerMap.get(url);
        for(Map.Entry<String,Object> bean:beans.entrySet()){
            Class<?> clazz=bean.getValue().getClass();
            if(clazz.isAnnotationPresent(ZpController.class)){
                ZpRequestMapping zrm=clazz.getAnnotation(ZpRequestMapping.class);
                String zcValue=zrm.value();
                if(controllerURL.equals(zcValue)){
                    try {
                        Object[] args=getArgs(req,resp,method);
                        method.invoke(bean.getValue(),args);
                    }  catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }
            }

        }

    }

    /**
     * 找出方法所需要的方法参数
     * @param req
     * @param resp
     * @param method
     * @return
     */
    private static Object[] getArgs(HttpServletRequest req, HttpServletResponse resp,Method method){
        //拿到当前类待执行的方法参数
        Class<?>[] clazzParams=method.getParameterTypes();
        //根据参数的个数，new一个参数的数组，将方法里的所有参数赋值到args里
        Object [] args=new Object[clazzParams.length];
        int args_i=0;
        int index=0;
        for(Class<?> clazz:clazzParams){
            //判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口
            if(ServletRequest.class.isAssignableFrom(clazz)){
                args[args_i++]=req;
            }
            if(ServletResponse.class.isAssignableFrom(clazz)){
                args[args_i++]=resp;
            }
            //判断有没有@ZpRequestParams注解
            Annotation[] pramsAns=method.getParameterAnnotations()[index];
            if(pramsAns.length>0){
                for(Annotation paramAn:pramsAns){
                    if(ZpRequestParams.class.isAssignableFrom(paramAn.getClass())){
                        ZpRequestParams zrp=(ZpRequestParams)paramAn;
                        //找到注解的name
                        args[args_i++]=req.getParameter(zrp.value());
                    }
                }
            }
            index++;
        }
        return args;
    }

    /***
     * 转小写方法
     * @param className
     * @return
     */
    private String lowerFirstChar(String className) {
        char[] chars = className.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }
}

 

至此就已经完成我们的功能了