Spring之创建Bean的方式

最新推荐文章于 2024-08-05 23:51:30 发布
最新推荐文章于 2024-08-05 23:51:30 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： SSH开发 SSH框架 文章标签： 创建Bean Spring 工厂方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carson0408/article/details/79038348
版权

Bean有别于传统的JavaBean，任何应用组件都可以作为Bean，接下来讲述的是Spring中创建Bean的方式。

1.调用构造器创建Bean

使用构造器来创建Bean是最常见的情况，如果是构造注入，则通过配置构造函数来实现创建Bean，如果是设值注入，Spring底层会调用Bean类的无参数构造器来创建实例。以下讲述的是设值注入。
以下是需要的接口 
package impl;


public interface Axe {
	public String chop();

}

package impl;

public interface Creature {

	public void useTool();
}

package impl;

public interface Metal {
	public String make();

}
以下是三个接口相应的实现类： 

package impl.handle;

import impl.Axe;

public class StealAxe implements Axe {

	@Override
	public String chop() {
		// TODO Auto-generated method stub
		return "使用斧头砍柴";
	}

}

package impl.handle;

import impl.Axe;
import impl.Creature;
import impl.Metal;
public class Person implements Creature
{
	private Axe axe;
	private Metal metal;
	// 设值注入所需的setter方法
	public void setMetal(Metal metal)
	{
		this.metal=metal;
		
	}
	public void setAxe(Axe axe)
	{
		this.axe=axe;
	}
	public void useTool()
	{
		System.out.println("我打算去砍点柴火！");
		// 调用axe的chop()方法，
		// 表明Person对象依赖于axe对象
		System.out.println(metal.make());
		System.out.println(axe.chop());
	}
}

package impl.handle;

import impl.Metal;

public class Steal implements Metal {
	public String make()
	{
		return "使用铁做斧头";
	}

}
根据需要的功能，编写工具类 

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import impl.handle.*;
import impl.*
;public class BeanTest
{
	public static void main(String[] args)throws Exception
	{
		// 以类加载路径下的beans.xml文件创建Spring容器
		ApplicationContext ctx = new
			ClassPathXmlApplicationContext("beans.xml");    // ①
		// 加载类的时候需要加载接口，从而真正实现面向接口编程。
		Creature c=(Creature)ctx.getBean("person", Creature.class);
		c.useTool();
	}
}
然后对Beans.xml文件进行配置 

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	<!-- 配置名为person的Bean，其实现类是org.crazyit.app.service.Person类 -->
	<bean id="person" class="impl.handle.Person">
		<property name="metal" ref="steal"/>
		<property name="axe" ref="stealAxe"/>
	</bean>
	<bean id="steal" class="impl.handle.Steal"/>
	<bean id="stealAxe" class="impl.handle.StealAxe"/>
</beans>

以上是设值注入，所以使用的是Spring底层调用Bean类的无参数构造器来创建实例的。这里的Bean类是指Steal类和StealAxe类。

2.调用静态工厂方法创建Bean

所谓静态工厂方法就是建立一个工厂类，工厂类有个静态工厂方法，让产品的实例化在工厂类的静态工厂方法中进行，让整个过程都面向接口编程。并且在配置beans.xml文件略有不同。通过以下例子进行详细讲述。
首先先定义一个接口，该接口的实例就是在静态工厂方法中生产的。 

package handle;

public interface Being {
	public void testBeing();

}
以下两个类Dog类和Cat类便是以上接口的实现类。 

package handle.impl;

import handle.Being;

public class Dog implements Being {
	
	private String msg;
	public void setMsg(String msg)
	{
		this.msg=msg;
	}
	//实现接口中的testBeing()方法
	@Override
	public void testBeing() {
		// TODO Auto-generated method stub
		System.out.println(msg+",狗爱啃骨头");

	}

}

package handle.impl;

import handle.Being;

public class Cat implements Being {

	private String msg;
	public void setMsg(String msg)
	{
		this.msg=msg;
	}
	@Override
	public void testBeing() {
		// TODO Auto-generated method stub
		System.out.println(msg+",猫喜欢吃老鼠");

	}

}

相应的类都准备就绪，产品的原料都到了，就等着工厂进行集中生产，于是我们应当建立一个工厂类，然后在工厂类中建立一个静态工厂方法，将所有的类进行相应的实例化。 
package factory;
import handle.*;
import handle.impl.*;
public class BeingFactory {
	//返回Being实例的静态工厂方法
	public static Being getBeing(String arg)
	{
		//调用次静态方法的参数是dog，则返回Dog实例
		if(arg.equalsIgnoreCase("dog"))
		{
			return new Dog();
		}
		else
		{
			return new Cat();
		}
	}

}
以上便是一个工厂类BeingFactory，而工厂类有个静态方法是getBeing(String arg)，而arg是传入的参数，相当于外界需要什么类的实例，则工厂方法就实例化什么类。
以下是beans.xml的配置内容： 
<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	<bean id="dog" class="factory.BeingFactory" factory-method="getBeing">
		<constructor-arg value="dog"/>
		<property name="msg" value="我是狗"/>
	</bean>
	<bean id="cat" class="factory.BeingFactory" factory-method="getBeing">
		<constructor-arg value="cat"/>
		<property name="msg" value="我是猫"/>
	</bean>
</beans>
可以看出<bean.../>子元素中id还是指实例名，作为标识作用，而class与构造器创建Bean的有所不同，构造器创建Bean的class指的是id对应的需要实例的类名，而静态工厂方法创建Bean中的class是工厂类的类名(包含包路径)，另外不同的是还多了factory-method元素，是指工厂类中的静态工厂方法名，如上便是getBeing。而静态方法需要的相应的参数，则使用<constructor-arg.../>传入，而传入的参数还需要参数，则由<property.../>元素传入。
接下来是建立工具类： 
package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import handle.*;
public class SpringTest {

	public static void main(String[] args)
	{
		// 以类加载路径下的beans.xml文件创建Spring容器
		ApplicationContext ctx = new
			ClassPathXmlApplicationContext("beans.xml"); 
		Being b1=ctx.getBean("dog", Being.class);
		b1.testBeing();
		Being b2=ctx.getBean("cat", Being.class);
		b2.testBeing();
	}
}
运行工具类之后，得到如下结果： 

我是狗,狗爱啃骨头
我是猫,猫喜欢吃老鼠
以上便是静态工厂方法创建Bean的示例。与构造器创建Bean最大的不同便是使用了工厂方法集中实例化，还有就是配置中<bean.../>元素中的class的不同。

3.调用实例工厂方法创建Bean

调用实例工厂方法与调用静态工厂方法类似，只是工厂类中的工厂方法有无static之分，以及配置上内容稍有差异，为便于区分，仍然使用调用静态工厂方法的示例。

先是产品接口： 
package handle;

public interface Being {
	public void testBeing();

}
然后相应的产品类： 

package handle.impl;

import handle.Being;

public class Dog implements Being {
	
	private String msg;
	public void setMsg(String msg)
	{
		this.msg=msg;
	}
	//实现接口中的testBeing()方法
	@Override
	public void testBeing() {
		// TODO Auto-generated method stub
		System.out.println(msg+",狗爱啃骨头");

	}

}

package handle.impl;

import handle.Being;

public class Cat implements Being {

	private String msg;
	public void setMsg(String msg)
	{
		this.msg=msg;
	}
	@Override
	public void testBeing() {
		// TODO Auto-generated method stub
		System.out.println(msg+",猫喜欢吃老鼠");

	}

}
建立工厂类，可以看到工厂类中的工厂方法没有static。 

package factory;
import handle.*;
import handle.impl.*;
public class BeingFactory {
	//返回Being实例的静态工厂方法
	public Being getBeing(String arg)
	{
		//调用次静态方法的参数是dog，则返回Dog实例
		if(arg.equalsIgnoreCase("dog"))
		{
			return new Dog();
		}
		else
		{
			return new Cat();
		}
	}

}
以下是beans.xml的配置： 
<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	<!-- 配置名为beingFactory的工厂类Bean，其实现类是factory.beingFactory类 -->
	<bean id="beingFactory" class="factory.BeingFactory"/>
	<!-- 下面配置驱动Spring调用beingFactory Bean的getBeing()方法来创建Bean,该Bean元素包含地constructor-arg元素用于为工厂方法指定参数
	BeingFactory bf=container.get("beingFactory");//container代表Spring容器
	dog=bf.getBeing("dog");-->
	<bean id="dog" factory-bean="beingFactory" factory-method="getBeing">
		<constructor-arg value="dog"/>
		<property name="msg" value="我是狗"/>
	</bean>
	<bean id="cat" factory-bean="beingFactory" factory-method="getBeing">
		<constructor-arg value="cat"/>
		<property name="msg" value="我是猫"/>
	</bean>
</beans>
从以上配置内容可以看出，先对工厂类进行配置，工厂类的配置跟调用构造器的配置类似，主要是id与class，然后进行配置产品实例，id仍然是产品名，但是没有class，而是用factory-bean取代，factory-bean就是前面已经配置好的工厂类的id，factory-method则是工厂方法，其余都同调用静态工厂方法。主要区别在于先进行工厂类的Bean配置，然后配置产品Bean实例时，class用factory-bean取代。
最后建立工具类： 

package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import handle.*;
public class SpringTest {

	public static void main(String[] args)
	{
		// 以类加载路径下的beans.xml文件创建Spring容器
		ApplicationContext ctx = new
			ClassPathXmlApplicationContext("beans.xml"); 
		Being b1=ctx.getBean("dog", Being.class);
		b1.testBeing();
		Being b2=ctx.getBean("cat", Being.class);
		b2.testBeing();
	}
}
运行工具类，得到如下结果： 
我是狗,狗爱啃骨头
我是猫,猫喜欢吃老鼠
综上所述，创建Bean的三种方式，首先使用工厂方法创建Bean与调用构造器创建Bean的区别在于：1.前者使用了工厂方法便于集中管理，而后者只是将Bean实例作为参数传入其它类。2.配置beans.xml的内容略有不同。
而调用静态方法创建Bean与调用实例工厂方法创建Bean的区别：
1.配置实例工厂方法创建Bean，必须将实例工厂配置成Bean实例，而配置静态工厂方法创建Bean，无须配置工厂Bean
2.配置实例工厂方法创建Bean，必须使用factory-bean属性确定工厂Bean，而配置静态工厂方法创建Bean，使用class元素确定静态工厂类。
相同之处：
1.都需要factory-method属性确定Bean实例的工厂方法
2.工厂方法需要参数，都使用<constructor-arg.../>元素指定参数值
3.普通的设值注入，都使用<property.../>元素确定参数值







carson0408
关注
专栏目录
Spring中创建bean的三种方式
weixin_45430616的博客
01-24 264
在IDEA中创建maven项目 整体构架 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...
Spring创建Bean的几种方式
weixin_42828799的博客
06-14 2569
最简单的配置，可以通过xml中bean标签来设置 通过这种方法要在响应类中添加get和set方法,或者添加构造方法.或者可以通过静态工厂或者实例工厂方法 通过这种方式配置要创建一个工厂类,然后将类和方法在xml文件中配置.最后我们还可以通过实现FactoryBean接口来创建一个bean,然后再xml中配置这个实现类即可. 需要注意的是BeanFactory和FactoryBean完全不是一个概念.BeanFactory是spring容器最基本的接口,他提供了spring容器的最基本方法,但是不
spring中创建bean的方式
清华大咖
07-20 2439
一、常见的bean创建方式 (1)基于xml配置bean (2)使用@Component派生注解 (3)使用@Configuration和@Bean注解 1、常见的使用xml中setter方法创建bean bean.xml文件中配置bean时，加上<property>标签设置bean所需参数 <bean id="bookManageDao" class="com.swys...
Spring源码(四)：bean的创建
最新发布
bashenanking的博客
08-05 965
本节紧接上一篇，深入讨论一个标准bean在Spring中究竟是如何生成&销毁的（重点关注Spring对bean的构造方法、注入字段、各种扩展方法的处理，以及围绕整个bean的全生命周期，Spring留了那些扩展点给用户实现）
Spring创建对象的方式3种方式
weixin_34355881的博客
06-10 177
此文为基础回顾，估计是最后一次总结。 项目利用maven进行架构，其基本项目结构为： 其中pom.xml中的内容为： &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="h...
spring中创建bean的三种方式
qq_42536483的博客
05-07 1866
之前学习了bean创建的三种方式 1：通过默认无参构造方法创建 <bean id="person" class="com.dgut.Person"></bean> 2：使用静态工厂的方法创建对象 public class StaticFactory { 工厂的静态方法创建 public static Person createPerson(){ ...
Spring：创建Bean的几种方式
热门推荐
VipMao的博客
06-04 1万+
Spring创建工厂的三种方式
Spring如何使用注解的方式创建bean
08-25
Spring 使用注解方式创建 Bean Spring 框架中提供了多种方式来创建 Bean，使用注解方式创建 Bean 是其中的一种常用方式。下面将详细介绍使用注解方式创建 Bean 的步骤和相关知识点。 使用@Configuration 和@Bean ...
Spring创建bean对象三种方式代码实例
08-18
总结，Spring框架提供了灵活的方式来创建Bean对象，可以根据具体需求选择合适的方法。无参构造方法适合简单场景，静态工厂和实例工厂则更适合复杂情况，如需进行特殊初始化或复用已有对象。理解并熟练掌握这些创建...
Spring Bean创建初始化流程.docx
03-04
在`doCreateBean()`方法中，Spring会创建Bean的实例，`createBeanInstance(beanName, mbd, args)`执行Bean实例的创建，而`populateBean(beanName, mbd, instanceWrapper)`则负责填充Bean的属性，将依赖注入到Bean中...
spring自动生成bean项目
05-05
运行项目，可以选择数据库的某张表进行填表名，类名，进行建bean的代码，下好不会用可以发邮箱到1297237518@qq.com
Spring创建Bean的3种方式
爱雨轩
09-06 1890
1. Spring创建Bean的三种方式 1. 调用构造器（因为常用就不讲） 2. 调用静态工厂方法 3. 调用实例工厂方法2. 使用静态工厂方法1.此时<bean.../>元素要指定以下两个属性 class：用于指定静态工厂类的完整类名 factory-method：用于指定创建Bean的静态工厂方法2.代码：//接口 public interface Animal{
Spring中创建Bean的六种方式
tanxinji的博客
02-27 1644
 创建一个容器类AppConfig加入@Configuration和@ComponentScan。  @ComponentScan默认是扫描AppConfig的本路径和子路径下加入了 import org.springframework.context.annotation.Configuration; @Configuration public class AppConfig { }  创建一个测试类。输出ApplConfig类中托管的所有方法。后续会多次运行
spring创建bean的三种方法
bring_coco的博客
08-30 2212
Spring支持如下三种方式创建Bean1：调用构造器创建Bean2：调用静态工厂方法创建Bean3：调用实例工厂方法创建Bean注解@Bean方式Xml方式BeanDefinitionBuilder方式。
spring中bean的创建过程（doCreateBean方法）
与君初相识，犹如故人归。
11-25 892
bean的创建过程大部分是在docreateBean里面完成的（为什么这么说？因为在createBean里如果InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法返回了一个bean实例的话createBean方法会直接返回导致不会进入doCreateBean方法，这里插一嘴，一个bean一般情况下被创建的方法调用链：getBean→doGetBean→getSingleton→createBean→doCreateBean）
Spring创建bean
qq_40708942的博客
05-21 294
之前分析了准备创建bean的一些操作. 现在来分析doCreateBean()这个方法做了哪些事. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; // 判断是不是singleton类型的
Spring-创建bean
Promise_J_Z
08-03 473
根据传入的名字获取bean真正的名字（有可能传入的是别名或者工厂类别名，以&开头的），特别需要说明的是，spring针对于别名专门使用一个map（aliasMap）进行存储，key为别名，而value则是bean真正的名字。所以在创建bena第一步就需要先根据名字获取到bean真正的名字。tips：最终调用getBean使用的是RootBeanDefinition进行构建的。什么是抽象BeanDefinition？合并BeanDefinition。
Spring创建bean的几种方式
Java技术攻略的博客
05-03 610
（1）如果一个类不是ImportSelector或ImportBeanDefinitionRegistrar的子类，当它被@Import导入的时候，它就会被当成一个配置类存在，可以简单理解为它被加了@Configuration注解，那么原本在这个类上面的注解（比如@ComponentScan、@Import、@ImportResource等等）就也会生效。
Spring框架创建Bean的多种方式详解
这样，Spring会在创建Bean时调用对应的构造器并传递给定的值。 除了上述方法，Spring还提供了多种创建和管理Bean的方式： 1. **无参构造器创建**：这是最基础的方式，Spring通过Bean的无参构造器创建实例，然后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值