Spring-IOC的XML配置

已于 2023-11-16 17:21:59 修改
阅读量5.1k 收藏 1
点赞数
分类专栏： SpringBoot 文章标签： spring xml java
于 2019-06-05 20:20:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WenWu_Both/article/details/90934002
版权

引言

在Springboot编程实践中，我们偏向使用注解的方式进行Bean的注册和依赖注入等，但XML格式的容器信息管理方式仍是Spring提供的最为强大、支持最为全面的方式，本文对Spring-IOC的XML配置进行详细的讲解。

<beans>和<bean>

BeanFactory和ApplicationContext的XML配置均采用统一的格式，在Spring2.0之前，这种格式由Spring提供的DTD规定，即在配置文件的头部，需要以下形式的DOCTYPE声明:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
   ...
</beans>

从Spring 2.0版本之后，Spring在继续保持向前兼容的前提下，既可以继续使用DTD方式的 DOCTYPE
进行配置文件格式的限定，又引入了基于XML Schema的文档声明：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:util="http://www.springframework.org/schema/util"
        xmlns:jee="http://www.springframework.org/schema/jee"
        xmlns:lang="http://www.springframework.org/schema/lang"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-2.0.xsd
        http://www.springframework.org/schema/jee
        http://www.springframework.org/schema/jee/spring-jee-2.0.xsd
        http://www.springframework.org/schema/lang
        http://www.springframework.org/schema/lang/spring-lang-2.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
    ...
</beans>

<beans>

<beans>是配置文件的顶层元素，其可以包含0或1个<description>和多个<bean>以及<import>或者<alias>

<beans>可以配置所有<bean>的全局行为，主要包括:

  • default-lazy-init

取值true或false，默认值false，用来标志是否对所有的<bean>进行延迟初始化。

  • default-autowire

可以取值为no、byName、byType、constructor以及autodetect。默认值为 no ，如果使用自动绑定的话，用来标志全体bean使用哪一种默认绑定方式。

  • default-dependency-check

可以取值none、objects、simple以及all，默认值为none，即不做依赖检查。

  • default-init-method

如果所管辖的<bean>按照某种规则，都有同样名称的初始化方法的话，可以在这里统一指定这个初始化方法名，而不用在每一个<bean>上都重复单独指定。

  • default-destroy-method

与default-init-method相对应，如果所管辖的bean有按照某种规则使用了相同名称的对象销毁方法，可以通过这个属性统一指定。

<description>、<import>和<alias>

  • <description>

配置文件的描述信息。

  • <import>

通常情况下，可以根据模块功能或者层次关系，将配置信息分门别类地放到多个配置文件中。在想加载主要配置文件，并将主要配置文件所依赖的配置文件同时加载时，可以在这个主要的配置文件中通过<import>元素对其所依赖的配置文件进行引用。比如，如果A.xml中的<bean>定义可能依赖B.xml中的某些<bean>定义，那么就可以在A.xml中使用<import>将B.xml引入到A.xml，以类似于<import resource=“B.xml”/> 的形式。

  • <alias>

可以通过<alias>为某些<bean>起一些“外号”（别名），通常情况下是为了减少输入。比如，假设有个<bean> ，它的名称为dataSourceForMasterDatabase ，你可以为其添加一个<alias> ，像这样<alias name=“dataSourceForMasterDatabase” alias=“masterDataSource”/> 。以后通过dataSourceForMasterDatabase或者 masterDataSource来引用这个<bean>都可以。

<bean>

  • id属性

对象在容器里的标识，若未配置，则<bean>的id取类名的小驼峰。

除了使用id，也可以使用name来进行标识，它与id的区别是， name可以使用id不能使用的一些字符，比如/。而且
还可以通过逗号、空格或者冒号分割指定多个name。name的作用跟使用<alias>为id指定多个别名基本相同：

<bean id="person" name="/china/person,/england/person"/ class="com.ruanshubin.springboot.entity.Person">
等同于:
<alias name="person" alias="/china/person"/>
<alias name="person" alias="/england/person"/>
  • class属性

每个注册到容器的对象都需要通过<bean>元素的class属性指定其类型。

依赖注入

为了演示依赖注入，我们新建3个实体类，分别为主机、显示器和电脑。

public class MainEngine {
    // 名称
    private String name;
    // 型号
    private String type;
    // 花费
    private Integer cost;
		
		...
		构造器及get/set方法
		toString方法
	}
	
public class Display {
    // 名称
    private String name;
    // 型号
    private String type;
    // 花费
    private Integer cost;

		...
		构造器及get/set方法
		toString方法
	}
	
public class Computer {
    // 名称
    private String name;
    // 主机
    private MainEngine mainEngine;
    // 显示器
    private Display display;
				
			...
		构造器及get/set方法
		toString方法
		}

构造方法注入

在resources目录下新建spring-beans.xml文件:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:util="http://www.springframework.org/schema/util"
        xmlns:jee="http://www.springframework.org/schema/jee"
        xmlns:lang="http://www.springframework.org/schema/lang"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-2.0.xsd
        http://www.springframework.org/schema/jee
        http://www.springframework.org/schema/jee/spring-jee-2.0.xsd
        http://www.springframework.org/schema/lang
        http://www.springframework.org/schema/lang/spring-lang-2.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <bean id="display" class="com.ruanshubin.springboot.ioc.entity.Display">
        <constructor-arg>
            <value>惠普</value>
        </constructor-arg>
        <constructor-arg>
            <value>V300</value>
        </constructor-arg>
        <constructor-arg>
            <value>1000</value>
        </constructor-arg>
    </bean>

    <bean id="mainEngine" class="com.ruanshubin.springboot.ioc.entity.MainEngine">
        <constructor-arg>
            <value>戴尔</value>
        </constructor-arg>
        <constructor-arg>
            <value>T600</value>
        </constructor-arg>
        <constructor-arg>
            <value>3600</value>
        </constructor-arg>
    </bean>

    <bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer">
        <constructor-arg>
            <value>组装机1</value>
        </constructor-arg>
        <constructor-arg>
            <ref bean="mainEngine"></ref>
        </constructor-arg>
        <constructor-arg>
            <ref bean="display"></ref>
        </constructor-arg>
    </bean>

</beans>

编写主函数:

public class IocXmlTest {
    public static void main(String[] args) {
        XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-beans.xml"));
        Computer computer = (Computer) beanFactory.getBean("computer");
        System.out.println(computer);
    }
}

运行结果为:

Computer{name='组装机1', mainEngine=MainEngine{name='戴尔', type='T600', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}}

可以发现，如果注入的属性为基本数据类型(及其包装类)、String等，则使用<value>进行注入，若为Java对象，则使用<ref bean=“…”>的方式进行注入。

同时，上述<constructor-arg>的顺序要与Java类中属性的顺序要严格一致，否则会出现问题，如将mainEngine的配置修改为:

<bean id="mainEngine" class="com.ruanshubin.springboot.ioc.entity.MainEngine">
		<constructor-arg>
				<value>T600</value>
		</constructor-arg>
		<constructor-arg>
				<value>戴尔</value>
		</constructor-arg>
		<constructor-arg>
				<value>3600</value>
		</constructor-arg>
</bean>

重新运行主类，结果为:

Computer{name='组装机1', mainEngine=MainEngine{name='T600', type='戴尔', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}}

可以发现，主机的名称和型号互换，造成异常。

此时，可以添加index标签，其表征了属性的顺序编号，从0开始。

<bean id="mainEngine" class="com.ruanshubin.springboot.ioc.entity.MainEngine">
		<constructor-arg index="1">
				<value>T600</value>
		</constructor-arg>
		<constructor-arg index="0">
				<value>戴尔</value>
		</constructor-arg>
		<constructor-arg>
				<value>3600</value>
		</constructor-arg>
</bean>

还有type标签，用于各属性类型不同时配置：

<bean id="mainEngine" class="com.ruanshubin.springboot.ioc.entity.MainEngine">
		<!--不添加type标签会报错-->
		<constructor-arg type="Integer">
				<value>3600</value>
		</constructor-arg>
		<constructor-arg>
				<value>戴尔</value>
		</constructor-arg>
		<constructor-arg>
				<value>T600</value>
		</constructor-arg>
</bean>

最强大的是name标签，不管<constructor-arg>的顺序是否与实体类各属性的顺序是否一致，只要保证name一致即可安全注入，如将mainEngine的配置修改为:

<bean id="mainEngine" class="com.ruanshubin.springboot.ioc.entity.MainEngine">
		<constructor-arg name="cost">
				<value>3600</value>
		</constructor-arg>
		<constructor-arg name="type">
				<value>T600</value>
		</constructor-arg>
		<constructor-arg name="name">
				<value>戴尔</value>
		</constructor-arg>
</bean>

虽然<constructor-arg>的顺序与实体类的属性顺序完全相反，但是通过name一对一绑定，运行结果仍旧为:

Computer{name='组装机1', mainEngine=MainEngine{name='戴尔', type='T600', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}}

setter方法注入

setter方法使用<property>完成依赖注入，如:

<bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer">
		<property name="name" value="组装机1"/>
		<property name="mainEngine" ref="mainEngine"/>
		<property name="display" ref="display"/>
</bean>

需要指出的是，除了value和ref标签，Spring还提供了bean、idref、value、null、list、set、map、props。

具体使用场景，本文不做过多介绍，大家可自行Google。

自动注入autowire

除了可以通过配置明确指定bean之间的依赖关系，Spirng还提供了根据bean定义的某些特点将相互依赖的某些bean直接自动绑定的功能。通过<bean> 的autowire属性，可以指定当前bean定义采用某种类型的自动绑定模式。这样，你就无需手工明确指定该bean定义相关的依赖关系，从而也可以免去一些手工输入的工作量。

Spring提供了5种自动绑定模式，即 no、byName、byType、constructor和autodetect。

  • no

默认配置，即不采取自动注入，仅依靠手工配置注入。

  • byName

按照类中声明的实例变量的名称，与XML配置文件中声明的bean定义的beanName的值进行匹配，相匹配的bean定义将被自动绑定到当前实例变量上。

如我们将上面的computer的注入配置修改为:

<bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer" autowire="byName">
</bean>

运行结果为:

Computer{name='null', mainEngine=MainEngine{name='戴尔', type='T600', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}}

程序会自动寻找id为mainEngine、display的bean来完成注入，因为没有id为name的<bean>，所以不能自动注入，该项为null。

可以修改配置，添加无法自动注入的属性:

<bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer" autowire="byName">
		<property name="name" value="组装机1"/>
</bean>

此时，再次运行:

Computer{name='组装机1', mainEngine=MainEngine{name='戴尔', type='T600', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}}
  • byType

与byName类似，byType是按照类中声明的实例变量的Type，与XML配置文件中声明的bean的Type进行匹配，相匹配的bean定义将被自动绑定到当前实例变量上。

如我们将上面的computer的注入配置修改为:

<bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer" autowire="byType">
		<property name="name" value="组装机1"/>
</bean>

运行:

Computer{name='组装机1', mainEngine=MainEngine{name='戴尔', type='T600', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}}

此处有个问题，当某个实例变量的Type在Spring容器中存在两个<bean>，会选择哪个进行注入呢?

假设在上述spring-beans.xml文件中添加如下配置:

<bean id="mainEngine1" class="com.ruanshubin.springboot.ioc.entity.MainEngine">
		<constructor-arg name="cost">
				<value>3000</value>
		</constructor-arg>
		<constructor-arg name="type">
				<value>X900</value>
		</constructor-arg>
		<constructor-arg name="name">
				<value>神州</value>
		</constructor-arg>
</bean>

此时，Spring容器里存在2个主机实例，我们仍旧通过byType进行自动注入。

运行主函数:

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'computer' defined in class path resource [spring-beans.xml]: Unsatisfied dependency expressed through bean property 'mainEngine'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.ruanshubin.springboot.ioc.entity.MainEngine' available: expected single matching bean but found 2: mainEngine,mainEngine1
...

很明显，Spring不会帮你做这个决策，当同一个Type存在多个实例时，程序直接会将错误抛出来，由你来做决策。

  • constructor

constructor类型则是针对构造方法参数的类型而进行的自动绑定，它同样是byType类型的绑定模式。不过，constructor是匹配构造方法的参数类型，而不是实例属性的类型。与byType模式类似，如果找到不止一个符合条件的bean定义，那么，容器会返回错误。

  • autodetect

是byType和constructor模式的结合体，如果对象拥有默认无参数的构造方法，容器会优先考虑byType的自动绑定模式。否则，会使用constructor模式。当然，如果通过构造方法注入绑定后还有其他属性没有绑定，容器也会使用byType对剩余的对象属性进行自动绑定。

依赖检查及继承

依赖检查

检查依赖是否按照预期绑定完成，其由dependency-check标签进行约束，存在以下4种模式:

  • none

不做依赖检查

  • simple

容器会对简单属性类型以及相关的collection进行依赖检查，对象引用类型的依赖除外。

  • object

只对对象引用类型依赖进行检查。

  • all

simple和object的结合体。

继承

新建服务器类，继承自计算机类:

public class Server extends Computer{
    // 名称
    private String name;
    // 主机
    private MainEngine mainEngine;
    // 显示器
    private Display display;
    // GPU型号
    private String gpuType;

    public Server() {
    }

    public Server(String name, MainEngine mainEngine, Display display, String gpuType) {
        super(name, mainEngine, display);
        this.gpuType = gpuType;
    }
		
		...
		get/set方法
		toString方法
	}

在spring-beans.xml配置文件中增加如下内容:

<bean id="server" parent="computer" class="com.ruanshubin.springboot.ioc.entity.Server">
		<property name="gpuType" value="TC800"/>
</bean>

修改启动类:

public class IocXmlTest {
    public static void main(String[] args) {
        XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-beans.xml"));
        Server server = beanFactory.getBean("server", Server.class);
        System.out.println(server);
    }
}

运行结果为:

Server{name='组装机1', mainEngine=MainEngine{name='戴尔', type='T600', cost=3600}, display=Display{name='惠普', type='V300', cost=1000}, gpuType='TC800'}

可以看到，我们通过parent标签完成了Bean继承的管理。

Bean的scope

Spring2.0前，Bean容器仅有2种作用域类型，即singleton和prototype，2.0后，又引入了3种web相关的scope类型，即request、session、global session。

singleton

  • 对象实例

容器中只存在一个共享实例。

  • 对象存活时间

第一次请求被实例化到容器销毁或者退出。

prototype

  • 对象实例

容器中存在多个实例。

  • 对象存活时间

每次请求即创建1个新的实例，对象实例返回给请求方之后，容器就不再拥有当前返回对象的引用，请求方需要自己负责当前返回对象的后继生命周期的管理工作，包括该对象的销毁。

  • request

Spring容器，即XmlWebApplicationContext会为每个HTTP请求创建一个全新的Request-Processor对象供当前请求使用，当请求结束后，该对象实例的生命周期即告结束。当同时有10个HTTP请求进来的时候，容器会分别针对这10个请求返回10个全新的RequestProcessor 对象实例，且它们之间互不干扰。

  • session

Spring容器会为每个独立的session创建属于它们自己的全新的UserPreferences对象实例。与request相比，除了拥有session scope的bean的实例具有比request scope的bean可能更长的存活时间，其他方面真是没什么差别。

  • global session

global session只有应用在基于portlet的Web应用程序中才有意义，它映射到portlet的global范围的session。如果在普通的基于servlet的Web应用中使用了这个类型的scope，容器会将其作为普通的session类型的scope对待。

  • 自定义scope

在Spring 2.0之后的版本中，容器提供了对scope的扩展点，这样，你可以根据自己的需要或者应用的场景，来添加自定义的scope类型。需要说明的是，默认的singleton和prototype是硬编码到代码中的，而request、session和global session，包括自定义scope类型，则属于可扩展的scope行列，它们都实现了org.springframework.beans.factory.config.Scope接口。

具体如何进行自定义scope的设计开发，以后我们专门写篇文章介绍。

下面看一个有意思的东西:

去除掉MainEngine的toString()方法，并将mainEngine的scope设置为prototype。

 <bean id="mainEngine" class="com.ruanshubin.springboot.ioc.entity.MainEngine" scope="prototype">
		<constructor-arg name="cost">
				<value>3600</value>
		</constructor-arg>
		<constructor-arg name="type">
				<value>T600</value>
		</constructor-arg>
		<constructor-arg name="name">
				<value>戴尔</value>
		</constructor-arg>
</bean>

修改主函数:

public class IocXmlTest {
    public static void main(String[] args) {
        XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-beans.xml"));
        Computer computer = (Computer) beanFactory.getBean("computer");
        System.out.println(computer.getMainEngine());
        System.out.println(computer.getMainEngine());
    }
}

运行:

com.ruanshubin.springboot.ioc.entity.MainEngine@4dfa3a9d
com.ruanshubin.springboot.ioc.entity.MainEngine@4dfa3a9d

显然，2次获取的MainEngine实例是同一个。

那么，如何在每次获取MainEngine时，总返回新创建的实例呢，可以使用<lookup-method>标签:

<bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer">
		<property name="name" value="组装机1"/>
		<property name="mainEngine" ref="mainEngine"/>
		<property name="display" ref="display"/>
		<lookup-method name="getMainEngine" bean="mainEngine"/>
</bean>

再次运行主函数:

com.ruanshubin.springboot.ioc.entity.MainEngine@480bdb19
com.ruanshubin.springboot.ioc.entity.MainEngine@2a556333

达到目的。

同时，可以对Computer的getMainEngine进行改造，使其每次从BeanFactory中取MainEngine得实例，操作方法是使Computer实现BeanFactoryAware接口。

public class Computer implements BeanFactoryAware {
	
    private BeanFactory beanFactory;
    
		@Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
    // 名称
    private String name;
    // 主机
    private MainEngine mainEngine;
    // 显示器
    private Display display;

    public Computer() {
    }

    public Computer(String name, MainEngine mainEngine, Display display) {
        this.name = name;
        this.mainEngine = mainEngine;
        this.display = display;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public MainEngine getMainEngine() {
        return beanFactory.getBean("mainEngine", MainEngine.class);
    }

    public void setMainEngine(MainEngine mainEngine) {
        this.mainEngine = mainEngine;
    }

    public Display getDisplay() {
        return display;
    }

    public void setDisplay(Display display) {
        this.display = display;
    }
}

此时，去掉以下配置，运行上述主程序:

<lookup-method name="getMainEngine" bean="mainEngine"/>

运行结果为:

com.ruanshubin.springboot.ioc.entity.MainEngine@402a079c
com.ruanshubin.springboot.ioc.entity.MainEngine@59ec2012

仍然可达到目的。

当然，如果不想实现BeanFactoryAware接口，也可以采用ObjectFactoryCreatingFactoryBean方式。

ObjectFactoryCreatingFactoryBean是Spring提供的一个FactoryBean实现，它返回一个ObjectFactory实例。从ObjectFactoryCreatingFactoryBean返回的这个ObjectFactory实例可以为我们返回容器管理的相关对象。

首先，在spring-beans.xml里配置ObjectFactoryCreatingFactoryBean，并注入主机类。

<bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
		<property name="targetBeanName">
				<idref bean="mainEngine"/>
		</property>
</bean>

<bean id="computer" class="com.ruanshubin.springboot.ioc.entity.Computer">
		<property name="name" value="组装机1"/>     
		<property name="display" ref="display"/>
		<property name="objectFactory">
				<ref bean="objectFactory"/>
		</property>
</bean>

同时修改Computer类:

public class Computer{
	
    private ObjectFactory objectFactory;

    public void setObjectFactory(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
    }

    // 名称
    private String name;
    // 主机
    private MainEngine mainEngine;
    // 显示器
    private Display display;

    public Computer() {
    }

    public Computer(String name, MainEngine mainEngine, Display display) {
        this.name = name;
        this.mainEngine = mainEngine;
        this.display = display;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public MainEngine getMainEngine() {
        return (MainEngine) objectFactory.getObject();
    }

    public void setMainEngine(MainEngine mainEngine) {
        this.mainEngine = mainEngine;
    }

    public Display getDisplay() {
        return display;
    }

    public void setDisplay(Display display) {
        this.display = display;
    }
}

运行结果为:

com.ruanshubin.springboot.ioc.entity.MainEngine@5cb9f472
com.ruanshubin.springboot.ioc.entity.MainEngine@56ef9176

写着写着就写多了，更多Spring-IOC容器XML配置的东西，我们后面有机会再讲。

Spring IOC 快速入门 配置XML和使用
06-19 530
前置技能: Java、JDBC、 什么是IOC: 控制反转（Inversion of Control），是面向对象编程中的一种设计原则，可以降低代码之间的耦合度。 最常见的实现方式是依赖注入（Dependency Injection） 什么是DI： 依赖注入（Dependency Injection），A对象依赖B接口类型对象，容器把B接口的一个实现类实例化对象赋值给A中的属性b（使A持有...
Spring IOC(XML)
weixin_44545672的博客
01-21 177
开发工具与关键技术：eclipse.exe 作者：农村扛粑子 撰写时间：2020年12月28日 IOC 反转控制 是Spring的基础，Inversion Of Control 简单说就是创建对象由以前的程序员自己new 构造方法来调用，变成了交由Spring创建对象 DI 依赖注入 Dependency Inject. 简单地说就是拿到的对象的属性，已经被注入好相关值了，直接使用 即可。 首先创建Java项目。打开软件右上角点击File,点击New,在点击Dynamic Web Projiect然后就按
Spring IOC XML版
weixin_41978551的博客
08-10 132
将获取一个对象，从原来的主动new创建，转变成由一个容器进行管理，容器能够自动的创建和配置对象，程序员只需按需索取即可。 XML配置Bean <!--注册一个Person对象，Spring会自动创建这个Person对象--> <!-- 一个Bean标签可以注册一个组件(类、对象) class：写要注册的组件的全类名 id：这个对象的唯一表示，以后通过getBean(id)来从容器中找到这个对象，以及ref = id来将这个对象注入到其他组件中 --> <bean id = "
Spring中Xml文件配置以及使用注解消除Xml
最新发布
qq_25206103的博客
09-23 771
快速了解Spring中Xml文件配置以及使用注解消除Xml
Spring IoC_xml
qq_17514043的博客
10-27 233
Spring IoC Spring IoC 容器组件，可以完成对象的创建、对象的属性赋值、对象管理 Spring框架部署（IoC） 新建Maven工程 java web 添加Spring IoC依赖 core beans aop expression context <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans --> &lt
Spring-IOC_xml
weixin_44919936的博客
04-27 197
文章目录概述入门案例IOC容器(IOC底层原理)IOC(接口）AppliactionContext接口的常用实现类IOC操作bean管理基于xml方式的bean管理（1）DI依赖注入-set和构造器两种方法Xml注入其他类型的属性（2）注入属性-外部bean（3）注入属性-内部bean和级联赋值Xml注入集合属性FactoryBean 工厂beanBean的作用域Bean的生命周期Xml自动装配引入外部属性文件 概述 Spring是开源的J2EE应用程序框架 目的是解决企业应用开发的复杂性 Sprin
coco-spring-ioc
04-16
6. **注解驱动的配置**：Spring-ioc也支持使用注解来替代XML配置，如`@Component`、`@Autowired`等。通过分析“coco-spring-ioc”的源码，我们可以学习如何实现类似的注解驱动的配置机制。 7. **Bean的生命周期管理...
maven-spring-ioc
08-07
Spring IoC通过XML配置文件实现了对象的实例化和依赖注入，有效地降低了对象间的耦合，提高了代码的可读性和可维护性。理解并熟练运用Spring的IoC机制是成为一名优秀的Java开发者的关键步骤之一。在实际项目中，结合...
Spring-IOC丐版
02-26
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IOC）特性而闻名。在这个名为"Spring-IOC丐版"的项目中，我们将深入探讨...
Spring-ioc-jar
07-18
学习Spring IOC，你需要理解Bean的定义、作用域、依赖注入的原理和方式，以及如何通过配置文件或注解来配置Bean。同时，掌握如何利用ApplicationContext获取Bean，以及如何利用AOP和生命周期管理功能，将帮助你更好...
Spring-IOC手动模拟实现-利用dom4解析xml文件
06-28
/*模拟spring的实现 * 1.通过构造器获取配置文件 * 2.通过dom4j解析配置文件，得到list集合（存放Bean标签的id和class属性） * 3.通过反射实例化得到对应的实例化对象，放置在map中（map是键值对，可根据id获取值）...
spring IOC容器依赖注入XML配置
02-05
spring IOC容器依赖注入XML配置详解 运行环境：eclipse 构建工具：maven 不提供maven构建，maven用来解决jar包的依赖
spring配置文件:整理总结Spring中XML配
02-24
　Spring是个强大JAVA应用框架广泛地应用于JAVA应用为PlainOldJavaObjects(POJOs)提供企业级 服务Spring利用依赖注入机制来简化工作同时提高易测性Springbeans及依赖以及beans类所需服务都在配置 文件中进行了详细介绍说明这个配置文件是典型XML格式但是它既冗长又不实用对于需要定义大量 Springbeans大工程来说我们难以阅读和管理它 　　在这篇文章里对于SpringXML配置我将向你展示12种比较好实战其中些实战不仅是好实战更是必要实战除 此以外还有其他原因例如领域模型设计都能影响XML配置但是这篇文章重点研究XML配置易读性和易管理性
Spring IoC的XML实现方式
My vegetable has exploded.
03-15 631
Spring学习笔记, 通过XML配置文件方式实现IoC
Spring之IOC(xml配置)
zeo_123的博客
03-18 702
IOC( Inversion of Control )，控制反转，也叫依赖注入DI(dependency injection)，是Spring框架Core模块提供的核心功能。“控制反转”：对象A运行需要对象B，由主动创建变为IOC容器注入，这便是控制反转。“依赖注入”：获得依赖对象的过程被反转了，获取依赖对象的过程由自身创建变为由IOC容器注入，这便是依赖注入。
spring ioc(xml配置bean)
hewenjing8168的博客
05-26 511
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。1.xml配置实现iocpom.xml&lt;?xml version="1.0" encoding="UTF-8"?&g...
Spring系列---基本IoC/DI使用
qq_43404873的博客
11-16 283
Spring概述 什么是Spring Spring是一个以IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming)为内核的框架。IoC是Spring的基础。IoC实现的是一种控制，简单来说，就是以前调用new构造方法来创建对象，现在变成了使用Spring来创建对象。DI(Dependency Inject，依赖注入)与IoC的含义相同，从两个角度描述同一个概念。简单来说，DI就是对象的属性，已经被主任好相关值，直接使用即可。 控制反转(I
Spring-IOC实现（xml配置）
十月
04-15 291
IOC概念 IOC控制反转  是对象控制权的转移，从代码本身转移到外部容器，由spring容器来操作对象的创建、初始化、销毁工作。由spring控制对象的生命周期。 DI依赖注入  依赖注入是指程序运行过程中，遇到需要调用另一个对象协助时，无需在代码中闯将被调用者，而是依赖外部容器创建后传递给程序（依赖注入是最优秀的解耦方式），他是让spring的bean之间以配置文件方式组织咋一起。 两者之间...
Spring(IoC的xml配置)
qq_39440949的博客
09-21 262
一、Spring概述 1、Spring的优势 Spring 出现是为了解决JavaEE 实际问题： 方便解耦，简化开发        通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。 AOP编程的支持        通过...
Spring-IOC
11-13
2.在Spring配置文件中配置UserService实例 ```xml ``` 3.在代码中获取UserService实例并使用 ```java ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值