文章目录

3、基于XML管理bean
- 实验一：入门案例
- 实验二：获取bean
- 实验三：依赖注入之setter注入
- 实验四：依赖注入之构造器注入
- 实验五：特殊值处理
- 实验六：为类类型属性赋值
- 实验七：为数组类型属性赋值
- 实验八：为集合类型属性赋值
- 实验九：p命名空间
- 实验十：c命名空间
- 实验十一：bean的作用域
- 实验十二：bean的生命周期
- 实验十三：FactoryBean
- 实验十四：基于xml的自动装配

【尚硅谷】SSM框架全套教程-讲师：杨博超

但行好事，莫问前程

3、基于XML管理bean

实验一：入门案例

①创建Maven Module
②引入依赖

<!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.22</version>
</dependency>
<!-- junit测试 -->
<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope>
</dependency>

③创建类HelloWorld

public class HelloWord {public void sayHello() {System.out.println("helloword");}
}

④创建Spring的配置文件

⑤在Spring的配置文件中配置bean

<?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"><!--
配置HelloWorld所对应的bean，即将HelloWorld的对象交给Spring的IOC容器管理
通过bean标签配置IOC容器所管理的bean
属性：
id：设置bean的唯一标识
class：设置bean所对应类型的全类名
--><bean id="helloword" class="pers.tianyu.pojo.HelloWord"></bean>
</beans>

⑥创建测试类测试

@Test
public void TestSayHello(){ApplicationContext ac= new ClassPathXmlApplicationContext("applicationContext.xml");HelloWorld helloworld = (HelloWorld) ac.getBean("helloworld");bean.sayHello();
}

⑦思路

⑧注意
Spring 底层默认通过反射技术调用组件类的无参构造器来创建组件对象，这一点需要注意。如果在需要无参构造器时，没有无参构造器，则会抛出下面的异常：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name
'helloworld' defined in class path resource [applicationContext.xml]: Instantiation of bean
failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed
to instantiate [com.atguigu.spring.bean.HelloWorld]: No default constructor found; nested
exception is java.lang.NoSuchMethodException: com.atguigu.spring.bean.HelloWorld.<init>
()

实验二：获取bean

①方式一：根据id获取

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。
上个实验中我们使用的就是这种方式。

②方式二：根据类型获取

@Test
public void TestSayHello(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");HelloWord bean = context.getBean(HelloWord.class);bean.sayHello();
}

③方式三：根据id和类型

@Test
public void TestSayHello(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");HelloWord bean = context.getBean("helloworld", HelloWord.class);bean.sayHello();
}

④注意

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个
当IOC容器中一共配置了两个：

<bean id="hellowordOne" class="pers.tianyu.pojo.HelloWord"></bean>
<bean id="hellowordTwo" class="pers.tianyu.pojo.HelloWord"></bean>

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean
of type 'com.atguigu.spring.bean.HelloWorld' available: expected single matching bean but
found 2: helloworldOne,helloworldTwo

⑤扩展

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

可以，前提是bean唯一

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

不行，因为bean不唯一

⑥结论

根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

实验三：依赖注入之setter注入

①创建学生类Student

public class Student {private Integer id;private String name;private Integer age;private String sex;// 无参有参构造函数// setget方法// toString方法
}

②配置bean时为属性赋值

<bean id="student" class="pers.tianyu.pojo.Student"><property name="id" value="1001"></property><property name="name" value="张三"></property><property name="age" value="23"></property><property name="sex" value="男"></property>
</bean>

③测试

@Test
public void testDIBySet() {ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");Student bean = context.getBean(Student.class);System.out.println(bean);
}

实验四：依赖注入之构造器注入

①在Student类中添加有参构造

public class Student {private Integer id;private String name;private Integer age;private String sex;// 无参有参构造函数// setget方法// toString方法
}

②配置bean

<bean id="studentOne" class="pers.tianyu.pojo.Student"><constructor-arg value="1003"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="30"></constructor-arg><constructor-arg value="女"></constructor-arg>
</bean>

注意：
constructor-arg标签还有两个属性可以进一步描述构造器参数：
index属性：指定参数所在位置的索引（从0开始）
name属性：指定参数名

③测试

@Test
public void testDIBySet() {ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");Student bean = context.getBean("studentOne",Student.class);System.out.println(bean);
}

实验五：特殊值处理

①字面量赋值

什么是字面量？
int a = 10;
声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a
的时候，我们实际上拿到的值是10。
而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面
量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>

②null值

<property name="name"><null />
</property>

注意：

<property name="name" value="null"></property>

以上写法，为name所赋的值是字符串’null’

③xml实体

<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a &lt; b"/>

④CDATA节

<property name="expression">
<!-- 解决方案二：使用CDATA节 -->
<!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
<!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
<!-- 所以CDATA节中写什么符号都随意 -->
<!-- idea快捷键CD -->
<value><![CDATA[a < b]]></value>
</property>

实验六：为类类型属性赋值

①创建班级类Clazz

public class Clazz {private Integer clazzId;private String ClassName;// 无参有参构造函数// setget方法// toString方法
}

②修改Student类
在Student类中添加

private Clazz clazz;public Clazz getClazz() {return clazz;
}
public void setClazz(Clazz clazz) {this.clazz = clazz;
}

③方式一：引用外部已声明的bean

配置Clazz类型的bean：

<bean id="clazzOne" class="pers.tianyu.pojo.Clazz"><property name="clazzId" value="1904"></property><property name="className" value="1904班"></property>
</bean>

为Student中的clazz属性赋值：

<bean id="studentOne" class="pers.tianyu.pojo.Student"><constructor-arg value="1003"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="30"></constructor-arg><constructor-arg value="女"></constructor-arg><!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 --><property name="clazz" ref="clazzOne"></property>
</bean>

错误演示：

<bean id="studentOne" class="pers.tianyu.pojo.Student"><constructor-arg value="1003"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="30"></constructor-arg><constructor-arg value="女"></constructor-arg><!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 --><property name="clazz" value="clazzOne"></property>
</bean>

如果错把ref属性写成了value属性，会抛出异常： Caused by: java.lang.IllegalStateException:
Cannot convert value of type ‘java.lang.String’ to required type
‘com.atguigu.spring.bean.Clazz’ for property ‘clazz’: no matching editors or conversion
strategy found

意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个
属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值

④方式二：内部bean

<bean id="studentOne" class="pers.tianyu.pojo.Student"><constructor-arg value="1003"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="30"></constructor-arg><constructor-arg value="女"></constructor-arg><!-- 在一个bean中再声明一个bean就是内部bean --><!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 --><property name="clazz"><bean name="clazzInner" class="pers.tianyu.pojo.Clazz"><property name="clazzId" value="1908"></property><property name="className" value="1908班"></property></bean></property>
</bean>

③方式三：级联属性赋值

<bean id="studentOne" class="pers.tianyu.pojo.Student"><constructor-arg value="1003"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="30"></constructor-arg><constructor-arg value="女"></constructor-arg><!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 --><property name="clazz" ref="clazzOne"></property><property name="clazz.clazzId" value="2222"></property><property name="clazz.className" value="2222班"></property>
</bean>

实验七：为数组类型属性赋值

①修改Student类

private String[] hobbies;public String[] getHobbies() {return hobbies;
}
public void setHobbies(String[] hobbies) {this.hobbies = hobbies;
}

②配置bean

<bean id="studentOne" class="pers.tianyu.pojo.Student"><constructor-arg value="1003"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="30"></constructor-arg><constructor-arg value="女"></constructor-arg><!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 --><property name="clazz" ref="clazzOne"></property><property name="hobbies" ><array><value>抽烟</value><value>喝酒</value><value>烫头</value></array></property>
</bean>

实验八：为集合类型属性赋值

①为List集合类型属性赋值
在Clazz类中添加以下代码：

private List<Student> students;public List<Student> getStudents() {return students;
}
public void setStudents(List<Student> students) {this.students = students;
}

配置bean：

<bean id="clazzOne" class="pers.tianyu.pojo.Clazz"><property name="clazzId" value="1904"></property><property name="className" value="1904班"></property><property name="students"><list><ref bean="studentOne"></ref></list></property>
</bean>

注意：
若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

②为Map集合类型属性赋值

创建教师类Teacher

public class Teacher {private Integer teacherId;private String teacherName;// 有参无参构造函数// setget方法// toString方法
}

在Student类中添加以下代码

private Map<String, Teacher> teacherMap;public Map<String, Teacher> getTeacherMap() {return teacherMap;
}public void setTeacherMap(Map<String, Teacher> teacherMap) {this.teacherMap = teacherMap;
}

配置bean

<bean id="thacherOne" class="pers.tianyu.pojo.Teacher"><property name="teacherId" value="1001"></property><property name="teacherName" value="深田永美"></property>
</bean>
<bean id="thacherTwo" class="pers.tianyu.pojo.Teacher"><property name="teacherId" value="1002"></property><property name="teacherName" value="周淑怡"></property>
</bean>
<bean id="studentThree" class="pers.tianyu.pojo.Student"><property name="id" value="1004"></property><property name="name" value="王五"></property><property name="age" value="26"></property><property name="sex" value="女"></property><property name="hobbies"><list><value>抽烟</value><value>喝酒</value><value>烫头</value></list></property><property name="teacherMap"><map><entry><key><value>1001</value></key><ref bean="thacherOne"></ref></entry><entry><key><value>1002</value></key><ref bean="thacherTwo"></ref></entry></map></property>
</bean>

③引用集合类型的bean

<!--list集合类型的bean-->
<util:list id="students"><ref bean="studentOne"></ref><ref bean="studentThree"></ref>
</util:list>
<!--map集合类型的bean-->
<util:map id="teacherMap"><entry><key><value>1001</value></key><ref bean="thacherOne"></ref></entry><entry><key><value>1002</value></key><ref bean="thacherTwo"></ref></entry>
</util:map>

注意：
使用util:list、util:map标签必须引入相应的命名空间，可以通过idea的提示功能选择

实验九：p命名空间

引入p命名空间后，可以通过以下方式为bean的各个属性赋值
set方法

<!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
<!--xmlns:p="http://www.springframework.org/schema/p" -->
<bean id="teacherThree" class="pers.tianyu.pojo.Teacher"p:teacherId="1003" p:teacherName="三上悠亚">
</bean>

实验十：c命名空间

构造器注入

<!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
<!--xmlns:c="http://www.springframework.org/schema/c"-->
<bean id="teacherFour" class="pers.tianyu.pojo.Teacher"c:teacherId="1004" c:teacherName="饭岛爱">
</bean>

注意：
必须有有参构造、set方法，缺一不可。

实验十一：bean的作用域

①概念
在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

取值	含义	创建对象的时机
singleton（默认）	在IOC容器中，这个bean的对象始终为单实例	IOC容器初始化时
prototype	这个bean在IOC容器中有多个实例	获取bean时

如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

取值	含义
request	在一个请求范围内有效
session	在一个会话范围内有效

②创建类User

public class User {private Integer id;private String username;private String password;private Integer age;// 有参无参构造方法// setget方法// toString方法
}

③配置bean

<!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建
对象 -->
<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 -->
<bean id="User" class="pers.tianyu.pojo.User" scope="singleton"><property name="id" value="1001"></property><property name="username" value="张三"></property>
</bean>

④测试

@Test
public void test03() {ApplicationContext context = new ClassPathXmlApplicationContext("spring-scope.xml");User user1 = context.getBean(User.class);User user2 = context.getBean(User.class);System.out.println(user1 == user2);
}

实验十二：bean的生命周期

①具体的生命周期过程

bean对象创建（调用无参构造器）
给bean对象设置属性（依赖注入）
bean对象初始化之前操作（由bean的后置处理器负责）
bean对象初始化（需在配置bean时指定初始化方法）
bean对象初始化之后操作（由bean的后置处理器负责）
bean对象就绪可以使用
bean对象销毁（需在配置bean时指定销毁方法）
IOC容器关闭

②修改类User

public class User {private Integer id;private String username;private String password;private Integer age;public User() {System.out.println("生命周期：1、创建对象");}public User(Integer id, String username, String password, Integer age) {this.id = id;this.username = username;this.password = password;this.age = age;}public void initMethod(){System.out.println("生命周期：3、初始化");}public void destroyMethod(){System.out.println("生命周期：5、销毁");}public Integer getId() {return id;}public void setId(Integer id) {System.out.println("生命周期：2、依赖注入");this.id = id;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", password='" + password + '\'' +", age=" + age +'}';}
}

注意
其中的initMethod()和destroyMethod()，可以通过配置bean指定为初始化和销毁的方法

③配置bean

<bean id="User" class="pers.tianyu.pojo.User" init-method="initMethod" destroy-method="destroyMethod"><property name="id" value="1001"></property><property name="username" value="张三"></property>
</bean>

④测试

@Test
public void test04(){// 不能使用ApplicationContext，它没有close()方法ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-scope.xml");User bean = context.getBean(User.class);System.out.println(bean);context.close();
}

⑤bean的后置处理器

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

创建bean的后置处理器：

public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {// 此方法在bean的生命周期初始化之前执行System.out.println("生命周期：4、前置");return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {// 此方法在bean的生命周期初始化之后执行System.out.println("生命周期：4、后置");return bean;}
}

在IOC容器中配置后置处理器：

<!-- bean的后置处理器要放入IOC容器才能生效 -->
<bean id="beanPostProcessor" class="pers.tianyu.process.MyBeanPostProcessor"></bean>

实验十三：FactoryBean

①简介
FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

/*
* Copyright 2002-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.beans.factory;
import org.springframework.lang.Nullable;
/**
* Interface to be implemented by objects used within a {@link BeanFactory}
which
* are themselves factories for individual objects. If a bean implements this
* interface, it is used as a factory for an object to expose, not directly as a
* bean instance that will be exposed itself.
*
* <p><b>NB: A bean that implements this interface cannot be used as a normal
bean.</b>
* A FactoryBean is defined in a bean style, but the object exposed for bean
* references ({@link #getObject()}) is always the object that it creates.
*
* <p>FactoryBeans can support singletons and prototypes, and can either create
* objects lazily on demand or eagerly on startup. The {@link SmartFactoryBean}
* interface allows for exposing more fine-grained behavioral metadata.
*
* <p>This interface is heavily used within the framework itself, for example
for
* the AOP {@link org.springframework.aop.framework.ProxyFactoryBean} or the
* {@link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for
* custom components as well; however, this is only common for infrastructure
code.
*
* <p><b>{@code FactoryBean} is a programmatic contract. Implementations are not
* supposed to rely on annotation-driven injection or other reflective
facilities.</b>
* {@link #getObjectType()} {@link #getObject()} invocations may arrive early in
the
* bootstrap process, even ahead of any post-processor setup. If you need access
to
* other beans, implement {@link BeanFactoryAware} and obtain them
programmatically.
*
* <p><b>The container is only responsible for managing the lifecycle of the
FactoryBean
* instance, not the lifecycle of the objects created by the FactoryBean.</b>
Therefore,
* a destroy method on an exposed bean object (such as {@link
java.io.Closeable#close()}
* will <i>not</i> be called automatically. Instead, a FactoryBean should
implement
* {@link DisposableBean} and delegate any such close call to the underlying
object.
*
* <p>Finally, FactoryBean objects participate in the containing BeanFactory's
* synchronization of bean creation. There is usually no need for internal
* synchronization other than for purposes of lazy initialization within the
* FactoryBean itself (or the like).
*
* @author Rod Johnson
* @author Juergen Hoeller
* @since 08.03.2003
* @param <T> the bean type
* @see org.springframework.beans.factory.BeanFactory
* @see org.springframework.aop.framework.ProxyFactoryBean
* @see org.springframework.jndi.JndiObjectFactoryBean
*/
public interface FactoryBean<T> {/**
* The name of an attribute that can be
* {@link org.springframework.core.AttributeAccessor#setAttribute set} on a
* {@link org.springframework.beans.factory.config.BeanDefinition} so that
* factory beans can signal their object type when it can't be deduced from
* the factory bean class.
* @since 5.2
*/
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
/**
* Return an instance (possibly shared or independent) of the object
* managed by this factory.
* <p>As with a {@link BeanFactory}, this allows support for both the
* Singleton and Prototype design pattern.
* <p>If this FactoryBean is not fully initialized yet at the time of
* the call (for example because it is involved in a circular reference),
* throw a corresponding {@link FactoryBeanNotInitializedException}.
* <p>As of Spring 2.0, FactoryBeans are allowed to return {@code null}
* objects. The factory will consider this as normal value to be used; it
* will not throw a FactoryBeanNotInitializedException in this case anymore.
* FactoryBean implementations are encouraged to throw
* FactoryBeanNotInitializedException themselves now, as appropriate.
* @return an instance of the bean (can be {@code null})
* @throws Exception in case of creation errors
* @see FactoryBeanNotInitializedException
*/
@Nullable
T getObject() throws Exception;
/**
* Return the type of object that this FactoryBean creates,
* or {@code null} if not known in advance.
* <p>This allows one to check for specific types of beans without
* instantiating objects, for example on autowiring.
* <p>In the case of implementations that are creating a singleton object,
* this method should try to avoid singleton creation as far as possible;
* it should rather estimate the type in advance.
* * For prototypes, returning a meaningful type here is advisable too.
* <p>This method can be called <i>before</i> this FactoryBean has
* been fully initialized. It must not rely on state created during
* initialization; of course, it can still use such state if available.
* <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return
* {@code null} here. Therefore it is highly recommended to implement
* this method properly, using the current state of the FactoryBean.
* @return the type of object that this FactoryBean creates,
* or {@code null} if not known at the time of the call
* @see ListableBeanFactory#getBeansOfType
*/
@Nullable
Class<?> getObjectType();
/**
* Is the object managed by this factory a singleton? That is,
* will {@link #getObject()} always return the same object
* (a reference that can be cached)?
* <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,
* the object returned from {@code getObject()} might get cached
* by the owning BeanFactory. Hence, do not return {@code true}
* unless the FactoryBean always exposes the same reference.
* <p>The singleton status of the FactoryBean itself will generally
* be provided by the owning BeanFactory; usually, it has to be
* defined as singleton there.
* <p><b>NOTE:</b> This method returning {@code false} does not
* necessarily indicate that returned objects are independent instances.
* An implementation of the extended {@link SmartFactoryBean} interface
* may explicitly indicate independent instances through its
* {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean}
* implementations which do not implement this extended interface are
* simply assumed to always return independent instances if the
* {@code isSingleton()} implementation returns {@code false}.
* <p>The default implementation returns {@code true}, since a
* {@code FactoryBean} typically manages a singleton instance.
* @return whether the exposed object is a singleton
* @see #getObject()
* @see SmartFactoryBean#isPrototype()
*/
default boolean isSingleton() {return true;
}
}

②创建类UserFactoryBean
getObject()：通过一个对象交给IOC容器管理
getObjectType()：设置所提供对象的类型
isSingleton()：所提供对象是否单例

public class UserFactoryBean implements FactoryBean<User> {@Overridepublic User getObject() throws Exception {return new User();}@Overridepublic Class<?> getObjectType() {return User.class;}
}

③配置bean

<bean class="pers.tianyu.Factory.UserFactoryBean"/>

④测试

@Test
public void test05(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-scope.xml");User bean = context.getBean(User.class);System.out.println(bean);
}

实验十四：基于xml的自动装配

自动装配：

根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值

①场景模拟

创建类UserController

public class UserController {private UserService userService;public void setUserService(UserService userService) {this.userService = userService;}public void saveUser() {userService.saveUser();}
}

创建接口UserService

public interface UserService {void saveUser();
}

创建类UserServiceImpl实现接口UserService

public class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao;}@Overridepublic void saveUser() {userDao.saveUser();}
}

创建接口UserDao

public interface UserDao {void saveUser();
}

创建类UserDaoImpl实现接口UserDao

public class UserDaoImpl implements UserDao {@Overridepublic void saveUser() {System.out.println("保存成功");}
}

②配置bean

使用bean标签的autowire属性设置自动装配效果

自动装配方式：byType

byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值
若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值null
若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常NoUniqueBeanDefinitionException

<bean id="controller" class="pers.tianyu.controller.UserController" autowire="byType"></bean>
<bean id="service" class="pers.tianyu.service.impl.UserServiceImpl" autowire="byType"></bean>
<bean id="dao" class="pers.tianyu.dao.impl.UserDaoImpl"></bean>

自动装配方式：byName

byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值

<bean id="controller" class="pers.tianyu.controller.UserController" autowire="byName"></bean>
<bean id="userService" class="pers.tianyu.service.impl.UserServiceImpl" autowire="byName"></bean>
<bean id="userDao" class="pers.tianyu.dao.impl.UserDaoImpl"></bean>

③测试

@Test
public void test06() {ApplicationContext context = new ClassPathXmlApplicationContext("autowrite.xml");UserController bean = context.getBean(UserController.class);bean.saveUser();
}