前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >排序算法-下(Java语言实现)

排序算法-下(Java语言实现)

作者头像
acc8226
发布于 2022-05-17 07:43:42
发布于 2022-05-17 07:43:42
47700
代码可运行
举报
文章被收录于专栏:叽叽西叽叽西
运行总次数:0
代码可运行

今天,我讲两种时间复杂度为

的排序算法,归并排序快速排序。这两种排序算法适合大规模的数据排序,比上一节讲的那三种排序算法要更常用。

归并排序和快速排序都用到了分治思想,非常巧妙。我们可以借鉴这个思想,来解决非排序的问题,比如:如何在 O(n) 的时间复杂度内查找一个无序数组中的第 K 大元素? 这就要用到我们今天要讲的内容。

归并排序(Merge Sort)的原理

如果要排序一个数组,我们先把数组从中间分成前后两部分,然后对前后两部分分别排序,再将排好序的两部分合并在一起,这样整个数组就都有序了。

归并排序使用的就是分治思想。分治,顾名思义,就是分而治之,将一个大问题分解成小的子问题来解决。小的子问题解决了,大问题也就解决了。

从我刚才的描述,你有没有感觉到,分治思想跟我们前面讲的递归思想很像。是的,分治算法一般都是用递归来实现的。分治是一种解决问题的处理思想,递归是一种编程技巧,这两者并不冲突。分治算法的思想我后面会有专门的一节来讲,现在不展开讨论,我们今天的重点还是排序算法。

我们现在就来看看如何用递归代码来实现归并排序。写递归代码的技巧就是,分析得出递推公式,然后找到终止条件,最后将递推公式翻译成递归代码。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 递推公式:
merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r))

// 终止条件:
p >= r 不用再继续分解

给下标从 p 到 r 之间的数组排序,转化为 p 到 q 和从 q+1 到 r 这两个子数组的排序,这两个子数组都排好序之后,我们再将两个有序的子数组合并在一起

有了递推公式,转化成代码就简单多了。为了阅读方便,我这里只给出伪代码,你可以翻译成你熟悉的编程语言。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 归并排序算法, A是数组,n表示数组大小
merge_sort(A, n) {
  merge_sort_c(A, 0, n-1)
}

// 递归调用函数
merge_sort_c(A, p, r) {
  // 递归终止条件
  if p >= r  then return

  // 取p到r之间的中间位置q
  q = (p+r) / 2
  // 分治递归
  merge_sort_c(A, p, q)
  merge_sort_c(A, q+1, r)
  // 将A[p...q]和A[q+1...r]合并为A[p...r]
  merge(A[p...r], A[p...q], A[q+1...r])
}

merge(A[p...r], A[p...q], A[q+1...r]) 这个函数的作用就是,将已经有序的 A[p...q]和 A[q+1....r]合并成一个有序的数组,并且放入 A[p....r]。那这个过程具体该如何做呢?

我们申请一个临时数组 tmp,大小与 A[p...r]相同。我们用两个游标 i 和 j,分别指向 A[p...q]和 A[q+1...r]的第一个元素。比较这两个元素 A[i]和 A[j],如果 A[i]<=A[j],我们就把 A[i]放入到临时数组 tmp,并且 i 后移一位,否则将 A[j]放入到数组 tmp,j 后移一位。继续上述比较过程,直到其中一个子数组中的所有数据都放入临时数组中,再把另一个数组中的数据依次加入到临时数组的末尾,这个时候,临时数组中存储的就是两个子数组合并之后的结果了。最后再把临时数组 tmp 中的数据拷贝到原数组 A[p...r]中。

伪代码实现

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
merge(A[p...r], A[p...q], A[q+1...r]) {
  var i := p,j := q+1,k := 0 // 初始化变量i, j, k
  var tmp := new array[0...r-p] // 申请一个大小跟A[p...r]一样的临时数组
  while i<=q AND j<=r do {
    if A[i] <= A[j] {
      tmp[k++] = A[i++] // i++等于i:=i+1
    } else {
      tmp[k++] = A[j++]
    }
  }
  
  // 判断哪个子数组中有剩余的数据
  var start := i,end := q
  if j<=r then start := j, end:=r
  
  // 将剩余的数据拷贝到临时数组tmp
  while start <= end do {
    tmp[k++] = A[start++]
  }
  
  // 将tmp中的数组拷贝回A[p...r]
  for i:=0 to r-p do {
    A[p+i] = tmp[i]
  }
}

你还记得之前讲讲过的利用哨兵简化编程的处理技巧吗?merge() 合并函数如果借助哨兵。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
/**
 * 合并(哨兵)
 */
private static void mergeBySentry(int[] array, int start, int mid, int end) {
    int[] leftTemp = new int[mid - start + 2];
    int[] rightTemp = new int[end - mid + 1];

    int i, j;
    for (i = 0; i < leftTemp.length - 1; i++) {
        leftTemp[i] = array[start + i];
    }
    // 第一个数组添加哨兵(最大值)
    leftTemp[i] = Integer.MAX_VALUE;
    for (i = 0; i < rightTemp.length - 1; i++) {
        rightTemp[i] = array[mid + 1 + i];
    }
    // 第二个数组添加哨兵(最大值)
    rightTemp[i] = Integer.MAX_VALUE;

    i = j = 0;
    // 当左边数组到达哨兵值时,i不再增加,直到右边数组读取完剩余值,同理右边数组也一样
    while (start <= end) {
        if (leftTemp[i] <= rightTemp[j]) {
            array[start] = leftTemp[i++];
        } else {
            array[start] = rightTemp[j++];
        }
        start++;
    }
}

归并排序的性能分析

第一,归并排序是稳定的排序算法吗? 结合我前面画的那张图和归并排序的伪代码,你应该能发现,归并排序稳不稳定关键要看 merge() 函数,也就是两个有序子数组合并成一个有序数组的那部分代码。在合并的过程中,如果 A[p...q]和 A[q+1...r]之间有值相同的元素,那我们可以像伪代码中那样,先把 A[p...q]中的元素放入 tmp 数组。这样就保证了值相同的元素,在合并前后的先后顺序不变。所以,归并排序是一个稳定的排序算法。

第二,归并排序的时间复杂度是多少? 归并排序涉及递归,时间复杂度的分析稍微有点复杂。我们正好借此机会来学习一下,如何分析递归代码的时间复杂度。

如果我们定义求解问题 a 的时间是 T(a),求解问题 b、c 的时间分别是 T(b) 和 T( c),那我们就可以得到这样的递推关系式:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
T(a) = T(b) + T(c) + K

其中 K 等于将两个子问题 b、c 的结果合并成问题 a 的结果所消耗的时间。从刚刚的分析,我们可以得到一个重要的结论:不仅递归求解的问题可以写成递推公式,递归代码的时间复杂度也可以写成递推公式。

我们假设对 n 个元素进行归并排序需要的时间是 T(n),那分解成两个子数组排序的时间都是 T(n/2)。我们知道,merge() 函数合并两个有序子数组的时间复杂度是 O(n)。所以,套用前面的公式,归并排序的时间复杂度的计算公式就是:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
T(1) = C;   n=1时,只需要常量级的执行时间,所以表示为C。
 
n>1时,
T(n) = 2*T(n/2) + n
     = 2*(2*T(n/4) + n/2) + n = 4*T(n/4) + 2*n
     = 4*(2*T(n/8) + n/4) + 2*n = 8*T(n/8) + 3*n
     = 8*(2*T(n/16) + n/8) + 3*n = 16*T(n/16) + 4*n
     ......
     = 2^k * T(n/2^k) + k * n
     ......

。当

时,也就是

,我们得到

。我们将 k 值代入上面的公式,得到

。如果我们用大 O 标记法来表示的话,T(n) 就等于

所以归并排序的时间复杂度是

从我们的原理分析和伪代码可以看出,归并排序的执行效率与要排序的原始数组的有序程度无关,所以其时间复杂度是非常稳定的,不管是最好情况、最坏情况,还是平均情况,时间复杂度都是 O(nlogn)。

第三,归并排序的空间复杂度是多少? 归并排序的时间复杂度任何情况下都是 O(nlogn),看起来非常优秀。(待会儿你会发现,即便是快速排序,最坏情况下,时间复杂度也是 O(n2)。)但是,归并排序并没有像快排那样,应用广泛,这是为什么呢?因为它有一个致命的“弱点”,那就是归并排序不是原地排序算法。这是因为归并排序的合并函数,在合并两个有序数组为一个有序数组时,需要借助额外的存储空间。这一点你应该很容易理解。那我现在问你,归并排序的空间复杂度到底是多少呢? 尽管每次合并操作都需要申请额外的内存空间,但在合并完成之后,临时开辟的内存空间就被释放掉了。在任意时刻,CPU 只会有一个函数在执行,也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过 n 个数据的大小,所以空间复杂度是 O(n)。

快速排序的原理

我们再来看快速排序算法(Quicksort),我们习惯性把它简称为“快排”。快排利用的也是分治思想。乍看起来,它有点像归并排序,但是思路其实完全不一样。

快排的思想是这样的:如果要排序数组中下标从 p 到 r 之间的一组数据,我们选择 p 到 r 之间的任意一个数据作为 pivot(分区点)。

我们遍历 p 到 r 之间的数据,将小于 pivot 的放到左边,将大于 pivot 的放到右边,将 pivot 放到中间。经过这一步骤之后,数组 p 到 r 之间的数据就被分成了三个部分,前面 p 到 q-1 之间都是小于 pivot 的,中间是 pivot,后面的 q+1 到 r 之间是大于 pivot 的。

根据分治、递归的处理思想,我们可以用递归排序下标从 p 到 q-1 之间的数据和下标从 q+1 到 r 之间的数据,直到区间缩小为 1,就说明所有的数据都有序了。

如果我们用递推公式来将上面的过程写出来的话,就是这样:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
递推公式:
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1… r)

终止条件:
p >= r

我将递推公式转化成递归代码。跟归并排序一样,我还是用伪代码来实现,你可以翻译成你熟悉的任何语言。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 快速排序,A是数组,n表示数组的大小
quick_sort(A, n) {
  quick_sort_c(A, 0, n-1)
}
// 快速排序递归函数,p,r为下标
quick_sort_c(A, p, r) {
  if p >= r then return
  
  q = partition(A, p, r) // 获取分区点
  quick_sort_c(A, p, q-1)
  quick_sort_c(A, q+1, r)
}

我们这里有一个 partition() 分区函数。partition() 分区函数实际上我们前面已经讲过了,就是随机选择一个元素作为 pivot(一般情况下,可以选择 p 到 r 区间的最后一个元素),然后对 A[p...r]分区,函数返回 pivot 的下标。

如果我们不考虑空间消耗的话,partition() 分区函数可以写得非常简单。我们申请两个临时数组 X 和 Y,遍历 A[p...r],将小于 pivot 的元素都拷贝到临时数组 X,将大于 pivot 的元素都拷贝到临时数组 Y,最后再将数组 X 和数组 Y 中数据顺序拷贝到 A[p....r]。

但是,如果按照这种思路实现的话,partition() 函数就需要很多额外的内存空间,所以快排就不是原地排序算法了。如果我们希望快排是原地排序算法,那它的空间复杂度得是 O(1),那 partition() 分区函数就不能占用太多额外的内存空间,我们就需要在 A[p...r]的原地完成分区操作。

原地分区函数的实现思路非常巧妙,我写成了伪代码,我们一起来看一下。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
partition(A, p, r) {
  pivot := A[r]
  i := p
  for j := p to r-1 do {
    if A[j] < pivot {
      swap A[i] with A[j]
      i := i+1
    }
  }
  swap A[i] with A[r]
  return i

这里的处理有点类似选择排序。我们通过游标 i 把 A[p...r-1]分成两部分。A[p...i-1]的元素都是小于 pivot 的,我们暂且叫它“已处理区间”,A[i...r-1]是“未处理区间”。我们每次都从未处理的区间 A[i...r-1]中取一个元素 A[j],与 pivot 对比,如果小于 pivot,则将其加入到已处理区间的尾部,也就是 A[i]的位置。

因为分区的过程涉及交换操作,如果数组中有两个相同的元素,比如序列 6,8,7,6,3,5,9,4,在经过第一次分区操作之后,两个 6 的相对先后顺序就会改变。所以,快速排序不是一个稳定的排序算法

快速排序的性能分析

在前面的分析可以得知快排是一种原地、不稳定的排序算法。现在,我们集中精力来看快排的时间复杂度。

快排也是用递归来实现的。对于递归代码的时间复杂度,我前面总结的公式,这里也还是适用的。如果每次分区操作,都能正好把数组分成大小接近相等的两个小区间,那快排的时间复杂度递推求解公式跟归并是相同的。所以,快排的时间复杂度也是 O(nlogn)。

递推求解的过程非常复杂,虽然可以求解,但我不推荐用这种方法。实际上,递归的时间复杂度的求解方法除了递推公式之外,还有递归树,在树那一节我再讲,这里暂时不说。我这里直接给你结论:T(n) 在大部分情况下的时间复杂度都可以做到 O(nlogn),只有在极端情况下,才会退化到 O(n2)。而且,我们也有很多方法将这个概率降到很低,如何来做?我们后面章节再讲。

解答开篇

快排核心思想就是分治分区,我们可以利用分区的思想,来解答开篇的问题:O(n) 时间复杂度内求无序数组中的第 K 大元素。比如,4, 2, 5, 12, 3 这样一组数据,第 3 大元素就是 4。

我们选择数组区间 A[0...n-1]的最后一个元素 A[n-1]作为 pivot,对数组 A[0...n-1]原地分区,这样数组就分成了三部分,A[0...p-1]、A[p]、A[p+1...n-1]。

如果 p+1=K,那 A[p]就是要求解的元素;如果 K>p+1, 说明第 K 大元素出现在 A[p+1...n-1]区间,我们再按照上面的思路递归地在 A[p+1...n-1]这个区间内查找。同理,如果 K<p+1,那我们就在 A[0...p-1]区间查找。

关键代码

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public static int kthSmallest(int[] arr, int k) {
    if (arr == null || arr.length < k) {
        return -1;
    }
    int pivot = partition(arr, 0, arr.length - 1);
    while (k != pivot + 1) {
        if (k > pivot + 1) {
            pivot = partition(arr, pivot + 1, arr.length - 1);
        } else {
            pivot = partition(arr, 0, pivot - 1);
        }
    }
    return arr[pivot];
}

我们再来看,为什么上述解决思路的时间复杂度是 O(n)?

第一次分区查找,我们需要对大小为 n 的数组执行分区操作,需要遍历 n 个元素。第二次分区查找,我们只需要对大小为 n/2 的数组执行分区操作,需要遍历 n/2 个元素。依次类推,分区遍历元素的个数分别为、n/2、n/4、n/8、n/16.……直到区间缩小为 1。

如果我们把每次分区遍历的元素个数加起来,就是:n+n/2+n/4+n/8+...+1。这是一个等比数列求和,最后的和等于 2n-1。所以,上述解决思路的时间复杂度就为 O(n)。你可能会说,我有个很笨的办法,每次取数组中的最小值,将其移动到数组的最前面,然后在剩下的数组中继续找最小值,以此类推,执行 K 次,找到的数据不就是第 K 大元素了吗?

不过,时间复杂度就并不是 O(n) 了,而是 O(K * n)。你可能会说,时间复杂度前面的系数不是可以忽略吗?O(K * n) 不就等于 O(n) 吗?

这个可不能这么简单地划等号。当 K 是比较小的常量时,比如 1、2,那最好时间复杂度确实是 O(n);但当 K 等于 n/2 或者 n 时,这种最坏情况下的时间复杂度就是 O(n2) 了。

内容小结

我的代码实现 https://gitee.com/kaiLee/struct/tree/master/src/main/java/com/s6/sort2

归并排序和快速排序是两种稍微复杂的排序算法,它们用的都是分治的思想,代码都通过递归来实现,过程非常相似。理解归并排序的重点是理解递推公式和 merge() 合并函数。同理,理解快排的重点也是理解递推公式,还有 partition() 分区函数。

归并排序算法是一种在任何情况下时间复杂度都比较稳定的排序算法,这也使它存在致命的缺点,即归并排序不是原地排序算法,空间复杂度比较高,是 O(n)。正因为此,它也没有快排应用广泛。

快速排序算法虽然最坏情况下的时间复杂度是 O(n2),但是平均情况下时间复杂度都是 O(nlogn)。不仅如此,快速排序算法时间复杂度退化到 O(n2) 的概率非常小,我们可以通过合理地选择 pivot 来避免这种情况。

参考

12 | 排序(下):如何用快排思想在O(n)内查找第K大元素? https://time.geekbang.org/column/article/41913

java/12_sorts · 编程语言算法集/algo - 码云 - 开源中国 https://gitee.com/TheAlgorithms/algo/tree/master/java/12_sorts

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2022-05-17,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
web九大组件之---RequestMappingHandlerAdapter详尽解析【享学Spring MVC】
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
YourBatman
2019/10/22
4.3K0
web九大组件之---RequestMappingHandlerAdapter详尽解析【享学Spring MVC】
SpringMVC这篇文章吃透了,最少最少涨5000
本文将通过阅读源码的方式带大家了解 springmv 容器启动的过程,SpringMVC 中的各种组件都是在容器启动的过程中组装的,所以如果熟悉整个过程后,你可以随意对 SpringMVC 进行扩展,SpringMVC 会被你玩的出神入化。
路人甲Java
2021/10/08
8700
这一次搞懂SpringMVC原理
前面几篇文章,学习了Spring IOC、Bean实例化过程、AOP、事务的源码和设计思想,了解了Spring的整体运行流程,但如果是web开发,那么必不可少的还有Spring MVC,本篇主要分析在请求调用过程中SpringMVC的实现原理,通过本篇要搞懂它是怎么解决请求、参数、返回值映射等问题的。
夜勿语
2020/09/07
3860
Spring MVC注解Controller源码流程解析--映射建立
本篇为spring mvc源码解析高级篇,其中关于DispathcerServlet的前置知识块,建议大家先通过我的spring源码专栏学习一下:
大忽悠爱学习
2022/09/28
1K0
Spring MVC注解Controller源码流程解析--映射建立
你想知道的MVC执行流程都在这里了
Spring提供一套视图层的处理框架,他基于Servlet实现,可以通过XML或者注解进行我们需要的配置。
石的三次方
2021/01/05
4890
SpringMVC详解
 【1】Spring Web MVC是基于Servlet API构建的原始Web框架,从一开始就已包含在Spring框架中。正式名称“ Spring Web MVC”来自其源模块的名称(spring-webmvc),但它通常被称为“ Spring MVC”。
忧愁的chafry
2022/11/24
5490
SpringMVC详解
Springmvc源码解读
文章目录 1. 实现Controller的方式 1.1. 实现Controller 1.2. 实现HttpRequestHandler 1.3. 使用注解 2. @EnableWebMvc 3. DispatcherServlet 4. HandlerMapping 4.1. BeanNameUrlHandlerMapping 4.2. SimpleUrlHandlerMapping 4.3. RequestMappingHandlerMapping 5. HandlerExecutionChain 6
爱撒谎的男孩
2019/12/31
4020
SpringMVC 解毒2
在第2章,DipatcherServlet中使用 HandlerMapping 得到执行链HandlerExecutionChain,然后就再也没有 HandlerMapping 的事了。也就是说SpringMVC就是靠 HandlerMapping 通过入参 HttpServletRequest 判断应该调用哪个方法、或者返回哪个文件,所以就让我们从这里入手。
zhangheng
2020/04/29
8330
SpringMVC 解毒2
【小家Spring】Spring MVC容器的web九大组件之---HandlerMapping源码详解(二)---RequestMappingHandlerMapping系列
上篇博客: 【小家Spring】Spring MVC容器的web九大组件之—HandlerMapping源码详解(一)—BeanNameUrlHandlerMapping系列 分析过了HandlerMapping的一些抽象实现,以及AbstractHandlerMapping的一个主要分支:AbstractUrlHandlerMapping体系的实现原理分析:它是基于类级别的Handler实现,大体上和源生servlet如出一辙,也还没有脱离源生servlet的API。作为第一版的实现,便捷度自然存在一些欠缺,但大的框架还是非常稳的。可以看出Spring的眼光、抽象思维算是顶级水准~
YourBatman
2019/09/03
2K1
【小家Spring】Spring MVC容器的web九大组件之---HandlerMapping源码详解(二)---RequestMappingHandlerMapping系列
【springmvc】controller的初始化与匹配
DispatcherServlet的初始化流程 讲述DispatcherServlet从Servlet::init一路调用至DispatcherServlet::initStrategies的过程。
平凡的学生族
2020/03/26
1.2K0
SpringMvc简单梳理
刚开始接触springmvc的时候就听说过一个核心的类: DispatchServlet , 现在以spring-webmvc为入口探索下springmvc的核心类及流程,
eeaters
2021/11/19
4050
SpringMvc简单梳理
springboot之mvc原理(二)-能力支持
前边一篇文章《springboot之mvc原理(一)-请求处理》我们详细分析了springboot应用接收http请求的处理过程,那么进一步的思考一下,为什么应用启动支持就能处理http请求了呢?在应用启动过程中springboot帮我们做了什么呢?DispatchServlet使用的各种组件哪里来的?本篇文章我们将从原理和源码层面对springboot的web能力支持做一下分析和描述。
叔牙
2020/11/19
1.1K0
springboot之mvc原理(二)-能力支持
SpringMVC之Controller查找(Spring4.0.3/Spring5.0.4源码进化对比)0 摘要1 SpringMVC请求流程2 SpringMVC初始化过程总结
0 摘要 本文从源码层面简单讲解SpringMVC的处理器映射环节,也就是查找Controller详细过程 1 SpringMVC请求流程 Controller查找在上图中对应的步骤1至2的过程
JavaEdge
2018/05/16
1.2K0
CORS跨域资源共享(三):@CrossOrigin/CorsFilter处理跨域请求示例,原理分析【享学Spring MVC】
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
YourBatman
2019/09/25
17.3K0
CORS跨域资源共享(三):@CrossOrigin/CorsFilter处理跨域请求示例,原理分析【享学Spring MVC】
SpringMVC源码解析
GenericServlet抽象类的子类HttpServlet没有实现,具体实现在HttpServletBean类 根据代码可知,具体实现依然需要子类根据需求喜好自己实现重写
Java微观世界
2025/01/20
950
SpringMVC源码解析
SpringMVC 九大组件之 HandlerMapping 深入分析
前面跟小伙伴们分享了 SpringMVC 一个大致的初始化流程以及请求的大致处理流程,在请求处理过程中,涉及到九大组件,分别是:
江南一点雨
2021/04/01
1.1K0
SpringMVC 九大组件之 HandlerMapping 深入分析
从Spring内存马检测到隐形马
本文首发于先知社区:https://xz.aliyun.com/t/10583 0x01 介绍 看了一些大佬的查杀内存马文章,很少有Spring相关内存马的检测方式 有部分是借助javaagent得到jvm中所有已加载的类然后分析,显得有点庞大 是否可以只借助Spring框架本身做检测呢 从检测思路上得到了一种进阶的内存马:隐形马,也可以叫做劫持马 劫持正常的Controller改为内存马,表明上一切正常,通过检测手段无法发现 0x02 检测效果 笔者基于SpringMVC本身写了一些检测代码 正常情况下,
亿人安全
2022/06/30
2.1K0
从Spring内存马检测到隐形马
原理解读:Spring MVC统一异常处理
当前,Spring统一异常处理机制是Java开发人员普遍使用的一种技术,在业务校验失败的时候,直接抛出业务异常即可,这明显简化了业务异常的治理流程与复杂度。值得一提的是,统一异常处理机制并不是Spring Boot提供的,而是Spring MVC,前者只是为Spring MVC自动配置了刚好够用的若干组件而已,具体配置了哪些组件,感兴趣的读者可以到spring-boot-autoconfigure模块中找到答案。
程序猿杜小头
2022/12/01
1.4K1
原理解读:Spring MVC统一异常处理
Spring MVC注解Controller源码流程解析---请求匹配中的容错处理
Spring MVC注解Controller源码流程解析–定位HandlerMethod
大忽悠爱学习
2022/09/28
8970
Spring MVC注解Controller源码流程解析---请求匹配中的容错处理
Spring MVC中HandlerMapping和HandlerAdapter是怎么工作的?
3月份的时候由于疫情被裁员,换了一家公司,结果来了这个公司一看代码就晕了,我熟悉的@RequestMapping注解哪去了?不用@RequestMapping注解怎么做映射啊?然后看了一波文档,原来映射规则是这样做的,有如下一个Controller类
Java识堂
2020/05/18
1.3K0
推荐阅读
相关推荐
web九大组件之---RequestMappingHandlerAdapter详尽解析【享学Spring MVC】
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档