Spring | Srping AOP (AOP简介、动态代理、基于“代理类”的AOP实现)

目录:

    • 1.Spring AOP简介
      • 1.1 AOP简介
      • 1.2 AOP术语
    • 2.动态代理
      • 2.1 JDK动态代理
      • 2.2 CGLIB代理
    • 3.基于“代理类”的AOP实现
      • 3.1 Spring的通知类型
      • 3.2 ProxyFactoryBean ( 可通知.xml配置文件完成aop功能 )

1.Spring AOP简介

1.1 AOP简介

  • Spring的AOP模块,是Spring框架体系结构中十分重要的内容,该模块中提供了面向切面编程实现。

  • AOP的全称是 Aspect-Oriented Programming,即面向切面编程( 也称面向方面编程 )它是面向对象编程(OOP)的一种补充,目前已成为一种比较成熟的编程方式。
    在传统的业务处理代码中,通常都会进行事务处理日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用,但如果要实现某个功能(如日志记录),同样的代码仍然会分散到各个方法中。这样,如果想要关闭某个功能,或者对其进行修改,就必须要修改所有的相关方法。这不但增加了开发人员的工作量,而且提高了代码的出错率。

    (要实现AOP功能核心关键之一是 : “代理”,通过“代理”可以获得 “增强功能后的目标对象” ,从而实现AOP功能)

  • 为了解决这一问题,AOP思想随之产生。AOP采取横向抽取机制,将分散在各个方法中的重复代码 提取出来,然后在程序编译运行时,再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式,采用传统的O0P思想显然是无法办到的,因为00P只能实现父子关系纵向重用。虽然AOP是一种新的编程思想,但却不是O0P的替代品,它只是OOP的延伸和补充。

  • 在AOP思想中,类与切面的关系图 如下所示 :
    在这里插入图片描述

    从上图 (类与切面关系图)可以看出,通过Aspect (切面) 分别在Class1Class2方法中加入了事务日志权限异常等功能

  • AOP的使用,使开发人员在编写业务逻辑时可以专心于核心业务,而不用过多地关注其他业务逻辑的实现,这不但提高了开发效率,而且增强了代码的可维护性。

  • 目前最流行AOP框架有两个,分别为Spring AOPAspectJSpring AOP使用纯Java实现,不需要专门的编译过程和类加载器,在运行期间通过代理方式向目标类织入增强的代码。
    AspectJ是一个基于Java语言的AOP框架,从Spring 2.0开始,Spring AOP引入了对AspectJ的支持,AspectJ扩展了Java语言,提供了一个专门的编译器,在编译时提供横向代码织入

1.2 AOP术语

AOP术语包括 AspectJoinpointPointcutAdviceTarget ObjectProxyWeaving。具体讲解如下。

  • 一、Aspect ( 切面 ) :
    实际应用
    中,切面通常是指封装的用于横向插入系统功能 (如事务日志等) 的。如 “类与切面关系图” 的 Aspect。该 要被Spring容器识别为切面,需要在配置文件<bean>元素指定 (哪个将作为 切面)。
    切面 可以 理解为 “切面类”)

  • 二、Joinpoint ( 连接点 ) :
    在程序执行过程中的某个阶段点,它实际上是对象的一个操作
    例子如:方法的调用异常的抛出Spring AOP中,连接点就是指方法的调用 ( 非切面类的那个类的方法的调用)。

  • 三、Pointcut( 切入点 ) :
    是指切面程序流程交叉点,即那些 需要处理连接点 ( 即待处理的“ 方法的调用 ” )。
    通常在程序中,切入点指的是或者方法名
    例子如 :某个通知要应用到所有以add开头方法中,那么所有满足这一规则方法都是切入点

切面、连接点 和切入点关系图如下图所示” :

在这里插入图片描述

  • 四、Advice( 通知 / 增强处理 ) :
    AOP框架在特定的 切入点 ( /方法名 )执行的增强处理,即在定义好的切入点处所 要执行的程序代码
    可以将 ( Advice ) 理解为 切面中的方法Advice切面具体实现

  • 五、Target Object ( 目标对象 ) :
    是指所有 被通知对象,也称为被 增强对象。如果AOP框架采用的是动态的AOP实现,那么该对象就是一个被代理对象

  • 六、Weaving ( 织入 ) :
    切面类中代码插入到目标对象上,从而生成代理对象过程

  • 七、Proxy( 代理 ) :

    通知应用到目标对象之后,被动态创建对象 ,该对象称为“代理对象” / 增强功能后目标对象
    该对象可直接当目标对象使用。(Proxy (代理) 可理解为一个 过程,一个将目标对象 进行 增强,变为代理对象 / “增强功能后的目标对象过程。) ( 代理就是AOP框架动态生成的一个对象 )

  • 八、 Proxy Class (代理类) :
    实现“Proxy ( 代理 )功能”的。该类 (代理类) 中包含了 Proxy(代理)”所需的功能代码

  • 九、Proxy Object (代理对象) / 增强功能后目标对象:
    Proxy Object (代理对象) 称为 / 可理解为 “增强功能后目标对象” 。该对象可直接当 “目标对象” 使用。

    代理对象通常包含了目标对象的功能,同时在 原目标对象的基础上 添加一些额外的功能逻辑,例如日志记录、事务管理等,因此可以说,代理对象可以被理解为"增强功能后的目标对象“。

2.动态代理

  • AOP中的==代理就是由AOP框架动态生成的一个对象==,该对象可直接当目标对象使用。
    (此处的代理 : 就是上面提到过的 生成增强功能后的目标对象” 的代理)

  • Spring 中的AOP代理,有 JDK动态代理 CGLIB代理。(两者都是 “动态代理”)。
    ps :

    JDK动态代理CGlib代理都属于 动态代理

    JDK动态代理目标对象实现一个或多个接口,如果要对没有实现接口的目标类 / 目标对象 进行代理时,可用CGLIB代理

2.1 JDK动态代理

  • JDK动态代理 是通过java.lang.reflect.Proxy类来实现的,我们可以调用Proxy类的 newProxyInstance() 方法来创建代理对象。对于使用业务接口Sping 默认会使用JDK代理来实现AOP

    (JDK动态代理实现接口,CGLIB代理不用实现接口。)

  • SpringJDK动态代理的例子如 :

第一步、在DIEA中创建一个Java项目,添加web功能模块。

第二步、在项目WEB-INF目录中创建lib文件夹,存放Spring框架最基本核心的jar包,让jar包生效。

获取spring框架基本核心jar包

第三步、创建UserDao接口,在该接口中编写添加删除的方法 。
创建UserDao的实现类 UserDaoImpl,分别实现接口中的方法,并在每个方法中添加一条输出语句。
UserDao.java

public interface UserDao{

 public void addUser();

 public void deleteUser();
}

UserDaoImpl.java

public class UserDaoImpl implements UserDao { // ”目标类“,该类创建的对象为”目标对象“

@Override
public void addUser() {  //这方法将要被“增强处理”
    System.out.println("添加用户");
}

@Override
public void deleteUser() { //这方法将要被“增强处理”
    System.out.println("删除用户");
}
}

实现类UserDaoImpl作为 目标类 ,对其中的方法进行 增强处理

第四步、创建切面类MyAspect
在该类中定义一个模拟权限检查的方法和一个模拟记录日志方法,这两个方法就表示切面中的通知

public class MyAspect { //切面类 : 以下为两个通知,将用于为“目标对象”实现增强功能。

//通知 : 要执行的切面类”的方法”
//在特定的 “切入点” 进行增强处理 : 在“切入点”的前或后,执行切面类中的方法

public void check_Permissions() { //该方法即为“通知” : 切面类中的方法
    System.out.println("模拟检查权限...");
}

public void log() { //通知
    System.out.println("模拟记录日志...");
}

/*
   对某个方法(切入点)进制“增强处理” : 即在程序执行这个方法的“前或后”的时机执行"切面方法"(添加通知)
 */
}

第五步、创建 代理类 JdkProxy ,该类实现 InvocationHandler 接口,并编写代理方法。在代理方法中,需要通过Proxy实现动态代理

/**
   *  JDK代理类 (JdkProxy) : 将通知应用到目标对象之后,被动态创建的对象。
   *  代理对象 : 经过“代理”这一过程,生成的类即为“代理对象”,也称为“增强功能后的目标对象”
   *  (可以理解为: “代理” / "代理类"的目的之一 : 生成“代理对象”)
*/
public class JdkProxy implements InvocationHandler {

//声明目标类接口
private UserDao userDao;

//创建代理方法
public Object createProxy(UserDao userDao) {

    this.userDao = userDao;
    //1.类加载器 (JdkProxy的类加载器) ---获得JdkProxy对应的“类加载器”
    ClassLoader classLoader = JdkProxy.class.getClassLoader();
    //2.被代理对象实现的所有接口 (此处为: UserDao 的接口内容等。)
    Class[] clazz = userDao.getClass().getInterfaces();
    //3.使用代理类,进行增强,返回的是 ”代理后的对象“ / “增强功能后的目标对象”
    return Proxy.newProxyInstance(classLoader, clazz, this);
}

/**
       * @param proxy  被代理后的对象
       * @param method 将要执行的方法信息 (反射)
       * @param args   执行方法时需要的参数
       * @throws Throwable
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    /**
      声明切面类 (其中有要用在特定“切入点”的“通知”)
       切入点 : 要进行“增强处理”/被“通知” 的 方法名
       通知(也称“增强处理”): 切面类中的方法
       对切入点进行“增强处理” : 在某个方法被执行的前/后的时机执行切面中的“方法”
     */
    //创建切面类
    MyAspect myAspect = new MyAspect();

 /**
     *  目标方法执行的前后,会分别执行切面类中的 check_Permissions()方法 和 log()方法
     *  前增强 : 执行UserDao接口的方法之前先执行 切面类中的 check_Permissions()这个方法
     *  后增强 : 执行完接口的方法后执行log()这个方法
  */
    //前增强
    myAspect.check_Permissions();

    //在目标类上调用方法,并传入参数
    Object obj = method.invoke(userDao, args); //执行UserDao接口中的方法

    //后增强
    myAspect.log();

    return obj;
}
}

上述例子中,JdkProxy类 (代理类) 实现了 InvocationHandler 接口,并实现了接口中的 invoke方法,所有动态代理类调用的方法都会交由该 ( invoke) 方法处理。在创建的代理方法 createProxy()中使用了 Proxy 类的 newProxyInstance()方法来创建 代理对象newProxyInstance()方法中包含3个参数,其中第1个参数是当前类的类加载器,第2个参数表示的是被代理对象实现的所有接口,第3个参数this代表的就是代理类JdkProxy本身。在invoke()方法中,目标类方法执行的前后会分别执行切面类中的check _Permissions() 方法和 log() 方法。

第六步、创建测试类 JdkTest,在该类中的main()方法中创建代理对象目标对象,然后从代理对象中获得对目标对象userDao增强功能后的对象,最后调用该对象的添加和删除方法。

public class JdkTest {
public static void main(String[] args) {
    //实例化JdkProxy类(JDK代理类) : 该类能产生“代理对象”(增强功能的目标对象)
    JdkProxy jdkProxy = new JdkProxy();
    //创建目标对象
    UserDao userDao  = new UserDaoImpl();
    /*
      调用JdkProxy中的createProxy()方法获得“代理对象”
     */
    UserDao userDao1 = (UserDao)jdkProxy.createProxy(userDao);

    //指向UserDao中的两个方法,该UserDao已被进行AOP操作,其中方法执行的前后都会执行切面类中的方法
    userDao1.addUser();
    userDao1.deleteUser();
}
}

测试类运行结果
在这里插入图片描述

UserDao实例添加用户删除用户方法被成功调用,并且在调用前后分别添加了“权限检查”和“记录日志”的功能,这种实现了接口的代理方式,就是Spring中的JDK动态代理

2.2 CGLIB代理

  • JDK动态代理的使用简单,但它还有一定的局限性,使用 JDK动态代理对象必须实现一个或多个接口

    如果要对没有实现接口进行代理,那么可以使用 CGLIB代理。即目标类 / 目标对象没有实现任何接口时,可用CGLIB代理

    ps:
    JDK动态代理目标对象实现一个或多个接口,如果要对没有实现接口的目标类 / 目标对象 进行代理时,可用CGLIB代理

  • CGLIB ( Code Generation Library )是一个高性能开源代码生成包,它采用非常底层字节码技术,对指定的目标类生成一个子类并对子类进行增强。在Spring的核心包中已经集成CGLIB所需要的包,所以开发中不需要另外导入JAR包
    JDK动态代理CGLIB代理核心包就行,不需要额外的JAR包

  • SpringJDK动态代理的例子如 :
    第一步、在DIEA中创建一个Java项目,添加web功能模块。

    第二步、在项目WEB-INF目录中创建lib文件夹,存放Spring框架最基本核心的jar包,让jar包生效。

    获取spring框架基本核心jar包

    第三步、创建目标类 :UserDao,UserDao不需要实现任何接口,只需定义一个添加用户的方法 和 一个删除用户的方法。

    public class UserDao { //目标类,没实现任何接口,可用CGLIB代理
         public void addUser() {
    	        System.out.println("添加用户");
    	    }
        public void deleteUser() {
            System.out.println("删除用户");
        }
    }
    

    第四步、创建切面类MyAspect
    在该类中定义一个模拟权限检查的方法和一个模拟记录日志方法,这两个方法就表示切面中的通知

    public class MyAspect { //切面类 : 以下为两个通知,将用于为“目标对象”实现增强功能。
    
    //通知 : 要执行的切面类”的方法”
    //在特定的 “切入点” 进行增强处理 : 在“切入点”的前或后,执行切面类中的方法
    
    public void check_Permissions() { //该方法即为“通知” : 切面类中的方法
        System.out.println("模拟检查权限...");
    }
    
    public void log() { //通知
        System.out.println("模拟记录日志...");
    }
    
    /*
       对某个方法(切入点)进制“增强处理” : 即在程序执行这个方法的“前或后”的时机执行"切面方法"(添加通知)
     */
    }
    

    第五步、创建代理类CglibProxy,该代理类需要实现 MethodInterceptor 接口,并实现接口中的 intercept( ) 方法。

    import com.myh.cglib.aspect.MyAspect;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    import java.lang.reflect.Method;
    
    //代理类
    public class CglibProxy implements MethodInterceptor { //CGLIB代理 : 目标类不需要实现接口
    
        //代理方法
        public Object createProxy(Object target) { //创建“代理对象/增强后的目标对象”的方法
            //创建一个动态类对象 (Enhancer : 增强器)
            Enhancer enhancer = new Enhancer();
            //确定要增强的类,为Enhancer设置“父类”
            enhancer.setSuperclass(target.getClass());
            //添加回调函数
            enhancer.setCallback(this);
            //返回创建的代理类
            return enhancer.create();
        }
    
        /**
         * @param proxy CGlib指定“父类”生成的“代理对象”
         * @param method 拦截的方法
         * @param args   拦截方法的参数数组
         * @param methodProxy 方法的代理对象,用于执行父类的方法
         * @throws Throwable
         */
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
             //创建切面类对象
            MyAspect myAspect = new MyAspect();
            //前增强
            myAspect.check_Permissions();
            //目标方法的执行
            Object obj = methodProxy.invokeSuper(proxy, args); //执行"代理对象"的 “父类的方法”
            //后增强
            myAspect.log();
            return obj;
        }
    }
    

    CglibProxy类的代理方法中,首先创建了一个动态类对象Enhancer,它是CGLIB的核心类;然后调用了Enhancer类的 setSuperclass()方法来确定目标对象 (为动态类对象指定父类 );接下来调用了setCallback()方法添加回调函数,其中的this代表的就是代理类CglibProxy本身;最后通过return语句将创建的代理类对象返回intercept()方法会在程序执行目标方法时被调用,方法运行时将会执行切面类中的增强方法

    第六步
    创建测试类 CglibTest 在该类的main()方法中首先创建代理对象目标对象,然后从代理对象中获得增强后的目标对象,最后调用对象添加删除方法

    public class CglibTest {
        public static void main(String[] args) {
            //创建代理对象
            CglibProxy cglibProxy = new CglibProxy();
            //创建目标对象
            UserDao userDao = new UserDao();
            UserDao userDao1 = (UserDao)cglibProxy.createProxy(userDao);
            //执行方法
            userDao1.addUser();
            userDao1.deleteUser();
        }
    }
    

    测试类运行结果
    在这里插入图片描述

    从测试类结果可以看出,目标类UserDao中方法被成功调用增强了,这种 (目标类) 没有实现接口的代理方式,就是CGLIB代理

3.基于“代理类”的AOP实现

  • 动态代理中的 JDK动态代理CGLIB代理都是基于“代理类”的AOP实现
  • Spring中的 AOP代理默认使用 的是 JDK动态代理
  • Spring中使用 ProxyFactoryBean创建 AOP代理最基本的方式

3.1 Spring的通知类型

Spring 中的 通知 按照在 目标类方法连接点位置,可以分为以下5种类型

  • org.aopalliance.intercept.MethodInterceptor (环绕通知) :
    目标方法执行前后实施增强,可以应用于日志事务管理等功能。
  • org.springframework. aop.MethodBeforeAdvice (前置通知)
    目标方法执行实施增强,可以应用于权限管理等功能。
  • org.springframework. aop.AfterReturningAdvice (后置通知)
    目标方法执行实施增强,可以应用于关闭流上传文件删除临时文件等功能
  • org.springframework.aop.ThrowsAdvice (异常通知) :
    方法抛出异常后实施增强,可以应用于处理异常记录日志等功能。
  • org.springframework.aop.IntroductionInterceptor (引介通知)
    目标类中添加一些新方法属性,可以应用于修改老版本程序(增强类)。

3.2 ProxyFactoryBean ( 可通知.xml配置文件完成aop功能 )

  • ProxyFactoryBeanFactoryBean接口实现类FactoryBean负责实例化一个Bean
    ProxyFactoryBean负责为其他Bean创建代理实例。在Spring中,使用ProxyFactoryBean 是 创建AOP代理基本方式

  • ProxyFactoryBean类中的常用可配置属性如下表所示 :

    属性名称描述
    target代理目标对象
    proxyInterfaces代理要实现接口,如果是多个接口,可以使用**以下格式赋值
    <list>
    <value></value>

    </list>
    proxyTargetClass是否对类代理不是接口,设置为true时,使用CGLIB代理.
    (设置为true表示是对类代理,自然是用 CGLIB代理
    interceptorNames需要织入目标Advice
    singleton返回的代理是否为单实例默认true (即返回单实例)
    optimize当设置为true时,强制使用CGLIB
  • ProxyFactoryBean类有了初步的了解后,接下来通过一个典型的环绕通知案例,来演示Spring使用ProxyFactoryBean创建AOP代理的过程,例子如下
    第一步
    核心JAR包的基础上,项目的lib目录导入AOP的两个JAR包①spring-aop.jar②aopalliance.jar
    spring-aop.jar : 是Spring为实现AOP功能提供的JAR包
    aopalliance.jar : 是AOP联盟提供的规范包,是实现AOP功能所需JAR包

    Spring核心jar + aop有关的jar

    第二步、创建UserDao接口,在该接口中编写添加删除的方法 。
    创建UserDao的实现类 UserDaoImpl,分别实现接口中的方法,并在每个方法中添加一条输出语句。
    UserDao.java

    public interface UserDao{
    
     public void addUser();
    
     public void deleteUser();
    }
    

    UserDaoImpl.java

    public class UserDaoImpl implements UserDao { // ”目标类“,该类创建的对象为”目标对象“
    
    @Override
    public void addUser() {  //这方法将要被“增强处理”
        System.out.println("添加用户");
    }
    
    @Override
    public void deleteUser() { //这方法将要被“增强处理”
        System.out.println("删除用户");
    }
    }
    

    实现类UserDaoImpl作为 目标类 ,对其中的方法进行 增强处理

    第三步
    创建切面类MyAspect。由于实现环绕通知需要实现 org. aopalliance.intercept.MethodInterceptor接口,所以MyAspect需要实现该接口,并实现接口中的 invoke() 方法,来执行目标方法
    MyAspect.java

    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    //切面类
    public class MyAspect implements MethodInterceptor { //切面类,该切面类实现了aopalliance包下的 MethodInterceptor(环绕通知)接口
    
        public void check_Permission() { //切面方法 (通知)
            System.out.println("模拟权限检查...");
        }
    
        public void log() { //切面方法 (通知)
            System.out.println("模拟记录日志...");
        }
    
        @Override
        public Object invoke(MethodInvocation mi) throws Throwable {
            /*
            在目标方法执行的前后,分別执行了“检查权限” 和 “记录日志”的方法,这两个方法也就是“增强的方法”,也就是通知。
            */ 
            check_Permission();
            //执行目标方法
            Object obj = mi.proceed();
            log();
            return obj;
        }
    }
    

    第四步
    创建配置文件applicationContext.xml,并指定对象

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <!--  1.目标类 (把对象放入IOC容器中,作为Bean)-->
        <bean id="userDao" class="com.myh.factorybean.UserDaoImpl"/>
    
        <!--  2.切面类 -->
        <bean id="myAspect" class="com.myh.factorybean.MyAspect"/>
    
        <!--  3.使用Spring代理工厂定义一个名称为: userDaoProxy 的代理对象 -->
        <bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定“代理实现的接口”  -->
            <property name="proxyInterfaces" value="com.myh.factorybean.UserDao"/>
            <!-- 指定“目标对象”  -->
            <property name="target" ref="userDao"/>
            <!-- 指定“切面”,植入环绕通知  -->
            <property name="interceptorNames" value="myAspect"/>
            <!-- 指定代理方式,true : 使用cglib, false(默认) : 使用jdk动态代理  -->
            <property name="proxyTargetClass" value="true"/>
        </bean>
    </beans>
    

    上述配置文件代码中,首先通过 <bean>元素定义了目标类切面,然后使用 ProxyFactoryBean类定义了代理对象。在定义的代理对象中,分别通过 <property>子元素指定了①代理实现的接口切代理、②目标对象、③需要织入目标类的通知以及④代理方式

    第五步

    创建ProxyFactoryBeanTest 测试类,在类中通过Spring容器获取代理对象的实例,并执行目标方法

    package com.myh.factorybean;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class ProxyFactoryBeanTest { //测试类
        public static void main(String[] args) {
            String xmlPath = "com/myh/factorybean/applicationContext.xml";
            //创建ApplicationContext (从其中获取IOC容器中的Bean)
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            //从IOC容器中获得“代理对象”
            UserDao userDao = (UserDao) applicationContext.getBean("userDaoProxy"); //获得“增强功能后的目标对象”
            //执行目标方法
            userDao.addUser();
            userDao.deleteUser();
        }
    }
    

    测试类运行结果如下
    在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【C++】list容器迭代器的模拟实现

list容器内部基本都是链表形式实现&#xff0c;这里的迭代器实现的逻辑需要注意C语言中指针的转换。 list容器如同数据结构中的队列&#xff0c;通常用链式结构进行存储。在这个容器中&#xff0c;我们可以模仿系统的逻辑&#xff0c;在头结点后设置一个“ 哨兵 ”&#xff0c;…

什么勒索攻击,应该如何防护?

当前&#xff0c;勒索攻击、僵尸网络攻击、DDos攻击、APT攻击、挖矿攻击、供应链攻击、网站攻击、电信诈骗等各种攻击手段层出不穷。 勒索攻击应该是今年网络安全行业讨论最多的话题&#xff0c;勒索钱财或者窃取商业数据是黑产最主要的目的。 勒索软件的攻击特征 与其它攻击行…

限价单和止损单是什么?澳福实例讲解

什么是限价单和止损单&#xff0c;投资者如何使用它?了解交易基础知识&#xff0c;快速进入市场盈利收场&#xff0c;今天fpmarkets澳福和各位投资者继续探讨交易基础知识。 止损单是在看涨趋势中以更高的价格买入的前提&#xff0c;通过图表得知&#xff0c;黄线显示欧元兑美…

刷题 ------ 排序

文章目录 1.K 次取返后最大化的数组和&#xff08;堆&#xff09;2.数组的相对排序&#xff08;桶&#xff09;3.最小绝对差4.根据数字二进制下1的数目排序&#xff08;qsort&#xff09;5.有多少小于当前数字的数字6.非递增顺序的最小子序列7.按照频率将数组升序排序&#xff…

生成当天递增唯一的流水号的几种方式

说明&#xff1a;当开发中&#xff0c;如交易、文件传输过程中的文件名&#xff0c;可能需要我们使用一串唯一的数字来锁定这一条“交互记录”&#xff0c;即流水号。 本文介绍几种生成6位递增唯一&#xff0c;且每日重置的流水号的方式。 方式一&#xff1a;使用Redis 我们…

Leetcode—22.括号生成【中等】

2023每日刷题&#xff08;七十九&#xff09; Leetcode—22.括号生成 算法思想 实现代码 class Solution { public:vector<string> generateParenthesis(int n) {vector<string> ans;int m n * 2;string path(m, 0);function<void(int, int)> dfs [&…

自己构建webpack+vue3+ts

先看看我的目录结构&#xff08;我全局使用TS&#xff09;&#xff1a; 一、安装配置webpack打包 安装esno npm install esnoesno 是基于 esbuild 的 TS/ESNext node 运行时,有了它&#xff0c;就可以直接通过esno *.ts的方式启动脚本&#xff0c;package.json中添加 type:…

力扣62. 不同路径

动态规划 思路&#xff1a; 定义 dp[r][c] 为到达坐标 (r, c) 的路径数&#xff1a; 它只能有同一行左边相邻方格向右到达或者同一列上方相邻方格向下到达&#xff1b;状态转移方程&#xff1a; dp[r][c] dp[r][c - 1] dp[r - 1][c]初始状态 dp[0][0] 1第一行的路径数是 1第…

二维码地址门牌管理系统:社区新风向

文章目录 前言一、集成先进技术的系统二、便捷居民体验三、支持社区管理四、未来展望与可扩展性 前言 随着科技的不断发展&#xff0c;智能化管理已经深入到我们的生活中。二维码门牌管理系统作为一款创新产品&#xff0c;在社区管理领域迅速引起广泛关注。这款系统不仅提升了…

CTFhub-bak文件

CTFhub-Web-信息泄露-备份文件下载-bak文件 题目信息 解题过程 看到提示说和index.php有关&#xff0c;在url后面加index.php.bak&#xff0c;跳转到http://challenge-7a4da2076cfabae6.sandbox.ctfhub.com:10800/index.php.bak网址&#xff0c;即&#xff1a; 跳转到下载页…

彻底搞定让人头痛的nginx location 路径匹配规则

nginx location 路径匹配规则 一、前言二、说在前面三、开始表演 一、前言 很多同学&#xff0c;在配置nginx的时候&#xff0c;都会遇到一个头痛的问题&#xff0c;就是location 的路径应该怎么写&#xff1f;到底要不要加斜杠&#xff0c;有点傻傻分不清楚。今天就来帮助大家…

蓝桥杯真题(Python)每日练Day3

题目 题目分析 为了找到满足条件的放置方法&#xff0c;可以带入总盘数为2和3的情景&#xff0c;用递归做法实现。 A中存在1 2两个盘&#xff0c;为了实现最少次数放入C且上小下大&#xff0c;先将1放入B&#xff0c;再将2放入C&#xff0c;最后将1放入C即可。同理当A中存在1 …

柔性数组和C语言内存划分

柔性数组和C语言内存划分 1. 柔性数组1.1 柔性数组的特点&#xff1a;1.2 柔性数组的使用1.3 柔性数组的优势 2. 总结C/C中程序内存区域划分 1. 柔性数组 也许你从来没有听说过柔性数组&#xff08;flexible array)这个概念&#xff0c;但是它确实是存在的。 C99 中&#xff…

以太坊账户地址与比特B地址生成方法对比

作者 张群&#xff08;赛联区块链教育首席讲师&#xff0c;工信部赛迪特聘资深专家&#xff0c;CSDN认证业界专家&#xff0c;微软认证专家&#xff0c;多家企业区块链产品顾问&#xff09;关注张群&#xff0c;为您提供一站式区块链技术和方案咨询。 以太坊和比特B地址在生成方…

C语言——内存函数介绍和模拟实现(memcpy、memmove、memset、memcmp)

之前我们讲过一些字符串函数&#xff08;http://t.csdnimg.cn/ZcvCo&#xff09;&#xff0c;今天我们来讲一讲几个内存函数&#xff0c;那么可能有人要问了&#xff0c;都有字符串函数了&#xff0c;怎么又来个内存函数&#xff0c;这不是一样的么&#xff1f; 我们要知道之前…

【C语言】指针进阶之sizeof和strlen函数的对比

目录 1.sizeofyu 2.strlen函数 3.sizeof与strlen的对比 1.sizeof >>sizeof计算变量所占内存内存空间 大小 的&#xff0c;单位是 字节 &#xff0c;如果操作数是类型的话&#xff0c;计算的是使⽤类型创建的变量所占内存空间的大小。 >>sizeof 只关注占⽤内存空…

Spring5系列学习文章分享---第一篇(概述+特点+IOC原理+IOC并操作之bean的XML管理操作)

目录 Spring&#xff08;概述特点IOC原理IOC并操作之bean的XML管理操作&#xff09;概述Spring是轻量级的开源的JavaEE框架Spring可以解决企业应用开发的复杂性Spring有两个核心部分ioc,aopSpring特点 loc(概念和原理)什么是 IOCIOC 底层原理IOC 过程图 IOC&#xff08;接口&am…

Java和Redis实现一个简单的热搜功能

1. 前言 我们有一个简单的需求&#xff1a; 搜索栏展示当前登陆的个人用户的搜索历史记录&#xff0c;删除个人历史记录。用户在搜索栏输入某字符&#xff0c;则将该字符记录下来 以zset格式存储的redis中&#xff0c;记录该字符被搜索的个数以及当前的时间戳 &#xff08;用…

阿里云优惠整理,最新2024阿里云优惠政策解读

阿里云优惠政策有哪些&#xff1f;2024年阿里云优惠政策风向改了&#xff0c;之前一直是老用户与狗的营销策略&#xff0c;今年阿里云2核2G、3M固定带宽服务器99元居然开启了老用户购买权限&#xff0c;并且续费不涨价&#xff0c;阿里云这波操作确实让用户赢麻了&#xff0c;在…

MBR扇区修复和GRUB引导修复实验

修复MBR扇区 步骤一&#xff1a;在进行实验之前我们需要新加一块磁盘&#xff0c;并对新加磁盘进行分区处理&#xff0c;用来备份sda磁盘的MBR及分区表信息。&#xff08;注&#xff1a;在实验中可以不像我如此这么繁琐&#xff0c;一个主分区&#xff0c;并格式化挂载即可&am…