Spring Controller的private方法在AOP场景下的Null异常

先说结论再分析原因：

如果Controller存在AOP切面等动态代理行为，并且Controller注入了service bean，那么如果方法是private修饰，该方法在调用service时会报空指针异常，改为public/protected/包内权限 就可以了。

原因分析：

spring动态代理的实现方式

spring可以使用jdk proxy和cglib两种方式实现动态代理，其中cglib可以在编译期或者运行期实现切面逻辑织入

• jdk proxy适用于被代理类是某个接口类的实现
• cglib适用于被代理类没有实现某个接口，只能通过继承的方式重写被代理类的方法，实现逻辑织入，代理类名中一般有EnhancerBySpringCglib字样

java继承规则，private不能继承不代表不能调用

定义一个Student类：

public class Student {
    public void eat(String name) {
        System.out.println(name+"正在吃饭...");
    }
    private void sleep(String name){
        System.out.println(name+"正在偷偷睡觉...");
    }
}

写一个方法拦截器，模拟切面：

public class TargetInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method,
                            Object[] params, MethodProxy proxy) throws Throwable {
        System.out.println("调用前");
        Object result = proxy.invokeSuper(obj, params);
        System.out.println("调用后");
        return result;
    }
}

在Student类里加一个main方法：

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //创建字节码增强器
        Enhancer enhancer =new Enhancer();
        //设置父类
        enhancer.setSuperclass(Student.class);
        //设置回调函数
        enhancer.setCallback(new TargetInterceptor());
        //创建代理类，相当于上文中的EnhancerBySpringCglib类
        Student student=(Student)enhancer.create();

        Method eat = student.getClass().getMethod("eat", String.class);
        eat.setAccessible(true);
        eat.invoke(student,"王二杆子");
	//注意这里是获取Student类的方法，代理类没有继承到这个方法
        Method sleep = Student.class.getDeclaredMethod("sleep", String.class);
        sleep.setAccessible(true);
        sleep.invoke(student,"王二杆子");
        System.out.println("-----------------------");
        student.sleep("王二杆子");
    }

输出：

调用前
王二杆子正在吃饭...
调用后
王二杆子正在偷偷睡觉...
-----------------------
王二杆子正在偷偷睡觉...

解释：

调用eat方法，调用了代理类，代理类先执行拦截器（切面）逻辑，然后调用真实类，因为代理类继承并重写了Student的eat方法。
为什么sleep不行呢，因为sleep方法是私有的，不能被继承和重写，那么通过反射调用时，子类没有往父类找，
能找到就直接调用，因为父类引用指向子类对象，而且我们的main方法是写在Student类里面的，
可以通过反射，也可以直接调用，如果main写在外部，那么可以通过反射调用。

spring初始化过程

相信大家知道原因了，调用controller方法，先调代理类，但是现在代理类没办法继承并重写private方法，导致反射直接调用了代理类的父类的private方法，这个private方法调用了service bean，也就是代理类的属性，为null，自然会报NPE，那么问题来了，为什么spring不给代理类注入service bean，或者说有必要注入吗？接下来分析一下spring的初始化过程，看看究竟为什么没做😄

构建ApplicationContext大流程AbstractApplicationContext.refresh()方法

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);
			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				// Initialize message source for this context.
				initMessageSource();
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// Check for listener beans and register them.
				registerListeners();
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);
				// Last step: publish corresponding event.
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();
				// Reset 'active' flag.
				cancelRefresh(ex);
				// Propagate exception to caller.
				throw ex;
			}
			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

onRefresh中是最主要的逻辑，也就是实例化bean，然后初始化bean，如果初始化beanA依赖beanB，那么还会递归去做beanB的实例化和初始化

先明确两个概念，bean的实例化和bean的初始化，实例化相当于调用new，初始化相当于调用set方法，这里有一个很重要的接口 BeanPostProcessor 有两个方法

	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

见名知意，一个是初始化之前调用，一个是初始化之后调用，通过这个，我们可以根据我们的需求来干预bean的初始化，而代理，就是一个很常见的需求，比如我们需要AOP来实现日志，事务，异常处理，计时等等。 AnnotationAwareAspectJAutoProxyCreator 这个类实现了创建代理的功能，在它的父类 AbstractAutoProxyCreator.wrapIfNecessary() 方法里有创建代理的逻辑

Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

主要逻辑如下

// Configure CGLIB Enhancer...
Enhancer enhancer = createEnhancer();
if (classLoader != null) {
	enhancer.setClassLoader(classLoader);
	if (classLoader instanceof SmartClassLoader &&
		((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
		enhancer.setUseCache(false);
	}
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
	types[x] = callbacks[x].getClass();
}
// fixedInterceptorMap only populated at this point, after getCallbacks call above
enhancer.setCallbackFilter(new ProxyCallbackFilter(
	this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);

// Generate the proxy class and create a proxy instance.
return createProxyClassAndInstance(enhancer, callbacks);

复盘流程

实例化controller bean，然后调用populateBean()设置这个bean的属性值，service有值
然后在initializeBean()方法里调用创建代理的逻辑，那么创建出的代理bean，service是null
调用public方法，由于有AOP切面，调用的是代理类（子类）重写的方法
这重写的方法里，调用了被代理bean的方法，service有值，正常调用。
调用private方法，代理类（子类）无法重写方法，通过反射调用，
则调用到代理类的父类的方法，也就是被代理类的私有方法，可以调用，但是，service是null

方法栈如下，可以调试一下：