linux操作系统有哪五个基本的组成部分

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了linux操作系统有哪五个基本的组成部分相关的知识，希望对你有一定的参考价值。

Linux系统一般有4个主要部分：内核、shell、文件系统和应用程序。Linux内核主要由五个子系统组成：进程调度，内存管理，虚拟文件系统，网络接口，进程间通信。

　　操作系统的组成要素：

操作系统 = 内核 + 系统程序

系统程序 = 编译环境 + API

编译环境 = 编译程序 + 连接程序 + 装载程序

API = 系统调用 + 语言库函数(C、C++、Java等等)

AUI = shell + 系统服务例程(如x服务器等)+ 应用程序(浏览器，字处理，编辑器等)

　　软件系统：

软件系统 = 操作系统 + AUI

操作系统最底层的组件是内核，其上层搭建了许多系统软件。

系统程序包括三个部分，分别是：编译环境、应用程序接口和用户接口。

编译环境包含汇编、C 等低高级语言编译程序，连接程序和装载程序，这些程序负责将文本格式的程序语言转变为机器能识别和装载的机器代码。

应用程序接口(API)包含内核提供的系统调用接口和语言库，系统调用是为了能让应用程序使用内核服务，语言库函数则是为了方便应用程序开发，所以将一些常用的基础功能预先编译以供使用，比如对C语言来说常用的C库等;

用户接口(AUI)包括我们熟悉的shell、系统服务程序和常用的应用程序。

这是一个典型的结构，但不是一成不变。许多操作系统的发行中会有所删减，比如应用于嵌入式设备的系统，对X服务器就可能不做要求。但是像内核、系统调用等要素是必不可少的。

Linux系统一般有4个主要部分：内核、shell、文件系统和应用程序。内核、shell和文件系统一起形成了基本的操作系统结构，它们使得用户可以运行程序、管理文件并使用系统。

一.Linux内核

内核是操作系统的核心，具有很多最基本功能，如虚拟内存、多任务、共享库、需求加载、可执行程序和TCP/IP网络功能。Linux内核主要由五个子系统组成：进程调度，内存管理，虚拟文件系统，网络接口，进程间通信。

二.Linux shell

shell是系统的用户界面，提供了用户与内核进行交互操作的一种接口。它接收用户输入的命令并把它送入内核去执行，是一个命令解释器。另外，shell编程语言具有普通编程语言的很多特点，用这种编程语言编写的shell程序与其他应用程序具有同样的效果。

三.Linux文件系统

文件系统是文件存放在磁盘等存储设备上的组织方法。Linux系统能支持多种目前流行的文件系统，如EXT2、 EXT3、 FAT、 FAT32、VFAT和ISO9660。

四.Linux应用程序

标准的Linux系统一般都有一套都有称为应用程序的程序集，它包括文本编辑器、编程语言、X

Window、办公套件、Internet工具和数据库等。

 参考技术A Linux操作系统主要由五个基本部分组成：进程调度，内存管理，虚拟文件系统，网络接口，进程间通信。

1.进程调度（SCHED）：控制进程对CPU的访问。当需要选择下一个进程运行时，由调度程序选择最值得运行的进程。可运行进程实际上是仅等待CPU资源的进程，如果某个进程在等待其它资源，则该进程是不可运行进程。Linux使用了比较简单的基于优先级的进程调度算法选择新的进程。

2.内存管理（MM）：允许多个进程安全的共享主内存区域。Linux 的内存管理支持虚拟内存，即在计算机中运行的程序，其代码，数据，堆栈的总量可以超过实际内存的大小，操作系统只是把当前使用的程序块保留在内存中，其余的程序块则保留在磁盘中。必要时，操作系统负责在磁盘和内存间交换程序块。内存管理从逻辑上分为硬件无关部分和硬件有关部分。硬件无关部分提供了进程的映射和逻辑内存的对换；硬件相关的部分为内存管理硬件提供了虚拟接口。

3.虚拟文件系统（Virtual File System,VFS）：隐藏了各种硬件的具体细节，为所有的设备提供了统一的接口，VFS提供了多达数十种不同的文件系统。虚拟文件系统可以分为逻辑文件系统和设备驱动程序。逻辑文件系统指Linux所支持的文件系统，如ext2,fat等，设备驱动程序指为每一种硬件控制器所编写的设备驱动程序模块。

4.网络接口（NET）：提供了对各种网络标准的存取和各种网络硬件的支持。网络接口可分为网络协议和网络驱动程序。网络协议部分负责实现每一种可能的网络传输协议。网络设备驱动程序负责与硬件设备通讯，每一种可能的硬件设备都有相应的设备驱动程序。

5.进程间通讯（IPC）：支持进程间各种通信机制。 参考技术B 下文摘自他人回答的百度知道
--------------------------------------------------------------------
Linux操作系统主要由五个基本部分组成：进程调度，内存管理，虚拟文件系统，网络接口，进程间通信。

1.进程调度（SCHED）：控制进程对CPU的访问。当需要选择下一个进程运行时，由调度程序选择最值得运行的进程。可运行进程实际上是仅等待CPU资源的进程，如果某个进程在等待其它资源，则该进程是不可运行进程。Linux使用了比较简单的基于优先级的进程调度算法选择新的进程。

2.内存管理（MM）：允许多个进程安全的共享主内存区域。Linux 的内存管理支持虚拟内存，即在计算机中运行的程序，其代码，数据，堆栈的总量可以超过实际内存的大小，操作系统只是把当前使用的程序块保留在内存中，其余的程序块则保留在磁盘中。必要时，操作系统负责在磁盘和内存间交换程序块。内存管理从逻辑上分为硬件无关部分和硬件有关部分。硬件无关部分提供了进程的映射和逻辑内存的对换；硬件相关的部分为内存管理硬件提供了虚拟接口。

3.虚拟文件系统（Virtual File System,VFS）：隐藏了各种硬件的具体细节，为所有的设备提供了统一的接口，VFS提供了多达数十种不同的文件系统。虚拟文件系统可以分为逻辑文件系统和设备驱动程序。逻辑文件系统指Linux所支持的文件系统，如ext2,fat等，设备驱动程序指为每一种硬件控制器所编写的设备驱动程序模块。

4.网络接口（NET）：提供了对各种网络标准的存取和各种网络硬件的支持。网络接口可分为网络协议和网络驱动程序。网络协议部分负责实现每一种可能的网络传输协议。网络设备驱动程序负责与硬件设备通讯，每一种可能的硬件设备都有相应的设备驱动程序。

5.进程间通讯（IPC）：支持进程间各种通信机制。 参考技术C Linux操作系统主要由五个基本部分组成：进程调度、内存管理、虚拟文件系统、网络接口、进程间通信。
进程调度：控制进程对CPU的访问。当需要选择下一个进程运行时，由调度程序选择最值得运行的程序，可运行进程实际上是仅等待CPU资源的进程，如果某个进程在等待其他资源，则该进程不可运行进程。Linux使用比较简单的基于优先级的进程调度算法选择新的进程。
内存管理：允许多个进程安全的共享主内存区域。Linux的内存管理支持虚拟内存，即在计算机中运行的程序，其代码、数据、堆栈的总量可以超过实际内存的大小，操作系统只是把当前使用的程序块保留在内存中，其余的程序则保留在磁盘中。必要时，操作系统负责在磁盘和内存空间交换程序块。
虚拟文件系统：隐藏了各种硬件的具体细节，为所有的设备提供了统一的接口，VFS提供了多达数十种不同的文件系统。虚拟文件系统可以分为逻辑文件系统和设备驱动程序。逻辑文件系统指Linux所支持的文件系统，如ext2、fat等，设备驱动程序指为每一种硬件控制器所编写的设备驱动程序模块。
网络接口：提供了对各种网络标准的存取和各种网络硬件的支持。网络接口可分为网络协议和网络驱动程序。网络协议部分负责实现每一种可能的网络传输协议，网络设备驱动程序负责与硬件设备通讯，每一种可能的硬件设备都有相应的设备驱动程序。
进程间通讯：支持进程间各种通信机制。 参考技术D Linux操作系统主要由五个基本部分组成：进程调度，内存管理，虚拟文件系统，网络接口，进程间通信。 1.进程调度（SCHED）：控制进程对CPU的访问。当需要选择下一个进程运行时，由调度程序选择最值得运行的进程。

AOP切入点表达式有哪五种通知类型

针对AOP中切入表达式我会分三个方面去讲解，分别是 语法格式 、 通配符和 书写技巧 。

1.1 语法格式

首先我们先要明确两个概念:

  • 切入点:要进行增强的方法
  • 切入点表达式:要进行增强的方法的描述方式

对于切入点的描述，我们其实是有两种方式的，先来看下面的例子

AOP切入点表达式有哪五种通知类型_5e

描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

<pre class="hljs css" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">execution(void com.itheima.dao.BookDao.update())</pre>

描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法

<pre class="hljs css" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">execution(void com.itheima.dao.impl.BookDaoImpl.update())</pre>

因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。

对于切入点表达式的语法为:

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

对于这个格式，我们不需要硬记，通过一个例子，理解它:

<pre class="hljs lisp" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">execution(public User com.itheima.service.UserService.findById(int))</pre>
  • execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
  • public:访问修饰符,还可以是public，private等，可以省略
  • User：返回值，写返回值类型
  • com.itheima.service：包名，多级包使用点连接
  • UserService:类/接口名称
  • findById：方法名
  • int:参数，直接写参数的类型，多个类型用逗号隔开
  • 异常名：方法定义中抛出指定异常，可以省略

切入点表达式就是要找到需要增强的方法，所以它就是对一个具体方法的描述，但是方法的定义会有很多，所以如果每一个方法对应一个切入点表达式，想想这块就会觉得将来编写起来会比较麻烦，有没有更简单的方式呢?

就需要用到下面的通配符。

1.2 通配符

我们使用通配符描述切入点，主要的目的就是简化之前的配置，具体都有哪些通配符可以使用?

  • ​​*​​ :单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
<pre class="hljs css" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">execution（public * com.itheima.*.UserService.find*(*))</pre>
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
  • ​​..​​ ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
<pre class="hljs css" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">execution（public User com..UserService.findById(..))</pre>
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
  • ​​+​​ ：专用于匹配子类类型
<pre class="hljs markdown" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">execution(* *..*Service+.*(..))</pre>
这个使用率较低，描述子类的，咱们做Java开发，继承机会就一次，使用都很慎重，所以很少用它。*Service+，表示所有以Service结尾的接口的子类。

接下来，我们把使用到的切入点表达式来分析下:

AOP切入点表达式有哪五种通知类型_spring_02

<pre class="prettyprint hljs vim" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">execution(void com.itheima.dao.BookDao.update())
匹配接口，能匹配到
execution(void com.itheima.dao.impl.BookDaoImpl.update())
匹配实现类，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update())
返回值任意，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update(*))
返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加参数
execution(void com.*.*.*.*.update())
返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配
execution(void com.*.*.*.update())
返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配
execution(void *..update())
返回值为void，方法名是update的任意包下的任意类，能匹配
execution(* *..*(..))
匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广
execution(* *..u*(..))
匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配
execution(* *..*e(..))
匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配
execution(void com..*())
返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法
execution(* com.itheima.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.itheima.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配</pre>

后面两种更符合我们平常切入点表达式的编写规则

1.3 书写技巧

对于切入点表达式的编写其实是很灵活的，那么在编写的时候，有没有什么好的技巧让我们用用:

  • 所有代码按照标准规范开发，否则以下技巧全部失效
  • 描述切入点 通 **常描述接口 **，而不描述实现类,如果描述到实现类，否则就出现紧耦合了
  • 访问控制修饰符针对接口开发均采用public描述（ **可省略访问控制修饰符描述 **）
  • 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用 * 通配快速描述
  • **包名 **书写 **尽量不使用..匹配 **，效率过低，常用 * 做单个包描述匹配，或精准匹配
  • **接口名/类名 **书写名称与模块相关的 **采用 * 匹配 **，例如UserService书写成 * Service，绑定业务层接口名
  • **方法名 **书写以 **动词 **进行 **精准匹配 **，名词采用 *匹配，例如getById书写成getBy *,selectAll书写成selectAll
  • 参数规则较为复杂，根据业务方法灵活调整
  • 通常 **不使用 异常 **作为 **匹配 **规则

二、AOP通知类型

AOP切入点表达式有哪五种通知类型_Java_03

它所代表的含义是将 ​​通知​​ 添加到 ​​切入点​​ 方法执行的 前面 。

除了这个注解外，还有没有其他的注解，换个问题就是除了可以在前面加，能不能在其他的地方加?

2.1 类型介绍

我们先来回顾下AOP通知:

  • AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置

通知具体要添加到切入点的哪里?

共提供了5种通知类型:

  • 前置通知
  • 后置通知
  • 环绕通知(重点)
  • 返回后通知(了解)
  • 抛出异常后通知(了解)

为了更好的理解这几种通知类型，我们来看一张图

AOP切入点表达式有哪五种通知类型_spring_04

(1)前置通知，追加功能到方法执行前,类似于在代码1或者代码2添加内容

(2)后置通知,追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行，类似于在代码5添加内容

(3)返回后通知,追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加

(4)抛出异常后通知,追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加

(5)环绕通知,环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。

2.2 环境准备

  • 创建一个Maven项目
  • pom.xml添加Spring依赖
class="prettyprint hljs xml" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;"><dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.4</version>
        </dependency>
    </dependencies></pre>
  • 添加BookDao和BookDaoImpl类
    <pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public interface BookDao 
        public void update();
        public int select();
    
    
    @Repository
    public class BookDaoImpl implements BookDao 
        public void update()
            System.out.println("book dao update ...");
        
        public int select() 
            System.out.println("book dao select is running ...");
            return 100;
        
    </pre>
  • 创建Spring的配置类
<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">@Configuration
    @ComponentScan("com.itheima")
    @EnableAspectJAutoProxy
    public class SpringConfig 
    </pre>
  • 创建通知类
    <pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">@Component
    @Aspect
    public class MyAdvice 
        @Pointcut("execution(void com.itheima.dao.BookDao.update())")
        private void pt()
    
        public void before() 
            System.out.println("before advice ...");
        
    
        public void after() 
            System.out.println("after advice ...");
        
    
        public void around()
            System.out.println("around before advice ...");
            System.out.println("around after advice ...");
        
    
        public void afterReturning() 
            System.out.println("afterReturning advice ...");
        

        public void afterThrowing() 
            System.out.println("afterThrowing advice ...");
        
    </pre>
  • 编写App运行类
<pre class="prettyprint hljs cpp" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public class App 
        public static void main(String[] args) 
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = ctx.getBean(BookDao.class);
            bookDao.update();
        
    </pre>

最终创建好的项目结构如下:

AOP切入点表达式有哪五种通知类型_5e_05

2.3 通知类型的使用

前置通知

修改MyAdvice,在before方法上添加 ​​@Before注解​​

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Before("pt()")
    //此处也可以写成 @Before("MyAdvice.pt()"),不建议
    public void before() 
        System.out.println("before advice ...");
    
</pre>

AOP切入点表达式有哪五种通知类型_spring_06

后置通知

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Before("pt()")
    public void before() 
        System.out.println("before advice ...");
    
    @After("pt()")
    public void after() 
        System.out.println("after advice ...");
    
</pre>

AOP切入点表达式有哪五种通知类型_5e_07

环绕通知

基本使用

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Around("pt()")
    public void around()
        System.out.println("around before advice ...");
        System.out.println("around after advice ...");
    
</pre>

AOP切入点表达式有哪五种通知类型_Java_08

运行结果中，通知的内容打印出来，但是原始方法的内容却没有被执行。

因为环绕通知需要在原始方法的前后进行增强，所以环绕通知就必须要能对原始操作进行调用，具体如何实现?

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Around("pt()")
    public void around(ProceedingJoinPoint pjp) throws Throwable
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        pjp.proceed();
        System.out.println("around after advice ...");
    
</pre>

**说明: **proceed()为什么要抛出异常?

主要原因原始方法不清楚到底执行会不会有异常，所以直接先抛出异常。原因很简单，看下源码就知道了

AOP切入点表达式有哪五种通知类型_spring_09

再次运行，程序可以看到原始方法已经被执行了

AOP切入点表达式有哪五种通知类型_spring_10

注意事项

(1)原始方法有返回值的处理

  • 修改MyAdvice,对BookDao中的select方法添加环绕通知，
<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2()

    @Around("pt2()")
    public void aroundSelect(ProceedingJoinPoint pjp) throws Throwable 
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        pjp.proceed();
        System.out.println("around after advice ...");
    
</pre>
  • 修改App类，调用select方法
<pre class="prettyprint hljs dart" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">public class App 
    public static void main(String[] args) 
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        int num = bookDao.select();
        System.out.println(num);
    
</pre>

运行后会报错，错误内容为:

Exception in thread "main" org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for: public abstract int com.itheima.dao.BookDao.select() at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:226) at com.sun.proxy.$Proxy19.select(Unknown Source) at com.itheima.App.main(App.java:12)

错误大概的意思是: ​​空的返回不匹配原始方法的int返回​​

  • void就是返回Null
  • 原始方法就是BookDao下的select方法

所以如果我们使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值，具体解决方案为:

<pre class="prettyprint hljs kotlin" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2()

    @Around("pt2()")
    public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable 
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    
</pre>

说明:

为什么返回的是Object而不是int的主要原因是Object类型更通用。 所以更一般的写法环绕通知的返回类型写object而不是void，如果没有返回值，那么object就为空

在环绕通知中是可以对原始方法返回值就行修改的。

返回后通知

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2()

    @AfterReturning("pt2()")
    public void afterReturning() 
        System.out.println("afterReturning advice ...");
    
</pre>

AOP切入点表达式有哪五种通知类型_spring_11

**注意： **返回后通知是需要在原始方法 ​​select​​ 正常执行后才会被执行，如果 ​​select()​​ 方法执行的过程中出现了异常，那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执行。

异常后通知

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt()

    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2()

    @AfterReturning("pt2()")
    public void afterThrowing() 
        System.out.println("afterThrowing advice ...");
    
</pre>

AOP切入点表达式有哪五种通知类型_spring_12

**注意： **异常后通知是需要原始方法抛出异常，可以在 ​​select()​​ 方法中添加一行代码 ​​int i = 1/0​​ 即可。如果没有抛异常，异常后通知将不会被执行。

介绍完这5种通知类型，我们来思考下环绕通知是如何实现其他通知类型的功能的?

因为环绕通知是可以控制原始方法执行的，所以我们把增强的代码写在调用原始方法的不同位置就可以实现不同的通知类型的功能，如:

AOP切入点表达式有哪五种通知类型_5e_13

通知类型总结

知识点1：@After

名称

@After

类型

方法注解

位置

通知方法定义上方

作用

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行

知识点2：@AfterReturning

名称

@AfterReturning

类型

方法注解

位置

通知方法定义上方

作用

设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法正常执行完毕后执行

知识点3：@AfterThrowing

名称

@AfterThrowing

类型

方法注解

位置

通知方法定义上方

作用

设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行

知识点4：@Around

名称

@Around

类型

方法注解

位置

通知方法定义上方

作用

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行

环绕通知注意事项

  1. 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
  2. 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
  3. 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，最好设定为Object类型
  4. 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void,也可以设置成Object
  5. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理Throwable异常，推荐直接抛出异常


以上是关于linux操作系统有哪五个基本的组成部分的主要内容，如果未能解决你的问题，请参考以下文章

MySQL子查询有哪五种形式？

ccb2制动机电空控制单元哪五个是智能模块

20160309作业

CDR绘图工具五个的特点都有哪些(？

Linux进程一般可以分为哪三类

PLC可编程序控制器,整个工作过程分五个阶段哪五个阶段