二、IOC 容器

Spring知识框架

一、Spring 框架概述
二、IOC 容器
三、AOP（面向切面编程）
四、JdbcTemplate
五、事务管理

---

正文

2.1 IOC 底层原理

1、什么是 IOC
控制反转（IOC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。通过控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理,也可以说，依赖被注入到对象中。
2、IOC 底层原理
xml 解析、工厂模式、反射

2.2 IOC 接口（BeanFactory）

BeanFactory	不提供开发人员进行使用，加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
ApplicationContext	BeanFactory 接口的子接口，开发人 员可以使用,加载配置文件时候就会把在配置文件对象进行创建

2、ApplicationContext 接口有实现类
FileSystemXmlApplicationContext
ClassPathXmlApplicationContext

2.3 IOC 操作 Bean 管理概述

1、什么是 Bean 管理 → 指的是两个操作：
（1）Spring 创建对象
（2）Spirng 注入属性
2、Bean管理操作有两种方式
（1）基于 xml 配置文件方式实现
（2）基于注解方式实现

2.4 基于 xml 方式操作Bean

2.4.1、基于 xml 方式创建对象

	<!--    配置User对象创建  -->
    <bean id="user" class="ys.User"/>

1. 在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建
2. 在 bean 标签有很多属性，介绍常用的属性
   • id 属性：唯一标识
   • class 属性：类全路径（包类路径）
3. 创建对象时候，默认也是执行无参数构造方法完成对象创建

2.4.2、基于 xml 方式注入属性

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

使用 set 方法进行注入

（1）创建类，定义属性和对应的 set 方法

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

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

使用有参数构造方法进行注入

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

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

<!--3 有参数构造注入属性--> 
<bean id="orders" class="ys.spring5.Orders">
	<constructor-arg name="oname" value="电脑"></constructor-arg>
 	<constructor-arg name="address" value="China"></constructor-arg>
</bean>

p 名称空间注入属性（了解）

（1）使用 p 名称空间注入，可以简化基于 xml 配置方式
第一步 添加 p 名称空间在配置文件中

（2） 进行属性注入，在 bean 标签里面进行操作

<!--2 set 方法注入属性-->
 <bean id="book" class="ys.spring5.Book" p:bname="九阳神功" 
p:bauthor="无名氏">
</bean>

xml 注入属性为null值

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

xml 注入属性包含特殊符号

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

注入外部 bean

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

注入内部 bean

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

级联注入属性

（1）第一种写法

<!--级联赋值--> 
<bean id="emp" class="ys.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="ys.spring5.bean.Dept">
	 <property name="dname" value="财务部"></property>
</bean> 

（2）第二种写法

<!--级联赋值--> 
<bean id="emp" class="ys.spring5.bean.Emp">
	 <!--设置两个普通属性-->
	 <property name="ename" value="lucy"></property>
	 <property name="gender" value="女"></property>
	 <!--级联赋值-->
	 <property name="dept.dname" value="技术部"></property>
 </bean>

xml 注入集合、数组 、列表

1、注入 数组/集合/列表 类型属性

<!--1 集合类型属性注入--> 
<bean id="stu" class="ys.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> 

2、在集合里面设置对象属性值

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

3、把集合注入部分提取出来
（1）在 spring 配置文件中引入名称空间 util
（2）使用 util 标签完成 list 集合注入提取

 <util:list id="bookList">
	 <value>易筋经</value>
	 <value>九阴真经</value>
	 <value>九阳神功</value>
</util:list>
<!--2 提取 list 集合类型属性注入使用--> 
<bean id="book" class="ys.spring5.collectiontype.Book">
 	<property name="list" ref="bookList"></property>
</bean>

FactoryBean 管理

普通 bean	在配置文件中定义 bean 类型就是返回类型
FactoryBean	在配置文件定义 bean 类型可以和返回类型不一样

1. 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
2. 实现接口里面的方法，在实现的方法中定义返回的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="ys.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 作用域

scope值	实例	创建对象的时机
singleton（默认值）	单实例	加载 spring 配置文件时候就会创建单实例对象
prototype	多实例	在调用getBean 方法时候创建多实例对象

bean 生命周期

生命周期:从对象创建到对象销毁的过程

 1. 通过构造器创建 bean 实例（无参数构造）
 2. 为 bean 的属性设置值和对其他 bean引用（调用 set 方法）
 3. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
 4. bean 可以使用了（对象获取到了） 
 5. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

bean 的后置处理器，bean 生命周期有七步

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

xml 自动装配

根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

<!--实现自动装配
 	bean 标签属性 autowire，配置自动装配
 	autowire 属性常用两个值：
		 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
		 byType 根据属性类型注入
-->
<bean id="emp" class="ys.spring5.autowire.Emp" autowire="byName"></bean> 
<bean id="dept" class="ys.spring5.autowire.Dept"></bean> 

<bean id="emp" class="ys.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="ys.spring5.autowire.Dept"></bean>

xml 方式操作外部属性文件（以数据库连接池为例）

1、直接配置数据库信息

<!--直接配置连接池--> 
<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. 创建外部属性文件，jdbc.properties 格式文件，写数据库信息
2. 把外部 properties 属性文件引入到 spring 配置文件中 引入 context 名称空间
3. 在 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>

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

2.5.1、什么是注解

1. 格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
2. 注解作用在类上面，方法上面，属性上面
3. 目的：简化 xml 配置

2.5.2、Spring 创建 bean 实例的注解

@Component	创建 bean 实例
@Service	创建 bean 实例
@Controller	创建 bean 实例
@Repository	创建 bean 实例

2.5.3、基于注解方式实现对象创建

第一步 引入依赖

第二步 开启组件扫描

<context:component-scan base-package="ys"></context:component-scan>

第三步 创建类，在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
//<bean id="userService" class=".."/>
@Component(value = "userService") 
public class UserService {
	 public void add() {
	 System.out.println("service add.......");
 } }

2.5.4、开启组件扫描细节配置

<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="ys" use-defaultfilters="false">
 	<context:include-filter type="annotation" 
		expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="ys">
 	<context:exclude-filter type="annotation" 
 		expression="org.springframework.stereotype.Controller"/>
</context:component-scan> 

2.5.5、注解→属性注入

（1）@Autowired：根据属性类型进行自动装配

@Service
public class UserService {
	 //定义 dao 类型属性
	 //不需要添加 set 方法
	 //添加注入属性注解
	 @Autowired 
	 private UserDao userDao;
	 public void add() {
	 System.out.println("service add.......");
	 userDao.add();
	 } 
}

（2）@Qualifier：根据名称进行注入，和@Autowired 一起使用

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

（3）@Resource：可以根据类型注入，可以根据名称注入

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao; 

（4）@Value：注入普通类型属性

@Value(value = "abc")
private String name; 

2.5.6、完全注解开发

创建配置类，替代 xml 配置文件

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"ys"})
public class SpringConfig {
}