一、Spring bean定义
由Spring IoC容器所管理的对象称为bean。bean被实例化，组装，并通过Spring IoC容器所管理的对象。Bean配置信息定义了Bean的实现及依赖关系，Spring容器根据各种形式的Bean配置信息在容器内部建立Bean定义注册表，然后根据注册表加载、实例化Bean，并建立Bean和Bean的依赖关系，最后将这些准备就绪的Bean放到Bean缓存池中，以供外层的应用程序进行调用。
<bean id="account " class="com.example.model.Account"></bean>这是一个最简单的 Bean 定义。它类似于调用了语句：Account account = new Account ()。
bean的属性
<bean
id="beanId" -----------------------（1）
name="beanName"---------------------（2）
class="beanClass"-------------------（3）
parent="parentBean"-----------------（4）
abstract="true | false"-------------（5）
singleton="true | false"------------（6）
lazy-init="true | false | default"--（7）
autowire="no | byName | byType | constructor | autodetect | default"（8）
dependency-check = "none | objects | simple | all | default"（9）
depends-on="dependsOnBean"----------（10）
init-method="method"----------------（11）
destroy-method="method"-------------（12）
factory-method="method"-------------（13）
factory-bean="bean">----------------（14）
</bean>
（1）id: Bean 的唯一标识名。它必须是合法的 XML ID，在整个 XML 文档中唯一。
（2）name: 用来为 id 创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。
（3）class: 用来定义类的全限定名（包名＋类名）。只有子类 Bean 不用定义该属性。
（4）parent: 子类 Bean 定义它所引用它的父类 Bean。这时前面的 class 属性失效。子类 Bean 会继承父类 Bean 的所有属性，子类 Bean 也可以覆盖父类 Bean 的属性。注意：子类 Bean 和父类 Bean 是同一个 Java 类。
（5）abstract（默认为“false”）：用来定义 Bean 是否为抽象 Bean。它表示这个 Bean 将不会被实例化，一般用于父类 Bean，因为父类 Bean 主要是供子类 Bean 继承使用。
（6）singleton（默认为“true”）：定义 Bean 是否是 Singleton（单例）。如果设为“true”,则在 BeanFactory 作用范围内，只维护此 Bean 的一个实例。如果设为“flase”，Bean将是 Prototype（原型）状态，BeanFactory 将为每次 Bean 请求创建一个新的 Bean 实例。
（7）lazy-init（默认为“default”）：用来定义这个 Bean 是否实现懒初始化。如果为“true”，它将在 BeanFactory 启动时初始化所有的 Singleton Bean。反之，如果为“false”,它只在 Bean 请求时才开始创建 Singleton Bean。
（8）autowire（自动装配，默认为"default"）：它定义了 Bean 的自动装载方式。
"no"：不使用自动装配功能。
"byName"：通过 Bean 的属性名实现自动装配。
"byType"：通过 Bean 的类型实现自动装配。
"constructor"：类似于 byType，但它是用于构造函数的参数的自动组装。
"autodetect"：通过 Bean 类的反省机制（introspection）决定是使用“constructor”还是使用“byType”。
（9）dependency-check（依赖检查，默认为“default”）：它用来确保 Bean 组件通过 JavaBean 描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用。
none：不进行依赖检查。
objects：只做对象间依赖的检查。
simple：只做原始类型和 String 类型依赖的检查
all：对所有类型的依赖进行检查。它包括了前面的 objects 和 simple。
（10）depends-on（依赖对象）：这个 Bean 在初始化时依赖的对象，这个对象会在这个 Bean 初始化之前创建。
（11）init-method:用来定义 Bean 的初始化方法，它会在 Bean 组装之后调用。它必须是一个无参数的方法。
（12）destroy-method：用来定义 Bean 的销毁方法，它在 BeanFactory 关闭时调用。同样，它也必须是一个无参数的方法。它只能应用于singleton Bean。
（13）factory-method：定义创建该 Bean 对象的工厂方法。它用于下面的"factory-bean"，表示这个 Bean 是通过工厂方法创建。此时，"class"属性失效。
（14）factory-bean:定义创建该 Bean 对象的工厂类。如果使用了"factory-bean"则"class"属性失效。
二、bean配置常用两种方法：（1）基于xml配置Bean；（2）使用注解定义Bean；
1、基于xml配置Bean
root-context.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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
<bean id="account" class="com.raindi.model.Account">
<property name="schoolName" value="XXXXXX大学"></property>
<property name="name" value="sugar"></property>
<property name="phoneNumber" value="15666666666"></property>
<property name="password" value="admin"></property></bean>
</beans>
对应的实体类Account
public class Account{
private int id;
private String schoolName;
private String name;
private String phoneNumber;
private String password;
private int roleId;
private String wechatId;
private String address;
private String cardId;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getRoleId() {
return roleId;
}
public void setRoleId(int roleId) {
this.roleId = roleId;
}
public String getWechatId() {
return wechatId;
}
public void setWechatId(String wechatId) {
this.wechatId = wechatId;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", schoolName='" + schoolName + ''' +
", name='" + name + ''' +
", phoneNumber='" + phoneNumber + ''' +
", password='" + password + ''' +
", roleId=" + roleId +
", wechatId='" + wechatId + ''' +
", address='" + address + ''' +
", cardId='" + cardId + ''' +
'}';
}
}
从 IOC 容器中获取 Bean，调用的是 getBean() 方法，getBean() 方法是在 FactoryBean 接口中定义的，而 ApplicationContext 接口继承了 FactoryBean 接口，所以可以直接使用，getBean() 方法提供了很多重载方法。
（1）通过 id 获取 IOC容器 中的Bean：Account account = (Account)applicationContext.getBean("account");
（2）通过全类名获取IOC容器中的Bean：Account account1 = (Account)applicationContext.getBean(Account.class);
由单元测试打印log和配置bean属性的值一致
1.png
2、使用注解定义Bean
在配置文件定义一个bean，并设置属性的值。
2.png
（1）配置bean
@Configuration //相当于beans
public class MyBeanConfig {
@Bean
@ConfigurationProperties(prefix = "mybean")
public MyBean myBean(){
return new MyBean();
}
}
（2）获取bean
@Component
public class BeanConfig {
@Autowired
private ConfigurableApplicationContext context;
private MyBean myBean;
public MyBean getMyBean() {
if (myBean == null) {
myBean = context.getBean(MyBean.class);
}
return myBean;
}
}
打印的Log：MyBean{phone='15666666666', name='sugar'}
网友评论