Spring AOP 概念及其使用

目录

AOP概述

什么是AOP？

什么是Spring AOP ?

Spring AOP 快速入门

1.引⼊ AOP 依赖

2.编写AOP程序

Spring AOP 核心概念 

1.切点

2.连接点

3.通知

4.切面

通知类型

注意事项:

@PointCut（定义切点）

切面优先级 @Order

切点表达式：

execution表达式

切点表达式示例

@annotation

1. 编写自定义注解

2. 使⽤ @annotation 表达式来描述切点

AOP概述

        AOP 是 Spring 框架的第⼆⼤核⼼(第⼀⼤核⼼是 IoC 推荐看Spring IoC & DI 使⽤)

什么是AOP？

        Aspect Oriented Programming（⾯向切⾯编程）

        什么是⾯向切⾯编程呢? 切⾯就是指某⼀类特定问题,所以 AOP 也可以理解为⾯向特定⽅法编程. 什么是⾯向特定⽅法编程呢?⽐如"登录校验",就是⼀类特定问题.登录校验拦截器,就 是对"登录校验"这类问题的统⼀处理（推荐看拦截器使用详解）.所以,拦截器也是 AOP 的⼀种应⽤. AOP 是⼀种思想,拦截器是 AOP  思想的⼀种实现. Spring 框架实现了这种思想, 提供了拦截器技术的相关接⼝. 同样的,统⼀数据返回格式和统⼀异常处理（推荐看Spring Boot 统⼀数据返回格式）, 也是 AOP 思想的⼀种实现. 简单来说: AOP是⼀种思想,是对某⼀类事情的集中处理.

         AOP的作⽤：可以在不修改源代码的基础上对已有⽅法进⾏增强（⽆侵⼊性:解耦）

什么是Spring AOP ?

        AOP 是⼀种思想,它的实现⽅法有很多,有 Spring AOP，也有AspectJ、CGLIB等. Spring AOP是其中的⼀种实现⽅式.

Spring AOP 快速入门

1.引⼊ AOP 依赖

        在pom.xml ⽂件中添加配置

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.编写AOP程序

@Aspect //标识这是一个切面类
@Component  //将 AspectDemo 的对象交给 Spring 进行管理，切面类中的通知方法才能对指定的目标方法起作用
@Slf4j
public class AspectDemo {//环绕通知（@Around）//通知方法作用于目标方法执行前和执行后@Around("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")// point 参数表示目标方法public Object around_AOP(ProceedingJoinPoint point) throws Throwable {log.info("执行 around_AOP 方法,目标方法前");//执行目标方法,并且要用一个变量接收目标方法的值，然后再让通知方法返回Object result=point.proceed();log.info("执行 around_AOP 方法,目标方法后");return result;}
}

        对于上述程序进行简单讲解：

        @Aspect：标识这是⼀个切⾯类

        @Component：IoC 核心思想，五大注解其中之一，表示将 AspectDemo 这个切面类的对象交给 Spring 进行管理，要加上这个注解，切面类中的通知方法才会对指定的目标方法起作用

        @Slf4j：lombok 工具类提供的注解，为我们创建了一个日志对象 log ，用于打印日志的

        @Around：环绕通知,在⽬标⽅法的前后都会被执⾏.后⾯的表达式表⽰对哪些⽅法进⾏增强.（指定目标方法）

        ProceedingJoinPoint 类型的对象 point 代表目标方法，point.proceed() 代表执行目标方法

Spring AOP 核心概念 

1.切点

        切点(Pointcut), 也称之为"切⼊点"  Pointcut 的作⽤就是提供⼀组规则,告诉程序对哪些⽅法来进⾏功能增强，简单来说：切点就是通过表达式指定对哪些目标方法进行功能增强，上⾯的表达式execution(* com.yulin.spring_aop_demo.Controller.*.*(..))  就是切点表达式.

2.连接点

        满⾜切点表达式规则的⽅法,就是连接点.简单来说：每一个需要进行功能增强的目标方法都是连接点，在上述代码中 com.yulin.spring_aop_demo.Controller 路径下的所有目标方法都是连接点

        切点和连接点的关系：连接点是满⾜切点表达式的元素.切点可以看做是保存了众多连接点的⼀个集合，简单来说：切点表示所有要进行功能增强的目标方法，每个目标方法都是一个连接点

3.通知

         通知就是具体要做的⼯作,指那些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)，简单来说：我们想要为目标方法添加的新功能就是通知，新功能的代码写在一个方法中，这个方法叫通知方法

4.切面

        切⾯(Aspect)= 切点 (Pointcut) + 通知(Advice)

        通过切⾯就能够描述当前 AOP 程序需要针对于哪些⽅法,添加哪些新的功能，如下图，一个完整的通知方法就是一个切面，通知方法所在的类就叫切面类

通知类型

        上⾯我们讲了什么是通知,接下来学习通知的类型.@Around 就是其中⼀种通知类型,表⽰环绕通知. 

        Spring AOP的通知类型有以下⼏种:

         • @Around:环绕通知,此注解标注的通知⽅法在⽬标⽅法前,后都被执⾏ 

        • @Before:前置通知,此注解标注的通知⽅法在⽬标⽅法前被执⾏

        • @After: 后置通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,⽆论是否有异常都会执⾏

        • @AfterReturning: 返回后通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,有异常不会执⾏ 

        • @AfterThrowing: 异常后通知, 此注解标注的通知⽅法在目标方法发⽣异常后执⾏

        我们可以通过如下的代码来熟悉这几种通知类型：

@Aspect //标识这是一个切面类
@Component  //将 AspectDemo 的对象交给 Spring 进行管理，切面类中的通知方法才能对指定的目标方法起作用
@Slf4j
public class AspectDemo {//前置通知（@Before）//通知方法作用于目标方法执行前@Before("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")public void before_AOP(){log.info("执行 before_AOP 方法");}//后置通知（@After）//通知方法作用于目标方法执行后@After("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")public void after_AOP(){log.info("执行 after_AOP 方法");}//返回后通知（@AfterReturning）//通知方法作用于目标方法“正确”返回后@AfterReturning("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")public void afterReturning_AOP(){log.info("执行 afterReturning_AOP 方法");}//抛出异常后通知(@AfterThrowing)//通知方法作用于目标方法抛出异常后@AfterThrowing("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")public void afterThrowing_AOP(){log.info("执行 afterThrowing_AOP 方法");}//环绕通知（@Around）//通知方法作用于目标方法执行前和执行后@Around("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")// point 参数表示目标方法public Object around_AOP(ProceedingJoinPoint point) throws Throwable {log.info("执行 around_AOP 方法,目标方法前");//执行目标方法,并且要用一个变量接收目标方法的值，然后再让通知方法返回Object result=point.proceed();log.info("执行 around_AOP 方法,目标方法后");return result;}
}

        1.当 com.yulin.spring_aop_demo.Controller 路径下的一个目标方法正常执行时：

        程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏ 从上图也可以看出来, @Around 标识的通知⽅法包含两部分,⼀个"前置逻辑",⼀个"后置逻辑".其 中"前置逻辑"会先于 @Before 标识的通知⽅法执⾏,"后置逻辑"会晚于 @After 标识的通知⽅法执行

        2.当 com.yulin.spring_aop_demo.Controller 路径下的一个目标方法执行出现异常时：

·        @AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了

@Around 环绕通知的后置逻辑没有执行，因为目标方法没有正常返回

注意事项:

        1.@Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏,其他 通知不需要考虑⽬标⽅法执⾏.在该代码前的代码就是环绕通知的前置逻辑，该代码后的代码就是环绕通知的后置逻辑

        2.@Around 环绕通知⽅法的返回值,必须指定为 Object ,来接收目标⽅法的返回值,否则目标⽅法执⾏完毕,是获取不到返回值的.

@PointCut（定义切点）

       上面的代码有一个问题，就是存在⼤量重复的切点表达式 execution(* com.yulin.spring_aop_demo.Controller.*.*(..)) Spring提供了 @PointCut 注解,把公共的切点表达式提取出来,需要⽤到时引⽤该切⼊点表达式即可

        上面的代码可以修改为：

@Aspect //标识这是一个切面类
@Component  //将 AspectDemo 的对象交给 Spring 进行管理，切面类中的通知方法才能对指定的目标方法起作用
@Slf4j
public class AspectDemo {//定义切点@Pointcut("execution(* com.yulin.spring_aop_demo.Controller.*.*(..))")private void pt(){}//前置通知（@Before）//通知方法作用于目标方法执行前@Before("pt()")public void before_AOP(){log.info("执行 before_AOP 方法");}//后置通知（@After）//通知方法作用于目标方法执行后@After("pt()")public void after_AOP(){log.info("执行 after_AOP 方法");}//返回后通知（@AfterReturning）//通知方法作用于目标方法“正确”返回后@AfterReturning("pt()")public void afterReturning_AOP(){log.info("执行 afterReturning_AOP 方法");}//抛出异常后通知(@AfterThrowing)//通知方法作用于目标方法抛出异常后@AfterThrowing("pt()")public void afterThrowing_AOP(){log.info("执行 afterThrowing_AOP 方法");}//环绕通知（@Around）//通知方法作用于目标方法执行前和执行后@Around("pt()")// point 参数表示目标方法public Object around_AOP(ProceedingJoinPoint point) throws Throwable {log.info("执行 around_AOP 方法,目标方法前");//执行目标方法,并且要用一个变量接收目标方法的值，然后再让通知方法返回Object result=point.proceed();log.info("执行 around_AOP 方法,目标方法后");return result;}
}

        注意：当切点定义使⽤private修饰时,仅能在当前切⾯类中使⽤,当其他切⾯类也要使⽤当前切点定义时,就需要把private改为public.引⽤⽅式为:全限定类名.⽅法名 ()

切面优先级 @Order

        当我们在⼀个项⽬中,定义了多个切⾯类时,并且这些切⾯类的切入点都匹配到了同⼀个⽬标⽅法.当⽬标⽅法运⾏的时候,这些切⾯类中的通知⽅法都会执⾏,那么这⼏个通知⽅法的执⾏顺序是什么样的呢?

        我们通过程序来求证:

        定义多个切⾯类: AspectDemo1 和 AspectDemo2，为简单化,只写了 @Before 和 @After 两个通知

AspectDemo1：

@Aspect
@Component
@Slf4j
public class AspectDemo1 {@Before("com.yulin.spring_aop_demo.Aspect.AspectDemo.pt()")public void before_AOP(){log.info("执行 AspectDemo1 -》 before_AOP 方法");}@After("com.yulin.spring_aop_demo.Aspect.AspectDemo.pt()")public void after_AOP(){log.info("执行 AspectDemo1 -》 after_AOP 方法");}}

AspectDemo2：

@Aspect
@Component
@Slf4j
public class AspectDemo2 {@Before("com.yulin.spring_aop_demo.Aspect.AspectDemo.pt()")public void before_AOP(){log.info("执行 AspectDemo2 -》 before_AOP 方法");}@After("com.yulin.spring_aop_demo.Aspect.AspectDemo.pt()")public void after_AOP(){log.info("执行 AspectDemo2 -》 after_AOP 方法");}}

        上述两个切面类中的通知方法都作用于同一批目标方法，我们现在来观察，目标方法执行后，通知方法的执行顺序

        

2023-12-04 11:55:07.539  INFO 28864 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo1   : 执行 AspectDemo1 -》 before_AOP 方法
2023-12-04 11:55:07.539  INFO 28864 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo2   : 执行 AspectDemo2 -》 before_AOP 方法
2023-12-04 11:55:07.545  INFO 28864 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo2   : 执行 AspectDemo2 -》 after_AOP 方法
2023-12-04 11:55:07.545  INFO 28864 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo1   : 执行 AspectDemo1 -》 after_AOP 方法

        如上的日志可以看出：

        存在多个切⾯类时,默认按照切⾯类的类名字⺟排序： 

        • @Before 通知：字⺟排名靠前的先执⾏

        • @After 通知：字⺟排名靠前的后执⾏

        但这种⽅式不⽅便管理，我们的类名更多还是具备⼀定含义的，这种方式不可控，Spring 给我们提供了⼀个新的注解, 来控制这些切⾯通知的执⾏顺序: @Order

使⽤⽅式如下:

@Aspect
@Component
@Order(2)
public class AspectDemo1 {//...代码省略 
}

@Aspect
@Component
@Order(1)
public class AspectDemo2 {//...代码省略 
}

        设置优先级以后，重新访问目标方法，带动执行通知方法，得到的日志为：

2023-12-04 12:07:38.540  INFO 34560 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo2   : 执行 AspectDemo2 -》 before_AOP 方法
2023-12-04 12:07:38.541  INFO 34560 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo1   : 执行 AspectDemo1 -》 before_AOP 方法
2023-12-04 12:07:38.546  INFO 34560 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo1   : 执行 AspectDemo1 -》 after_AOP 方法
2023-12-04 12:07:38.546  INFO 34560 --- [nio-8080-exec-1] c.y.spring_aop_demo.Aspect.AspectDemo2   : 执行 AspectDemo2 -》 after_AOP 方法

        当我们设置 AspectDemo2 的优先级为1，AspectDemo1 的优先级为 2 后，AspectDemo2 的优先级就比 AspectDemo1 的高，所以 AspectDemo2 的 before 通知会先执行，after 通知会后执行

        通过上述程序的运⾏结果,得出结论: 

        @Order 注解标识的切⾯类,执⾏顺序如下:

         • @Before 通知：数字越⼩，优先级越高先执⾏

         • @After 通知：数字越⼤，优先级越小先执⾏

切点表达式：

        上⾯的代码中,我们⼀直在使⽤切点表达式来描述切点（描述目标方法所在的位置）.下⾯我们来介绍⼀下切点表达式的语法. 切点表达式常⻅有两种表达⽅式

1. execution(......) 根据⽅法的签名来匹配

2.@annotation(......) 根据注解匹配

execution表达式

        execution() 是最常⽤的切点表达式, ⽤来匹配目标⽅法,语法为:

execution(<访问修饰符> <返回类型> <包名.类名.⽅法(⽅法参数)> <异常>),其中:访问修饰符和异常可以省略

访问修饰符：为 private ，public ，protected，匹配目标方法的访问修饰符

切点表达式⽀持通配符表达:

1. * ：匹配任意字符，只匹配⼀个元素(返回类型,包,类名,⽅法或者⽅法参数) 

        a. 包名使⽤* 表⽰任意包(⼀层包使⽤⼀个*)

        b. 类名使⽤* 表⽰任意类 

        c. 返回值使⽤* 表⽰任意返回值类型 

        d. ⽅法名使⽤* 表⽰任意⽅法 

        e. 参数使⽤* 表⽰⼀个任意类型的参数

.. ：匹配多个连续的任意符号,可以通配任意层级的包,或任意类型,任意个数的参数

        a. 使⽤ .. 配置包名，标识此包以及此包下的所有⼦包

        b. 可以使⽤ .. 配置参数，匹配任意个任意类型的参数

切点表达式示例

TestController类下的 public修饰,返回类型为String⽅法名为t1,⽆参⽅法

execution(public String com.example.demo.controller.TestController.t1())

匹配 controller 包下所有的类的所有⽅法

execution(* com.example.demo.controller.*.*(..))

匹配所有包下⾯的 TestController 类中的所有方法

execution(* com..TestController.*(..))

匹配com.example.demo包下,⼦孙包下的所有类的所有⽅法

execution(* com.example.demo..*(..))

@annotation

        execution 表达式更适⽤有规则的,如果我们要匹配多个⽆规则的⽅法呢,⽐如：TestController中的 t1()  和 UserController 中的 u1() 这两个⽅法.

        这个时候我们使⽤ execution 这种切点表达式来描述就不是很⽅便了.我们可以借助⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点

       实现步骤：

        1. 编写⾃定义注解

        2. 使⽤ @annotation 表达式来描述切点

        3. 在连接点的⽅法上添加⾃定义注解

1. 编写自定义注解

        创建⼀个注解类(和创建 Class ⽂件⼀样的流程,选择Annotation就可以了)

@Target(ElementType.METHOD) //表示自定义注解的作用范围，即该注解可以⽤在什么地⽅.
@Retention(RetentionPolicy.RUNTIME) //表示自定义注解的生命周期，即注解被保留的时间⻓短
public @interface MyAspectAnnotation { }

        @Target 注解，用于设置自定义注解的作用范围，即该注解可以⽤在什么地⽅.上述代码表示注解用于方法上

        常⽤取值:

        ElementType.TYPE:⽤于描述类、接⼝(包括注解类型)或 enum 声明 

        ElementType.METHOD:描述⽅法

        ElementType.PARAMETER:描述参数

        ElementType.TYPE_USE:可以标注任意类型

        @Retention 注解，设置自定义注解的生命周期，即注解被保留的时间⻓短，上述代码表示注解在程序运行时也一直存在

        常⽤取值:

        1. RetentionPolicy.SOURCE：表⽰注解仅存在于源代码中,编译成字节码后会被丢弃.这意味着 在运⾏时⽆法获取到该注解的信息,只能在编译时使⽤.⽐如 @SuppressWarnings ,以及 lombok提供的注解 @Data ,@Slf4j

        2. RetentionPolicy.CLASS：编译时注解.表⽰注解存在于源代码和字节码中,但在运⾏时会被丢弃.这意味着在编译时和字节码中可以通过反射获取到该注解的信息,但在实际运⾏时⽆法获取.通常⽤于⼀些框架和⼯具的注解.

        3. RetentionPolicy.RUNTIME：运⾏时注解.表⽰注解存在于源代码,字节码和运⾏时中.这意味 着在编译时,字节码中和实际运⾏时都可以通过反射获取到该注解的信息.通常⽤于⼀些需要在运⾏时处理的注解,如Spring的 @Controller @ResponseBody

2. 使⽤ @annotation 表达式来描述切点

        我更喜欢这样理解：通过 @annotation 注解把切面类中的通知方法依附于注解上，在目标方法上使用该注解，在运行目标方法时便会执行依附于注解上的通知方法

@Aspect
@Component
@Slf4j
public class MyAspectDemo {// @annotation 注解中的参数是通知方法要绑定的注解位置//如下代码就将 beforeAOP（）通知方法绑定到了 MyAspectAnnotation 注解上@Before("@annotation(com.yulin.spring_aop_demo.Annotation.MyAspectAnnotation)")public void beforeAOP(){log.info("执行 MyAspectDemo -》 beforeAOP 通知方法");}@After("@annotation(com.yulin.spring_aop_demo.Annotation.MyAspectAnnotation)")public void afterAOP(){log.info("执行 MyAspectDemo -》 beforeAOP 通知方法");}
}

        我们定义一个接口类来使用定义好的注解 @MyAspectAnnotation 

@RequestMapping("/userController")
@RestController
@Slf4j
public class userController {@RequestMapping("/getUserName")public String getUserName(){log.info("进入接口 getUserName ");return "小三";}@MyAspectAnnotation@RequestMapping("/getPassword")public String getPassword(){log.info("进入接口 getPassword ");return "123";}
}

        当我们访问 ”/userController/getUserName“ 路径，得到如下的日志

2023-12-04 16:33:01.873  INFO 18364 --- [nio-8080-exec-1] c.y.s.Controller.userController          : 进入接口 getUserName

        通过日志我们可以看出，由于 getUserName（）方法上没有添加 @MyAspectAnnotation 注解，所以访问该接口后，不会执行通知方法

         当我们访问 ”/userController/getPassword“ 路径，得到如下的日志

2023-12-04 16:35:47.123  INFO 18364 --- [nio-8080-exec-4] c.y.spring_aop_demo.Aspect.MyAspectDemo  : 执行 MyAspectDemo -》 beforeAOP 通知方法
2023-12-04 16:35:47.123  INFO 18364 --- [nio-8080-exec-4] c.y.s.Controller.userController          : 进入接口 getPassword 
2023-12-04 16:35:47.123  INFO 18364 --- [nio-8080-exec-4] c.y.spring_aop_demo.Aspect.MyAspectDemo  : 执行 MyAspectDemo -》 beforeAOP 通知方法

        通过日志我们可以看出，由于 getPassword（）方法上添加了 @MyAspectAnnotation 注解，所以访问该接口后，会执行依附于该注解的通知方法

        Spring AOP的实现⽅式(常⻅⾯试题) 

        1. 基于注解 @Aspect (参考上述内容) 

        2. 基于⾃定义注解(参考⾃定义注解 @annotation 部分的内容)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/247586.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Oracle的数据一致性机制原理

Oracle的数据一致性机制原理

一、前言 在单用户环境下&#xff0c;在操作数据库是不需要考虑其他用户会修改同一个数据。但是在多用户的情况下&#xff0c;多个事务可能会修改同一个数据&#xff0c;最终会得到错误的数据结果。 Oracle数据库是通过 multiversion consistency model&#xff08;多版本数据…
阅读更多...
AWS攻略——使用中转网关(Transit Gateway)连接同区域(Region)VPC

AWS攻略——使用中转网关(Transit Gateway)连接同区域(Region)VPC

文章目录 环境准备创建VPC 配置中转网关给每个VPC创建Transit Gateway专属挂载子网创建中转网关创建中转网关挂载修改VPC的路由 验证创建业务Private子网创建可被外网访问的环境测试子网连通性Public子网到Private子网Private子网到Private子网 知识点参考资料 在《AWS攻略——…
阅读更多...
基于SSM的老年公寓信息管理的设计与实现

基于SSM的老年公寓信息管理的设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用JSP技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
pip命令详解

pip命令详解

pip命令介绍 pip是由Ian Bicking在2008年提出的&#xff0c;他将pyinstall重命名为pip。名称pip是首字母缩写词&#xff0c;全称为“Package Installer for Python”。自Python3的3.4版本以及Python2的2.7.9版本开始&#xff0c;pip被直接包括在Python的安装包内&#xff0c;成…
阅读更多...
树_二叉树所有路劲

树_二叉树所有路劲

//给你一个二叉树的根节点 root &#xff0c;按 任意顺序 &#xff0c;返回所有从根节点到叶子节点的路径。 // // 叶子节点 是指没有子节点的节点。 // // 示例 1&#xff1a; // // //输入&#xff1a;root [1,2,3,null,5] //输出&#xff1a;["1->2->5&quo…
阅读更多...
Liunx高级程序设计-Shell -1

Liunx高级程序设计-Shell -1

引入 完成以下任务 : 判断用户家目录下&#xff08;~ &#xff09;下面有没有一个叫 test 的文件夹 如果没有&#xff0c;提示按 y 创建并进入此文件夹&#xff0c;按 n 退出 如果有&#xff0c;直接进入&#xff0c;提示请输入一个字符串&#xff0c;并按此字符串创建…
阅读更多...
14、策略模式（Strategy Pattern）

14、策略模式（Strategy Pattern）

策略模式&#xff08;Strategy Pattern&#xff09;为同一个行为定义了不同的策略&#xff0c;并为每种策略都实现了不同的方法。在用户使用的时候&#xff0c;系统根据不同的策略自动切换不同的方法来实现策略的改变。同一个策略下的不同方法是对同一功能的不同实现&#xff0…
阅读更多...
分布式搜索引擎elasticsearch(一）

分布式搜索引擎elasticsearch(一）

5.1 初始elasticsearch elasticsearch是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容。 elasticsearch是elastic stack的核心，负责存储、搜索、分析数据。 5.1.1正向索引 5.1.2elasticsearch采用倒排索引： 文档（document）：每条数据就是一个…
阅读更多...
【深度学习】回归模型相关重要知识点总结

【深度学习】回归模型相关重要知识点总结

回归分析为许多机器学习算法提供了坚实的基础。在这篇文章中&#xff0c;我们将总结 10 个重要的回归问题和5个重要的回归问题的评价指标。 一、线性回归的假设是什么 线性回归有四个假设&#xff1a; 线性&#xff1a;自变量&#xff08;x&#xff09;和因变量&#xff08;y&…
阅读更多...
Elasticsearch：评估 RAG - 指标之旅

Elasticsearch：评估 RAG - 指标之旅

作者&#xff1a;Quentin Herreros&#xff0c;Thomas Veasey&#xff0c;Thanos Papaoikonomou 2020年&#xff0c;Meta发表了一篇题为 “知识密集型NLP任务的检索增强生成” 的论文。 本文介绍了一种通过利用外部数据库将语言模型 (LLM) 知识扩展到初始训练数据之外的方法。 …
阅读更多...
SpringBoot药品进销存管理系统(诊所管理系统)(乡村药店管理系统)

SpringBoot药品进销存管理系统(诊所管理系统)(乡村药店管理系统)

SSM毕设分享 SpringBoot药品进销存管理系统(诊所管理系统)(乡村药店管理系统) 1 项目简介 Hi&#xff0c;各位同学好&#xff0c;这里是郑师兄&#xff01; 今天向大家分享一个毕业设计项目作品【SpringBoot药品进销存管理系统(诊所管理系统)(乡村药店管理系统)】 师兄根据实…
阅读更多...
简单了解传输层协议之TCP和UDP

简单了解传输层协议之TCP和UDP

目录 一、什么是端口号? 二、TCP协议 2.1 TCP报文格式 2.2 三次握手 2.3 四次挥手 2.4 窗口流量控制 三、UDP协议 3.1 UDP报文格式 3.4 传输过程 一、什么是端口号? 我们自己的一台电脑上有时可能会同时运行多个进程软件来进行上网。那么当网络上的服务器响应我们电…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023