手写简易 Spring（一）

已于 2023-04-01 20:45:27 修改
阅读量485 收藏
点赞数
分类专栏： Spring 详解 文章标签： spring java 设计模式
于 2023-03-28 19:53:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33530115/article/details/129822082
版权

文章目录

1. Spring Bean 容器是什么

  • Spring 定义的用于存放与管理对象的配置、生命周期与依赖的容器
  • 配置：单例还是多例
  • 生命周期：统一的流程，实例化、属性填充、初始化、业务使用、销毁
  • 依赖：生命周期的属性填充

2. Spring Bean 容器流程

  • 基础流程
  • 定义：接口 BeanDefinition、接口 BeanFactory
    • BeanDefinition：定义 Bean 的实例信息的接口
  • 注册：对象的 id 与地址存放到 HashMap
    • BeanFactory：注册与获取 Bean 的根接口
  • 获取：根据 id 获取 HashMap 的对象地址
    • BeanFactory：注册与获取 Bean 的根接口
      在这里插入图片描述

1. 核心抽象类 AbstractBeanFactory

  1. 抽象类 AbstractBeanFactory 实现了 getBean 方法：获取 Bean 对象
    • BeanFactory 接口定义了 getBean 方法
    • 抽象类 AbstractBeanFactory 使用了模板方法模式
  2. 实现类 DefaultSingletonBeanRegistry 实现了 getSingleton 方法：获取单例 Bean 对象
    • SingletonBeanRegistry 接口定义了 getSingleton 方法
  3. 实现类 DefaultSingletonBeanRegistry 实现了 addSingleton(String beanName, Object singletonObject) 方法：注册单例 Bean 对象
    • 他自己定义的 addSingleton 方法

Spring 源码：
在这里插入图片描述

2. 核心实现类 DefaultListableBeanFactory

  1. 抽象类 AbstractAutowireCapableBeanFactory 实现了 createBean(String beanName, BeanDefinition beanDefinition) 方法：创建 Bean 对象
    • 依赖了 BeanDefinition 接口
    • 抽象类 AbstractBeanFactory 定义了 createBean(String beanName, BeanDefinition beanDefinition) 方法
  2. 实现类 DefaultListableBeanFactory 实现了 getBeanDefinition(String beanName) 方法：获取 BeanDefinition 对象的
    • 依赖了 BeanDefinition 接口
    • 抽象类 AbstractBeanFactory 定义了 getBeanDefinition(String beanName) 方法
  3. 实现类 DefaultListableBeanFactory 实现了 registerBeanDefinition(String beanName, BeanDefinition beanDefinition) 方法：注册 BeanDefinition 对象
    • 接口 BeanDefinitionRegistry 定义了 registerBeanDefinition(String beanName, BeanDefinition beanDefinition) 方法

Spring 源码：
在这里插入图片描述

3. 核心接口 InstantiationStrategy

  • 抽象类 AbstractAutowireCapableBeanFactory 定义：使用 JDK 还是 Cglib 实例化带参 Bean 对象
  • 核心接口 InstantiationStrategy 定义：instantiate(BeanDefinition beanDefinition, String beanName, Constructor ctor, Object[] args) throws BeansException; 实例化对象、无论是否带参
    • 策略模式，根据传入参数自动选择哪个算法模板
  • 实现类 SimpleInstantiationStrategy 实现：instantiate 方法，使用 JDK 反射创建 Bean 对象（无论是否带参）
  • 实现类 CglibSubclassingInstantiationStrategy 实现：instantiate 方法，使用 Cglib 代理实例化 Bean 对象（无论是否带参）
    • Cglib 代理是一种代理模式，此外还有 Proxy 的动态代理，直接使用的静态代理
    • Cglib 代理是基于字节码框架 ASM 实现
    • net.sf.cglib.proxy.NoOp：在 Cglib 使用回调时把方法调用直接委派到父类实现（或者说传入对象直接调用方法）

4. 核心实现类 AbstractAutowireCapableBeanFactory

  • 实现类 PropertyValue 定义了：Bean 对象的属性名与与数据
  • 实现类 PropertyValues 封装了：PropertyValue
  • 实现类 BeanDefinition 定义了：注入的属性类 PropertyValues
  • 实现类 AbstractAutowireCapableBeanFactory 实现了：在创建 Bean 对象后注入依赖 applyPropertyValues 的方法
  • 工具类 BeanReference 定义了：它在依赖注入时属于一个 Bean 对象
  • 注意此时并未考虑循环依赖的问题

5. 总结

  • 总结：
    • 系统设计通常是通过接口、抽象类、继承与实现，隔离类的功能职责和作用范围
    • Spring 内部将 Bean 对象拆分放入 BeanDefinition，方便统一管理

3. 我的代码结构与源码

1. 我的调用类图（模拟 Spring 源码）

在这里插入图片描述

2. 我的代码结构（模拟 Spring 源码）

.
└── beans
    ├── BeansException.java
    ├── PropertyValue.java
    ├── PropertyValues.java
    └── factory
        ├── BeanFactory.java
        ├── config
        │   ├── BeanDefinition.java
        │   ├── BeanReference.java
        │   └── SingletonBeanRegistry.java
        └── support
            ├── AbstractAutowireCapableBeanFactory.java
            ├── AbstractBeanFactory.java
            ├── BeanDefinitionRegistry.java
            ├── CglibSubclassingInstantiationStrategy.java
            ├── DefaultListableBeanFactory.java
            ├── DefaultSingletonBeanRegistry.java
            ├── InstantiationStrategy.java
            └── SimpleInstantiationStrategy.java
.
└── test
    ├── ApiTest.java
    └── bean
        ├── UserController.java
        ├── UserDao.java
        └── UserService.java

3. 源码

1. BeanFactory 接口定义获取 Bean 对象

/**
 * 核心接口：定义获取 Bean 对象
 * @author gusixue
 * @date 2023/3/26
 */
public interface BeanFactory {

    Object getBean(String beanName) throws BeansException;

    Object getBean(String beanName, Object... args) throws BeansException;

}

2. AbstractBeanFactory 抽象类

/**
 * 核心抽象类：实现获取 Bean 对象、定义获取 BeanDefinition 对象、定义创建 Bean 对象
 * @author gusixue
 * @date 2023/3/26
 */
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {

    /**
     * 获取无参 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @return 返回创建好的 Bean 对象
     * @throws BeansException 创建 Bean 对象失败
     */
    @Override
    public Object getBean(String beanName) throws BeansException {
        Object bean = getSingletonBean(beanName);
        if (null != bean) {
            return bean;
        }

        BeanDefinition beanDefinition = getBeanDefinition(beanName);

        return createBean(beanName, beanDefinition, null);
    }

    /**
     * 获取有参 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @param args Bean 对象参数
     * @return 返回创建好的有参 Bean 对象
     * @throws BeansException 创建 Bean 对象失败
     */
    @Override
    public Object getBean(String beanName, Object... args) throws BeansException {
        Object bean = getSingletonBean(beanName);
        if (null != bean) {
            return bean;
        }

        BeanDefinition beanDefinition = getBeanDefinition(beanName);
        return createBean(beanName, beanDefinition, args);
    }

    protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;

    protected abstract Object createBean(String beanName, BeanDefinition beanDefinition, Object... args) throws BeansException;
}

3. DefaultSingletonBeanRegistry 定义单例对象

/**
 * 实现：获取单例 Bean 对象、注册单例 Bean 对象
 * @author gusixue
 * @date 2023/3/26
 */
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

    // 缓存 Bean 对象唯一 id 和单例 Bean 对象的容器
    private Map<String, Object> singletonBeanMap = new HashMap<>();

    /**
     * 获取单例 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @return 返回单例 Bean 对象
     */
    @Override
    public Object getSingletonBean(String beanName) {
        return singletonBeanMap.get(beanName);
    }

    /**
     * 注册单例 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @param singletonBean 单例 Bean 对象
     */
    protected void addSingleBean(String beanName, Object singletonBean) {
        singletonBeanMap.put(beanName, singletonBean);
    }
}

4. AbstractAutowireCapableBeanFactory 核心抽象类，创建对象核心

/**
 * 实现：创建 Bean 对象，依赖注入（暂未考虑循环依赖）
 * @author gusixue
 * @date 2023/3/26
 */
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {

    // 使用 JDK 进行 Bean 对象的实例化
//    InstantiationStrategy instantiationStrategy = new SimpleInstantiationStrategy();

    // 使用 Cglib 进行 Bean 对象的实例化
    InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

    /**
     * 创建 Bean 对象并进行依赖注入
     * @param beanName Bean 对象唯一 id
     * @param beanDefinition 解耦封装 Bean 对象
     * @param args Bean 对象参数
     * @return 返回已经创建好的 Bean 对象
     * @throws BeansException 创建 Bean 对象失败或者依赖注入失败
     */
    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object... args) throws BeansException {
        Object bean = null;

        try {
            bean = createBeanInstance(beanName, beanDefinition, args);

            applyPropertyValues(beanName, bean, beanDefinition);
        } catch (Exception e) {
            throw new BeansException("Instantiation of bean failed", e);
        }

        addSingleBean(beanName, bean);
        return bean;
    }

    /**
     * 选择正确的构造器，通过策略类创建 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @param beanDefinition 解耦封装 Bean 对象
     * @param args Bean 对象参数
     * @return 返回已经创建好的 Bean 对象
     */
    private Object createBeanInstance(String beanName, BeanDefinition beanDefinition, Object[] args) {
        Constructor ctor = null;
        Constructor<?>[] constructors = beanDefinition.getBeanClass().getConstructors();
        /**
         * 简化：根据传入参数选择最匹配的构造器
         * Spring 实际会使用这个：getBean 传入参数与 BeanDefinition 中所有构造器权重相差最小的就使用那个构造器
         * int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
         * 						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
         */
        if (null != args) {
            for (Constructor constructor : constructors) {
                if (null != constructor && constructor.getParameterCount() == args.length) {
                    ctor = constructor;
                    break;
                }
            }
        }

        return instantiationStrategy.instantiate(beanName, beanDefinition, ctor, args);
    }

    /**
     * Bean 对象进行依赖注入
     * @param beanName Bean 对象唯一 id
     * @param bean 创建好的 Bean 对象
     * @param beanDefinition 解耦封装 Bean 对象
     */
    private void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {

        PropertyValues propertyValues = beanDefinition.getPropertyValues();
        if (propertyValues != null && propertyValues.getPropertyValues() != null
                && propertyValues.getPropertyValues().size() > 0) {

            for (PropertyValue propertyValue : propertyValues.getPropertyValues()) {

                String propertyName = propertyValue.getName();
                Object propertyValueObj = propertyValue.getValue();

                if (propertyValueObj instanceof BeanReference) {

                    BeanReference beanReference = (BeanReference)propertyValueObj;
                    /**
                     * 注意这儿为了方便获取 Bean 对象没有加参数
                     * 注意 beanReference.getPropertyName() 可能与 propertyName 不一致，propertyName 方法与 setXxx 参数是一致的
                     */
                    propertyValueObj = getBean(beanReference.getPropertyName());
                }

                // 直接反射未考虑 Cglib 代理的 Bean 对象，set 方法内部是基本数据类型
//                String setMethodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
//                bean.getClass().getMethod(setMethodName, propertyValueObj.getClass())
//                        .invoke(bean, propertyValueObj);

                BeanUtil.setFieldValue(bean, propertyName, propertyValueObj);
            }
        }
    }


    public InstantiationStrategy getInstantiationStrategy() {
        return instantiationStrategy;
    }

    public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
        this.instantiationStrategy = instantiationStrategy;
    }
}

5. DefaultListableBeanFactory 最终核心使用实现类

/**
 * 核心实现类：实现类获取 BeanDefinition 对象、注册 BeanDefinition 对象
 * @author gusixue
 * @date 2023/3/26
 */
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry{

    // 缓存 Bean 对象唯一 id 和 BeanDefinition 对象的容器
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();

    /**
     * 获取 BeanDefinition 对象
     * @param beanName Bean 对象唯一 id
     * @return 返回 BeanDefinition 对象
     * @throws BeansException 获取不到 BeanDefinition 对象
     */
    @Override
    protected BeanDefinition getBeanDefinition(String beanName) throws BeansException {
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        if (beanDefinition == null) {
            throw new BeansException("No bean named '" + beanName + "' is defined");
        }
        return beanDefinition;
    }

    /**
     * 注册 BeanDefinition 对象
     * @param beanName Bean 对象唯一 id
     * @param beanDefinition BeanDefinition 对象
     */
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(beanName, beanDefinition);
    }
}

6. BeanDefinition 实现类，解耦 Bean 对象

/**
 * 定义：Bean 对象的 Class 以及属性信息
 * @author gusixue
 * @date 2023/3/26
 */
public class BeanDefinition {

    // Bean 对象的 Class
    private Class beanClass;

    // Bean 对象的所有属性信息
    private PropertyValues propertyValues;

    public BeanDefinition(Class beanClass, PropertyValues propertyValues) {
        this.beanClass = beanClass;
        this.propertyValues = propertyValues;
    }

... Getter、Setter、toString
}

7. SimpleInstantiationStrategy JDK 实例化对象

/**
 * 实现：创建有参 Bean 对象（无论是否有参），使用 JDK 反射
 * @author gusixue
 * @date 2023/3/27
 */
public class SimpleInstantiationStrategy implements InstantiationStrategy {

    /**
     * 通过 Cglib 代理实例化 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @param beanDefinition 解耦封装 Bean 对象
     * @param ctor Bean 对象构造器
     * @param args Bean 对象参数
     * @return 实例化 Bean 对象
     * @throws BeansException 实例化 Bean 对象异常
     */
    @Override
    public Object instantiate(String beanName, BeanDefinition beanDefinition, Constructor ctor, Object[] args) throws BeansException {
        Object bean = null;

        Class clazz = beanDefinition.getBeanClass();

        try {
            if (null == args) {
                bean = clazz.getDeclaredConstructor().newInstance();

            } else {
                bean = clazz.getDeclaredConstructor(ctor.getParameterTypes()).newInstance(args);

            }
        } catch (IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException e) {
            throw new BeansException("Failed to instantiate [" + clazz.getName() + "]", e);
        }

        return bean;
    }
}

8. CglibSubclassingInstantiationStrategy Cglib 实例化对象

/**
 * 实现：创建有参 Bean 对象（无论是否有参），使用 Cglib 代理
 * @author gusixue
 * @date 2023/3/27
 */
public class CglibSubclassingInstantiationStrategy implements InstantiationStrategy {

    /**
     * 通过 Cglib 代理实例化 Bean 对象
     * @param beanName Bean 对象唯一 id
     * @param beanDefinition 解耦封装 Bean 对象
     * @param ctor Bean 对象构造器
     * @param args Bean 对象参数
     * @return 实例化 Bean 对象
     * @throws BeansException 实例化 Bean 对象异常
     */
    @Override
    public Object instantiate(String beanName, BeanDefinition beanDefinition, Constructor ctor, Object[] args) throws BeansException {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(beanDefinition.getBeanClass());
//        enhancer.setCallback(new NoOp() {
//            @Override
//            public int hashCode() {
//                return super.hashCode();
//            }
//        });

        enhancer.setCallback(NoOp.INSTANCE);

        if (null == ctor) {
            return enhancer.create();
        }
        return enhancer.create(ctor.getParameterTypes(), args);
    }

}

9. PropertyValue 定义对象的属性名与与属性值

/**
 * 定义 Bean 对象的属性名与与属性值
 * @author gusixue
 * @date 2023/3/28
 */
public class PropertyValue {

    // Bean 对象属性名
    private String name;

    // Bean 对象具体属性值
    private Object value;

    public PropertyValue(String name, Object value) {
        this.name = name;
        this.value = value;
    }

... Getter、Setter、toString
}

参考：https://bugstack.cn/md/spring/develop-spring/2021-05-16-%E7%AC%AC1%E7%AB%A0%EF%BC%9A%E5%BC%80%E7%AF%87%E4%BB%8B%E7%BB%8D%EF%BC%8C%E6%89%8B%E5%86%99Spring%E8%83%BD%E7%BB%99%E4%BD%A0%E5%B8%A6%E6%9D%A5%E4%BB%80%E4%B9%88%EF%BC%9F.html

专注如一
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写一个简易的spring
qq_53219518的博客
04-26 361
手写一个简易的spring之Ioc的实现 Spring核心功能手写一个简易的spring之Ioc的实现一、概念二、Spring中容器的获取总结 一、概念 控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指 将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。简单来说，这里的反转指的就是将原先new代码的权力交付给spring的容器去实
简易的手写springmvc
08-04
本工程模仿了简易的springMVC的实现， 包含了controller、service、requestParam、autowired、requestMapping注解类的创建 IOC容器的创建及组装原理实现 简易的request请求
手写简易Spring框架
hwp_ing的博客
11-12 855
b站图灵学院up周瑜手写简易Spring课程笔记视频配套代码。
手写简易Spring
qq_50313418的博客
08-21 1029
实现其中的两个方法，一个在初始化bean前调用，一个在初始化bean后调用，在其中写我们自己想要写的逻辑。AOP 其实就是利用 BeanPostProcessor 实现的，并且它就是在初始化后这一步实现的。如果想要在初始化的时候专门有一个方法用于处理一些逻辑时，我们应该怎么做呢？注意：下面有些代码有的只是简单写了一下大致流程，具体细节会在之后实现。在工厂中的名字传给这个值，我们应该如何实现呢，这就需要用到。那么在 Spring 中我们如何实现呢？我们新创建一个类，然后让其实现。Spring实现包中。
手写简易版 Spring框架
FBB360JAVA的博客
04-26 1074
文章目录前言目前已实现1 简单校验2 扫描配置3 根据扫描到的配置组装 BeanDefinition4 根据 BeanDefinition 创建非懒加载、并且是单例的bean，存储到单例池5 增加 BeanNameAware 接口6 增加 InitializingBean 接口7 增加 BeanPostProcessor 接口延伸阅读 前言 最近项目里有大量的 “长的很像的代码”。这类代码，用到了工厂模式、建造者模式，但是最终由于业务复杂，而且功能上是对接平台的，因此会有上百个这种类，每个都不一样。 出于对
手写简易mybatis
03-06
【标题】"手写简易mybatis"涉及到的知识点主要涵盖了MyBatis框架的核心概念和实现原理，这包括了配置文件解析、SQL会话管理、Mapper注解以及动态代理技术的应用。下面将对这些主题进行详细阐述。 首先，**配置文件...
手写springmvc 简易版
10-28
在这个“手写springmvc简易版”项目中，我们有机会深入理解Spring MVC的核心概念和工作原理。下面将详细介绍这个简易版Spring MVC实现中的关键知识点。 1. **DispatcherServlet**：作为Spring MVC的前端控制器，...
仿 Spring 手写 IoC、AOP 框架.rar
10-23
本教程将带你深入理解这两个概念，并通过手写一个简易的IoC和AOP框架来加深理解。 **依赖注入（IoC）** 依赖注入是Spring的核心特性之一，它允许开发者将对象的创建和管理权交给框架，从而降低组件之间的耦合度。在...
手写简单Spring MVC
11-02
手写简易SpringMVC 附测试demo
SpringBoot集成EasyExcel实现模板写入多个sheet导出
最新发布
LynneZoe的博客
07-18 178
SpringBoot集成EasyExcel实现模板写入多个sheet导出。
springboot start.aliyun.com java8
JavaUpgrade
07-15 125
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Spring Security 授权
persistence_PSH的博客
07-14 895
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
springboot基于协同过滤算法的黔醉酒业白酒销售系统lw源码调试讲解
u014445459的博客
07-16 800
本章开始先是介绍了系统进行测试目的及方法，然后简单地阐述了系统测试中常见的黑命、白盒和灰盒测试方法，以及它们各自的特征，随后围绕本系统的注册登录、删除分类、修改密码、等功能进行了功能测试，并将测试用例和测试结果呈现出来，此外，还对实现的系统进行了关于登录和功能模块的压力测试。本系统开发之前的所有调研基本都是本人独立完成，需求设计，功能开发等也都是自己及指导老师的帮助下完成，通过自己的努力解决掉开发过程中所遇到的问题经济支出可以忽略不计，固黔醉酒业白酒销售系统在经济可行性上完全可行可以开发。
玩转springboot之springboot集成redis乱码问题
Lxn2zh的博客
07-15 207
在使用redis操作字符串时发现会变成乱码，这是因为RedisTemplate默认是使用的是JdkSerializationRedisSerializer序列化方式，这里可以使用StringRedisTemplate来进行操作，StringRedisTemplate中默认使用的是StringRedisSerializer。也可以对RedisTemplate进行配置，设置其序列化方式。springboot集成redis乱码问题。
基于SpringBoot+MySQL的租房项目+文档
欧阳小白闯天涯
07-11 1030
在当今快节奏的生活中，房屋租赁市场的需求与日俱增。为了有效管理租房流程、提升用户体验，本文基于SpringBoot+MySQL技术栈，设计并实现了一套全方位的租房系统。该系统融合了经纪人、维修员、管理员和用户四个角色，各自拥有独特的功能模块，包括房源管理、维修处理、员工用户管理、统计分析等。经纪人角色能够方便地添加房源、管理自己的房源、处理房源出租事务，并通过系统提供的月出租量统计功能进行业绩分析与优化。其次，维修员可以及时响应待处理的房源报修请求，有效地管理已处理的房源维修记录。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 704
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
SpringCloud第二篇（如何将大型项目拆分成微服务项目）
Du_XiaoNan的博客
07-13 1031
这一章我们从单体架构的优缺点来分析，看看开发大型项目采用单体架构存在哪些问题，而微服务架构又是如何解决这些问题的
No spring.config.import property has been defined 及其它几个问题
王广帅--游戏开发技术
07-15 209
最近对nacos版本进行了升级，在使用nacos2.2.x的时候遇到的这个问题：No spring.config.import property has been defined。springboot版本也进行了升级到了版本3.5.x。那么在配置中必须添加spring.cloud.nacos.config的相关配置。因为注册到nacos的服务必须是一个web服务。
手写一个简易的 spring 框架
04-14
好的，我可以为您提供一些关于手写一个简易的 Spring 框架的建议： 1. 设计一个 IoC 容器：IoC (Inversion of Control) 是 Spring 框架的核心概念之一，它通过通过将控制权交给容器来管理对象的创建和依赖关系。您...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值