300行代码带你了解Spring的核心运行原理

我会带着你远行 2022-12-09 05:17 185阅读 0赞

## 一、Spring核心原理分析 ##

Spring在目前JavaSE开发领域占有绝对的主导地位，可以毫不夸张的说现在任何一家公司项目的主导框架绝对是Spring。那么为何大家都这么齐心的选择Spring呢。原因很简单，易上手，封装度高，简化开发，提升效率。

Spring是一个BOP编程框架，何为BOP呢？ 所谓BOP就是 Bean Oriented Programming，面向Bean编程。这种思想，可以联想Java本省的OOP编程，面向对象编程。而Bean对于BOP，就相当于Object对于OOP的意义一样。这样应该好理解一些。

Spring之所以这么经典，归功于其对设计模式的灵活运用和编程思想的合理使用。Spring的拥有自己的编程策略，来决定如何简化开发。

*  基于POJO的轻量级和最小侵入式编程
 *  通过依赖注入和面向接口松耦合
 *  基于切面和惯性进行声明式编程
 *  基于切面和模板减少样板式编程

以上4点是Spring核心策略。而Spring最为经典的两大特性绝对是IOC、AOP和DI。

*  IOC(控制反转): 创建对象的权力交给Spring自动管理，创建对象Bean注入到IOC容器中，并且将每个Bean声明命名
 *  DI(依赖注入): 将对象从IOC容器中拿出，自动赋值。弃用手动new赋值。
 *  AOP(切面编程):多个方法的同一代码块，提出来作为一个"面",方法公用。

Spring的功能分布图，涵盖了Spring对于开发中常用功能总结：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzNDkwNDQ3NDA2_size_16_color_FFFFFF_t_70][]

Spring-core IOC和DI最基本的实现

Spring-beans Bean工厂与Bean的装配

Spring-context 定义Spring的Context的上线文以及IOC容器

Spring-context-support 对Spring容器的扩展支持，以及IOC子容器

Spring-context-indexer Spring的类管理组件和Classpath扫描 (类加载路径)

Spring-expression Spring表达式语言

Spring-Aop 面向切面编程的应用模块 整合Asm CGLIB JDKProxy

Spring-aspects 集成AspectJ AOP的应用框架

Spring-Instrument 动态Class Loading模块

Spring-jdbc JDBC抽象框架的实现模块

Spring-tx JDBC 事务控制

Spring-orm 集成ORM框架

Spring-oxm Java->xml xml->java

Spring-jms Java的消息发送和接收

Spring-web Web支持

Spring-webmvc SpringMvc

Spring-websocket 通讯

Spring-webflux 全新的非阻塞函数式框架

## 二、300行代码模拟实现Spring核心功能 ##

*  配置阶段

1.  配置核心配置文件 web.xml (DispatcherServlet 统一入口)
2.  设定 init-param （ contextConfigLoacation = classpath:application.xml）
3.  设定 url-pattern /\* servlet拦截请求设定
4.  配置注解 Annotation (@Controller @Service @Autowirted @RequestMapping)

<?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.lishuoedu.mvcframework.v3.servlet.SpringDispatcherServlet</servlet-class>
    		
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>application.properties</param-value>
    		</init-param>
    		<load-on-startup>1</load-on-startup>
    	</servlet>
    	<servlet-mapping>
    		
    		<servlet-name>gpmvc</servlet-name>
    		<url-pattern>/*</url-pattern>
    	</servlet-mapping>
    </web-app>

// 模拟注入注解
    @Target({ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface LSAutowired {
        String value() default "";
    }

// 模拟Controller注解
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface LSController {
        String value() default "";
    }

// 模拟mapping注解
    @Target({ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface LSRequestMapping {
        String value() default "";
    }

// 模拟 requestParam 注解
    @Target({ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface LSRequestParam {
        String value() default "";
    }

// 模拟 Service 注解
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface LSService {
        String value() default "";
    }

*  初始化阶段

1.  重写并且调用init()方法 (加载配置文件，初始化准备)
2.  IOC容器初始化
3.  扫描映射关系对应的相关类
4.  创建类实例化并存入IOC容器缓存 (IOC)
5.  进行DI操作 (扫描IOC容器中的实例，对实例中的属性进行复制 @Autowrited注解)
6.  初始化HandlerMapping (将URL和Method进行一对一的关系映射)

*  运行阶段

1.  前端输入请求路径 调用doGet/doPost() 方法 获取Request/Response对象
2.  匹配HandlerMapping 从request获取用户输入的url找到对应的Method方法
3.  反射调用method.invoker() 利用反射调用方法并返回结果
4.  response.getwriter().writer() 将返回信息结果输出到浏览器

public class SpringDispatcherServlet extends HttpServlet{
    
        /**  对应application.properties中的配置信息 */
        private Properties contextConfig = new Properties();
        /**  类信息 */
        private List<String> classNames = new ArrayList<>();
        /**  ioc */
        private Map<String,Object> ioc = new HashMap<String,Object>();
    
        private List<HandlerMapping> handlerList = new ArrayList<>();
    
    
        // 重写父类的 doGet/doPost 方法
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //  简单模拟，Get请求暂时使用Post
            doPost(req,resp);
        }
    
        // 3. 运行阶段
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setCharacterEncoding("UTF-8");
            resp.setHeader("Content-Type", "text/html;charset=UTF-8");
            //  url 关系映射反射执行对应method
            try {
                doDispatcher(req,resp);
            } catch (Exception e) {
                resp.getWriter().write("500 method invoke failed, failed reason : " + e.getMessage());
            }
        }
    
    
        private void doDispatcher(HttpServletRequest req, HttpServletResponse resp) throws Exception {
            //  根据请求的url寻找对应的handler
            HandlerMapping handler = getHandler(req);
            if(null == handler){
                resp.getWriter().write("404 not found!!");
                return;
            }
            // 存在比对正常的handle
            // 获取方法的形参列表
            Class<?>[] paramTypes = handler.getParamTypes();
            // 拿到参数
            Map<String,String []> parameterMap = req.getParameterMap();
            // 参数索引位置
            Map<String, Integer> paramIndexMapping = handler.getParamIndexMapping();
            // 参数列表
            Object [] params = new Object[paramTypes.length];
            // k: key v : value （String []）
            parameterMap.forEach((k,v)->{
                  //  value格式转换   [] 替换成 ""   空格 替换成 ""
                String value = Arrays.toString(v).replaceAll("\\[|\\]","")
                        .replaceAll("\\s","");
                // 判断当前参数在入参数组中的位置
                if(!paramIndexMapping.containsKey(k)){return;}
                // 参数格式转换
                params[paramIndexMapping.get(k)] = convert(paramTypes[paramIndexMapping.get(k)],value);
            });
            // 特殊参数处理
            String requestName = HttpServletRequest.class.getName();
            if(paramIndexMapping.containsKey(requestName)){
                params[paramIndexMapping.get(requestName)] = req;
            }
            String responseName = HttpServletResponse.class.getName();
            if(paramIndexMapping.containsKey(responseName)){
                params[paramIndexMapping.get(responseName)] = resp;
            }
            // 反射执行
            Object invoke = handler.getMethod().invoke(handler.getController(), params);
            if(invoke == null || invoke instanceof Void){ return; }
            // 返回参数  现在默认考虑String反参形式 所以暂时使用 toString方法
            resp.getWriter().write(invoke.toString());
        }
    
        // 参数转化
        private Object convert(Class<?> paramType, String value) {
            if(paramType == Integer.class){
                return Integer.parseInt(value);
            }else if(paramType == Double.class){
                return Double.parseDouble(value);
            }
            return value;
        }
    
        private HandlerMapping getHandler(HttpServletRequest req) {
              if(handlerList.isEmpty()){return null;}
              // 获取绝对路径
             String url = req.getRequestURI();
             System.out.println("请求的绝对路径为  : { " + url + " }");
             // 获取相对路径
             String contextPath = req.getContextPath();
             System.out.println("请求的相对路径为  : { " + contextPath + " }");
             //  url 比对
             url = url.replaceAll(contextPath,"").replaceAll("/+","/");
             // 遍历 handler 集合
             for (HandlerMapping  handler : handlerList) {
                Pattern pattern = handler.getPattern();
                // url 正则比对
                Matcher matcher = pattern.matcher(url);
                if(!matcher.matches()){continue;}
                return handler;
             }
             return null;
        }
    
        // 2.  初始化阶段
        @Override
        public void init(ServletConfig config) throws ServletException {
             //  1.  读取配置
             //  ServletConfig  该配置类在项目初始化时    会将web.xml中 init-param中 的相关属性全部加载出来
             doLoadConfig(config.getInitParameter("contextConfigLocation"));
             //  2.  包扫描相关类
             //  扫描包中类信息，  读取配置文件的包名称
             doLoadPackage(contextConfig.getProperty("scanPackage"));
             //  3.  创建相关类，并将Bean注入到IOC容器中
             doInstance();
             //  4.  DI 依赖注入
             doAutowired();
             //  5.  初始化 HandlerMapping   url-method 映射关系
             initHandlerMapping();
             System.out.println("Spring init success ");
        }
    
        // 初始化HandlerMapping  url-method 映射关系
        private void initHandlerMapping() {
            if(ioc.isEmpty()){return;}
            // k : beanName  v : Object
            ioc.forEach((k,v)->{
                Class<?> clazz = v.getClass();
                if(!clazz.isAnnotationPresent(LSController.class)){return;}
                String baseUrl = "";
                if(clazz.isAnnotationPresent(LSRequestMapping.class)){
                    LSRequestMapping annotation = clazz.getAnnotation(LSRequestMapping.class);
                    baseUrl = annotation.value();
                }
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if(!method.isAnnotationPresent(LSRequestMapping.class)){return;}
                    LSRequestMapping annotation = method.getAnnotation(LSRequestMapping.class);
                    // 正则校验
                    String regex = ("/" + baseUrl + "/" + annotation.value())
                            .replaceAll("/+","/");
                    Pattern pattern = Pattern.compile(regex);
                    handlerList.add(new HandlerMapping(pattern,v,method));
                }
            });
        }
    
        // DI属性注入
        private void doAutowired() {
            // 首先明确  什么样的类中的什么属性需要被注入
            // 1.  交由IOC管理的类   2.  被注解 Autowired 注解注释的属性
            if(ioc.isEmpty()){return;}
            // k : beanName  v : Object
            ioc.forEach((k,v)->{
                // 获取类的属性列表
                Field[] fields = v.getClass().getDeclaredFields();
                for (Field field : fields) {
                    if(!field.isAnnotationPresent(LSAutowired.class)){continue;}
                    LSAutowired annotation = field.getAnnotation(LSAutowired.class);
                    String beanName = annotation.value();
                    if("".equals(beanName)){
                        beanName = field.getType().getName();
                    }
                    // 考虑到私有属性  暴力破解
                    field.setAccessible(true);
                    try {
                        // 当前类属性进行赋值
                        field.set(v,ioc.get(beanName));
                    } catch (IllegalAccessException e) {
                        System.out.println("bean : { " + beanName + " }  filed : { " + field.getName() + " } init failed");
                    }
                }
            });
        }
    
        // 创建扫描的相关类
        private void doInstance() {
            if(classNames.isEmpty()){return;}
            classNames.forEach(className->{
                try {
                    Class<?> clazz = Class.forName(className);
                    // 需要被初始化的类  :  被Spring注解修饰的类 @Controller  @Service 。。。。
                    if(clazz.isAnnotationPresent(LSController.class)){
                        Object instance = clazz.newInstance();
                        // 首字母小写
                        String beanName = toLowerFirstCase(clazz.getSimpleName());
                        ioc.put(beanName,instance);
                    }else if(clazz.isAnnotationPresent(LSService.class)){
                        // 判断当前Bean是否有自定义名称
                        LSService annotation = clazz.getAnnotation(LSService.class);
                        String beanName = annotation.value();
                        if("".equals(beanName.trim())){
                            beanName =  toLowerFirstCase(clazz.getSimpleName());
                        }
                        Object instance = clazz.newInstance();
                        ioc.put(beanName,instance);
                        // 判断当前类 是否包含 实现接口 如果包含 直接全部赋值  (存在BUG 暂时不考虑接口多次实现情况)
                        Class<?>[] interfaces = clazz.getInterfaces();
                        for (Class<?> inface :interfaces){
                            String interfaceName = inface.getName();
                            if(ioc.containsKey(interfaceName)){
                                // 证明Bean名称冲突  已经存在同名Bean
                                throw new RuntimeException("The " + interfaceName+ " is Exists");
                            }
                            ioc.put(interfaceName,instance);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    
        private String toLowerFirstCase(String simpleName) {
            char [] chars = simpleName.toCharArray();
            chars[0] += 32;
            return String.valueOf(chars);
        }
    
        // 读取 web.xml 中的全部配置
        private void doLoadConfig(String contextConfigLocation) {
            //  contextConfigLocation 对应的是 application的文件名称
            //  所以拿取当前类加载器 根据文件名称拿取文件流
            //  成功获取到文件流 将其转换为 properties文件  方便之后使用
            InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
            try {
                contextConfig.load(resourceAsStream);
            } catch (IOException e) {
                System.out.println("config load failed");
            }
        }
    
        // 包扫描类信息
        private void doLoadPackage(String scanPackage) {
            //  首先将包路径 转化为文件路径
            URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
            //  拿取到文件路径  进行递归扫描 拿取类信息
            if(null == url){return;}
            File[] files = new File(url.getFile()).listFiles();
            for (File file : files) {
                 // 判断当前层是文件夹还是文件
                 if(file.isDirectory()){
                   doLoadPackage(scanPackage + "." + file.getName());
                 }else{
                     if(!file.getName().endsWith(".class")){ continue;}
                     String className = (scanPackage + "." + file.getName().replace(".class",""));
                     System.out.println("init className : { " + className +" }");
                     classNames.add(className);
                 }
            }
        }
    
    
    
    }

##  三、编写测试类运行 ##

@LSController
    @LSRequestMapping("/demo")
    public class DemoAction {
    
      	@LSAutowired
    	private IDemoService demoService;
    
    
    	@LSRequestMapping("/query.*")
    	public void query(HttpServletRequest req, HttpServletResponse resp,
    					  @LSRequestParam("name") String name){
    //		String result = demoService.get(name);
    		String result = "My name is " + name;
    		try {
    			resp.getWriter().write(result);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	@LSRequestMapping("/add")
    	public void add(HttpServletRequest req, HttpServletResponse resp,
    					@LSRequestParam("a") Integer a, @LSRequestParam("b") Integer b){
    		try {
    			resp.getWriter().write(a + "+" + b + "=" + (a + b));
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	@LSRequestMapping("/sub")
    	public void add(HttpServletRequest req, HttpServletResponse resp,
    					@LSRequestParam("a") Double a, @LSRequestParam("b") Double b){
    		try {
    			resp.getWriter().write(a + "-" + b + "=" + (a - b));
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	@LSRequestMapping("/remove")
    	public String  remove(@LSRequestParam("id") Integer id){
    		return "" + id;
    	}
    
    }

*   需要完整Demo代码的可以留言！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzNDkwNDQ3NDA2_size_16_color_FFFFFF_t_70]: /images/20221123/791ceb3de5534d88a2a203302f20df39.png