Day14AOP+虚拟机基础命令笔记-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_61099585/article/details/142465113

第一步：先引入pom文件依赖

<!--引入aop依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

第二步：准备目标资源（想要被Aop切面处理的资源）

package com.tedu.aopdemo.aop;

/**
 * Calculator:计算器
 */
public interface Calculator {
    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);
}

第三步：准备目标资源的实现类

package com.tedu.aopdemo.aop;

import org.springframework.stereotype.Component;

/**
 * Calculator的实现类
 */
@Component
public class CalculatorImpl implements Calculator{
    @Override
    public int add(int a, int b) {
        int result = a + b;
        return result;
    }

    @Override
    public int sub(int a, int b) {
        int result = a - b;
        return result;
    }

    @Override
    public int mul(int a, int b) {
        int result = a * b;
        return result;
    }

    @Override
    public int div(int a, int b) {
        if(b==0){
            throw new RuntimeException("除数不能为0");
        }
        int result = a / b;
        return result;
    }
}

第四步：定义一个切面类，用于在项目业务中动态添加逻辑

@Before：用于表达该方法逻辑是在执行实际方法之前切入并运行
@AfterReturning：表示切入点为实际方法调用完毕并返回结果后调用
@After：表示是在一个方法执行完毕后。无论该方法是否抛出异常，最后都会走该切面注意该切面不能获取方法返回值
@AfterThrowing：@AfterThrowing切入点是在实际方法抛出异常后进行
@Around：@Around 切入点结合了上述几个
所有切入点通常用异常处理机制来进行即可

package com.tedu.aopdemo.aop;

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

import javax.naming.event.ObjectChangeListener;
import java.util.Arrays;

/**
 * 定义一个切面类，用于在项目业务逻辑中动态添加逻辑
 */
@Component//该类也需要让Spring容器管理
@Aspect//使用该注解让Spring容器知道它是一个切面类
public class SysoutAspect {
//    /*
//        @Before是切面类中的一个切入点注解，用于表达该方法逻辑是在执行实际方法之前切入并运行
//        方法中需要传入切入点的描述信息(实际切入方法的签名):
//        访问修饰符 返回值类型 方法所属的类.方法名(参数列表)
//        public int CalculatorImpl.sub(..)      这里参数列表中的".."表示任意参数
//                      ^
//           引用类型实际要写完全限定名(包名.类名)
//
//        在方法签名中可以使用"*"模糊匹配，例如:
//        public int com.tedu.aopdemo.aop.CalculatorImpl.*(..)
//                                                       ^
//                                          表示CalculatorImpl中任意方法都要切入
//     */
//    @Before("execution(public int com.tedu.aopdemo.aop.CalculatorImpl.*(..))")
//    public void before(JoinPoint joinPoint) {
//        /*
//            JoinPoint 切入点
//            该类用于描述当前切面切入的方法信息，通过它我们可以得知当前切面切入的方法所属的类，
//            方法名，参数等信息
//         */
//        //切入点方法所属的对象(我们切入的是CalculatorImpl的add方法，因此target是:CalculatorImpl)
        System.out.println("target"+joinPoint.getTarget());
//        //获取切入方法信息，（Signature签名，这里表示方法签名），通过Signature获取该方法名字(.getName())
        System.out.println(joinPoint.getSignature().getName());
//        //获取切入方法的参数(实参)
        System.out.println("参数:"+ Arrays.toString(joinPoint.getArgs()));
//        //获取切入点的方法名
//        String methodName = joinPoint.getSignature().getName();
//        //获取切入点该方法所属类的名字
//        String className = joinPoint.getTarget().getClass().getSimpleName();
//        //获取切入点调用方法实际传入的参数
//        String args = Arrays.toString(joinPoint.getArgs());
//        System.out.println("开始调用"+className+"."+methodName+"(),实参为:"+args);
//    }
//
//    /*
//        @AfterReturning表示切入点为实际方法调用完毕并返回结果后调用
//        该切入点方法除了可以获取切入点信息(joinPoint)，
//        还可以获取实际方法调用后返回的结果(returnValue)
//     */
//    @AfterReturning(
//            value="execution(public int com.tedu.aopdemo.aop.CalculatorImpl.*(..))",
//            returning="returnValue"//说明将实际方法返回值传递给下面方法的哪个参数
//    )
//    public void afterReturning(JoinPoint joinPoint, Object returnValue) {
//        String methodName = joinPoint.getSignature().getName();
//        String className = joinPoint.getTarget().getClass().getSimpleName();
//        System.out.println(className+"."+methodName+"()执行完毕，返回值为:"+returnValue);
//    }
//
//    /*
//        @After切入点是在一个方法执行完毕后。
//        无论该方法是否抛出异常，最后都会走该切面
//        注意该切面不能获取方法返回值
//     */
//    @After("execution(public int com.tedu.aopdemo.aop.CalculatorImpl.*(..))")
//    public void after(JoinPoint joinPoint){
//        String methodName = joinPoint.getSignature().getName();
//        String className = joinPoint.getTarget().getClass().getSimpleName();
//        System.out.println(className+"."+methodName+"()完毕!");
//    }
//    /*
//        @AfterThrowing切入点是在实际方法抛出异常后进行
//     */
//    @AfterThrowing(
//            value = "execution(public int com.tedu.aopdemo.aop.CalculatorImpl.*(..))",
//            throwing = "e"//指定将实际方法抛出的异常传递给下面方法的哪个参数
//    )
//    public void AfterThrowing(JoinPoint joinPoint,Exception e){
//        String methodName = joinPoint.getSignature().getName();
//        String className = joinPoint.getTarget().getClass().getSimpleName();
//        System.out.println(className+"."+methodName+"()抛出异常:"+e.getMessage());
//    }

    /*
        @Around 切入点结合了上述几个
        所有切入点通常用异常处理机制来进行即可
     */
    @Around("execution(public int com.tedu.aopdemo.aop.CalculatorImpl.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getTarget().getClass().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        //@Before里切入的逻辑写在这里
        System.out.println(className + "." + methodName+"()开始执行,参数为:"+args);

        try {
            //实际方法执行，并接收该方法的返回值
            Object returnValue = joinPoint.proceed();//CalculatorImpl.add()执行。。(实际的方法去执行)

            //@AfterReturning
            System.out.println(className + "." + methodName+"()执行完毕");
            return returnValue;
        } catch (Throwable e) {
            //@AfterThrowing
            System.out.println(className + "." + methodName+"()出现异常:"+e.getMessage());
            throw new RuntimeException(e);
        } finally {
            //@After
            System.out.println(className + "." + methodName+"()最终执行完毕");
        }

    }

}

注意传参问题！！！

下面是调用图

pwd 命令

pwd--- Print Working Directory

[root@localhost ~]# pwd
/root

cd 命令

cd --- Change Directory

作用：切换工作目录

格式： cd [ 目标文件夹位置 ]

绝对路径：以 / 开头的路径（ /etc/subject/java ）

相对路径：不以 / 开头的路径，相对当前所在位置而言（ etc/car/bmw ）

[root@localhost ~]# cd /dev #切换至/dev目录（绝对路径）
[root@localhost dev]# pwd #查看当前工作目录
/dev
[root@localhost dev]# cd / #切换至根目录（绝对路径）
[root@localhost /]# pwd #查看当前工作目录
/
[root@localhost /]# cd boot #切换至boot目录（相对路径）
[root@localhost boot]# pwd
/boot

ls 命令

ls --- List

作用：查看目录里的内容，或者查看资料是否存在

格式： ls [ 选项 ] [ 目标 ]

[root@localhost boot]# cd / #切换至根目录
[root@localhost /]# pwd #查看当前工作目录
/
[root@localhost /]# ls #查看当前工作目录下有哪些数据
[root@localhost /]# cd /root/ #切换至/root目录（绝对路径）
[root@localhost ~]# ls #查看当前工作目录下有哪些数据
[root@localhost ~]# ls /opt/ #查看/opt目录中有哪些数据
[root@localhost ~]# ls /boot/ #查看/boot目录中有哪些数据

cd 命令与 ls 命令的高级使用

cd 命令高级使用

. 表示当前目录

[root@localhost ~]# cd /etc/pki/tls #切换至/etc/pki/tls目录
[root@localhost tls]# pwd #查看当前工作目录
/etc/pki/tls
[root@localhost tls]# cd .. #切换至父目录(上一级目录)
[root@localhost pki]# pwd #查看当前工作目录
/etc/pki
[root@localhost pki]# cd .. #切换至父目录(上一级目录)
[root@localhost etc]# pwd #查看当前工作目录
/etc
[root@localhost etc]# cd .. #切换至父目录(上一级目录)
[root@localhost /]# pwd #查看当前工作目录
/
[root@localhost /]# cd .. #切换至父目录(上一级目录)
[root@localhost /]#pwd #还在根目录，因为根目录没有上一级目录
/
[root@localhost etc]# cd /etc/skel/ #切换至/etc/skel目录
[root@localhost skel]# cd ../.. #切换至父目录的父目录
[root@localhost /]# pwd #查看当前所在位置
/

~ ：表示用户的家目录

/root: 管理员用户 root 的家目录

5.4.2 ls 命令高级使用

常用命令选项

-l ：以长格式显示（显示详细属性）

-A ：包括名称以 . 开头的隐藏文档

-d ：显示目录本身 ( 而不是内容 ) 的属性

-h ：提供易读的容量单位 (K 、 M) 等

-R ：递归显示内容

[root@localhost ~]# ls -l /etc/passwd #查看/etc/passwd详细属性
[root@localhost ~]# ls -l -h /etc/passwd #显示详细属性加上易读的单位

也可以将选项写到一起（复合选项）

[root@localhost ~]# ls -lh /etc/passwd
[root@localhost ~]# ls -ld /boot/ #显示目录本身的详细属性
[root@localhost ~]# ls -A /root/ #显示目录所有数据，包括隐藏文档
[root@localhost ~]# ls -R /opt/ #递归查看/opt/目录，分目录进行显示
[root@localhost ~]# ls --help #显示ls帮助信息

其他常用命令

pwd 命令：查看当前所在路径；

mkdir 命令