Spring中的IOC知识学习记录（xml）
IOC（接口）
1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
2.Spring提供IOC容器实现两种方式：（两个接口）
（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口；
加载配置文件的时候不会创建对象，在获取对象（使用）的时候才去创建对象（懒汉式）
（2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员使用。
加载配置文件的时候就会在配置文件中将对象进行创建（饿汉式）
public class TestSpring5 {
@Test
public void testCollection(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
A b = context.getBean("b", A.class); //这里的b就是bean标签中id的名称
b.test();
}
}
3.ApplicationContext接口有实现类
IOC操作Bean管理
1.什么是Bean管理？
指代两个操作：Spring创建对象和Spring注入属性
2.Bean管理操作有两种方式
（1）基于xml配置文件方式实现
（2）基于注解方式实现
IOC操作Bean管理（基于xml方式）
基于xml方式创建对象
<bean id="user" class="com.syw.spring5.User"></bean>
（1）在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建；
（2）在bean标签中有很多属性，常用的属性有：id唯一标识、class类的全类名；
（3）创建对象的时候，默认执行无参构造方法，当添加
public User(String userName) {
this.userName = userName;
}
的时候，就会报Caused by: java.lang.NoSuchMethodException: com.syw.spring5.User.错误。
基于xml方式注入属性
（1）DI：依赖注入，即注入属性第一种注入方式：使用set方法进行注入
步骤1：创建类，定义属性和对应的set方法
package com.syw.spring5;
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;
}
public void testDemo(){
System.out.println(bname+":"+bauthor);
}
}
步骤2：在Spring配置文件配置对象创建，配置属性注入
<bean id="book" class="com.syw.spring5.Book">
<!-- bean标签里使用property完成属性注入-->
<property name="bname" value="高数"></property>
<property name="bauthor" value="同济出版社"></property>
</bean>
步骤3：单元测试
@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.testDemo();
}
第二种注入方式：使用有参构造进行注入
步骤1：创建类，定义属性，创建属性对应有参构造方法
package com.syw.spring5;
public class Orders {
private String oname;
private String address;
public Orders(String oname, String address) {
this.oname = oname;
this.address = address;
}
}
步骤2：在Spring配置文件中配置
<!-- 有参构造注入属性-->
<bean id="orders" class="com.syw.spring5.Orders">
<constructor-arg name="oname" value="Tom"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
步骤3：单元测试
@Test
public void testOrders(){
// 1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
// 2.获取配置创建的对象
Orders orders = context.getBean("orders", Orders.class);
System.out.println(orders);
orders.ordersTest();
}
xml注入其他类型属性
1.字面量 （1）null值<property name="address">
<null></null>
</property>
结果为高数:同济出版社:null
（2）属性值包含特殊符号
<property name="address">
<!-- IDEA输入CD可快捷生成-->
<value><![CDATA[<<南京>>]]></value>
</property>
结果为高数:同济出版社:<<南京>>
2.注入属性-外部bean
（1）创建两个类：service类和dao类
（2）在service类中调用dao类里面的方法
（3）在Spring配置文件中进行配置
Dao：
package com.syw.spring5.dao;
public interface UserDao {
public void update();
}
package com.syw.spring5.dao;
public class UserDaoImp implements UserDao{
@Override
public void update() {
System.out.println("dao update------");
}
}
Service：
package com.syw.spring5.service;
import com.syw.spring5.User;
import com.syw.spring5.dao.UserDao;
import com.syw.spring5.dao.UserDaoImp;
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.update();
}
}
bean：
<!-- service和dao对象创建-->
<bean id="userService" class="com.syw.spring5.service.UserService">
<!-- 注入userDao对象
name属性：类里面属性的名称
ref属性：创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImp"></property>
</bean>
<!-- 接口不能new,只能找实现类-->
<bean id="userDaoImp" class="com.syw.spring5.dao.UserDaoImp"></bean>
单元测试的结果为：
service add------
dao update------
3.注入属性-内部bean和级联赋值
（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于某一个部门。
（2）在实体类之间表示一对多关系
package com.syw.spring5.bean;
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
}
package com.syw.spring5.bean;
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);
}
}
（3）在Spring配置文件中配置
<bean id="emp" class="com.syw.spring5.bean.Emp">
<property name="ename" value="Lucy"></property>
<property name="gender" value="女"></property>
<!-- 对象类型的属性-->
<property name="dept">
<bean id="dept" class="com.syw.spring5.bean.Dept">
<property name="dname" value="开发部"></property>
</bean>
</property>
</bean>
单元测试结果为：Lucy:女:Dept{dname='开发部'}
4.注入属性-级联赋值
（1）第一种写法
<!-- 级联赋值-->
<bean id="emp" class="com.syw.spring5.bean.Emp">
<property name="ename" value="Lucy"></property>
<property name="gender" value="女"></property>
<!-- 级联赋值-->
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.syw.spring5.bean.Dept">
<property name="dname" value="开发部"></property>
</bean>
单元测试结果为：Lucy:女:Dept{dname='开发部'}
（2）第二种写法
bean标签内加入： <property name="dept.dname" value="技术部"></property>
Emp类添加get方法，因为dept需要调用dname
xml注入集合属性
1.注入数组类型属性
2.注入List集合类型属性
3.注入Map集合类型属性
4.注入Set集合类型属性
package com.syw.spring5.collectiontype;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
// 数组类型属性
private String[] courses;
// list集合类型属性
private List<String> list;
// map集合类型属性
private Map<String,String> maps;
// set集合类型属性
private Set<String> set;
public void setSet(Set<String> set) {
this.set = set;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
}
（2）在Spring配置文件中配置
<bean id="stu" class="com.syw.spring5.collectiontype.Stu">
<property name="courses">
<array>
<value>Java</value>
<value>MySQL</value>
</array>
</property>
<property name="list">
<list>
<value>张三</value>
<value>李四</value>
</list>
</property>
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PHP" value="php"></entry>
</map>
</property>
<property name="set">
<set>
<value>HTML</value>
<value>CSS</value>
</set>
</property>
</bean>
单元测试结果：
[Java, MySQL]
[张三, 李四]
{JAVA=java, PHP=php}
[HTML, CSS]
在集合里面设置对象类型值
注入List集合类型，值是对象
-->
<property name="coursesList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
<!-- 创建多个course对象-->
<bean id="course1" class="com.syw.spring5.collectiontype.Course">
<property name="coursename" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.syw.spring5.collectiontype.Course">
<property name="coursename" value="MyBatis框架"></property>
</bean>
package com.syw.spring5.collectiontype;
public class Course {
private String coursename;
public void setCoursename(String coursename) {
this.coursename = coursename;
}
@Override
public String toString() {
return "Course{" +
"coursename='" + coursename + '\'' +
'}';
}
}
单元测试结果：[Course{coursename='Spring5框架'}, Course{coursename='MyBatis框架'}]
把集合注入部分提取出来
（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: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">
</beans>
（2）使用util标签完成List集合注入提取
<!-- 提取List集合类型属性注入-->
<util:list id="bookList">
<value>活着</value>
<value>围城</value>
<value>三体</value>
</util:list>
<!-- 提取List集合类型属性注入使用-->
<bean id="book" class="com.syw.spring5.collectiontype.Book">
<property name="list" ref="bookList"></property>
</bean>
单元测试结果：[活着, 围城, 三体]
IOC操作Bean管理（FactoryBean）
1.Spring有两种bean，普通bean和工厂bean
普通bean：在配置文件中定义bean类型就是返回类型
工厂bean：在配置文件中定义bean类型可以和返回类型不一样
步骤（1）：创建类，让这个类作为工厂bean，实现接口FactoryBean
package com.syw.spring5.FactoryBean;
import com.syw.spring5.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course> {
// 定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCoursename("SYW");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
步骤（2）：实现接口里面的方法，在实现的方法中定义返回的bean类型
@Test
public void testFactory(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
Course course= context.getBean("mybean", Course.class);
System.out.println(course);
}
单元测试结果为：Course{coursename='SYW'}
IOC操作Bean管理（作用域）
1.在Spring里面，设置创建bean实例是单实例还是多实例
2.在Spring里面，默认情况下，创建的bean是一个单实例对象
3.bean标签中的scope属性：第一个值：singleton表示单实例对象；第二个值：prototype表示多实例对象。
\quad 区别：单实例，多实例；设置scope值是singleton的时候，加载Spring配置文件的时候就会创建单实例对象；设置scope值是prototype的时候，不是在加载Spring配置文件的时候创建对象，而是在调用getBean方法的时候创建多实例对象。
IOC操作Bean管理（生命周期）
1.生命周期
（1）从对象创建到对象销毁的过程
2.bean生命周期
（1）通过构造器创建bean实例（无参构造）
（2）为bean的属性设置值和对其他bean引用（调用set方法）
（3）调用bean的初始化的方法（需要进行配置）
（4）bean使用（获取到对象）
（5）当容器关闭的时候，调用bean的销毁方法（需要配置销毁的方法）
3.演示过程
<bean id="orders" class="com.syw.spring5.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
<property name="oname" value="手机"></property>
</bean>
package com.syw.spring5.bean;
public class Orders {
private String oname;
public Orders() {
System.out.println("1.无参构造");
}
public void setOname(String oname) {
this.oname = oname;
System.out.println("2.调用set方法设置属性值");
}
// 创建执行的初始化的方法
public void initMethod(){
System.out.println("3.执行初始化的方法");
}
// 创建执行的销毁的方法
public void destoryMethod(){
System.out.println("5.销毁");
}
}
@Test
public void testBean3(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
Orders orders= context.getBean("orders", Orders.class);
System.out.println("4.获取创建bean的实例对象");
System.out.println(orders);
// 手动让bean销毁
((ClassPathXmlApplicationContext) context).close();
}
单元测试结果为：
1.无参构造
2.调用set方法设置属性值
3.执行初始化的方法
4.获取创建bean的实例对象
com.syw.spring5.bean.Orders@4c163e3
5.销毁
4.bean的后置处理器
（1）通过构造器创建bean实例（无参构造）
（2）为bean的属性设置值和对其他bean引用（调用set方法）
（3）把bean实例传递给bean后置处理器的方法
（4）调用bean的初始化的方法（需要进行配置）
（5）把bean实例传递给bean后置处理器的方法
（6）bean使用（获取到对象）
（7）当容器关闭的时候，调用bean的销毁方法（需要配置销毁的方法）
5.演示添加后置处理器
<bean id="myBeanPost" class="com.syw.spring5.bean.MyBeanPost"></bean>
package com.syw.spring5.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("初始化之后执行的方法");
return bean;
}
}
单元测试结果为：1.无参构造
2.调用set方法设置属性值
初始化之前执行的方法
3.执行初始化的方法
初始化之后执行的方法
4.获取创建bean的实例对象
com.syw.spring5.bean.Orders@312aa7c
5.销毁
IOC操作Bean管理（xml自动装配）
1.什么是自动装配？
\quad 根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入
2.演示自动装配过程
package com.syw.spring5.autowire;
public class Dept {
@Override
public String toString() {
return "Dept{}";
}
}
package com.syw.spring5.autowire;
public class Emp {
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{" +
"dept=" + dept +
'}';
}
public void test(){
System.out.println(dept);
}
}
<bean id="emp" class="com.syw.spring5.autowire.Emp">
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.syw.spring5.autowire.Dept"></bean>
单元测试结果为：Emp{dept=Dept{}} 这是手动装配
<!-- bean标签属性autowire 配置自动装配
autowire属性常用两个值：byName根据属性名称注入 : 注入值bean的id值和类属性名称一样
byType根据属性类型注入 :
-->
<bean id="emp" class="com.syw.spring5.autowire.Emp" autowire="byName"></bean>
自动装配
浙公网安备 33010602011771号