Spring-IOC

IOC底层原理

什么是IOC？

控制反转：将创建对象和对象之间的调用都交spring来实现

有什么好处？

解耦合
工厂模式解耦合：
IOC解耦合过程：

IOC接口（BeanFactory）

Spring 提供 IOC 容器实现两种方式：（两个接口）

（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用
加载配置文件时候不会创建对象，在获取对象（使用）时才去创建对象
（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人
员进行使用

一般情况用（2），将耗资源耗时间的创建对象交给服务启动时就做好，我们直接用就好了

Bean管理

什么是 Bean 管理
（0）Bean 管理指的是两个操作
（1）Spring 创建对象
（2）Spirng 注入属性

Bean 管理操作有两种方式
（1）基于 xml 配置文件方式实现
（2）基于注解方式实现

IOC操作Bean管理（基于xml）

<bean id="" class=""></bean>

基于 xml 方式创建对象

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建
（2）在 bean 标签有很多属性，介绍常用的属性

• id 属性：唯一标识
• class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

基于 xml 方式注入属性

DI：依赖注入，就是注入属性

• 第一种注入方式：使用 set 方法进行注入

---

创建类，定义属性和对应的 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;
 }
}

在 spring 配置文件配置对象创建，配置属性注入

<bean id="book" class="com.atguigu.spring5.Book">
 <!--使用 property 完成属性注入
 name：类里面属性名称
 value：向属性注入的值
 -->
 <property name="bname" value="易筋经"></property>
 <property name="bauthor" value="达摩老祖"></property>
</bean>

---

• 第二种注入方式：使用有参数构造进行注入

---

创建类，定义属性，创建属性对应有参数构造方法

public class Orders {
 //属性
 private String oname;
 private String address;
 //有参数构造
 public Orders(String oname,String address) {
 this.oname = oname;
 this.address = address;
 }
}

在 spring 配置文件中进行配置

<bean id="orders" class="com.atguigu.spring5.Orders">
 <constructor-arg name="oname" value="电脑"></constructor-arg>
 <constructor-arg name="address" value="China"></constructor-arg>
</bean>

进阶: XML自动装配对象属性
p名称空间注入

IOC操作Bean管理（注入空值和特殊符号）

• 字面量

（1）null 值

<!--null 值-->
< property name= "address">
< null/>
</ property>

（2）属性值包含特殊符号

<!--属性值包含特殊符号
1 把<>进行转义 &lt; &gt;
2 把带特殊符号内容写到 CDATA
-->
< property name= "address">
< value><![CDATA[<<南京>>]]></ value>
</ property>

IOC操作Bean管理（注入外部Bean）

（1）创建两个类 service 类和 dao 类
（2）在 service 调用 dao 里面的方法
（3）在 spring 配置文件中进行配置
JAVA:

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();
}
}

XML:

<!--1 service 和 dao 对象创建-->
< bean id= "userService" class= "com.atguigu.spring5.service.UserService">
<!--注入 userDao 对象
name 属性：类里面属性名称
ref 属性：创建 userDao 对象 bean 标签 id 值
-->
< property name= "userDao" ref= "userDaoImpl"></ property>
</ bean>
< bean id= "userDaoImpl" class= "com.atguigu.spring5.dao.UserDaoImpl"></ bean>

IOC操作Bean管理（注入内部Bean）

（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
部门是一，员工是多
（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
JAVA：

部门类

public class Dept {
private String dname;
public void setDname(String dname) {
this. 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;
}
}

(3)在 spring 配置文件中进行配置

<!--内部 bean-->
< bean id= "emp" class= "com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
< property name= "ename" value= "lucy"></ property>
< property name= "gender" value=" " 女" "></ property>
<!--设置对象类型属性-->
< property name= "dept">
< bean id= "dept" class= "com.atguigu.spring5.bean.Dept">
< property name= "dname" value=" " 安保部" "></ property>
</ bean>
</ property>
</ bean>

凸凸大军中一员: 级联赋值的两种方法.

IOC操作Bean管理（XML注入集合属性）

1 、注入数组类型属性
2 、注入 List 集合类型属性
3 、注入 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;
public void setSets(Set<String> sets) {
this. sets = sets;
}
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;
}
}

（2）在 spring 配置文件进行配置

<!--1 集合类型属性注入-->
< bean id= "stu" class= "com.atguigu.spring5.collectiontype.Stu">
<!--数组类型属性注入-->
< property name= "courses">
< array>
< value>java 课程</ value>
< value>数据库课程</ value>
</ array>
</ property>
<!--list 类型属性注入-->
< property name= "list">
< list>
< value>王老五</ value>
< value>沈小二</ value>
</ list>
</ property>
<!--map 类型属性注入-->
< 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>

在集合里面设置对象类型值

<!--创建多个 course 对象-->
< bean id= "course1" class= "com.atguigu.spring5.collectiontype.Course">
< property name= "cname" value=5 "Spring5 框架" "></ property>
</ bean>
< bean id= "course2" class= "com.atguigu.spring5.collectiontype.Course">
< property name= "cname" value=s "MyBatis 框架" "></ property>
</ bean>
<!--注入 list 集合类型，值是对象-->
< property name= "courseList">
< list>
< ref bean= "course1"></ ref>
< ref bean= "course2"></ ref>
</ list>
</ property>

把集合注入部分提取出来

（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>

IOC 操作 Bean 管理（FactoryBean ）

1 、Spring 有两种类型 bean ，一种普通 bean ，另外一种工厂 bean （FactoryBean ）
2 、普通 bean ：在配置文件中定义 bean 类型就是返回类型
3 、工厂 bean ：在配置文件定义 bean 类型可以和返回类型不一样
第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

public class MyBean implements FactoryBean<Course> {
//定义返回 bean
@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 false;
}
}
< bean id= "myBean" class= "com.atguigu.spring5.factorybean.MyBean">
</ bean>
@Test
public void test3() {
ApplicationContext context =
new ClassPathXmlApplicationContext( "bean3.xml");
Course course = context.getBean( "myBean", Course. class);
System. out .println(course);
}

Bean的生命周期

bean 的后置处理器，bean 生命周期有七步
（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）把 n bean 实例传递 n bean 后置处理器的方法 postProcessBeforeInitialization
（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）
（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
（6）bean 可以使用了（对象获取到了）
（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

IOC 操作 Bean 管理( 外部属性文件)

1 、直接配置数据库信息
（1）配置德鲁伊连接池
（2）引入德鲁伊连接池依赖 jar 包

<!--直接配置连接池-->
< bean id ="dataSource" class ="com.alibaba.druid.pool.DruidDataSource">
< property name ="driverClassName" value ="com.mysql.jdbc.Driver"></ property>
< property name ="url"
value ="jdbc:mysql://localhost:3306/userDb"></ property>
< property name ="username" value ="root"></ property>
< property name ="password" value ="root"></ property>
</ bean>

2 、引入外部属性文件配置数据库连接池
（1）创建外部属性文件，properties 格式文件，写数据库信息

（2）把外部 properties 属性文件引入到 spring 配置文件中

• 引入 context 名称空间

< beans xmlns ="http://www.springframework.org/schema/beans"
xmlns: xsi ="http://www.w3.org/2001/XMLSchema- - instance"
xmlns:p p ="http://www.springframework.org/schema/p"
xmlns: util ="http://www.springframework.org/schema/util"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring- - context.xsd d" ">

在 spring 配置文件使用标签引入外部属性文件

<!--引入外部属性文件-->
< context :property- - placeholder location ="classpath:jdbc.properties"/>
<!--配置连接池-->
< bean id ="dataSource" class ="com.alibaba.druid.pool.DruidDataSource">
< property name ="driverClassName" value ="${prop.driverClass}"></ property>
< property name ="url" value ="${prop.url}"></ property>
< property name ="username" value ="${prop.userName}"></ property>
< property name ="password" value ="${prop.password}"></ property>
</ bean>

IOC操作Bean管理（基于注解）