DaiXT：Spring-AOP-使用注解完成环绕时间打印

引入的包如下

目录结构如下

Context-application.xml代码如下

<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
        https://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         https://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:annotation-config/>
    <bean id = "e" class="com.qst.pojo.Eye">
        <property name="light" value="光"></property>
    </bean>
    <bean id="b" class="com.qst.pojo.Brain">
    </bean>
    <context:component-scan base-package="com.qst.aop"/>
    <aop:aspectj-autoproxy/>
</beans>

主函数代码如下

package com.qst.testdemo;

import com.qst.pojo.Brain;
import com.qst.pojo.Eye;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testDemo {
    public static void main(String[] args) {
        /*
        两个大类：眼睛（Eye）、大脑（Brain）
        视觉产生的过程：光->眼->视网膜->视觉神经->丘脑->视觉皮层
         */
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Context-application.xml");
        Brain brain =(Brain) classPathXmlApplicationContext.getBean("b");
        Eye eye = (Eye) classPathXmlApplicationContext.getBean("e");
        String resualt = brain.visual_Cortex(//视觉皮层
                brain.thalamus(//丘脑
                        eye.optical_Nerve(//视觉神经
                                eye.retina(//视网膜
                                        brain.getEye().getLight()//大脑依赖于眼睛去捕获光
                                )
                        )
                )
        );
        System.out.println(resualt);
    }
}

Eye类

package com.qst.pojo;
import org.springframework.stereotype.Component;
@Component("e")
public class Eye {
    private String light;
    private String Neurotransmitter;//神经递质
    private String electrical_Signal;//电信号

    public Eye() {
        System.out.println("调用了眼睛的构造方法");
    }

    public String getNeurotransmitter() {
        return Neurotransmitter;
    }

    public void setNeurotransmitter(String neurotransmitter) {
        Neurotransmitter = neurotransmitter;
    }

    public String getElectrical_Signal() {
        return electrical_Signal;
    }

    public void setElectrical_Signal(String electrical_Signal) {
        this.electrical_Signal = electrical_Signal;
    }
    public String getLight() {
        System.out.print("眼睛捕获到了光");
        return light;
    }

    public void setLight(String light) {
        this.light = light;
    }

    //视网膜
    public String retina(String light){
        if(light.equals("光")){
            System.out.print("视网膜的感光细胞感受到了光");
            this.Neurotransmitter="神经递质";
            return this.Neurotransmitter;
        }else {
            return "视网膜的感光细胞未接收到光信号";
        }

    };
    //视觉神经
    public String optical_Nerve(String Neurotransmitter){
        if(Neurotransmitter.equals("神经递质")){
            System.out.print("视觉神经接收到神经递质并产生了神经冲动");
            this.electrical_Signal="电信号";
            return this.electrical_Signal;
        }else {
            return "没有神经递质发出";
        }

    }

}

brain类

package com.qst.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component("b")
public class Brain {
    private String electrical_Signal;//电信号
    @Autowired
    private Eye eye;

    public Brain() {
        System.out.println("调用了大脑的构造方法");
    }

    public String getElectrical_Signal() {
        return electrical_Signal;
    }

    public void setElectrical_Signal(String electrical_Signal) {
        this.electrical_Signal = electrical_Signal;
    }

    public Eye getEye() {
        System.out.print("执行了getEye");
        return eye;
    }

    public void setEye(Eye eye) {
        this.eye = eye;
    }

    //丘脑
    public String thalamus(String electrical_Signal){
        this.electrical_Signal = electrical_Signal;
        if (this.electrical_Signal.equals("电信号")){
            System.out.print("下丘脑接收到了电信号");
            return this.electrical_Signal;
        }else{
            return "丘脑并未接收到电信号";
        }
    }
    //视觉皮层
    public String visual_Cortex(String electrical_Signal){
        this.electrical_Signal = electrical_Signal;
        if (this.electrical_Signal.equals("电信号")){
            System.out.print("视觉皮层接收到了丘脑传来的电信号");
            return "视觉产生";
        }else{
            return "视觉皮层并未接收到电信号";
        }
    }

}

AOP切面类

package com.qst.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class AspectLog {
    @Pointcut("execution(* com.qst.pojo.*.*(..))")
    public void myPointCut() {
    }
    // 环绕通知
    @Around("myPointCut()")
    public Object log(ProceedingJoinPoint joinPoint)throws Throwable{
        //切入前获取时间
        //long date3 = getmicTime();
        long date1 = System.nanoTime();
        //执行切面环绕任务
        Object object = joinPoint.proceed();
        //切入后获取时间
        long date2 = System.nanoTime();
        //long date4 = getmicTime();
        //输出切入前后的时间差
        System.out.println("---该过程经历的时间为："+(date2-date1)+"（纳秒）");
        System.out.println("");
        return object;
    }
    //获取当前的时间转换为微秒
//    public static Long getmicTime() {
//        Long cutime = System.currentTimeMillis() * 1000; // 微秒
//        Long nanoTime = System.nanoTime(); // 纳秒
//        return cutime + (nanoTime - nanoTime / 1000000 * 1000000) / 1000;
//    }
}

执行效果如下