您现在的位置是：首页 >学无止境 >CodeNote_1.2.0_spring中bean的基本配置网站首页学无止境

CodeNote_1.2.0_spring中bean的基本配置

Cierlly 2024-06-17 11:27:04
简介CodeNote_1.2.0_spring中bean的基本配置

factory-bean 与 factory-method

在 XML 配置文件中，可以使用 元素来定义一个 FactoryBean，并配置其相关属性。下面是一个示例：

首先，创建一个实现了 FactoryBean 接口的工厂类 MyFactoryBean：

public class MyFactoryBean implements FactoryBean<Product> {
    @Override
    public Product getObject() throws Exception {
        // 在这里进行产品对象的创建逻辑
        return new ConcreteProduct();
    }

    @Override
    public Class<?> getObjectType() {
        return Product.class;
    }

    @Override
    public boolean isSingleton() {
        return true; // 或者根据需求返回是否为单例
    }
}

然后，在 XML 配置文件中配置 FactoryBean：

<bean id="myFactoryBean" class="com.example.MyFactoryBean" />

<bean id="myProduct" factory-bean="myFactoryBean" factory-method="getObject" />

在上述配置中，myFactoryBean 是 FactoryBean 的实例，通过 class 属性指定了实现类 com.example.MyFactoryBean。myProduct 是由 myFactoryBean 创建的产品对象，通过 factory-bean 属性指定了工厂 bean 的 ID，通过 factory-method 属性指定了工厂方法名 getObject。

使用 元素配置 FactoryBean，可以在应用程序中通过获取 myProduct bean 来获得由工厂创建的产品对象。

需要注意的是，FactoryBean 本身也是一个 Bean，因此需要给它定义一个唯一的 ID，并在其他地方引用它。同时，也要确保工厂方法 getObject 返回的对象类型与配置中的类型匹配，以便在其他地方正确使用。

bean的依赖注入

Setter注入

<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="stringBean" class="com.example.StringBean">
        <property name="stringValue" value="Hello, World!" />
    </bean>
    
    <!-- 注入空字符串 -->
    <bean id="emptyStringBean" class="com.example.StringBean">
        <property name="stringValue" value="" />
    </bean>
    
    <!-- 注入 null 值 -->
    <bean id="nullBean" class="com.example.NullBean">
        <property name="nullValue">
            <null />
        </property>
    </bean>
    
    <!-- 注入内部 Bean -->
    <bean id="outerBean" class="com.example.OuterBean">
        <property name="innerBean">
            <bean class="com.example.InnerBean" />
        </property>
    </bean>
    
    <!-- 注入已有 Bean -->
    <bean id="existingBean" class="com.example.ExistingBean" />
    
    <!-- 注入 List -->
    <bean id="listBean" class="com.example.ListBean">
        <property name="list">
            <list value-type="java.lang.Object">
                <value>Item 1</value>
                <!--引用已经定义好的demo1>
                <ref bean="demo1" />
                <!--定义一个内部bean，作为list的元素>
                <bean class="com.Demo1">
                	<property name="key" value="hello" />
                </bean>
                <value>Item 2</value>
                <value>Item 3</value>
            </list>
        </property>
    </bean>
    
    <!-- 注入 Set -->
    <bean id="setBean" class="com.example.SetBean">
        <property name="set">
            <set>
                <value>Item 1</value>
                <value>Item 2</value>
                <value>Item 3</value>
            </set>
        </property>
    </bean>
    
    <!-- 注入 Map -->
    <bean id="mapBean" class="com.example.MapBean">
        <property name="map">
            <map>
                <entry key="Key 1" value="Value 1" />
                <entry key="Key 2" value="Value 2" />
                <entry key="Key 3" value="Value 3" />
                <!--定义一个内部bean，作为entry的value -->
                <entry key="C">
                	<bean class="com.Demo1">
                		<property name="key" value="hello" />
                	</bean>
                </entry>
            </map>
        </property>
    </bean>
    
</beans>

相关的java类：

public class Demo2{
	private String code;
	private String name;
	...
	public static void main(String[] args){
		ClassPathXmlApplicationContext ctx = null;
		try{
			ctx = new ClassPathXmlApplicationContext(//"classpath:Demo2.xml");
			Demo2 o= ctx.getBean("demo2",Demo2.class);
			System.out.println(o.getList().getClass().getName());
			System.out.println(o.getSet().getClass().getName());
			System.out.println(o.getMap().getClass().getName());
		}finally{
			if(ctx != null){
				ctx.close();
			}
		}
	}
}

工厂方式注入

以下是一个使用 ListFactoryBean 的示例代码，展示了如何以工厂方式注入 ArrayList 和 LinkedList 等属性的实例：

<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">

    <!-- 使用 ListFactoryBean 注入 ArrayList -->
    <bean id="arrayList" class="org.springframework.beans.factory.config.ListFactoryBean">
        <property name="targetListClass" value="java.util.ArrayList" />
        <property name="sourceList">
            <list>
                <value>Item 1</value>
                <value>Item 2</value>
                <value>Item 3</value>
            </list>
        </property>
    </bean>
    
    <!-- 使用 ListFactoryBean 注入 LinkedList -->
    <bean id="linkedList" class="org.springframework.beans.factory.config.ListFactoryBean">
        <property name="targetListClass" value="java.util.LinkedList" />
        <property name="sourceList">
            <list>
                <value>Item A</value>
                <value>Item B</value>
                <value>Item C</value>
            </list>
        </property>
    </bean>
	    <bean id="hashSet" class="org.springframework.beans.factory.config.SetFactoryBean">
	    <property name="targetSetClass" value="java.util.HashSet" />
	    <property name="sourceSet">
	        <set>
	            <value>Item X</value>
	            <value>Item Y</value>
	            <value>Item Z</value>
	        </set>
	    </property>
	    </bean>
	<bean id="hashMap" class="org.springframework.beans.factory.config.MapFactoryBean">
	    <property name="targetMapClass" value="java.util.HashMap" />
	    <property name="sourceMap">
	        <map>
	            <entry key="Key 1" value="Value A" />
	            <entry key="Key 2" value="Value B" />
	            <entry key="Key 3" value="Value C" />
	        </map>
	    </property>
	</bean>

</beans>

在上述示例中，我们使用 ListFactoryBean 注入了一个 ArrayList 和一个 LinkedList。通过设置 targetListClass 属性为对应的列表类，然后在 sourceList 属性中定义列表的元素。您可以根据需要添加或修改元素，以适应您的实际情况。

请确保您的项目中包含了 Spring Framework 的相关依赖，并根据您的实际情况进行适当调整。

构造器注入

使用构造器注入时，可以通过 元素来注入参数。以下是使用构造器注入的示例代码：

<bean id="exampleBean" class="com.example.ExampleBean">
    <constructor-arg value="string value" />
    <constructor-arg ref="anotherBean" />
</bean>

<bean id="anotherBean" class="com.example.AnotherBean">
    <constructor-arg>
        <list>
            <value>item 1</value>
            <value>item 2</value>
            <value>item 3</value>
        </list>
    </constructor-arg>
</bean>

在上述示例中，我们创建了一个 ExampleBean 的实例，并使用构造器注入了两个参数。第一个参数是字符串类型的值 “string value”，通过 value 属性直接注入。第二个参数是引用类型，使用 ref 属性指定了另一个 bean anotherBean。anotherBean 使用构造器注入了一个列表类型的参数。

请根据您的实际情况修改类名和参数值，并确保在项目中正确引入了所需的类和依赖。

@Autowired和@Resource的区别

@Autowired 和 @Resource 都是用于依赖注入的注解，但它们有一些区别：

  1. 来源：@Autowired 是Spring框架提供的注解，而 @Resource 是Java标准的注解。

  2. 自动装配方式：@Autowired 是按照类型自动装配依赖，它会根据类型匹配来注入相应的bean。如果存在多个匹配的bean，可以通过添加 @Qualifier 注解指定具体的bean名称。而 @Resource 是按照名称自动装配依赖，它会根据指定的名称来查找并注入对应的bean。

  3. 默认注入方式：@Autowired 是按照 required=true 的方式注入依赖，默认情况下依赖必须存在，如果找不到匹配的bean，会抛出异常。可以通过将 required=false 来设置非必需的依赖。而 @Resource 是按照 required=false 的方式注入依赖，默认情况下依赖可以不存在，如果找不到匹配的bean，则将依赖设置为 null。

  4. 支持的注入方式：@Autowired 支持按类型注入、按名称注入和按属性名称注入。而 @Resource 只支持按名称注入。

  5. 扩展性：@Autowired 是Spring框架提供的注解，因此它具有更多的扩展性和灵活性，可以与其他Spring特性集成，如注解驱动的事务管理、AOP等。而 @Resource 是Java标准的注解，功能相对较简单，没有像 @Autowired 那么多的扩展功能。

总的来说，@Autowired 是Spring框架的一部分，更为强大和灵活，而 @Resource 是Java标准的注解，相对简单且功能较为有限。在选择使用哪个注解时，可以根据具体的需求和项目环境来决定。

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐