欢迎光临
我们一直在努力
        找回密码
当前位置：171主机测评 > 服务器技术 > 正文

Spring入门指南：揭秘IOC与工厂模式解耦

2026-03-11 分类：服务器技术 阅读(31) 评论(0)

目录

一、Spring概述

1、Spring介绍

2、Spring的体系结构

二、Spring IOC深入解析

1、程序的耦合

2、工厂模式的IOC解决程序耦合

3、Spring的IOC解决程序耦合

3.1、pom.xml

3.2、IOC

3.3、DI

3.3.1、构造函数注入

3.3.2、set方法注入

3.3.3、自动注入

3.3.4、注入集合类型的属性

总结

一、Spring概述

1、Spring介绍

        Spring是轻量级的Java EE应用开源框架，由Rod Johnson创建，旨在解决企业级开发的复杂性。它通过IOC、AOP等技术简化应用开发，并像“粘合剂”一样整合其他技术框架，解决了传统Java开发中的高耦合和代码冗余问题。

2、Spring的体系结构

        Spring 框架根据功能的不同大体可分为 Data Access/Integration（数据访问与集成）、Web、AOP、Aspects、Instrumentation（检测）、Messaging（消息处理）、Core Container（核心容器）和 Test。

  • Core Container： 框架的最基础部分，提供控制反转和依赖注入特性

  • AOP ：提供了面向切面的编程的实现

  • Data Access/Integration：简化了持久层的操作

  • Web：提供了Spring MVC Web 框架实现以及与Servlet、WebSocket的集成

  • Test：方便程序的测试

二、Spring IOC深入解析

        IOC（控制反转）是Spring的核心思想之一，它解决程序中的耦合问题。

1、程序的耦合

  • 耦合：耦合指的就是对象之间的依赖关系。对象之间的耦合越高，维护成本越高。

  • 案例：没有引入IOC容器时系统的Web层、业务层、持久层存在耦合

public class UserDaoImpl implements UserDao {

@Override
public void addUser(){
System.out.println("insert into tb_user……");
}
}
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl(); // 硬编码的耦合
public void addUser() {
userDao.addUser();
}
}
public class Client {
public static void main(String[] args) {
//硬编码：此处有依赖关系
UserService userService = new UserServiceImpl();
userService.addUser();
}
}

  • 问题分析：

    上边的代码service层在依赖dao层的实现类，此时如果更改dao了层的实现类或此时没有dao层实现类，编译将不能通过。

  • IOC(工厂模式)解耦：

    • 把所有的dao和service对象使用配置文件配置起来

    • 当服务器启动时读取配置文件

    • 把这些对象通过反射创建出来并保存在容器中

    • 在使用的时候，直接从工厂拿

2、工厂模式的IOC解决程序耦合

之前我们在获取对象时，都是采用new的方式，是主动的。

现在：

        我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

        这种被动接收的方式获取对象的思想就是控制反转，它是spring框架的核心之一。

案例一

/**
* bean工厂
*/
public class BeanFactory_v1 {

/**
* 获得UserServiceImpl对象
* @return
*/
public static UserService getUserService(){
return new UserServiceImpl();
}

/**
* 获得UserDaoImpl对象
* @return
*/
public static UserDao getUserDao(){
return new UserDaoImpl();
}
}

问题：我们在开发中会有很多个service和dao，此时工厂类就要添加无数个方法。

案例二

#1、配置要使用的dao和service
UserDao=com.hg.dao.UserDaoImpl
UserService=com.hg.service.UserServiceImpl

/**
* bean工厂
*/
public class BeanFactory_v2 {

private static Properties prop = new Properties();

/**
* 根据全类名获取bean对象
* @param beanName
* @return
* @throws ClassNotFoundException
*/
public static Object getBean(String beanName) {
try {
//不能使用：web工程发布后没有src目录
//InputStream is = new FileInputStream("src/bean.properties");
InputStream is =
BeanFactory_v2.class.getClassLoader()
.getResourceAsStream("bean.properties");
prop.load(is);
return Class.forName(prop.getProperty(beanName)).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

public static void main(String[] args) {
System.out.println(prop.get("UserService"));
System.out.println(getBean("UserService"));
}
}
/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {

private UserDao userDao = (UserDao) BeanFactory.getBean("UserDao");

public void addUser(){
userDao.addUser();
}
}

测试：

/**
* 模拟表现层
*/
public class Client {
public static void main(String[] args) {
//直接引用接口实现类
for (int i = 0; i < 5; i++) {
UserService userService =
(UserService)BeanFactory_v2.getBean("UserService");
System.out.println(userService);
}
}
}

问题：

  • 每次都会创建新的对象

  • 程序运行时才创建对象(读取配置文件)

案例三

package com.hg.factory;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
* bean工厂
*/
public class BeanFactory_v3 {

//定义一个容器，用于存放对象
private static Map<String, Object> beans = new HashMap<>();

/**
* 加载配置文件
*/
static {
try {
//2、读取配置文件
//不能使用：web工程发布后没有src目录
//InputStream is = new FileInputStream("src/bean.properties");
InputStream is =
BeanFactory_v3.class.getClassLoader()
.getResourceAsStream("bean.properties");

//3、通过反射创建对象,把对象存到容器中
Properties prop = new Properties();
prop.load(is);
Set<Map.Entry<Object, Object>> entrySet = prop.entrySet();
for (Map.Entry<Object, Object> entry : entrySet) {
String key = entry.getKey().toString();
String beanName = entry.getValue().toString();
Object value = Class.forName(beanName).newInstance();
beans.put(key, value);
}

} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 4、在使用的时候，直接从工厂拿
* @param beanName
* @return
*/
public static Object getBean(String beanName) {
try {
return beans.get(beanName);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

public static void main(String[] args) {
System.out.println(getBean("UserService"));
}
}

3、Spring的IOC解决程序耦合

3.1、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.hg</groupId>
<artifactId>Spring_IOC_Xml</artifactId>
<version>1.0-SNAPSHOT</version>

<properties>
<!– 项目源码及编译输出的编码 –>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!– 项目编译JDK版本 –>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>

<dependencies>
<!– Spring常用依赖 –>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
</dependencies>
</project>

注意：Jar包彼此存在依赖，只需引入最外层Jar即可由Maven自动将相关依赖Jar引入到项目中。

        核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4个模块组成。

spring-beans和spring-core模块 是Spring框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。
spring-context模块 构架于核心模块之上，扩展了BeanFactory，为它添加了Bean生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。
spring-expression 模块 是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。

1）dao

/**
* 持久层实现类
*/
public class UserDaoImpl implements UserDao {

@Override
public void addUser(){
System.out.println("insert into tb_user……");
}
}

2）service

/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {
//此处有依赖关系
private UserDao userDao = new UserDaoImpl();

@Override
public void addUser(){
userDao.addUser();
}
}

3.2、IOC

1）applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!–1、注意：要导入schema约束–>
<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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<!–
2、把对象交给spring来创建
id：给对象在容器中提供一个唯一标识。用于获取对象
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数
–>
<bean id="userDao" class="com.hg.dao.UserDaoImpl"></bean>
<bean id="userService" class="com.hg.service.UserServiceImpl"></bean>
</beans>

注意：命名无限制，约定俗成命名有：spring-context.xml、applicationContext.xml、beans.xml

2）测试

/**
* 模拟表现层
*/
public class Client {
public static void main(String[] args) {
//1.使用ApplicationContext接口，就是在获取spring容器
ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xml");
//2.根据bean的id获取对象
UserDao userDao = (UserDao) ac.getBean("userDao");
System.out.println(userDao);

UserService userService = (UserService) ac.getBean("userService");
System.out.println(userService);
userService.addUser();
}
}

问题：service层仍然耦合

3.3、DI

        概述：DI（Dependency Injection）依赖注入：将依赖对象从容器中拿出来赋值给调用者

3.3.1、构造函数注入

/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {

private UserDao userDao;
private String name;
private Integer age;

public UserServiceImpl(UserDao userDao, String name, Integer age) {
this.userDao = userDao;
this.name = name;
this.age = age;
}

public void addUser(){
System.out.println(name+","+age);
userDao.addUser();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!–1、注意：要导入schema约束–>
<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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!–2、把对象交给spring来创建–>
<bean id="userDao" class="com.hg.dao.UserDaoImpl"></bean>
<bean id="userService" class="com.hg.service.UserServiceImpl">
<!–
要求：类中需要提供一个对应参数列表的构造函数。
标签：constructor-arg
==给谁赋值:==
index:指定参数在构造函数参数列表的索引位置
name:指定参数在构造函数中的名称
==赋什么值:==
value:它能赋的值是基本数据类型和String类型
ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
–>
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
<constructor-arg name="name" value="张三"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
</bean>
</beans>

3.3.2、set方法注入

/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {

private UserDao userDao;
private String name;
private Integer age;

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

public void setName(String name) {
this.name = name;
}

public void setAge(Integer age) {
this.age = age;
}

public void addUser(){
System.out.println(name+","+age);
userDao.addUser();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!–1、注意：要导入schema约束–>
<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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!–2、把对象交给spring来创建–>
<bean id="userDao" class="com.hg.dao.UserDaoImpl"></bean>
<bean id="userService" class="com.hg.service.UserServiceImpl">
<!–
要求：必须提供set方法
标签：property
==给谁赋值:==
name:找的是类中set方法后面的部分
==赋什么值:==
value:它能赋的值是基本数据类型和String类型
ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
–>
<property name="userDao" ref="userDao"></property>
<property name="name" value="张三"></property>
<property name="age" value="18"></property>
</bean>
</beans>

3.3.3、自动注入

/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {

private UserDao userDao;

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

public void addUser(){
userDao.addUser();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!–1、注意：要导入schema约束–>
<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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!–2、把对象交给spring来创建–>
<bean id="userDao" class="com.hg.dao.UserDaoImpl"></bean>
<!–autowire="byType"：按照类型自动注入值–>
<bean id="userService" class="com.hg.service.UserServiceImpl" autowire="byType">
</bean>
</beans>

3.3.4、注入集合类型的属性

/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {

private UserDao userDao;
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String,String> myMap;

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

public void setMyStrs(String[] myStrs) {
this.myStrs = myStrs;
}

public void setMyList(List<String> myList) {
this.myList = myList;
}

public void setMySet(Set<String> mySet) {
this.mySet = mySet;
}

public void setMyMap(Map<String, String> myMap) {
this.myMap = myMap;
}

public void addUser(){
System.out.println(Arrays.toString(myStrs));
System.out.println(myList);
System.out.println(mySet);
System.out.println(myMap);
userDao.addUser();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!–1、注意：要导入schema约束–>
<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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!–2、把对象交给spring来创建–>
<bean id="userDao" class="com.hg.dao.UserDaoImpl"></bean>
<bean id="userService" class="com.hg.service.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
<!– 给mySet集合注入数据 –>
<property name="mySet">
<set>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</set>
</property>
<!– 注入array数组数据 –>
<property name="myArray">
<array>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</array>
</property>
<!– 注入list集合数据 –>
<property name="myList">
<list>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</list>
</property>
<!– 注入Map数据 –>
<property name="myMap">
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB" value="bbb"></entry>
</map>
</property>
</bean>
</beans>

总结

        从硬编码耦合到工厂模式解耦，再到Spring IOC容器的依赖注入，我们看到了如何一步步降低程序间的依赖。特别是自动注入功能，让配置更加简洁，开发者只需专注于业务逻辑，而对象之间的依赖关系交给Spring容器来管理。这仅仅是Spring强大功能的开始，后续还有AOP、事务管理等更多高级特性等待探索。

赞(0)
未经允许不得转载：171主机测评 » Spring入门指南：揭秘IOC与工厂模式解耦
分享到： 更多 (0)
标签：

相关推荐

评论 抢沙发

取消

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

热门标签

#人工智能(65148)#python(21700)#开发语言(18054)#java(16619)#运维(16353)#linux(15804)#大数据(15466)#服务器(13785)#算法(12413)#前端(11797)#ai(10493)#网络(10016)#数据库(9651)#c++(8778)#学习(7257)#课程设计(7058)#机器学习(7044)#区块链(6077)#后端(5619)#OpenClaw(5425)#spring boot(5360)#深度学习(5319)#c语言(4581)#安全(4579)#毕业设计(4415)#数据结构(4360)#架构(4236)#docker(4148)#javascript(4008)#大模型(3983)

热门文章

最新文章

归档

分类