spring(一)简介及IOC容器

最新推荐文章于 2024-06-23 00:14:41 发布
最新推荐文章于 2024-06-23 00:14:41 发布
阅读量913 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring 从入门到放弃 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37256896/article/details/81947744
本文介绍了Spring框架的核心概念，包括依赖注入、AOP、模块化结构等，并详细解释了Spring Bean的生命周期、作用域以及配置方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

目录

Spring

为什么需要Spring FrameWork

体系结构

核心容器

数据访问/集成

Web

其他

主要有七大模块

IOC 容器

Spring Bean

依赖注入（DI）

自动装配Bean

注解代替xml

Spring

为什么需要Spring FrameWork

当已经存在许多开放源代码（和专有）J2EEframework时，我们为什么还需要Spring Framework？ 因为诸多原因让Spring变得独特：它定位的领域是许多其他流行的framework没有的。

Spring致力于提供一种方法管理你的业务对象。

Spring是全面的和模块化的。

Spring有分层的体系结构，这意味着你能选择使用它孤立的任何部分，它的架构仍然是内在稳定的。因此从你的学习中，你可得到最大的价值。例如，你可能选择仅仅使用Spring来简单化JDBC的使用，或用来管理所有的业务对象。它的设计从底部帮助你编写易于测试的代码。

Spring是用于测试驱动工程的理想的framework。

Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。可以降低开发企业应用的复杂程度，以IoC(控制反转)和AOP(面向切面编程)两种技术为基础简化了企业开发的复杂性，方便解耦，简化开发 Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理 AOP 编程的支持 Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支持 只需要通过配置就可以完成对事务的管理，而无需手动编程 方便程序的测试 Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序 方便集成各种优秀框架 Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、 MyBatis、Quartz 等）的直接支持 降低 JavaEE API 的使用难度 Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装， 使这些 API 应用难度大大降

体系结构

Spring 有可能成为所有企业应用程序的一站式服务点，然而，Spring 是模块化的，允许你挑选和选择适用于你的模块，不必要把剩余部分也引入。 ​ Spring 框架提供约 20 个模块，可以根据应用程序的要求来使用。

核心容器

核心容器由spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring表达式语言，Spring Expression Language）等模块组成，它们的细节如下：

  • spring-core模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。

  • spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。

  • context模块建立在由core和 beans 模块的基础上建立起来的，它以一种类似于JNDI注册的方式访问对象。Context模块继承自Bean模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过Servelet容器）等功能。Context模块也支持Java EE的功能，比如EJB、JMX和远程调用等。ApplicationContext接口是Context模块的焦点。spring-context-support提供了对第三方库集成到Spring上下文的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。

  • spring-expression模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是JSP2.1规范中定义的统一表达式语言的扩展，支持set和get属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从Spring IoC容器检索对象，还支持列表的投影、选择以及聚合等。。

数据访问/集成

  • 数据访问/集成层包括 JDBC，ORM，OXM，JMS 和事务处理模块，它们的细节如下： ​ （注：JDBC=Java Data Base Connectivity，ORM=Object Relational Mapping，OXM=Object XML Mapping，JMS=Java Message Service）

  • JDBC 模块提供了JDBC抽象层，它消除了冗长的JDBC编码和对数据库供应商特定错误代码的解析。

  • ORM 模块提供了对流行的对象关系映射API的集成，包括JPA、JDO和Hibernate等。通过此模块可以让这些ORM框架和spring的其它功能整合，比如前面提及的事务管理。

  • OXM 模块提供了对OXM实现的支持，比如JAXB、Castor、XML Beans、JiBX、XStream等。

  • JMS 模块包含生产（produce）和消费（consume）消息的功能。从Spring 4.1开始，集成了spring-messaging模块。

  • 事务模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。（注：编程式事务需要自己写beginTransaction()、commit()、rollback()等事务管理方法，声明式事务是通过注解或配置由spring自动处理，编程式事务粒度更细）

Web

Web 层由 Web，Web-MVC，Web-Socket 和 Web-Portlet 组成，它们的细节如下：

  • Web 模块提供面向web的基本功能和面向web的应用上下文，比如多部分（multipart）文件上传功能、使用Servlet监听器初始化IoC容器等。它还包括HTTP客户端以及Spring远程调用中与web相关的部分。

  • Web-MVC 模块为web应用提供了模型视图控制（MVC）和REST Web服务的实现。Spring的MVC框架可以使领域模型代码和web表单完全地分离，且可以与Spring框架的其它所有功能进行集成。

  • Web-Socket 模块为 WebSocket-based 提供了支持，而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。

  • Web-Portlet 模块提供了用于Portlet环境的MVC实现，并反映了spring-webmvc模块的功能。

其他

还有其他一些重要的模块，像 AOP，Aspects，Instrumentation，Web 和测试模块，它们的细节如下：

  • AOP 模块提供了面向方面的编程实现，允许你定义方法拦截器和切入点对代码进行干净地解耦，从而使实现功能的代码彻底的解耦出来。使用源码级的元数据，可以用类似于.Net属性的方式合并行为信息到代码中。

  • Aspects 模块提供了与 AspectJ 的集成，这是一个功能强大且成熟的面向切面编程（AOP）框架。

  • Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。

  • Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。

  • 测试模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

主要有七大模块

每个模块可以单独使用也可以多模块组合使用，

核心模块：spring core是核心容器实现了IoC模式，提供了框架的基础功能，在模块中包含BeanFactory类，负责对JavaBean配置与管理采用Factory模式实现loC容器即依赖注入。

Context模块：继承了BeanFactory并且添加了处理事件，国际化,资源装载，数据校验等，JNDI访问，ejb,远程调用，集成模块框架，Email,定时任务。

AOP模块：通过事务管理使得任意Spring管理的对象AOP化。

DAO模块：JDBC的抽象层，简化数据库的厂商的异常错误，减少了代码的书写，并且提供了声明式的任务，和编程式任务。

O/R映射模块：直接用Hibernate。

Web模块：建立在Spring Context 模块的基础，提供servlet监听器的Context和web应用上下文

mvc模块：建立在Spring 核心功能之上，使得拥有Spring框架的所有特性适应于多种的视图模块技术

配置：

Spring模块中是根据每一个模块对应的一个jar包
spring,jar//整个Spring模块
spring-core.jar//核心模块包含ioc容器
spring-aop.jar//Aop模块
spring-context.jar//Spring上下文包含ApplicationContext容器
spring-dao.jar//dao层与jdbc的支持
spring-orm.jar
spring-web.jar
spring-webmvc.jar//
Spring项目：<---Spring配置{jar包----->tlb标签库--->applicationContext.xml}

IOC 容器

IoC即控制反转，他使得组件或类之间尽量的形成一种松的耦合结构，创建类都是Ioc容器来干，

Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。

Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans，

Spring IoC 容器利用 Java 的 POJO 类和配置元数据来生成完全配置和可执行的系统或应用程序

BeanFactory

它主要的功能是为依赖注入 （DI） 提供支持，这个容器接口在 org.springframework.beans.factory.BeanFactor 中被定义。 BeanFactory 和相关的接口，比如BeanFactoryAware、 DisposableBean、InitializingBean，仍旧保留在 Spring 中，主要目的是向后兼容已经存在的和那些 Spring 整合在一起的第三方框架实现了IoC控制，可以称为IoC容器通过xml配置文件或.properties中读取Javabean的定义，来实现Javabean配置和管理创建。 XmlBeanFactory可以通过xml读取装配JavaBean 在调用getBean()方法时不会实例化任何对象只有在JavaBean需要创建时才会分配资源空间，

  • 第一步利用框架提供的 XmlBeanFactory() API 去生成工厂 bean 以及利用 ClassPathResource() API 去加载在路径 CLASSPATH 下可用的 bean 配置文件。 XmlBeanFactory() API 负责创建并初始化所有的对象，即在配置文件中提到的 bean。

  • 第二步利用第一步生成的 bean 工厂对象的 getBean() 方法得到所需要的 bean。 这个方法通过配置文件中的 bean ID 来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，就可以利用这个对象来调用任何方法 例如：

    Resource re=new ClassPathResource("applicationContext.xml"); BeanFactory factory=new XmlBeanFactory(re); Test test =factory.getBean("test"); 在xml文件中配置如下： <！引入beans.dtd> <beans> < bean id="test" class="com.test.Test"> </beans>

ApplicationContext:

ApplicationContext是Spring中较高级的容器和beanFactory类似，他可以加载配置文件定义的bean，将所有的bean集中在一起，当请求时分配bean，扩展了BeanFactory容器并添加了国际化，生命周期，事件，监听，提供了BeanFactory的所有特性而且允许用户使用更多的声明方式 有三个实现的类： ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,WebApplicationContext

ClassPathXmlApplicationContext:

从当前类路径中检索配置文件并装载他来创建容器的实例 ​ ApplicationContext context=new ClassPathXmlApplicationContext(String configLocation);

FileSystemXmlApplicationContext:

不是从类路径中获取配置信息，而是通过参数指定配置文件的位置，可以获取类路径之外的资源，该容器从 XML 文件中加载已被定义的 bean。

在这里，你需要提供给构造器 XML 文件的完整路径 ​ ApplicationContext context=new FileSystemXmlApplicationContext(String configLocation);

WebApplicationContext:

有两种方法在servlet中使用

  • 1.在servlet中的web.xml配置Spring 的 ContextLoaderListener的监听器，

  • 2.修改web.xml在配置文件中添加一个servlet定义使用Spring的ContextLoaderServlert类

Spring Bean

bean 对象也是由Spring IoC容器管理，bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。这些 bean 是由用容器提供的配置元数据创建的 <bean>元素有以下属性： id，name,class,singleton,autowire,init-method,destroy-method,depends-on

<bean id="id" class="创建的bean类" scope="bean的作用域">
<!-- collaborators and configuration for this bean go here -->
</bean>
<bean id="..." class="..." lazy-init="true">
<!-- collaborators and configuration for this bean go here -->
</bean>
<bean id="..." class="..." destroy-method="...">
<!-- collaborators and configuration for this bean go here -->
</bean>

Bean元素

使用Spring注册的对象

name属性：给被管理对象起名字，根据改名字获取对象。名字可以重复，可以使用特殊字符

class属性：被管理对象完整的类名

id属性：与name属性一样，名字不可重复，不能使用特殊字符

尽量使用name属性

Bean作用域

singleton

在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，默认值

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用他都存在了每次获取到的对象都是同一个对象。

注意，Singleton作用域是Spring中的缺省作用域 <bean id="..." class="..." scope="singleton"></bean>

prototype

每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()这就是平时使用new创建对象的默认方式；

表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。

Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。

通常DAO不会被配置成prototype,因为一个Dao不会支持任何会话状态，

request

每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境

session

同一个HTTP Session共享一个Bean，不同Session使用不同的Bean，仅适用于WebApplicationContext环境

global-session

一般用于Portlet应用环境，改作用于仅适用于WebApplicationContext环境

Bean的生命周期

声明带有 init-method 和/或 destroy-method 参数的 。init-method 属性指定一个方法，在实例化 bean 时，立即调用该方法。同样，destroy-method 指定一个方法，只有从容器中移除 bean 之后，才能调用该方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="helloWorld" class="com.tutorialspoint.HelloWorld" init-method="init" destroy-method="destroy">
        <property name="message" value="Hello World!"/>
    </bean>
</beans>

如果你有太多具有相同名称的初始化或者销毁方法的 Bean，那么你不需要在每一个 bean 上声明初始化方法和销毁方法。

框架使用 元素中的 default-init-method 和 default-destroy-method 属性提供了灵活地配置这种情况，

Bean的初始化步骤

  1. 1.<bean>标签使用autowire属性，会进行自动装配，
  2. 2.通过get(),set()方法。
  3. 3.如果实现BeanNameAware接口容器会将调用bean的setBeanName()方法传递bean的ID
  4. 4.如果实现BeanFactoryAware接口，容器会将调用的bean得setBeanfactory()方法注入bean，
  5. 5.如果注册了BeanPostProcessor接口的实现类，将调用这个实现类的postProcessBeforeInitialization()方法；完成bean的预处理
  6. 6.如果是实现了InitializingBean接口容器会调用JavaBean的afterPropertiesSet()方法修改JavaBean的属性。
  7. 7.在XML中配置Bean时如果用init-method属性指定来了初始化方法容器会执行指定的方法
  8. 8.如果注册了BeanPostProcessor的实现类，将调用实现类的postProcessAfterInitialization()方法完成后置处理方法

Bean的销毁

1.在销毁bean之前如果Bean实现了DisposableBean接口，容器会调用bean的destroy()方法来完成销毁工作，

2.如果在bean定义了指定的销毁方法呢么在bean被销毁前会先执行指定的方法，在同时指定的时候DisposableBean接口时有优先权

Bean的后置处理

BeanPostProcessor 接口定义回调方法，你可以实现该方法来提供自己的实例化逻辑，依赖解析逻辑等。你也可以在 Spring 容器通过插入一个或多个 BeanPostProcessor 的实现来完成实例化，配置和初始化一个bean之后实现一些自定义逻辑回调方法。

你可以配置多个 BeanPostProcesso r接口，通过设置 BeanPostProcessor 实现的 Ordered 接口提供的 order 属性来控制这些 BeanPostProcessor 接口的执行顺序。

BeanPostProcessor 可以对 bean（或对象）实例进行操作，这意味着 Spring IoC 容器实例化一个 bean 实例，然后 BeanPostProcessor 接口进行它们的工作。

ApplicationContext 会自动检测由 BeanPostProcessor 接口的实现定义的 bean，注册这些 bean 为后置处理器，然后通过在容器中创建 bean，在适当的时候调用它。调用的时候只需要实现BeanPostProcessor接口

Bean定义继承

bean 定义可以包含很多的配置信息，包括构造函数的参数，属性值，容器的具体信息例如初始化方法，静态工厂方法名，等等。

子 bean 的定义继承父定义的配置数据。子定义可以根据需要重写一些值，或者添加其他值。

Spring Bean 定义的继承与 Java 类的继承无关，但是继承的概念是一样的。你可以定义一个父 bean 的定义作为模板和其他子 bean 就可以从父 bean 中继承所需的配置。当你使用基于 XML 的配置元数据时，通过使用父属性，指定父 bean 作为该属性的值来表明子 bean 的定义。

xml配置信息：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="helloWorld" class="xxxparent">
        <property name="message1" value="Hello World!"/>
        <property name="message2" value="Hello Second World!"/>
    </bean>
    <bean id="helloIndia" class="xxx" parent="helloWorld">
        <property name="message1" value="Hello India!"/>
        <property name="message3" value="Namaste India!"/>
    </bean>
</beans>
## 使用的时候可以直接定义模板，这样就可以方便让其他子bean定义使用：需要指定抽象属性为true;
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="beanTeamplate" abstract="true">
        <property name="message1" value="Hello World!"/>
        <property name="message2" value="Hello Second World!"/>
        <property name="message3" value="Namaste India!"/>
    </bean>
    <bean id="helloIndia" class="com.tutorialspoint.HelloIndia" parent="beanTeamplate">
        <property name="message1" value="Hello India!"/>
        <property name="message3" value="Namaste India!"/>
    </bean>
</beans>

依赖注入（DI）

依赖注入(DI)的设计模式是用来定义对象彼此间的依赖 主要有两种方式注入：

  • Setter方法注入

  • 构造器注入（构造函数注入）

  • 接口注入

  • 设值函数注入

接口注入

基于接口将调用与实现分离，必须实现容器所规定的接口使程序代码和容器的API绑定在一起，不是理想的依赖注入

Setter注入

基于Java的setter方法的属性赋值最为广泛应用

可以混合这两种方法，基于构造函数和基于 setter 方法的 DI，然而使用有强制性依存关系的构造函数和有可选依赖关系的 setter是一个好的做法。

代码是 DI 原理的清洗机，当对象与它们的依赖关系被提供时，解耦效果更明显。对象不查找它的依赖关系，也不知道依赖关系的位置或类，而这一切都由 Spring 框架控制的。

例如：

一个简单的Javabean就是有一个私有的属性对应getter() setter()方法，来实现对属性的封装；

class User {
    private  String name;
    private  String  sex;
    private  int age;
    //setter();
}
## applicationContext.xml配置：
<bean name="user" class="xxx.User">
   <property name="name">
        <value>sssd</value>
   </property>
   <property name="age">
        <value>12</value>
   </property>
   <property name="sex">
        <value>男</value>
   </property>
</bean>
直接获取到bean用User对象接收，然后即可以调用对象的属性

构造函数注入

当容器调用带有一组参数的类构造函数时，基于构造函数的 DI 就完成了，其中每个参数代表一个对其他类的依赖。基于构造方法为属性赋值，容器通过调用类的构造方法将其进行依赖注入 <constructor-arg>是<bean>元素的子元素，通过 <constructor-arg>的子元素<value>可以传参 <ref>元素用于引入其他的Javabean对象

public class TextEditor {
    private SpellChecker spellChecker;
    public TextEditor(SpellChecker spellChecker) {
        System.out.println("Inside TextEditor constructor." );
        this.spellChecker = spellChecker;
    }
    public void spellCheck() {
        spellChecker.checkSpelling();
    }
}
public class SpellChecker {
    public SpellChecker(){
        System.out.println("Inside SpellChecker constructor." );
    }
    public void checkSpelling() {
        System.out.println("Inside checkSpelling." );
    } 
}
public static void main(String[] args) {
    ApplicationContext context = 
        new ClassPathXmlApplicationContext("Beans.xml");
    TextEditor te = (TextEditor) context.getBean("textEditor");
    te.spellCheck();
}
beans.xml文件：
<!-- Definition for textEditor bean -->
<bean id="textEditor" class="com.tutorialspoint.TextEditor">
   <constructor-arg ref="spellChecker"/>
</bean>
<!-- Definition for spellChecker bean -->
<bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
</bean>
这样的好处是实例化对象的同时完成属性的初始化
class User {
    private  String name;
    private  String  sex;
    private  int age;
    //setter();
    User(String name,int age,string sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
}
在applicationContext.xml为其赋值
    <bean name="user" class="com.xxx.User">
        <constructor-arg>
            <value>小强</value>
        </contructor-arg>
        <constructor-arg>
            <value>12</value>
        </contructor-arg>
        <constructor-arg>
        <value>男</value>
        </contructor-arg>
        构造函数注入设置执行哪一个构造函数，主要用 index属性进行测试：
        <!-- 构造函数注入
        constructor-age 用于设置属性的 
        name 用于设置构造函数的参数名
        index 用于设置参数的索引
        type 用于设置参数类型
        ref 用于引入其他对象，也需要先把其他对象给实例出来
        -->
        <bean name="user4" class="com.leo.demo.User">
            <constructor-arg name="name" index="0" type="String" value="黑市"></constructor-arg>
            <constructor-arg name="car" index="1" ref="car"></constructor-arg>
        </bean>
        <bean name="user5" class="com.leo.demo.User">
             <constructor-arg name="name" index="1" type="String" value="黑市"></constructor-arg>
             <constructor-arg name="car" index="0" ref="car"></constructor-arg>
          </bean>
构造函数如下：
/**
 * 指定到这个构造：
 * @param car
 * @param name
 */
public User(Car car,String name) {
     this.car=car;
     this.name=name;
     System.out.println("car,name,");
}
/**
 * 
 * @param name
 * @param car
*/
public User(String name,Car car) {
    this.car=car;
    this.name=name;
    System.out.println("name,car");
}
使用的时候：
 @Test
public void test5() {
    ClassPathXmlApplicationContext context =new ClassPathXmlApplicationContext("Beans.xml");
    User bean=(User)context.getBean("user4");
    System.out.println(bean.getCar().getName());
    context.close();
}
/**
 * 构造函数注入指定走哪一个构造函数配置走car nam
@Test
public void test6() {
    ClassPathXmlApplicationContext context =new ClassPathXmlApplicationContext("Beans.xml");
    User bean=(User)context.getBean("user5");
    System.out.println(bean.getCar().getName());
    context.close();
}

设值函数注入：

当容器调用一个无参的构造函数或一个无参的静态 factory 方法来初始化你的 bean 后，通过容器在你的 bean 上调用设值函数，基于设值函数的 DI 就完成了。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
​
    <!-- Definition for textEditor bean -->
    <bean id="textEditor" class="com.tutorialspoint.TextEditor">
    <property name="spellChecker" ref="spellChecker"/>
    </bean>
​
    <!-- Definition for spellChecker bean -->
    <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
    </bean>
​
</beans>
应该注意定义在基于构造函数注入和基于设值函数注入中的 Beans.xml 文件的区别。
唯一的区别就是在基于构造函数注入中，我们使用的是〈bean〉标签中的〈constructor-arg〉元素，而在基于设值函数的注入中，我们使用的是〈bean〉标签中的〈property〉元素。
如果你要把一个引用传递给一个对象，那么你需要使用 标签的 ref 属性，而如果你要直接传递一个值，那么你应该使用 value 属性。

注入其他

注入内部beans:

匿名内部类的与xml

<bean id="outerBean" class="...">
    <property name="target">
        <bean id="innerBean" class="..."/>
    </property>
</bean>

注入集合：
Java Collection 类型 List、Set、Map 和 Properties，为了处理这种情况，Spring提供了四种类型的集合：
<list><set><map><props>
例如：

public class JavaCollection {
List addressList;
Set  addressSet;
Map  addressMap;
Properties addressProp;
....
}
配置形式：
<?xml version="1.0" encoding="UTF-8"?>
​
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
​
    <!-- Definition for javaCollection -->
    <bean id="javaCollection" class="com.tutorialspoint.JavaCollection">
​
    <!-- results in a setAddressList(java.util.List) call -->
    <property name="addressList">
        <list>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
        </list>
    </property>
​
    <!-- results in a setAddressSet(java.util.Set) call -->
    <property name="addressSet">
        <set>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
        </set>
    </property>
​
    <!-- results in a setAddressMap(java.util.Map) call -->
    <property name="addressMap">
        <map>
            <entry key="1" value="INDIA"/>
            <entry key="2" value="Pakistan"/>
            <entry key="3" value="USA"/>
            <entry key="4" value="USA"/>
        </map>
    </property>
​
    <!-- results in a setAddressProp(java.util.Properties) call -->
    <property name="addressProp">
        <props>
            <prop key="one">INDIA</prop>
            <prop key="two">Pakistan</prop>
            <prop key="three">USA</prop>
            <prop key="four">USA</prop>
        </props>
    </property>
    </bean>
</beans>

好了这就是要介绍的spring简介和Bean 以及IOC容器

spring框架测试题
光光探险路
04-28 1万+
章节测验 1.spring基本应用 1.[单选题] 以下关于Spring核心容器相关说法错误的是()。 A.Spring框架的所有功能都是通过其核心容器来实现的 B.创建BeanFactory实例时,需要提供Spring所管理容器的详细配置信息,这些信息通常采用XML文件形式来管理 C.ApplicationContext不仅包含了BeanFactory的所有功能,还添加了对国际化、资源访问、事件...
Spring简介与IOC容器
m0_62356365的博客
04-21 1820
一、Spring简介 开源：源码公开、免费试用； 简化：简化企业级开发。 解耦：耦合度降低、可插拔，便于后续维护更新升级拓展。 二、Sping核心模块 Spring 框架的这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。 官网：Spring | Home Core 核心模块：提供了 Spring 框架的基本组成部分，包括 IoC 和 DI 功能。 Context 上下文模块：建立在核心和 Beans 模块的基础之上，它是访问定义和配置任.
Spring之IoC容器和依赖注入(1)
qq_36116242的博客
02-20 577
1. IoC的概念 本质上就是工厂模式 以前 以前我们是由自己主动创建一个对象，主动获取一个资源 //Car是接口, 后面是实现类 Car bmw = new Bmw(); Car benZ = new BenZ(); Car audi = new Audi(); 现在 使用工厂模式，我们需要的对象由工厂去创建，我们不再自己创建，我们只消费对象。 Car bmw = BeanFactory.getBean("bmw"); Car benZ = BeanFactory.getBean("be
Spring框架(第1天)-IoC容器和依赖注入
weixin_42914989的博客
02-25 3521
文章目录Spring框架(第1天)-IoC容器和依赖注入SSM框架阶段学习目标1. IoC的概念目标原来现在有什么好处？容器的概念在项目开发中将对象存放在什么地方？什么是工厂呢？概念：控制反转IoC（Inversion Of Control）小结2. Spring框架介绍目标Spring框架的由来Spring框架的介绍Spring体系结构体系结构组成Core Container核心容器Data Access/Integration数据访问与集成Web其他模块小结3. Spring入门案例创建maven项目搭
Sring传智播客第一章的题（带答案和解析）
此心安处
08-30 5232
目 录作业一单选题多选题判断题 作业一 单选题 1、以下有关Spring的四个基础包说法正确的是（） A、Spring的四个基础包，它们分别对应Spring Web容器的四个模块 B、Spring的四个基础包有spring-core.RELEASE.jar、spring-beans-.RELEASE.jar、spring-context-.RELEASE.jar和spring-aop-.RELEASE.jar； C、spring-context-.RELEASE.jar是所有应用都要用到的JAR包，它包含访
我对于spring IOC容器的理解
Jiang的博客
07-26 374
三层架构的互相调用，ui视图层调用service业务层，业务层调用dao持久层。在调用时，都需要将每一层进行实例化，通过获取其对象的方式去实现。这种主动获取对象的方式大大增加了其模块之间的耦合性。 　　 　　这时就引进了spring来解耦，其中spring IOC 全称为Inverse of Control控制反转。意思就是创建对象的细节和方法交给spring IOC来管理，当我们想要获取需要的对象时，可以通过获取spring IOC容器的方式去获取。 　　 　　大概举个例子就是，机器猫，我想要啥，给它一说
Spring实现一个简单的SpringIOC容器
08-30
本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计模式，它将对象的创建和管理从对象本身转移到一个外部容器，即IOC容器。Spring的IOC容器通过读取配置文件（如...
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心所在，本文将从 ...
Spring之IOC容器
tq02的博客
03-28 1508
本文讲解的SpringIoc的知识点，对比传统代码，SpringIoc的优点，通过控制反转，如何获取Bean的两种方法，以及配置的xml文件
Spring源码之手写IOC容器
最新发布
小兔子的博客
06-23 1238
手写Spring IOC容器 源码
Spring IOC 的理解
qq_18457333的博客
10-24 351
提到IOC，我们通常能想到Spring框架，然后就想到三个特性，控制反转，依赖注入（DI），面向切面编程（AOP）。IOC就是一个容器，以Map形式的容器（Key,Value）。举个例子来讲，通常我们在开发中，会创建一些Bean对象，写一些注解，而我们写完这些东西之后，它们会存在这个IOC容器中，以键值对形式存入，当我们用时，容器就会通过Key值来获取，供给我们使用。这样来讲就会很好理解。简单来说，可以理解为控制权发生了反转。主要对于对象的创建或使用，对象的控制权反转给IOC容器，而不是我们开发者。
第一章 Spring的基本应用
weixin_46066900的博客
05-20 4608
单选题 1、下列选项中，不属于Spring框架优点的是（A）。5分 A、提供强大的、可以有效减少页面代码的标签 B、声明式事务的支持 C、方便解耦、简化开发 D、方便集成各种优秀框架 2、以下关于Spring核心容器相关说法错误的是（参考答案 :A）。5分 A、Spring框架的所有功能都是通过其核心容器来实现的 B、创建BeanFactory实例时，需要提供Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理 C、ApplicationContext不仅包含了BeanFactory的
Spring框架由哪些部分组成?
Cheetahcubs的博客
08-23 5180
1.Spring Core     Core封装包是框架的最基础部分，提供IOC和依赖注入的特性。这里的基础l概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。 2.Spring Context    构建于Core封装包基础上的Context封装包,提供了一种框架式的对象访问方法，有些像JNDI注...
Spring知识点整理---（IOC，DI）
zyz博客
01-06 441
1.Spring的基本应用 1.1Spring概述 1.1.1什么是Spring Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE full-stack（一站式）轻量级开源框架，它以IoC（Inversion of Control，控制反转）和 AOP（Aspect OrientedProgramming，面向切面编程）为内核，使用基本的JavaBean来...
JavaEE 初识Spring框架、Bean、IOC、DI、Spring配置及文件加载和bean注入、获取bean对象
char_m的博客
09-08 560
文章目录一、Spring框架是什么？Spring框架特点二、Spring体系结构1.引入库2.读入数据总结 一、Spring框架是什么？ Spring 是另一个主流的 Java Web 开发框架，该框架是一个轻量级的应用框架，具有很高的凝聚力和吸引力。Spring 具有简单、可测试和松耦合等特点，不仅可以用于服务器端的开发，也可以应用于任何 Java 应用的开发中 Spring 是分层的 Java SE/EE full-stack 轻量级开源框架，以 IoC（Inverse of Control，控制
Spring框架：核心容器总结
热门推荐
当一堆用不熄灭的柴火
10-22 1万+
最近想要深入了解一下spring，所以今天先对spring框架做一个宏观的总结。 Spring框架： 首先我们看到Spring框架被分成7部分：Core Container(核心容器)，Data Access/Integration、WEB、AOP、Instrumentation、Messaging(消息)和Test(测试)，这篇博客我们把注意点放到最核心的核心容器上来进行总结。 核心容器核心容器
《Java EE企业级应用开发教程（SSM）》练习题答案---第一章Spring的基本应用（仅供参考）
皓月南游的博客
06-08 4387
第一章Spring的基本应用 多选题 1、以下有关Spring核心容器的说法正确的是（）。 A、Spring框架提供了两种核心容器，分别为BeanFactory和ApplicationContext B、BeanFactory由org.springframework.beans.facytory.BeanFactory接口定义，是基础类型的IoC容器 C、BeanFactory就是一个管理Bean的工厂，它主要负责初始化各种Bean，并调用它们的生命周期方法 D、ApplicationContext是Bea
Spring的学习（一）
weixin_40139002的博客
04-21 240
Spring 学习（一） 简介 Spring框架的核心特性是可以用于开发任何JAVA应用程序，但是在JAVA EE平台上构建web应用是需要扩展的。Spring框架的目标是使J2EE开发变得更容易使用，通过启用POJO编程模型来促进良好的编程实践。 体系架构 Spring 是模块化的，允许用户挑选适用的模块进行适用，不需要把剩余的部分引入。Spring框架提供了20个模块 核心容器 核心容器由s...
Spring框架功能分为哪些模块？其作用是什么？
xiaoxijing的博客
06-03 4810
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。本文，就来说一说Spring框架功能模块构成及概念。 Spring框架功能模块构成及概念，Spring框架采用分层架构，功能要素被分成20个模块，分为Core Container、Data Access/I
Spring IoC容器深度解析
2. **IoC的基本概念**：IoC的核心思想是，对象不再自行创建或查找其依赖的对象，而是由一个外部容器（如Spring的IoC容器）负责创建和注入。这包括构造方法注入、setter方法注入和接口注入等不同方式，它们允许开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kay三石

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值