Spring AOP 详解

news2024/9/24 7:14:36

Spring AOP 详解

  • 一、什么是 Spring AOP
  • 二、为何要用 AOP
  • 三、Spring AOP
    • 3.1 AOP 组成
      • 3.1.1 切面 (Aspect)
      • 3.1.2 连接点 (Join Point)
      • 3.1.3 切点 (Pointcut)
      • 3.1.4 通知 / 增强方法 (Advice)
      • 3.1.5 小结
    • 3.2 Spring AOP 使用
      • 3.2.1 添加 AOP 框架支持
      • 3.2.2 定义切面和切点
      • 3.2.3 定义相关通知
      • 3.2.4 验证
    • 3.3 Spring AOP 实现原理
  • 四、总结

一、什么是 Spring AOP

在介绍 Spring AOP 之前，⾸先要了解⼀下什么是 AOP？

AOP (Aspect Oriented Programming)：⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的集中处理。 比如⽤户登录权限的效验，没学 AOP 之前，我们所有需要判断⽤户登录的⻚⾯ (中的⽅法)，都要各⾃实现或调⽤⽤户验证的⽅法，然⽽有了 AOP 之后，我们只需要在某⼀处配置⼀下，所有需要判断⽤户登录页面 (中的⽅法) 就全部可以实现⽤户登录验证了，不再需要每个⽅法中都写相同的⽤户登录验证了。

AOP 是⼀种思想，而 Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。

在这里插入图片描述

二、为何要用 AOP

想象⼀个场景，我们在做后台系统时，除了登录和注册等几个功能不需要做⽤户登录验证之外，其他几乎所有页面调用的前端控制器（ Controller）都需要先验证⽤户登录的状态，那这个时候我们要怎么处理呢？

我们之前的处理⽅式是每个 Controller 都要写⼀遍用户登录验证，然⽽当你的功能越来越多，那么你要写的登录验证也越来越多，⽽这些⽅法⼜是相同的，这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢？答案是有的，对于这种功能统一，且使用的地方较多的功能，就可以考虑 AOP 来统一处理了。

除了统⼀的用户登录判断之外，AOP 还可以实现：

  • 统⼀⽇志记录
  • 统⼀⽅法执⾏时间统计
  • 统⼀的返回格式设置
  • 统⼀的异常处理
  • 事务的开启和提交等

也就是说使用 AOP 可以扩充多个对象的某个能力，所以 AOP 可以说是 OOP（Object Oriented Programming，⾯向对象编程）的补充和完善。

三、Spring AOP

Spring AOP 学习主要分为以下 3 个部分：

  1. 学习 AOP 是如何组成的？也就是学习 AOP 组成的相关概念。
  2. 学习 Spring AOP 使用。
  3. 学习 Spring AOP 实现原理。

下⾯我们分别来看。

3.1 AOP 组成

3.1.1 切面 (Aspect)

切面（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。

切⾯是包含了：通知、切点和切⾯的类，相当于 AOP 实现的某个功能的集合。

3.1.2 连接点 (Join Point)

应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为。

连接点相当于需要被增强的某个 AOP 功能的所有⽅法。

3.1.3 切点 (Pointcut)

Pointcut 是匹配 Join Point 的谓词。

Pointcut 的作⽤就是提供⼀组规则（使⽤ AspectJ pointcut expression language 来描述）来匹配 Join Point，给满⾜规则的 Join Point 添加 Advice。

切点相当于保存了众多连接点的⼀个集合（如果把切点看成⼀个表，⽽连接点就是表中⼀条⼀条的数据）。

3.1.4 通知 / 增强方法 (Advice)

切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中，切面的工作被称之为通知。

通知：定义了切⾯是什么，何时使⽤，其描述了切⾯要完成的⼯作，还解决何时执⾏这个⼯作的问题。

Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤：

  • 前置通知使⽤ @Before：通知⽅法会在⽬标⽅法调⽤之前执⾏。
  • 后置通知使⽤ @After：通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤。
  • 返回之后通知使⽤ @AfterReturning：通知⽅法会在⽬标⽅法返回后调⽤。
  • 抛异常后通知使⽤ @AfterThrowing：通知⽅法会在⽬标⽅法抛出异常后调⽤。
  • 环绕通知使⽤ @Around：通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为。

切点相当于要增强的方法。

AOP 整个组成部分的概念如下图所示，以多个⻚⾯都要访问⽤户登录权限为例：
在这里插入图片描述

3.1.5 小结

在这里插入图片描述

3.2 Spring AOP 使用

接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能，完成的⽬标是拦截所有 UserController ⾥⾯的⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件。

Spring AOP 的实现步骤如下：

  1. 添加 Spring AOP 框架⽀持
  2. 定义切⾯和切点
  3. 定义通知

3.2.1 添加 AOP 框架支持

在 pom.xml 中添加如下配置：

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

3.2.2 定义切面和切点

切点指的是具体要处理的某⼀类问题，⽐如⽤户登录权限验证就是⼀个具体的问题，记录所有⽅法的执行日志就是⼀个具体的问题，切点定义的是某⼀类问题。

Spring AOP 切点的定义如下，在切点中我们要定义拦截的规则，具体实现如下：

package com.example.demo.aop;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 登录的 AOP 实现代码
 */
@Component
@Aspect // 标识当前类为一个切面
public class LoginAOP {

    // 定义切点（拦截的规则）
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut() {
    }

}

其中 pointcut ⽅法为空⽅法，它不需要有⽅法体，此⽅法名就是起到⼀个“标识”的作⽤，标识下⾯的
通知⽅法具体指的是哪个切点（因为切点可能有很多个）。

切点表达式说明
AspectJ ⽀持三种通配符：
* ：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）
.. ：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使⽤。
+ ：表示按照类型匹配指定类的所有类，必须跟在类名后⾯，如 com.cad.Car+ ,表示继承该类的所有子类包括本身
切点表达式由切点函数组成，其中 execution() 是最常⽤的切点函数，⽤来匹配⽅法，语法为：
execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)
在这里插入图片描述
修饰符和异常可以省略，具体含义如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
表达式示例：
execution(* com.cad.demo.User.*(..)) ：匹配 User 类⾥的所有⽅法。
execution(* com.cad.demo.User+.*(..)) ：匹配该类的⼦类包括该类的所有⽅法。
execution(* com.cad.*.*(..)) ：匹配 com.cad 包下的所有类的所有⽅法。
execution(* com.cad..*.*(..)) ：匹配 com.cad 包下、⼦孙包下所有类的所有⽅法。
execution(* addUser(String, int)) ：匹配 addUser ⽅法，且第⼀个参数类型是 String，第⼆个参数类型是 int。

3.2.3 定义相关通知

通知定义的是被拦截的⽅法具体要执⾏的业务，⽐如⽤户登录权限验证⽅法就是具体要执⾏的业务。
Spring AOP 中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤：

  • 前置通知使⽤@Before：通知⽅法会在目标方法调⽤之前执行。
  • 后置通知使⽤@After：通知⽅法会在目标方法返回或者抛出异常后调用。
  • 返回之后通知使⽤@AfterReturning：通知方法会在目标方法返回后调用。
  • 抛异常后通知使⽤@AfterThrowing：通知方法会在目标方法抛出异常后调用。
  • 环绕通知使⽤@Around：通知包裹了被通知的方法，在被通知的⽅法通知之前和调用之后执行⾃定义的行为。

具体实现如下：

package com.example.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 登录的 AOP 实现代码
 */
@Component
@Aspect // 标识当前类为一个切面
public class LoginAOP {

    // 定义切点（拦截的规则）
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut() {
    }

    // 前置通知
    @Before("pointcut()")
    public void doBefore() {
        System.out.println("执行了前置通知");
    }

    // 后置通知
    @After("pointcut()")
    public void doAfter() {
        // 后置通知实现的具体业务代码
        System.out.println("执行了后置通知");
    }

    // 环绕通知
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object result = null;
        // 前置业务代码
        System.out.println("环绕通知的前置执行方法");
        try {
            // 执行目标方法
            result = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        // 后置业务执行代码
        System.out.println("环绕通知的后置执行方法");
        return result;
    }

}

经过以上的代码我们就能实现 Spring AOP 了。

3.2.4 验证

提前对 UserController 类中的 getall 方法进行一系列封装：

package com.example.demo.controller;

import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/getall")
    public List<UserInfo> getUsers() {
        System.out.println("执行了 UserController.getUsers 方法");
        return userService.getAll();
    }
}

package com.example.demo.service;

import com.example.demo.mapper.UserMapper;
import com.example.demo.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public List<UserInfo> getAll(){
        return userMapper.getAll();
    }
}

package com.example.demo.mapper;

import com.example.demo.model.UserInfo;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper // mybaits 接口，此注解一定不能忽略
public interface UserMapper {
    // 查询所有的信息
    public List<UserInfo> getAll();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="getAll" resultType="com.example.demo.model.UserInfo">
        select * from userinfo
    </select>
</mapper>

通过 http://localhost:8080/user/getall 访问，控制台：

在这里插入图片描述
(环绕通知在最外层~)

3.3 Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的支持局限于方法级别的拦截。

Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。

  • 默认情况下，实现了接口的类，使用 AOP 会基于 JDK ⽣成代理类；
  • 没有实现接⼝的类，会基于 CGLIB ⽣成代理类。

在这里插入图片描述

织入（Weaving）：代理的生成时机
织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对象中。
在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊：

  • 编译期：切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的。
  • 类加载期：切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器（ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊（load-time weaving.LTW）就⽀持以这种⽅式织⼊切⾯。
  • 运⾏期：切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为目标对象动态创建⼀个代理对象。SpringAOP就是以这种方式织入切面的。

动态代理
此种实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动态的织⼊字节码。
我们学习 Spring 框架中的AOP，主要基于两种⽅式：JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法，在运⾏期，动态的织⼊字节码⽣成代理类。

  • CGLIB是Java中的动态代理框架，主要作⽤就是根据⽬标类和⽅法，动态⽣成代理类。
  • Java中的动态代理框架，⼏乎都是依赖字节码框架（如 ASM，Javassist 等）实现的。
  • 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码⽂件信息，修改部
    分信息，或动态⽣成⼀个 class。

JDK 动态代理实现
JDK 实现时，先通过实现 InvocationHandler 接⼝创建⽅法调⽤处理器，再通过 Proxy 来创建代理类。

以下为代码实现：

import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//动态代理：使⽤JDK提供的api（InvocationHandler、Proxy实现），此种⽅式实现，要求被
代理类必须实现接⼝
public class PayServiceJDKInvocationHandler implements InvocationHandler {

    //⽬标对象即就是被代理对象
    private Object target;

    public PayServiceJDKInvocationHandler( Object target) {
        this.target = target;
    }

    //proxy代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }
    public static void main(String[] args) {
        PayService target= new AliPayService();
        //⽅法调⽤处理器
        InvocationHandler handler =
                new PayServiceJDKInvocationHandler(target);
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                handler
        );
        proxy.pay();
    }
}

CGLIB 动态代理实现
CGLIB 实现时，先通过实现 MethodInterceptor 接⼝创建⽅法调⽤处理器，再通过 Enhancer 来创建代理类。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.Method;
public class PayServiceCGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;

    public PayServiceCGLIBInterceptor(Object target){
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过cglib的代理⽅法调⽤
        Object retVal = methodProxy.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target= new AliPayService();
        PayService proxy= (PayService) Enhancer.create(target.getClass(),new PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}

JDK 和 CGLIB 实现的区别

  1. JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完成。
  2. CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的⽣成代理类对象 (三方框架，一般性能有优势)。

四、总结

AOP 是对某⽅⾯能⼒的统⼀实现，它是⼀种实现思想，Spring AOP 是对 AOP 的具体实现，Spring AOP 可通过 AspectJ (注解) 的方式来实现 AOP 的功能，Spring AOP 的实现步骤是：

  1. 添加 AOP 框架⽀持。
  2. 定义切⾯和切点。
  3. 定义通知。

Spring AOP 是通过动态代理的⽅式，在运⾏期将 AOP 代码织⼊到程序中的，它的实现⽅式有两种：JDK Proxy 和 CGLIB。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python---字典相关知识

Python---字典相关知识

专栏&#xff1a;python 个人主页&#xff1a;HaiFan. 专栏简介&#xff1a;本专栏主要更新一些python的基础知识&#xff0c;也会实现一些小游戏和通讯录&#xff0c;学时管理系统之类的&#xff0c;有兴趣的朋友可以关注一下。 字典思维导图字典是什么创建字典查找键key字典的…
阅读更多...
十分钟入门Zigbee

十分钟入门Zigbee

大部分教程通常都是已Zigbee原理开始讲解和学习&#xff0c;各种概念让初学者难以理解。本教程从一个小白的角度出发&#xff0c;入门无需任何Zigbee底层原理知识&#xff0c;只需要基本的MCU研发经验就可以掌握&#xff0c;让您快速实现zigbee组网和节点之间通信。 本教程采用…
阅读更多...
JDBC快速入门，如何使用JDBC操作数据库？

JDBC快速入门，如何使用JDBC操作数据库？

文章目录1. 前言2. JDBC 概述2.1 概念2.2 优点3. JDBC 快速入门Java编程基础教程系列1. 前言 在 Java 开发中&#xff0c;使用 Java 语言操作数据库是非常重要的一部分&#xff0c;那么 Java 语言是如何操作数据库的呢&#xff1f;我们需要使用不同厂商的数据库时&#xff0c;…
阅读更多...
23种设计模式（二十二）——访问者模式【行为变化】

23种设计模式（二十二）——访问者模式【行为变化】

文章目录 意图什么时候使用访问者真实世界类比访问者模式的实现访问者模式的优缺点亦称：Visitor 意图 封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于其内部各个元素的新操作。 什么时候使用访问者 1、如果你需要对一个复杂对象…
阅读更多...
Redis脑裂为何会导致数据丢失？

Redis脑裂为何会导致数据丢失？

1 案例 主从集群有1个主库、5个从库和3个哨兵实例&#xff0c;突然发现客户端发送的一些数据丢了&#xff0c;直接影响业务层数据可靠性。 最终排查发现是主从集群中的脑裂问题导致&#xff1a;主从集群中&#xff0c;同时有两个主节点都能接收写请求。 影响 客户端不知道应…
阅读更多...
Python数模笔记-模拟退火算法（5）求解旅行商问题的联合算子模拟退火算法

Python数模笔记-模拟退火算法（5）求解旅行商问题的联合算子模拟退火算法

Python数模笔记—求解旅行商问题的联合算子模拟退火算法&#xff08;完整例程&#xff09; 文章目录Python数模笔记—求解旅行商问题的联合算子模拟退火算法&#xff08;完整例程&#xff09;0 摘要1 引言2 模拟退火算法求解旅行商问题2.1 模拟退火算法2.2 多个新解的竞争机制2…
阅读更多...
详解P431 塔防

详解P431 塔防

题目说明gsy 最近在玩一个塔防游戏&#xff0c;但是这次她控制的是迷宫中的怪兽而非防御塔建造者游戏的地图是一个 n * m 的矩阵&#xff0c;起点在 (1,1) &#xff0c;终点在 (n,m) &#xff0c;gsy 每次可以选择上下左右四个方向移动 1 步这个地图上有很多的防御塔&#xff0…
阅读更多...
“华为杯”研究生数学建模竞赛2005年-【华为杯】B题：空中加油问题的讨论（附获奖论文及C++代码）

“华为杯”研究生数学建模竞赛2005年-【华为杯】B题：空中加油问题的讨论（附获奖论文及C++代码）

赛题描述 对飞行中的飞机进行空中加油，可以大大提高飞机的直航能力。为了简化问题，便于讨论，我们作如下假设。 少辅机架数两种情况给出你的作战方案。 论文 一． 问题重述 空中加油技术可以大大提高飞机的直航能力。作战飞机称为主机，加油机称 为辅机。已知：（ 1 ）主…
阅读更多...
[创业之路-50] ：动态股权机制 -5- 创业公司股权分配常见的坑

[创业之路-50] ：动态股权机制 -5- 创业公司股权分配常见的坑

1、 分工不清晰&#xff0c;决策不清晰&#xff0c;理念不一致分工必须要简单明晰初创公司的合伙人一般是三到五个&#xff0c;最合理的架构一开始最好是三个人&#xff0c;相互之间需要一段时间的磨合&#xff0c;了解清楚各自的特长&#xff0c;工作经历等等&#xff0c;不要…
阅读更多...
微信小程序开发uni-app

微信小程序开发uni-app

一、uni-app简介官网&#xff1a;https://uniapp.dcloud.io/PC端&#xff1b;移动端&#xff1a;&#xff08;APP&#xff0c;WebApp&#xff09;&#xff1b;纯原生&#xff1a;&#xff08;IOS,Android &#xff09; 应用商店&#xff1b;H5Hybrid 模式&#xff08;混合&…
阅读更多...
活动星投票最美农商人网络评选微信的投票方式线上免费投票

活动星投票最美农商人网络评选微信的投票方式线上免费投票

“最美农商人”网络评选投票_视频投票的相关评选_投票统计_微信不记名免费评选投票用户在使用微信投票的时候&#xff0c;需要功能齐全&#xff0c;又快捷方便的投票小程序。而“活动星投票”这款软件使用非常的方便&#xff0c;用户可以随时使用手机微信小程序获得线上投票服务…
阅读更多...
树莓派Python虚拟环境、PyQt5、PySide2

树莓派Python虚拟环境、PyQt5、PySide2

要从头设置好一台可用于开发的树莓派&#xff0c;可以参考树莓派 4B 无屏幕&#xff0c;连接WiFi、SSH、VNC&#xff0c;系统换源、pip换源&#xff0c;安装中文输入法 Python虚拟环境 树莓派&#xff08;或者说arm平台&#xff09;使用Python虚拟环境的正确方式是使用pipenv…
阅读更多...
【MyBatis】| 使⽤javassist⽣成类、面向接口的方式进行CRUD

【MyBatis】| 使⽤javassist⽣成类、面向接口的方式进行CRUD

目录 一&#xff1a;使⽤javassist⽣成类 1. Javassist的使⽤ 2. 动态生成类并实现接口 3. MyBatis中接⼝代理机制及使⽤ 二&#xff1a;面向接口的方式进行CRUD 一&#xff1a;使⽤javassist⽣成类 Javassist是⼀个开源的分析、编辑和创建Java字节码的类库。是由东京⼯业⼤…
阅读更多...
SSH原理与运用

SSH原理与运用

SSH原理与运用 SSH原理与运用&#xff08;一&#xff09;&#xff1a;远程登录 SSH原理与运用&#xff08;二&#xff09;&#xff1a;远程操作与端口转发 一. 什么是SSH&#xff1f; 简单说&#xff0c;SSH是一种网络协议&#xff0c;用于计算机之间的加密登录。需要指出的…
阅读更多...
7个流行的强化学习算法及代码实现

7个流行的强化学习算法及代码实现

目前流行的强化学习算法包括 Q-learning、SARSA、DDPG、A2C、PPO、DQN 和 TRPO。 这些算法已被用于在游戏、机器人和决策制定等各种应用中&#xff0c;并且这些流行的算法还在不断发展和改进&#xff0c;本文我们将对其做一个简单的介绍。 1、Q-learning Q-learning&#xff1…
阅读更多...
23种设计模式（十九）——迭代器模式【数据结构】

23种设计模式（十九）——迭代器模式【数据结构】

文章目录 意图什么时候使用迭代器真实世界类比迭代器模式的实现迭代器模式的优缺点亦称：Iterator 意图 提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。 什么时候使用迭代器 1、当集合背后为复杂的数据结构， 且你希望对客户端隐藏其复杂性时 …
阅读更多...
[QMT]05-获取基础行情信息

[QMT]05-获取基础行情信息

函数&#xff1a;获取合约基础信息get_instrument_detail(stock_code)1释义获取合约基础信息参数stock_code - string 合约代码返回 dict 数据字典&#xff0c;{ field1 : value1, field2 : value2, ... }&#xff0c;找不到指定合约时返回NoneExchangeID - string 合约市场代码…
阅读更多...
零基础学JavaWeb开发（二十）之 spring框架（3）

零基础学JavaWeb开发（二十）之 spring框架（3）

SpringBean的AOP 1、AOP基本的概念 AOP(Aspect Oriented Programming)是一种面向切面的编程思想。面向切面编程是将程序抽象成各个切面&#xff0c;即解剖对象的内部&#xff0c;将那些影响了多个类的公共行为抽取到一个可重用模块里&#xff0c;减少系统的重复代码&#xff…
阅读更多...
二叉树知识锦囊（三）

二叉树知识锦囊（三）

作者&#xff1a;爱塔居 专栏&#xff1a;数据结构​​​​​​ 作者简介&#xff1a;大三学生&#xff0c;希望和大家一起进步&#xff01; 目录 前言 1. 检查两棵树是否相同。 2. 另一颗树的子树。 3. 翻转二叉树。 4. 判断一颗二叉树是否是平衡二叉树。 5. 对称二叉树。 前…
阅读更多...
【Python】Python数据结构之布尔类型（bool）

【Python】Python数据结构之布尔类型（bool）

目录&#xff1a;Python数据结构之布尔类型&#xff08;bool&#xff09;一、布尔说明二、判定三、布尔运算&#xff1a; and, or, not一、布尔说明 Python 中布尔值使用常量True 和 False来表示&#xff1b;注意大小写。比较运算符< > 等返回的类型就是bool类型&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023