17.用300行代码手写初体验Spring V1.0版本

2024-06-24 13:48
文章标签 java 代码 300 spring 版本 17 v1.0 手写 初体验

本文主要是介绍17.用300行代码手写初体验Spring V1.0版本，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.1.课程目标

1、了解看源码最有效的方式，先猜测后验证，不要一开始就去调试代码。

2、浓缩就是精华，用 300行最简洁的代码

提炼Spring的基本设计思想。

3、掌握Spring框架的基本脉络。

1.2.内容定位

1、 具有1年以上的SpringMVC使用经验。

2、 希望深入了解Spring源码的人群，对 Spring有一个整体的宏观感受。

3、 全程手写实现SpringMVC的核心功能，从最简单的V1版本一步一步优化为V2版本，最后到V3版本。

1.3.实现思路

先来介绍一下Mini版本的Spring基本实现思路,如下图所示:

image-20200331202948382

1.4.自定义配置 application.properties 文件

为了解析方便,我们用application.properties来代替application.xml文 件 ，具体配置内容如下:

scanPackage=com.gupaoedu.demo

1.5.配置web.xml文件

大家都知道,所有依赖于web容器的项目,都是从读取web.xml文件开始的。我们先配置好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/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.gupaoedu.mvcframework.v2.servlet.GPDispatchServlet</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>

其中GPDispatcherServlet是有自己模拟Spring实现的核心功能类。

1.6.自定义 Annotation

@GPService 注解:

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

@GPAutowired 注 解 ：

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

@GPController 注 解 ：

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

@GPRequestMapping 注 解 ：

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

@GPRequestParam 注 解 ：

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

1.7.配置 Annotation

配置业务实现类DemoService :

/*** 核心业务逻辑*/
@GPService
public class DemoService implements IDemoService{public String get(String name) {return "My name is " + name + ",from service.";}}

配置请求入口类DemoAction :

//虽然，用法一样，但是没有功能
@GPController
@GPRequestMapping("/demo")
public class DemoAction {@GPAutowired private IDemoService demoService;@GPRequestMapping("/query")public void query(HttpServletRequest req, HttpServletResponse resp,@GPRequestParam("name") String name){String result = demoService.get(name);// String result = "My name is " + name;try {resp.getWriter().write(result);} catch (IOException e) {e.printStackTrace();}}@GPRequestMapping("/add")public void add(HttpServletRequest req, HttpServletResponse resp,@GPRequestParam("a") Integer a, @GPRequestParam("b") Integer b){try {resp.getWriter().write(a + "+" + b + "=" + (a + b));} catch (IOException e) {e.printStackTrace();}}@GPRequestMapping("/sub")public void add(HttpServletRequest req, HttpServletResponse resp,@GPRequestParam("a") Double a, @GPRequestParam("b") Double b){try {resp.getWriter().write(a + "-" + b + "=" + (a - b));} catch (IOException e) {e.printStackTrace();}}@GPRequestMapping("/remove")public String  remove(@GPRequestParam("id") Integer id){return "" + id;}}

至 此 ，配置阶段就已经完成。

1.8.容器初始化实现V1版本

所有的核心逻辑全部写在一个init()方法中。

public class GPDispatcherServlet extends HttpServlet {private Map<String,Object> mapping = new HashMap<String, Object>();@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {this.doPost(req,resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {try {doDispatch(req,resp);} catch (Exception e) {resp.getWriter().write("500 Exception " + Arrays.toString(e.getStackTrace()));}}private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {String url = req.getRequestURI();String contextPath = req.getContextPath();url = url.replace(contextPath, "").replaceAll("/+", "/");if(!this.mapping.containsKey(url)){resp.getWriter().write("404 Not Found!!");return;}Method method = (Method) this.mapping.get(url);Map<String,String[]> params = req.getParameterMap();method.invoke(this.mapping.get(method.getDeclaringClass().getName()),new Object[]{req,resp,params.get("name")[0]});}//init方法肯定干得的初始化的工作//inti首先我得初始化所有的相关的类，IOC容器、servletBean@Overridepublic void init(ServletConfig config) throws ServletException {InputStream is = null;try{Properties configContext = new Properties();is = this.getClass().getClassLoader().getResourceAsStream(config.getInitParameter("contextConfigLocation"));configContext.load(is);String scanPackage = configContext.getProperty("scanPackage");doScanner(scanPackage);for (String className : mapping.keySet()) {if(!className.contains(".")){continue;}Class<?> clazz = Class.forName(className);if(clazz.isAnnotationPresent(GPController.class)){mapping.put(className,clazz.newInstance());String baseUrl = "";if (clazz.isAnnotationPresent(GPRequestMapping.class)) {GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);baseUrl = requestMapping.value();}Method[] methods = clazz.getMethods();for (Method method : methods) {if (!method.isAnnotationPresent(GPRequestMapping.class)) {  continue; }GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);String url = (baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");mapping.put(url, method);System.out.println("Mapped " + url + "," + method);}}else if(clazz.isAnnotationPresent(GPService.class)){GPService service = clazz.getAnnotation(GPService.class);String beanName = service.value();if("".equals(beanName)){beanName = clazz.getName();}Object instance = clazz.newInstance();mapping.put(beanName,instance);for (Class<?> i : clazz.getInterfaces()) {mapping.put(i.getName(),instance);}}else {continue;}}for (Object object : mapping.values()) {if(object == null){continue;}Class clazz = object.getClass();if(clazz.isAnnotationPresent(GPController.class)){Field [] fields = clazz.getDeclaredFields();for (Field field : fields) {if(!field.isAnnotationPresent(GPAutowired.class)){continue; }GPAutowired autowired = field.getAnnotation(GPAutowired.class);String beanName = autowired.value();if("".equals(beanName)){beanName = field.getType().getName();}field.setAccessible(true);try {field.set(mapping.get(clazz.getName()),mapping.get(beanName));} catch (IllegalAccessException e) {e.printStackTrace();}}}}} catch (Exception e) {}finally {if(is != null){try {is.close();} catch (IOException e) {e.printStackTrace();}}}System.out.print("GP MVC Framework is init");}private void doScanner(String scanPackage) {URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.","/"));File classDir = new File(url.getFile());for (File file : classDir.listFiles()) {if(file.isDirectory()){ doScanner(scanPackage + "." +  file.getName());}else {if(!file.getName().endsWith(".class")){continue;}String clazzName = (scanPackage + "." + file.getName().replace(".class",""));mapping.put(clazzName,null);}}}
}

1.9.实现V2版本

在 V1版本上进了优化，采用了常用的设计模式（工厂模式、单例模式、委派模式、策略模式），将 inito方法中的代 码进行封装。按照之前的实现思路，先搭基础框架,再填肉注血,具体代码如下:

//初始化阶段
@Override
public void init(ServletConfig config) throws ServletException {//1、加载配置文件doLoadConfig(config.getInitParameter("contextConfigLocation"));//2、扫描相关的类doScanner(contextConfig.getProperty("scanPackage"));//3、初始化扫描到的类，并且将它们放入到ICO容器之中doInstance();//4、完成依赖注入doAutowired();//5、初始化HandlerMappinginitHandlerMapping();System.out.println("GP Spring framework is init.");
}

声明全局的成员变量，其中IOC容器就是注册时单例的具体案例：

//保存application.properties配置文件中的内容
private Properties contextConfig = new Properties();//保存扫描的所有的类名
private List<String> classNames = new ArrayList<String>();//传说中的IOC容器，我们来揭开它的神秘面纱
//为了简化程序，暂时不考虑ConcurrentHashMap
// 主要还是关注设计思想和原理
private Map<String,Object> ioc = new HashMap<String,Object>();//保存url和Method的对应关系
private Map<String,Method> handlerMapping = new HashMap<String,Method>();

实现 doLoadConfig方法:

//加载配置文件
private void doLoadConfig(String contextConfigLocation) {//直接从类路径下找到Spring主配置文件所在的路径//并且将其读取出来放到Properties对象中//相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);try {contextConfig.load(fis);} catch (IOException e) {e.printStackTrace();}finally {if(null != fis){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}
}

实现doScanner()方 法 ：

//扫描出相关的类
private void doScanner(String scanPackage) {//scanPackage = com.gupaoedu.demo ，存储的是包路径//转换为文件路径，实际上就是把.替换为/就OK了//classpathURL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.","/"));File classPath = new File(url.getFile());for (File file : classPath.listFiles()) {if(file.isDirectory()){doScanner(scanPackage + "." + file.getName());}else{if(!file.getName().endsWith(".class")){ continue;}String className = (scanPackage + "." + file.getName().replace(".class",""));classNames.add(className);}}
}

实现dolnstance()方法，dolnstance。方法就是工厂模式的具体实现：

private void doInstance() {//初始化，为DI做准备if(classNames.isEmpty()){return;}try {for (String className : classNames) {Class<?> clazz = Class.forName(className);//什么样的类才需要初始化呢？//加了注解的类，才初始化，怎么判断？//为了简化代码逻辑，主要体会设计思想，只举例 @Controller和@Service,// @Componment...就一一举例了if(clazz.isAnnotationPresent(GPController.class)){Object instance = clazz.newInstance();//Spring默认类名首字母小写String beanName = toLowerFirstCase(clazz.getSimpleName());ioc.put(beanName,instance);}else if(clazz.isAnnotationPresent(GPService.class)){//1、自定义的beanNameGPService service = clazz.getAnnotation(GPService.class);String beanName = service.value();//2、默认类名首字母小写if("".equals(beanName.trim())){beanName = toLowerFirstCase(clazz.getSimpleName());}Object instance = clazz.newInstance();ioc.put(beanName,instance);//3、根据类型自动赋值,投机取巧的方式for (Class<?> i : clazz.getInterfaces()) {if(ioc.containsKey(i.getName())){throw new Exception("The “" + i.getName() + "” is exists!!");}//把接口的类型直接当成key了ioc.put(i.getName(),instance);}}else {continue;}}}catch (Exception e){e.printStackTrace();}}

为了处理方便,自己实现了 toLowerFirstCase方法,来实现类名首字母小写,具体代码如下：

//如果类名本身是小写字母，确实会出问题
//但是我要说明的是：这个方法是我自己用，private的
//传值也是自己传，类也都遵循了驼峰命名法
//默认传入的值，存在首字母小写的情况，也不可能出现非字母的情况//为了简化程序逻辑，就不做其他判断了，大家了解就OK
//其实用写注释的时间都能够把逻辑写完了
private String toLowerFirstCase(String simpleName) {char [] chars = simpleName.toCharArray();//之所以加，是因为大小写字母的ASCII码相差32，// 而且大写字母的ASCII码要小于小写字母的ASCII码//在Java中，对char做算学运算，实际上就是对ASCII码做算学运算chars[0] += 32;return String.valueOf(chars);
}

实现 doAutowired方法：

//自动依赖注入
private void doAutowired() {if(ioc.isEmpty()){return;}for (Map.Entry<String, Object> entry : ioc.entrySet()) {//Declared 所有的，特定的 字段，包括private/protected/default//正常来说，普通的OOP编程只能拿到public的属性Field[] fields = entry.getValue().getClass().getDeclaredFields();for (Field field : fields) {if(!field.isAnnotationPresent(GPAutowired.class)){continue;}GPAutowired autowired = field.getAnnotation(GPAutowired.class);//如果用户没有自定义beanName，默认就根据类型注入//这个地方省去了对类名首字母小写的情况的判断，这个作为课后作业//小伙伴们自己去完善String beanName = autowired.value().trim();if("".equals(beanName)){//获得接口的类型，作为key待会拿这个key到ioc容器中去取值beanName = field.getType().getName();}//如果是public以外的修饰符，只要加了@Autowired注解，都要强制赋值//反射中叫做暴力访问， 强吻field.setAccessible(true);try {//用反射机制，动态给字段赋值field.set(entry.getValue(),ioc.get(beanName));} catch (IllegalAccessException e) {e.printStackTrace();}}}
}

实现dolnitHandlerMapping方法，handlerMapping就是策略模式的应用案例：

//初始化url和Method的一对一对应关系
private void initHandlerMapping() {if(ioc.isEmpty()){ return; }for (Map.Entry<String, Object> entry : ioc.entrySet()) {Class<?> clazz = entry.getValue().getClass();if(!clazz.isAnnotationPresent(GPController.class)){continue;}//保存写在类上面的@GPRequestMapping("/demo")String baseUrl = "";if(clazz.isAnnotationPresent(GPRequestMapping.class)){GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);baseUrl = requestMapping.value();}//默认获取所有的public方法for (Method method : clazz.getMethods()) {if(!method.isAnnotationPresent(GPRequestMapping.class)){continue;}GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);//优化// //demo///queryString url = ("/" + baseUrl + "/" + requestMapping.value()).replaceAll("/+","/");handlerMapping.put(url,method);System.out.println("Mapped :" + url + "," + method);}}
}

到这里位置初始化阶段就已经完成，接下实现运行阶段的逻辑，来看doPost/doGet的代码:

@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 {//6、调用，运行阶段try {doDispatch(req,resp);} catch (Exception e) {e.printStackTrace();resp.getWriter().write("500 Exection,Detail : " + Arrays.toString(e.getStackTrace()));}}

doPost()方法中，用了委派模式，委派模式的具体逻辑在doDispatch方法中：

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {String url = req.getRequestURI();String contextPath = req.getContextPath();url = url.replace(contextPath, "").replaceAll("/+", "/");if(!this.mapping.containsKey(url)){resp.getWriter().write("404 Not Found!!");return;}Method method = (Method) this.mapping.get(url);Map<String,String[]> params = req.getParameterMap();method.invoke(this.mapping.get(method.getDeclaringClass().getName()),new Object[]{req,resp,params.get("name")[0]});
}

在以上代码中，doDispatch。虽然完成了动态委派并反射调用，但对url参数处理还是静态代码。
的动态获E
要实现url参数
,其实还稍微有些复杂。我们可以优化doDispatch方法的实现逻辑，代码如下:

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {//绝对路径String url = req.getRequestURI();//处理成相对路径String contextPath = req.getContextPath();url = url.replaceAll(contextPath,"").replaceAll("/+","/");if(!this.handlerMapping.containsKey(url)){resp.getWriter().write("404 Not Found!!!");return;}Method method = this.handlerMapping.get(url);//从reqest中拿到url传过来的参数Map<String,String[]> params = req.getParameterMap();//获取方法的形参列表Class<?> [] parameterTypes = method.getParameterTypes();Object [] paramValues = new Object[parameterTypes.length];for (int i = 0; i < parameterTypes.length; i ++) {Class parameterType = parameterTypes[i];//不能用instanceof，parameterType它不是实参，而是形参if(parameterType == HttpServletRequest.class){paramValues[i] = req;continue;}else if(parameterType == HttpServletResponse.class){paramValues[i] = resp;continue;}else if(parameterType == String.class){GPRequestParam requestParam = (GPRequestParam)parameterType.getAnnotation(GPRequestParam.class);if(params.containsKey(requestParam.value())) {for (Map.Entry<String,String[]> param : params.entrySet()){String value = Arrays.toString(param.getValue()).replaceAll("\\[|\\]","").replaceAll("\\s",",");paramValues[i] = value;}}}}//投机取巧的方式//通过反射拿到method所在class，拿到class之后还是拿到class的名称//再调用toLowerFirstCase获得beanNameString beanName  = toLowerFirstCase(method.getDeclaringClass().getSimpleName());method.invoke(ioc.get(beanName),paramValues);
}

1.10.实现V3版本

在 V2版本中，基本功能以及完全实现，但代码的优雅程度还不如人意。譬如HandlerMapping还不能像SpringMVC 一样支持正则,url参数还不支持强制类型转换,在反射调用前还需要重新获取beanName ,在V3版本中,下面我们
继续优化。

首先，改造HandlerMapping , 在真实的Spring源码中，HandlerMapping其实是一个List而非Mapo List中的元
素是一个自定义的类型。现在我们来仿真写一段代码，先定义一个内部类Handler类 :

//保存一个url和一个Method的关系
private class Handler {//必须把url放到HandlerMapping才好理解吧private Pattern pattern;  //正则private Method method;private Object controller;private Class<?> [] paramTypes;public Pattern getPattern() {return pattern;}public Method getMethod() {return method;}public Object getController() {return controller;}public Class<?>[] getParamTypes() {return paramTypes;}//形参列表//参数的名字作为key,参数的顺序，位置作为值private Map<String,Integer> paramIndexMapping;public Handler(Pattern pattern, Object controller, Method method) {this.pattern = pattern;this.method = method;this.controller = controller;paramTypes = method.getParameterTypes();paramIndexMapping = new HashMap<String, Integer>();putParamIndexMapping(method);}private void putParamIndexMapping(Method method){//提取方法中加了注解的参数//把方法上的注解拿到，得到的是一个二维数组//因为一个参数可以有多个注解，而一个方法又有多个参数Annotation [] [] pa = method.getParameterAnnotations();for (int i = 0; i < pa.length ; i ++) {for(Annotation a : pa[i]){if(a instanceof GPRequestParam){String paramName = ((GPRequestParam) a).value();if(!"".equals(paramName.trim())){paramIndexMapping.put(paramName, i);}}}}//提取方法中的request和response参数Class<?> [] paramsTypes = method.getParameterTypes();for (int i = 0; i < paramsTypes.length ; i ++) {Class<?> type = paramsTypes[i];if(type == HttpServletRequest.class ||type == HttpServletResponse.class){paramIndexMapping.put(type.getName(),i);}}}
}

然后，优化HandlerMapping的结构，代码如下：

//保存所有的URL和方法的映射关系
private List<Handler> handlerMapping = new ArrayList<Handler>();

修改 dolnitHandlerMapping方 法 ：

//初始化url和Method的一对一对应关系
private void initHandlerMapping() {if(ioc.isEmpty()){ return; }for (Map.Entry<String, Object> entry : ioc.entrySet()) {Class<?> clazz = entry.getValue().getClass();if(!clazz.isAnnotationPresent(GPController.class)){continue;}//保存写在类上面的@GPRequestMapping("/demo")String baseUrl = "";if(clazz.isAnnotationPresent(GPRequestMapping.class)){GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);baseUrl = requestMapping.value();}//默认获取所有的public方法for (Method method : clazz.getMethods()) {if(!method.isAnnotationPresent(GPRequestMapping.class)){continue;}GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);//优化// //demo///queryString regex = ("/" + baseUrl + "/" + requestMapping.value()).replaceAll("/+","/");Pattern pattern = Pattern.compile(regex);this.handlerMapping.add(new Handler(pattern,entry.getValue(),method));System.out.println("Mapped :" + pattern + "," + method);}}
}

修改 doDispatch()方法:

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {Handler handler = getHandler(req);if (handler == null) {resp.getWriter().write("404 Not Found!!!");return;}//获得方法的形参列表Class<?>[] paramTypes = handler.getParamTypes();Object[] paramValues = new Object[paramTypes.length];Map<String, String[]> params = req.getParameterMap();for (Map.Entry<String, String[]> parm : params.entrySet()) {String value = Arrays.toString(parm.getValue()).replaceAll("\\[|\\]", "").replaceAll("\\s", ",");if (!handler.paramIndexMapping.containsKey(parm.getKey())) {continue;}int index = handler.paramIndexMapping.get(parm.getKey());paramValues[index] = convert(paramTypes[index], value);}if (handler.paramIndexMapping.containsKey(HttpServletRequest.class.getName())) {int reqIndex = handler.paramIndexMapping.get(HttpServletRequest.class.getName());paramValues[reqIndex] = req;}if (handler.paramIndexMapping.containsKey(HttpServletResponse.class.getName())) {int respIndex = handler.paramIndexMapping.get(HttpServletResponse.class.getName());paramValues[respIndex] = resp;}Object returnValue = handler.method.invoke(handler.controller, paramValues);if (returnValue == null || returnValue instanceof Void) {return;}resp.getWriter().write(returnValue.toString());
}private Handler getHandler(HttpServletRequest req) {if (handlerMapping.isEmpty()) {return null;}//绝对路径String url = req.getRequestURI();//处理成相对路径String contextPath = req.getContextPath();url = url.replaceAll(contextPath, "").replaceAll("/+", "/");for (Handler handler : this.handlerMapping) {Matcher matcher = handler.getPattern().matcher(url);if (!matcher.matches()) {continue;}return handler;}return null;
}//url传过来的参数都是String类型的，HTTP是基于字符串协议
//只需要把String转换为任意类型就好
private Object convert(Class<?> type, String value) {//如果是intif (Integer.class == type) {return Integer.valueOf(value);} else if (Double.class == type) {return Double.valueOf(value);}//如果还有double或者其他类型，继续加if//这时候，我们应该想到策略模式了//在这里暂时不实现，希望小伙伴自己来实现return value;
}

在以上代码中,增加了两个方法，一个是getHandler。方法,主要负责处理url的正则匹配;一个是 convert()方 法 ，主要负责url参数的强制类型转换。

至此,手写Mini版 SpringMVC框架就已全部完成。

1.11.运行效果演示

在浏览器输入：http://localhost:8080/demo/query.json?name=Tom , 就会得到下面的结果：

image-20200331212455132

当然，真正的Spring要复杂很多，本课中主要通过手写的形式，了解Spring的基本设计思路以及设计 模式如何应用，在以后的课程中，我们还会继续手写更加高仿真版本的Spring2.0。

1.12.作业

1、请用自己的语言描述Spring IOC、DI、MVC的基本执行原理。

IOC：调用init()方法加载配置文件。IOC容器初始化，Map<String, Object>。扫描相关的类，scan-package = “com.gupaoedu”。创建实例化并保存至容器，通过反射机制将类实例化放入IOC容器中。

DI：进行DI操作，扫描IOC容器中的实例，给没有赋值的属性自动赋值。

MVC：初始化HandlerMapping，将一个URL和一个Method进行一对一的关系映射到Map<String, Method>。

2、Spring中的Bean是线程安全的吗？为什么？

  • Spring框架并没有对单例的bean进行多线程的封装处理，线程安全问题和并发问题，需要我们开发者自己考虑。
  • 但实际上，大部分的Spring bean并没有可变的状态（比如：service类和dao类），所有在某种程度上来说Spring单例bean是线程安全的。如果bean有多种状态的话（比如：View Model对象），就需要自行考虑线程安全问题。

参考资料：

1.《spring 5核心原理与30个类手写实战》谭勇德著

这篇关于17.用300行代码手写初体验Spring V1.0版本的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1090324。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
活用c4d官方开发文档查询代码

活用c4d官方开发文档查询代码

当你问AI助手比如豆包，如何用python禁止掉xpresso标签时候，它会提示到 这时候要用到两个东西。https://developers.maxon.net/论坛搜索和开发文档 比如这里我就在官方找到正确的id描述 然后我就把参数标签换过来
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2