一、Bean管理概述
1.1 Bean管理
1. Bean管理指的是两个操作(依赖注入),分别为:
- Spring创建对象(依赖)
- Spring注入属性(注入)
2. Bean 管理操作有两种方式 :
- 基于xml配置文件方式实现
- 基于注解方式实现
1.2 基于XML方式创建对象
(1) 在spring配置文件中,使用bean标签,标签里面添加对应的属性,就可以实现对象的创建。如下所示:
<!-- 配置User对象 -->
<bean id="user" class="com.wyf.spring5.User"></bean>
(2)在Bean标签中有很多属性,如上例中的id、class。常见的属性及其含义如下:
- id属性: 唯一标识(别名)
- class属性:类全路径(包类路径)
(3)创建对象时候,默认也是执行无参数构造方法完成对象创建
二、 基于xml方式注入属性
DI:依赖注入
2.1 第一种注入方式:使用set方式进行注入。
1. 创建类,定义属性和对应的set方法;
public class Book {
//创建属性
private String bname;
private String bauthor;
//创建属性对应的set方法
public void setBname(String bname){
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
}
2. 在spring配置文件配置对象创建(<bean>标签),配置属性注入(<bean>标签内部的<property>标签)。注入属性在创建对象的基础之上完成,先创建对象,在注入属性。
<!-- set方法注入属性-->
<bean id = "book" class="com.wyf.spring5.Book">
<!-- 使用property完成属性注入
name: 类里面属性名称
value:向属性注入的值
-->
<property name="bname" value="史记"></property>
<property name="bauthor" value="司马迁"></property>
</bean>
对xml方式使用set进行注入的测试:
public class TestSpring5 {
@Test
public void testbook(){
//1. 加载spring 配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2. 获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
book.testDeno();
}
}
测试结果:
com.wyf.spring5.Book@3c46e67a
史记::司马迁
2.2 第二种注入方式:使用有参数的构造函数进行注入
1. 创建 类,定义属性,创建属性对应的有参数构造方法
public class Orders {
//属性
private String name;
private String address;
//多参数构造函数
public Orders(String name, String address) {
this.name = name;
this.address = address;
}
}
2. 在spring配置文件中进行配置:
<!-- 使用有参构造函数注入属性-->
<bean id = "orsers" class="com.wyf.spring5.Orders">
<constructor-arg name="name" value="abc"></constructor-arg>
<constructor-arg name = "address" value="china"></constructor-arg>
</bean>
对xml方式使用有参构造注入的测试:
public class TestSpring5 {
@Test
public void testorder(){
//1. 加载spring 配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2. 获取配置创建的对象
Orders orders = context.getBean("orders", Orders.class);
System.out.println(orders);
orders.orderTest();
}
}
测试结果:
com.wyf.spring5.Orders@74e52ef6
abc::china
2.3 xml注入其他类型属性
2.3.1 字面量
(1)设置null值:
<!-- 向属性注入null值 -->
<property name="address">
<null/>
</property>
(2) 属性值包含特殊符号:
<!--属性值包含特殊符号 ,两种方式可以实现:
1 把<>进行转义 < >
2 把带特殊符号内容写到 CDATA
-->
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
2.3.2 注入属性-外部bean
示例:
1) 创建两个类service类和dao类;
2) 在service调用dao里面的方法;
3) 在sping配置文件中进行配置。
userDao实现类:
public class UserDaoImpl implements UserDao{
@Override
public void updata() {
System.out.println("dao updata....");
}
}
UserService类:
/**
* 在UserService中调用UserDao的方法
*/
public class UserService {
//创建UserDao类型属性,生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("service add....");
// /**
// * 原始的调用方式
// */
// UserDao dao = new UserDaoImpl();
// dao.updata();
/**
* Spring方式
*/
userDao.updata();
}
}
配置文件将userDao注入到userService中:
<?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">
<!-- 创建service和dao对象 -->
<bean id="userService" class="com.wyf.service.UserService">
<!-- 在service 中注入UserDao对象
name属性:类里面的属性名称
ref属性:创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImdl"></property>
</bean>
<bean id="userDaoImdl" class="com.wyf.dao.UserDaoImpl"></bean>
</beans>
2.3.3 注入属性—内部bean
示例:
一对多关系,如部门和员工。一个部门有多个员工,一个员工属于一个部门,部门是一,员工是多 。
使用实体类表示一对多的关系如下所示:
/**
* 部门类
*/
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Dept{" +
"dname='" + dname + '\'' +
'}';
}
}
/**
* 员工类
*/
public class Emp {
//员工属性
private String ename;
private String gender;
//员工属于一个部门,采用对象表示员工属于一个部门
private Dept dept; //表示员工所属的部门
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
public void add(){
System.out.println(ename+"::"+gender+"::"+dept.toString());
}
}
在spring配置文件中进行配置(配置为内部bean):
<!-- 内部bean -->
<bean id="emp" class="com.wyf.bean.Emp">
<!-- 设置两个普通的属性,名称和性别 -->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!-- 设置对象类型属性 -->
<property name="dept">
<!-- 内部bean -->
<bean id="dept" class="com.wyf.bean.Dept">
<property name="dname" value="研发部"></property>
</bean>
</property>
</bean>
<bean id="userDaoImdl" class="com.wyf.dao.UserDaoImpl"></bean>
2.3.4 xml注入集合属性
示例:
- 注入数组类型属性;
- 注入 List 集合类型属性
- 注入 Map 集合类型属性
(1)创建类,并在其中定义数组,list、map、set类型属性,生成对应的set方法
public class Stu {
//1. 数组类型属性
private String[] courses;
//2.list集合类型属性
private List<String> list;
//3.Map集合类型属性
private Map<String,String> maps;
//4. set集合类型属性
private Set<String> sets;
//学生所学的多门课程
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
}
(2)在spring文件中进行配置
<?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">
<!-- 1.集合类型属性注入 -->
<bean id="stu" class="com.wyf.collectionType.Stu">
<!-- 数组类型属性注入 -->
<property name="courses">
<array>
<value>数学</value>
<value>英语</value>
</array>
</property>
<!-- list类型属性注入 -->
<property name="list">
<list>
<value>java</value>
<value>C++</value>
<value>C#</value>
</list>
</property>
<!-- list类型属性注入 -->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PHP" value="php"></entry>
</map>
</property>
<!-- set类型属性注入 -->
<property name="sets">
<set>
<value>Mysql</value>
<value>Redis</value>
</set>
</property>
</bean>
</beans>
4. 在集合里面设置对象类型值
<!-- 创建多个course对象 -->
<bean id="course1" class="com.wyf.collectionType.Course">
<property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.wyf.collectionType.Course">
<property name="cname" value="Mybatis框架"></property>
</bean>
<!-- 注入List集合类型,值为对象 -->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
5. 把集合注入部分提取出来
(1) 在 spring 配置文件中引入名称空间 util
<?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"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd">
(2)使用 util 标签完成 list 集合注入提取
<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
<value>易筋经</value>
<value>九阴真经</value>
<value>九阳神功</value>
</util:list>
<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
<property name="list" ref="bookList"></property>
</bean>
三、FactoryBean
Spring 有两种类型 bean,一种普通 bean,另外一种工厂 bean(FactoryBean)。
- 普通 bean:在配置文件中定义 bean 类型就是返回类型 (前文都是普通Bean)
- 工厂 bean:在配置文件定义 bean 类型可以和返回类型不一样
第一步 创建类,让这个类作为工厂 bean,实现接口 FactoryBean
第二步 实现接口里面的方法,在实现的方法中定义返回的 bean 类型 ,如下方法getObject
import com.wyf.collectionType.Course;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course>{
/**
* 定义返回bean对象
* 此处返回Course类型
* @return
* @throws Exception
*/
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return FactoryBean.super.isSingleton();
}
}
配置文件:
<bean id="mybean" class="com.wyf.facbean.MyBean"></bean>
测试代码:
@Test
public void TestBean5(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
Course myBean = context.getBean("mybean",Course.class);
System.out.println(myBean);
}
虽然定义的类型为MyBean,但是工程Bean返回的是Course类型。
四、Bean作用域及声明周期
4.1 Bean作用域
在Spring中,Bean作用域用于确定那种类型的Bean实例应该从Spring容器中返回给调用者 ,即设置创建bean实例是单实例还是多实例。Spring中默认情况下Bean是单实例的。
默认情况获取Bean:
@Test
public void TestBean4(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
Stu stu = context.getBean("stu",Stu.class);
Stu stu2 = context.getBean("stu",Stu.class);
System.out.println(stu);
System.out.println(stu2);
}
程序输出结果表明stu和stu2是同一个对象,也就是单实例:
com.wyf.collectionType.Stu@2a5c8d3f
com.wyf.collectionType.Stu@2a5c8d3f
4.2 设置Bean为单实例或多实例
在 spring 配置文件 bean 标签里面有属性(scope)用于设置单实例还是多实例 。scope 属性值 如下:
- 第一个值 默认值,singleton,表示为单实例对象。
- 第二个值 prototype, 表示是多实例对象。
在配置文件中设置scope属性值为多实例:
<bean id="stu" class="com.wyf.collectionType.Stu" scope="prototype"></bean>
程序运行结果表明是两个不同的对象:
com.wyf.collectionType.Stu@2a5c8d3f
com.wyf.collectionType.Stu@752325ad
singleton 和 prototype 区别 :
1. singleton 单实例,prototype 多实例
2. 设置 scope 值是 singleton 时候,加载 spring 配置文件时候就会创建单实例对象,设置 scope 值是 prototype 时候,不是在加载 spring 配置文件时候创建对象,在调用getBean 方法时候创建多实例对象 。
4.3 Bean的生命周期
生命周期是指从对象创建到对象销毁的过程。
Bean的生命周期过程如下:
- 通过构造器创建 bean 实例(无参数构造)
- 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
- 调用 bean 的初始化的方法(需要进行配置初始化的方法)
- bean 可以使用了(对象获取到了)
- 当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)
示例如下:
public class Orders {
//无参构造
public Orders(){
System.out.println("第一步 执行无参构造,创建bean实例");
}
private String onname;
public void setOnname(String onname) {
this.onname = onname;
System.out.println("第二步 调用set方法设置属性值");
}
//创建执行的初始化的方法
public void initMethod(){
System.out.println("第三步 执行初始化方法");
}
//创建执行的销毁的方法
public void destroyMethod() {
System.out.println("第五步 执行销毁的方法");
}
}
配置文件如下:
<bean id="orders" class="com.wyf.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="onname" value="手机"></property>
</bean>
测试代码如下:
@Test
public void TestBean5(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
Orders orsers = context.getBean("orders",Orders.class);
System.out.println("第四步 获取创建 bean实例对象 ");
System.out.println(orsers);
//手动让bean实例销毁
context.close();
}
程序运行结果:
第一步 执行无参构造,创建bean实例
第二步 调用set方法设置属性值
第三步 执行初始化方法
第四步 获取创建 bean实例对象
com.wyf.bean.Orders@22555ebf
第五步 执行销毁的方法
加上bean 的后置处理器,其实bean 生命周期有七步 :
(1)通过构造器创建 bean 实例(无参数构造)
(2)为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
(3)把bean 实例传递 bean后置处理器的方法 postProcessBeforeInitialization
(4)调用 bean 的初始化的方法(需要进行配置初始化的方法)
(5)把bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
(6)bean 可以使用了(对象获取到了)
(7)当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)
五、xml自动装配(很少使用,一般用注解)
自动装配是指根据指定装配规则(属性名称或者属性类型),Spring 自动将匹配的属性值进行注入 。
(1)根据属性名称自动注入 。注入值bean的 id值和类属性名称一样
<!--实现自动装配
bean标签属性 autowire,配置自动装配
autowire属性常用两个值:
byName根据属性名称注入 ,注入值bean的 id值和类属性名称一样
byType根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
<!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
(2)根据属性类型自动注入
<!--实现自动装配
bean标签属性 autowire,配置自动装配
autowire属性常用两个值:
byName根据属性名称注入 ,注入值bean的 id值和类属性名称一样
byType根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
<!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
六、结束
本文是对尚硅谷Spring教程的学习笔记,主要介绍了基于xml的spring属性注入。