Spring IoC容器

最新推荐文章于 2024-07-06 08:48:47 发布
最新推荐文章于 2024-07-06 08:48:47 发布
阅读量252 收藏
点赞数
分类专栏： Spring源码系列 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013857458/article/details/108723083
版权
Spring IoC容器

依赖反转（依赖注入）：IoC亦称“依赖倒置原理”（ Dependency Inversion Principle）

  • 对象的引用或依赖关系的管理由具体的对象来完成，会导致代码的高度耦合和可测试性降低
  • 对象封装了数据和对数据的处理，对象的依赖关系常常体现在对数据和方法的依赖上

控制反转是关于一个对象如何获取它所依赖的对象的引用，反转是指责任的反转。
通过使用IoC容器，对象依赖关系的管理被反转了，转到IoC容器中来了，对象之间的相互依赖关系由IoC容器进行管理，并由Ioc容器完成对象的注入。

注：依赖注入是可以递归的，对象被逐层注入。

POJO和JavaBean的区别

  • POJO是指那些没有从任何类继承、也没有实现任何接口，更没有被其它框架侵入的java对象，用于数据的临时传递，它只能装载数据， 作为数据存储的载体，而不具有业务逻辑处理的能力。
  • JavaBean 是一种JAVA语言写成的可重用组件，javabean当中除了和POJO一样外，还可以有其它的业务处理方法。

依赖注入的方式：

  • 接口注入
  • setter注入
  • 构造器注入

Spring 通过定义BeanDefinition来管理基于Spring的应用中的各种对象以及他们之间的相互依赖关系，BeanDefinition抽象了我们对Bean的定义，是让容器起作用的主要数据类型。

Scope

  1. singleton 作用域
    当一个bean的 作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例
  2. prototype
    prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的 getBean()方法）都会产生一个新的bean实例
  3. request
    request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
  4. session
    session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
  5. global session
    global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。
Spring 注意点
  • <context:annotationconfig />
    将隐式地向Spring容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、 PersistenceAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor
  • <context:component-scan />让Bean定义注解工作起来
    值得注意的是<context:component-scan />配置项不但启用了对类包进行扫描以实施注释驱动Bean定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan />后，就可以将<context:annotation-config />移除了。
Spring IoC容器实现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZAfqGcCN-1600729980532)(./1527979863459.png)]

Spring IoC容器设计

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pyU8vCJk-1600729980535)(./1479347643871.png)]

  1. BeanFactory：提供的是最基本的IoC容器的功能，定义了IoC容器最基本的形式
  2. 使用IoC容器时的几个步骤：
  • 创建 IoC配置文件的抽象资源，这个抽象资源包含了BeanDefinition的定义信息
  • 创建一个BeanFactory，默认的是DefaultBeanDefinitionFactory
  • 创建一个载入BeanDefinition的读取器，比如使用 XMLBeanDefinitionReader来载入XML文件形式的BeanDefinition，通过一个回调配置给BeanFactory
  • 从定义好的资源位置读取配置信息，具体的解析过程由 XMLBeanDefinitionReader来完成。完成整个载入和注册Bean定义之后，需要的IoC容器就建立起来了。
BeanDefinition

一个BeanDefinition描述了一个bean的实例，包括属性值，构造方法参数值和继承自它的类的更多信息。BeanDefinition仅仅是一个最简单的接口，主要功能是允许BeanFactoryPostProcessor 例如PropertyPlaceHolderConfigure 能够检索并修改属性值和别的bean的元数据。

  1. BeanDefinition的继承关系

  • 父接口：AttributeAccessor, BeanMetadataElement

  • 子接口： AnnotatedBeanDefinition

  • 子类：AbstractBeanDefinition, AnnotatedGenericBeanDefinition, ChildBeanDefinition, GenericBeanDefinition, RootBeanDefinition, ScannedGenericBeanDefinition

    1）AttributeAccessor 接口定义了最基本的对任意对象的元数据的修改或者获取，主要方法有：

      String[] attributeNames() 
  Object getAttribute(String name) 
  boolean hasAttribute(String name) 
  Object removeAttribute(String name) 
  void setAttribute(String name, Object value)

2）BeanMetadataElement 接口提供了一个getResource()方法,用来传输一个可配置的源对象。
3）3 BeanDefinition 的抽象类 AbstractBeanDefinition

	public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
	        implements BeanDefinition, Cloneable {
	}

其中BeanMetadataAttributeAccessor接口既实现了BeanMetadataElement接口提供的getResource()方法也提供了AttributeAccessorSupport 针对属性的增删改查，如上AttributeAccessor的方法。

	public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {
	}

4）MutablePropertyValues：PropertyValues接口的默认实现，支持对属性的简单操作，为构造方法提供深度复制和使用map获取构造的支持。

5） BeanDefinition实现类ChildBeanDefinition, GenericBeanDefinition, RootBeanDefinition

  • ChildBeanDefinition是一种bean definition，它可以继承它父类的设置，即ChildBeanDefinition对RootBeanDefinition有一定的依赖关系。
  • GenericBeanDefinition是一站式的标准bean definition，除了具有指定类、可选的构造参数值和属性参数这些其它bean definition一样的特性外，它还具有通过parenetName属性来灵活设置parent bean definition。
  • 一个RootBeanDefinition定义表明它是一个可合并的bean definition：即在spring beanFactory运行期间，可以返回一个特定的bean。

6）Bean的包装BeanWrapper

  • 作用：提供对标准javabean的分析和操作方法：单个或者批量获取和设置属性值，获取属性描述符，查询属性的可读性和可写性等。支持属性的嵌套设置，深度没有限制。

  • 继承关系：

      public interface BeanWrapper extends ConfigurablePropertyAccessor {
  }
  
  public interface ConfigurablePropertyAccessor extends PropertyAccessor, PropertyEditorRegistry, TypeConverter {
  }

7）BeanWrapper的实现类：BeanWrapperImpl

  • BeanWrapperImpl作用：可以根据需求，将集合与数组的值转换到对应目标对象的集合和数组。自定义的属性编辑器通过属性编辑器的setValue，setAsText方法实现上述的转换功能。
  • BeanWrapperImpl 默认的PropertyEditor的实现如下：(PropertyEditorRegistrySupport.java)
IoC容器的初始化过程

IoC容器的初始化由AbstractApplicationContext的refresh()方法来启动，这个启动包括BeanDefinition的 Resource定位、载入和注册三个基本过程

  1. Resource定位：Resource定位指的是BeanDefinition的资源定位，它由ResourceLoader通过统一的Resource接口来完成，这个Resource对各种形式的BeanDefinition的使用提供了统一接口。
  2. BeanDefinition载入：载入过程就是把用户定义好的Bean表示成IoC容器内部的数据结构BeanDefinition。BeanDefinition实际上是POJO对象在IoC容器中的抽象，通过BeanDefinition定义的数据结构，使IoC容器能够方便的对POJO对象也就是Bean进行管理。
  3. 向IoC容器注册BeanDefinition：调用 BeanDefinitionRegistry接口的实现来完成注册，把载入过程中解析得到的BeanDefinition注入到IoC容器中额一个ConcurrentHashMap中，IoC容器就是通过这个ConcurrentHashMap来持有这些BeanDefinition数据的。

注：Bean定义的载入和依赖注入是两个独立的过程，依赖注入一般发生在应用第一次通过getBean向容器索取Bean的时候。

	public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver{}
  1. BeanDefinition的Resource定位
    以FileSystemXmlApplicationContext为例分析，FileSystemXmlApplicationContext的继承关系
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0qltlsNH-1600729980542)(./1479371820333.png)]

1）FileSystemXmlApplicationContext

  • 构造方法：父类AbstractApplicationContext 中初始化this.resourcePatternResolver 为PathMatchingResourcePatternResolver
  • setConfigLocations：父类AbstractRefreshableConfigApplicationContext中的方法，对this.configLocations赋值
  • refresh：父类AbstractApplicationContext中的方法，调用obtainFreshBeanFactory
  • obtainFreshBeanFactory：父类AbstractApplicationContext中的方法，调用 refreshBeanFactory方法
  • refreshBeanFactory：父类AbstractRefreshableApplicationContext中的方法，创建默认的IoC容器DefaultListableBeanFactory，调用loadBeanDefinitions
  • loadBeanDefinitions：父类AbstractXmlApplicationContext中的方法，创建XmlBeanDefinitionReader，调用重载方法loadBeanDefinitions(XmlBeanDefinitionReader reader)，在重载方法中调用getConfigLocations，然后调用XmlBeanDefinitionReader的loadBeanDefinitions方法
AbstractApplicationContext的refresh 方法
  • obtainFreshBeanFactory：创建BeanFactory，并完成BeanDefinition的载入、解析、注册
  • prepareBeanFactory：设置BeanFactory的前置处理
  • postProcessBeanFactory：设置BeanFactory的后置处理
  • invokeBeanFactoryPostProcessors：调用BeanFactory的后处理器，这些后处理器是在Bean定义中向容器注册的
  • registerBeanPostProcessors：注册Bean的后处理器，在Bean创建过程中调用
  • initMessageSource：对上下文中的消息源进行初始化
  • initApplicationEventMulticaster：初始化上下文中的事件机制
  • onRefresh：初始化其他特殊的Bean
  • registerListeners：检查监听Bean并且将这些Bean向容器注册
  • finishBeanFactoryInitialization：实例化所有的（non-lazy-init）单件
  • finishRefresh：发布容器，结束refresh过程

2）XmlBeanDefinitionReader

  • loadBeanDefinitions(String… locations)：父类AbstractBeanDefinitionReader中的方法，遍历调用重载方法loadBeanDefinitions(String location, Set<Resource> actualResources)
  • getResourceLoader：获取资源定位加载器，这里即FileSystemXmlApplicationContext（继承自DefaultResourceLoader）
  • 调用ResourcePatternResolver 实例的getResources方法，即AbstractApplicationContext中的实现this.resourcePatternResolver.getResources(locationPattern)，resourcePatternResolver即容器构造方法中初始化的PathMatchingResourcePatternResolver
  • PathMatchingResourcePatternResolver中的getResources实现中调用DefaultResourceLoader的getResource
  • DefaultResourceLoader的getResource实现中调用FileSystemXmlApplicationContext的getResourceByPath
  • FileSystemXmlApplicationContext的getResourceByPath 创建FileSystemResource对象
  • loadBeanDefinitions(Resource resource)：获取配置文件资源定位对象输入流封装之后调用doLoadBeanDefinitions方法
  • doLoadBeanDefinitions：调用doLoadDocument获取BeanDefinition定义配置文件的Document对象，调用registerBeanDefinitions(Document doc, Resource resource)解析、注册BeanDefinition
  • registerBeanDefinitions：启动对BeanDefinition解析过程，创建BeanDefinitionDocumentReader，XmlReaderContext、DefaultNamespaceHandlerResolver，然后调用BeanDefinitionDocumentReader的registerBeanDefinitions方法

3）DefaultBeanDefinitionDocumentReader

  • registerBeanDefinitions：调用doRegisterBeanDefinitions
  • doRegisterBeanDefinitions：创建BeanDefinitionParserDelegate解析器委托，调用parseBeanDefinitions
  • parseBeanDefinitions：获取XML配置的子节点，然后遍历解析各子节点，如果命名空间是http://www.springframework.org/schema/beans的调用parseDefaultElement方法，否则调用delegate.parseCustomElement(ele);
  • parseDefaultElement：
    • processBeanDefinition：通过BeanDefinitionParserDelegate获取BeanDefinitionHolder，然后通过BeanDefinitionReaderUtils.registerBeanDefinition注册BeanDefinition

普通的Bean定义解析是在 DefaultBeanDefinitionDocumentReader的processBeanDefinition方法中委托BeanDefinitionParserDelegate完成的

BeanDefinitionParserDelegate
  • parseBeanDefinitionElement方法创建BeanDefinitionHolder
  • parseBeanDefinitionElement重载方法中创建AbstractBeanDefinition
    • createBeanDefinition：创建GenericBeanDefinition：
    • parseConstructorArgElements：解析<Bean>构造函数设置
    • parsePropertyElements：解析<Bean>的property设置
    • 。。。。

4）NamespaceHandlerSupport
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YvJ3pizy-1600729980549)(./1479447820130.png)]

  • registerBeanDefinitionParser：注册解析器
  • findParserForElement：查找元素解析器
  • parse：调用解析器的parse方法

5）AbstractBeanDefinitionParser 解析器抽象类

  • parse：
    • 调用子类AbstractSingleBeanDefinitionParser的parseInternal方法获取AbstractBeanDefinition
    • parseInternal：创建BeanDefinitionBuilder、GenericBeanDefinition，获取解析元素的Class 对象，通过工厂方法设置BeanDefinition的属性，调用子类的 doParse方法设置BeanDefinition的属性并返回BeanDefinition
    • 处理别名，id
    • 创建一个BeanDefinitionHolder来持有BeanDefinition
    • registerBeanDefinition：注册BeanDefinition
      • 调用BeanDefinitionReaderUtils.registerBeanDefinition注册BeanDefinition到IoC容器，BeanDefinitionReaderUtils中又调用DefaultListableBeanFactory的注册方法registerBeanDefinition注册BeanDefinition、registerAlias方法注册别名
    • 触发完成注册事件

6）DefaultListableBeanFactory

  • registerBeanDefinition：
    • this.beanDefinitionMap.put(beanName, beanDefinition);
    • this.beanDefinitionNames.add(beanName);
    • this.manualSingletonNames.remove(beanName);

7）invokeBeanFactoryPostProcessors 调用IoC容器的后处理器

  • PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors
各类解析器
  1. ComponentScanBeanDefinitionParser 扫描context:component-scan
  • parse:
    + 获取扫描包basePackages
    + 创建ClassPathBeanDefinitionScanner类路径下的扫描器，父类构造方法中调用registerDefaultFilters方法添加AnnotationTypeFilter(Component.class)过滤器
    + 调用ClassPathBeanDefinitionScanner的 doScan方法
    - 调用父类ClassPathScanningCandidateComponentProvider的findCandidateComponents方法，返回Set<BeanDefinition>
    + 获取扫描包下的所有.class文件
    + 遍历.class文件
    + 创建SimpleMetadataReader，构造方法中创建ClassReader、AnnotationMetadataReadingVisitor(继承自ClassVisitor)，调用classReader.accept 方法。classReader跟classVisitor是asm提供的字节码访问类，从字面上就能看出来，其使用了visitor模式，事实上就是classReader.accept的时候会遍历整个类的字节码，遍历的时候如果碰到method，就会调用ClassVisitor中定义的visitMethod，碰到field，就会调用visitField（同样是回调）。
    + 判断是否是定义的注解，肯定则创建ScannedGenericBeanDefinition
    - 遍历Set<BeanDefinition>
    - postProcessBeanDefinition：处理BeanDefinition的一些赋值
    - AnnotationConfigUtils.processCommonDefinitionAnnotations：处理注解，依赖值等
    - 创建BeanDefinitionHolder持有BeanDefinition
    - registerBeanDefinition：注册BeanDefinition，BeanDefinitionReaderUtils.registerBeanDefinition
注：
  • AbstractBeanDefinition：描述类大部分BeanDefinition的属性
  • BeanDefinition的载入分为两部分：
    • 通过调用XML的解析器得到 Document对象
    • 按照Spring的Bean规则进行解析， DefaultBeanDefinitionDocumentReader
IoC容器的依赖注入

BeanFactory的getBean是触发依赖注入的入口，最终调用doGetBean来实现

1）DefaultListableBeanFactory

  • doGetBean：
    • getSingleton：先从缓存中获取Bean，处理那些已经被创建过的单件模式的Bean
    • getObjectForBeanInstance：完成FactoryBean的相关处理，以取得FactoryBean的生产结果
    • 检查是否能在当前的BeanFactory中取到需要的Bean，取不到则到双亲BeanFactory中取
    • getMergedLocalBeanDefinition：根据Bean的名字得到BeanDefinition
    • String[] dependsOn = mbd.getDependsOn()：获取当前Bean的所有依赖Bean，这样会触发getBean的递归调用，直到取到一个没有任何依赖的Bean为止
    • getSingleton：通过调用ObjectFactory的回调方法getObject方法调用createBean创建 Singleton bean的实例

2）AbstractAutowireCapableBeanFactory

  • createBean：调用doCreateBean
  • doCreateBean：

    • BeanWrapper用来持有创建出来的Bean

    • createBeanInstance：创建Bean

      • instantiateUsingFactoryMethod：使用工厂方法对Bean进行实例化
      • instantiateBean：（最常见）使用默认构造函数对Bean进行实例化
        • CglibSubclassingInstantiationStrategy：默认的实例化策略，即使用CGLIB对Bean进行实例化
        • SimpleInstantiationStrategy：Spring用来生成Bean的默认类，提供了两种实例化Java对象的方法，一种是使用了JVM的反射功能的BeanUtils；另一种是通过使用CGLIB生成
          • instantiate：
            • BeanUtils.instantiateClass：BeanUtils实例化通过 Constructor来实例化Bean
            • instantiateWithMethodInjection：使用CGLIB来实例化Bean

    • populateBean：依赖注入入口

      • mbd.getPropertyValues()：获取BeanDefinition中的properties
      • autowireByName、autowireByType：对Autowire注入的处理，可以根据Bean的名字和类型完成注入
      • applyPropertyValues：对属性进行注入
      • BeanDefinitionValueResolver：resolveValueIfNecessary方法完成对BeanDefinition的解析

    • initializeBean：对Bean初始化

ApplicationContext和Bean的初始化和销毁
IoC容器中Bean的生命周期
  • Bean实例的创建
  • 为Bean实例设置属性
  • 调用Bean的初始化方法
  • 应用可以通过IoC容器使用
  • 当容器关闭时，调用Bean的销毁方法
初始化方法

initializeBean（AbstractAutowireCapableBeanFactory）

  • invokeAwareMethods：调用一系列Aware接口实现
  • applyBeanPostProcessorsBeforeInitialization
  • invokeInitMethods：调用InitializingBean接口实例的afterPropertiesSet方法
  • applyBeanPostProcessorsAfterInitialization
lazy-init属性和预实例化

refresh（AbstractApplicationContext）

  • finishBeanFactoryInitialization：对lazy-init属性处理
  • preInstantiateSingletons（DefaultListableBeanFactory）：调用getBean实例化
FactoryBean的实现

FactoryBean为应用生成需要的对象，这些对象往往是经过特殊处理的，FactoryBean机制可以提供一个很好的封装机制，比如封装Proxy、RMI、JNDI等

AbstractBeanFactory
  • doGetBean中
  • sharedInstance = createBean(beanName, mbd, args)生成Bean实例，
  • bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 如果Bean实现了FactoryBean接口，则用FactoryBean 生产Bean实例
BeanPostProcessor的实现

BeanPostProcessor Bean的后置处理器是一个监听器，可以触发容器触发的事件，将它向IoC容器注册后，容器中管理的Bean具备了接收IoC容器事件回调的能力。

在initializeBean方法中实现

autowiring（自动依赖装配）的实现

IoC依赖关系管理方法：

  • 通过BeanDefinition的属性值和构造方法以显示的方式
  • 自动依赖装配方式
    在自动装配中，不需要对Bean的属性做显式的依赖关系声明，只需要配置好autowiring属性，IoC容器会根据这个属性的配置，使用反射自动查找属性的类型或名字，然后基于属性的类型和名字自动匹配IoC容器中的Bean，从而自动的完成依赖注入
Bean的依赖检测

Spring通过特定的 aware接口 来完成在Bean中直接操作IoC容器

  • BeanNameAware：可以在Bean中得到它在IoC容器中的Bean实例名称
  • BeanFactoryAware：在Bean中得到Bean所在的IoC容器，从而直接在Bean中使用更多的IoC容器服务
  • ApplicationContextAware：在Bean中得到Bean所在的应用上下文
  • MessageSourceAware：在Bean中可以得到消息源
  • ApplicationEventPublisherAware：在Bean中得到应用上下文的事件发布器，从而可以在Bean中发布应用上下文事件
  • ResourceLoaderAware：在Bean中得到ResourceLoader，从而在Bean中使用ResourceLoader加载外部对应的Resource资源
附录
常见命名空间初始化

  • ContextNamespaceHandler

      public void init() {
  		registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
  		registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
  		registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
  		registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
  		registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
  		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
  		registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
  		registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
  	}

  • AopNamespaceHandler

      public void init() {
  		// In 2.0 XSD as well as in 2.1 XSD.
  		registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
  		registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
  		registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
  
  		// Only in 2.0 XSD: moved to context namespace as of 2.1
  		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
  	}

  • TaskNamespaceHandler

      public void init() {
  		this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
  		this.registerBeanDefinitionParser("executor", new ExecutorBeanDefinitionParser());
  		this.registerBeanDefinitionParser("scheduled-tasks", new ScheduledTasksBeanDefinitionParser());
  		this.registerBeanDefinitionParser("scheduler", new SchedulerBeanDefinitionParser());
  	}

  • MvcNamespaceHandler

      public void init() {
  		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
  		registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
  		registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
  		registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
  		registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
  		registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
  		registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
  		registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
  		registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
  		registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
  		registerBeanDefinitionParser("velocity-configurer", new VelocityConfigurerBeanDefinitionParser());
  		registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
  		registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
  		registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
  	}

  • UtilNamespaceHandler

      public void init() {
  		registerBeanDefinitionParser("constant", new ConstantBeanDefinitionParser());
  		registerBeanDefinitionParser("property-path", new PropertyPathBeanDefinitionParser());
  		registerBeanDefinitionParser("list", new ListBeanDefinitionParser());
  		registerBeanDefinitionParser("set", new SetBeanDefinitionParser());
  		registerBeanDefinitionParser("map", new MapBeanDefinitionParser());
  		registerBeanDefinitionParser("properties", new PropertiesBeanDefinitionParser());
  	}
META-INF/spring.handlers（Spring 命名空间处理器，多个jar下）

  • http://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler,

  • http://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.MvcNamespaceHandler,

  • http://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler,

  • http://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler,

  • http://www.springframework.org/schema/websocket=org.springframework.web.socket.config.WebSocketNamespaceHandler,

  • http://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler,

  • http://www.springframework.org/schema/oxm=org.springframework.oxm.config.OxmNamespaceHandler,

  • http://www.springframework.org/schema/jdbc=org.springframework.jdbc.config.JdbcNamespaceHandler,

  • http://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler,

  • http://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler,

  • http://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler,

  • http://www.springframework.org/schema/jms=org.springframework.jms.config.JmsNamespaceHandler,

  • http://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler,

  • http://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler,

  • http://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler

lhrimperial
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IoC 容器
沈荣荣的博客
12-20 97
IoC 容器 Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans，我们将在下一章中进行讨论。 通过阅读配置元数据提供的指令，容器知道对哪些对象进行实例化，配置和组装。配置元数据可以通过 XML，Java 注释或 Java 代码来表示。下图是 Spring 如何工作的高级视图。 Spring IoC 容器利用 Ja...
Spring源码深入阅读AnnotationConfigApplicationContext
热门推荐
旭旭1998的博客
09-20 7万+
一直很好奇代码 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SimpleBeanConfig.class);运行的时候，spring容器做了什么事情，为了搞清楚，我要看一看Spring源码剖析一下。 AnnotationConfigApplicationContext的Class构造方法有三行代码如下，当然是进去看一看了 public AnnotationConfigApplicati
SpringBoot-yaml（在配置文件中设置多个对象）
weixin_44783506的博客
08-26 5397
SpringBoot 配置文件 SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的 application.properties 语法结构 ：key=value application.yml 语法结构 ：key：空格 value **配置文件的作用 ：**修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了； 比如我们可以在配置文件中修改Tomcat 默认启动的端口号！测试一下！ server.port=8081 ya
springboot+mybatis实现一对一，一对多
极客鼠之家
08-09 575
一个学生对应多门科目成绩。
Spring Data JPA一对多关联保存到数据库外键为空
Apple South的博客
03-21 9149
今天碰到一个问题，在使用Spring Data JPA一对多关联时候保存到数据库，数据都保存了，但是外键的值为空！ 原因：实体类配置关联关系后还要在保存的时候体现出关联性。 PS:如果有看不懂的可以给我留言，这个问题我搞了半天，哎 多的一方： @ManyToOne @JoinColumn(name = "notify_id") private Notify notify; 一的一...
SpringBoot中使用jpa实现一对多(或者多对一)的处理(纯注解的实现方式)
编程学习者的博客
11-01 5996
当前环境：idea、springboot 1.简介 由于要求需要使用springboot中使用jpa来简化开发，但是对于一对多或者多对一的关系还是不够了解(由于是使用注解版的)。 所以这里使用了：一个学生对应一个班级，但是一个班级中具有多个学生，所以可以理解为：一个班级中具有一个许多学生(一个班级中具有一个学生集合)，一个学生属于一个班级 2.编写数据库 classes班级表中表结构： 学生表u...
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
Spring实现一个简单的SpringIOC容器
08-30
本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计模式，它将对象的创建和管理从对象本身转移到一个外部容器，即IOC容器。Spring的IOC容器通过读取配置文件（如...
手写一个SpringIoc容器
04-12
本项目"手写一个SpringIoc容器"旨在模仿Spring的IOC（Inversion of Control，控制反转）功能，帮助开发者深入理解Spring的工作原理，提升对依赖注入（Dependency Injection）模式的认识。 在实现自定义的Spring IOC...
Spring boot整合Mybatis实现级联一对多CRUD操作的完整步骤
08-25
主要给大家介绍了关于Spring boot整合Mybatis实现级联一对多CRUD操作的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
spring Ioc容器配置
04-19
spring Ioc容器配置 IOC容器数据源配置 <!-- 配置数据源 --> destroy-method="close"> <value>org.gjt.mm.mysql.Driver <value>jdbc:mysql://localhost:3306/demo <value>root ...
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
spring boot Jpa 一对多关系维护 @OneToMany
u013185759的博客
12-11 6964
     业务中经常会出现对象有一对多的关系，如 小明有多张银行等。      表结构如下:      注意这里我没有指定外键关系。      如果要持久化这些对象，按照以往的做法先生成小明，赋予ID，再将这个ID设置为在银行卡的外键。      但是JPA指定了更为方便的做法。      从生成实体类开始(我使用的是IDEA) 1.添加数据源       2.生成实体类 ...
Spring Boot JPA级联查询【一对多、多对一】
u014713873的博客
05-24 8170
一、数据准备 在管理系统中，角色和用户是典型一对多关系，一个角色可以分配给多个用户，一个用户对应一个角色。准备两个实体类TestRole、TestUser类，并在数据库建好对应表结构z_test_roles、z_test_users两张表。 @Entity @Getter @Setter @Table(name = "z_test_roles") public class TestRole implements Serializable { @Id @Column(na...
SpringBoot操作MongoDB实现批量的插入或保存
鸟人的博客
07-05 3778
除了一般的MySQL中我们经常会用到批量插入或保存，此外，在大数据领域我们还常常还用到MongoDB，那么对于MongoDB怎么实现批量插入或保存呢？下面来直接看下代码实现了MongoDB批量插入或保存到数据库的功能，其中如果根据主键存在，就更新，不存在就插入 注意：下面的代码不能丢...............
Spring boot + mybatis resultMap高级映射(一对一、一对多、多对多)
SaQiMa1的博客
06-13 1万+
application.properties配置文件############################################ ## MySQL数据库连接 ############################################ spring.datasource.url = jdbc:mysql://localhost:3306/dongsuo_test?useU...
springboot第16集：一对多，多对一，SQL缓存
程序员哆啦A梦，蓝胖子
05-04 819
createtableteacher( idint(10)notnull, namevarchar(30)defaultnull, primarykey(id) )engine=innodbdefaultcharset=utf8 insertintoteacher(id,name)values(1,'jeskson'); createt...
springboot基于Java的超市进销存系统+ LW+ PPT+源码+讲解
最新发布
u014445459的博客
07-06 654
操作的多样性也变高了。由此可见，本系统在操作上是可行的。软件测试的方法有好几种，但目前主要采用的是包括以功能为主要测试方向的黑盒测试以及以逻辑为主要测试方向的白盒测试，这是两种不同的测试方法，针对的测试侧重点不同，本课题根据实际需求情况，选择以功能为主要的黑盒测试方法，同时测试是要遵循一定的规则来执行的，一个测试要执行其执行的依据一般是由测试用例来规定的，而测试用例一般是依据需求或说明书来综合制定的，测试在硬件出厂前是十分重要的一个过程，本课题由于时间和精力的关系，选择以实现的功能作为测试要点来进行测试。
spring ioc容器
03-31
Spring IOC容器是Spring框架的核心部分，它是一个容器，用于存储和管理应用程序中的Java对象。IOC是Inversion of Control（控制反转）的缩写，是一种设计模式，它将应用程序的控制权从应用程序代码中转移到容器中。在Spring框架中，IOC容器负责创建、装配和管理应用程序中的对象，从而实现了应用程序的松耦合和可维护性。Spring IOC容器的主要作用如下： 1. 创建和管理对象：Spring IOC容器负责创建和管理应用程序中的对象，这些对象可以是普通的Java对象、JavaBean、服务、数据源等。 2. 装配对象：Spring IOC容器负责将应用程序中的对象装配到相应的位置，使得对象之间可以相互协作，实现应用程序的业务逻辑。 3. 控制对象的生命周期：Spring IOC容器负责管理对象的生命周期，包括对象的创建、初始化、销毁等。 4. 提供依赖注入：Spring IOC容器可以提供依赖注入功能，将对象之间的依赖关系注入到对象中，使得对象之间的关系更加松耦合。 Spring IOC容器有两种实现方式：BeanFactory和ApplicationContext。BeanFactory是Spring IOC容器的基础实现，提供了最基本的IOC功能，而ApplicationContext是BeanFactory的拓展，提供了更多的功能，如国际化支持、事件机制等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值