Spring：高级依赖关系配置&XML简化配置方式

最新推荐文章于 2021-12-25 17:55:32 发布
最新推荐文章于 2021-12-25 17:55:32 发布
阅读量244 收藏
点赞数
分类专栏： Spring/SpringMVC/MyBatis
版权所有——燕双嘤
本文链接：https://blog.csdn.net/qq_42192693/article/details/113241964
版权

1，高级依赖关系配置

Spring允许将Bean实例的所有成员变量，甚至基本类型的成员变量都通过配置文件来指定值，这种方式提供了很好的解耦。但是否真的值得呢？如果将基本类型的成员变量也通过配置文件指定，虽然提供了很好的解耦，但大大降低了程序的可读性（必须同时参照配置文件才可以知道程序中各成员变量的值）。因此，滥用依赖注入会产生严重问题！

最好的做法：组件与组件的耦合，采用依赖注入管理；但基本类型的成员的变量值，应直接在代码中设置。对于组件之间的耦合关系，通过使用控制反转，使代码变得清晰。因此，Bean无须管理依赖关系，而是由容器提供注入，Bean无须知道这些实例在哪里，以及它们具体的实现。

前面介绍的依赖关系，要么事基本类型的值，要么直接依赖于其他Bean。在实际的应用中，某个Bean实例的属性值可能是某个方法的返回值，或者类的Field值，或者另一个对象的getter方法返回值，Spring同样可以支持这种非常规的注入方式。Spring甚至支持将任意方法的返回值、类或对象的Field值、其他Bean的getter方法返回值，直接定义成容器中的一个Bean。

Spring框架的本质是：开发者在Spring配置文件中使用XML元素进行管理，实际驱动Spring执行相应的代码。

  • 使用<bean.../>元素，实际启动Spring执行无参数或有参数的构造器，或者调用工厂方法创建Bean。
  • 使用<property.../>元素，实际驱动Spring执行一次setter方法。

但Java程序还可能有其他类型的语句，如调用getter方法、调用普通方法、访问类或对象的Field，而Spring也为这种语句提供了对相应的配置语法。

  • 调用getter方法：使用PropertyPathFactoryBean。
  • 访问类或对象的Field对象：使用FieldRetrievingFactoryBean。
  • 调用普通方法：使用MethodInvokingFactoryBean。

可以换一个角度来看Spring框架：Spring框架的功能是什么？它可以让开发者无须书写Java代码就可以进行Java编程，当开发者XML采用合适语法进行配置后，Spring就可通过反射在底层执行任意的Java代码。

1.1，获取其他Bean的属性值

PropertyPathFactoryBean用来获取目标Bean的属性值（实际上就是它的getter方法的返回值），获得的值可注入给其他Bean，也可直接定义成新的Bean。

使用PropertyPathFactoryBean来调用其他Bean的getter方法需要指定如下信息：

  • 调用那个对象：由PropertyFactoryBean的setTargetObject(Object targetObject)方法指定。
  • 调用那个getter方法：由PropertyPathFactoryBean的setPropertyPath(String propertyPath)方法指定。
package Bean;
public class Person {
    private String name;
    private Son son;
    public void setName(String name) {
        this.name = name;
    }
    public void setSon(Son son) {
        this.son = son;
    }
    public String getName() {
        return name;
    }
    public Son getSon() {
        return son;
    }
}
---------------------------------
package Bean;
public class Son {
    private String age;
    public void setAge(String age) {
        this.age = age;
    }
    public String getAge() {
        return age;
    }
}
<?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.xsd">
    <bean id="person" class="Bean.Person">
        <property name="name" value="30"/>
        <property name="son">
            <bean class="Bean.Son">
                <property name="age" value="11"/>
            </bean>
        </property>
    </bean>
    <bean id="son1" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
        <property name="targetBeanName" value="person"/>
        <property name="propertyPath" value="son"/>
    </bean>
</beans>

上面配置文件使用PropertyPathFactoryBean来获取指定Bean的、指定getter的返回值，其中粗体代码指定了获取person的getSon()方法的返回值，该返回值将直接定义成容器中的son1。

PropertyPathFactoryBean就是工厂Bean，工厂Bean专门返回某个类型的值，并不是返回该Bean的实例。在这种配置方式下，配置PropertyPathFactoryBean工厂Bean时指定id属性，并不是该Bean的唯一标识，而是用于指定属性表达式的值。

AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(((Son)context.getBean("son1")).getAge());

Spring获取指定Bean的getter方法的返回值之后，该返回值不仅可直接定义成容器中的Bean，还可注入另一个Bean。

<bean id="son2" class="Bean.Son">
    <property name="age">
        <bean id="person.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>
    </property>
</bean>

上面的代码中，程序调用son2实例setAget()方法时的参数并不是直接指定的，而是将容器中另一个Bean实例的属性值（getter方法的返回值）作为setAge()方法的参数，PropertyPathFactoryBean工厂Bean负责获取容器中另一个Bean的属性值（getter()方法的返回值）。 

public static void main(String[] args) throws BeansException  {
    AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println(((Son)context.getBean("son2")).getAge());
}

为PropertyPathFactoryBean的setPropertyPath()方法指定属性表达式时，还支持使用复合属性的形式。

<bean id="son1" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
    <property name="targetBeanName" value="person"/>
    <property name="propertyPath" value="son.age"/>
</bean>
------------------------------------------
public static void main(String[] args) throws BeansException  {
    AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println(context.getBean("son1"));
}

1.2，获取Field值

通过FieldRetrievingFavtoryBean类，可访问类的静态Field或对象的实例Field值。FieldRetrievingFactoryBean获得指定Field的值之后，即可将获得的值注入其他Bean，也可直接定义成新的Bean。

使用FieldRetrievingFactoryBean访问Field值可分为两种情形：

（1）如果要访问的Field是静态Field，则需要指定：

  • 调用哪个类：由FieldRetrievingFactoryBean的setTargetClass(String targetClass)方法指定。
  • 访问哪个Field：由FieldRetrievingFactoryBean的setTargetField(String targetClass)方法指定。

（2）如果要访问的Field是实例Field，则需要指定：

  • 调用哪个对象：由FieldRetrievingFactoryBean的setTargetObject(Object targetObject)方法指定。
  • 访问哪个Field：由FieldRetrievingFactoryBean的setTargetField(String targetField)方法指定。

对于FieldRetrievingFactoryBean的第一种用法，与前面介绍FactoryBean时开发的GetFieldFactoryBean基本相同。对于FieldRetrievingFactoryBean的第二种用法，在实际编程机会没有太大作用，原因是根据良好的封装原则，Java类的实例Field应该用private修饰，并使用getter和setter来访问和修改。FieldRetrievingFactoryBean则要求实例Field以public修饰。

<?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.xsd">
    <bean id="theAge1" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
        <property name="targetClass" value="java.sql.Connection"/>
        <property name="targetField" value="TRANSACTION_SERIALIZABLE"/>
    </bean>
</beans>
public static void main(String[] args) throws BeansException  {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println(context.getBean("theAge1"));
}
=================================
8

FieldRetrievingFactoryBean还提供了一个setStaticField(String staticField)方法，该方法可同时指定获取哪个类的哪个静态Field值。

<bean id="theAge1" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
    <property name="staticField" value="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
</bean>

从程序输出可以看出，son的age成员变量的值，等于java.sql.Connection接口中TRANSACTION_SERIALIZABLE的值。在上面定义中，定义FieldRetrievingFactoryBean工厂Bean时指定的id属性，并不是该Bean实例的唯一标识，而是指定Field表达式。

1.3，获取方法返回值

通过MethodInvokingFactoryBean工厂Bean，可调用任意类的类方法，也可调用任意对象的实例方法，如果调用的方法有返回值，则即可将该指定方法的返回值定义成容器中的Bean，也可将指定方法的方法的返回值会注入给其他Bean。

使用MethodInvokingFactoryBean来调用任意方法时，可分为两种情形：

（1）如果希望调用的方法是静态方法，则需要指定：

  • 调用哪个类：通过MethodInvokingFactoryBean的setTargetClass(String targetClass)方法指定。
  • 调用哪个方法：通过MethodInvokingFactoryBean的setTargetMethod(String targetMethod)方法指定。
  • 调用方法的参数：通过MethodInvokingFactoryBean的setAtrguments(Object[] arguments)方法指定。

（2）如果希望调用的方法无须参数，则可以省略该配置：

  • 调用哪个对象：通过MethodInvokingFactoryBean的setTargetObject(Object targetObject)方法指定。
  • 调用哪个方法：通过MethodInvokingFactoryBean的setTargetMethod(String targetMethod)方法指定。
  • 调用方法的参数：通过MethodInvokingFactoryBean的setArguments(Object[] arguments)方法指定。
<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://www.springframework.org/schema/beans"
     xmlns:util="http://www.springframework.org/schema/util"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
     http://www.springframework.org/schema/util
     http://www.springframework.org/schema/util/spring-util-4.0.xsd">
     <!-- 下面配置相当于如下Java代码：
     JFrame win = new JFrame("我的窗口");
     win.setVisible(true); -->
     <bean id="win" class="javax.swing.JFrame">
           <constructor-arg value="我的窗口"  type="java.lang.String"/>
           <property name="visible" value="true"/>
     </bean>
     
     <!-- 下面配置相当于如下Java代码：
     JTextArea jta = JTextArea(7, 40); -->
     <bean id="jta" class="javax.swing.JTextArea">
           <constructor-arg value="7" type="int"/>
           <constructor-arg value="40" type="int"/>
     </bean>    
     
     <!-- 使用MethodInvokingFactoryBean驱动Spring调用普通方法
     下面配置相当于如下Java代码：
     win.add(new JScrollPane(jta)); -->
     <bean class=
     "org.springframework.beans.factory.config.MethodInvokingFactoryBean">
           <property name="targetObject" ref="win"/>
           <property name="targetMethod" value="add"/>
           <property name="arguments">
                <list>
                     <bean class="javax.swing.JScrollPane">
                           <constructor-arg ref="jta"/>
                     </bean>
                </list>
           </property>
     </bean>
     
     <!-- 下面配置相当于如下Java代码：
     JPanel jp = new JPanel(); -->
     <bean id="jp" class="javax.swing.JPanel"/>
     <!-- 使用MethodInvokingFactoryBean驱动Spring调用普通方法
     下面配置相当于如下Java代码：
     win.add(jp , BorderLayout.SOUTH); -->
     <bean class=
           "org.springframework.beans.factory.config.MethodInvokingFactoryBean">
           <property name="targetObject" ref="win"/>
           <property name="targetMethod" value="add"/>
           <property name="arguments">
                <list>
                     <ref bean="jp"/>
                     <util:constant  static-field="java.awt.BorderLayout.SOUTH"/>
                </list>
           </property>
     </bean>
     
     <!-- 下面配置相当于如下Java代码：
     JButton jb1 = new JButton("确定"); -->
     <bean id="jb1" class="javax.swing.JButton">
           <constructor-arg value="确定"  type="java.lang.String"/>
     </bean>
     
     <!-- 使用MethodInvokingFactoryBean驱动Spring调用普通方法
     下面配置相当于如下Java代码：
     jp.add(jb1); -->
     <bean  class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
           <property name="targetObject" ref="jp"/>
           <property name="targetMethod" value="add"/>
           <property name="arguments">
                <list>
                     <ref bean="jb1"/>
                </list>
           </property>
     </bean>
     <!-- 下面配置相当于如下Java代码：
     JButton jb2 = new JButton("取消"); -->
     <bean id="jb2" class="javax.swing.JButton">
           <constructor-arg value="取消"  type="java.lang.String"/>
     </bean>
     
     <!-- 使用MethodInvokingFactoryBean驱动Spring调用普通方法
     下面配置相当于如下Java代码：
     jp.add(jb2); -->
     <bean class=
           "org.springframework.beans.factory.config.MethodInvokingFactoryBean">
           <property name="targetObject" ref="jp"/>
           <property name="targetMethod" value="add"/>
           <property name="arguments">
                <list>
                     <ref bean="jb2"/>
                </list>
           </property>
     </bean>
     <!-- 使用MethodInvokingFactoryBean驱动Spring调用普通方法
     下面配置相当于如下Java代码：
     win.pack(); -->
     <bean class=
           "org.springframework.beans.factory.config.MethodInvokingFactoryBean">
           <property name="targetObject" ref="win"/>
           <property name="targetMethod" value="pack"/>
     </bean>
</beans>
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

几乎所有的Java代码都可以通过Spring XML配置文件配置出来——连上吗的Swing编程都可以使用Spring XML配置文件来驱动。

Spring框架的本质：通过XML配置来执行Java代码，因此几乎可以把所有的Java代码放入到Spring配置文件中管理。

  • 调用构造器创建对象（包括使用工程方法创建对象）：用<bean.../>元素。
  • 调用setter方法：用<property.../>元素。
  • 调用getter方法：用PropertyPathFactoryBean。
  • 调用普通方法：用MethodInvokingFactoryBean。
  • 获取Field的值：用FieldRetrievingFactoryBean。

但是，过度使用XML配置文件不仅使得配置文件更加臃肿，难以维护，而且导致程序可读性严重降低。一般来说，应该将：项目升级、维护时需要改动的信息。控制项目内各组件的耦合关系的代码。放到XML配置文件。这就体现了Spring IoC容器的作用：将原来使用Java代码管理的耦合关系，提取到XML中进行管理，从而降低了各组件之间的耦合，提高了软件系统的可维护性。

2，基于XML Schema的简化配置方式

从Spring2.0开始，Spring允许使用基于XML Schema的配置方式来简化Spring配置文件。

早期Spring用一种<bean.../>元素即可配置所有的Bean实例，而每个设值注入再用一个<property.../>元素即可。这种配置方式简单、直观，而且能以相同风格处理所有Bean的配置——唯一的缺点是配置烦琐，当Bean实例足够多的时候，且类型复杂（大多数是集合注入）时，基于DTD的配置文件将变得更加烦琐。

这种情况下，Spring提出了使用基于XML Schema的配置方式。这种配置方式更加简洁，可以对Spring配置文件进行“减肥”。

2.1，使用p：命名空间简化配置

p：命名空间甚至不需要特定的Schema定义，它直接存在于Spring内核中。与前面采用<property.../>元素定义Bean的属性不同的是，当导入p:命名空间之后，就可直接在<bean.../>元素中使用属性来驱动执行setter方法。

xmlns:p="http://www.springframework.org/schema/p"
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="son" class="Bean.Son" p:age="22"></bean>
</beans>

2.2，使用c：命名空间简化配置

c：用于简化构造注入。

xmlns:c="http://www.springframework.org/schema/c"
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="son" class="Bean.Son" c:age="22"></bean>
</beans>

使用c:指定构造器参数的格式为：c：构造器参数名=“值”或c：构造器参数名-ref=“其他Bean的id”。

另外，Spring还支持一种通过索引来配置构造参数的方式。

<bean id="son" class="Bean.Son" c:_0="22"></bean>

2.3，使用util：命名空间简化配置

在Spring框架压缩包的schema\util\路径下包含有util:命名空间的XML Schema文件，为了使用util:命令空间的元素，必须先在Spring配置文件中导入最新的spring-util-4.3.xsd。

<?xml version="1.0" encoding="GBK"?>
<!-- 指定Spring配置文件的根元素和Schema
	导入p:命名空间和util:命名空间的元素 -->
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/util 
		http://www.springframework.org/schema/util/spring-util-4.3.xsd">
	<!-- 配置chinese实例，其实现类是Chinese -->
	<bean id="chinese" class="Bean.Chinese"
		p:age-ref="chin.age" p:axe-ref="stoneAxe"
		p:schools-ref="chin.schools"
		p:axes-ref="chin.axes"
		p:scores-ref="chin.scores"/>
	<!-- 使用util:constant将指定类的静态Field定义成容器中的Bean -->
	<util:constant id="chin.age" static-field=
		"java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
	<!-- 使用util.properties加载指定资源文件 -->
	<util:properties id="confTest"
		location="classpath:test_zh_CN.properties"/>
	<!-- 使用util:list定义一个List集合，指定使用LinkedList作为实现类，
	如果不指定默认使用ArrayList作为实现类 -->
	<util:list id="chin.schools" list-class="java.util.LinkedList">
		<!-- 每个value、ref、bean...配置一个List元素 -->
		<value>小学</value>
		<value>中学</value>
		<value>大学</value>
	</util:list>
	<!-- 使用util:set定义一个Set集合，指定使用HashSet作为实现类，
	如果不指定默认使用HashSet作为实现类-->
	<util:set id="chin.axes" set-class="java.util.HashSet">
		<!-- 每个value、ref、bean...配置一个Set元素 -->
		<value>字符串</value>
		<bean class="Bean.SteelAxe"/>
		<ref bean="stoneAxe"/>
	</util:set>
	<!-- 使用util:map定义一个Map集合，指定使用TreeMap作为实现类，
	如果不指定默认使用HashMap作为实现类 -->
	<util:map id="chin.scores" map-class="java.util.TreeMap">
		<entry key="数学" value="87"/>
		<entry key="英语" value="89"/>
		<entry key="语文" value="82"/>
	</util:map>
	<!-- 配置steelAxe实例，其实现类是SteelAxe -->
	<bean id="steelAxe" class="Bean.SteelAxe"/>
	<!-- 配置stoneAxe实例，其实现类是StoneAxe -->
	<bean id="stoneAxe" class="Bean.StoneAxe"/>
</beans>

 

燕双嘤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2、基于XML的依赖注入详细配置
余笙的博客
12-09 1310
依赖注入详细配置
cron定制任务配置参数问题
weixin_34384557的博客
04-03 193
2019独角兽企业重金招聘Python工程师标准>>> ...
java游戏服务器开发之六--整合spring
热门推荐
cmqwan的博客
06-18 1万+
netty和spring的结合 上篇将netty大致部署好了，但是里面的配置我们都是写在代码里面，其实这样是不太好的，毕竟你改个参数就要打包一下。 所以打算写在配置文件中，顺便把spring也集成进来   第一步，在pom文件中加入spring的包,   &lt;spring.version&gt;4.2.4.RELEASE&lt;/spring.version&gt;这个写在propert...
Spring实战之使用util:命名空间简化配置操作示例
09-18
主要介绍了Spring实战之使用util:命名空间简化配置操作,结合实例形式分析了Spring使用util:命名空间简化配置操作的具体步骤与相关操作注意事项,需要的朋友可以参考下
Spring框架学习笔记（三）Xml高级配置
sdau_20171819的博客
02-04 164
第二篇写完了xml的基本配置方法，那么这一篇就开始写一下Xml的高级配置（没有啥，可能只是我这么说。。。）闲话少说，现在开始 1. bean 之间的关系：继承 or 依赖 如果配置两个bean，但是发现里面很多属性是一样的，比如Car类，车标一样，产地一样，价格不一样...这时候就可以想到一个关系就是 继承，子类继承父类，子类中就有父类中的各个属性，然后重写不一样的属性，就完成了一...
spring配置文件:整理总结Spring中XML配
02-24
服务Spring利用依赖注入机制来简化工作同时提高易测性Springbeans及依赖以及beans类所需服务都在配置 文件中进行了详细介绍说明这个配置文件是典型XML格式但是它既冗长又不实用对于需要定义大量 Springbeans大工程来...
Spring核心注解深入解析：提升开发效率
12-13
@Configuration 和 @Bean 注解用于Java配置，允许开发者用程序的方式定义Spring容器中的bean，取代传统的XML配置文件。 @Value 提供了一种方便的方式来注入简单类型的属性，支持SpEL表达式和外部配置。
Spring高级之注解驱动开发视频教程
11-05
学习spring，要有一定的Java基础，同时应用过spring基于xml的配置。（或者学习过官网的Spring课程） 学习springmvc，要有一定java web开发基础。同时对spring框架要有一定了解。 3、课程亮点 系统的学习Spring框架...
Spring Boot是一个基于Spring框架的开源项目，旨在简化Spring应用的初始搭建以及开发过程 以下是对Spring
最新发布
05-05
Spring Boot是一款快速、轻便的Java开发框架，它为Spring应用提供了更加简化的开发方式。它解决了在开发过程中经常遇到的配置繁琐、依赖管理复杂等问题，使开发者能够更专注于业务逻辑的实现。 首先，Spring Boot...
jetty4spring:该库有助于将Jetty嵌入到Spring应用程序中
05-06
我决定编写一个Spring命名空间，以简化这些XML片段并使它们更具可读性。 该库是此决定的结果。如何使用如果您使用的是Maven，请在您的项目中添加以下依赖项。 <dependency> <groupId>org.urbantower</groupId> ...
Spring定时任务传参问题 <property name="arguments"
weixin_33736048的博客
11-30 753
<bean id="mayAckRedeemGiftJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="mayAckRedeemGiftJob"/> <!-- <...
Spring配置中使用util标签
鹤啸九天
07-10 1万+
需要在applicationContext.xml文件中的开头部分加入以下描述：xmlns:util="http://www.springframework.org/schema/util"，并在xsi:schemaLocation描述中插入以下xsd描述： http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.0.xsd
spring工程相互依赖关系(最为常用,必会精华)
pingzhuyan的博客
11-15 1900
1. 了解两个xml 下列代码所示 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <.
Spring定时器中关于方法传参的问题
君玲菜鸟笔记
10-13 7377
<bean id="autoDetailTransactionTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean" scope="singleton"> -->
Spring中Xml配置Bean的依赖注入源码分析
陈俊的马蹄印
04-01 1222
     上一篇 IOC容器从BeanFactory获取Bean源码浅析中，实例化bean到IOC容器中，是通过默认无参构造器来实例化的，没有涉及到Bean的依赖注入问题。现补上。     bean依赖注入过程，首先实例化，可以通过构造器实例化，也可以通过cblib代理实例化。然后解析属性值，如果是基本类型，则不需要解析，如果是对象的引用类型，则要实例化该属性的引用对象。最后通过反射机制对对象属性...
spring依赖关系配置
09-10 95
spring中xml配置和类配置
weixin_43896929的博客
12-25 712
spring中xml配置和类配置 基于xml进行配置的方式初始化容器，ClasspathXmlApplicationContext，这种方式在ssm整合时候使用。 基于类进行配置的方式来初始化容器：AnnocationConfigApplicationContext，这种方式在springboot框架使用。 基于 xml 的 spring 文件配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springf
Spring实战——使用util:命名空间简化配置
实践求真知
09-25 625
一配置 <?xml version="1.0" encoding="GBK"?> <!-- 指定Spring配置文件的根元素和Schema 导入p:命名空间和util:命名空间的元素 --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http:/...
Spring学习（三）Spring配置bean对象
周帅傅
06-24 301
Spring学习（三）Spring配置bean对象 一、spring对象的获取及属性赋值方式 1、通过bean的id获取IOC容器中的对象 public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml"); //根据bean标签的id来获取对象
spring xml配置
07-27
Spring XML配置是一种传统的配置方式，用于配置Spring框架中的Bean和它们之间的依赖关系。通过XML配置文件，我们可以定义和组织应用程序中的各个组件，包括Bean的定义、Bean之间的关系、AOP配置、数据源配置等。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值