spring-ioc源码浅析

最新推荐文章于 2024-07-25 11:59:12 发布
最新推荐文章于 2024-07-25 11:59:12 发布
阅读量54 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chunbing_dkw/article/details/129809785
版权

1 说明

  1. 本文只是作为阅读spring源码梳理，没有太多源码贴进来；
  2. 梳理的只是个人认为比较重要的点
  3. 入口是机遇注解的spring容器，用的是 AnnotationConfigApplicationContext

2 使用

2.1 pom文件

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.9</version>
</dependency>

2.2 配置类

package spring.kewen.ding.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "spring.kewen.ding.bean")
public class DingConfig {
}

2.3 bean

package spring.kewen.ding.bean;

import org.springframework.stereotype.Component;

@Component
public class DingBean {
    public String name = "dingkewen";
}

2.4 启动类与使用

package spring.kewen.ding;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import spring.kewen.ding.bean.DingBean;
import spring.kewen.ding.config.DingConfig;

public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext acac = new AnnotationConfigApplicationContext(DingConfig.class);
        DingBean dingBean = (DingBean)acac.getBean("dingBean");
        System.out.println(dingBean.name);
    }
}

3 源码入口

3.1 启动类构造函数说明

org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>…)

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
	/*
	// this()方法中的重点代码
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	1.this()
	1.this()中看似只调用了两个方法，但是其实还有一个super()，super()中有各种受气的创建，比如：DefaultListableBeanFactory等
	1.2. new AnnotatedBeanDefinitionReader(this) 除了创建reader,初始化registry等最重要的一点还有向beanDefs中设置各种spring自定义的各种PostProcessor
	1.3. new ClassPathBeanDefinitionScanner(this)初始化扫描器
	*/
	this();
	/*
	2.register(componentClasses);//将自定定义的，并且传入到到启动容器中的配置类注册到BeanDefinition池中
	最重要方法： this.beanDefinitionMap.put(beanName, beanDefinition);
	*/
	register(componentClasses);
	/*
	扫描所有文件，拿到因该被spring容器管理的类，注册到BeanDefinition池中，再从池中取出，创建spring中的bean对象，并缓存
	下面进行重点解析
	*/
	refresh();
}

3.2 刷新方法说明(包含容器创建大部分功能，还有的功能在上面的构造方法中)

3.2.1 org.springframework.context.support.AbstractApplicationContext#refresh

重点关注方法：

  1. invokeBeanFactoryPostProcessors(beanFactory);//执行所有BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor
  2. registerBeanPostProcessors(beanFactory);// 将所有的 BeanPostProcessors 创建对象，放到单例池中；并且注册到beanfactory中（存在 private final List beanPostProcessors = new BeanPostProcessorCacheAwareList();）
  3. finishBeanFactoryInitialization(beanFactory);// 根据所有的beandefinition创建对象，放到单例池中
public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
		StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

		/*
		1. 设置容器激活标志，并初始化一些变量比如监听器容器等
		*/
		// Prepare this context for refreshing.
		prepareRefresh();

		/*
		2. 给spring容器设置序列化id，并返回容器(DefaultListableBeanFactory)
		*/
		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		/*
		向容器中添加postProsser
		并且注册（是不是一部分，没有具体来找）前面放在BeanDefinition池中的benadefinition(直接跳过一级缓存，二级缓存，进入三级缓存)，忽略一些接口
		*/
		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			/*
			什么也没有做，只是一个空方法，留待子类扩展
			*/
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
			
			/*

			说明：
				1）先执行所有的 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
				2）再执行 BeanFactoryPostProcessor#postProcessBeanFactory（这个先分成两大类，一种仅仅是BeanFactoryPostProcessor 还有一种是BeanDefinitionRegistryPostProcessor 因为BeanDefinitionRegistryPostProcessor implements BeanFactoryPostProcessor）
				3）每个右分成三种，没有继承排序接口，继承Ordered，继承 PriorityOrdered，执行顺序是PriorityOrdered,Ordered到没有继排序接口的
				4）防止重复执行，有一个 processedBeans 集合来保存beanName
			执行顺序：
				1）先执行传入的 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
				2）到BeanDefinations中找BeanDefinitionRegistryPostProcessor和PriorityOrdered，然后执行 postProcessBeanDefinitionRegistry
				3）到BeanDefinations中找BeanDefinitionRegistryPostProcessor和Ordered，然后执行 postProcessBeanDefinitionRegistry
				4）到BeanDefinations中找BeanDefinitionRegistryPostProcessor然后执行 postProcessBeanDefinitionRegistry
				5）所有在容器中找都会判断不能在processedBeans出现并且每次找到了也要放到processedBeans中
				5）然后执行BeanDefinitionRegistryPostProcessor#postProcessBeanFactory
				6）到容器中拿BeanFactoryPostProcessor
				7）循环，排除已经在processedBeans的，按照排序接口分类
				8）然后执行BeanFactoryPostProcessor#postProcessBeanFactory
			*/
			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			/*
			找到所有的BeanPostprocessors，
			1）放到单例池中；
			2）并且注册到beanfactory中（存在 private final List<BeanPostProcessor> beanPostProcessors = new BeanPostProcessorCacheAwareList();）
			*/
			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);
			beanPostProcess.end();

			/*
			初始化国际化相关bean（name必须是messageSource），如果有就用自己的，如果没有就用默认的（DelegatingMessageSource）
			*/
			// Initialize message source for this context.
			initMessageSource();

			/*
			初始化发布订阅模式中的发布者
			*/
			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();
			/*
			什么也没做，留给子类扩展
			*/
			// Initialize other special beans in specific context subclasses.
			onRefresh();
			
			/*
			初始化发布订阅模式中的订阅者
			并尝试发布一次（如果有事件）
			*/
			// Check for listener beans and register them.
			registerListeners();

			/*
			创建对象，比较重要，下面单独说
			*/
			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);
			
			// Last step: publish corresponding event.
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
			contextRefresh.end();
		}
	}
}

3.2.2 ConfigurationClassPostProcessor特别说明

ConfigurationClassPostProcessor 是 BeanDefinitionRegistryPostProcessor的实现类之一，在 postProcessBeanDefinitionRegistry方法中对传入的文件夹进行扫描，根据class对象生成BeanDefinition （包括解析各种注解，比如import等）

1）执行链路（从ConfigurationClassPostProcessor开始，到拿到class文件）：
    postProcessBeanDefinitionRegistry:247, ConfigurationClassPostProcessor (org.springframework.context.annotation)
        processConfigBeanDefinitions:331, ConfigurationClassPostProcessor (org.springframework.context.annotation)
            parse:175, ConfigurationClassParser (org.springframework.context.annotation)
                parse:207, ConfigurationClassParser (org.springframework.context.annotation)
                    processConfigurationClass:250, ConfigurationClassParser (org.springframework.context.annotation)
                        doProcessConfigurationClass:296, ConfigurationClassParser (org.springframework.context.annotation)
                            parse:132, ComponentScanAnnotationParser (org.springframework.context.annotation)
                                doScan:276, ClassPathBeanDefinitionScanner (org.springframework.context.annotation)
                                    findCandidateComponents:315, ClassPathScanningCandidateComponentProvider (org.springframework.context.annotation)
                                        scanCandidateComponents:429, ClassPathScanningCandidateComponentProvider (org.springframework.context.annotation)
2）简述过程
1.找到传入的配置文件，解析注解@ComponentScan 拿到传入的包名，
2.根据包名和classpath等，定位到文件夹，
3.找到文件下所有文件，封装成resource
4.根据resource和classlaod 通过asm框架，生成 MetadataReader （这里面有class，拿到了class,也就能拿到注解等了）
5.将MetadataReader根据条件（有没有某些注解等）转换成 BeanDefinition 缓存起来

3.3 对象创建说明(普通的没有引用的对象的创建)

说明：

  • org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization（调用链路实在太长，就不一个一个贴代码了，只说重要的地方调用)
  • 按照spring的bean的生命周期顺序来说明
  • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean（spring生命周期前半段创建对象～使用基本都逃不过这个方法）

下面按照生命周期以及调用生命周期的方法以及关键代码进行说明

  1. 构造方法
    推导构造方法的方法：
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance；
    上面方法中，如果我们的bean没有构造方法，会调用 return ctor.newInstance(argsWithDefaultValues);最终一步步点下去（比较简单，就没有一步步写了）调用如下方法：
    return ctor.newInstance(argsWithDefaultValues);
  2. 执行MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition方法
实现类功能
CommonAnnotationBeanPostProcessor解析注解@PostConstruct，@PreDestroy和@Resource
AutowiredAnnotationBeanPostProcessor解析注解@Autowrite和@Value
ApplicationListenerDetector记录当前beanDefination是不是单例
简单说明解析@Resources注解和@Autowrite注解
  • @Resource org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#buildResourceMetadata中会把复合的字段或方法组合成 ResourceElement 放到 List<InjectionMetadata.InjectedElement> elements中
  • @Autowrite org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata中会把字段或方法组合成 AutowiredFieldElement 放到 List<InjectionMetadata.InjectedElement> elements 中
  1. 放入三级缓存
    这个方法org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean中
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  2. 根据InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation判断要不要继续往下执行
实现类功能
ConfigurationClassPostProcessor扫描文件转换成BeanDefinition，前面有说过了
AnnotationAwareAspectJAutoProxyCreatoraop创建代理，到aop中具体说明
CommonAnnotationBeanPostProcessor@Resource 依赖注入，详情见下面
AutowiredAnnotationBeanPostProcessor@Autowrite 依赖注入，详情见下面

依赖注入用到的最终方法是java.lang.reflect.Field#set
重点在于怎么拿到该设置的值

  1. 调用InstantiationAwareBeanPostProcessor#postProcessProperties给需要依赖注入的字段设置属性（还是上面的几个实现类）,尤其是CommonAnnotationBeanPostProcessor，AutowiredAnnotationBeanPostProcessor
  2. BeanNameAware
  3. BeanClassLoaderAware
  4. BeanFactoryAware
  5. BeanPostProcessor#postProcessBeforeInitialization(@PostConstruct修饰的方法在InitDestroyAnnotationBeanPostProcessor中被调用，属于BeanPostProcessor)
  6. InitializingBean#afterPropertiesSet
  7. BeanPostProcessor#postProcessAfterInitialization
  8. 放入第一级缓存
  1. 销毁 先执行 加注解@PreDestroy的 DestructionAwareBeanPostProcessor#postProcessBeforeDestruction
  2. DisposableBean#destroy

3.4 CommonAnnotationBeanPostProcessor（@Resource拿依赖的调用链路）

/**
重要的功能是依赖注入    InstantiationAwareBeanPostProcessor#postProcessProperties
 */
 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

/**
这里循环到 CommonAnnotationBeanPostProcessor
*/
org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessProperties


/**
InjectionMetadata
*/
org.springframework.beans.factory.annotation.InjectionMetadata#inject


/**
AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement（CommonAnnotationBeanPostProcessor解析@Resource时创建的对象）
*/
org.springframework.beans.factory.annotation.InjectionMetadata.InjectedElement#inject

/**
CommonAnnotationBeanPostProcessor.ResourceElement
*/
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.ResourceElement#getResourceToInject

/**
CommonAnnotationBeanPostProcessor
*/
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#getResource

/**
CommonAnnotationBeanPostProcessor
*/
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#autowireResource

/**
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeanByName
*/
resolveBeanByName:461, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)

/**
AbstractBeanFactory
*/
org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class<T>)

3.5 AutowiredAnnotationBeanPostProcessor（@Autowired拿依赖的调用链路）

/**
重要的功能是依赖注入    InstantiationAwareBeanPostProcessor#postProcessProperties
 */
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

/**
这里循环到 AutowiredAnnotationBeanPostProcessor
*/
org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessProperties

/**
InjectionMetadata
*/
org.springframework.beans.factory.annotation.InjectionMetadata#inject

/**
AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement
（CommonAnnotationBeanPostProcessor解析@Autowrite时创建的对象）
*/
org.springframework.beans.factory.annotation.InjectionMetadata.InjectedElement#inject

/**
AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement
*/
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#resolveFieldValue

/**
DefaultListableBeanFactory
*/
org.springframework.beans.factory.config.AutowireCapableBeanFactory#resolveDependency(org.springframework.beans.factory.config.DependencyDescriptor, java.lang.String, java.util.Set<java.lang.String>, org.springframework.beans.TypeConverter)

/**
DefaultListableBeanFactory
*/
org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency

/**
DependencyDescriptor
*/
org.springframework.beans.factory.config.DependencyDescriptor#resolveCandidate

/**
AbstractBeanFactory
*/
org.springframework.beans.factory.BeanFactory#getBean(java.lang.String)

4 三级缓存说明

4.1 哪三级缓存，存的分别是什么

  • private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    第一级缓存，存放的是已经给变量赋值好的bean，拿出来就可以用的
  • private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    第二级缓存，存放的虽然是我们取出时的对象，但是并没有进行依赖注入
  • private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    第三级缓存，存放的是ObjectFactory
    大概是这么放的 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));(可以自己定义创建对象的细节，比如动态代理也是从这个方法进入的)

4.2 每一级缓存是什么时候放的

情况一：没有循环依赖（没有用到第二级缓存）
1.创建对象
2.组装成ObjectFactory，放到第三级缓存
3.给对象设置属性等操作
4.从第三级缓存中取出对象（删除第三级缓存），放入第一级缓存

情况二：有循环依赖（A与B相互引用）

// A
public class A{
	@Autowrite
	private B b;
}

// B
public class B{
	@Autowrite
	private A a;
}

1.创建对象A
2.将对象A组装成ObjectFactory，放到第三级缓存
3.给A对象设置属性值（需要对象B，但是对象B暂时不存在，所以没有办法设置，要去创建B）
4.创建对象B
5.将对象B组装成ObjectFactory，放到第三级缓存
6.给B设置属性值，（需要对象A，但是对象A存在与第三级缓存中，以ObjectFactory形式存在）
7.从三级缓存中取出对象A(经过SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference处理)，并存放到第二级缓存中
8.拿到第二级缓存中的A对象，给B对象设置属性值
9.B对象依赖注入结束，放到第一级缓存中
10.给A对象依赖注入结束，放到第一级缓存中

4.3 二级缓存足以解决循环依赖，为什么是三级缓存

1）首先第三级缓存中存放的是ObjectFactory，以便可以自己定制化创建对象，这种形式存在是必要的
2）如果存在代理，每次调用ObjectFactory.getObject()都会进行代理，生成一个新的代理对象
3）循环依赖中先创建的对象会有两次被取出，第一次是给后创建的对象赋值，第二次是移动到第一级缓存，这两次取出的对象要是同一个对象吧，但是从第三级缓存中取，每次取出的都是新建的代理对象。
4）总结，第二级缓存存在的含义既是存没有依赖注入完全的对象，也是暂存这个唯一的代理对象

dingkw1115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浅析Spring-kafka源码——消费者模型的实现
WannaRunning的博客
06-17 2416
在使用Spring-kafka时，一般都是通过使用@KafkaListener注解的方法来实现消息监听和消费。今天写一下基于这个注解实现的消费端模型和实现的原理。
Spring-IOC源码浅析（一）
qq_45731464的博客
05-07 134
Spring-IOC源码分析核心容器Web IOC容器初始化 核心容器 BeanFactor： Spring Bean的创建是一系列的Bean工厂，IOC容器为开发者管理容器之间的依赖关系提供了很多便利和基础服务，在Spring中有很多IOC容器的实现提供给用户选择和使用。其中BeanFactory作为最顶层的接口，定义了IOC的基本功能规范，其中有三个重要的子类，ListableBeanFactory、HierarchicalBeanFactory、AutowireCapableBeanFactory
Spring-IOC源码浅析
weixin_33858336的博客
09-29 69
试着把自己看源码对一些理解写下来 从相对宏观的角度去分析整个过程码 还是从经典的例子开始入手 private void applicationEntrance(){ ApplicationContext context = new FileSystemXmlApplicationContext("classpath:applicationContext.xml"); ...
Spring-IOC源码浅析（二）
images_whj的博客
12-23 830
由于常规使用方式是不会用到AnnotationConfigApplicationContext里面的scanner的，这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法。所以这里就不看scanner是如何被实例化的了。在这里又要说明下，以常规方式去注册配置类，此方法中除了第一个参数，其他参数都是默认值。把目光回到最开始，再分析第二行代码。到这里注册配置类也分析完毕了。
Spring-IOC源码浅析（四）
images_whj的博客
12-25 815
扩展了BeanFactoryPostProcessor，还有postProcessBeanFactory方法没有分析，这个方法是干嘛的，简单的来说，就是判断配置类是Lite配置类，还是Full配置类，如果是配置类，就会被Cglib代理，目的就是保证Bean的作用域。这里需要做一个补充说明，添加规则的时候，只是把具体的规则放入规则类的集合中去，规则类是一个函数式接口，只定义了一个虚方法的接口被称为函数式接口，函数式接口在java8的时候大放异彩，这里只是把规则方塞进去，并没有真正执行匹配规则。
Spring-IOC源码浅析（三）
images_whj的博客
12-25 850
这里有一个问题，为什么我自己写了个类，实现了BeanDefinitionRegistryPostProcessor接口，也打上了@Component注解，但是这里没有获得，因为直到这一步，Spring还没有完成扫描，扫描是在ConfigurationClassPostProcessor类中完成的，也就是下面第一个invokeBeanDefinitionRegistryPostProcessors方法。定义了一个Set，装载BeanName，后面会根据这个Set，来判断后置处理器是否被执行过了。
Spring---IOC原理浅析
爱上在路上
08-14 585
1、简介 IoC 容器：最主要是完成了对象的创建和依赖的管理注入等等。 所谓控制反转，就是把原先我们代码里面需要实现的对象创建、依赖的代码，反转给容器来帮忙实现。那么必然的我们需要创建一个容器，同时需要一种描述来让容器知道需要创建的对象与对象的关系。这个描述最具体表现就是我们可配置的文件。 具体描述IOC容器使用过程： IOC容器---水桶 BeanFactory---最
Spring源码-IOC之ClassPathXmlApplicationContext
orixixi的博客
01-09 976
实例化PathMatchingResourcePatternResolver，给属性resourcePatternResolver赋值给属性parent赋值，当父环境不为空是，合并父子环境获取环境，当环境为空时创建环境并初始化，给上下文属性environment赋值解析资源路径，如果存在占位符，则获取占位符的关联值，给上下文属性configLocations赋值无参考Spring核心讲解篇——ApplicationContext - 知乎 (zhihu.com)
Spring-IOC浅析
08-29 122
初始化项目 spring配置文件如下 <bean id="student" name="STUDENT" class="com.simon.entity.Student"> <property name="teacher" ref="teacher...
老王读spring-ioc源码分析&测试代码.zip
11-19
老王读 Spring IoC 系列文章的源码分析&测试代码 Spring IoC 源码分析，帮助大家学习 Spring 源码，更加了解 Spring 的底层 博客专栏地址：https://blog.csdn.net/wang489687009/category_11269905.html
maven-spring-ioc
08-07
**Spring IoC 框架详解** Spring框架是Java开发中的一个核心组件，它提供了许多功能，其中最重要的一项就是Inversion of Control（IoC），也称为Dependency Injection（DI）。IoC容器是Spring的核心，它负责管理...
Spring-IOC丐版
02-26
在这个"Spring-IOC丐版"的源码中，我们可以看到一个简化的IOC容器的实现，可能包括以下几个部分： 1. **Bean定义**: 表示Bean的基本信息，包括类名、属性、依赖等。这些信息通常会从XML或注解中解析得到。 2. **...
coco-spring-ioc
04-16
在“coco-spring-ioc-master”中，我们可以找到对应的Bean工厂实现，了解其如何加载配置信息，以及如何根据配置创建Bean。 3. **依赖注入**：是IOC的核心，通过配置文件或注解指定Bean之间的依赖关系。在“coco-...
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 150
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
SpringBoot添加密码安全配置以及Jwt配置
最新发布
qq_64468032的博客
07-25 487
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
spring-from表单
weixin_51482243的博客
07-22 865
2.Controller定义的接口指定consumes，produces对应的是客户端请求header的Content-Type，Accept；标记在方法上,对应接口的第2层地址；500是请求头Accept=text/plain,接口代码produces=MediaType.TEXT_PLAIN_VALUE,但代码响应是某类的对象;3.面试题/接口文档-要求请求参数是int类型，测试请求参数时还是字符串，但开发的代码需要类型转换，如@RequestParam(name="xx")Integer xx,
Spring Task详解
SRY12240419的博客
07-24 429
Spring Task是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑
Spring-IOC
11-13
Spring-IOC是Spring框架的核心部分之一，它是一种设计模式，全称为Inversion of Control（控制反转）。它通过将对象的创建、依赖关系的管理和对象的生命周期交给Spring容器来实现，从而降低了组件之间的耦合度，提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值