@Autowired注入的bean有的方法为null，有的方法不为null的情况

已于 2023-01-06 13:22:18 修改
阅读量1.3k 收藏 7
点赞数 3
分类专栏： java spring 文章标签： java spring aop
于 2023-01-06 13:10:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48709775/article/details/128576406
版权
java 同时被 2 个专栏收录
17 篇文章 0 订阅
订阅专栏
spring
1 篇文章 0 订阅
订阅专栏

目录

问题描述：

工作中遇到了一种情况：controller层中@Autowired注入的bean，在一些方法中是有值的，在一些方法中是null的情况。但是，之前都是没有问题的，突然有一天出现了这个问题。
测试案例：
controller类：

@RestController
public class AnnotationTest {

    @Autowired
    private TestController testController;

    @GetMapping("/hello")
    @Victor("hello")
    public void test(){
        System.out.println("hello");
        testController.proxy();
    }

    @GetMapping("/world")
    private void world() {
        System.out.println("world");
        testController.proxy();
    }
 }

controller注入的TestController类：

@RestController
public class TestController {

    @Autowired
    private InstanceAImpl instanceA;

    @GetMapping("/proxy")
    public void proxy(){
        instanceA.method("hello world", 100);
    }
}

调试注入为null

  • 由图可以看出注入的值为null，可以发现当前类为CGLIB代理类。
  • 代理类中的属性值为null。
    调试注入不为null
  • 调用hello接口时注入的属性值不为null。
  • 当前类非代理类。

Controller类是被aop代理的，切面类如下：

@Component
@Aspect
@Order(0)
public class AspectTest {
/**
 * 只切入带有@Victor注解的方法，@annotation只对方法进行切入
 */
@Pointcut("@annotation(com.victor.annotation.Victor)")
public void victorJoinPoint() {
}

@Around("victorJoinPoint() && @annotation(victor)")
    public Object victorInterceptor(ProceedingJoinPoint joinPoint, Victor victor) throws Throwable {
        System.out.println("before");
        System.out.println(victor.name());
        Object proceed = joinPoint.proceed();
        System.out.println("after");
        return proceed;
    }
}
  • AOP切面对带有@Victor注解的方法进入切入，因此，最后放入IOC容器内的AnnotationTest为CGLIB代理类，AOP对方法hello进行代理，但是对world方法不进行代理。

原因分析：

先说结论：
因为hello方法为public修饰，world方法为private修饰。将world方法修改为public修饰即可消除空指针问题。

如果被代理的方法为private，@Autowired则没有用。因为，private方法不会被aop代理，则调用invoke0(method, obj, args)方法时，由于代理类里没有这个方法则直接调用父类的方法，由于代理类是直接new出来的，则@Autowired属性值是null，非private方法是可以被代理的，调用被代理的方法时会调用DynamicAdvisedInterceptor.intercept(this,CGLIB$exam$0$Method, CGLIB$emptyArgs, CGLIB$exam$0$Proxy)在intercept方法内会调用完整的bean的方法，完整的bean里面@Autowired属性值是有值的。

详解：
先说动态代理CGLIB，如果AOP对某个类的某个方法进行切入时，则当前类会被动态代理CGLIB所代理。CGLIB利用动态字节码技术，生成代理类加载进内存。CGLIB采用继承目标类的方式进行代理。
通过一定技术可以查看生成的代理类，如下：
代理类

  • 第一个类为生成的目标代理类。
  • 第二个和第三个为快速调用切入方法而生成的快速调用类，这两个类不是今天讨论的重点。

代理类如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.victor.controller;

import java.lang.reflect.Method;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.SpringProxy;
import org.springframework.aop.TargetClassAware;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.Advised;
import org.springframework.aop.framework.AopConfigException;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Dispatcher;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.cglib.proxy.NoOp;

public class AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59 extends AnnotationTest implements SpringProxy, Advised, Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private MethodInterceptor CGLIB$CALLBACK_1;
    private NoOp CGLIB$CALLBACK_2;
    private Dispatcher CGLIB$CALLBACK_3;
    private Dispatcher CGLIB$CALLBACK_4;
    private MethodInterceptor CGLIB$CALLBACK_5;
    private MethodInterceptor CGLIB$CALLBACK_6;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$hello$0$Method;
    private static final MethodProxy CGLIB$hello$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.victor.controller.AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        CGLIB$hello$0$Method = ReflectUtils.findMethods(new String[]{"hello", "()V"}, (var1 = Class.forName("com.victor.controller.AnnotationTest")).getDeclaredMethods())[0];
        CGLIB$hello$0$Proxy = MethodProxy.create(var1, var0, "()V", "hello", "CGLIB$hello$0");
    }

    final void CGLIB$hello$0() {
        super.hello();
    }

    public final void hello() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$hello$0$Method, CGLIB$emptyArgs, CGLIB$hello$0$Proxy);
        } else {
            super.hello();
        }
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_5;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_5;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_6;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_6;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch (var10000.hashCode()) {
            case -792725149:
                if (var10000.equals("hello()V")) {
                    return CGLIB$hello$0$Proxy;
                }
                break;
            case -508378822:
                if (var10000.equals("clone()Ljava/lang/Object;")) {
                    return CGLIB$clone$4$Proxy;
                }
                break;
            case 1826985398:
                if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                    return CGLIB$equals$1$Proxy;
                }
                break;
            case 1913648695:
                if (var10000.equals("toString()Ljava/lang/String;")) {
                    return CGLIB$toString$2$Proxy;
                }
                break;
            case 1984935277:
                if (var10000.equals("hashCode()I")) {
                    return CGLIB$hashCode$3$Proxy;
                }
        }

        return null;
    }

    public final void addAdvice(int var1, Advice var2) throws AopConfigException {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).addAdvice(var1, var2);
    }

    public final void addAdvice(Advice var1) throws AopConfigException {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).addAdvice(var1);
    }

    public final void addAdvisor(int var1, Advisor var2) throws AopConfigException {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).addAdvisor(var1, var2);
    }

    public final void addAdvisor(Advisor var1) throws AopConfigException {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).addAdvisor(var1);
    }

    public final void setTargetSource(TargetSource var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).setTargetSource(var1);
    }

    public final TargetSource getTargetSource() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).getTargetSource();
    }

    public final void setPreFiltered(boolean var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).setPreFiltered(var1);
    }

    public final boolean isPreFiltered() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).isPreFiltered();
    }

    public final Class[] getProxiedInterfaces() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).getProxiedInterfaces();
    }

    public final boolean isInterfaceProxied(Class var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).isInterfaceProxied(var1);
    }

    public final Advisor[] getAdvisors() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).getAdvisors();
    }

    public final int getAdvisorCount() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).getAdvisorCount();
    }

    public final void removeAdvisor(int var1) throws AopConfigException {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).removeAdvisor(var1);
    }

    public final boolean removeAdvisor(Advisor var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).removeAdvisor(var1);
    }

    public final boolean replaceAdvisor(Advisor var1, Advisor var2) throws AopConfigException {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).replaceAdvisor(var1, var2);
    }

    public final boolean removeAdvice(Advice var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).removeAdvice(var1);
    }

    public final String toProxyConfigString() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).toProxyConfigString();
    }

    public final boolean isProxyTargetClass() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).isProxyTargetClass();
    }

    public final void setExposeProxy(boolean var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        ((Advised)var10000.loadObject()).setExposeProxy(var1);
    }

    public final boolean isExposeProxy() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).isExposeProxy();
    }

    public final int indexOf(Advice var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).indexOf(var1);
    }

    public final int indexOf(Advisor var1) {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).indexOf(var1);
    }

    public final boolean isFrozen() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((Advised)var10000.loadObject()).isFrozen();
    }

    public final Class getTargetClass() {
        Dispatcher var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }

        return ((TargetClassAware)var10000.loadObject()).getTargetClass();
    }

    public AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59 var1 = (AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            Callback[] var10001 = (Callback[])var10000;
            var1.CGLIB$CALLBACK_6 = (MethodInterceptor)((Callback[])var10000)[6];
            var1.CGLIB$CALLBACK_5 = (MethodInterceptor)var10001[5];
            var1.CGLIB$CALLBACK_4 = (Dispatcher)var10001[4];
            var1.CGLIB$CALLBACK_3 = (Dispatcher)var10001[3];
            var1.CGLIB$CALLBACK_2 = (NoOp)var10001[2];
            var1.CGLIB$CALLBACK_1 = (MethodInterceptor)var10001[1];
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)var10001[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59 var10000 = new AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        throw new IllegalStateException("More than one callback object required");
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59 var10000 = new AnnotationTest$$EnhancerBySpringCGLIB$$5c3ecc59;
        switch (var1.length) {
            case 0:
                var10000.<init>();
                CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
                return var10000;
            default:
                throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        Object var10000;
        switch (var1) {
            case 0:
                var10000 = this.CGLIB$CALLBACK_0;
                break;
            case 1:
                var10000 = this.CGLIB$CALLBACK_1;
                break;
            case 2:
                var10000 = this.CGLIB$CALLBACK_2;
                break;
            case 3:
                var10000 = this.CGLIB$CALLBACK_3;
                break;
            case 4:
                var10000 = this.CGLIB$CALLBACK_4;
                break;
            case 5:
                var10000 = this.CGLIB$CALLBACK_5;
                break;
            case 6:
                var10000 = this.CGLIB$CALLBACK_6;
                break;
            default:
                var10000 = null;
        }

        return (Callback)var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch (var1) {
            case 0:
                this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
                break;
            case 1:
                this.CGLIB$CALLBACK_1 = (MethodInterceptor)var2;
                break;
            case 2:
                this.CGLIB$CALLBACK_2 = (NoOp)var2;
                break;
            case 3:
                this.CGLIB$CALLBACK_3 = (Dispatcher)var2;
                break;
            case 4:
                this.CGLIB$CALLBACK_4 = (Dispatcher)var2;
                break;
            case 5:
                this.CGLIB$CALLBACK_5 = (MethodInterceptor)var2;
                break;
            case 6:
                this.CGLIB$CALLBACK_6 = (MethodInterceptor)var2;
        }

    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0, this.CGLIB$CALLBACK_1, this.CGLIB$CALLBACK_2, this.CGLIB$CALLBACK_3, this.CGLIB$CALLBACK_4, this.CGLIB$CALLBACK_5, this.CGLIB$CALLBACK_6};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
        this.CGLIB$CALLBACK_1 = (MethodInterceptor)var1[1];
        this.CGLIB$CALLBACK_2 = (NoOp)var1[2];
        this.CGLIB$CALLBACK_3 = (Dispatcher)var1[3];
        this.CGLIB$CALLBACK_4 = (Dispatcher)var1[4];
        this.CGLIB$CALLBACK_5 = (MethodInterceptor)var1[5];
        this.CGLIB$CALLBACK_6 = (MethodInterceptor)var1[6];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}
  • 代理类继承了目标类AnnotationTest。
  • 代理类对方法hello进行了重写，但是没有对world方法进行重新。
  • 调用重写的hello方法，其实是调用了var10000.intercept(this, CGLIB$hello$0$Method, CGLIB$emptyArgs, CGLIB$hello$0$Proxy);其实就是调用了DynamicAdvisedInterceptor.intercept(this,CGLIB$exam$0$Method, CGLIB$emptyArgs, CGLIB$exam$0$Proxy)。
  • 从第一张图片中可以看出代理类中的this.CGLIB$CALLBACK_0就是DynamicAdvisedInterceptor。

spring中的AOP执行流程就是根据代理类生成代理对象，当调用hello方法时就会调用代理类重写的hello方法，代理类方法调用DynamicAdvisedInterceptor.intercept()方法，在这个intercept方法中会拿到完整生命周期的AnnotationTest bean对象，这个bean对象是有注入的TestController bean的。但是代理对象的属性TestController 却是空的，因为代理对象是直接new出来的。

AOP代理是无法对private方法进行代理的。 因此，world方法是没有被重写的，所以，当调用world方法时，是调用了代理类父类的world方法，但是代理类中的属性却是null的，所以，就会出现这个问题。

SpringWeb调用接口方法是没有对接口类进行动态代理的。所以，如果Controller没有被AOP的话，带有private修饰的接口拿到的属性也是有值的。
如下所示：
未被代理的类

如图所示，如果Controller没有被动态代理时，private修饰的接口内的属性也是有值的。这就是为什么项目内的某个接口突然不能用的原因，之前Controller类没有被AOP代理过，即使接口是private修饰也不影响接口的调用，当Controller类被突然代理时，被private修饰的接口就不能用了。

所以，当Controller类中的接口为private修饰时，这个Controller类必不能被AOP所代理，否则接口会抛空指针。如果这个类被代理时，接口必须为public修饰。

victorgk
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解SpringBoot 多线程处理任务 无法@Autowired注入bean问题解决
08-25
SpringBoot 多线程处理任务中无法@Autowired注入bean问题解决 在 SpringBoot 应用程序中，多线程处理任务是一个常见的场景，但是，在多线程处理任务中无法使用 @Autowired 注入 bean，这是一个常见的问题。今天，...
自定义标签中@Autowired的属性为null
01-25
自定义标签中@Autowired的属性为null 解决办法：两步 1.新建一个类SpringContext，实现接口ApplicationContextAware; 2.spring.xml中添加<bean id="" class="com............SpringContext"> 3.使用SpingContext....
关于springboot读取配置类，使用@Autowired自动注入为null的问题
初心不改
02-15 1876
springboot普通类调用配置类 自动注入为null的问题
@autowired 注入进来对象为null的几种场景及解决办法
初夏0811的博客
06-01 3401
Autowired 注解用于自动注入 Spring 容器中管理的依赖对象。如果是配置类中的 @Bean 方法注入失败，可能是该方法没有被标记为 @Bean 或者方法所在的类没有使用 @Configuration 注解。
@Configuration使用@Autowired注入Bean为null解决办法
m0_52934670的博客
11-12 7821
以前经常在@Configuration注解的配置类中使用@Autowired注入依赖的Bean，像下面这样 @Configuration public class IotServerConfig { @Autowired SocketClientManager clientManager; @Value("${iot.tcp.port}") private Integer port; @Bean public IotServer iotServer(
Spring项目中多线程通过@Autowired注入bean对象一直为null问题
zdw_zoro的博客
05-18 3067
Spring项目中多线程通过@Autowired注入bean对象一直为null问题 转自https://blog.csdn.net/qiuqiu886/article/details/102565029?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&depth_1-utm_source=distribute.pc_r
测试类使用@Autowired注入的bean为null
稚彦的博客
09-18 5991
SpringBoot项目编写测试用例，在测试类中使用@Autowired注解拿到bean的值为null。 public class OrderBookServiceTest { @Autowired private OrderBookService orderBookService; //null @Test @Transactional public void testHandleJson(){ String msg="{\"asks\":[
@Autowired注入Bean为Null，通过spring工具类获取bean
qq_16733389的博客
04-09 490
第一种 import org.springframework.beans.BeansException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.s
[已解决]@Autowired 失效、@Autowired 注入为null
最新发布
wwxb_06的博客
07-12 689
问题：@Autowired 失效、@Autowired 注入为null，使用@Atuowried注入Bean失败，导致空指针异常。 原因： （1）被注入的对象没有加载到Spring容器中 （2）自定义配置存在问题 （3）被注入的对象不是Spring加载 （4）需要自动注入的对象存在被new出来的实例 解决方案： 确实需要在这个new 的类去注入某些类，但是用@Autowired 又注入为null,这时候就需要去**实现ApplicationContextAware接口，拿到IOC容器，实现手动获取Bean。
@Component类 @Autowired注入为null
weixin_43560781的博客
01-19 598
@Component类 @Autowired注入为null解决一：解决二： 解决一： public class TestBean { public static TestBean testBean; @PostConstruct public void init() { testBean = this; testBean .test= this.test; } //代替@AutoWired取该类 public static TestBean getIn
关于@Autowired注入bean为NULL的解决方案（楼主亲测有效，一条语句搞定）
向小凯同学学习
11-04 7415
今天遇见这样一个问题，在使用@Autowired注入类的时候，一直报为NULL的空指针的错误。 错误截图 这个CommonService是在其他包中定义的。 那么在另外的包中使用的时候，可能会因为一系列的原因，出现注入失败。 bean为NULL，总得来说还是加载不到Bean。 报错就是空指针 Caused by: java.lang.NullPointerException: nul...
详解Spring关于@Resource注入为null解决办法
08-26
但是，在实际开发中，经常会遇到 @Resource 注解的对象为 null 的问题。本文将详细介绍 Spring 中 @Resource 注解解决 null 问题的方法。 一、问题背景 在使用 Spring 框架时，经常会在 DAO 层使用 @Repository ...
你所不知道的Spring的@Autowired实现细节分析
09-07
在Spring框架中，`@Autowired`注解是一种自动装配依赖的方式，它允许开发者在不编写显式依赖注入代码的情况下，自动将Bean的依赖注入到需要的地方。本文将深入探讨`@Autowired`的实现原理。 1. **BeanPostProcessor...
SSH笔记-通过@Autowired配置注入关系
06-10
如果Spring找不到匹配的Bean，它不会抛出异常，而是允许属性保持为`null`。 3. **多个候选Bean**：如果有多个相同类型的Bean，可以通过`@Qualifier`注解指定特定的Bean。`@Qualifier`允许你通过Bean的名称来精确...
logback配置的日志相对路径
weixin_48709775的博客
05-17 7063
前言 当项目用容器部署时，会有项目日志的存放路径问题，如果路径用绝对路径，那么会有Windows环境和Linux环境不一致问题，因此logback日志存放路径的配置要使用相对路径，但是相对路径基于什么位置却是一个问题。 验证 如何验证的就不贴了，咱们直接说结论 结论 logback配置里的相对路径是基于Dockfile里的WORKDIR来的，如果不配置默认就是/，配置的话相对于配置的工作路径。 logback.xml 其中的LOG_HOME采用相对路径的方式，日志存放在…/logs文件夹里。 <con
SSM框架整合：各种配置文件的整合和详解
weixin_48709775的博客
12-11 4807
SSM框架整合：各种配置文件的整合和详解 前言 学习了ssm框架的整合之后，对于数量众多的配置文件，和各种不同的配置方式感到甚是头疼，接下来教给大家一个清晰明白的配置，分门别类的配置不同的xml文件。 项目目录 名称 作用 mapper mybatis映射文件 spring spring家族配置文件=context为父(全局性)+mybatis整合+transaction事务+mvc config druid配置文件 log4j log4j.properties文件 w
事务传播行为的失效（异常传递）
weixin_48709775的博客
02-15 917
事务传播行为的失效（异常传递） 众所周知，事务的传播行为一共有7种，7种传播行为具体有什么特征在这里不再赘述，详情参考https://zhuanlan.zhihu.com/p/256263914，本文主要对对于传播行为失效进行探究，旨在对于事务的使用时对于细节的把控。 在这里引出第一个问题： 1.为什么我用@Transactional(propagation = Propagation.REQUIRES_NEW)却得到了意想不到的结果？ 首先，由于spring中的事务底层采用的是jdk或cglib的动态代
但是使用@Autowired注入的为null
05-30
如果使用@Autowired注入的SqlSessionFactory为null，可能有以下几个原因： 1. 检查是否在dataSourceConfig类上添加了@Configuration注解，该注解用于标识该类为配置类，告诉Spring容器需要进行扫描和解析。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值