Spring IOC

HikZ.919

已于 2022-04-25 20:50:24 修改

阅读量368

点赞数

分类专栏： Spring Java 文章标签： java

于 2022-04-25 18:49:04 首次发布

本文链接：https://blog.csdn.net/weixin_61399281/article/details/124411239

版权

Java 同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

Spring

2 篇文章 0 订阅

订阅专栏

Spring IOC是什么?

Spring是一个基于分层的javaEE应用一站式轻量级开源框架,主要核心是控制反转(IoC)和面向切面(AOP)的两大技术,实现项目在开发过程中的轻松解耦，提高项目的开发效率。

Spring 框架环境搭建

   新建 Maven 项目
       1. 创建 Maven 的普通 Java 项目
       2. 设置项目的坐标、名称、工作空间
       3. 设置项目的 Maven 环境
   调整项目环境
       1. 修改 JDK 版本

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>

2. 修改单元测试 JUnit 版本

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

添加 Spring 框架的依赖坐标
添加Spring框架的核心依赖

<!-- 添加Spring框架的核心依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>

   编写 Bean 对象
   添加Spring 配置文件
       1. 在项目的src下创建文件夹 resources（Alt+insert）
       2. 将 resources 标记为资源目录
       3. 在 src\main\resources 目录下新建 spring.xml 文件，并拷贝官网文档提供的模板内容到 xml 中。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
xmlns 即 xml namespace xml使用的命名空间
xmlns:xsi 即xml schema instance xml 遵守的具体规范
xsi:schemaLocation 本文档xml遵守的规范 官方指定
-->
<bean id="userService" class="com.xxxx.service.UserService"></bean>
</beans>

4. 在 spring.xml 中配置 Bean 对象
id：bean对象的id，唯一标识。一般是Bean对象的名称的首字母小写
class：bean对象的类路径

<!--
id：bean对象的id，唯一标识。一般是Bean对象的名称的首字母小写
class：bean对象的类路径
-->
<bean id="userService" class="com.xxxx.service.UserService"></bean>

   加载配置文件，获取实例化对象
       1.获取Spring上下文环境 (加载配置文件)
       2.通过getBean方法得到Spring容器中实例化好的Bean对象（实例化Bean对象）
// userService代表的是配置文件中bean标签的id属性值
           UserService userService = (UserService) ac.getBean("userService");
       3.调用方法（使用实例化对象）
           userService.test();

package com.yjxxt;
import com.yjxxt.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) {
// 获取Spring上下文环境 (加载配置文件)
ApplicationContext ac = new
ClassPathXmlApplicationContext("spring.xml");
// 通过getBean方法得到Spring容器中实例化好的Bean对象 （实例化Bean对象）
// userService代表的是配置文件中bean标签的id属性值
UserService userService = (UserService) ac.getBean("userService");
// 调用方法 （使用实例化对象）
userService.test();
}
}

Spring IOC 容器 Bean 对象实例化模拟

   思路
       1. 定义Bean 工厂接口，提供获取bean方法
       2. 定义Bean工厂接口实现类，解析配置文件，实例化Bean对象
       3. 实现获取Bean方法
   1. 定义 Bean 属性对象
       用来接收配置文件中bean标签的id与class属性值
   2. 添加 dom4j 坐标依赖
       1. dom4j

<!-- dom4j -->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- XPath -->
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>

2.XPath

<?xml version="1.0" encoding="utf-8" ?>
<beans>
<bean id="userService" class="com.xxxx.service.UserService"></bean>
<bean id="accountService" class="com.xxxx.service.AccountService"></bean>
</beans>

   3. 准备自定义配置文件
       <?xml version="1.0" encoding="utf-8" ?>
       <beans>
       <bean id="userService" class="com.xxxx.service.UserService"></bean>
       <bean id="accountService" class="com.xxxx.service.AccountService"></bean>
       </beans>
   4. 定义 Bean 工厂接口
       1.Bean 工厂接口定义
       2.通过id值获取对象
   5. 定义 Bean 接口的实现类
       1、通过构造器得到相关配置文件
       2、通过dom4j解析xml文件，得到List 存放id和class
       3、通过反射实例化得到对象 Class.forName(类的全路径).newInstance(); 通过Map<id,Class>存储
       4、得到指定的实例化对象
   .6. 测试自定义 IOC 容器
       1. 创建与配置文件中对应的Bean对象
       2. 测试是否可以获取实例化的Bean对象

Spring IOC 配置文件加载

1. Spring 配置文件加载 <bean id="userService" class="com.xxxx.service.UserService"></bean>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userService" class="com.xxxx.service.UserService"></bean>
</beans>

       1. 根据相对路径加载资源
       2. 根据绝对路径加载资源（了解）
   2. Spring 多配置文件加载
       .1. 可变参数，传入多个文件名
           同时加载多个资源文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userService" class="com.xxxx.service.UserService"></bean>
</beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="com.xxxx.dao.UserDao"></bean>
</beans>

       .2. 通过总的配置文件import其他配置文件
           <import resource="service.xml"/>
           <import resource="dao.xml"/>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--导入需要包含的资源文件-->
<import resource="service.xml"/>
<import resource="dao.xml"/>
</beans>

3.加载时只需加载总的配置文件即可
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");

Spring IOC 容器 Bean 对象实例化

   注：通过默认构造器创建空构造方法必须存在否则创建失败
   1. 构造器实例化
       1. 设置配置文件 spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userService" class="com.xxxx.service.UserService"></bean>
</beans>

           <bean id="userService" class="com.xxxx.service.UserService"></bean>
       2. 获取实例化对象
   .2. 静态工厂实例化（了解）
       1. 定义静态工厂类
       2. 设置配置文件 spring.xml
           <bean id="userService" class="com.xxxx.factory.StaticFactory" factorymethod="createUserService"></bean>
       3. 获取实例化对象
   3. 实例化工厂实例化（了解）
       1. 定义普通工厂类
       2. 设置配置文件 spring.xml
           <bean id="instanceFactory" class="com.xxxx.factory.InstanceFactory"></bean>
           <bean id="userService" factory-bean="instanceFactory" factorymethod="createUserService"></bean>
       3. 获取实例化对象

Spring IOC 注入

   .1. Spring IOC 手动装配（注入）
       1. set方法注入
           属性字段需要提供set方法
       .2. 构造器注入
           注意:循环依赖问题 Bean通过构造器注入，之间彼此相互依赖对方导致bean无法实例化。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
IOC通过构造器注入：
通过constructor-arg标签进行注入
name：属性名称
ref：指定bean标签的id属性值
-->
<bean id="userDao" class="com.yjxxt.dao.UserDao" ></bean>
<bean id="userService" class="com.yjxxt.service.UserService">
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
</beans>

               如何解决：将构造器注入改为set方法注
       3. 静态工厂注入
       4. 实例化工厂注入
       p名称空间的使用
           为了简化setter方法属性注入，引用p名称空间的概念，可以将子元素，简化为元素
属性配置。
               1. 属性字段提供 set 方法
               2. 在配置文件 spring.xml 引入 p 名称空间
               xmlns:p="http://www.springframework.org/schema/p"

. Spring IOC 自动装配（注入）

       注解方式注入 Bean,可以简化配置文件，
提高开发的速度，使程序看上去更简洁通过反射技术实现。
       .1. 准备环境
           1. 修改配置文件
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           2. 开启自动化注入
               <context:annotation-config/>

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--开启自动化装配（注入）-->
<context:annotation-config/>
<bean id="userDao" class="com.yjxxt.dao.UserDao"></bean>
<bean id="userService" class="com.yjxxt.service.UserService"></bean>

           3. 给注入的bean对象添加注解
       .2. @Resource注解
           名称查找对应的bean对象（属性字段的名称与bean标签的id属性值相等）
       .3. @Autowired注解
           默认通过类型（Class类型）查找bean对象与属性字段的名称无关
           属性可以提供set方法，也可以不提供set方法
           注解可以声明在属性级别或 set方法级别
           可以添加@Qualifier结合使用，通过value属性值查找bean对象（value属性值必须要设置，且值要与bean标签的id属性值对应）

Spring IOC 扫描器

   对扫描到的bean对象统一进行管理，简化开发配置，提高开发效率。
   1. Spring IOC 扫描器的配置
       1、设置自动化扫描的范围

<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 设置自动化扫描的范围 -->
<context:component-scan base-package="com.yjxxt"/>
</beans>

2、使用指定的注解（声明在类级别） bean对象的id属性默认是类的首字母小写

Bean的作用域与生命周期

默认情况下，我们从Spring容器中拿到的对象均是单例的

注意:

lazy-init是懒加载, 如果等于true时作用是指Spring容器启动的时候不会去实例化这个bean, 而是在程序调用时才去实例化. 默认是false即Spring容器启动时实例化.

默认情况下，被管理的bean只会IOC容器中存在一个实例，对于所有获取该Bean的操作Spring容器将只返回同一个Bean。容器在启动的情况下就实例化所有singleton 的 bean对象，并缓存与容器中 lazy-init属性（懒加载）如果为false，则在IOC容器启动时会实例化bean对象，默认false 如果为true，则IOC容器启动时不会实例化Bean对象，在使用bean对象时才会实例化

lazy-init设置为false有什么好处？

1）可以提前发现潜在的配置问题

2）Bean 对象存在于缓存中，使用时不用再去实例化bean，加快程序运行效率什么对象适合作为单例对象？一般来说对于无状态或状态不可改变的对象适合使用单例模式。（不存在会改变对象状态的成员变量）比如：controller层、service层、dao层

什么是无状态或状态不可改变的对象？

实际上对象状态的变化往往均是由于属性值得变化而引起的，比如user类姓名属性会有变化，属性姓名的变化一般会引起user对象状态的变化。对于我们的程序来说，无状态对象没有实例变量的存在，保证了线程的安全性，service 层业务对象即是无状态对象。线程安全的。

Web应用中的作用域

1. request作用域表示每个请求需要容器创建一个全新Bean。比如提交表单的数据必须是对每次请求新建一个Bean 来保持这些表单数据，请求结束释放这些数据。

2. session作用域表示每个会话需要容器创建一个全新Bean。比如对于每个用户一般会有一个会话，该用户的用户信息需要存储到会话中，此时可以将该Bean作用域配置为session级别。

3. globalSession作用域类似于session作用域，其用于portlet(Portlet是基于Java的Web组件，由Portlet容器管理，并由容器处理请求，生产动态内容)环境的web应用。如果在非portlet环境将视为session作用域。

Bean的生命周期

对比已经学过的servlet 生命周期（容器启动装载并实例化servlet类，初始化servlet，调用service方法，销毁servlet）。

同样对于Spring容器管理的bean也存在生命周期的概念在Spring中，Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段

Bean的定义在Spring中，通常是通过配置文档的方式来定义Bean的。在一个配置文档中，可以定义多个Bean。 8.2.2. Bean 的初始化默认在IOC容器加载时，实例化对象。

Spring bean 初始化有两种方式：

方式一：在配置文档中通过指定 init-method 属性来完成。

public class RoleService {
// 定义初始化时需要被调用的方法
public void init() {
System.out.println("RoleService init...");
}
}
<!-- 通过init-method属性指定方法 -->
<bean id="roleService" class="com.yjxxt.service.RoleService" init-method="init">

方式二：实现 org.springframework.beans.factory.InitializingBean 接口。

public class RoleService implements InitializingBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("RoleService init...");
}
}
<bean id="roleService" class="com.yjxxt.service.RoleService" ></bean>

Bean 的使用

//方式一：使用 BeanFactory

// 得到Spring的上下文环境
BeanFactory factory = new ClassPathXmlApplicationContext("spring.xml");
RoleService roleService = (RoleService) factory.getBean("roleService");


//方式二：使用 ApplicationContext
// 得到Spring的上下文环境
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
RoleService roleService = (RoleService) ac.getBean("roleService");

Bean的销毁

实现销毁方式(Spring容器会维护bean对象的管理，可以指定bean对象的销毁所要执行的方法)

<bean id="roleService" class="com.yjxxt.service.RoleService" destroymethod="destroy"></bean>
**步骤二：**通过 AbstractApplicationContext 对象，调用其close方法实现bean的销毁过程
AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("spring.xml");
ctx.close();

HikZ.919

关注

0
点赞
踩
1

收藏

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

Spring IOC是什么? Spring是一个基于分层的javaEE应用一站式轻量级开源框架,主要核心是控制反转(IoC)和面向切面(AOP)的两大技术,实现项目在开发过程中的轻松解耦，提高项目的开发效率。Spring 框架环境搭建新建 Maven 项目 1. 创建 Maven 的普通 Java 项目 2. 设置项目的坐标、名称、工作空间 3. 设置项目的 Maven 环境调整项目环境 1. 修改 JD...
复制链接

扫一扫