Spring IOC

最新推荐文章于 2023-07-01 10:05:17 发布

L1AK

最新推荐文章于 2023-07-01 10:05:17 发布

阅读量143

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_43357874/article/details/118818096

版权

Java 专栏收录该内容

73 篇文章 0 订阅

订阅专栏

1.IOC原理（Inversion of Control)

参考 https://blog.csdn.net/ivan820819/article/details/79744797
https://zhuanlan.zhihu.com/p/64001753

1.1简介

IOC就是控制反转，DI是依赖注入，是实现IOC的一种方式
所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。
why?
借助于“第三方”实现具有依赖关系的对象之间的解耦

对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了，这就是“控制反转”这个名称的由来。
本来对象A依赖与对象B，但是通过IOC容器，把B和A解耦，到A对象运行需要B的时候再通过IoC将对象B注入到对象A中

1.2 IoC例子

这里有一个应用，包含两个Jar包，一个是myApp.jar，一个是lib.jar。其中myApp.jar包含了程序的主逻辑，由程序员A编写。lib.jar中定义了一个接口，和该接口的实现类，由程序员员B编写。

如下图：
在这里插入图片描述
在lib.jar中，有一个接口Person，两个实现类Student、Teacher。在myApp.jar，通过代码Person p = null；从而导致myApp.jar依赖于lib.jar。但因为语句Person p只是做了定义，而没有实际赋值。这时候我们就称myApp.jar仅依赖于lib.jar（通过接口Person），但并没有实现“注入”。然后，我们把程序进一步修改下，如图：
在这里插入图片描述
其中修改了语句：Person p = new Student();这样，MyApp.jar就把Student的实例“注入”到了对象p中，也就是说，通过new关键字创建对象，这就是最常见的依赖注入方法。但这种写法有一个很大的缺点，那就是因为myApp.jar不仅依赖于Person接口，还依赖于具体的实现类Student，这是一种明显的强耦合。而如果哪天myApp.jar不想使用Student了，而想使用Teacher，那么**程序员就不得不回过头来修改myApp.jar的代码。而在实际应用中，myApp.jar中往往包含了程序主流程。而主流程一旦完成，就应该保持相对稳定。如果有改变，也应该通过扩展的方式。这也就是架构设计中著名的“开关原则”，即主业务对修改关闭，对扩展开放。**而使用Spring就可以达到这样的目的。下面我们就引入Spring IOC机制，把代码修改下。如图：
在这里插入图片描述
这样，在myApp.jar包中，就把对Person对象的具体注入从代码中移除，代之在spring.xml文件中定义。任何时候，只要修改Spring.xml的配置，就能改变myApp.jar中具体Person对象的注入。从而保证了“开关原则”。而上面的整个过程，就是通过Spring框架中的IOC机制来实现的。从中，你也能体察到Spring框架为什么对企业级程序这么重要性。因为企业级程序必然是复杂的，而要解决复杂度的前提就是解耦。可以说，没有解耦，所有企业级应用都会崩溃在千丝万缕的业务逻辑中。

1.3 反射（Reflection）

IOC中最基本的技术就是“反射(Reflection)”编程，目前.Net C#、Java和PHP5等语言均支持，其中PHP5的技术书籍中，有时候也被翻译成“映射”。有关反射的概念和用法，大家应该都很清楚，通俗来讲就是根据给出的类名（字符串方式）来动态地生成对象。这种编程方式可以让对象在生成时才决定到底是哪一种对象。

1.4 底层原理

xml 解析、工厂模式、反射

2. IOC 接口（BeanFactory）

IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
Spring 提供 IOC 容器实现两种方式：（两个接口）
1. BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用* 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
2. ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使* 加载配置文件时候就会把在配置文件对象进行创建
ApplicationContext 接口有实现类

2.1 IOC操作bean管理

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

3. IOC 操作 Bean 管理（基于 xml）

3.1 基于xml方式创建对象

在这里插入图片描述

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

3.2 基于xml方式注入属性

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

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

创建类，定义属性和对应的 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 配置文件配置对象创建，配置属性注入

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

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

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

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

在 spring 配置文件中进行配置

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

3.5 p名称空间注入（使用 p 名称空间注入，可以简化基于 xml 配置方式）

第一步添加 p 名称空间在配置文件中
进行属性注入，在 bean 标签里面进行操作

3.6 xml 注入其他类型属性

3.6.1 字面量

null值

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

属性值包含特殊符号

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

3.6.2 注入属性-外部bean

创建两个类 service 类和 dao 类
在 service 调用 dao 里面的方法

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

在 spring 配置文件中进行配置

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

3.6.3 注入属性-内部bean

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

//部门类
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;
 } 
}

在 spring 配置文件中进行配置

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

3.6.4 注入属性-级联赋值

第一种写法

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

第二种写法

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

3.7 xml注入集合属性

3.7.1 注入数组类型属性 & 注入 List 集合类型属性 & 注入 Map 集合类型属性

创建类，定义数组、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;
	 } 
}

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

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

<!--创建多个 course 对象--> <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
 <property name="cname" value="Spring5 框架"></property>
</bean> <bean id="course2" class="com.atguigu.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.7.3 把集合注入部分提取出来

在 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">

使用 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>

3.4 IOC 操作 Bean 管理（FactoryBean）

在 Spring 里面，设置创建 bean 实例是单实例还是多实例
普通bean：配置文件中定义bean类型可以和返回类型
工厂bean：在配置文件定义bean类型可以和返回类型不一样
- 创建类，让这个类作为工厂bean，实现接口FactoryBean
- 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

 //定义返回 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>

public void test3() {
 ApplicationContext context =
 new ClassPathXmlApplicationContext("bean3.xml");
 Course course = context.getBean("myBean", Course.class);
 System.out.println(course);
}

3.5 IOC 操作 Bean 管理（bean 作用域）

在 Spring 里面，设置创建 bean 实例是单实例还是多实例
在 Spring 里面，默认情况下，bean 是单实例对象
如何设置单实例还是多实例
- 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
- scope 属性值
  - 第一个值默认值，singleton，表示是单实例对象
  - 第二个值 prototype，表示是多实例对象
singleton 和 prototype 区别
- singleton 单实例，prototype 多实例
- 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象
- 设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用
  getBean 方法时候创建多实例对象

3.6 IOC 操作 Bean 管理（bean 生命周期）

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

public class Orders {
	 //无参数构造
	 public Orders() {
	 	System.out.println("第一步 执行无参数构造创建 bean 实例");
	 }
	 private String oname;
	 public void setOname(String oname) {
		 this.oname = oname;
		 System.out.println("第二步 调用 set 方法设置属性值");
	 }
	 //创建执行的初始化的方法
	 public void initMethod() {
		 System.out.println("第三步 执行初始化的方法");
	 }
	 //创建执行的销毁的方法
	 public void destroyMethod() {
	 	System.out.println("第五步 执行销毁的方法");
	 } 
}
	 <bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod">
	 <property name="oname" value="手机"></property>
	</bean>
	
 @Test
 public void testBean3() {
	// ApplicationContext context =
	// new ClassPathXmlApplicationContext("bean4.xml");
	 ClassPathXmlApplicationContext context =
	 new ClassPathXmlApplicationContext("bean4.xml");
	 Orders orders = context.getBean("orders", Orders.class);
	 System.out.println("第四步 获取创建 bean 实例对象");
	 System.out.println(orders);
	 //手动让 bean 实例销毁
	 context.close();
 }

bean 的后置处理器，bean 生命周期有七步
- 通过构造器创建 bean 实例（无参数构造）
- 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
- 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
- 调用 bean 的初始化的方法（需要进行配置初始化的方法）
- 把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
- bean 可以使用了（对象获取到了）
- 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
添加后置处理器效果
- 创建类，实现接口 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;
 } 
}

<!--配置后置处理器--> <bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

在这里插入图片描述

3.6 IOC 操作 Bean 管理（xml 自动装配）

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

<!--实现自动装配
 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>

 -  根据属性类型自动注入

<!--实现自动装配
 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>

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

直接配置数据库信息
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>

引入外部属性文件配置数据库连接池
- 创建外部属性文件，properties 格式文件，写数据库信息
- 把外部 properties 属性文件引入到 spring 配置文件中
  - 引入 context 名称空间
  - 在 spring 配置文件使用标签引入外部属性文件

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

<!--引入外部属性文件-->
<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>

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

4.1 什么是注解

注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
使用注解，注解作用在类上面，方法上面，属性上面
使用注解目的：简化 xml 配置

4.2 Spring 针对 Bean 管理中创建对象提供注解

@Component
@Service
@Controller
@Repository

上面四个注解功能是一样的，都可以用来创建 bean 实例

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

第一步引入依赖
第二步开启组件扫描

<!--开启组件扫描
 1 如果扫描多个包，多个包使用逗号隔开
 2 扫描包上层目录
--><context:component-scan base-package="com.atguigu"></context:component-scan>

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

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

4.4 开启组件扫描细节配置

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

4.5 基于注解方式实现属性注入

@Autowired：根据属性类型进行自动装配
- 第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
- 第二步在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

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

@Qualifier：根据名称进行注入
1. 这个@Qualifier 注解的使用，和上面@Autowired 一起使用

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

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

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

@Value：注入普通类型属性

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

4.6 完全注解开发

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

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

编写测试类

@Test
public void testService2() {
 //加载配置类
 ApplicationContext context
 = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService", 
UserService.class);
 System.out.println(userService);
 userService.add();
}

L1AK

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring IOC

一、IOC原理依赖注入的方式依赖倒置原则、IOC、DI和Spring IOC容器的关系二、Spring IOC的应用spring IOC支持的功能spring IOC容器的核心接口getBean方法的代码逻辑Spring Bean的作用域Spring Bean的生命周期...
复制链接

扫一扫