Spring入门图解（体系结构-IOC-DI-AOP）

最新推荐文章于 2024-08-20 16:01:03 发布

BitHachi

最新推荐文章于 2024-08-20 16:01:03 发布

阅读量5.8k

点赞数 11

分类专栏： # Spring 文章标签： java spring ioc aop

本文链接：https://blog.csdn.net/weixin_43914604/article/details/112644999

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

0. 什么是Spring？

一句话：Spring是一个轻量级的控制反转(IoC-Inversion of Control)和面向切面(AOP-Aspect Oriented Programming)的容器（框架）。

1. 体系结构

1.1 体系结构图

Spring 是模块化的，允许你挑选和选择适用于你的模块，不必要把剩余部分也引入。下面的部分对在 Spring 框架中所有可用的模块给出了详细的介绍。

Spring 总共大约有 20 个模块，由 1300 多个不同的文件构成。而这些组件被分别整合在

核心容器（Core Container）
AOP（Aspect Oriented Programming）
Aspects
设备支持（Instrmentation）
消息（Messaging）
数据访问与集成（Data Access/Integeration）
Web
Test

8 个大模块中。以下是 Spring 5 的模块结构图：

1.2 核心容器（Core Container）

核心容器由 spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring 表达式语言，Spring Expression Language）等模块组成，它们的细节如下：

spring-core 模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。
spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。
context 模块建立在由 core和 beans 模块的基础上建立起来的，它以一种类似于 JNDI 注册的方式访问对象。Context 模块继承自 Bean 模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过 Servelet 容器）等功能。Context 模块也支持 Java EE 的功能，比如 EJB、JMX 和远程调用等。ApplicationContext 接口是 Context 模块的焦点。spring-context-support 提供了对第三方集成到 Spring 上下文的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。
spring-expression 模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是 JSP2.1 规范中定义的统一表达式语言的扩展，支持 set 和 get 属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从 Spring IoC 容器检索对象，还支持列表的投影、选择以及聚合等。

它们的完整依赖关系如下图所示：

Spring 体系结构

1.3 数据访问/集成（Data Access/Integeration）

数据访问/集成层包括 JDBC，ORM，OXM，JMS 和事务处理模块，它们的细节如下：

（注：JDBC=Java Data Base Connectivity，ORM=Object Relational Mapping，OXM=Object XML Mapping，JMS=Java Message Service）

JDBC 模块提供了 JDBC 抽象层，它消除了冗长的 JDBC 编码和对数据库供应商特定错误代码的解析。
ORM 模块提供了对流行的对象关系映射 API 的集成，包括 JPA、JDO 、 Hibernate、Mybatis 等。通过此模块可以让这些 ORM 框架和 spring的其它功能整合，比如前面提及的事务管理。
OXM 模块提供了对 OXM 实现的支持，比如 JAXB、Castor、XML Beans、JiBX、XStream 等。
JMS 模块包含生产（produce）和消费（consume）消息的功能。从 Spring 4.1 开始，集成了 spring-messaging 模块。
事务模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。（注：编程式事务需要自己写 beginTransaction()、commit()、rollback() 等事务管理方法，声明式事务是通过注解或配置由 spring 自动处理，编程式事务力度更细）

1.4 Web

Web 层由 Web，Servlet，Web-Socket 和 Web-Portlet 组成，它们的细节如下：

Web 模块提供面向 web 的基本功能和面向 web 的应用上下文，比如多部分（multipart）文件上传功能、使用 Servlet 监听器初始化 IoC 容器等。它还包括 HTTP 客户端以及 Spring 远程调用中与 web 相关的部分。
Servlet 模块为 web 应用提供了模型视图控制（MVC）和 REST Web服务的实现。Spring 的 MVC 框架可以使领域模型代码和 web 表单完全地分离，且可以与 Spring 框架的其它所有功能进行集成。
Web-Socket 模块为 WebSocket-based 提供了支持，而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。
Web-Portlet 模块提供了用于 Portlet 环境的 MVC 实现，并反映了 spring-webmvc 模块的功能。

1.5 AOP

AOP 模块提供了面向方面（切面）的编程实现，允许你定义方法拦截器和切入点对代码进行干净地解耦，从而使实现功能的代码彻底的解耦出来。能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

1.6 Aspects

Aspects 模块提供了与 AspectJ 的集成，这是一个功能强大且成熟的面向切面编程（AOP）框架。

1.7 Instrumentation

Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。

1.8 Messaging

Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。

1.9 Test

测试模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

既然我们已经知道了Spring框架是什么，然后大致了解Spring框架的体系结构，那么接下来重点关注Spring最重要的两个思想：IOC和AOP

2. 控制反转和依赖注入（IOC-DI）

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。

依赖注入（DI），是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。

依赖 : 指Bean对象的创建依赖于Spring容器
注入 : 指Bean对象的属性(例如pojo类对象属性、其它需要依赖的Bean对象) , 由容器来设置和装配.

传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；

IOC是由专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建，程序被动接受对象,这就叫控制反转；

在Spring中，我们可以把IOC容器与Spring容器等同于一个东西，及IOC容器=Spring容器，我们也可以把Spring容器看做配置文件xxx.xml来简单记忆

以下是一个使用xml配置文件实现IOC的图例：

无标题

3. 切面编程（AOP）

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，将日志记录，性能统计，安全控制，事务处理，异常处理等相同代码从业务逻辑代码中划分出来，通过对这些行为的分离，可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。提高程序的可重用性，同时提高了开发的效率。

4. 通过Spring案例进一步理解IOC与DI

4.1 文件目录结构

4.2 案例UML架构图

4.3 pom.xml

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.1</version>
    </dependency>
</dependencies>

4.4 dao

package cn.bithachi.dao;

public interface  UserDao {
     void getUser();
}

/*-------------------------------------*/
package cn.bithachi.dao;
public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("获取用户数据");
    }
}
/*-------------------------------------*/
package cn.bithachi.dao;

public class UserDaoMySqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("MySql获取用户数据");
    }
}

4.5 service

package cn.bithachi.service;

public interface UserService {
     void getUser();
}
/*-------------------------------------*/   
package cn.bithachi.service;

import cn.bithachi.dao.UserDao;

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    // 利用set实现依赖注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

4.6 pojo

package cn.bithachi.pojo;

public class Hello {
        private String name;

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

        public void show(){
            System.out.println("Hello,"+ name );
        }
}

4.7 beans.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
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--bean就是java对象 , 由Spring创建和管理, id为对象的引用变量名-->
    <bean id="hello" class="cn.bithachi.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>


    <bean id="OriginImpl" class="cn.bithachi.dao.UserDaoImpl"/>
    <bean id="MysqlImpl" class="cn.bithachi.dao.UserDaoMySqlImpl"/>
    <!--依赖注入，采用setUserDao方法-->
    <bean id="ServiceImpl" class="cn.bithachi.service.UserServiceImpl">
        <property name="userDao" ref="OriginImpl"/>
    </bean>
</beans>

4.8 Test

import cn.bithachi.pojo.Hello;
import cn.bithachi.service.UserServiceImpl;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test(){
        //解析beans.xml文件 , 生成管理相应的Bean对象,创建容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //getBean : 参数即为spring配置文件中bean的id .
        Hello hello = (Hello) context.getBean("hello");
        hello.show();
    }

    @Test
    public void test2(){
        //获取spring容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //从容器中取出Bean对象的引用
        UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");
        //调用Bean对象的方法
        serviceImpl.getUser();
    }
}