Spring高级特性及用法

最新推荐文章于 2024-04-29 17:13:56 发布

踩踩踩从踩

最新推荐文章于 2024-04-29 17:13:56 发布

阅读量2k

点赞数 4

分类专栏： spring mybatis等框架源码深入理解文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_33373609/article/details/121747756

版权

spring mybatis等框架源码深入理解专栏收录该内容

25 篇文章 15 订阅

订阅专栏

前言

本篇文章会介绍spring框架，这个在java开发中占了大比重的，怎么样快速构建项目，让我们只考虑业务功能，尽量不去在架构上花时间，这是spring做的非常好的地方，也是它这么火的原因，本篇文章会介绍spring是什么，几个核心组件包括ioc 容器，aop特性，web的部分以及事件驱动、任务调用部分，spring中应用了大量的设计模式，包括工厂模式，代理模式策略模式等等这都是spring框架优秀的地方。

Spring介绍

Spring | Home

它是一个生态圈，集成大量的框架，将spring大量框架集成变化，应对我们使用是不变。

Spring是一个Java轻量级的IOC容器，实现了AOP特性，非侵入性框架。提供对持久层、事务、Web层等各个方面组件集成与一致性封装。涉及到的组件非常丰富，但核心仍然是Spring

Framework。Spring Framework真正的核心组件只有几个：

核心组件只有三个：Core、Context 和 Beans。它们构建起了整个 Spring 的骨骼架构。没有它们就不可能有 AOP、Web 等上层的特性功能。

Spring包含的组件： https://spring.io/projects

spring在不断的往后不断更新的。

针对springboot呀约定大于配置的含义，然后包含了什么spring cloud 分布式大的容器， amqp

在官网中介绍的 spring 对android框架的支持了。以及 batch 等等框架。

这都在官方文档中会有介绍文档中包含示例等等都可以使用的。

Spring 的设计理念

Spring的设计理念：构建一个数据结构，然后根据这个数据结构设计它的生存环境。

这是大部分java开源框架中的一个设计理念。也就是围绕着某个类，进行不断扩展功能，这就是整个spring的设计框架。

Spring的三个核心组件中核心是Beans组件 ， Bean则是Spring构建的数据结构。

在Spring中Bean才是真正的主角，Spring是面向Bean的编程
Bean在Spring中作用就像Object对OOP的作用一样
通过IOC容器完成依赖注入机制，构建Bean生存环境
IOC容器就是被Bean包裹的对象，Spring正是通过把对象包装在Bean中，从而达到对这些对象管理以及一些列额外操作的目的

达到Spring框架设计目标：依赖注入机制，把对象之间的依赖关系用配置文件或注解来管理。

核心组件的协同工作

Bean 是 Spring 中关键因素，把Bean比作一场演出中的演员，那Context就是这场演出的舞台背景，Core就是演出的道具。

Context 组件解决Bean的生存环境问题

Context发现每个Bean之间的关系，为它们建立维护好Bean关系。

Context是一个Bean关系的集合，这个关系集合又叫Ioc容器，一旦建立起这个Ioc容器后Spring就可以工作了。

Core组件就是发现、建立和维护Bean关系需要的一些列的工具，从这个角度看来，Core组件叫Util更容易理解。

Spring中设计模式的应用

设计模式一定要说到代理模式策略模式，以及工厂模式抽象模式等等，太多了，这里只根据aop中引出的代理模式和策略模式。

Spring中代理模式

Spring AOP中CGLIB、JDK动态代理就是利用代理模式设计实现的

Spring除了实现被代理对象的接口，还有SpringProxy和Advised 两个接口。

$Proxy 就是创建的代理对象，而 Subject 是抽象主题，代理对象是通过 InvocationHandler 来持有对目标对象的引用的。

里面包含目标类型获取代理接口目标源码等，代理对象信息。并扫描生成一个扩展接口

而代理出来的

Spring 中一个真实的代理对象结构如下：

织入代码， spring的代理模式。

Spring中策略模式

Spring 中代理对象的创建就是通过策略模式来实现的

Spring的代理方式有两个，JDK动态代理和CGLIB代理，两个代理方式都使用了策略模式

AopProxy 接口表示抽象策略

Cglib2AopProxy 和 JdkDynamicAopProxy 分别代表两种策略的实现方式
ProxyFactoryBean 就是代表 Context 角色，它根据条件选择使用 Jdk 代理方式还是 CGLIB 方式
另外三个类主要是来负责创建具体策略对象
ProxyFactoryBean通过依赖关联具体策略对象，通过调用策略对象getProxy(ClassLoader classLoader)方法来完成操作。

也就是通过配置，进行选择那个策略实现方式。

抽象出来策略的接口。

创建具体的proxy代理方式。

根据不同的配置去创建的代理方式。

factorybean 代表的含义就是对bean的一个增强，这也点出spring框架整体都是围绕着bean，这里就是对bean进行代理。

都是在spring中会使用到的。

spring中特性应用

这里重点要说的就是事件驱动编程，怎么发布订阅的编程模型，观察者模式。

事件驱动编程

事件驱动编程，基于发布-订阅模式的编程模型，即观察者模式。

事件驱动模型的核心构件通常包含以下几个：

事件源：负责产生事件的对象。比如我们常见的按钮，按钮就是一个事件源，能够产生“点击”这事件
事件监听器（事件处理器）：负责处理事件的对象
事件：或者称为事件对象，是事件源和事件监听器之间的信息桥梁。是整个事件模型驱动的核心

事件驱动模型的实现包含以下几种：

观察者模式
JDK观察者模式
JavaBean事件驱动
Spring事件驱动

Spring事件驱动模型原理比较复杂，涉及到的类比较多，从代码示例入手。

示例，当一个订单的支付状态发生变化时，能够通知到邮件服务、短信服务、库存服务。

事件机制，一定要有源头，

@Service
public class PaymentService implements InitializingBean {
    @Autowired
    ApplicationContext applicationContext;

    public void pay(int id, String status) {
        // ...... 省略处理业务逻辑代码
        PaymentInfo paymentInfo = new PaymentInfo(id, status);
        // 发布事件
        applicationContext.publishEvent(new PaymentStatusUpdateEvent(paymentInfo));
    }

    @PostConstruct
    public void init(){
        System.out.println("@PostConstruct");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean afterPropertiesSet");
    }
}

支付状态更新的事件，以PaymentInfo作为传输的载体作为传递的对象。

public class PaymentStatusUpdateEvent extends ApplicationEvent {
    public PaymentStatusUpdateEvent(PaymentInfo source) {
        super(source);
    }
}

有序或者无序的事件监听器。

无序事件监听器，库存服务监听器

 */
@Service
public class StockPaymentStatusUpdateListener implements ApplicationListener<PaymentStatusUpdateEvent> {
    @Override
    @Async
    public void onApplicationEvent(PaymentStatusUpdateEvent paymentStatusUpdateEvent) {
        System.out.println("Thread: " + Thread.currentThread().getName() +
                " 库存服务, 收到支付状态更新的事件. " + paymentStatusUpdateEvent);
    }
}

应对有序的事件监听

可以采用 smartapplicationlistener去判断。

根据指定顺序排序事件。

异步执行

Spring 2种异步执行方式：全局异步、注解式配置异步

采用全局异步进行执行。

全局异步的操作步骤：

定义并配置Executor Bean
配置名为applicationEventMulticaster的 SimpleApplicationEventMulticaster Bean
设置applicationEventMulticaster执行器为第一步的 Executor

@Async注解的使用操作执行步骤：

开启异步执行：@EnableAsync
配置线程池，非必须，没有则用默认线程池
Bean方法指定为异步：@Async

异步执行原理本质是AOP，具体步骤：

初始化线程池和异常处理器
创建异步方法所在Bean后，执行Async对应的BeanPostProcessor，创建AOP代理类，代理对象替换原来的对象
代理对象中，异步方法被动态植入了异步执行方法
执行异步方法，其实执行的是代理对象里面的方法，从而实现异步，除了Async这个注解，没有任何入侵

定时任务

spring源码深入理解（三）：定时任务框架各种使用方式_踩踩踩从踩的博客-CSDN博客

spring源码深入理解（二）：定时任务管理-源码核心解析_踩踩踩从踩的博客-CSDN博客

spring源码深入理解（一）：定时任务-自定义注解及任务及同一时间多任务执行_踩踩踩从踩的博客-CSDN博客

SpringTask

1. fixedRate，上一次开始执行时间点之后再执行

2. fixedDelay，上一次执行完毕时间点之后再执行

3. initialDelay，第一次延迟后执行，之后按上面指定的规则执行

Spring集成Quartz

4. 默认是，上一次执行完毕时间后执行下一轮

Cron表达式，一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。按照顺序依次是：

- 秒（0~59）

- 分钟（0~59）

- 3 小时（0~23）

- 4 天（0~31）

- 5 月（0~11）

- 6 星期（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）

- 年份（1970－2099）

Corn表达式生成工具：http://qqe2.com/cron/index

AOP应用

AOP（Aspect Orient Programming） ，作为面向对象编程的一种补充，广泛应用于处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。

AOP的实现关键在于 AOP 框架自动创建的 AOP 代理，代理分为静态代理和动态代理。
动态代理在运行时在内存中临时产生动态代理类，达到运行时增强。

AOP由 切面、切点、连接点、目标对象、回调 五个元素构成

1. aspect：切面，通俗的讲可以理解为一个功能，比如具备某项能力(如：帮助他人是一种能力))，定义为一个切面；
2. pointCut：切点，可以理解为一种匹配规则，比如哪些人需要被帮助，通过一些规则进行分组筛选；
3. Target Object：目标对象，比如某种能力需要对某个人使用，这个某个人就是目标对象；
4. joinpoint：连接点，具体的需要做的事情，可以理解为需要使用某项能力帮助某人做什么事情的时候提供帮助；这个做什么事情就是连接点了；
5. Advice：回调的通知，比如：在什么时间点去帮助他们，在什么时间点提供某种能力帮助别人；

Spring中6中AOP增强方式

1. Before 前置增强
2. After 后置增强
3. Around 环绕增强
4. AfterReturning 最终增强
5. AfterThrowing 异常增强
6. DeclareParents 引入增强

AOP在Spring框架中应用非常广泛，比如最常见的事务。

在方法前开启事务
方法后提交事务
检测到有异常时，回滚事务

踩踩踩从踩

关注

4
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
1
评论
Spring高级特性及用法

本篇文章会介绍spring框架，这个在java开发中占了大比重的，怎么样快速构建项目，让我们只考虑业务功能，尽量不去在架构上花时间，这是spring做的非常好的地方，也是它这么火的原因，本篇文章会介绍spring是什么，几个核心组件包括ioc 容器，aop特性，web的部分以及事件驱动、任务调用部分，spring中应用了大量的设计模式，包括工厂模式，代理模式策略模式等等这都是spring框架优秀的地方。
复制链接

扫一扫