十二、面向切面编程AOP

news2024/11/15 19:29:10

IoC使软件组件松耦合。AOP让你能够捕捉系统中经常使用的功能，把它转化成组件。

AOP（Aspect Oriented Programming）：面向切面编程，面向方面编程。（AOP是一种编程技术）
AOP是对OOP的补充延伸。

AOP底层使用的就是动态代理来实现的。

Spring的AOP使用的动态代理是：JDK动态代理 + CGLIB动态代理技术。Spring在这两种动态代理中灵活切换，如果是代理接口，会默认使用JDK动态代理，如果要代理某个类，这个类没有实现接口，就会切换使用CGLIB。当然，你也可以强制通过一些配置让Spring只使用CGLIB。

1 AOP介绍

一般一个系统当中都会有一些系统服务，例如：日志、事务管理、安全等。这些系统服务被称为：交叉业务

这些交叉业务几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日志、事务管理、安全，这些都是需要做的。

如果在每一个业务处理过程当中，都掺杂这些交叉业务代码进去的话，存在两方面问题：

     第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务代码没有得到复用。并且修改这些交叉业务代码的话，需要修改多处。

     第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务。
使用AOP可以很轻松的解决以上问题。
AOP的思想：

在这里插入图片描述

用一句话总结AOP：将与核心业务无关的代码独立的抽取出来，形成一个独立的组件，然后以横向交叉的方式应用到业务流程当中的过程被称为AOP。
AOP的优点：
● 第一：代码复用性增强。
● 第二：代码易维护。
● 第三：使开发者更关注业务逻辑。

2 AOP的七大术语

public class UserService{
    public void do1(){
        System.out.println("do 1");
    }
    public void do2(){
        System.out.println("do 2");
    }
    public void do3(){
        System.out.println("do 3");
    }
    public void do4(){
        System.out.println("do 4");
    }
    public void do5(){
        System.out.println("do 5");
    }
    // 核心业务方法
    public void service(){
        try{
            // Joinpoint连接点
            do1(); // Pointcut切点
            // Joinpoint连接点
            do2(); // Pointcut切点
            // Joinpoint连接点
            do3(); // Pointcut切点
            // Joinpoint连接点
            do5(); // Pointcut切点
            // Joinpoint连接点
        } catch (Exception e){
            // Joinpoint连接点
        } finally {
            // Joinpoint连接点
        }
    }
}
// 1. 连接点(Joinpoint)描述的是位置
// 2. 切点(Pointcut)本质上就是方法(真正织入切面的那个方法叫做切点)
// 3. 通知(Advice),通知又叫做增强。就是具体增强的那个代码
//           例如: 具体的事务代码, 日志代码, 安全代码
//           具体的这个代码是通知
//           通知描述的是代码
// 4. 切面: 切点 + 通知
  • 连接点 Joinpoint
    • 在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后等位置。
  • 切点 Pointcut
    • 在程序执行流程中，真正织入切面的方法。（一个切点对应多个连接点）
  • 通知 Advice
    • 通知又叫增强，就是具体你要织入的代码。
    • 通知包括：
      • 前置通知
      • 后置通知
      • 环绕通知
      • 异常通知
      • 最终通知
  • 切面 Aspect
    • 切点 + 通知就是切面。
  • 织入 Weaving
    • 把通知应用到目标对象上的过程。
  • 代理对象 Proxy
    • 一个目标对象被织入通知后产生的新对象。
  • 目标对象 Target
    • 被织入通知的对象。
      在这里插入图片描述

3 切点表达式

切点表达式用来定义通知（Advice）往哪些方法上切入。
切入点表达式语法格式：

execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])

访问控制权限修饰符：

  • 可选项。
  • 没写，就是4个权限都包括。
  • 写public就表示只包括公开的方法。

返回值类型：

  • 必填项。
  • * 表示返回值类型任意。

全限定类名：

  • 可选项。
  • 两个点“..”代表当前包以及子包下的所有类。
  • 省略时表示所有的类。

方法名：

  • 必填项。
  • *表示所有方法。
  • set*表示所有的set方法。

形式参数列表：

  • 必填项
  • () 表示没有参数的方法
  • (..) 参数类型和个数随意的方法
  • (*) 只有一个参数的方法
  • (*, String) 第一个参数类型随意，第二个参数是String的。

异常：

  • 可选项。
  • 省略时表示任意异常类型。

理解以下的切点表达式：

service包下所有的类中以delete开始的所有方法

execution(public * com.powernode.mall.service.*.delete*(..))

mall包下所有的类的所有的方法

execution(* com.powernode.mall..*(..))

所有类的所有方法

execution(* *(..))

4 使用Spring的AOP

Spring对AOP的实现包括以下3种方式：

  • 第一种方式：Spring框架结合AspectJ框架实现的AOP，基于注解方式。
  • 第二种方式：Spring框架结合AspectJ框架实现的AOP，基于XML方式。
  • 第三种方式：Spring框架自己实现的AOP，基于XML配置方式。

使用Spring+AspectJ的AOP需要引入依赖

<dependencies>
    <!--spring context依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.2</version>
    </dependency>
    <!--spring aspects依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>6.0.2</version>
    </dependency>
</dependencies>

Spring配置文件中添加context命名空间和aop命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

1 基于AspectJ的AOP注解式开发

定义目标类以及目标方法

package com.powernode.spring6.service;

import org.springframework.stereotype.Service;

/**
 * 目标类
 */
@Service("userService")
public class UserService {
    // 目标方法
    public void login(){
        System.out.println("正在登录");

        /*if (1 == 1){
            throw new RuntimeException("运行时异常");
        }*/
    }
}

定义切面类

通知类型

通知类型包括：

  • 前置通知：@Before 目标方法执行之前的通知
  • 后置通知：@AfterReturning 目标方法执行之后的通知
  • 环绕通知：@Around 目标方法之前添加通知，同时目标方法执行之后添加通知。
  • 异常通知：@AfterThrowing 发生异常之后执行的通知
  • 最终通知：@After 放在finally语句块中的通知
package com.powernode.spring6.service;

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

/**
 * 切面
 */
@Component("logAspect")
// 使用@Aspect注解标注切面类
@Aspect
public class LogAspect {
    // 切面 = 通知 + 切点

    // 通知就是增强，具体的要编写的增强代码
    // @Before标注的方法就是一个前置通知
    // 括号里写切点表达式
    @Before("execution(* com.powernode.spring6.service.UserService.*(..))")
    public void beforeAdvice(){
        System.out.println("前置通知");
    }

    // 后置通知
    @AfterReturning("execution(* com.powernode.spring6.service.UserService.*(..))")
    public void afterReturningAdvice(){
        System.out.println("后置通知");
    }
    // 环绕通知(环绕是最大的通知，在前置通知之前，在后置通知之后)
    @Around("execution(* com.powernode.spring6.service.UserService.*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前面代码
        System.out.println("前环绕");
        // 执行目标
        joinPoint.proceed();
        // 后面代码
        System.out.println("后环绕");
    }

    // 异常通知
    @AfterThrowing("execution(* com.powernode.spring6.service.UserService.*(..))")
    public void afterThrowingAdvice(){
        System.out.println("异常通知");
    }


    // 最终通知(finally语句块中的通知)
    @After("execution(* com.powernode.spring6.service.UserService.*(..))")
    public void afterAdvice(){
        System.out.println("最终通知");
    }
}

在spring配置文件中添加组建扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--组件扫描-->
    <context:component-scan base-package="com.powernode.spring6.service"/>

    <!--开启aspectj的自动代理-->
    <!--spring容器在扫描类的时候，查看该类上是否有@Aspect注解 ，有，则给这个类生成代理-->
    <!--
        proxy-target-class="true" 表示强制使用CGLIB动态代理
        proxy-target-class="false" 默认值，表示接口使用JDK动态代理，反之使用CGLIB动态代理
    -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

<aop:aspectj-autoproxy proxy-target-class=“true”/> 开启自动代理之后，凡事带有@Aspect注解的bean都会生成代理对象。
proxy-target-class=“true” 表示采用cglib动态代理。
proxy-target-class=“false” 表示采用jdk动态代理。默认值是false。即使写成false，当没有接口的时候，也会自动选择cglib生成代理类。

测试

package com.powernode.spring6.test;

import com.powernode.spring6.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAOPTest {
    @Test
    public void testBefore(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.login();
    }
}

在这里插入图片描述
放开目标方法中的异常：
在这里插入图片描述
当发生异常之后，最终通知也会执行，因为最终通知@After会出现在finally语句块中。
出现异常之后，后置通知和环绕通知的结束部分不会执行。

切面的先后顺序

多个切面，可能有的切面控制事务，有的记录日志，有的进行安全控制，如果多个切面的话，顺序如何控制：可以使用@Order注解来标识切面类，为@Order注解的value指定一个整数型的数字，数字越小，优先级越高。

/**
 * 切面
 */
@Component("logAspect")
// 使用@Aspect注解标注切面类
@Aspect
@Order(0)
public class LogAspect {
}
定义通用切点表达式
/**
 * 切面
 */
@Component("logAspect")
// 使用@Aspect注解标注切面类
@Aspect
@Order(0)
public class LogAspect {
    // 定义通用的切点表达式
    @Pointcut("execution(* com.powernode.spring6.service.UserService.*(..))")
    public void Point(){
        // 这个方法只是一个标记，方法名随意，方法体也不需要写代码
    }

    // 前置通知
    @Before("Point()")
    public void beforeAdvice(){
        System.out.println("前置通知");
    }

非本类中使用

package com.powernode.spring6.service;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 安全切面
 */
@Aspect
@Component
@Order(1)
public class SecurityAspect {
    @Before("com.powernode.spring6.service.LogAspect.Point()")
    public void beforeAdvice(){
        System.out.println("安全前置通知");
    }
}
全注解式开发AOP

就是编写一个类，在这个类上面使用大量注解来代替spring的配置文件

package com.powernode.spring6.service;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

// 代替spring.xml文件
@Configuration
// 组件扫描
@ComponentScan({"com.powernode.spring6.service"})
// 启用aspectj的自动代理
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class Spring6Config {
}

测试

@Test
public void testNoXMl(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Config.class);
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.login();
}

2 基于XML配置方式的AOP

编写目标类

package com.powernode.spring6.service.xml;
// 目标对象
public class OrderService {
    // 目标方法
    public void logout(){
        System.out.println("正在退出");
    }
}

编写切面类，并且编写通知

package com.powernode.spring6.service.xml;

import org.aspectj.lang.ProceedingJoinPoint;

// 切面
public class TimerAspect {
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前环绕
        long begin = System.currentTimeMillis();
        // 目标
        joinPoint.proceed();
        // 后环绕
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }
}

编写spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--纳入spring ioc-->
    <bean id="orderService" class="com.powernode.spring6.service.xml.OrderService"/>
    <bean id="timerAspect" class="com.powernode.spring6.service.xml.TimerAspect"/>

    <!--aop配置-->
    <aop:config>
        <!--切点表达式-->
        <aop:pointcut id="mypointcut" expression="execution(* com.powernode.spring6.service.xml..*(..))"/>
        <!--切面:通知 + 切点-->
        <aop:aspect ref="timerAspect">
            <aop:around method="aroundAdvice" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>

</beans>

测试程序

package com.powernode.spring6.test;

import com.powernode.spring6.service.xml.OrderService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAOPXMLTest {
    @Test
    public void testXml(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("springXml.xml");
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
        orderService.logout();
    }
}

5 AOP的实际案例：事务处理

控制事务的代码就是和业务逻辑没有关系的“交叉业务”。采用AOP思想。可以把控制事务的代码作为环绕通知，切入到目标类的方法当中。

有两个业务类

package com.powernode.spring6.service;

import org.springframework.stereotype.Service;
// 业务类
// 目标对象
@Service
public class AccountService {
    // 目标方法
    // 转账的业务方法
    public void transfer(){
        System.out.println("银行账户正在完成转账操作");
    }

    // 取款的业务方法
    public void withdraw(){
        System.out.println("正在取款");
    }
}

package com.powernode.spring6.service;

import org.springframework.stereotype.Service;
// 业务类
// 目标对象
@Service
public class OrderService {
    // 目标方法
    // 生成订单的业务方法
     public void generate(){
         System.out.println("正在生成订单");
     }

     // 取消订单的业务方法
     public void cancel(){
         System.out.println("订单已取消");
         // 模拟异常
         String s = null;
         s.toString();
     }
}

给以上两个业务类的4个方法添加事务控制代码，使用AOP来完成：

package com.powernode.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
// 事务切面类
@Component
@Aspect
public class TransactionAspect {
    @Around("execution(* com.powernode.spring6.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint){
        try {
            // 前环绕
            System.out.println("开启事务");
            // 执行目标
            joinPoint.proceed();
            // 后环绕
            System.out.println("提交事务");
        } catch (Throwable e) {
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }
}

编写spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--组件扫描-->
    <context:component-scan base-package="com.powernode.spring6.service"/>
    <!--启动自动代理-->
    <aop:aspectj-autoproxy/>
</beans>

编写测试程序：

package com.powernode.spring6.test;

import com.powernode.spring6.service.AccountService;
import com.powernode.spring6.service.OrderService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPRealAppTest {
    @Test
    public void testTransaction(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
        accountService.transfer();
        accountService.withdraw();
        orderService.generate();
        orderService.cancel();
    }
}

在这里插入图片描述

6 AOP的实际案例：安全日志

需求：凡事在系统中进行修改操作的，删除操作的，新增操作的，都要记录下来。因为这几个操作是属于危险行为。例如有业务类和业务方法：

package com.powernode.spring6.biz;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public void savaUser(){
        System.out.println("新增用户");
    }
    public void deleteUser(){
        System.out.println("删除用户");
    }
    public void modifyUser(){
        System.out.println("修改用户");
    }
    public void getUser(){
        System.out.println("查询用户");
    }
}

package com.powernode.spring6.biz;

import org.springframework.stereotype.Service;

@Service
public class VipService {
    public void savaVip(){
        System.out.println("新增会员");
    }
    public void deleteVip(){
        System.out.println("删除会员");
    }
    public void modifyVip(){
        System.out.println("修改会员");
    }
    public void getVip(){
        System.out.println("查询会员");
    }
}

package com.powernode.spring6.biz;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
@Component
@Aspect
public class SecurityLogAspect {

    @Pointcut("execution(* com.powernode.spring6.biz..sava*(..))")
    public void savaPointcut(){}
    @Pointcut("execution(* com.powernode.spring6.biz..delete*(..))")
    public void deletePointcut(){}
    @Pointcut("execution(* com.powernode.spring6.biz..modify*(..))")
    public void modifyPointcut(){}

    @Before("savaPointcut() || deletePointcut() || modifyPointcut()")
    public void beforeAdvice(JoinPoint joinPoint){
        // 系统实际
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String nowTime = sdf.format(new Date());
        // 输出日志信息
        System.out.println(nowTime + " 张三操作了: " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
    }
}

@Test
public void testSecurityLog(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    UserService userService = applicationContext.getBean("userService", UserService.class);
    VipService vipService = applicationContext.getBean("vipService", VipService.class);
    userService.savaUser();
    userService.deleteUser();
    userService.modifyUser();
    userService.getUser();

    vipService.savaVip();
    vipService.deleteVip();
    vipService.modifyVip();
    vipService.getVip();
}

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

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

相关文章

互联互通新里程，数字城轨助力城市繁荣！

互联互通新里程，数字城轨助力城市繁荣！

轨道交通是城市间互通互联的命脉&#xff0c;是当下人们出行的首要选择之一&#xff0c;也是我国“新基建”的重点建设对象。将城轨交通各链路系统及多类型服务&#xff0c;与空间感知、移动互联、云计算等技术深度融合&#xff0c;集中实现城市空间、城轨分布、城轨运行动态的…
阅读更多...
有哪些平价好用的台灯推荐？台灯买什么光的比较好

有哪些平价好用的台灯推荐？台灯买什么光的比较好

随着社会的发展&#xff0c;生产水平逐渐提高&#xff0c;很多东西都得到长足的发展&#xff0c;对咱们的生活水平的提高帮助也越来越大&#xff0c;台灯也不例外。台灯是现在各个年龄段人群都在使用的产品&#xff0c;晚上熬夜工作、学习、看书、休闲等等都很合适&#xff0c;…
阅读更多...
Linux学习第十七节-Apache httpd的web服务

Linux学习第十七节-Apache httpd的web服务

1.简介 适用于Unix/Linux下的web服务器软件。 Apache httpd&#xff08;开源且免费&#xff09;&#xff0c;虚拟主机&#xff0c;支持HTTPS协议&#xff0c;支持用户认证&#xff0c;支持单个目录的访问控制&#xff0c;支持URL地址重写&#xff0c;支持路径别名&#xff0c;…
阅读更多...
北斗RTK高精度定位在AI领域的应用

北斗RTK高精度定位在AI领域的应用

随着北斗高精度定位技术越来越成熟&#xff0c;通过GNSS高精度定位与机器人结合&#xff0c;越来越多的智能机器人走进我们生活中。像驾培机器人、智能除草机器人、智能巡检机器人、北斗划线机器人等智能机器人已经广泛的投入使用。驾培机器人驾培机器人&#xff1a;通考车安装…
阅读更多...
java基础——类加载机制

java基础——类加载机制

类加载机制一、背景知识补充二、类加载过程/机制1、浅层理解2、大致步骤3、具体步骤&#xff08;3.1&#xff09;装载loading&#xff1a;查找和导入相应的class文件&#xff08;3.2&#xff09;链接linking&#xff1a;把类的二进制数据合并到JRE中&#xff08;3.3&#xff09…
阅读更多...
计算机的操作系统

计算机的操作系统

目录 ❤ 什么是操作系统? ❤ 什么是文件? ❤ 什么是应用程序? ❤ 为什么要有操作系统? ​❤ 操作系统有什么用? ❤ 操作系统和应用程序的启动 python从小白到总裁完整教程目录:https://blog.csdn.net/weixin_67859959/article/details/129328397?spm1001.201…
阅读更多...
json-server的使用

json-server的使用

流程 1.安装json-server的两个依赖 npm -g i json-server npm install -g json-server 2.安装axios依赖 npm i axios 3.全局导入axios使用src目录下main.js文件内 import axios from ‘axios’; 4.配置全局默认地址&#xff1a;src目录下main.js文件内 axios.defaults.bas…
阅读更多...
十九、java虚拟机堆

十九、java虚拟机堆

堆的核心概述 1.一个JVM实例只存在一个堆内存&#xff0c;堆也是java内存管理的核心区域。 2.Java堆区子啊JVM启动的时候即被创建&#xff0c;其空间大小也就确定了&#xff0c;是jvm管理的最大一块内存空间&#xff0c; 1&#xff09;堆内存的大小是可以调节的。 3.《java虚拟…
阅读更多...
运行时数据区及程序计数器

运行时数据区及程序计数器

运行时数据区 概述 运行时数据区&#xff0c;也就是下图这部分&#xff0c;它是在类加载完成后的阶段 当我们通过前面的&#xff1a;类的加载-> 验证 -> 准备 -> 解析 -> 初始化 这几个阶段完成后&#xff0c;就会用到执行引擎对我们的类进行使用&#xff0c;同时…
阅读更多...
记录Paint部分常用的方法

记录Paint部分常用的方法

Paint部分常用的方法1、实例化之后Paint的基本配置2、shader 和 ShadowLayer3、pathEffect4、maskFilter5、colorFilter6、xfermode1、实例化之后Paint的基本配置 Paint.Align Align指定drawText如何将其文本相对于[x,y]坐标进行对齐。默认为LEFTPaint.Cap Cap指定了笔画线和路…
阅读更多...
SpringBoot整合定时任务和邮件发送（邮箱 信息轰炸 整蛊）

SpringBoot整合定时任务和邮件发送（邮箱 信息轰炸 整蛊）

SpringBoot整合定时任务和邮件发送&#xff08;邮箱 信息轰炸 整蛊&#xff09; 目录SpringBoot整合定时任务和邮件发送&#xff08;邮箱 信息轰炸 整蛊&#xff09;1.概述2.最佳实践2.1创建项目引入依赖(mail)2.2 修改yml配置文件2.3 启动类添加EnableScheduling注解2.4 执行的…
阅读更多...
设计模式(三)--适配器模式(Adapter Pattern)

设计模式(三)--适配器模式(Adapter Pattern)

将一个接口转换成客户希望的另一个接口&#xff0c;适配器模式使接口不兼容的那些类可以一起工作.比如我们日常开发中使用到的slf4j就使用了适配器模式&#xff0c;slf4j提供了一系列打日志的api,底层调用的是log4j或者logback来打日志&#xff0c;而作为调用者&#xff0c;不需…
阅读更多...
C++基础（二）—— 类和对象(类的封装)、对象的构造和析构(浅拷贝、深拷贝、explicit、动态分配内存)

C++基础（二）—— 类和对象(类的封装)、对象的构造和析构(浅拷贝、深拷贝、explicit、动态分配内存)

【上一篇】C基础&#xff08;一&#xff09;—— C概述、C对C的扩展(作用域、struct类型、引用、内联函数、函数默认参数、函数占位参数、函数重载)1. 类和对象的基本概念1.1 C和C中struct区别c语言struct只有变量c语言struct 既有变量&#xff0c;也有函数1.2 类的封装我们编写…
阅读更多...
【建议收藏】超详细的Canal入门，看这篇就够了！！！

【建议收藏】超详细的Canal入门，看这篇就够了！！！

概述 canal是阿里巴巴旗下的一款开源项目&#xff0c;纯Java开发。基于数据库增量日志解析&#xff0c;提供增量数据订阅&消费&#xff0c;目前主要支持了MySQL&#xff08;也支持mariaDB&#xff09;。 背景 早期&#xff0c;阿里巴巴B2B公司因为存在杭州和美国双机房部…
阅读更多...
Vue3 核心模块源码解析(中)

Vue3 核心模块源码解析(中)

【Vue3 核心模块源码解析(上)】讲到了 Vue2 与 Vue3的一些区别&#xff0c;Vue3 新特性的使用&#xff0c;以及略微带了一点源码。那么这篇文章就要从Vue3 模块源码解析 与 Vue3 执行逻辑解析这两个方面去给大家剖析 Vue3 的深层次&#xff0c;一起学习起来吧&#xff01; 这里…
阅读更多...
6.深入理解SecurityConfigurer

6.深入理解SecurityConfigurer

深入理解SecurityConfigurer 一、SecurityConfigurer SecurityConfigurer 在 Spring Security 中是一个非常重要的角色。在前面的内容中曾经多次提到过&#xff0c; Spring Security 过滤器链中的每一个过滤器&#xff0c;都是通过 xxxConfigurer 来进行配置的&#xff0c;而这…
阅读更多...
文件跳过回收站删除了常见原因|找回方法

文件跳过回收站删除了常见原因|找回方法

演示机型&#xff1a;技嘉 H310M HD22.0系统版本&#xff1a;Windows 10 专业版软件版本&#xff1a;云骑士数据恢复软件3.21.0.92你有没有遇到文件跳过回收站而直接删除的情况&#xff1f;如果有的话&#xff0c;你是知道是什么原因吗&#xff1f;文件跳过回收站删除了怎么办&…
阅读更多...
【JavaScript速成之路】JavaScript数组

【JavaScript速成之路】JavaScript数组

&#x1f4c3;个人主页&#xff1a;「小杨」的csdn博客 &#x1f525;系列专栏&#xff1a;【JavaScript速成之路】 &#x1f433;希望大家多多支持&#x1f970;一起进步呀&#xff01; 文章目录前言1&#xff0c;初识数组1.1&#xff0c;数组1.2&#xff0c;创建数组1.3&…
阅读更多...
SCI期刊收不收费也有门道，你知道吗?

SCI期刊收不收费也有门道，你知道吗?

什么是OA期刊? OA期刊是在互联网上在线出版的学术刊物&#xff0c;英文全称是OpenAccess Journal&#xff0c;中文译为“开放存取期刊”。OA期刊不同于传统的学术期刊如《自然》、《科学》等&#xff0c;采取的是向读者收费的运营模式&#xff0c;读者只有付费订阅&#xff0…
阅读更多...
【MySQL】表的数据处理

【MySQL】表的数据处理

哈喽&#xff0c;大家好&#xff01;我是保护小周ღ&#xff0c;本期为大家带来的是 MySQL 数据表中数据的基本处理的操作&#xff0c;数据表的增删改查&#xff0c;更多相关知识敬请期待&#xff1a;保护小周ღ *★,*:.☆(&#xffe3;▽&#xffe3;)/$:*.★*一、 添加数据&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023