手写200行代码实现精简版SpringMVC

最新推荐文章于 2022-03-30 17:36:55 发布
最新推荐文章于 2022-03-30 17:36:55 发布
阅读量230 收藏
点赞数
分类专栏： Spring+MyBatis 整理式学习 文章标签： springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013969018/article/details/96105107
版权

文章目录

1. Spring IOC、DI、MVC 的原理图

在这里插入图片描述

2. 开始构建自己的SpringMVC

项目目录
在这里插入图片描述

2.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_4_0.xsd"
      version="4.0">
 <servlet>
     <servlet-name>myspring</servlet-name>
     <servlet-class>com.gz.myspring.MyDispatchServlet</servlet-class>
     <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:application.properties</param-value>
     </init-param>
     <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
     <servlet-name>myspring</servlet-name>
     <url-pattern>/*</url-pattern>
 </servlet-mapping>
</web-app>

application.properties 文件

scanPackge=com.gz

2.2 先用后写

HelloController.java 文件

package com.gz.controller;
import com.gz.myspring.annotation.MyAutowried;
import com.gz.myspring.annotation.MyController;
import com.gz.myspring.annotation.MyRequestMapping;
import com.gz.myspring.annotation.MyRequestParam;
import com.gz.service.HelloService;
/**
* @Author guozhi
* @Date 2019/7/14 16:36
* @Description TODO
*/

@MyController
@MyRequestMapping("/myspring")
public class HelloController {

 @MyAutowried
 private HelloService helloService;

 @MyRequestMapping("/")
 public String hello(){
     return helloService.Hello("mySpring");
 }

 @MyRequestMapping("/hello")
 public String hello2(@MyRequestParam("name")String name, @MyRequestParam("age") String age){
     return helloService.Hello(name + " your age is " + age);
 }
}

HelloService.java 文件

package com.gz.service;

/**
* @Author guozhi
* @Date 2019/7/14 16:27
* @Description TODO
*/
public interface HelloService {
 String Hello(String name);
}

HelloServiceImpl.java 文件

package com.gz.service.impl;
import com.gz.myspring.annotation.MyService;
import com.gz.service.HelloService;
/**
* @Author guozhi
* @Date 2019/7/14 16:27
* @Description TODO
*/

@MyService
public class HelloServiceImpl implements HelloService {
   public String Hello(String name) {
       return "hello "+name;
   }
}

2.3 注解

MyAutowried.java 文件

package com.gz.myspring.annotation;
import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAutowried {
 String value() default  "";
}

MyController.java 文件

package com.gz.myspring.annotation;
import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAutowried {
    String value() default  "";
}

MyRequestMapping.java 文件

package com.gz.myspring.annotation;
import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAutowried {
    String value() default  "";
}

MyRequestParam.java 文件

package com.gz.myspring.annotation;
import java.lang.annotation.*;

@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyRequestParam {
    String value() default "";
}

MyService.java 文件

package com.gz.myspring.annotation;
import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyService {
    String value() default "";
}

2.4 DispatchServlet的init() 初始化

    // 上下文的配置文件
    private  Properties properties = new Properties();
    // 扫描指定包下的类名
    private  List<String> classNames = new ArrayList<String>();
    // ioc 容器
    private  Map<String, Object> ioc = new HashMap<String, Object>();
    // handleMapping url映射
    private Map<String, Method> handleMapping = new HashMap<String, Method>();

 @Override
 public void init(ServletConfig config) throws ServletException {
     // 1. 加载配置文件
     doLoadProperties(config);
     // 2. 扫描相关的类
     doScanClass(properties.getProperty("scanPackge"));
     // 3.初始化相关的类，并放入ioc容器
     doInstance();
     // 4. DI 操作
     doAutoried();
     // 5 handleMapping 的初始化
     initHandleMapping();
     System.out.println("mySpring started !");
 }
 /**
  * 初始化handleMapping 映射
  */
 private void initHandleMapping() {
     if (ioc.isEmpty()) return;
     for (Map.Entry entry : ioc.entrySet()){
         Class clazz = entry.getValue().getClass();
         if (!clazz.isAnnotationPresent(MyController.class)) continue;
         StringBuilder baseUrl = new StringBuilder("/");
         if (clazz.isAnnotationPresent(MyRequestMapping.class)){
             MyRequestMapping myRequestMapping = (MyRequestMapping) clazz.getAnnotation(MyRequestMapping.class);
             baseUrl.append(myRequestMapping.value());
         }
         Method [] methods = entry.getValue().getClass().getMethods();
         for (Method method : methods){
             if (!method.isAnnotationPresent(MyRequestMapping.class))
                 continue;
             MyRequestMapping myRequestMapping = method.getAnnotation(MyRequestMapping.class);
             StringBuilder stringBuilder = new StringBuilder(baseUrl);
             stringBuilder.append("/");
             stringBuilder.append(myRequestMapping.value());
             handleMapping.put(stringBuilder.toString().replaceAll("/+", "/"), method);
         }
     }
 }

 /**
  * 进行Di操作
  * 对 被@Autowried注解了的变量 进行初始化
  */
 private void doAutoried() {
     if (ioc.isEmpty()){
         return;
     }
     for (Map.Entry<String, Object> entry: ioc.entrySet()){
         Field[] fields = entry.getValue().getClass().getDeclaredFields();
         System.out.println(fields.length);
         for (Field field : fields){
             // 过滤没有被 @Autowried 注解的变量
             if (!field.isAnnotationPresent(MyAutowried.class)) continue;
             String beanName = field.getAnnotation(MyAutowried.class).value();
             if ("".equals(beanName)){
                 beanName = toLowerFirst(field.getType().getSimpleName());
             }
             field.setAccessible(true); // 强制授权
             try {
                 field.set(entry.getValue(), ioc.get(beanName));
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
             }
         }
     }

 }

 /**
  * 对扫描到的类分析，如果有 MyController 或者 MyService 注解则进行实例化，并放入ioc容器中
  */
 private void doInstance(){
     if (classNames.isEmpty()) {
         return;
     }
     for (String name: classNames){
         try{
             Class clazz = Class.forName(name);
             Object instance = clazz.newInstance();
             if (clazz.isAnnotationPresent(MyController.class)){
                 // 将类名的首字母小写后，作为key， 其实例作为value，放入ioc容器中
                 ioc.put(toLowerFirst(clazz.getSimpleName()), instance);
             }else if (clazz.isAnnotationPresent(MyService.class)){
                 /*
                  * 首先判断 注解的value 值是否为空
                  * 如果不为空，则将其作为类名，实例化后加入到ioc容器中
                  * 如果为空: 1 获取这个类实现的所有接口，将接口名称首字母小写后，作为类名，加入到ioc容器中
                  *          2 将这个类的首字母小写后，作为类名key 加入到ioc容器中
                  * */
                 MyService myService = (MyService) clazz.getAnnotation(MyService.class);
                 String beanName = myService.value();
                 if ("".equals(beanName.trim())){
                     for (Class<?> i : clazz.getInterfaces()){
                         String iname = toLowerFirst(i.getSimpleName());
                         if (ioc.containsKey(iname)){
                             throw new Exception(String.format("beanName: %s is exists!", iname));
                         }
                         ioc.put(iname, instance);
                     }
                     beanName = toLowerFirst(clazz.getSimpleName());
                 }
                 ioc.put(beanName, instance);
             }
         }catch (Exception e){
             e.printStackTrace();
         }
     }

 }

 /**
  * 首字母小写
  * @param string
  * @return
  */
 private String toLowerFirst(String string){
     char [] chars = string.toCharArray();
     chars[0] += 32;
     return new String(chars);
 }

 /**
  * 扫描包路径下的所有 .class 文件
  * @param packagePath 包路径
  */
 private void doScanClass(String packagePath) {
     URL url = this.getClass().getClassLoader().getResource("/" + packagePath.replaceAll("\\.", "/"));
     for (File file : new File(url.getFile()).listFiles()){
         if (file.isDirectory()){
             this.doScanClass(packagePath + "." + file.getName());
         }else if (file.getName().contains(".class")){
             classNames.add((packagePath + "." + file.getName().replaceAll(".class", "")).trim());
         }
     }
 }

 /**
  * 加载配置文件
  * @param config 配置文件
  */
 private void doLoadProperties(ServletConfig config) {
     String contextConfigLocation = config.getInitParameter("contextConfigLocation").replace("classpath:", "");
     //从项目下取得配置文件的输入流
     InputStream in = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
     try {
         properties.load(in);
     } catch (IOException e) {
         e.printStackTrace();
     }finally {
         if (in != null)
             try {
                 in.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
     }
 }

2.5 doPost（）进行映射处理

   @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     doPost(req, resp);
 }
 @Override
 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     doDispatch(req, resp);
 }
 
 /**
  * 将请求映射到指定的方法
  * @param req
  * @param resp
  * @throws IOException
  */
 private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws IOException {
     if (handleMapping.isEmpty())
         return;
     String contextPath = req.getContextPath();
     String url = req.getRequestURI().replace(contextPath, "").replaceAll("/+", "/");
     if (!handleMapping.containsKey(url)){
         resp.getWriter().write("404 not found url " + url);
         return;
     }
     Method method = handleMapping.get(url);
     Parameter[] me_parameter = method.getParameters();
     List param_objs = new ArrayList();
     for (Parameter p : me_parameter){
         if (p.isAnnotationPresent((MyRequestParam.class))){
             param_objs.add(req.getParameterMap().get(p.getAnnotation(MyRequestParam.class).value())[0]);
         }
     }
     String beanName = toLowerFirst(method.getDeclaringClass().getSimpleName());
     try {
         resp.getWriter().write((String) method.invoke(ioc.get(beanName), param_objs.toArray()));
     } catch (IllegalAccessException | InvocationTargetException e) {
         e.printStackTrace();
     }
 }

2.6 完整的 MyDispatchServlet 代码

package com.gz.myspring;
import com.gz.myspring.annotation.*;
import javax.servlet.ServletConfig;
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.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.net.URL;
import java.util.*;
/**
 * @Author guozhi
 * @Date 2019/7/14 16:19
 * @Description TODO
 */
public class MyDispatchServlet extends HttpServlet {
    // 上下文的配置文件
    private  Properties properties = new Properties();
    // 扫描指定包下的类名
    private  List<String> classNames = new ArrayList<String>();
    // ioc 容器
    private  Map<String, Object> ioc = new HashMap<String, Object>();
    // handleMapping url映射
    private Map<String, Method> handleMapping = new HashMap<String, Method>();
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doDispatch(req, resp);
    }

    /**
     * 将请求映射到指定的方法
     * @param req
     * @param resp
     * @throws IOException
     */
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        if (handleMapping.isEmpty())
            return;
        String contextPath = req.getContextPath();
        String url = req.getRequestURI().replace(contextPath, "").replaceAll("/+", "/");
        if (!handleMapping.containsKey(url)){
            resp.getWriter().write("404 not found url " + url);
            return;
        }
        Method method = handleMapping.get(url);
        Parameter[] me_parameter = method.getParameters();
        List param_objs = new ArrayList();
        for (Parameter p : me_parameter){
            if (p.isAnnotationPresent((MyRequestParam.class))){
                param_objs.add(req.getParameterMap().get(p.getAnnotation(MyRequestParam.class).value())[0]);
            }
        }
        String beanName = toLowerFirst(method.getDeclaringClass().getSimpleName());
        try {
            resp.getWriter().write((String) method.invoke(ioc.get(beanName), param_objs.toArray()));
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void init(ServletConfig config) throws ServletException {
        // 1. 加载配置文件
        doLoadProperties(config);
        // 2. 扫描相关的类
        doScanClass(properties.getProperty("scanPackge"));
        // 3.初始化相关的类，并放入ioc容器
        doInstance();
        // 4. DI 操作
        doAutoried();
        // 5 handleMapping 的初始化
        initHandleMapping();
        System.out.println("mySpring started !");
    }
    /**
     * 初始化handleMapping 映射
     */
    private void initHandleMapping() {
        if (ioc.isEmpty()) return;
        for (Map.Entry entry : ioc.entrySet()){
            Class clazz = entry.getValue().getClass();
            if (!clazz.isAnnotationPresent(MyController.class)) continue;
            StringBuilder baseUrl = new StringBuilder("/");
            if (clazz.isAnnotationPresent(MyRequestMapping.class)){
                MyRequestMapping myRequestMapping = (MyRequestMapping) clazz.getAnnotation(MyRequestMapping.class);
                baseUrl.append(myRequestMapping.value());
            }
            Method [] methods = entry.getValue().getClass().getMethods();
            for (Method method : methods){
                if (!method.isAnnotationPresent(MyRequestMapping.class))
                    continue;
                MyRequestMapping myRequestMapping = method.getAnnotation(MyRequestMapping.class);
                StringBuilder stringBuilder = new StringBuilder(baseUrl);
                stringBuilder.append("/");
                stringBuilder.append(myRequestMapping.value());
                handleMapping.put(stringBuilder.toString().replaceAll("/+", "/"), method);
            }
        }
    }

    /**
     * 进行Di操作
     * 对 被@Autowried注解了的变量 进行初始化
     */
    private void doAutoried() {
        if (ioc.isEmpty()){
            return;
        }
        for (Map.Entry<String, Object> entry: ioc.entrySet()){
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
            System.out.println(fields.length);
            for (Field field : fields){
                // 过滤没有被 @Autowried 注解的变量
                if (!field.isAnnotationPresent(MyAutowried.class)) continue;
                String beanName = field.getAnnotation(MyAutowried.class).value();
                if ("".equals(beanName)){
                    beanName = toLowerFirst(field.getType().getSimpleName());
                }
                field.setAccessible(true); // 强制授权
                try {
                    field.set(entry.getValue(), ioc.get(beanName));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * 对扫描到的类分析，如果有 MyController 或者 MyService 注解则进行实例化，并放入ioc容器中
     */
    private void doInstance(){
        if (classNames.isEmpty()) {
            return;
        }
        for (String name: classNames){
            try{
                Class clazz = Class.forName(name);
                Object instance = clazz.newInstance();
                if (clazz.isAnnotationPresent(MyController.class)){
                    // 将类名的首字母小写后，作为key， 其实例作为value，放入ioc容器中
                    ioc.put(toLowerFirst(clazz.getSimpleName()), instance);
                }else if (clazz.isAnnotationPresent(MyService.class)){
                    /*
                     * 首先判断 注解的value 值是否为空
                     * 如果不为空，则将其作为类名，实例化后加入到ioc容器中
                     * 如果为空: 1 获取这个类实现的所有接口，将接口名称首字母小写后，作为类名，加入到ioc容器中
                     *          2 将这个类的首字母小写后，作为类名key 加入到ioc容器中
                     * */
                    MyService myService = (MyService) clazz.getAnnotation(MyService.class);
                    String beanName = myService.value();
                    if ("".equals(beanName.trim())){
                        for (Class<?> i : clazz.getInterfaces()){
                            String iname = toLowerFirst(i.getSimpleName());
                            if (ioc.containsKey(iname)){
                                throw new Exception(String.format("beanName: %s is exists!", iname));
                            }
                            ioc.put(iname, instance);
                        }
                        beanName = toLowerFirst(clazz.getSimpleName());
                    }
                    ioc.put(beanName, instance);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

    /**
     * 首字母小写
     * @param string
     * @return
     */
    private String toLowerFirst(String string){
        char [] chars = string.toCharArray();
        chars[0] += 32;
        return new String(chars);
    }

    /**
     * 扫描包路径下的所有 .class 文件
     * @param packagePath 包路径
     */
    private void doScanClass(String packagePath) {
        URL url = this.getClass().getClassLoader().getResource("/" + packagePath.replaceAll("\\.", "/"));
        for (File file : new File(url.getFile()).listFiles()){
            if (file.isDirectory()){
                this.doScanClass(packagePath + "." + file.getName());
            }else if (file.getName().contains(".class")){
                classNames.add((packagePath + "." + file.getName().replaceAll(".class", "")).trim());
            }
        }
    }

    /**
     * 加载配置文件
     * @param config 配置文件
     */
    private void doLoadProperties(ServletConfig config) {
        String contextConfigLocation = config.getInitParameter("contextConfigLocation").replace("classpath:", "");
        //从项目下取得配置文件的输入流
        InputStream in = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
        try {
            properties.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (in != null)
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

3. 运行效果

在这里插入图片描述
在这里插入图片描述

4. 遗留问题

  1. 在对请求的URL进行method映射时，只能将参数作为String类型处理，即 @MyRequestParam 注解的形参只能是String类型，这个问题是出在 method.invoke(ioc.get(beanName), objects) 中，其中objects是需要给方法传入的参数，是 Object[ ] 类型，预想的解决在从request中获取请求参数时，判断参数类型并进行强制转型，然后再放入 Objects[ ] 中
  2. 目前这个项目只对 doGet（） 与doPost（） 方法进行了处理，其他 put、delete等， 需要额外加代码，预想的解决办法就是像 doGet（）中写的那样， 直接调用doPost()
@gzhi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2662
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
2022版史上最牛Java学习路线图（视频教程+配套资料）
程序员日常
07-29 1711
0基础如何学习java？Java要学习哪些是核心内容？自学Java到什么程度可找工作？正在迷茫的你不必在东瞅西逛，自学Java看这一篇就够了！​PS。
spring_精简教程
07-30
spring_精简教程，入门级的spring教程
spring笔记（精简版）
bintoYu的博客
03-17 449
Spring的核心是控制反转（IoC）和面向切面（AOP） IoC 所谓的IoC：Spring是个大容器，存放着各种各样的bean，以往这些bean是你自己主动去new出来的。有了spring后，所有的bean是通过spring容器来进行生成，因此控制权就由你自己反转到了容器上。 IoC的使用方式： ① 将所有的bean都配置xml中：&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;am
mini-springframework-简化版Spring实现设计
weixin_34072857的博客
12-16 239
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Ioc 精简版
Piemon&Anokata的博客
10-25 258
抽象 容器的核心抽象类： BeanFactory：Spring Ioc的核心，即是BeanFactory，它即是我们常说的Spring容器，它负责Bean实例的创建于管理 ApplicationContext：它是BeanFactory子接口，但是添加了更多的企业级功能 功能类： Environment：容器的环境，默认的实现是StandardEnvironment，Environment中...
Spring Aop 精简版
Piemon&Anokata的博客
10-27 224
1.切面术语 Aspect【切面】：横切多个类的关注点的模块化。事务管理是企业Java应用程序中横切关注点的一个很好的例子。在Spring AOP中，切面是通过使用标准类(基于schema的风格)或使用@Aspect注解标注的标准类(@AspectJ风格)来实现的。 Join point【连接点】：Spring并没有抽象自己的连接点，而是复用AspectJ第三方包的JointPoint。切面规范...
spring+mybatis企业应用实战官方源码下载
06-01
spring+mybatis企业应用实战官方源码下载，含光盘所有内容，除了官方的02-14讲义的源码外，13张的sql我也手写了，且综合资源压缩资源359M，资源未做任何精简，myeclispe和eclipse能直接引用运行。
人类高质量 Java 学习路线【一条龙版】
Feng_clay的博客
12-04 1525
大家好，我是张讨嫌。现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 我还在文档中整理了链接，也不用自己搜了，还有思维导图。 大纲 实在太长了，没办法全部展开，
java架构师进阶之路
henhenha的博客
03-30 3373
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
精简源码-spring-mvc 入门级使用，亲测好用
01-02
适合入门级开发人员学习借鉴，绝对精简，本人亲自通过哦ide调试通过，望大家共同进步。
原创spring aop精简版
疯狂程序员
08-26 888
//javabean 必须要有一个不带参数的构造器 config.properties #xxx=java.util.ArrayList xxx=cn.itcast.day3.aopframework.ProxyFactoryBean xxx.advice
Spring框架精简总结
Philanderers的博客
12-26 351
一、Spring是什么？ 1.1轻量级：并不是说Spring的jar包有多大，而是说Spring是非侵入性的（即当使用Spring时，不需要去实现Spring给提供的任何接口，不需要去继承它的任何父类，可以享用它的功能）基于Spring开发的应用中的对象可以不依赖于Spring的API 1.2依赖注入（DI、IOC） 1.3面向切面编程（AOP） 1.4容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期 1.5框架：Spring实现了使用简单的组件配置组合成一个复杂的应用。在Sp
手写SpringIOC的XML实现方式
汉南最後の読書人
02-13 316
1.XML文件(Spring.xml) &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:cont...
spring boot项目精简瘦身打包
Chen_RuiMin的博客
08-23 2935
1、背景介绍 当网络不是很给力的时候，一个大的jar包传输是费时的，往往存在修改1分钟，传包10分钟的尴尬时刻。 1）正常打包出来的jar 2)解压出来后的包大小98M 3)lib的jar包大小 综上我们能看出来，一个普通项目，打包出来有进90M，里面的项目依赖就85.7M，这就触发了瘦身打包的念头 2、开始减肥行动 在启动类所在的pom文件中，添加以下的插件，即可打包出一个无依赖的jar包 1) pom配置图 2）pom 配置代码 <plugins> &
SpringBoot精简一(配置)
satoshiCC的博客
11-20 503
1.简化Spring应用开发的一个框架 2.整个Spring技术栈的一个整合 3.JavaEE一站式解决方案 优点： 微服务简介： 一个应用应该是一组小型服务；可以通过HTTP的方式进行互通 每一个功能元素最终都是一个可独立替换和独立升级的软件单元 ...
手写SpringMVC (一) 简要版,去除冗余复杂代码,手写Spring核心功能
卡式优雅的博客
03-07 1673
github 地址 :https://github.com/yjy91913/jerry-mvcframework 只是闲来无事写的简化版，仅供大家理解SpringMvc的运作原理） 了解了springMVC的源码,写一个功能简单可以实现的springMVC,只是为了深入了解spring 先看一下项目结构 demo是测试类 第一步:pom文件 加入依赖 -servlet &...
蒋金楠：200行代码7个对象《ASP.NET Core框架揭密》苏州.NET俱乐部课程分享
dotNET跨平台
01-29 2212
【课程名称】《ASP.NET Core框架揭密》【老师介绍】蒋金楠，同程艺龙机票事业部技术专家，微软最有价值专家（MVP，连续12），多本.NET专著作者。博客园Arte...
手写SpringMVC底层原理实现
萌新比克o的博客
03-11 1271
手写SpringMVC首先理清思路，具体要做什么 我分为以下几个步骤 1.扫描包下带有@Controller @Service注解的类 2.实例化:将扫描的类通过反射实例化并保存到ioc容器中 3.依赖注入:将存在依赖的bean进行注入:列如被@Autowired修饰的属性进行注入 4.urlMapping:http请求路径与方法建立映射关系 理清思路我们就开始快乐之旅吧~~~~~~ ...
springmvc定时任务代码实现
最新发布
04-08
好的，关于springmvc定时任务代码实现，可以使用Spring内置的@Scheduled注解来实现定时任务。具体实现方式可以参考以下代码示例： ``` import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component public class MyScheduledTask { @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1点执行 public void doTask() { // 在此处编写定时任务的逻辑代码 } } ``` 以上代码中，我们定义了一个名为MyScheduledTask的定时任务类，并使用@Scheduled注解来指定定时任务的执行时间。在本例中，我们设置定时任务在每天凌晨1点执行，即cron表达式为“0 0 1 * * ?”。 当定时任务触发时，程序将自动调用doTask()方法中编写的逻辑代码，从而实现定时任务的功能。 希望以上回答能够帮助您解决问题，如果还有其它问题，请随时提出。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值