Spring 管理 Bean-IOC--基于 XML 配置bean
站长
· 阅读数 13
Spring 管理 Bean-IOC--基于 XML 配置bean
Spring 配置/管理 bean 介绍
Bean 管理包括两方面
创建 bean 对象
给 bean 注入属性
Bean 配置方式
基于 xml 文件配置方式
基于注解方式
基于 XML 配置 bean
通过类型来获取 bean
通过 spring 的ioc 容器, 获取一个bean 对象
获取 bean 的方式：按类型
public void getBeanByType() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
//，直接传入class对象/类型
Monster bean = ioc.getBean(Monster.class);
System.out.println("bean=" + bean);
}
Monster类
注意
无参构造器一定要写，Spring反射创建对象时，需要使用
public class Monster {
private Integer monsterId;
private String name;
private String skill;
//全参构造器
public Monster(Integer monsterId, String name, String skill) {
this.monsterId = monsterId;
this.name = name;
this.skill = skill;
}
//无参构造器一定要写，Spring反射创建对象时，需要使用
public Monster() {
}
public Integer getMonsterId() {
return monsterId;
}
public void setMonsterId(Integer monsterId) {
this.monsterId = monsterId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
@Override
public String toString() {
return "Monster{" +
"monsterId=" + monsterId +
", name='" + name + '\'' +
", skill='" + skill + '\'' +
'}';
}
}
xml配置
<bean id="monster01" class="com.wyxedu.spring.beans.Monster">
<property name="monsterId" value="1"/>
<property name="name" value="牛魔王"/>
<property name="skill" value="牛魔王拳"/>
</bean>
细节说明
1. 按类型来获取 bean, 要求 ioc 容器中的同一个类的 bean 只能有一个,
否则会抛出异常 NoUniqueBeanDefinitionException
2. 这种方式的应用场景：
比如 XxxAction/Servlet/Controller, 或 XxxService 在一个线程中只需要一个对象实例(单例)的情况
3. 这里在说明一下:
在容器配置文件(比如 beans.xml)中给属性赋值, 底层是通过setter 方法完成的, 这也是为什么我们需要提供 setter 方法的原因
通过构造器配置 bean
public void setBeanByConstructor() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Monster monster03 = ioc.getBean("monster03", Monster.class);
System.out.println("monster03=" + monster03);
}
xml配置
1. constructor-arg标签可以指定使用构造器的参数 2. index表示构造器的第几个参数 从0开始计算的 3. 除了可以通过index 还可以通过 name / type 来指定参数方式 4. 解除大家的疑惑, 类的构造器，不能有完全相同类型和顺序的构造器，所以可以通过type来指定
<!--配置Monster对象，并且指定构造器
解读
1. constructor-arg标签可以指定使用构造器的参数
2. index表示构造器的第几个参数 从0开始计算的
3. 除了可以通过index 还可以通过 name / type 来指定参数方式
4. 解除大家的疑惑, 类的构造器，不能有完全相同类型和顺序的构造器，所以可以通过type来指定
-->
<bean id="monster03" class="com.spring.bean.Monster">
<constructor-arg value="200" index="0"/>
<constructor-arg value="白骨精" index="1"/>
<constructor-arg value="吸人血" index="2"/>
</bean>
<bean id="monster04" class="com.spring.bean.Monster">
<constructor-arg value="200" name="monsterId"/>
<constructor-arg value="白骨精" name="name"/>
<constructor-arg value="吸人血" name="skill"/>
</bean>
<bean id="monster05" class="com.spring.bean.Monster">
<constructor-arg value="300" type="java.lang.Integer"/>
<constructor-arg value="白骨精~" type="java.lang.String"/>
<constructor-arg value="吸人血~" type="java.lang.String"/>
</bean>
使用细节
1. 通过 index 属性来区分是第几个参数
2. 通过 type 属性来区是什么类型(按照顺序)
通过 p 名称空间配置 bean
//通过p名称空间来设置属性
@Test
public void setBeanByP() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Monster monster06 = ioc.getBean("monster06", Monster.class);
System.out.println("monster06=" + monster06);
}
xml配置
<!--通过p名称空间来配置bean
1. 将光标放在p , 输入alt+enter , 就会自动的添加xmlns
2. 有时需要多来几次
-->
<bean id="monster06" class="com.spring.bean.Monster"
p:monsterId="500"
p:name="红孩儿"
p:skill="吐火"
/>
引用/注入其它 bean 对象--ref
//通过ref来设置bean属性
@Test
public void setBeanByRef() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
MemberServiceImpl memberService =
ioc.getBean("memberService", MemberServiceImpl.class);
memberService.add();
}
MemberDAOImpl
public class MemberDAOImpl {
//构造器...
public MemberDAOImpl() {
//System.out.println("MemberDAOImpl 构造器被执行...");
}
//方法
public void add() {
//System.out.println("MemberDAOImpl add()方法被执行");
}
}
MemberServiceImpl
public class MemberServiceImpl {
private MemberDAOImpl memberDAO;
public MemberServiceImpl() {
//System.out.println("MemberServiceImpl() 构造器被执行");
}
public MemberDAOImpl getMemberDAO() {
return memberDAO;
}
public void setMemberDAO(MemberDAOImpl memberDAO) {
//System.out.println("setMemberDAO()...");
this.memberDAO = memberDAO;
}
public void add() {
System.out.println("MemberServiceImpl add() 被调用..");
memberDAO.add();
}
}
xml配置
<!--配置MemberServiceImpl对象
1. ref="memberDAO"表示 MemberServiceImpl对象属性memberDAO引用的对象是id=memberDAO
的对象
2. 这里就体现出spring容器的依赖注入
3. 注意再spring容器中, 他是作为一个整体来执行的, 即如果你引用到一个bean对象, 对你配置的顺序没有要求
4. 建议还是按顺序，好处是阅读的时候，比较方便
-->
<!--配置MemberDAOImpl对象-->
<bean class="com.spring.dao.MemberDAOImpl" id="memberDAO"/>
<bean class="com.spring.service.MemberServiceImpl" id="memberService">
<property name="memberDAO" ref="memberDAO"/>
</bean>
引用/注入内部 bean 对象--内部 bean 对象
1. 创建 MemberDAOImpl.java， 前面有了
2. 创建 MemberServiceImpl.java, 前面有
//通过内部bean设置属性
@Test
public void setBeanByPro() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
MemberServiceImpl memberService2 =
ioc.getBean("memberService2", MemberServiceImpl.class);
memberService2.add();
}
只需要修改一下xml配置就好
xml配置
<!--配置MemberServiceImpl对象-使用内部bean-->
<bean class="com.wyxedu.spring.service.MemberServiceImpl" id="memberService2">
<!--自己配置一个内部bean-->
<property name="memberDAO">
<bean class="com.spring.dao.MemberDAOImpl"/>
</property>
</bean>
引用/注入集合/数组类型
在 spring 的 ioc 容器, 看看如何给 bean
其中包括
list map set 数组 Properties
1. 创建 Monster.java， 前面有了
2. 创建Master.java
Master.java
public class Master {
private String name;//主人名
private List<Monster> monsterList;
private Map<String, Monster> monsterMap;
private Set<Monster> monsterSet;
//数组
private String[] monsterName;
//Java基础
//这个Properties 是 Hashtable的子类 , 是key-value的形式
//这里Properties key和value 都是String
private Properties pros;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Monster> getMonsterList() {
return monsterList;
}
public void setMonsterList(List<Monster> monsterList) {
this.monsterList = monsterList;
}
public Map<String, Monster> getMonsterMap() {
return monsterMap;
}
public void setMonsterMap(Map<String, Monster> monsterMap) {
this.monsterMap = monsterMap;
}
public Set<Monster> getMonsterSet() {
return monsterSet;
}
public void setMonsterSet(Set<Monster> monsterSet) {
this.monsterSet = monsterSet;
}
public String[] getMonsterName() {
return monsterName;
}
public void setMonsterName(String[] monsterName) {
this.monsterName = monsterName;
}
public Properties getPros() {
return pros;
}
public void setPros(Properties pros) {
this.pros = pros;
}
@Override
public String toString() {
return "Master{" +
"name='" + name + '\'' +
", monsterList=" + monsterList +
", monsterMap=" + monsterMap +
", monsterSet=" + monsterSet +
", monsterName=" + Arrays.toString(monsterName) +
", pros=" + pros +
'}';
}
}
配置 beans.xml
给list属性赋值 给map属性赋值 给set属性赋值
给数组属性赋值 说一句: array标签中使用 value 还是 bean , ref .. 要根据你的业务决定
给Properties属性赋值 结构k(String)-v(String)
<!--配置Master对象
体会 spring 容器配置特点 依赖注入-非常灵活
-->
<bean class="com.spring.bean.Master" id="master01">
<property name="name" value="太上老君"/>
<!--给list属性赋值-->
<property name="monsterList">
<list>
<!--引用的方法-->
<ref bean="monster01"/>
<ref bean="monster02"/>
<!--内部bean-->
<bean class="com.spring.bean.Monster">
<property name="name" value="老鼠精"/>
<property name="monsterId" value="100"/>
<property name="skill" value="吃粮食"/>
</bean>
</list>
</property>
<!--给map属性赋值-->
<property name="monsterMap">
<map>
<entry>
<key>
<value>monster03</value>
</key>
<!--这里使用的外部bean,引入-->
<ref bean="monster03"/>
</entry>
<entry>
<key>
<value>monster04</value>
</key>
<ref bean="monster04"/>
</entry>
</map>
</property>
<!--给set属性赋值-->
<property name="monsterSet">
<set>
<ref bean="monster05"/>
<ref bean="monster06"/>
<bean class="com.spring.bean.Monster">
<property name="name" value="金角大王"/>
<property name="skill" value="吐水"/>
<property name="monsterId" value="666"/>
</bean>
</set>
</property>
<!--给数组属性赋值
说一句: array标签中使用 value 还是 bean , ref .. 要根据你的业务决定
-->
<property name="monsterName">
<array>
<value>小妖怪</value>
<value>大妖怪</value>
<value>老妖怪</value>
</array>
</property>
<!--给Properties属性赋值 结构k(String)-v(String)-->
<property name="pros">
<props>
<prop key="username">root</prop>
<prop key="password">123456</prop>
<prop key="ip">127.0.0.1</prop>
</props>
</property>
</bean>
setCollectionByPro
- 获取 list 集合
- 获取 map 集合
- 获取 set
- 获取数组
- 获取 properties 集合
public void setCollectionByPro() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Master master01 = ioc.getBean("master01", Master.class);
//获取 list 集合
System.out.println("======list=======");
List<Monster> monster_list = master01.getMonsterList();
for (Monster monster : monster_list) {
System.out.println(monster);
}
//获取 map 集合
System.out.println("======map=======");
Map<String, Monster> monster_map = master01.getMonsterMap();
Set<Map.Entry<String, Monster>> entrySet = monster_map.entrySet();
for (Map.Entry<String, Monster> entry : entrySet) {
System.out.println(entry);
}
//获取 set
System.out.println("======set=======");
Set<Monster> monsterSet = master01.getMonsterSet();
for (Monster monster : monsterSet) {
System.out.println(monster);
}
//获取数组
System.out.println("======数组=======");
String[] monsterName = master01.getMonsterName();
for (String s : monsterName) {
System.out.println("妖怪名= " + s);
}
//获取 properties 集合
System.out.println("======properties=======");
Properties pros = master01.getPros();
String property1 = pros.getProperty("k1");
String property2 = pros.getProperty("k2");
String property3 = pros.getProperty("k3");
System.out.println(property1 + "\t" + property2 + "\t" + property3);
}
}
通过 util 名称空间创建 list
spring 的 ioc 容器, 通过 util 名称空间来创建 list 集合,可以当做创建 bean 对象的工具来
//使用util:list名称空间给属性赋值
@Test
public void setBeanByUtilList() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
BookStore bookStore = ioc.getBean("bookStore", BookStore.class);
System.out.println("bookStore=" + bookStore);
}
创建BookStore 类
无参构造器,如果你没有其它的构造器,该无参构造器可以不写 但是如果你有其它的构造器，则必须显式的定义一下无参构造器
public class BookStore {
//书
private List<String> bookList;
//无参构造器,如果你没有其它的构造器,该无参构造器可以不写
//但是如果你有其它的构造器，则必须显式的定义一下无参构造器
public BookStore() {
}
public List<String> getBookList() {
return bookList;
}
public void setBookList(List<String> bookList) {
this.bookList = bookList;
}
@Override
public String toString() {
return "BookStore{" +
"bookList=" + bookList +
'}';
}
}
修改 beans.xml , 增加配置
如果没有自动导入则复制这二行 到上面
xmlns:util="www.springframework.org/schema/util" xmlns:context="www.springframework.org/schema/cont…"
<!--定义一个util:list 并且指定id 可以达到数据复用
说明: 在使用util:list 名称空间时候，需要引入相应的标签, 一般来说通过alt+enter会自动加入
, 如果没有就手动添加一下即可.
-->
<util:list id="myBookList">
<value>三国演义</value>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
</util:list>
<!--配置BookStore对象-->
<bean class="com.spring.bean.BookStore" id="bookStore">
<property name="bookList" ref="myBookList"/>
</bean>
级联属性赋值
spring 的 ioc 容器, 可以直接给对象属性的属性赋值， 即级联属性赋值
//给属性进行级联赋值
@Test
public void setBeanByRelation() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Emp emp = ioc.getBean("emp", Emp.class);
System.out.println("emp=" + emp);
}
创建Dept.java
public class Dept {
private String name;
public Dept() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dept{" +
"name='" + name + '\'' +
'}';
}
}
创建Emp.java
public class Emp {
private String name;
private Dept dept;
public Emp() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{" +
"name='" + name + '\'' +
", dept=" + dept +
'}';
}
}
修改 beans.xml
<!--配置Dept对象-->
<bean class="com.spring.bean.Dept" id="dept"/>
<!--配置Emp对象-->
<bean class="com.spring.bean.Emp" id="emp">
<property name="name" value="jack"/>
<property name="dept" ref="dept"/>
<!--这里我希望给dept的name属性指定值[级联属性赋值]-->
<property name="dept.name" value="Java开发部门"/>
</bean>
通过静态工厂获取对象
在 spring 的 ioc 容器, 可以通过静态工厂获对象
重新在获取一个bean因为他们所指定的工厂是静态的只会执行一次 所以他们是同一个对象
//通过静态工厂获取bean
//Java基础-静态和非静态
@Test
public void getBeanByStaticFactory() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Monster my_monster01 = ioc.getBean("my_monster01", Monster.class);
Monster my_monster04 = ioc.getBean("my_monster04", Monster.class);
System.out.println("my_monster01=" + my_monster01);
System.out.println(my_monster01 == my_monster04);//true
}
MyStaticFactory类
public class MyStaticFactory {
private static Map<String, Monster> monsterMap;
//使用 static代码块 进行初始化
//在java基础的时候，讲过的
static {
monsterMap = new HashMap<>();
monsterMap.put("monster01", new Monster(100,"牛魔王","芭蕉扇"));
monsterMap.put("monster02", new Monster(200,"狐狸精","美人计"));
}
//提供一个方法,返回Monster对象
public static Monster getMonster(String key) {
return monsterMap.get(key);
}
}
修改 beans.xml
<!--配置monster对象,通过静态工厂获取
1. 通过静态工厂获取/配置bean
2. class 是静态工厂类的全路径
3. factory-method 表示是指定静态工厂类的哪个方法返回对象
4. constructor-arg value="monster02" value是指定要返回静态工厂的哪个对象
-->
<bean id="my_monster01"
class="com.spring.factory.MyStaticFactory"
factory-method="getMonster">
<constructor-arg value="monster02"/>
</bean>
<bean id="my_monster04"
class="com.spring.factory.MyStaticFactory"
factory-method="getMonster">
<constructor-arg value="monster02"/>
</bean>
通过实例工厂获取对象
在 spring 的 ioc 容器, 可以通过实例工厂获对象
重新在获取一个bean因为他们所指定的工厂是非静态的调用一次执行一次所以他们不是同一个对象
//通过实例工厂获取bean
@Test
public void getBeanByInstanceFactory() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Monster my_monster02 = ioc.getBean("my_monster02", Monster.class);
Monster my_monster03 = ioc.getBean("my_monster03", Monster.class);
System.out.println("my_monster02=" + my_monster02);
System.out.println("my_monster03=" + my_monster03);
System.out.println(my_monster02 == my_monster03);//false
}
MyInstanceFactory 类
public class MyInstanceFactory {
private Map<String, Monster> monster_map;
//通过普通代码块进行初始化
{
monster_map = new HashMap<>();
monster_map.put("monster03", new Monster(300, "牛魔王~", "芭蕉扇~"));
monster_map.put("monster04", new Monster(400, "狐狸精~", "美人计~"));
}
//写一个方法返回Monster对象
public Monster getMonster(String key) {
return monster_map.get(key);
}
}
修改 beans.xml
1. factory-bean 指定使用哪个实例工厂对象返回bean 2. factory-method 指定使用实例工厂对象的哪个方法返回bean 3. constructor-arg value="monster03" 指定获取到实例工厂中的哪个monster
<!--配置2个实例工厂对象-->
<bean class="com.spring.factory.MyInstanceFactory" id="myInstanceFactory"/>
<bean class="com.spring.factory.MyInstanceFactory" id="myInstanceFactory2"/>
<!--配置monster对象, 通过实例工厂
解读
1. factory-bean 指定使用哪个实例工厂对象返回bean
2. factory-method 指定使用实例工厂对象的哪个方法返回bean
3. constructor-arg value="monster03" 指定获取到实例工厂中的哪个monster
-->
<bean id="my_monster02" factory-bean="myInstanceFactory" factory-method="getMonster">
<constructor-arg value="monster03"/>
</bean>
<bean id="my_monster03" factory-bean="myInstanceFactory2" factory-method="getMonster">
<constructor-arg value="monster03"/>
</bean>
通过 FactoryBean 获取对象
在 spring 的 ioc 容器, 可以通过 FactoryBean 获取对象
//通过FactoryBean获取bean
@Test
public void getBeanByFactoryBean() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Monster my_monster05 = ioc.getBean("my_monster05", Monster.class);
System.out.println("my_monster05=" + my_monster05);
}
创建 MyFactoryBean
public class MyFactoryBean implements FactoryBean<Monster> {
//这个就是你配置时候，指定要获取的对象对应key
private String key;
private Map<String, Monster> monster_map;
{ //代码块，完成初始化
monster_map = new HashMap<>();
monster_map.put("monster03", new Monster(300, "牛魔王~", "芭蕉扇~"));
monster_map.put("monster04", new Monster(400, "狐狸精~", "美人计~"));
}
public void setKey(String key) {
this.key = key;
}
@Override
public Monster getObject() throws Exception {
return monster_map.get(key);
}
@Override
public Class<?> getObjectType() {//得到类型
return Monster.class;
}
@Override
public boolean isSingleton() {//这里指定是否返是单例
return false;
}
}
配置beans.xml
<!--配置monster对象，通过FactoryBean获取
解读
1. class 指定使用的FactoryBean
2. key表示就是 MyFactoryBean 属性key
3. value就是你要获取的对象对应key
-->
<bean id="my_monster05" class="com.spring.factory.MyFactoryBean">
<property name="key" value="monster04"/>
</bean>
bean 配置信息重用(继承)
在 spring 的 ioc 容器, 提供了一种继承的方式来实现 bean 配置信息的重用
//配置Bean通过继承
@Test
public void getBeanByExtends() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Monster monster11 = ioc.getBean("monster11", Monster.class);
System.out.println("monster11=" + monster11);
Monster monster13 = ioc.getBean("monster13", Monster.class);
System.out.println("monster13=" + monster13);
}
配置beans.xml
1. 配置Monster对象 2.但是这个对象的属性值和 id="monster10"对象属性一样 3.parent="monster10" 指定当前这个配置的对象的属性值从 id=monster10的对象来
<!--配置Monster对象-->
<bean id="monster10" class="com.spring.bean.Monster">
<property name="monsterId" value="10"/>
<property name="name" value="蜈蚣精"/>
<property name="skill" value="蜇人"/>
</bean>
<!--
解读
1. 配置Monster对象
2.但是这个对象的属性值和 id="monster10"对象属性一样
3.parent="monster10" 指定当前这个配置的对象的属性值从 id=monster10的对象来
-->
<bean id="monster11"
class="com.spring.bean.Monster"
parent="monster10"/>
bean 创建顺序
在 spring 的 ioc 容器, 默认是按照配置的顺序创建bean 对象
//测试Bean创建顺序
@Test
public void testBeanByCreate() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
System.out.println("ok");
}
1. 在默认情况下, bean创建的顺序是按照配置顺序来的 2. 但是如果我们增加了 depends-on="department01" 这时就会先创建id= department01对象
配置Monster对象
1. 如果bean指定了 abstract="true", 表示该bean对象, 是用于被继承 2. 本身这个bean就不能被获取/实例化
配置beans.xml
<!--测试bean对象的创建顺序
1. 在默认情况下, bean创建的顺序是按照配置顺序来的
2. 但是如果我们增加了 depends-on="department01" 这时就会先创建id= department01对象
-->
<bean id="student01" class="com.wyxedu.spring.bean.Student" depends-on="department01"/>
<bean id="department01" class="com.wyxedu.spring.bean.Department"/>
<!--配置Monster对象
1. 如果bean指定了 abstract="true", 表示该bean对象, 是用于被继承
2. 本身这个bean就不能被获取/实例化
-->
<bean id="monster12" class="com.wyxedu.spring.bean.Monster" abstract="true">
<property name="monsterId" value="100"/>
<property name="name" value="蜈蚣精~"/>
<property name="skill" value="蜇人~"/>
</bean>
<bean id="monster13" class="com.wyxedu.spring.bean.Monster" parent="monster12"/>
bean 对象的单例和多例
● 说明
在 spring 的 ioc 容器, 在默认是按照单例创建的，即配置一个 bean 对象后，ioc 容器只会 创建一个 bean 实例。
如果,我们希望 ioc 容器配置的某个 bean 对象，是以多个实例形式创建的则可以通过配置 scope="prototype" 来指定
创建car.java
public class Car {
private Integer id;
private String name;
private Integer price;
public Car(Integer id, String name, Integer price) {
this.id = id;
this.name = name;
this.price = price;
}
public Car() {
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
'}';
}
}
配置beans.xml
1. 在默认情况下 scope属性是 singleton
2. 在ioc容器中, 只要有一个这个bean对象
3. 当程序员执行getBean时, 返回的的是同一个对象
4. 如果我们希望每次getBean返回一个新的Bean对象，则可以scope="prototype"
5. 如果bean的配置是 scope="singleton" lazy-init="true" 这时,ioc容器就不会提前创建该对象, 而是当执行getBean方法的时候，才会创建对象
<!--配置Cat对象
1. 在默认情况下 scope属性是 singleton
2. 在ioc容器中, 只要有一个这个bean对象
3. 当程序员执行getBean时, 返回的的是同一个对象
4. 如果我们希望每次getBean返回一个新的Bean对象，则可以scope="prototype"
5. 如果bean的配置是 scope="singleton" lazy-init="true" 这时,ioc容器就不会提前创建该对象
, 而是当执行getBean方法的时候，才会创建对象
-->
<bean id="cat" class="com.spring.bean.Cat" scope="prototype" lazy-init="false">
<property name="id" value="100"/>
<property name="name" value="小花猫"/>
</bean>
@Test
public void testBeanScope() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
Cat cat = ioc.getBean("cat", Cat.class);
Cat cat2 = ioc.getBean("cat", Cat.class);
Cat cat3 = ioc.getBean("cat", Cat.class);
System.out.println("cat=" + cat);
System.out.println("cat2=" + cat2);
System.out.println("cat3=" + cat3);
}
使用细节
1. 默认是单例 scope=singleton,
在启动容器时, 默认就会创建 , 并放入到 singletonObjects 集合
2. 当 <bean scope="prototype" >
设置为多实例机制后, 该 bean 是在 getBean()时才创建
3. 如果是单例 scope=singleton,
同时希望在 getBean 时才创建 , 可以指定懒加载lazy init="true" (注意默认是 false)
4. 通常情况下,
lazy-init 就使用默认值 false , 在开发看来, 用空间换时间是值得的, 除非有特殊的要求.
5. 如果 scope="prototype"
这时你的 lazy-init 属性的值不管是 ture, 还是 false 都是在getBean 时候，才创建对象
bean 的生命周期
● 说明:
bean 对象创建是由 JVM 完成的，然后执行如下方法
1. 执行构造器 2. 执行 set 相关方法 3. 调用 bean 的初始化的方法 4. 使用 bean 5. 当容器关闭时候，调用 bean 的销毁方法
1. 这里java基础 2. ioc的编译类型 ApplicationContext , 运行类型 ClassPathXmlApplicationContext 3. 因为ClassPathXmlApplicationContext 实现了 ConfigurableApplicationContext 4. ClassPathXmlApplicationContext 是有close 5. 将ioc 转成ClassPathXmlApplicationContext,再调用close ioc.close();关闭ioc容器.
public void testBeanLife() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
House house = ioc.getBean("house", House.class);
System.out.println("使用house=" + house);
//关闭容器
//1. 这里又要考察大家的java基础
//2. ioc的编译类型 ApplicationContext , 运行类型 ClassPathXmlApplicationContext
//3. 因为ClassPathXmlApplicationContext 实现了 ConfigurableApplicationContext
//4. ClassPathXmlApplicationContext 是有close
//5. 将ioc 转成ClassPathXmlApplicationContext,再调用close
//ioc.close();
//关闭ioc容器.
((ConfigurableApplicationContext) ioc).close();
}
创建House.java
public class House {
private String name;
public House() {
System.out.println("House() 构造器...");
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("House setName()=" + name);
this.name = name;
}
//1. 这个方法是程序员来编写的.
//2. 根据自己的业务逻辑来写.
public void init() {
System.out.println("House init()..");
}
//1. 这个方法是程序员来编写的.
//2. 根据自己的业务逻辑来写.
//3. 名字也不是固定的
public void destroy() {
System.out.println("House destroy()..");
}
@Override
public String toString() {
return "House{" +
"name='" + name + '\'' +
'}';
}
}
配置beans.xml
1. init-method="init" 指定bean的初始化方法 , 在setter方法后执行 2. init方法执行的时机，有spring容器来控制 3. destroy-method="destroy" 指定bean的销毁方法, 在容器关闭的时候执行 4. destroy方法执行的时机，有spring容器来控制
<!--配置House对象，演示整个Bean的生命周期
解读
1. init-method="init" 指定bean的初始化方法 , 在setter方法后执行
2. init方法执行的时机，有spring容器来控制
3. destroy-method="destroy" 指定bean的销毁方法, 在容器关闭的时候执行
4. destroy方法执行的时机，有spring容器来控制
-->
<bean class="com.spring.bean.House" id="house"
init-method="init"
destroy-method="destroy">
<property name="name" value="北京豪宅"/>
</bean>
使用细节
1. 初始化 init 方法和 destory 方法, 是程序员来指定 2. 销毁方法就是当关闭容器时，才会被调用
配置 bean 的后置处理器
说明
1. 在 spring 的 ioc 容器,可以配置 bean 的后置处理器 2. 该处理器/对象会在 bean 初始化方法调用前和初始化方法调用后被调用 3. 程序员可以在后置处理器中编写自己的代码
@Test
public void testBeanPostProcessor() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans02.xml");
House house = ioc.getBean("house", House.class);
System.out.println("使用house=" + house);
House house02 = ioc.getBean("house02", House.class);
System.out.println("使用house02=" + house02);
((ConfigurableApplicationContext)ioc).close();
}
创建 House.java 前面有
创建后置处理器MyBeanPostProcessor.java
什么时候被调用: 在Bean的init方法前被调用 @param bean 传入的在IOC容器中创建/配置Bean @param beanName 传入的在IOC容器中创建/配置Bean的id @return Object 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回 @throws BeansException
什么时候被调用: 在Bean的init方法后被调用 @param bean 传入的在IOC容器中创建/配置Bean @param beanName 传入的在IOC容器中创建/配置Bean的id @return 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回 @throws BeansException
public class MyBeanPostProcessor implements BeanPostProcessor {
/**
* 什么时候被调用: 在Bean的init方法前被调用
* @param bean 传入的在IOC容器中创建/配置Bean
* @param beanName 传入的在IOC容器中创建/配置Bean的id
* @return Object 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回
* @throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization().. bean="
+ bean + " beanName=" + beanName);
//初步体验案例: 如果类型是House的统一改成 上海豪宅
//对多个对象进行处理/编程==>切面编程
if(bean instanceof House) {
((House)bean).setName("上海豪宅~");
}
return null;
}
/**
* 什么时候被调用: 在Bean的init方法后被调用
* @param bean 传入的在IOC容器中创建/配置Bean
* @param beanName 传入的在IOC容器中创建/配置Bean的id
* @return 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回
* @throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization().. bean="
+ bean + " beanName=" + beanName);
return bean;
}
}
配置beans.xml
1. 当我们在 .xml 容器配置文件 配置了 MyBeanPostProcessor 2. 这时后置处理器对象，就会作用在该容器创建的Bean对象 3. 已经是针对所有对象编程->切面编程AOP
<!--配置House对象-->
<bean class="com.spring.bean.House" id="house"
init-method="init"
destroy-method="destroy">
<property name="name" value="大豪宅"/>
</bean>
<bean class="com.spring.bean.House" id="house02"
init-method="init"
destroy-method="destroy">
<property name="name" value="香港豪宅"/>
</bean>
<!--配置了一个Monster对象-->
<!--配置后置处理器对象
1. 当我们在beans02.xml 容器配置文件 配置了 MyBeanPostProcessor
2. 这时后置处理器对象，就会作用在该容器创建的Bean对象
3. 已经是针对所有对象编程->切面编程AOP
-->
<bean class="com.spring.bean.MyBeanPostProcessor" id="myBeanPostProcessor"/>
其它说明
1、怎么执行到这个方法?=> 使用 AOP(反射+动态代理+IO+容器+注解)
2、有什么用？=> 可以对 IOC 容器中所有的对象进行统一处理 ,比如 日志处理/权限的校验/安全的验证/事务管理. - 初步体验: 如果类型是 House 的统一改成 上海豪宅
3、针对容器的所有对象吗? 是的=>切面编程特点
通过属性文件给 bean 注入值
src/ 创建 my.properties
name=\u9EC4\u888D\u602A
id=10
skill=\u72EE\u5B50\u543C
@Test
public void setBeanByFile() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans03.xml");
Monster monster1000 = ioc.getBean("monster1000", Monster.class);
System.out.println("monster1000=" + monster1000);
}
1. 先把这个文件修改成提示All Problem 2. 提示错误，将光标放在context 输入alt+enter 就会自动引入namespace 3. location="classpath:my.properties" 表示指定属性文件的位置 4. 提示，需要带上 classpath 5. 属性文件有中文，需要将其转为unicode编码-> 使用工具
<context:property-placeholder location="classpath:my.properties"/> 配置Monster对象
1.通过属性文件给monster对象的属性赋值 2. 这时我们的属性值通过${属性名} 3. 这里说的 属性名 就是 my.properties文件中的 k=v 的k
配置beans.xml
<!--指定属性文件
1. 先把这个文件修改成提示All Problem
2. 提示错误，将光标放在context 输入alt+enter 就会自动引入namespace
3. location="classpath:my.properties" 表示指定属性文件的位置
4. 提示，需要带上 classpath
5. 属性文件有中文，需要将其转为unicode编码-> 使用工具
-->
<context:property-placeholder location="classpath:my.properties"/>
<!--配置Monster对象
1.通过属性文件给monster对象的属性赋值
2. 这时我们的属性值通过${属性名}
3. 这里说的 属性名 就是 my.properties文件中的 k=v 的k
-->
<bean class="com.spring.bean.Monster" id="monster1000">
<property name="monsterId" value="${monsterId}"/>
<property name="skill" value="${skill}"/>
<property name="name" value="${name}"/>
</bean>
基于 XML 的 bean 的自动装配
在 spring 的 ioc 容器,可以实现自动装配 bean
这里说的 Action 就是 Servlet->充当 Controller
OrderDao
public class OrderDao { //方法。。。 public void saveOrder() { System.out.println("保存 一个订单..."); } }
OrderService
public class OrderService {
//OrderDao属性
private OrderDao orderDao;
//getter
public OrderDao getOrderDao() {
return orderDao;
}
//setter
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
}
OrderAction
public class OrderAction {
//属性OrderService
private OrderService orderService;
//getter
public OrderService getOrderService() {
return orderService;
}
//setter
public void setOrderService(OrderService orderService) {
this.orderService = orderService;
}
}
配置beans.xml
1. autowire="byType" 表示 在创建 orderService时通过类型的方式 给对象属性 自动完成赋值/引用 2. 比如OrderService 对象有 private OrderDao orderDao 3. 就会在容器中去找有没有 OrderDao类型对象 4. 如果有，就会自动的装配, 提示如果是按照 byType 方式来装配, 这个容器中，不能有两个 的OrderDao类型对象 5. 如果你的对象没有属性, autowire就没有必要写 6. 其它类推..
7. 如果我们设置的是 autowire="byName" 表示通过名字完成自动装配 8. 比如下面的 autowire="byName" class="com.wyxedu.spring.service.OrderService" 1) 先看 OrderService 属性 private OrderDao orderDao 2) 再根据这个属性的setXxx()方法的 xxx 来找对象id 3) public void setOrderDao() 就会找id=orderDao对象来进行自动装配 4) 如果没有就装配失败
<!--配置OrderDao对象-->
<bean class="com.spring.dao.OrderDao" id="orderDao"/>
<!--配置OrderService对象
1. autowire="byType" 表示 在创建 orderService时
通过类型的方式 给对象属性 自动完成赋值/引用
2. 比如OrderService 对象有 private OrderDao orderDao
3. 就会在容器中去找有没有 OrderDao类型对象
4. 如果有，就会自动的装配, 提示如果是按照 byType 方式来装配, 这个容器中，不能有两个
的OrderDao类型对象
5. 如果你的对象没有属性, autowire就没有必要写
6. 其它类推..
7. 如果我们设置的是 autowire="byName" 表示通过名字完成自动装配
8. 比如下面的 autowire="byName" class="com.spring.service.OrderService"
1) 先看 OrderService 属性 private OrderDao orderDao
2) 再根据这个属性的setXxx()方法的 xxx 来找对象id
3) public void setOrderDao() 就会找id=orderDao对象来进行自动装配
4) 如果没有就装配失败
-->
<bean autowire="byName" class="com.spring.service.OrderService"
id="orderService"/>
<!--配置OrderAction-->
<bean autowire="byName" class="com.spring.web.OrderAction" id="orderAction"/>
spring eel 表达式
1. Spring Expression Language，Spring 表达式语言，简称 SpEL。支持运行时查询并可以操作对象。 2. 和 EL 表达式一样，SpEL 根据 JavaBean 风格的 getXxx()、setXxx()方法定义的属性访问对象 3. SpEL 使用#{…}作为定界符，所有在大框号中的字符都将被认为是 SpEL 表达式。 4. 不是重点，如果看到有人这样使用，能看懂即可
SpELBean.java
public class SpELBean {
private String name;
private Monster monster;
private String monsterName;
private String crySound; //叫声
private String bookName;
private Double result;
public SpELBean() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Monster getMonster() {
return monster;
}
public void setMonster(Monster monster) {
this.monster = monster;
}
public String getMonsterName() {
return monsterName;
}
public void setMonsterName(String monsterName) {
this.monsterName = monsterName;
}
public String getCrySound() {
return crySound;
}
public void setCrySound(String crySound) {
this.crySound = crySound;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public Double getResult() {
return result;
}
public void setResult(Double result) {
this.result = result;
}
//cry 方法会返回字符串
public String cry(String sound) {
return "发出 " + sound + "叫声...";
}
//read 返回字符串
public static String read(String bookName) {
return "正在看 " + bookName;
}
@Override
public String toString() {
return "SpELBean{" +
"name='" + name + '\'' +
", monster=" + monster +
", monsterName='" + monsterName + '\'' +
", crySound='" + crySound + '\'' +
", bookName='" + bookName + '\'' +
", result=" + result +
'}';
}
}
配置beans.xml
通过spel给bean的属性赋值
<!-- spring el 表达式使用
1. 通过spel给bean的属性赋值
-->
<bean id="spELBean" class="com.wyxedu.spring.bean.SpELBean">
<!-- sp el 给字面量 -->
<property name="name" value="#{'大家好'}"/>
<!-- sp el 引用其它bean -->
<property name="monster" value="#{monster01}"/>
<!-- sp el 引用其它bean的属性值 -->
<property name="monsterName" value="#{monster01.name}"/>
<!-- sp el 调用普通方法(返回值) 赋值 -->
<property name="crySound" value="#{spELBean.cry('喵喵的..')}"/>
<!-- sp el 调用静态方法(返回值) 赋值 -->
<property name="bookName" value="#{T(com.spring.bean.SpELBean).read('天龙八部')}"/>
<!-- sp el 通过运算赋值 -->
<property name="result" value="#{89*1.2}"/>
</bean>
测试
//通过spring el 对属性赋值
@Test
public void setBeanBySpel() {
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans04.xml");
SpELBean spELBean = ioc.getBean("spELBean", SpELBean.class);
System.out.println("spELBean=" + spELBean);
}