AOP切面试编程

最新推荐文章于 2024-07-01 19:29:42 发布
最新推荐文章于 2024-07-01 19:29:42 发布
阅读量1.6k 收藏 31
点赞数 40
文章标签： sql 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62736267/article/details/137056390
版权

1. AOP基础

1.1 AOP概述

什么是AOP？

  • AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。

  • AOP面向方法编程，可以做到在不改动这些原始方法的基础上，针对特定的方法进行功能的增强。

AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）

AOP的优势：

  1. 减少重复代码

  2. 提高开发效率

  3. 维护方便

1.2 AOP快速入门

实现步骤：

  1. 导入依赖：在pom.xml中导入AOP的依赖

  2. 编写AOP程序：针对于特定方法根据业务需要进行编程

pom.xml

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

AOP程序：TimeAspect

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {
​
    @Around("execution(* com.itheima.service.*.*(..))") 
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();
​
        //执行原始方法
        Object result = pjp.proceed();
​
        //记录方法执行结束时间
        long end = System.currentTimeMillis();
​
        //计算方法执行耗时
        log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);
​
        return result;
    }
}

我们通过AOP入门程序完成了业务方法执行耗时的统计，那其实AOP的功能远不止于此，常见的应用场景如下：

  • 记录系统的操作日志

  • 权限控制

  • 事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务这些都是AOP应用的典型场景。

我们也应该感受到了AOP面向切面编程的一些优势：

  • 代码无侵入：没有修改原始的业务方法，就已经对原始的业务方法进行了功能的增强或者是功能的改变

  • 减少了重复代码

  • 提高开发效率

  • 维护方便

1.3 AOP核心概念

1. 连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

连接点指的是可以被aop控制的方法。例如：入门程序当中所有的业务方法都是可以被aop控制的方法。在SpringAOP提供的JoinPoint当中，封装了连接点方法在执行时的相关信息。

2. 通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法），在AOP面向切面编程当中，我们只需要将这部分重复的代码逻辑抽取出来单独定义。抽取出来的这一部分重复的逻辑，也就是共性的功能。

3. 切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

在aop的开发当中，我们通常会通过一个切入点表达式来描述切入点(后面会有详解)。

假如：切入点表达式改为DeptServiceImpl.list()，此时就代表仅仅只有list这一个方法是切入点。只有list()方法在运行的时候才会应用通知。

4. 切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

当通知和切入点结合在一起，就形成了一个切面。通过切面就能够描述当前aop程序需要针对于哪个原始方法，在什么时候执行什么样的操作。

切面所在的类，我们一般称为切面类（被@Aspect注解标识的类）

5. 目标对象：Target，通知所应用的对象

目标对象指的就是通知所应用的对象，我们就称之为目标对象。

Spring的AOP底层是基于动态代理技术来实现的，也就是说在程序运行的时候，会自动的基于动态代理技术为目标对象生成一个对应的代理对象。在代理对象当中就会对目标对象当中的原始方法进行功能的增强。

2. AOP进阶

AOP的基础知识学习完之后，下面我们对AOP当中的各个细节进行详细的学习。主要分为4个部分：

  1. 通知类型

  2. 通知顺序

  3. 切入点表达式

  4. 连接点

2.1 通知类型

在入门程序当中，我们已经使用了一种功能最为强大的通知类型：Around环绕通知。

@Around("execution(* com.itheima.service.*.*(..))")
public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
    //记录方法执行开始时间
    long begin = System.currentTimeMillis();
    //执行原始方法
    Object result = pjp.proceed();
    //记录方法执行结束时间
    long end = System.currentTimeMillis();
    //计算方法执行耗时
    log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);
    return result;
}

只要我们在通知方法上加上了@Around注解，就代表当前通知是一个环绕通知。

Spring中AOP的通知类型：

  • @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行

  • @Before：前置通知，此注解标注的通知方法在目标方法前被执行

  • @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

  • @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行

  • @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

下面我们通过代码演示，来加深对于不同通知类型的理解：

@Slf4j
@Component
@Aspect
public class MyAspect1 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        log.info("before ...");
​
    }
​
    //环绕通知
    @Around("execution(* com.itheima.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");
​
        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();
        
        //原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了
        
        log.info("around after ...");
        return result;
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }
​
    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("execution(* com.itheima.service.*.*(..))")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }
​
    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.itheima.service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}
​

重新启动SpringBoot服务，进行测试：

程序发生异常的情况下：

  • @AfterReturning标识的通知方法不会执行，@AfterThrowing标识的通知方法执行了

  • @Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了 （因为原始方法调用已经出异常了）

在使用通知时的注意事项：

  • @Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行

  • @Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。

2.2 通知顺序

这多个通知方法到底哪个先运行，哪个后运行？ 下面我们通过程序来验证（这里呢，我们就定义两种类型的通知进行测试，一种是前置通知@Before，一种是后置通知@After）

定义多个切面类：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}
​
@Slf4j
@Component
@Aspect
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}
@Slf4j
@Component
@Aspect
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}
​

重新启动SpringBoot服务，测试通知的执行顺序：

备注：

  1. 把DeptServiceImpl实现类中模拟异常的代码删除或注释掉。

  2. 注释掉其他切面类(把@Aspect注释即可)，仅保留MyAspect2、MyAspect3、MyAspect4 ，这样就可以清晰看到执行的结果，而不被其他切面类干扰。

通过以上程序运行可以看出在不同切面类中，默认按照切面类的类名字母排序：

  • 目标方法前的通知方法：字母排名靠前的先执行

  • 目标方法后的通知方法：字母排名靠前的后执行

如果我们想控制通知的执行顺序有两种方式：

  1. 修改切面类的类名（这种方式非常繁琐、而且不便管理）

  2. 使用Spring提供的@Order注解

使用@Order注解，控制通知的执行顺序：

@Slf4j
@Component
@Aspect
@Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
​
    //后置通知 
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}
@Slf4j
@Component
@Aspect
@Order(3)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}
@Slf4j
@Component
@Aspect
@Order(1) //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

重新启动SpringBoot服务，测试通知执行顺序

通知的执行顺序大家主要知道两点即可：

  1. 不同的切面类当中，默认情况下通知的执行顺序是与切面类的类名字母排序是有关系的

  2. 可以在切面类上面加上@Order注解，来控制不同的切面类通知的执行顺序

2.3 切入点表达式

切入点表达式：

  • 描述切入点方法的一种表达式

  • 作用：主要用来决定项目中的哪些方法需要加入通知

  • 常见形式：

    1. execution(……)：根据方法的签名来匹配

    1. @annotation(……) ：根据注解匹配

首先我们先学习第一种最为常见的execution切入点表达式。

2.3.1 execution

execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

  • 访问修饰符：可省略（比如: public、protected）

  • 包名.类名： 可省略

  • throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

示例：

@Before("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")

可以使用通配符描述切入点

  • * ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分

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

切入点表达式的语法规则：

  1. 方法的访问修饰符可以省略

  2. 返回值可以使用*号代替（任意返回值类型）

  3. 包名可以使用*号代替，代表任意包（一层包使用一个*）

  4. 使用..配置包名，标识此包以及此包下的所有子包

  5. 类名可以使用*号代替，标识任意类

  6. 方法名可以使用*号代替，表示任意方法

  7. 可以使用 * 配置参数，一个任意类型的参数

  8. 可以使用.. 配置参数，任意个任意类型的参数

切入点表达式示例

  • 省略方法的修饰符号

    execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替返回值类型

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替包名（一层包使用一个*）

    execution(* com.itheima.*.*.DeptServiceImpl.delete(java.lang.Integer))

  • 使用..省略包名

    execution(* com..DeptServiceImpl.delete(java.lang.Integer))    

  • 使用*代替类名

    execution(* com..*.delete(java.lang.Integer))  

  • 使用*代替方法名

    execution(* com..*.*(java.lang.Integer))  

  • 使用 * 代替参数

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(*))

  • 使用..省略参数

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

注意事项：

  • 根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式。

    execution(* com.itheima.service.DeptService.list(..)) || execution(* com.itheima.service.DeptService.delete(..))

切入点表达式的书写建议：

  • 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头

    //业务类
@Service
public class DeptServiceImpl implements DeptService {
    
    public List<Dept> findAllDept() {
       //省略代码...
    }
    
    public Dept findDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptByMoreCondition(Dept dept) {
       //省略代码...
    }
    //其他代码...
}
//匹配DeptServiceImpl类中以find开头的方法
execution(* com.itheima.service.impl.DeptServiceImpl.find*(..))
描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性

execution(* com.itheima.service.DeptService.*(..))
在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 ..，使用 * 匹配单个包

execution(* com.itheima.*.*.DeptServiceImpl.find*(..))

3.3.2 @annotation

已经学习了execution切入点表达式的语法。那么如果我们要匹配多个无规则的方法，比如：list()和 delete()这两个方法。这个时候我们基于execution这种切入点表达式来描述就不是很方便了。而在之前我们是将两个切入点表达式组合在了一起完成的需求，这个是比较繁琐的。

我们可以借助于另一种切入点表达式annotation来描述这一类的切入点，从而来简化切入点表达式的书写。

实现步骤：

  1. 编写自定义注解

  2. 在业务类要做为连接点的方法上添加自定义注解

自定义注解：MyLog

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
}

业务类：DeptServiceImpl

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;
​
    @Override
    @MyLog //自定义注解（表示：当前方法属于目标方法）
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        //模拟异常
        //int num = 10/0;
        return deptList;
    }
​
    @Override
    @MyLog  //自定义注解（表示：当前方法属于目标方法）
    public void delete(Integer id) {
        //1. 删除部门
        deptMapper.delete(id);
    }
​
​
    @Override
    public void save(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.save(dept);
    }
​
    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }
​
    @Override
    public void update(Dept dept) {
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }
}

切面类

@Slf4j
@Component
@Aspect
public class MyAspect6 {
    //针对list方法、delete方法进行前置通知和后置通知
​
    //前置通知
    @Before("@annotation(com.itheima.anno.MyLog)")
    public void before(){
        log.info("MyAspect6 -> before ...");
    }
​
    //后置通知
    @After("@annotation(com.itheima.anno.MyLog)")
    public void after(){
        log.info("MyAspect6 -> after ...");
    }
}

重启SpringBoot服务，测试查询所有部门数据，查看控制台日志.

到此我们两种常见的切入点表达式我已经介绍完了。

  • execution切入点表达式

    • 根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式

    • 如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐

  • annotation 切入点表达式

    • 基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。我们需要匹配哪个方法，就在方法上加上对应的注解就可以了

2.4 连接点

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

示例代码：

@Slf4j
@Component
@Aspect
public class MyAspect7 {
​
    @Pointcut("@annotation(com.itheima.anno.MyLog)")
    private void pt(){}
   
    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> before ...");
    }
    
    //后置通知
    @Before("pt()")
    public void after(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> after ...");
    }
​
    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        //获取目标类名
        String name = pjp.getTarget().getClass().getName();
        log.info("目标类名：{}",name);
​
        //目标方法名
        String methodName = pjp.getSignature().getName();
        log.info("目标方法名：{}",methodName);
​
        //获取方法执行时需要的参数
        Object[] args = pjp.getArgs();
        log.info("目标方法参数：{}", Arrays.toString(args));
​
        //执行原始方法
        Object returnValue = pjp.proceed();
​
        return returnValue;
    }
}
​

重新启动SpringBoot服务，执行查询部门数据的功能。

爱编程的猫猫
关注
  • 40
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面试题之面向切面编程（AOP）
Yi_xy的博客
08-16 537
AOP面向切面编程只要是解决OOP（面向对象编程）的共性问题和扩展问题 AOP的作用是将公共的功能提取出来，公共的模块，只关注通用功能，不关注业务逻辑 AOP的优势： 1.将通用功能从业务中抽离出来，提高代码的复用性。有利于后期的维护和拓展。 2.在软件设计时，抽出通用功能，有利于软件设计的模块化，降低架构的复杂度。 AOP与OOP的区别： OOP是针对业务处理过程的实体，属性，行为进行封装 AOP则是针对业务处理过程中的切面进行提取，面对处理过程中的某个步骤或阶段，逻辑过程中各个部分的低耦合性 它们针对的
AOP面向切面编程
asdfghsadg的博客
09-27 90
AOP面向切面编程 AOP的概念： 面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 ...
并发编程面试题以及答案.docx
07-30
并发编程面试题以及答案 本文档提供了一份并发编程面试题集，涵盖了数据结构与算法基础、Java 基础、JVM、多线程/并发、Linux 使用与问题分析排查、框架使用等多个方面的知识点。同时，本文档还提供了面试真题和...
aop-study:面试切面变成总结
05-13
在Java开发领域，AOP（Aspect Oriented Programming，面向切面编程）是一种强大的设计模式，它允许程序员将关注点从核心业务逻辑中分离出来，如日志、事务管理、性能监控等。`aop-study`项目显然是一个专门用于学习...
Interview:面试编程问题
06-11
以下是一些基于Java的面试编程问题，这些问题旨在考察候选人的逻辑思维、代码实现以及对Java核心概念的理解。 1. **数组与集合** - **数组与ArrayList的区别**：数组是固定大小的，而ArrayList是动态数组，可以...
springboot面试题aop.docx
10-17
Spring Boot 面试题 AOP Spring Boot 是 Spring 开源组织下的子项目，是 Spring 组件一站式解决方案，主要是简化了使用 Spring 的难度，简省了繁重的配置，提供了各种启动器，开发者能快速上手。Spring Boot 的...
piquet:编程面试题集
06-18
《piquet:编程面试题集》是一份专为准备编程面试者设计的资源库，主要聚焦于Java语言。这份题集旨在帮助求职者提升解决实际编程问题的能力，从而在面试中表现出色。虽然作者提示答案可能不完全准确，但这份资料仍然...
如何设置SQL Server端口：确保数据库连接的最佳实践
06-28 673
在现代企业环境中，SQL Server作为微软的关系数据库管理系统，广泛应用于数据存储、分析和管理。然而，默认配置并不总能满足特定的网络安全和性能要求。因此，了解如何设置SQL Server端口对于优化数据库连接和确保网络安全至关重要。本文将详细探讨SQL Server端口的配置步骤、注意事项及最佳实践，帮助读者在复杂网络环境中有效管理数据库连接。
SQLAlchemy：原理与使用详解
Aaron_945的博客
06-25 1032
SQLAlchemy是一个强大的SQL工具包和对象关系映射（ORM）系统，它为应用程序开发者提供了SQL的全部功能和灵活性，同时提供了Python的简洁性和易用性。本文将介绍SQLAlchemy的基本原理和基本使用方法。
ubuntu 18 虚拟机安装（6） postgresql pg_dump pg_restore
abc
06-28 152
ubuntu 18 虚拟机安装（6） postgres mysql pg_dump。
对于 PHP 开发的 Web 应用，怎样有效地防止 SQL 注入攻击？
xy520521的博客
06-26 536
错误处理和日志记录：对于 SQL 查询的执行过程中出现的错误，进行适当的错误处理，不要将详细的错误信息直接暴露给用户。输入验证和过滤：对于用户输入的数据，进行有效的验证和过滤，确保只有合法的数据才能被用于构建 SQL 查询。使用安全的密码存储方式：对于用户的密码，应该使用适当的加密算法进行存储，例如使用哈希函数对密码进行进行散列处理，避免明文存储密码。定期更新和升级：及时更新和升级使用的 PHP 框架和相关库的版本，以获取最新的安全修复和漏洞修复。）来验证和过滤用户输入的数据。
Victor CMS v1.0 SQL 注入漏洞（CVE-2022-28060）
最新发布
Flag少侠的博客
07-01 1241
CVE-2022-28060 是 Victor CMS v1.0 中的一个SQL注入漏洞。该漏洞存在于文件中的user_name参数。攻击者可以通过发送特制的 SQL 语句，利用这个漏洞执行未授权的数据库操作，从而访问或修改数据库中的敏感信息。春秋云镜靶场是一个专注于网络安全培训和实战演练的平台，旨在通过模拟真实的网络环境和攻击场景，提升用户的网络安全防护能力和实战技能。这个平台主要提供以下功能和特点：实战演练：提供各种网络安全攻防演练场景，模拟真实的网络攻击事件，帮助用户在实际操作中掌握网络安全技术。
DM达梦数据日期时间函数、系统函数整理
菜鸟小码的博客
06-27 1064
达梦数据库作为国内领先的企业级数据库系统，提供了丰富的日期时间处理和系统信息获取函数。本文将详细介绍达梦数据库中几种关键的日期时间函数和系统函数，并通过实际的SQL示例来解析其用法
Postgresql从小白到高手 九 : psql高级查询及内部视图使用
simensk的博客
06-27 815
pgsql 内部视图，pg高级查询
PostgreSQL 基本SQL语法（二）
技术学习与分享
06-25 543
子句用于过滤数据，仅返回满足条件的记录。语句用于从数据库中检索数据。语句用于向表中插入数据。语句用于更新表中的数据。语句用于从表中删除数据。
SQL面试题练习 —— 查询前2大和前2小用户并有序拼接
hu_wei123的博客
07-01 153
根据年份分组，取出每年最大、第二大，最小、第二小用户ID。使用 if 对desc_rn，rn进行判断，对符合条件的数据取出 user_id，其他去null，然后使用聚合函数取出结果。有用户账户表，包含年份，用户id和值,请按照年份分组，取出值前两小和前两大对应的用户id，需要保持值最小和最大的用户id排首位。（2）根据年份分组，取出value最大user_id，第二大user_id，最小user_id，第二小user_id。（3）按照顺序拼接，得到最终结果。按照题目要求，进行字符拼接。
aop面向切面编程面试题
09-03
当谈到AOP（面向切面编程）时，以下是一些常见的面试问题： 1. 什么是AOP？它的用途是什么？ 2. AOP和OOP（面向对象编程）之间有什么区别？ 3. 在Java中，AOP的实现方式有哪些？请举例说明。 4. 什么是切面（Aspect）？切面由哪些组成？ 5. 在AOP中，切点（Pointcut）的作用是什么？如何定义一个切点？ 6. 什么是连接点（Joinpoint）？连接点在AOP中的作用是什么？ 7. 在AOP中，通知（Advice）有哪些类型？请描述它们的用途。 8. 什么是织入（Weaving）？它在AOP中的作用是什么？ 9. 在Spring框架中，如何使用AOP进行方法拦截？ 10. AOP的优点和缺点是什么？ 这些问题旨在考察你对AOP的理解和实际应用经验。确保你理解AOP的基本概念，并能够解释其在软件开发中的重要性和用途。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值