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

2024-01-22 12:12
文章标签 java 动态 实现 spring 代理 简介 aop srping

本文主要是介绍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 (切面) 分别在Class1和Class2的方法中加入了事务、日志、权限和异常等功能。

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

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

1.2 AOP术语

AOP术语包括 Aspect、Joinpoint、Pointcut、 Advice、 Target Object、Proxy 和 Weaving。具体讲解如下。

  • 一、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代理不用实现接口。）

  • Spring 中JDK动态代理的例子如 ：

第一步、在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包）

  • Spring 中JDK动态代理的例子如 ：
    第一步、在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*/@Overridepublic 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功能 )

  • ProxyFactoryBean是 FactoryBean接口的实现类，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("模拟记录日志...");}@Overridepublic 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();}
}

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

这篇关于Spring | Srping AOP (AOP简介、动态代理、基于“代理类”的AOP实现)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/632930。

相关文章

springboot健康检查监控全过程

springboot健康检查监控全过程

《springboot健康检查监控全过程》文章介绍了SpringBoot如何使用Actuator和Micrometer进行健康检查和监控,通过配置和自定义健康指示器,开发者可以实时监控应用组件的状态,... 目录1. 引言重要性2. 配置Spring Boot ActuatorSpring Boot Act
阅读更多...
使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)

使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)

《使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)》在现代软件开发中,处理JSON数据是一项非常常见的任务,无论是从API接口获取数据,还是将数据存储为JSON格式,解析... 目录1. 背景介绍1.1 jsON简介1.2 实际案例2. 准备工作2.1 环境搭建2.1.1 添加
阅读更多...
Java实现任务管理器性能网络监控数据的方法详解

Java实现任务管理器性能网络监控数据的方法详解

《Java实现任务管理器性能网络监控数据的方法详解》在现代操作系统中,任务管理器是一个非常重要的工具,用于监控和管理计算机的运行状态,包括CPU使用率、内存占用等,对于开发者和系统管理员来说,了解这些... 目录引言一、背景知识二、准备工作1. Maven依赖2. Gradle依赖三、代码实现四、代码详解五
阅读更多...
java如何分布式锁实现和选型

java如何分布式锁实现和选型

《java如何分布式锁实现和选型》文章介绍了分布式锁的重要性以及在分布式系统中常见的问题和需求,它详细阐述了如何使用分布式锁来确保数据的一致性和系统的高可用性,文章还提供了基于数据库、Redis和Zo... 目录引言：分布式锁的重要性与分布式系统中的常见问题和需求分布式锁的重要性分布式系统中常见的问题和需求
阅读更多...
SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

《SpringBoot基于MyBatis-Plus实现LambdaQuery查询的示例代码》MyBatis-Plus是MyBatis的增强工具,简化了数据库操作,并提高了开发效率,它提供了多种查询方... 目录引言基础环境配置依赖配置（Maven）application.yml 配置表结构设计demo_st
阅读更多...
在Ubuntu上部署SpringBoot应用的操作步骤

在Ubuntu上部署SpringBoot应用的操作步骤

《在Ubuntu上部署SpringBoot应用的操作步骤》随着云计算和容器化技术的普及,Linux服务器已成为部署Web应用程序的主流平台之一,Java作为一种跨平台的编程语言,具有广泛的应用场景,本... 目录一、部署准备二、安装 Java 环境1. 安装 JDK2. 验证 Java 安装三、安装 mys
阅读更多...
Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

《Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单》：本文主要介绍Springboot的ThreadPoolTaskScheduler线... 目录ThreadPoolTaskScheduler线程池实现15分钟不操作自动取消订单概要1，创建订单后
阅读更多...
JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

《JAVA中整型数组、字符串数组、整型数和字符串的创建与转换的方法》本文介绍了Java中字符串、字符数组和整型数组的创建方法,以及它们之间的转换方法,还详细讲解了字符串中的一些常用方法,如index... 目录一、字符串、字符数组和整型数组的创建1、字符串的创建方法1.1 通过引用字符数组来创建字符串1.2
阅读更多...
python使用watchdog实现文件资源监控

python使用watchdog实现文件资源监控

《python使用watchdog实现文件资源监控》watchdog支持跨平台文件资源监控,可以检测指定文件夹下文件及文件夹变动,下面我们来看看Python如何使用watchdog实现文件资源监控吧... python文件监控库watchdogs简介随着Python在各种应用领域中的广泛使用，其生态环境也
阅读更多...
el-select下拉选择缓存的实现

el-select下拉选择缓存的实现

《el-select下拉选择缓存的实现》本文主要介绍了在使用el-select实现下拉选择缓存时遇到的问题及解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的... 目录项目场景：问题描述解决方案：项目场景：从左侧列表中选取字段填入右侧下拉多选框，用户可以对右侧
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2