Spring5 - 30个类手写实战 - 打卡第一天（V1版本）

最新推荐文章于 2024-04-03 16:33:16 发布
最新推荐文章于 2024-04-03 16:33:16 发布
阅读量718 收藏 4
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45676630/article/details/105848959
版权

相关文章：
Spring5 - 30个类手写实战 - 打卡第二天（IOC与DI）

Spring5 - 30个类手写实战 - 打卡第三天（MVC）

Spring5 - 30个类手写实战 - 打卡第四天（AOP）

Spring5 - 30个类手写实战 - 打卡第五天（手绘IOC时序图）

1.实现基本思路

在这里插入图片描述

2.注解类的实现

2.1 LAutowired

package com.liulin.spring.framework.annotation;

import java.lang.annotation.*;

/**
 * Create by DbL on 2020/4/29 0029
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LAutowired {
    String value() default "";
}

2.2 LController

package com.liulin.spring.framework.annotation;

import java.lang.annotation.*;

/**
 * Create by DbL on 2020/4/29 0029
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LController {
    String value() default "";
}

2.3 LRequestMapping

package com.liulin.spring.framework.annotation;

import java.lang.annotation.*;

/**
 * Create by DbL on 2020/4/29 0029
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LRequestMapping {
    String value() default "";
}

2.4 LRequestParam

package com.liulin.spring.framework.annotation;

import java.lang.annotation.*;

/**
 * Create by DbL on 2020/4/29 0029
 */
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LRequestParam {
    String value() default "";
}

2.5 LService

package com.liulin.spring.framework.annotation;

import java.lang.annotation.*;

/**
 * Create by DbL on 2020/4/29 0029
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LService {
    String value() default "";
}

3.pom.xml 引入需要用到的jar

	<groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.4</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.4</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.25</version>
    </dependency>

4.web.xml配置

为了方便把需要扫描的包配置在application.properties文件中，servlet-class配置为自己写的LDispatcherServlet

<?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">
    <display-name>Archetype Created Web Application</display-name>

    <servlet>
        <servlet-name>lmvc</servlet-name>
        <servlet-class>com.liulin.spring.framework.servlet.LDispatcherServlet</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>lmvc</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

5. application.properties文件

里面很简单，只配置了需要扫描的包的路径scanPackage=com.liulin.demo

在这里插入图片描述

6.扫描的demo包，用于测试

在这里插入图片描述

MyAction ：

package com.liulin.demo.action;

import com.liulin.demo.service.IModifyService;
import com.liulin.demo.service.IQueryService;
import com.liulin.spring.framework.annotation.LAutowired;
import com.liulin.spring.framework.annotation.LController;
import com.liulin.spring.framework.annotation.LRequestMapping;
import com.liulin.spring.framework.annotation.LRequestParam;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * Create by DbL on 2020/4/29 0029
 */
@LController
@LRequestMapping("/web")
public class MyAction {

    @LAutowired
    IQueryService queryService;
    @LAutowired
    IModifyService modifyService;

    @LRequestMapping("/query.json")
    public void query(HttpServletRequest request, HttpServletResponse response,
                      @LRequestParam("name") String name) {
        String result = queryService.query(name);
        out(response, result);
    }

    @LRequestMapping("/add*.json")
    public void add(HttpServletRequest request, HttpServletResponse response,
                    @LRequestParam("name") String name, @LRequestParam("addr") String addr) {
        String result = modifyService.add(name, addr);
        out(response, result);
    }

    @LRequestMapping("/remove.json")
    public void remove(HttpServletRequest request, HttpServletResponse response,
                       @LRequestParam("id") Integer id) {
        String result = modifyService.remove(id);
        out(response, result);
    }

    @LRequestMapping("/edit.json")
    public void edit(HttpServletRequest request, HttpServletResponse response,
                     @LRequestParam("id") Integer id,
                     @LRequestParam("name") String name) {
        String result = modifyService.edit(id, name);
        out(response, result);
    }


    private void out(HttpServletResponse resp, String str) {
        try {
            resp.getWriter().write(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

IModifyService ：

package com.liulin.demo.service;

/**
 * Create by DbL on 2020/4/29 0029
 */
public interface IModifyService {
    /**
     * 增加
	 */
    public String add(String name, String addr);

    /**
     * 修改
     */
    public String edit(Integer id, String name);

    /**
     * 删除
     */
    public String remove(Integer id);
}

ModifyServiceImpl ：

package com.liulin.demo.service.impl;

import com.liulin.demo.service.IModifyService;
import com.liulin.spring.framework.annotation.LService;

/**
 * Create by DbL on 2020/4/29 0029
 */
@LService
public class ModifyServiceImpl implements IModifyService {

    /**
     * 增加
     */
    public String add(String name,String addr) {
        return "modifyService add,name=" + name + ",addr=" + addr;
    }

    /**
     * 修改
     */
    public String edit(Integer id,String name) {
        return "modifyService edit,id=" + id + ",name=" + name;
    }

    /**
     * 删除
     */
    public String remove(Integer id) {
        return "modifyService id=" + id;
    }

}

IQueryService ：

package com.liulin.demo.service;

/**
 * Create by DbL on 2020/4/29 0029
 */
public interface IQueryService {
    /**
     * 查询
     */
    public String query(String name);
}

QueryServiceImpl ：

package com.liulin.demo.service.impl;

import com.liulin.spring.framework.annotation.LService;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Create by DbL on 2020/4/29 0029
 */
@LService
public class QueryServiceImpl implements IQueryService{

    /**
     * 查询
     */
    public String query(String name) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = sdf.format(new Date());
        String json = "{name:\"" + name + "\",time:\"" + time + "\"}";
        System.out.println("这是在业务方法中打印的：" + json);
        return json;
    }

}

7.LDispatcherServlet （V1版本）

后面再对各个功能进行拆分。

package com.liulin.spring.framework.servlet;

import com.liulin.spring.framework.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.awt.print.PrinterAbortException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;

/**
 * Create by DbL on 2020/4/29 0029
 */
public class LDispatcherServlet extends HttpServlet {
    private Properties contextConfig = new Properties();
    // 享元模式 ， 缓存
    private List<String> classNames = new ArrayList<String>();
    // IOC容器，key默认是类名首字母小写，value是对应的实例对象
    private Map<String, Object> ioc = new HashMap<String, Object>();

    private Map<String, Method> handlerMapping = new HashMap<String, Method>();

    @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.委派，根据URL去找到一个对应的Method并通过response返回
        try {
            doDispatch(req, resp);
        } catch (Exception e) {
            e.printStackTrace();
            resp.getWriter().write("500 Exception , Detail : " + Arrays.toString(e.getStackTrace()));
        }
    }

    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;
        }

        Map<String, String[]> params = req.getParameterMap();
        Method method = this.handlerMapping.get(url);
        // 获取形参列表
        Class<?>[] parameterTypes = method.getParameterTypes();
        Object[] paramValues = new Object[parameterTypes.length];
        for (int i = 0; i < parameterTypes.length; i++) {
            Class paramterType = parameterTypes[i];
            if (paramterType == HttpServletRequest.class) {
                paramValues[i] = req;
            } else if (paramterType == HttpServletResponse.class) {
                paramValues[i] = resp;
            } else if (paramterType == String.class) {
                // 通过运行时的状态去拿到注解的值
                Annotation[][] pa = method.getParameterAnnotations();
                for (int j = 0; j < pa.length; j++) {
                    for (Annotation a : pa[j]) {
                        if (a instanceof LRequestParam) {
                            String paramName = ((LRequestParam) a).value();
                            if (!"".equals(paramName.trim())) {
                                String value = Arrays.toString(params.get(paramName))
                                        .replaceAll("\\[|\\]", "")
                                        .replaceAll("\\s+", "");
                                paramValues[i] = value;
                            }
                        }
                    }
                }
               /* LRequestParam requestParam = (LRequestParam) paramterType.getAnnotation(LRequestParam.class);
                String paramName = requestParam.value();
                String value = Arrays.toString(params.get(paramName))
                        .replaceAll("\\[|\\]", "")
                        .replaceAll("\\s+","");
                paramValues[i] = value;*/
            }
        }
        // 暂时写死，用于测试
        String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
        method.invoke(ioc.get(beanName), new Object[]{req, resp, params.get("name")[0]});

    }

    @Override
    public void init(ServletConfig config) throws ServletException {
        // 1.加载配置文件  contextConfigLocation对应web.xml中的init-param  ==》 param-name
        doLoadConfig(config.getInitParameter("contextConfigLocation"));
        // 2.扫描相关的类
        doScanner(contextConfig.getProperty("scanPackage"));
        //=================IOC部分=============//
        // 3.初始化IOC容器，将扫描到的相关的类实例化，保存到IOC容器中
        doInstance();
        // AOP，DI之前，新生成的代理对象
        //================DI部分==============//
        // 4.完成依赖注入
        doAutoWired();
        //================MVC部分==============//
        // 5.初始化HandlerMapping
        doInitHandlerMapping();
        System.out.println("L Spring framework init success ");
    }

    private void doInitHandlerMapping() {
        if (ioc.isEmpty()) {
            return;
        }
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
            // 类没有加注解的跳过
            if (!clazz.isAnnotationPresent(LController.class)) {
                continue;
            }
            // 如果类上定义了路径，方法上的路径需要拼接上此路径
            String baseUrl = "";
            if (clazz.isAnnotationPresent(LRequestMapping.class)) {
                LRequestMapping Mapping = clazz.getAnnotation(LRequestMapping.class);
                baseUrl = Mapping.value();
            }
            // 只获取public的方法
            for (Method method : clazz.getMethods()) {
                // 方法没有加注解的跳过
                if (!method.isAnnotationPresent(LRequestMapping.class)) {
                    continue;
                }
                LRequestMapping requestMapping = method.getAnnotation(LRequestMapping.class);
                // 对于配置了“/” 和没有配置“/”的通过正则表达式统一处理
                String url = ("/" + baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");
                handlerMapping.put(url, method);
                System.out.println("mapped : " + url + " , " + method);
            }
        }
    }

    private void doAutoWired() {
        if (ioc.isEmpty()) {
            return;
        }
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            // 获取private/protected/default/public修饰的所有字段
            for (Field field : entry.getValue().getClass().getDeclaredFields()) {
                if (!field.isAnnotationPresent(LAutowired.class)) {
                    return;
                }
                LAutowired autowired = field.getAnnotation(LAutowired.class);
                // 如果用户没有自定义的beanName，就默认根据类型注入
                String beanName = autowired.value().trim();
                if ("".equals(beanName)) {
                    // 接口全名
                    beanName = field.getType().getName();
                }
                // 对于类中的private属性的成员进行暴力访问
                field.setAccessible(true);
                try {
                    // ioc.get(beanName) 相当于通过接口的全名从IOC中拿到接口的实现的实例
                    field.set(entry.getValue(), ioc.get(beanName));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void doInstance() {
        if (classNames.isEmpty()) {
            return;
        }
        for (String className : classNames) {
            try {
                Class<?> clazz = Class.forName(className);
                // 加了LController或者LService注解的才加到IOC容器，因为像接口类不能new
                if (clazz.isAnnotationPresent(LController.class)) {
                    // 类名首字母小写作为key
                    String beanName = toLowerFirstCase(clazz.getSimpleName());
                    Object instance = clazz.newInstance();
                    ioc.put(beanName, instance);
                } else if (clazz.isAnnotationPresent(LService.class)) {
                    // 1.在多个包下出现相同的类名，只能自己起一个全局唯一的名字
                    // 自定义名字
                    String beanName = clazz.getAnnotation(LService.class).value();
                    // 如果设置了名字就用设置的，没有就用默认的
                    if ("".equals(beanName.trim())) {
                        beanName = toLowerFirstCase(clazz.getSimpleName());
                    }
                    // 2. 默认的类名首字母小写
                    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 !!! ");
                        }
                        ioc.put(i.getName(), instance);
                    }

                } else {
                    continue;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

    private void doScanner(String scanPackage) {
        // com.liulin.demo 需要转换成文件夹的路径形式便于扫描路径下的文件
        URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
        File classPath = new File(url.getFile());
        // 当成是一个classPath文件夹
        for (File file : classPath.listFiles()) {
            if (file.isDirectory()) {
                // 递归遍历子文件夹
                doScanner(scanPackage + "." + file.getName());
            } else {
                // 非class文件跳过
                if (!file.getName().endsWith(".class")) continue;
                String className = file.getName().replace(".class", "");
                // Class.forName(className)
                // 防止名字重复，这里使用包名加上类名
                classNames.add(scanPackage + "." + className);
            }
        }
    }

    private void doLoadConfig(String contextConfigLocation) {
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
        try {
            contextConfig.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != resourceAsStream) {
                try {
                    resourceAsStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

8 运行测试

在这里插入图片描述

白小T~
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
spring5-samples:《Spring5核心原理与30个类手写实战》随书代码示例工程
05-14
《Spring5核心原理与30个类手写实战》 4个月销量破万，连续占据畅销榜 京东购买链接： 当当购买链接： 倾注十年Spring研究精华与见解 ★本书几乎涵盖在Spring应用中可能遇到的所有问题，核心原理（IoC、DI、AOP、MVC）、高仿手写、数据访问等 ★深度解析Spring 5的原理与新特性，从环境准备、顶层结构设计、数据访问等方面一步步推导出Spring设计原理 ★通过本书你可以： --看源码不再晕车，轻松找到入口。 --系统学习设计思想，提高解决问题的效率。 --培养架构思维能力，自驱学习能力。 --用30个类提炼出Spring核心的精华思想，并保证功能可用。 --从不一样的角度分析Spring经典高频面试题。 --了解Spring 5 的新特性。 --为深入了解Spring Boot做铺垫。 关于我 为什么说我来自文艺界？ 　　我自幼爱好书法和美术，长了一双能书会画的手，
[Spring] 30个类手写 Spring Mini 版本系列（一）
架构探险之道
04-18 930
[Spring] 30个类手写 Spring Mini 版本系列（一） 简介 为了更深入的了解 Spring 的实现原理和设计思想，一直打算出个系列文章，从零开始重新学习 Spring。有兴趣的小伙伴可以持续关注更新。 目录[Spring] 30个类手写 Spring Mini 版本系列（一）V1 版本V1.0.0 版本注解定义定义 Controller 和 Service定义配置定义 Di...
Spring5 - 30个类手写实战 - 打卡第二天（IOC与DI）
zgliulin
05-01 465
相关文章：Spring5 - 30个类手写实战 - 打卡第一天（V1版本） 1.IOC中三个最重要的类 BeanDefinition ： 所有配置文件（properties/xml/yml/…），在内存中的体现形式 BeanWrapper ： 保存了原生对象对未来要创建的各种对象之间的关联关系 ApplicationContext ： 简单的理解为它就是工厂类，它有一个getBean()的方法...
《Spring 5 核心原理与30个类手写实战》读书笔记
chanhu3999的博客
08-10 445
目录 第一章 软件架构设计原则 第二章 Spring中常用的设计模式 第一章 软件架构设计原则 SOLID SRP The Single Responsibility Principle 单一责任原则 修改一个类的原因应该只有一个 换让一个类只负责一件事，当这个类需要做过多事情的时候，就需要分解这个类。 OCP The Open Closed Principle 开放封闭原则 类对扩展开放对修改关闭 扩展就是添加新功能的意思，因此该原则要求在添加新功能时不需要修改代码。
Spring5 - 30个类手写实战 - 打卡第五天（手绘IOC时序图）
zgliulin
05-04 428
1. IOC&DI IOC(Inversion of Control) ： 控制反转，所谓控制反转，就是把原先我们代码里面需要实现的对象创建、依赖的代码，反转给容器来帮忙实现。 DI(Dependency Injection)：依赖注入，就是指对象是被动接受依赖类而不是自己主动去找，换句话说就是指对象不是从容器中查找它依赖的类，而是在容器实例化对象的时候主动将它依赖的类注入给他。 完成Be...
[Spring] 30个类手写 Spring Mini 版本系列（二）
架构探险之道
04-30 555
[Spring] 30个类手写 Spring Mini 版本系列（二） 简介 为了更深入的了解 Spring 的实现原理和设计思想，一直打算出个系列文章，从零开始重新学习 Spring。在[Spring] 30个类手写 Spring Mini 版本系列（一）中，我们直接通过 Servlet API 初步实现了 Spring 的简易版。针对V1.1.0版，今天我们来做下优化，主要针对主要流程节点...
Spring 5核心原理与30个类手写实战
abczyhbei的博客
09-09 2208
软件架构设计原则 开闭原则 开闭原则是对扩展和修改行为的一个原则，指的是软件中的函数、类、模块应该对扩展开放，对修改关闭。强调的是用抽象构建框架，用实现扩展细节。常用于解决的问题如：更新版本时，尽量在不修改源代码，但增加新功能。 依赖倒置 依赖倒置是指设计系统代码结构时，高层模块不依赖底层模块，它们都应依赖于其抽象。细节应该依赖抽象。通过依赖倒置，可减少系统之间模块的耦合性，提高系统的稳定性，提高系统的可读性与可维护性，降低修改程序带来的风险。 以抽象为基准设计的架构要比以细节为基准设计的架构稳定
Spring5 - 30个类手写实战 - 打卡第三天（MVC）
zgliulin
05-02 420
1.MVC九大组件 序号 组件名 解释 1 MultipartResolver 多文件上传的组件 2 LocalResolver 本地语言环境 3 ThemeResolver 主题模块处理器 4 HandlerMapping 保存Url映射关系 5 HandlerAdapter 动态参数适配器 6 HandlerExceptionResolver 异常拦截器 ...
spring书籍_十年沉淀之作，手写spring精华思想，Java架构师成长必备
weixin_39900206的博客
12-17 400
书籍介绍：《Spring 5核心原理与30个类手写实战》基于编程开发实践，不仅深度解析Spring 5的原理与新特性，更从环境准备、顶层结构设计、数据访问等方面一步步地推导出Spring的设计原理。在每个知识点上，均以大量的经典代码案例辅助讲解，使理论紧密联系实际。最后手写30个类，以体会Spring作者的创作过程，让每一位读者学以致用。对于立志成为Java架构师的技术人员，以及对以Spring为...
30个类仿真手写spring框架V2.0版本
Jarvis.y的博客
11-01 2518
必读，代码只是模仿spring的一个大致设计思路，很多细节问题并没有考虑到，代码本身还存在很多的问题，只能供参考一下。 从 Servlet 到 ApplicationContext 我们已经了解 SpringMVC 的入口是 DispatcherSerlvet，我们实现了 DispatcherServlet 的 init()方法。在 init()方法中完成了 IOC 容器的初始化。而在我们使用Spring 的经验中，我们见得最多的是 ApplicationContext，似乎 Spring 托管的所有实例
spring(纯手写spring)
08-03
spring(纯手写spring)，通过本代码，可以了解得到spring的基本原理。
《27道大厂高频Spring面试题，95%的人答不上》
chengwei9208的博客
07-30 954
《27道大厂高频Spring面试题，95%的人答不上》 本文节选自《Spring5核心原理与30个类手写实战》一书，谭勇德（Tom）著，电子工业出版社出版。本书基于编程开发实践，不仅深度解析Spring 5的原理与新特性，更从环境准备、顶层结构设计、数据访问等方面一步步地推导出Spring的...
30个类手写Spring核心原理之自定义ORM（上）（6，kafka面试题零拷贝
最新发布
2401_84104883的博客
04-03 1007
看完美团、字节、腾讯这三家的一二三面试问题，是不是感觉问的特别多，可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。开篇有提及我可是足足背下了Java互联网工程师面试1000题，多少还是有点用的呢，换汤不换药，不管面试官怎么问你，抓住本质即可！能读到此处的都是真爱Java互联网工程师面试1000题。
30个类手写Spring核心原理之Ioc顶层架构设计（2）
m0_66789766的博客
05-04 156
[](()3.2 GPBeanWrapper BeanWrapper主要用于封装创建后的对象实例，代理对象（Proxy Object）或者原生对象（Original Object）都由BeanWrapper来保存。 package com.tom.spring.formework.beans; public class GPBeanWrapper { private Object wrappedInstance; private Class<?> wrappedClass; public GPB
手写一个简单的Spring框架
不会编程的汪
09-12 4568
手写Spring 初始化流程 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl + Q 插入链接 Ctrl + L 插入代码 Ctrl + K 插...
27道高频Spring面试题，你能答对几个？
程序猿DD
07-24 2927
点击蓝色“程序猿DD”关注我回复“资源”获取独家整理的学习资料！坚持看完，文末福利等你本文节选自 《Spring 5核心原理与30个类手写实战》一书，谭勇德（Tom） 著...
手写SpringMVC框架（简易版）
热门推荐
yaluoshan的专栏
06-22 1万+
SpringMVC简介 SpringMVC是当前最优秀的MVC框架，自从Spring 2.5版本发布后，由于支持注解配置，易用性有了大幅度的提高。Spring 3.0更加完善，实现了对Struts 2的超越。现在越来越多的开发团队选择了Spring MVC。 - Spring为展现层提供的基于MVC设计理念的优秀的Web框架，是目前最主流的MVC框架之一 - Spring3.0后全面超越St...
手写代码提炼Spring核心原理
阿浩的博客
08-10 326
基本实现思路 一.配置阶段：配置web.xml (DispatcherServlet) —>设定init-param(contextConfigLocation=classpath:application.xml)—>设定url-pattern(/*)—>配置Annotation(@Controller @Service @Autowired @RequestMapping)...
手写实现Spring AOP
Jet_Green的博客
08-09 3102
Spring IOC、AOP可谓是spring中两大王牌 上次我们手写了IOC，那么今天我们来手写一下AOP 感谢这篇博主的手写AOP博文（https://blog.csdn.net/qq_35704236/article/details/79997182） 我是学习他的写法，然后将一些我不懂的代码进行了注释解释，应该可以更加适合小白学习吧。 一.准备 首先我们都知道Spring AOP...
spring 5核心原理与30个类手写实战
06-06
很抱歉，我是AI语言模型，无法亲自进行实战操作。但是，我可以告诉你，Spring 5核心原理与30个类手写实战是一本介绍Spring框架核心原理和实战应用的书籍，通过手写实现30个类的方式，深入讲解了Spring框架的核心机制和设计思想，帮助读者更好地理解和应用Spring框架。如果你对Spring框架感兴趣，可以阅读这本书籍，深入了解Spring框架的内部原理和实际应用。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值