小鲁蛋儿
小鲁蛋儿

Spring原理学习（八）AOP底层实现

一、Advice、Advisor、Advised接口

Advice: org.aopalliance.aop.Advice
“通知”，实际增强的逻辑部分。

Pointcut: org.springframework.aop.Pointcut
“切点”，一些特使的连接点，是具体附加通知的地方。例如坐地铁的时候，具体在某个站下车，那这个站就是切入点。

  • 连接点：在应用执行过程中能够插入切面（Aspect）的一个点。例如坐地铁的时候，每一个站都可以下车，那么这每一个站都是一个接入点。假如一个对象中有多个方法，那么这个每一个方法就是一个连接点。

Advisor: org.springframework.aop.Advisor
“通知者”，它持有 Advice，是 Spring AOP 的一个基础接口。

Advised: org.springframework.aop.framework.Advised
AOP 代理工厂配置类接口。提供了操作和管理 Advice 和 Advisor 的能力。

1、Advice、Advisor、Advised 类图

Spring原理学习（八）AOP底层实现_第1张图片

1. Advisor 可以获取到 Advice。

2. PointcutAdvisor 可以获取到 Pointcut 和 Advice。
Pointcut 可以匹配连接点，Advice 是具体的通知，所以，PointcutAdvisor 是一个功能完善接口。

3. Advised 是 AOP 代理工厂配置类接口，它可以操作和管理 Advice 和 Advisor，它的实现类有 ProxyFactory、AspectJProxyFactory，用于生成AOP 代理类。

Spring原理学习（八）AOP底层实现_第2张图片

2、Advice

Spring原理学习（八）AOP底层实现_第3张图片

 Advice 大体上分为了三类：BeforeAdvice、MethodInterceptor、AfterAdvice

可以看出，MethodInterceptor 是功能最强大的，它能够处理 BeforeAdvice、AroundAdvice、AfterAdvice、ThrowsAdvice、@Valid方法参数校验、@Async异步等

3、Advisor

Spring原理学习（八）AOP底层实现_第4张图片

Advisor 大体分为了三类：PointcutAdvisor、IntroductionAdvisor、PrototypePlaceholderAdvisor
其中，用到的最多的就是 PointcutAdvisor，它涵盖了绝大部分的 Advisor。 

PointcutAdvisor

PointcutAdvisor 是一个功能完善接口，也是 Spring AOP 中使用最多的，它涵盖了绝大部分的 Advisor。

通过 PointcutAdvisor 可以获取到 Pointcut 和 Advice。Pointcut 可以完成连接点的匹配，而 Advice 就是在连接点上具体要执行的"通知"。

4、Advised

Spring原理学习（八）AOP底层实现_第5张图片

Spring原理学习（八）AOP底层实现_第6张图片 

Advised 是 AOP 代理工厂配置类接口。

它的实现类有：ProxyFactory、AspectJProxyFactory、ProxyFactoryBean。
Advised 提供了操作和管理 Advice 和 Advisor 的能力，所以，ProxyFactory 实现 Advised 之后，就可以方便的获取和操作 Advice、Advisor，从而创建 AOP 代理类了。

Advised、ProxyConfig、AdvisedSupport 都是跟 Spring AOP 代理配置相关的接口和类，它们可以统一 Spring AOP 的代理配置。

参考文章：【Spring源码三千问】Advice、Advisor、Advised都是什么接口？

二、Spring的代理选择规则

代理相关类图

  • AopProxyFactory 根据 proxyTargetClass 等设置选择 AopProxy 实现

  • AopProxy 通过 getProxy 创建代理对象

  • 图中 Proxy 都实现了 Advised 接口，能够获得关联的切面集合与目标（其实是从 ProxyFactory 取得）

  • 调用代理方法时，会借助 ProxyFactory 将通知统一转为环绕通知：MethodInterceptor

Spring原理学习（八）AOP底层实现_第7张图片

先说结论： 

  • proxyTargetClass = false, 目标实现了接口, 用 jdk 实现
  • proxyTargetClass = false, 目标没有实现接口, 用 cglib 实现
  • proxyTargetClass = true, 总是使用 cglib 实现
public class A15 {
    public static void main(String[] args) {

        // 1. 备好切点
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* foo())");

        // 2. 备好通知 ,注意同名MethodInterceptor
        MethodInterceptor advice = new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...");
                //调用目标
                Object result = invocation.proceed();
                System.out.println("after...");
                return result;
            }
        };

        // 3. 备好切面
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
          
        //4. 创建代理   
        Target1 target1 = new Target1();
        ProxyFactory factory = new ProxyFactory();
        factory.setTarget(target1);
        factory.addAdvisor(advisor);

        I1 proxy = (I1) factory.getProxy();
        
        //5. 调用增强后的方法
        System.out.println(proxy.getClass());
        proxy.foo();
        proxy.bar();
    }

    interface I1 {
        void foo();

        void bar();
    }

    static class Target1 implements I1 {
        public void foo() {
            System.out.println("target1 foo");
        }

        public void bar() {
            System.out.println("target1 bar");
        }
    }

    static class Target2 {
        public void foo() {
            System.out.println("target2 foo");
        }

        public void bar() {
            System.out.println("target2 bar");
        }
    }
}

 结果：使用 CGLIB 实现，不应该是 JDK 吗？

class com.itheima.a15.A15$Target1$$EnhancerBySpringCGLIB$$88a7fb77
before...
target1 foo
after...
target1 bar

解释：因为生成代理类时并不知道目标类是否实现了接口，需要告诉工厂目标类实现的接口

factory.setInterfaces(target1.getClass().getInterfaces());

设置接口后再进行测试，使用JDK实现

class com.itheima.a15.$Proxy2

设置 ProxyTargetClass 为 true 再进行测试，使用CGLIB实现

factory.setProxyTargetClass(true);
class com.itheima.a15.A15$Target1$$EnhancerBySpringCGLIB$$abb40a5f

总结

ProxyFactory 是用来创建代理的核心实现，用 AopProxyFactory 选择具体代理实现

  • JdkDynamicAopProxy
  • ObjenesisCglibAopProxy

注意：要区分上面提到的 MethodInterceptor，它与之前 CGLIB 中用的的 MethodInterceptor 是不同的接口

三、切点匹配

1、根据指定的方法进行匹配

public class A16 {
    public static void main(String[] args) throws NoSuchMethodException {
        AspectJExpressionPointcut pt1 = new AspectJExpressionPointcut();
        //根据指定的方法进行匹配
        pt1.setExpression("execution(* bar())");
        //判断是否匹配
        System.out.println(pt1.matches(T1.class.getMethod("foo"), T1.class));
        System.out.println(pt1.matches(T1.class.getMethod("bar"), T1.class));
    }

    static class T1 {
        public void foo() {
        }
        public void bar() {
        }
    }
}

matches方法的第二个参数可以随意指定，对于结果没有影响，后面在自己实现切点匹配时会解释。 

结果：

false
true

2、根据方法上的注解进行匹配

public class A16 {
    public static void main(String[] args) throws NoSuchMethodException {
        AspectJExpressionPointcut pt2 = new AspectJExpressionPointcut();
        //根据方法上的注解进行匹配
        pt2.setExpression("@annotation(org.springframework.transaction.annotation.Transactional)");
        System.out.println(pt2.matches(T1.class.getMethod("foo"), T1.class));
        System.out.println(pt2.matches(T1.class.getMethod("bar"), T1.class));
    }

    static class T1 {
        @Transactional
        public void foo() {
        }
        public void bar() {
        }
    }
}

结果：

true
false

3、自己实现切点匹配

MergedAnnotations是一个注解的工具类

public class A16 {
    public static void main(String[] args) throws NoSuchMethodException {
        StaticMethodMatcherPointcut pt3 = new StaticMethodMatcherPointcut() {
            @Override
            public boolean matches(Method method, Class targetClass) {
                /* 检查方法上是否加了 Transactional 注解 */

                //获取方法上标注的注解
                MergedAnnotations annotations = MergedAnnotations.from(method);
                //是否有@Transactional注解
                if (annotations.isPresent(Transactional.class)) {
                    return true;
                }

                /* 查看类上是否加了 Transactional 注解 */

                //获取类上标注的注解
                annotations = MergedAnnotations.from(targetClass, MergedAnnotations.SearchStrategy.TYPE_HIERARCHY);
                //是否有@Transactional注解
                if (annotations.isPresent(Transactional.class)) {
                    return true;
                }
                return false;
            }
        };

        System.out.println(pt3.matches(T1.class.getMethod("foo"), T1.class));
        System.out.println(pt3.matches(T1.class.getMethod("bar"), T1.class));
        System.out.println(pt3.matches(T2.class.getMethod("foo"), T2.class));
        System.out.println(pt3.matches(T3.class.getMethod("foo"), T3.class));
    }


    static class T1 {
        @Transactional
        public void foo() {
        }
        public void bar() {
        }
    }

    @Transactional
    static class T2 {
        public void foo() {
        }
    }

    @Transactional
    interface I3 {
        void foo();
    }
    static class T3 implements I3 {
        public void foo() {
        }
    }
}

 说明：from方法默认的搜索策略是在本类，那么如果在接口或者父类上标注 @Transactional 注解则查找不到。

    static MergedAnnotations from(AnnotatedElement element) {
        return from(element, MergedAnnotations.SearchStrategy.DIRECT);
    }

所以更换了策略 

MergedAnnotations.SearchStrategy.TYPE_HIERARCHY：从继承树查找

默认策略的结果：

true
false
true
false

指定为 TYPE_HIERARCHY 策略的结果：

true
false
true
true

总结

  • 底层切点实现是如何匹配的：调用了 aspectj 的匹配方法，比较关键的是它实现了 MethodMatcher 接口，用来执行方法的匹配。
  • aspectj 切点的局限性：只能匹配方法的信息

四、从 @Aspect 到 Advisor

两个切面概念

aspect =

  • 通知1(advice) + 切点1(pointcut)
  • 通知2(advice) + 切点2(pointcut)
  • 通知3(advice) + 切点3(pointcut)
  • ...

advisor =

  • 更细粒度的切面，包含一个通知和切点

aspect：高级切面，advisor：低级切面

1、代理创建器

AnnotationAwareAspectJAutoProxyCreator其实是个Bean后处理器，具体可以看它的继承关系。

AnnotationAwareAspectJAutoProxyCreator的作用：

  • 将高级 @Aspect 切面统一为低级 Advisor 切面

  • 在合适的时机创建代理

public class A17 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("aspect1", Aspect1.class);
        context.registerBean("config", Config.class);
        context.registerBean(ConfigurationClassPostProcessor.class);

        //解析@Aspect，产生代理
        context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);

        context.refresh();

        /*
        第一个重要方法 findEligibleAdvisors：找到有资格的Advisors
            a. 有资格的 Advisor 一部分是低级的，可以由自己编写，如下例中的 advisor3
            b. 有资格的 Advisor 一部分是高级的，由解析 @Aspect 后获得
         */
        AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
        Method findEligibleAdvisors = creator.getClass().getSuperclass().getSuperclass().
                getDeclaredMethod("findEligibleAdvisors", Class.class, String.class);
        findEligibleAdvisors.setAccessible(true);
        //找到和 Target1 类匹配的所有切面
        // 参数一：目标类型，参数二：bean名字，由于没交给spring管理，随便写一个
        List advisors = (List) findEligibleAdvisors.invoke(creator, Target1.class, "target1");
        for (Advisor advisor : advisors) {
            System.out.println(advisor);
        }

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>");


        /*
        第二个重要方法 wrapIfNecessary
            a. 它内部调用 findEligibleAdvisors，只要返回集合不为空，则表示需要创建代理
         */

        //参数一：目标对象 参数二：bean名字，由于没交给spring管理，随便写一个 参数三：对于这个操作没用，随便写一个
        Method wrapIfNecessary = creator.getClass().getSuperclass().getSuperclass().getSuperclass().
                getDeclaredMethod("wrapIfNecessary", Object.class, String.class, Object.class);
        wrapIfNecessary.setAccessible(true);
        Object o1 = wrapIfNecessary.invoke(creator, new Target1(), "target1", "target1");
        //代理对象
        System.out.println(o1.getClass());
        Object o2 = wrapIfNecessary.invoke(creator, new Target2(), "target2", "target2");
        //对象本身
        System.out.println(o2.getClass());

        ((Target1) o1).foo();

    }
    static class Target1 {
        public void foo(){
            System.out.println("target1 foo");
        }
    }

    static class Target2 {
        public void bar(){
            System.out.println("target2 bar");
        }
    }

    @Aspect //高级切面类
    static class Aspect1 {
        @Before("execution(* foo())")
        public void before(){
            System.out.println("aspect1 before...");
        }

        @After("execution(* foo())")
        public void after(){
            System.out.println("aspect1 after...");
        }
    }

    @Configuration
    static class Config {
        @Bean//低级切面
        public Advisor advisor3(MethodInterceptor advice3){
            AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
            pointcut.setExpression("execution(* foo())");
            DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice3);
            return advisor;
        }

        @Bean
        public MethodInterceptor advice3() {
            return new MethodInterceptor() {
                @Override
                public Object invoke(MethodInvocation invocation) throws Throwable {
                    System.out.println("advice3 before...");
                    Object result = invocation.proceed();
                    System.out.println("advice3 after...");
                    return result;
                }
            };
        }
    }
}

结果：

//spring加的,暴露调用器的拦截器,作用后面会讲
org.springframework.aop.interceptor.ExposeInvocationInterceptor.ADVISOR

//低级切面
org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [com.itheima.a17.A17$Config$1@209da20d]

//高级切面转换后的低级切面
InstantiationModelAwarePointcutAdvisor: expression [execution(* foo())]; advice method [public void com.itheima.a17.A17$Aspect1.before()]; perClauseKind=SINGLETON
InstantiationModelAwarePointcutAdvisor: expression [execution(* foo())]; advice method [public void com.itheima.a17.A17$Aspect1.after()]; perClauseKind=SINGLETON

>>>>>>>>>>>>>>>>>>>>>>>>>>
[TRACE] 16:10:29.788 [main] o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator - Creating implicit proxy for bean 'target1' with 0 common interceptors and 4 specific interceptors 
class com.itheima.a17.A17$Target1$$EnhancerBySpringCGLIB$$a2f64ee5
class com.itheima.a17.A17$Target2

advice3 before...
aspect1 before...
target1 foo
aspect1 after...
advice3 after...

总结

  1. AnnotationAwareAspectJAutoProxyCreator 的作用

    • 将高级 @Aspect 切面统一为低级 Advisor 切面

    • 在合适的时机创建代理

  2. findEligibleAdvisors 找到有【资格】的 Advisors

    • 有【资格】的 Advisor 一部分是低级的, 可以由自己编写, 如本例 A17 中的 advisor3

    • 有【资格】的 Advisor 另一部分是高级的, 由解析 @Aspect 后获得

  3. wrapIfNecessary

    • 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理

    • 它的调用时机通常在原始对象初始化后执行, 但碰到循环依赖会提前至依赖注入之前执行

2、代理创建时机

1）代理的创建时机：

  • 初始化之后 (无循环依赖时)

  • 实例创建后，依赖注入前 (有循环依赖时)，并暂存于二级缓存

注意：不会重复创建代理，两个位置二选一

无循环依赖

public class A17_1 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean(Config.class);
        context.registerBean(ConfigurationClassPostProcessor.class);

        context.refresh();
    }

    @Configuration
    static class Config {
        @Bean //解析 @Aspect，产生代理
        public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator() {
            return new AnnotationAwareAspectJAutoProxyCreator();
        }

        @Bean //解析 @Autowired
        public AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor() {
            return new AutowiredAnnotationBeanPostProcessor();
        }

        @Bean //解析 @PostConstruct
        public CommonAnnotationBeanPostProcessor commonAnnotationBeanPostProcessor() {
            return new CommonAnnotationBeanPostProcessor();
        }

        @Bean
        public Advisor advisor(MethodInterceptor advice) {
            AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
            pointcut.setExpression("execution(* foo())");
            return new DefaultPointcutAdvisor(pointcut, advice);
        }

        @Bean
        public MethodInterceptor advice(){
            return new MethodInterceptor() {
                @Override
                public Object invoke(MethodInvocation invocation) throws Throwable {
                    System.out.println("before...");
                    Object result = invocation.proceed();
                    return result;
                }
            };
        }

        @Bean
        public Bean1 bean1() {
            return new Bean1();
        }

        @Bean
        public Bean2 bean2() {
            return new Bean2();
        }
    }

    static class Bean1 {

        public void foo(){

        }

        public Bean1(){
            System.out.println("Bean1()");
        }

        @PostConstruct
        public void init() {
            System.out.println("Bean1 init()");
        }
    }

    static class Bean2 {

        public Bean2(){
            System.out.println("Bean2()");
        }

        @Autowired
        public void setBean1(Bean1 bean1) {
            System.out.println("Bean2 setBean1(bean1) class is: " + bean1.getClass());
        }

        @PostConstruct
        public void init() {
            System.out.println("Bean2 init()");
        }
    }
}

结果：

Bean1()
Bean1 init()
[TRACE] 16:21:47.952 [main] o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator - Creating implicit proxy for bean 'bean1' with 0 common interceptors and 2 specific interceptors 
Bean2()
Bean2 setBean1(bean1) class is: class com.itheima.a17.A17_1$Bean1$$EnhancerBySpringCGLIB$$b0011e5d
Bean2 init()

有循环依赖时

    static class Bean1 {

        public void foo(){

        }

        public Bean1(){
            System.out.println("Bean1()");
        }

        @Autowired
        public void setBean1(Bean2 bean2) {
            System.out.println("Bean1 setBean2(bean2) class is: " + bean2.getClass());
        }

        @PostConstruct
        public void init() {
            System.out.println("Bean1 init()");
        }
    }

    static class Bean2 {

        public Bean2(){
            System.out.println("Bean2()");
        }

        @Autowired
        public void setBean1(Bean1 bean1) {
            System.out.println("Bean2 setBean1(bean1) class is: " + bean1.getClass());
        }

        @PostConstruct
        public void init() {
            System.out.println("Bean2 init()");
        }
    }

结果：

Bean1()
Bean2()
[TRACE] 16:23:35.276 [main] o.s.a.a.a.AnnotationAwareAspectJAutoProxyCreator - Creating implicit proxy for bean 'bean1' with 0 common interceptors and 2 specific interceptors 
Bean2 setBean1(bean1) class is: class com.itheima.a17.A17_1$Bean1$$EnhancerBySpringCGLIB$$2d7cace9
Bean2 init()
Bean1 setBean2(bean2) class is: class com.itheima.a17.A17_1$Bean2
Bean1 init()

3、@Before 对应的低级通知

@Before 前置通知会被转换为原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息

  1. 通知代码从哪儿来

  2. 切点是什么(这里为啥要切点, 后面解释)

  3.  Aspect 对象，将来反射调用切面类的方法需要切面类对象

类似的还有：

  1. AspectJAroundAdvice (环绕通知)

  2. AspectJAfterReturningAdvice

  3. AspectJAfterThrowingAdvice (环绕通知)

  4. AspectJAfterAdvice (环绕通知)

环绕通知：实现了 MethodInterceptor 接口的类

public class A17_2 {
    static class Aspect {
        @Before("execution(* foo())")
        public void before1() {
            System.out.println("before1");
        }

        @Before("execution(* foo())")
        public void before2() {
            System.out.println("before2");
        }

        public void after() {
            System.out.println("after");
        }
    }

    static class Target {
        public void foo() {
            System.out.println("target foo");
        }
    }

    public static void main(String[] args) {
        //切面对象工厂，将来由工厂拿到切面对象
        AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());
        List list = new ArrayList<>();
        //高级切面转低级切面类
        for (Method method : Aspect.class.getDeclaredMethods()) {
            //方法上是否标注 @Before 注解
            if (method.isAnnotationPresent(Before.class)) {
                //解析切点
                String expression = method.getAnnotation(Before.class).value();
                AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
                pointcut.setExpression(expression);

                //通知类
                //参数三：将来反射调用切面类的方法需要切面类对象，所以需要传入切面类对象，具体从工厂获取
                AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);

                //切面
                DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

                list.add(advisor);
            }
        }
        for (Advisor advisor : list) {
            System.out.println(advisor);
        }
    }
}

结果：

org.springframework.aop.support.DefaultPointcutAdvisor: 
pointcut [AspectJExpressionPointcut: () execution(* foo())]; 
advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void com.itheima.a17.A17_2$Aspect.before1()]; aspect name '']

org.springframework.aop.support.DefaultPointcutAdvisor: 
pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: 
advice method [public void com.itheima.a17.A17_2$Aspect.before2()]; aspect name '']

五、静态通知调用

步骤：

  1. 高级切面转低级切面类
  2. 通知统一转换为环绕通知 MethodInterceptor
  3. 创建并执行调用链 (所有的环绕通知 + 目标)

1、通知为什么需要统一转换为环绕通知？

其实无论proxyFactory基于哪种方式创建，最后干活(调用 advice)的是一个 MethodInvocation 对象

1）因为 advisor 有多个，且一个套一个调用，因此需要一个调用链对象，即 MethodInvocation

2）MethodInvocation 要知道 advice 有哪些，还要知道目标，调用次序

Spring原理学习（八）AOP底层实现_第8张图片

3）从上图可以看出，环绕通知才适合作为 advice，因此其他 before，afterReturning 都会被转换为环绕通知

如何统一转换为 MethodInterceptor 环绕通知？

统一转换为环绕通知，体现的是设计模式的适配器模式

  • 对外是为了方便使用要区分 before, afterReturning, afterThrowing
  • 对内统一都是环绕通知，统一用 MethodInterceptor 表示

适配如下

  • MethodBeforeAdviceAdapter 将 AspectJMethodBeforeAdvice 适配为 MethodBeforeAdviceInterceptor
  • AfterReturningAdviceAdapter 将 AspectJAfterReturningAdvice 适配为 MethodAfterReturningAdviceInterceptor
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
    MethodBeforeAdviceAdapter() {
    }

    //支持哪种通知的适配
    public boolean supportsAdvice(Advice advice) {
        return advice instanceof MethodBeforeAdvice;
    }

    //转换成 MethodInterceptor 接口
    public MethodInterceptor getInterceptor(Advisor advisor) {
        MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
        return new MethodBeforeAdviceInterceptor(advice);
    }
}

2、模拟静态通知调用

public class A18 {
    static class Aspect {
        @Before("execution(* foo())")
        public void before1() {
            System.out.println("before1");
        }

        @Before("execution(* foo())")
        public void before2() {
            System.out.println("before2");
        }

        public void after() {
            System.out.println("after");
        }

        @AfterReturning("execution(* foo())")
        public void afterReturning() {
            System.out.println("afterReturning");
        }

        @AfterThrowing("execution(* foo())")
        public void afterThrowing(Exception e) {
            System.out.println("afterThrowing" + e.getMessage());
        }

        @Around("execution(* foo())")
        public Object around(ProceedingJoinPoint pjp) throws Throwable{
            System.out.println("around before...");
            Object result = pjp.proceed();
            System.out.println("around after...");
            return result;
        }
    }

    static class Target {
        public void foo() {
            System.out.println("target foo");
        }
    }

    public static void main(String[] args) throws Throwable {

        /* 1. 高级切面转低级切面类 */

        //切面对象工厂，由工厂拿到切面对象
        AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());
        List list = new ArrayList<>();
        for (Method method : Aspect.class.getDeclaredMethods()) {
            //方法上是否标注 @Before 注解
            if (method.isAnnotationPresent(Before.class)) {
                //解析切点
                String expression = method.getAnnotation(Before.class).value();
                AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
                pointcut.setExpression(expression);

                //通知类
                AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);

                //切面
                DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

                list.add(advisor);
            } else if (method.isAnnotationPresent(AfterReturning.class)) {
                //方法上是否标注 @AfterReturning 注解
                if (method.isAnnotationPresent(AfterReturning.class)) {
                    //解析切点
                    String expression = method.getAnnotation(AfterReturning.class).value();
                    AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
                    pointcut.setExpression(expression);

                    //通知类
                    AspectJAfterReturningAdvice advice = new AspectJAfterReturningAdvice(method, pointcut, factory);

                    //切面
                    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

                    list.add(advisor);
                }
            } else if (method.isAnnotationPresent(Around.class)) {
                //方法上是否标注 @Around 注解
                if (method.isAnnotationPresent(Around.class)) {
                    //解析切点
                    String expression = method.getAnnotation(Around.class).value();
                    AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
                    pointcut.setExpression(expression);

                    //通知类
                    AspectJAroundAdvice advice = new AspectJAroundAdvice(method, pointcut, factory);

                    //切面
                    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

                    list.add(advisor);
                }
            }
        }

        for (Advisor advisor : list) {
            System.out.println(advisor);
        }

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        /* 省略了 advisor 排序步骤 */

        /* 2. 通知统一转换为环绕通知 MethodInterceptor */

        ProxyFactory proxyFactory = new ProxyFactory();
        Target target = new Target();
        proxyFactory.setTarget(target);
        //准备把 MethodInvocation 放入当前通知
        proxyFactory.addAdvice(ExposeInvocationInterceptor.INSTANCE); 
        proxyFactory.addAdvisors(list);

        //把除了环绕通知以外的其他类型通知统一转换为环绕通知
        List methodInterceptorList =
                proxyFactory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo"), Target.class);
        for (Object o : methodInterceptorList) {
            System.out.println(o);
        }

        /* 3. 创建并执行调用链 (所有的环绕通知 + 目标) */
        Constructor constructor = ReflectiveMethodInvocation.class.getDeclaredConstructor(
                Object.class, Object.class, Method.class, Object[].class, Class.class, List.class);
        constructor.setAccessible(true);
        ReflectiveMethodInvocation methodInvocation = constructor.newInstance(
                null, target, Target.class.getMethod("foo"), new Object[0], Target.class, methodInterceptorList);
        methodInvocation.proceed();
    /*
        此步模拟调用链过程，是一个简单的递归调用
            1. proceed() 方法调用链中下一个环绕通知
            2. 每个环绕通知内部继续调用 proceed()
            3. 调用到没有更多通知了，就调用目标方法
     */
    }
}
 
  
结果：
 
  
org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJAroundAdvice: advice method [public java.lang.Object com.itheima.a18.A18$Aspect.around(org.aspectj.lang.ProceedingJoinPoint) throws java.lang.Throwable]; aspect name '']
org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJAfterReturningAdvice: advice method [public void com.itheima.a18.A18$Aspect.afterReturning()]; aspect name '']
org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void com.itheima.a18.A18$Aspect.before1()]; aspect name '']
org.springframework.aop.support.DefaultPointcutAdvisor: pointcut [AspectJExpressionPointcut: () execution(* foo())]; advice [org.springframework.aop.aspectj.AspectJMethodBeforeAdvice: advice method [public void com.itheima.a18.A18$Aspect.before2()]; aspect name '']
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
org.springframework.aop.interceptor.ExposeInvocationInterceptor@8e24743
org.springframework.aop.aspectj.AspectJAroundAdvice: advice method [public java.lang.Object com.itheima.a18.A18$Aspect.around(org.aspectj.lang.ProceedingJoinPoint) throws java.lang.Throwable]; aspect name ''
org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor@74a10858
org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@23fe1d71
org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@28ac3dc3
around before...
before1
before2
target foo
afterReturning
around after...
 
  
ExposeInvocationInterceptor的作用
 
  
某些通知会用到 MethodInvocation，在执行的时候，需要放在公共的位置，让所有的通知都能找到，如果某个通知想取的时候没取到，就会报如下错误：
 
  
Spring原理学习（八）AOP底层实现_第9张图片
 
  
如何放置？
 
  
ExposeInvocationInterceptor的作用就是将 MethodInvocation 放到当前线程，这样所有通知就都能获取到了，它同时也是个环绕通知，那把它放到最外层的环绕通知就可以了。
 
  
总结 
 
  
代理方法执行时会做如下工作
 
  
1. 通过 proxyFactory 的 getInterceptorsAndDynamicInterceptionAdvice() 将其他通知统一转换为 MethodInterceptor 环绕通知。这体现的是适配器设计模式
 
  
2. 所谓静态通知，体现在上面方法的 Interceptors 部分，这些通知调用时无需再次检查切点，直接调用即可
 
  
3. 结合目标与环绕通知链，创建 MethodInvocation 对象，通过它完成整个调用
 
  
3、模拟 MethodInvocation
 
  
用到的是职责链模式
 
  
public class A18_1 {

    static class Target {
        public void foo() {
            System.out.println("Target.foo()");
        }
    }

    static class Advice1 implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            System.out.println("Advice1.before()");
            Object result = invocation.proceed(); //调用下一个通知目标
            System.out.println("Advice1.after()");
            return result;
        }
    }

    static class Advice2 implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            System.out.println("Advice2.before()");
            Object result = invocation.proceed(); //调用下一个通知目标
            System.out.println("Advice2.after()");
            return result;
        }
    }

    static class MyInvocation implements MethodInvocation {

        private Object targrt;
        private Method method;
        private Object[] args;
        private List methodInterceptorList;
        private int count = 1; //调用次数

        public MyInvocation(Object targrt, Method method, Object[] args, List methodInterceptorList) {
            this.targrt = targrt;
            this.method = method;
            this.args = args;
            this.methodInterceptorList = methodInterceptorList;
        }

        @Override
        public Method getMethod() {
            return method;
        }

        @Override
        public Object[] getArguments() {
            return args;
        }

        @Override
        public Object proceed() throws Throwable { //调用每一个环绕通知，调用目标
            if (count > methodInterceptorList.size()) {
                //调用目标，返回并结束通知
                return method.invoke(targrt, args);
            }
            //逐一调用通知
            MethodInterceptor methodInterceptor = methodInterceptorList.get(count++ - 1);
            return methodInterceptor.invoke(this);
        }

        @Override
        public Object getThis() {
            return targrt;
        }

        @Override
        public AccessibleObject getStaticPart() {
            return method;
        }
    }

    public static void main(String[] args) throws Throwable {
        Target target = new Target();
        ArrayList list = new ArrayList<>();
        list.add(new Advice1());
        list.add(new Advice2());
        MyInvocation myInvocation = new MyInvocation(target, Target.class.getMethod("foo"), new Object[0], list);
        myInvocation.proceed();
    }
}

 
  
结果：
 
  
Advice1.before()
Advice2.before()
Target.foo()
Advice2.after()
Advice1.after()
 
  
 具体过程：
 
  
     
   
  1.  
    proceed() 方法调用链中下一个环绕通知
     
    2.  
   
  2.  
    每个环绕通知内部继续调用 proceed()
     
    3.  
   
  3.  
    调用到没有更多通知了, 就调用目标方法
     
    4.  
  
 
  
MethodInvocation 的编程技巧在实现拦截器、过滤器时能用上
 
  
六、动态通知调用
 
  
带参数绑定的通知方法调用
 
  
public class A19 {
    @Aspect
    static class MyAspect {
        @Before("execution(* foo(..))") //静态通知调用，不需要参数绑定，执行时不需要切点
        public void before1(){
            System.out.println("before1");
        }

        @Before("execution(* foo(..)) && args(x)") //动态通知调用，需要参数绑定，执行时需要切点对象
        public void before2(int x){
            System.out.printf("before2(%d)%n", x);
        }
    }

    static class Target {
        public void foo(int x) {
            System.out.printf("target foo(%d)%n", x);
        }
    }

    @Configuration
    static class MyConfig {
        @Bean
        AnnotationAwareAspectJAutoProxyCreator proxyCreator() {
            return new AnnotationAwareAspectJAutoProxyCreator();
        }

        @Bean
        public MyAspect myAspect() {
            return new MyAspect();
        }
    }

    public static void main(String[] args) throws Throwable {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean(ConfigurationClassPostProcessor.class);
        context.registerBean(MyConfig.class);
        context.refresh();
        
        AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
        Method findEligibleAdvisors = creator.getClass().getSuperclass().getSuperclass().
                getDeclaredMethod("findEligibleAdvisors", Class.class, String.class);
        findEligibleAdvisors.setAccessible(true);
        //找到和Target匹配的切面
        List list = (List) findEligibleAdvisors.invoke(creator, Target.class, "target");

        Target target = new Target();
        ProxyFactory factory = new ProxyFactory();
        factory.setTarget(target);
        factory.addAdvisors(list);
        //获取代理
        Object proxy = factory.getProxy();

        //把除了环绕通知以外的其他类型通知统一转换为环绕通知
        List interceptorList =
                factory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo", int.class), Target.class);

        for (Object o : interceptorList) {
            showDetail(o);
        }

        //创建并执行调用链
        Constructor constructor = ReflectiveMethodInvocation.class.getDeclaredConstructor(
                Object.class, Object.class, Method.class, Object[].class, Class.class, List.class);
        constructor.setAccessible(true);
        ReflectiveMethodInvocation methodInvocation = constructor.newInstance(
                proxy, target, Target.class.getMethod("foo", int.class), new Object[]{100}, Target.class, interceptorList);
        methodInvocation.proceed();
    }

    public static void showDetail(Object o) {
        try {
            Class clazz = Class.forName("org.springframework.aop.framework.InterceptorAndDynamicMethodMatcher");
            if (clazz.isInstance(o)) {
                Field methodMatcher = clazz.getDeclaredField("methodMatcher");
                methodMatcher.setAccessible(true);
                Field interceptor = clazz.getDeclaredField("interceptor");
                interceptor.setAccessible(true);
                System.out.println("环绕通知和切点:" + o);
                System.out.println("\t切点为：" + methodMatcher.get(o));
                System.out.println("\t通知为：" + interceptor.get(o));
            }else {
                System.out.println("普通环绕通知：" + o);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
} 
  
结果：
 
  
普通环绕通知：org.springframework.aop.interceptor.ExposeInvocationInterceptor@82de64a
普通环绕通知：org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@659499f1
环绕通知和切点:org.springframework.aop.framework.InterceptorAndDynamicMethodMatcher@47e2e487
	切点为：AspectJExpressionPointcut: (int x) execution(* foo(..)) && args(x)
	通知为：org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor@201a4587
before1
before2(100)
target foo(100)
 
  
InterceptorAndDynamicMethodMatcher：拦截器和动态的方法匹配器，内部包含了真正的环绕通知和切点，它并不是一个环绕通知，查看它的类就能知道。
 
  
class InterceptorAndDynamicMethodMatcher {
    // 环绕通知
    final MethodInterceptor interceptor;
    // 切点
    final MethodMatcher methodMatcher;

    public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {
        this.interceptor = interceptor;
        this.methodMatcher = methodMatcher;
    }
}
 
  
总结：
 
  
     
   
  1.  
    通过 proxyFactory 的 getInterceptorsAndDynamicInterceptionAdvice() 将其他通知统一转换为 MethodInterceptor 环绕通知
     
    2.  
   
  2.  
    所谓动态通知，体现在上面方法的 DynamicInterceptionAdvice 部分，这些通知调用时因为要为通知方法绑定参数，还需再次利用切点表达式
     
    3.  
   
  3.  
    动态通知调用复杂程度高，性能较低 
     
    4.  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring系列原理,spring原理)

        

            

                
    
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • git - Webhook让部署自动化
                        大猪大猪

                        
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • Faiss：高效相似性搜索与聚类的利器
                        网络·魚
大数据faiss
                        
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
    
                    
    • 
                    
  • 2022-08-28
                        蔚蓝一片晴

                        
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
    
                    
    • 
                    
  • STM32中的计时与延时
                        lupinjia
STM32stm32单片机
                        
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
    
                    
    • 
                    
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通
                        学习3人组
大数据大数据
                        
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • 5分钟说透AppStore审核原理，让你拥有上架新思路！
                        Q仔本人噢

                        
    在AppStore上架是越来越难了!相信非常多公司的技术人员都为此困扰，然而外包团队水平又层次不齐，容易遇坑，实在是内忧外患。是什么原因导致审核机制频繁调整？又是什么原因使得审核变得越发严格？那么接下来听小Q分解，马上给各位带来解答!首先看一下近一年的上下架的情况：近一年上架情况近一年下架情况通过数据我们发现越是马甲包产量权重高的分类里被下架的app数量越多，苹果此举可谓是上有政策，下有对策。通过
    
                    
    • 
                    
  • 2019-03-24
                        李飞720

                        
    姓名：李飞企业名称：临沂鑫道食品有限公司组别373期利他1组日精进打卡第338天】【知~学习】1、阿米巴经营一段2、活用人才1段3、活法、一段【行~实践】一、修身：读书、抽烟减量、俯卧撑个跑步3公里二、齐家、劝说老爸与姑姑和好三、建功、业务洽谈【经典名句分享】1、依据原理原则追求事物的本质，以“作为人，何谓正确”进行判断2、经营者必须为员工物质和精神两方面的幸福殚精竭虑，倾尽全力，必须超脱私心，让
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • 计算机木马详细编写思路
                        小熊同学哦
php开发语言木马木马思路
                        
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • 在RabbitMQ中四种常见的消息路由模式
                        Xwzzz_
rabbitmq分布式
                        
    1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • C++八股
                        Petrichorzncu
八股总结c++开发语言
                        
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现
                        Lenyiin
C++修炼全景指南技术指南c++数据结构stl
                        
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
    
                    
    • 
                    
  • 非对称加密算法原理与应用2——RSA私钥加密文件
                        私语茶馆
云部署与开发架构及产品灵感记录RSA2048私钥加密
                        
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
    
                    
    • 
                    
  • 为什么学生不喜欢上学
                        虾虾说

                        
    图片发自App《为什么学生不喜欢上学》作者是丹尼尔·威林厄姆。本书从认知心理学角度，结合大量实证案例，阐释了大脑工作的基本原理，回答了关于学习过程的一系列问题。为什么学生不喜欢上学？——大脑工作的基本原理思考是缓慢的、费力的、不可靠的。思考有三个要素，环境、工作记忆和长期记忆。环境是信息来源；长期记忆是知识、经验的巨型仓库，随时可以调取；工作记忆是中央处理器，是加工信息素材的中央厨房，也是思考过程
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 补充元象二面
                        Redstone Monstrosity
前端面试
                        
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                    
  • AI大模型的架构演进与最新发展
                        季风泯灭的季节
AI大模型应用技术二人工智能架构
                        
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
    
                    
    • 
                                
  • ztree设置禁用节点
                                    3213213333332132
JavaScriptztreejsonsetDisabledNodeAjax
                                    
    ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 
 
 
$(function(){            	
                showTree();
	            setDisabledNode();

});
                   
        
    
                                
    • 
                                
  • JVM patch by Taobao
                                    bookjovi
javaHotSpot
                                    
    在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。 
  
7050685：jsdbproc64.sh has a typo in the package name 
7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 
7060619：C1 should respect inline and
    
                                
    • 
                                
  • 将session存储到数据库中
                                    dcj3sjt126com
sqlPHPsession
                                    
    CREATE TABLE sessions (
  id CHAR(32) NOT NULL,
  data TEXT,
  last_accessed TIMESTAMP NOT NULL,
  PRIMARY KEY (id)
); 
  
<?php
/**
 * Created by PhpStorm.
 * User: michaeldu
 * Date
    
                                
    • 
                                
  • Vector
                                    171815164
vector
                                    
    public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) {
		for (int i = 0; i < cart.size(); i++) {
			if (cart.get(i).getId().equals(id)) {
				cart.remove(i);
				
    
                                
    • 
                                
  • 各连接池配置参数比较
                                    g21121
连接池
                                    
            排版真心费劲，大家凑合看下吧，见谅~ 
      
  
Druid 
DBCP 
C3P0 
Proxool   
数据库用户名称 Username Username User     
数据库密码 Password Password Password     
驱动名
    
                                
    • 
                                
  • [简单]mybatis insert语句添加动态字段
                                    53873039oycg
mybatis
                                    
          mysql数据库,id自增,配置如下： 
      
<insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id"
		parameterType=&
    
                                
    • 
                                
  • struts2拦截器配置
                                    云端月影
struts2拦截器
                                    
    struts2拦截器interceptor的三种配置方法 
方法1. 普通配置法 
 
<struts> 
    <package name="struts2" extends="struts-default"> 
        &
    
                                
    • 
                                
  • IE中页面不居中，火狐谷歌等正常
                                    aijuans
IE中页面不居中
                                    
    问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
    
                                
    • 
                                
  • String,int,Integer,char 几个类型常见转换
                                    antonyup_2006
htmlsql.net
                                    
    如何将字串 String 转换成整数 int? 
int i = Integer.valueOf(my_str).intValue(); 
 
int i=Integer.parseInt(str); 
 
如何将字串 String 转换成Integer ? 
Integer integer=Integer.valueOf(str); 
 
如何将整数 int 转换成字串 String ? 
1.
    
                                
    • 
                                
  • PL/SQL的游标类型
                                    百合不是茶
显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
                                    
    游标是oracle中的一个结果集,用于存放查询的结果; 
  
PL/SQL中游标的声明; 
1,声明游标

2,打开游标(默认是关闭的);

3,提取数据

4,关闭游标
 
  
  
注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标 
  
隐式游标:主要是对DML数据的操作隐
    
                                
    • 
                                
  • JUnit4中@AfterClass @BeforeClass @after @before的区别对比
                                    bijian1013
JUnit4单元测试
                                    
    一.基础知识 
JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
    
                                
    • 
                                
  • 精通Oracle10编程SQL(12)开发包
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *开发包
 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数）
 */
--包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成
--建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等
--在包规
    
                                
    • 
                                
  • 【EhCache二】ehcache.xml配置详解
                                    bit1129
ehcache.xml
                                    
    在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ 
ehcache.xml ： http://ehcache.org/ehcache.xml 
ehcache.xsd ： http://ehcache.org/ehcache.xsd 
ehcache配置文件的根元素是ehcahe 
  ehcac
    
                                
    • 
                                
  • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
                                    白糖_
javaeclipsespringtomcatWeb
                                    
    今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： 
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
 随后启动
    
                                
    • 
                                
  • angular.element
                                    boyitech
AngularJSAngularJS APIangular.element
                                    
    angular.element 
描述:      包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）       如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
    
                                
    • 
                                
  • java-给定两个已排序序列，找出共同的元素。
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class CommonItemInTwoSortedArray {

	/**
	 * 题目：给定两个已排序序列，找出共同的元素。
	 * 1.定义两个指针分别指向序列的开始。
	 * 如果指向的两个元素
    
                                
    • 
                                
  • sftp 异常，有遇到的吗？求解
                                    Chen.H
javajcraftauthjschjschexception
                                    
    com.jcraft.jsch.JSchException: Auth cancel 
 at com.jcraft.jsch.Session.connect(Session.java:460) 
 at com.jcraft.jsch.Session.connect(Session.java:154) 
 at cn.vivame.util.ftp.SftpServerAccess.connec
    
                                
    • 
                                
  • [生物智能与人工智能]神经元中的电化学结构代表什么?
                                    comsci
人工智能
                                    
         我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色.... 
 
     我们可以尝试一下...在某些神经
    
                                
    • 
                                
  • 通过LAC和CID获取经纬度信息
                                    dai_lm
laccid
                                    
    方法1： 
用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 
 
方法2： 
发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
    
                                
    • 
                                
  • JAVA的困难分析
                                    datamachine
java
                                    
    前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。 
  
-----------------------------------------------------------------------------------------
    
                                
    • 
                                
  • 小学5年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    money 钱 
paper 纸 
speak 讲，说 
tell 告诉 
  
remember 记得，想起 
knock 敲，击，打 
question 问题 
number 数字，号码 
  
learn 学会，学习 
street 街道 
carry 搬运，携带 
send 发送，邮寄，发射 
  
must 必须 
light 灯，光线，轻的 
front 
    
                                
    • 
                                
  • linux下面没有tree命令
                                    dcj3sjt126com
linux
                                    
    centos p安装 
yum -y install tree 
  
mac os安装 
brew install tree 
  首先来看tree的用法  
tree  中文解释：tree
功能说明：以树状图列出目录的内容。
语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
    
                                
    • 
                                
  • Map迭代方式，Map迭代，Map循环
                                    蕃薯耀
Map循环Map迭代Map迭代方式
                                    
    Map迭代方式，Map迭代，Map循环 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年
    
                                
    • 
                                
  • Spring Cache注解+Redis
                                    hanqunfeng
spring
                                    
    Spring3.1 Cache注解  
依赖jar包： 
<!-- redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			
    
                                
    • 
                                
  • Guava中针对集合的 filter和过滤功能
                                    jackyrong
filter
                                    
    在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： 
 
   

@Test
public void whenFilterWithIterables_thenFiltered() {
    List<String> names = Lists.newArrayList("John"
    
                                
    • 
                                
  • 学习编程那点事
                                    lampcy
编程androidPHPhtml5
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • 架构师之流处理---------bytebuffer的mark,limit和flip
                                    nannan408
ByteBuffer
                                    
    1.前言。 
  如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 
2.例子. 
 

例子代码:
     String str = "helloWorld";  
        ByteBuffer buff  = ByteBuffer.wrap(str.getBytes());  
        Sy
    
                                
    • 
                                
  • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1
                                    Everyday都不同
$转义el表达式
                                    
    最近在做Highcharts的过程中，在写js时，出现了以下异常： 
  
严重: Servlet.service() for servlet jsp threw exception 
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, 
    
                                
    • 
                                
  • 用Java实现发送邮件到163
                                    tntxia
java实现
                                    
    /*

 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。

 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。

 此篇仅介绍用
    
                                
    • 
                                
  • 探索实体类存在的真正意义
                                    java小叶檀
POJO
                                    
    一. 实体类简述   
 实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 
POJO（Plain Old Java Objects）简单的Java对象 
  
它的一般格式就是 
public class A{
      private String id;
      public Str
    
                                
    •