[Spring]-AOP

AOP场景

AOP: Aspect Oriented Programming (面向切面编程)

OOP: Object Oriented Programming (面向对象编程)

场景设计

  1. 设计: 编写一个计算器接口和实现类，提供加减乘除四则运算

  1. 需求: 在加减乘除运算的时候需要记录操作日志(运算前参数、运算后结果)
  2. 实现方案:
  • 硬编码
  • 静态代理
  • 动态代理
  • AOP

硬编码

使用硬编码的方式记录日志

  1. 创建工程环境: 新建模块, 加一个lombok依赖

  1. 新建计算器接口和实现类, 并在实现类中, 通过硬编码记录日志
package com.guigu.aop.calculator;// 定义四则运算
public interface MathCalculator {// 加法int add(int i, int b);// 减法int sub(int i, int b);// 乘法int mul(int i , int b);// 除法int div(int i, int b);
}

package com.guigu.aop.calculator.impl;/*** 计算器实现类* 1. 硬编码: 不推荐; 耦合:(通用逻辑 + 专用逻辑)希望不要耦合; 耦合太多就是维护地狱*/
@Component
public class MathCalculatorImpl implements MathCalculator {@Overridepublic int add(int i, int b) {System.out.println("[日志] add开始, 参数:" + i + "," + b);int res = i + b;System.out.println("[日志] add结束, 结果:" + res);return res;}@Overridepublic int sub(int i, int b) {return i -b;}@Overridepublic int mul(int i, int b) {return i * b;}@Overridepublic int div(int i, int b) {return  i / b;}
}
  1. 新建单元测试, 测试一下
package com.guigu.aop;@SpringBootTest
public class MathTest {@AutowiredMathCalculatorImpl mathCalculator;@Testvoid test01() {int add = mathCalculator.add(1, 9);}
}

静态代理

编码时介入: 包装真实对象，对外提供静态代理对象

实现步骤

  1. 包装被代理对象
  2. 实现被代理对象的接口
  3. 运行时调用被代理对象的真实方法
  4. 外部使用代理对象调用

优点

  • 实现简单

缺点

  • 需要为不同类型编写不同代理类，导致扩展维护性差

使用静态代理技术, 记录代码日志

package com.guigu.aop.proxy.statics;import com.guigu.aop.calculator.MathCalculator;
import lombok.Data;
import org.springframework.stereotype.Component;/*** 静态代理: 定义代理对象, 帮助目标对象完成一些工作*/
@Component
@Data
public class CalculatorStaticProxy implements MathCalculator {private MathCalculator target; // 目标对象public CalculatorStaticProxy(MathCalculator mc) {this.target = mc;}@Overridepublic int add(int i, int b) {System.out.println("[日志] add开始, 参数:" + i + "," + b);int res = target.add(i, b);System.out.println("[日志] add结束, 结果:" + res);return res;}@Overridepublic int sub(int i, int b) {return target.sub(i, b);}@Overridepublic int mul(int i, int b) {return target.mul(i, b);}@Overridepublic int div(int i, int b) {return target.div(i, b);}
}

package com.guigu.aop;@SpringBootTest
public class MathTest {@AutowiredCalculatorStaticProxy calculatorStaticProxy;@Testvoid test02() {int add = calculatorStaticProxy.add(2, 3);}
}

动态代理

运行时介入: 创建真实对象运行时代理对象

  1. 实现步骤
  • ·Java 反射提供 Proxy.newProxyInstance 的方式创建代理对象
  1. 优点:
  • 节约不同代理类的开发
  1. 缺点:
  • 开发难度大
  • 必须有接口，才能创建动态代理

使用动态代理技术, 记录代码日志

  1. 封装一个日志工具类, 提供记录日志的静态方法
package com.guigu.aop.log;public class LogUtils {public static void logStart(String name, Object... args) {System.out.println("[日志]: [" + name + "]开始, 参数:" + Arrays.toString(args));}public static void logEnd(String name) {System.out.println("[日志]: [" + name + "]结束");}public static void logException(String name, Throwable e) {System.out.println("[日志]: [" +name+ "]异常: 异常信息:" + e.getCause());}public static void logReturn(String name, Object result) {System.out.println("[日志]: [" + name + "]结束, 返回结果:" + result);}
}
  1. 创建动态代理类 封装一个静态方法, 可以传入任何对象, 返回代理对象
package com.guigu.aop.proxy.dynamic;/*** 动态代理* 1.是java原生支持的技术* 2.运行期间才决定代理关系, 类似于拦截器的思想* 3.目标对象在执行期间会被动态拦截, 可以插入指定逻辑* 4.优点: 可以代理任何对象* 5.缺点: 代码多* 6.强制要求: 目标对象必须有接口(否则报错), 代理的也只是接口规定的方法,*/
@Component
public class DynamicProxy {// 获取目标对象的代理对象public static Object getProxyInstance(Object target) {/*** Proxy是java反射包提供的类* 下面的方法可以创建对象的代理对象, 需要三个参数* Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)* 参数1: ClassLoader loader, 类加载器 (通过类加载器拿到目标对象)* 参数2: Class<?>[] interfaces, 目标对象实现的接口 (通过接口拿到目标对象实现的方法)* 参数3: InvocationHandler h, 代理对象需要执行的方法, 这个方法中可以插入指定逻辑*//*** 拦截方法说明:* 通过拦截方法, 可以拦截到目标对象方法的调用, 从而做任何事情*  (proxy, method, args)-> { }*  proxy: 代理对象*  method: 准备执行的目标对象的方法*  args: 方法调用传递的参数*/return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),(proxy, method, args)-> {String name = method.getName();// 记录开始LogUtils.logStart(name, args);Object result = null;try {result = method.invoke(target, args); // 执行目标对象的方法// 记录返回值LogUtils.logReturn(name, result);} catch (Exception e) {// 记录异常LogUtils.logException(name, e);} finally {// 记录结束LogUtils.logEnd(name);}return result;});}
}
  1. 使用动态代理类的方法创建代理对象
package com.guigu.aop;@SpringBootTest
public class MathTest {@AutowiredMathCalculatorImpl mathCalculator;@AutowiredDynamicProxy dynamicProxy;@Testvoid test03() {MathCalculator instance =(  MathCalculator) dynamicProxy.getProxyInstance(mathCalculator);instance.add(3,5);}
}

AOP使用

了解AOP的术语

AOP基本使用步骤

  1. 导入AOP依赖
    <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>
  1. 编写切面Aspect
package com.guigu.aop.aspect;@Component
@Aspect // 告诉spring这个组件是一个切面
public class LogAspect {}
  1. 编写通知方法
package com.guigu.aop.aspect;@Component
@Aspect // 告诉spring这个组件是一个切面
public class LogAspect {public void logStart() {System.out.println("[切面-日志]开始...");}public void logEnd() {System.out.println("[切面-日志]结束...");}public void logReturn() {System.out.println("[切面-日志]返回结果");}public void logException() {System.out.println("[切面-日志]爬出抛出异常:");}
}
  1. 指定切入点表达式
package com.guigu.aop.aspect;import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Component
@Aspect // 告诉spring这个组件是一个切面
public class LogAspect {/*** 告诉Spring, 以下通知何时何地生效?* 何时?*   通知方法:*   @Before: 方法执行前运行*   @AfterReturning: 方法执行正常返回结果运行*   @AfterThrowing: 方法抛出异常时运行*   @After: 方法执行之后运行*  何地:*    切入点表达式:*       1. execution(方法的全签名)*       作用: 根据方法匹配切入点*       全写法: [public] int [com.guigu.aop.calculator].add(int, int) [throws ArithmeticException]*       省略写法: int add(int, int)*       通配符:*          *: 表示任意字符*         ..: 表示多个参数, 任意类型*       最省略: * *(..)*/@Before("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void logStart() {System.out.println("[切面-日志]开始...");}@After("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void logEnd() {System.out.println("[切面-日志]结束...");}@AfterReturning("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void logReturn() {System.out.println("[切面-日志]返回结果");}@AfterThrowing("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void logException() {System.out.println("[切面-日志]爬出抛出异常:");}
}
  1. 测试AOP动态织入
package com.guigu.aop;import com.guigu.aop.calculator.MathCalculator;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;@SpringBootTest
public class AopTest {@Autowired // 容器中注入的是  MathCalculator 的代理对象MathCalculator mathCalculator;@Testvoid test01() {System.out.println(mathCalculator.getClass()); // 看看代理对象mathCalculator.add(10, 20);}
}

AOP细节

切入点表达式

切入点表达式的写法

package com.guigu.aop.annotation;import java.lang.annotation.*;// 自定义接口
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAn {
}

package com.guigu.aop.calculator.impl;import com.guigu.aop.annotation.MyAn;
import com.guigu.aop.calculator.MathCalculator;
import org.springframework.stereotype.Component;/*** 计算器实现类* 1. 硬编码: 不推荐; 耦合:(通用逻辑 + 专用逻辑)希望不要耦合; 耦合太多就是维护地狱*/
@Component
public class MathCalculatorImpl implements MathCalculator {@Overridepublic int add(int i, int b) {int res = i + b;return res;}@Overridepublic int sub(int i, int b) {return i -b;}@Overridepublic int mul(int i, int b) {return i * b;}@MyAn@Overridepublic int div(int i, int b) {return  i / b;}
}

package com.guigu.aop.aspect;import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Component
@Aspect // 告诉spring这个组件是一个切面
public class LogAspect {/*** 告诉Spring, 以下通知何时何地生效?* 何时?*   @Before: 方法执行前运行*   @AfterReturning: 方法执行正常返回结果运行*   @AfterThrowing: 方法抛出异常时运行*   @After: 方法执行之后运行*  何地:*    切入点表达式:*       1. execution(方法的全签名)*       作用: 根据方法匹配切入点*       全写法: [public] int [com.guigu.aop.calculator].add(int, int) [throws ArithmeticException]*       省略写法: int add(int, int)*       通配符:*          *: 表示任意字符*         ..: 表示多个参数, 任意类型*       最省略: * *(..)*       2. args(参数类型或其子类型)*       作用: 根据方法的参数匹配切入点*       3. annotation(注解类型)*       作用: 根据方法的注解匹配切入点, 一般配合自定义注解使用*/@Before("args(int, int)")public void logHaha() {System.out.println("[切面-日志]哈哈...");}@Before("@annotation(com.guigu.aop.annotation.MyAn)")public void logHehe() {System.out.println("[切面-日志]呵呵...");}
}

package com.guigu.aop;@SpringBootTest
public class AopTest {@Autowired // 容器中注入的是  MathCalculator 的代理对象MathCalculator mathCalculator;@Testvoid test02() {// 根据方法的参数匹配切入点mathCalculator.add(1, 2);// 测试方法的注解匹配切入点mathCalculator.div(1, 2);}
}

执行顺序

AOP 的底层原理

1、Spring会为每个被切面切入的组件创建代理对象(Spring CGLIB 创建的代理对象，无视接口)。

2、代理对象中保存了切面类里面所有通知方法构成的增强器链。

3、目标方法执行时，会先去执行增强器链中拿到需要提前执行的通知方法去执行

通知方法的执行顺序

  1. 正常链路: 前置通知->目标方法->返回通知->后置通知
  2. 异常链路: 前置通知->目标方法->异常通知->后置通知

连接点信息

通过 JoinPoint 包装了当前目标方法的所有信息

通过 returning 属性可以接收当前方法的返回值

通过 throwing 属性可以接收当前方法的异常信息

package com.guigu.aop.aspect;@Component
@Aspect // 告诉spring这个组件是一个切面
public class LogAspect {@Before("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void logStart(JoinPoint joinPoint) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();// 获取方法的参数值Object[] args = joinPoint.getArgs();System.out.println("【切面- 日志】【" + name + "】开始:参数列表:【" + Arrays.toString(args) + "】");}@After("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void logEnd(JoinPoint joinPoint) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("[切面-日志] " + name + "结束...");}@AfterReturning(value = "execution(int com.guigu.aop.calculator.MathCalculator.*(..))",returning = "result")public void logReturn(JoinPoint joinPoint, Object result) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("【切面 -日志】【" + name + "】返回:值:" + result);}@AfterThrowing(value = "execution(int com.guigu.aop.calculator.MathCalculator.*(..))",throwing = "e")public void logException(JoinPoint joinPoint, Exception e) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("【切面 - 日志】【" + name + "】异常:错误信息:【" + e.getMessage() + "】");}}

抽取切入点表达式

使用@Pointcut 注解抽取切入点表达式

package com.guigu.aop.aspect;@Component
@Aspect // 告诉spring这个组件是一个切面
public class LogAspect {@Pointcut("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void pointCut(){};@Before("pointCut()")public void logStart(JoinPoint joinPoint) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();// 获取方法的参数值Object[] args = joinPoint.getArgs();System.out.println("【切面- 日志】【" + name + "】开始:参数列表:【" + Arrays.toString(args) + "】");}@After("pointCut()")public void logEnd(JoinPoint joinPoint) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("[切面-日志] " + name + "结束...");}@AfterReturning(value = "pointCut()",returning = "result")public void logReturn(JoinPoint joinPoint, Object result) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("【切面 -日志】【" + name + "】返回:值:" + result);}@AfterThrowing(value = "pointCut()",throwing = "e")public void logException(JoinPoint joinPoint, Exception e) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("【切面 - 日志】【" + name + "】异常:错误信息:【" + e.getMessage() + "】");}}

多切面的执行顺序

默认情况下, 切面方法的执行顺序受切面类的首字母排序影响

通过 Order 注解可以指定切面类的优先级

package com.guigu.aop.aspect;@Order(1) // 数值越小, 优先级越高, 执行越早
@Component
@Aspect
public class LogAspect {@Pointcut("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void pointCut(){};@Before("pointCut()")public void logStart(JoinPoint joinPoint) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();// 获取方法的参数值Object[] args = joinPoint.getArgs();System.out.println("【切面- 日志】【" + name + "】开始:参数列表:【" + Arrays.toString(args) + "】");}@After("pointCut()")public void logEnd(JoinPoint joinPoint) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("[切面-日志] " + name + "结束...");}@AfterReturning(value = "pointCut()",returning = "result")public void logReturn(JoinPoint joinPoint, Object result) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("【切面 -日志】【" + name + "】返回:值:" + result);}@AfterThrowing(value = "pointCut()",throwing = "e")public void logException(JoinPoint joinPoint, Exception e) {// 拿到方法全签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法名String name = signature.getName();System.out.println("【切面 - 日志】【" + name + "】异常:错误信息:【" + e.getMessage() + "】");}
}

package com.guigu.aop.aspect;@Component
@Aspect
public class AuthAspect {@Pointcut("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void pointCut(){};@Before("pointCut()")public void authStart() {System.out.println("[切面-权限] 开始");}@After("pointCut()")public void authEnd() {System.out.println("[切面-权限] 结束");}@AfterReturning("pointCut()")public void authReturn() {System.out.println("【切面 -权限】 返回");}@AfterThrowing("pointCut()")public void authException() {System.out.println("【切面 - 权限】 异常");}}

package com.guigu.aop;@SpringBootTest
public class AopTest {@Testvoid test04() {mathCalculator.add(1, 2);}
}

环绕通知

环绕通知可以控制目标方法是否执行, 修改目标方法的参数和执行结果

package com.guigu.aop.aspect;@Aspect
@Component
public class AroundAspect {/*** 环绕通知的固定写法如下* Object: 返回值* ProceedingJoinPoint: 可以继续推进的切入点*/@Pointcut("execution(int com.guigu.aop.calculator.MathCalculator.*(..))")public void pointCut(){};@Around("pointCut()")public Object around(ProceedingJoinPoint pjp) throws Throwable {// 获取目标方法的参数Object[] args = pjp.getArgs();System.out.println("[切面-环绕前置]: 参数" + Arrays.toString(args));Object proceed = null;try {// 继续执行目标方法proceed = pjp.proceed(args);System.out.println("[切面-环绕返回]: 返回值" + proceed);} catch (Throwable e) {System.out.println("[切面-环绕异常]: 异常信息" + e.getMessage());throw e; // 抛出异常, 让别人继续感知, 否则异常会被吃掉, 影响后面的程序} finally {System.out.println("[切面-环绕后置]");}// 目标方法执行完毕，返回结果return proceed;}
}

package com.guigu.aop;@SpringBootTest
public class AopTest {@Autowired // 容器中注入的是  MathCalculator 的代理对象MathCalculator mathCalculator;@Testvoid test04() {mathCalculator.add(1, 2);}
}

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

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

相关文章

Web3 借贷与清算机制全解析：链上金融的运行逻辑

Web3 借贷与清算机制全解析：链上金融的运行逻辑

Web3 借贷与清算机制全解析&#xff1a;链上金融的运行逻辑 超额抵押借款 例如&#xff0c;借款人用ETH为抵押借入DAI&#xff1b;借款人的ETH的价值一定是要超过DAI的价值&#xff1b;借款人可以任意自由的使用自己借出的DAI 稳定币 第一步&#xff1a;借款人需要去提供一定…
阅读更多...
RK3588开发笔记-GNSS-RTK模块调试

RK3588开发笔记-GNSS-RTK模块调试

目录 前言 一、什么是GNSS/RTK 二、硬件连接 三、内核配置 四、模块调试 五、ntripclient使用 总结 前言 在RK3588平台上集成高精度定位功能是许多工业级应用的需求。本文记录了我调试GNSS-RTK模块的全过程，包含硬件连接、驱动移植、数据解析和精度优化等关键环节，希望对…
阅读更多...
Vue.js $emit的介绍和简单使用

Vue.js $emit的介绍和简单使用

前言 在 Vue.js 开发中&#xff0c;组件化是核心思想之一。但组件间的通信是一个重要课题&#xff0c;特别是子组件向父组件传递数据的场景。Vue 提供了多种通信方式&#xff0c;而$emit正是实现子→父通信的关键方法。本文将深入解析$emit的原理、使用场景及最佳实践。 一、$e…
阅读更多...
【Linux 学习计划】-- 简易版shell编写

【Linux 学习计划】-- 简易版shell编写

目录 思路 创建自己的命令行 获取用户命令 分割命令 检查是否是内建命令 cd命令实现 进程程序替换执行程序 总代码 结语 思路 int main() {while (1){// 1. 自己的命令行PrintCommandLine();// 2. 获取用户命令char command[SIZE];int n GetUserCommand(command, si…
阅读更多...
一个完整的日志收集方案:Elasticsearch + Logstash + Kibana+Filebeat (二)

一个完整的日志收集方案:Elasticsearch + Logstash + Kibana+Filebeat (二)

&#x1f4c4; 本地 Windows 部署 Logstash 连接本地 Elasticsearch 指南 ✅ 目标 在本地 Windows 上安装并运行 Logstash配置 Logstash 将数据发送至本地 Elasticsearch测试数据采集与 ES 存储流程 &#x1f9f0; 前提条件 软件版本要求安装说明Java17Oracle JDK 下载 或 O…
阅读更多...
Java使用Selenium反爬虫优化方案

Java使用Selenium反爬虫优化方案

当我们爬取大站的时候&#xff0c;就得需要对抗反爬虫机制的场景&#xff0c;因为项目要求使用Java和Selenium。Selenium通常用于模拟用户操作&#xff0c;但效率较低&#xff0c;所以需要我们结合其他技术来实现高效。 在 Java 中使用 Selenium 进行高效反爬虫对抗时&#xff…
阅读更多...
状态管理方案对比与决策

状态管理方案对比与决策

1. 状态管理的基本概念 现代前端应用随着功能复杂度提升&#xff0c;状态管理已成为架构设计的核心挑战。状态管理本质上解决的是数据的存储、变更追踪和响应式更新问题&#xff0c;以确保UI与底层数据保持同步。 核心挑战: 状态共享与组件通信可预测的状态变更性能优化与重…
阅读更多...
Fetch与Axios：区别、联系、优缺点及使用差异

Fetch与Axios：区别、联系、优缺点及使用差异

Fetch与Axios&#xff1a;区别、联系、优缺点及使用差异 文章目录 Fetch与Axios&#xff1a;区别、联系、优缺点及使用差异一、联系二、区别1. 浏览器支持与兼容性2. 响应处理3. 请求拦截和响应拦截4. 错误处理 三、优缺点1. Fetch API优点缺点 2. Axios优点缺点 四、使用上的差…
阅读更多...
【Docker】快速入门与项目部署实战

【Docker】快速入门与项目部署实战

我们在部署一个项目时&#xff0c;会出现一系列问题比如&#xff1a; 命令太多了&#xff0c;记不住软件安装包名字复杂&#xff0c;不知道去哪里找安装和部署步骤复杂&#xff0c;容易出错 其实上述问题不仅仅是新手&#xff0c;即便是运维在安装、部署的时候一样会觉得麻烦…
阅读更多...
Java面试题尚硅谷版第1季

Java面试题尚硅谷版第1季

1、写出如下代码运行结果 1.1、 使用局部变量表和操作数栈解题 1.2、使用前置和后置递增解题 2、写一个单例模式 2.1、考察知识点 2.2、单例模式实现 3、类加载和初始化顺序 package classload;public class Father {private int i test();private static int j method();st…
阅读更多...
关于Qt阻断样式继承的解决办法

关于Qt阻断样式继承的解决办法

引言 在使用 Qt 开发桌面应用时&#xff0c;借助样式表&#xff08;StyleSheet&#xff09;来统一定义界面风格是非常常见的做法。通常&#xff0c;你会在主程序中通过 qApp->setStyleSheet(...) 或者直接给某个父控件设置样式表&#xff0c;让所有的子控件都采用相同的配色…
阅读更多...
鼠标右键添加新建某种文件的方法

鼠标右键添加新建某种文件的方法

场景 我经常用到.emmx&#xff0c;.eddx文件&#xff0c;电脑上装的是wpsX亿图&#xff08;因为有wps会员&#xff09;&#xff0c;没有开亿图会员。 然后问题就是&#xff0c;思维导图和流程图我都能正常开&#xff0c;正常编辑&#xff0c;但鼠标右键没有新建这两个文件的按…
阅读更多...
Inxpect安全雷达传感器与控制器：动态检测 + 抗干扰技术重构工业安全防护体系

Inxpect安全雷达传感器与控制器：动态检测 + 抗干扰技术重构工业安全防护体系

Inxpect 推出工业安全领域新型智能传感器与控制器&#xff0c;其核心产品为雷达扫描仪&#xff0c;具备动态调整检测区域、抗干扰能力强等特点&#xff0c;可精准检测危险区域人员进入或存在情况&#xff0c;适用于移动机器人等场景。 Inxpect安全雷达传感器核心功能 动态检测…
阅读更多...
【AI学习】李广密与阶跃星辰首席科学家张祥雨对谈：多模态发展的历史和未来

【AI学习】李广密与阶跃星辰首席科学家张祥雨对谈：多模态发展的历史和未来

仔细阅读了文章《专访张祥雨&#xff1a;多模态推理和自主学习是未来的 2 个 「GPT-4」 时刻》 https://mp.weixin.qq.com/s/892QuRPH9uP6zN6dS-HZMw 非常赞叹的一篇文章&#xff0c;说清楚了NLP、CV发展中的许多重大问题&#xff0c;读来醍醐灌顶&#xff01;这样的文章&…
阅读更多...
C++中std::deque详解和实战工程代码示例

C++中std::deque详解和实战工程代码示例

C中std::deque详解和实战工程代码示例 std::deque&#xff08;双端队列&#xff09;是 C 标准库中的一个序列容器&#xff0c;与 std::vector 类似&#xff0c;但它支持从头部和尾部高效地插入和删除元素。它底层采用分段连续空间实现&#xff0c;兼具灵活性与性能。 一、基本…
阅读更多...
【AI大模型入门指南】概念与专有名词详解 （二）

【AI大模型入门指南】概念与专有名词详解 （二）

【AI大模型入门指南】概念与专有名词详解 &#xff08;二&#xff09; 一 、前言 当你和聊天机器人聊得天花乱坠时&#xff0c;当你用文字让AI生成精美图片时&#xff0c;当手机相册自动帮你分类照片时 —— 这些看似智能的操作背后&#xff0c;都藏着 AI 大模型的身影。 本…
阅读更多...
AIStor 的模型上下文协议 (MCP) 服务器：管理功能

AIStor 的模型上下文协议 (MCP) 服务器：管理功能

在本系列的上一篇博文中&#xff0c;我们讨论了 MinIO AIStor 的模型上下文协议 (MCP) 服务器的基本用户级功能。我们学习了如何使用人类语言命令查看存储桶的内容、分析对象并标记它们以便将来处理&#xff0c;以及如何通过 LLM&#xff08;例如 Anthropic Claude&#xff09;…
阅读更多...
期权末日轮实值期权盈利未平仓怎么办？

期权末日轮实值期权盈利未平仓怎么办？

本文主要介绍期权末日轮实值期权盈利未平仓怎么办&#xff1f;期权末日轮实值期权盈利未平仓该怎么办&#xff0c;需要明确几个关键点&#xff1a;末日轮指的是期权到期日临近的时候&#xff0c;通常指最后一周&#xff0c;尤其是最后一天&#xff0c;这时候时间价值衰减很快&a…
阅读更多...
C++/Qt 联合编程中的定时器使用陷阱：QObject::startTimer 报错详解

C++/Qt 联合编程中的定时器使用陷阱：QObject::startTimer 报错详解

在 Qt 开发中&#xff0c;QTimer 是一个常用的工具类&#xff0c;用于处理定时事件。但不少开发者在 C/Qt 联合编程&#xff0c;尤其是在工具类、静态类、线程中使用定时器时&#xff0c;会遇到如下令人困惑的报错&#xff1a; QObject::startTimer: Timers can only be used …
阅读更多...
CentOS7.9 查询运维安全日志，排查恶意用户

CentOS7.9 查询运维安全日志，排查恶意用户

1、查看系统版本 cat /etc/redhat-release uname -a 2、查看所有账号 cat /etc/shadow 3、修改 root 密码 passwd 3、查看账号ID id jinzhi 4、查看登录日志 lastlog 5、查看操作日志 cat .bash_history sudo cat /home/yunwei/.bash_history sudo grep root /va…
阅读更多...
最新文章

Copyright @ 2022~2023