mummyFly
mummyFly

Spring源码阅读——记录一次非典型异常排查

最近在做微服务技术方案调研，因为eureka的闭源，注册中心准备启用consul，同时consul还可以把配置中心的活干了。搭了一个简单的springboot2.0+consul2.1的demo，模拟了一下配置中心的任务，没啥问题，准备跟现有项目合并，结果合并后springboot无法正常启动，报了一个很诡异的错误：

[WARN] [main] 2019-01-03 12:10:14,408 org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext : log 87 - Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanInitializationException: Failed to process @EventListener annotation on bean with name 'consulAutoServiceRegistration'; nested exception is java.lang.IllegalStateException: Need to invoke method 'bind' declared on target class 'AbstractAutoServiceRegistration', but not found in any interface(s) of the exposed proxy type. Either pull the method up to an interface or switch to CGLIB proxies by enforcing proxy-target-class mode in your configuration. 

这个错误看起来没什么大不了的，甚至于spring只是将其列为了一个warning，还很贴心的给了一大堆错误提示，简单理解一下就是说consulserviceautoconfig这个类在初始化过程中报错了，因为没有找到类的接口定义，但是又使用了jdk的动态代理，导致无法进一步执行bind方法注入，还给出了推荐强制使用cglib代理的解决方案。但其实这个问题没那么简单。首先项目中我们已经配置了aop的代理模式为cglib，其次如果一个类没有实现接口，spring难道不应该在初始化bean的时候就自动去采用cglib代理么？

问题排查的话，先去看一眼报错的类ConsulAutoServiceRegistrationAutoConfiguration：

    @Bean
	@ConditionalOnMissingBean
	public ConsulAutoServiceRegistration consulAutoServiceRegistration(
			ConsulServiceRegistry registry,
			AutoServiceRegistrationProperties autoServiceRegistrationProperties,
			ConsulDiscoveryProperties properties,
			ConsulAutoRegistration consulRegistration) {
		return new ConsulAutoServiceRegistration(registry,
				autoServiceRegistrationProperties, properties, consulRegistration);
	}

方法注入的bean名称默认为方法名，这点方便后面找ConsulAutoServiceRegistration的实例bean，继续看一眼ConsulAutoServiceRegistration类本身没有bind方法，实现在其父类AbstractAutoServiceRegistration：

    @EventListener(WebServerInitializedEvent.class)
	public void bind(WebServerInitializedEvent event) {
		ApplicationContext context = event.getApplicationContext();
		if (context instanceof ConfigurableWebServerApplicationContext) {
			if ("management".equals(
					((ConfigurableWebServerApplicationContext) context).getServerNamespace())) {
				return;
			}
		}
		this.port.compareAndSet(0, event.getWebServer().getPort());
		this.start();
	}

初步判定，在进行EventListener注解绑定的时候出现了问题。下一步该干嘛呢？当然不是百度。简单的配置问题百度一下固然可以，但是这个问题明显有点非典型，先不说能不能百度到，即便是百度到答案，不明白为啥会出这样的问题，以后再遇到也一样懵逼。所以解决spring的问题，最好的办法就是，翻源码。

排查之前我们首先要整理一下现有的线索，我们目前已知的线索如下：

  1. 项目确认已经配置了aop:proxy-target-class属性为true，强制使用cglib代理，观察启动日志也可以见到cglib相关代理类的初始化信息，可以验证cglib模块工作正常。
  2. ConsulAutoServiceRegistration的初始化发生了问题，而且问题并不是发生在初始化阶段，而是在实例初始化完成后，进行下一步的实例内部注解的解析封装时出现了问题。

线索2的得出是基于之前对bean初始化过程的一定了解。spring的bean初始化大体上分成加载bean定义，初始化bean实例，执行BeanProcessor处理器。这里涉及一个概念就是BeanProcessor，为了方便称之为bean处理器。bean处理器用来对bean做额外操作，例如修改bean的相关属性。Spring提供了一个BeanPostProcessor接口，用来给开发人员使用。很多人理解BeanProcessor一定会在Bean初始化完成后执行，其实不然。这里主要看如何定义Bean初始化完成这个动作。DefaultListableBeanFactory是一个常用的工厂类，我们看一下其中创建bean的逻辑：

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isDebugEnabled()) {
			logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction)
											((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

方法整体上由两个大循环构成，其中第一个循环负责初始化bean，第二个循环用来进行bean初始化后的回调工作。以本次出问题的ConsulAutoServiceRegistration类为例，第一个循环中会创建ConsulAutoServiceRegistration的bean实例，并且同时调用该bean所属的Context中包含的所有BeanProcessor，对bean进行必要性的处理，其中如果涉及aop的相关逻辑，在此时生成的bean对象，本身就已经是一个代理对象：


	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
        //getBeanPostProcessor会返回该context下所包含的所有类型为BeanProcessor的bean，包括用户
        //自定义的BeanPostProcessor接口
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
            //result代表返回的bean实例，current是由各个processor生成的结果，这些结果根据各个 
            //processor的内部逻辑，有可能是普通对象也有可能是代理对象
			result = current;
		}
		return result;
	}



所以BeanPostProcessor接口的执行时机，并不是我们普通意义上的Bean实例化完成后，而是在bean实例被创建以后，尚未完全实例化的过程中执行。那么什么叫Bean的完全实例化？还是以DefaultListableBeanFactory为例，在该工厂中默认注册了一个DefaultSingletonBeanRegistry这样一个策略类，负责对单例bean的获取销毁等工作。当中有这样一个方法：


	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}


任何一个bean都会在初始化到一定阶段后调用该方法，一般而言，只要进入了this.singletonObjects这个map中的bean，都可以视为完全初始化。但这只是完成了我们DefaultListableBeanFactory的第一个循环，也就是说这个阶段的bean对程序员而言并不是完全可用的，很多bean内部方法属性的初始化还在进行中，例如这次bind方法的EvenHandler注解。


了解这些以后，大概可以猜想到问题所在一定是初始化过程中，spring错误的将ConsulAutoServiceRegistration类注册成了一个jdk的代理类，然后想要继续初始化EventHandler注解时出错。所以排查的方向上，我们并不用去关心EventHandler注解的实现方式，也不要去关心ConsulAutoServiceRegistration这个类为啥不去使用cglib代理，因为bean本身并不会生成一个代理类，spring默认生成bean只会调用bean的工厂方法或者构造方法二者选其一，既然是代理类出了问题，我们最终问题排查的方向一定是加工该代理类的BeanProcessor。下面将会带着大家一步一步的重现问题的排查过程，同时也是对spring整体bean初始化的一个源码阅读，只不过我们的方向跟传统的阅读方向不同，一般阅读bean初始化都是从ioc容器初始化开始，我们这次算是逆过程，一步一步的从一个创建好的bean倒退回去，看一下spring在bean的创建过程中到底做了什么。当然过程中我们要重点关注processor的处理逻辑


在我们开始排查之前，我们务必要精通IDE的debug调试工具，无论你用的是eclipse还是idea，debug时条件的判断，数组的展开，栈帧的查看都是必要手段，这里先不展开讲，笔者用的idea。我们首先去到车祸现场，也就是ConsulAutoServiceRegistrationAutoConfiguration这个报错类，在bean实例化时打入断点：


Spring源码阅读——记录一次非典型异常排查_第1张图片


这里简单讲一下我们如何找到这里，毕竟这是问题排查的第一步。其实思想很简单，既然是bean的初始化出了问题，我们首先要去找的一定是这个bean在哪里被定义的，也就是初始化的源头。找到ConsulAutoServiceRegistration类之后我们首先发现这个类并没有被标示为一个bean：


Spring源码阅读——记录一次非典型异常排查_第2张图片


然后我们在整个项目目录下寻找有调用ConsulAutoServiceRegistration这个类的地方，然后点进去就能得到答案了：


Spring源码阅读——记录一次非典型异常排查_第3张图片


回到我们刚才打断点的地方，代码执行到这里的时候，我们看一下栈帧：


Spring源码阅读——记录一次非典型异常排查_第4张图片


以此为基础，我们一步一步点过去，一直看到AbstractAutowiredCapableBeanFactory的createBeanInstance方法，我们断点打在了new语句，也就是bean刚刚准备实例化的起点，所以此时我们看到的第一个方法就是创建bean实例的方法：


	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class beanClass = resolveBeanClass(mbd, beanName);

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null)  {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// Need to determine the constructor...
		Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}



代码内容很简单这里不详细讲，主要是判断初始化bean的时候采用哪种方式，工厂方式，有参构造函数，或者最后一种默认的无参构造函数构建，也就是上面所说的bean在初始化时并不会直接生成代理对象的依据，继续往上走，还是这个类，我们进入到doCreateBean方法:


	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		...

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		...

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			...
		}

		// Register bean as disposable.
		...

		return exposedObject;
	}



代码略长做了部分删减，这里我们着重注意两个方法，一个是在当前栈中能看到的createBeanInstance方法，负责实例化bean，另外就是实例化之后的初始化工作，也就是最终返回值exposedObject的加工者initializeBean方法，当然代码执行到这里还没进入初始化部分，我们先略过，继续往上跟，一直到AbstractApplicationContext中的finishBeanFactoryInitialization方法，


	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		...

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}



然后向上看调用者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，finally
		}
	}



对spring稍微有了解的人都知道，refresh方法时spring各个context中的核心方法，spring整个ioc容器的启动也就是调用各个context的refresh方法的过程。至于这个方法是在哪被调用的，感兴趣的同学可以继续顺着栈帧向上走，你会发现最终的入口就是springboot的main方法中调用的run方法，该方法在初始化准备好context环境后就进入了ioc容器的初始化部分，也就是refresh方法。


refresh方法的倒数第二步，finishBeanFactoryInitialization方法，根据名字来看这是负责完成Bean工厂的初始化，但其实Bean的创建初始化逻辑也在这个方法之中，同时我们也要注意靠上的invokeBeanFactoryPostProcessors方法，该方法负责在容器初始化时注入context所有的processor。


至此我们了解了整个bean创建之前的逻辑，接下来我们逐步的去跟踪代码，会发现创建bean的主要过程都集中在AbstractAutowiredCapableBeanFactory的doCreateBean方法中，毕竟该方法是直接返回创建的bean，那么在跟踪这个方法时，我们要重点关注返回值exposeObject的变化，


Spring源码阅读——记录一次非典型异常排查_第5张图片


 代码继续执行过initializeBean方法：Spring源码阅读——记录一次非典型异常排查_第6张图片


到此，我们可以初步判定，问题发生在initializeBean方法内。虽然我们此时还不清楚这个方法内部做了什么，但从结果上可以清晰的看到，这个方法改变了createBean方法的返回值，从而导致了后面异常的发生。那么下面的重点就是弄清楚initializeBean方法内部逻辑。


我们先看一眼代码：


	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

可以清楚的看到我们熟悉的BeanPostProcessor接口中，两个方法的执行时机。这里的invokeInitMethods可以暂时忽略，该方法并不是创建bean，而是对一个创建好的bean进行属性注入，我们继续采用之前的策略，跟踪返回值wrappedBean，我们可以看到wrappedBean一开始的值与创建好的bean一致，后面只有两个更改值的过程，也就是BeanPostProcessor的两个方法，根据代码执行中wrapperBean值的变化，我们观察到在ConsulAutoServiceRegistration这个bean的初始化中，applyBeanPostProcessorsAfterInitialization方法改变了返回值：


	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}


该方法的作用非常清晰，遍历所有的BeanPostProcessor，然后执行Processor的逻辑。


代码调试到这里，我们算是完成了第二阶段，定义到了直接改变bean的地方。但是问题并没有解决，接下来我们还需要知道两件事：


    

  1. 到底是哪个BeanProcessor使用了错误的代理方式？
    2. 

  2. 这个BeanProcessor为何会选择jdk代理模式？
    3. 



解决第一个问题，我们需要idea的帮助：


Spring源码阅读——记录一次非典型异常排查_第7张图片


我们首先打一个条件断点，根据name，不断的去监控方法中current与result的值变化，看看究竟是哪一个processor改变了result的值，当我们执行到DefaultAdvisorAutoProxyCreator的时候，我们能明显发现变化的发生地：


Spring源码阅读——记录一次非典型异常排查_第8张图片


至此，我们解决了目前需要解决的第一个问题，是谁修改了 ConsulAutoServiceRegistration这个bean的返回值，答案很明显。那么接下来我们就要去解决第二个问题，DefaultAdvisorAutoProxyCreator这个processor抽什么风，为啥要去用jdk的动态代理方案？


关于jdk代理和cglib代理的区别，大家可以自行百度，源码也可以稍微翻一下。这里我们继续去解决DefaultAdvisorAutoProxyCreator使用jdk代理的问题，我们继续跟进postProcessAfterInitialization这个方法，DefaultAdvisorAutoProxyCreator本身并没有实现这个方法，该方法的实现在其父类AbstractAutoProxyCreator中：


	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (!this.earlyProxyReferences.contains(cacheKey)) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}


 看代码或者debug都能知道，问题一定在wrapIfNecessary方法中：


	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}


我们很容易看到代码createProxy，继续往下走：


	protected Object createProxy(Class beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);

		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}

		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}

		return proxyFactory.getProxy(getProxyClassLoader());
	}


在这段创建代理对象的前置准备代码中，我们注意proxyFactory.copyFrom方法。我们进入到返回值调用的getProxy方法：




可以看到getProxy方法已经开始多态，那么决定实现方式的一定是createAopProxy方法，继续跟进，我们最终会进入到DefaultAopProxyFactory的createAopProxy方法：


	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}


 这里很明显是用来区分代理种类，而且很显然默认采用了jdk代理，这过程中我们注意到config.isProxyTargetClass，根据debug工具的反馈，DefaultAdvisorAutoProxyCreator也有这个属性，但问题是，这个属性为false！


关于配置文件中的aop:proxy-target-class属性如何被读取的，限于篇幅我们不展开讲，感兴趣的同学可以去加载BeanDefine的代码中找一下，不复杂，就是映射到ProxyConfig这个类中，覆盖类的原有属性。其实在之前对AbstractAutowiredCapableBeanFactory类的applyBeanPostProcessorsAfterInitialization方法的跟踪中我们也可以看到，大部分的processor的属性都为true，唯独DefaultAdvisorAutoProxyCreator例外。那么为何DefaultAdvisorAutoProxyCreator的属性值为false呢？


到这里我们需要整理一下思路，既然DefaultAdvisorAutoProxyCreator属性出了问题，那么我们就需要去查一下DefaultAdvisorAutoProxyCreator这个processor的初始化过程。回到AbstractAutowiredCapableBeanFactory中的applyBeanPostProcessorsAfterInitialization方法：


 Spring源码阅读——记录一次非典型异常排查_第9张图片


我们关注一下processor是从哪里获取的，进入到getBeanPostProcessors 方法内部：


	public List getBeanPostProcessors() {
		return this.beanPostProcessors;
	}


既然获取的是实例变量，我们利用IDEA查看一下BeanPostProcessors这个变量被调用的地方：


Spring源码阅读——记录一次非典型异常排查_第10张图片


如果要增加一个processor，必然要调用List.add方法， 借此我们找到了add方法：


	public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
		Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
		this.beanPostProcessors.remove(beanPostProcessor);
		this.beanPostProcessors.add(beanPostProcessor);
		if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
			this.hasInstantiationAwareBeanPostProcessors = true;
		}
		if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
			this.hasDestructionAwareBeanPostProcessors = true;
		}
	}


在试图寻找addBeanPostProcessor的调用者时，我们发现调用这个方法的地方很多，所以这里我们换种策略，在add方法打一个条件断点：


Spring源码阅读——记录一次非典型异常排查_第11张图片


通过栈帧信息，我们一步一步往上推，找到PostProcessorRegistrationDelegate类中的registerBeanPostProcessor方法：


	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List priorityOrderedPostProcessors = new ArrayList<>();
		List internalPostProcessors = new ArrayList<>();
		List orderedPostProcessorNames = new ArrayList<>();
		List nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);



方法开始定义了一个局部变量，postProcessorNames，该方法获取某一个类型下的所有bean的名称，我们跟踪这个方法，回到DefaultListableBeanFactory中的doGetBeanNamesForType方法：


	private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
		List result = new ArrayList<>();

		// Check all bean definitions.
		for (String beanName : this.beanDefinitionNames) {
			// Only consider bean as eligible if the bean name
			// is not defined as alias for some other bean.
			if (!isAlias(beanName)) {
            ...


代码很长，我们不需要看全，这里明显发现beanName是从beanDefinitionNames数组中获取，我们利用查DefaultAdvisorAutoProxyCreator的方法，查找这个实例变量add方法的调用处：


Spring源码阅读——记录一次非典型异常排查_第12张图片


 进入该方法，debug调试后找到该bean的定义：


Spring源码阅读——记录一次非典型异常排查_第13张图片


至此，问题开始清晰，我们进入到JavaMelodyAutoConfiguration，搜索一下DefaultAdvisorAutoProxyCreator：


Spring源码阅读——记录一次非典型异常排查_第14张图片


 其实对spring的bean生命周期熟悉的话，在之前我们发现DefaultAdvisorAutoProxyCreator的属性值不对的时候，就可以着手去找这个bean的定义地点，先检查是不是覆盖掉了配置文件中的设置。这里的DefaultAdvisorAutoProxyCreator只是单纯的新建对象，并没有做任何属性处理。


文中其实还少了一个部分，那就是文章开头的异常到底是哪一行代码报的错？我们回到DefaultListableBeanFactory的preInstantiateSingletons方法：


Spring源码阅读——记录一次非典型异常排查_第15张图片


这段代码进行bean初始化后的其他操作，debug调试可以看到EventHandler的执行对象为 org.springframework.context.event.internalEventListenerProcessor，我们进入到这个类对该方法的实现：


@Override
	public void afterSingletonsInstantiated() {
		List factories = getEventListenerFactories();
		ConfigurableApplicationContext context = getApplicationContext();
		String[] beanNames = context.getBeanNamesForType(Object.class);
		for (String beanName : beanNames) {
			if (!ScopedProxyUtils.isScopedTarget(beanName)) {
				Class type = null;
				try {
					type = AutoProxyUtils.determineTargetClass(context.getBeanFactory(), beanName);
				}
				catch (Throwable ex) {
					// An unresolvable bean type, probably from a lazy bean - let's ignore it.
					if (logger.isDebugEnabled()) {
						logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
					}
				}
				if (type != null) {
					if (ScopedObject.class.isAssignableFrom(type)) {
						try {
							Class targetClass = AutoProxyUtils.determineTargetClass(
									context.getBeanFactory(), ScopedProxyUtils.getTargetBeanName(beanName));
							if (targetClass != null) {
								type = targetClass;
							}
						}
						catch (Throwable ex) {
							// An invalid scoped proxy arrangement - let's ignore it.
							if (logger.isDebugEnabled()) {
								logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);
							}
						}
					}
					try {
						processBean(factories, beanName, type);
					}
					catch (Throwable ex) {
						throw new BeanInitializationException("Failed to process @EventListener " +
								"annotation on bean with name '" + beanName + "'", ex);
					}
				}
			}
		}
	}


核心逻辑在processBean中：


	protected void processBean(
			final List factories, final String beanName, final Class targetType) {

		if (!this.nonAnnotatedClasses.contains(targetType)) {
			Map annotatedMethods = null;
			try {
				annotatedMethods = MethodIntrospector.selectMethods(targetType,
						(MethodIntrospector.MetadataLookup) method ->
								AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
			}
			catch (Throwable ex) {
				// An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.
				if (logger.isDebugEnabled()) {
					logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
				}
			}
			if (CollectionUtils.isEmpty(annotatedMethods)) {
				this.nonAnnotatedClasses.add(targetType);
				if (logger.isTraceEnabled()) {
					logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
				}
			}
			else {
				// Non-empty set of methods
				ConfigurableApplicationContext context = getApplicationContext();
				for (Method method : annotatedMethods.keySet()) {
					for (EventListenerFactory factory : factories) {
						if (factory.supportsMethod(method)) {
							Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
							ApplicationListener applicationListener =
									factory.createApplicationListener(beanName, targetType, methodToUse);
							if (applicationListener instanceof ApplicationListenerMethodAdapter) {
								((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
							}
							context.addApplicationListener(applicationListener);
							break;
						}
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +
							beanName + "': " + annotatedMethods);
				}
			}
		}
	}


在最终注入方法的时候，调用了AopUtils.selectInvocableMethod方法，该方法最终调用了MethodIntrospector的selectInvokeMethod方法：


	public static Method selectInvocableMethod(Method method, Class targetType) {
		if (method.getDeclaringClass().isAssignableFrom(targetType)) {
			return method;
		}
		try {
			String methodName = method.getName();
			Class[] parameterTypes = method.getParameterTypes();
			for (Class ifc : targetType.getInterfaces()) {
				try {
					return ifc.getMethod(methodName, parameterTypes);
				}
				catch (NoSuchMethodException ex) {
					// Alright, not on this interface then...
				}
			}
			// A final desperate attempt on the proxy class itself...
			return targetType.getMethod(methodName, parameterTypes);
		}
		catch (NoSuchMethodException ex) {
			throw new IllegalStateException(String.format(
					"Need to invoke method '%s' declared on target class '%s', " +
					"but not found in any interface(s) of the exposed proxy type. " +
					"Either pull the method up to an interface or switch to CGLIB " +
					"proxies by enforcing proxy-target-class mode in your configuration.",
					method.getName(), method.getDeclaringClass().getSimpleName()));
		}
	}


bind方法是在ConsulAutoServiceRegistration父类AbstractAutoServiceRegistration类中，并不是通过接口实现的。而jdk代理是根据对象的接口来生成代理对象，所以代码执行到这一步，在进行EventHandler注解的解析时，方法会找不到。


后续：


javamelody官方其实已经有过类似的解决方案：


Spring源码阅读——记录一次非典型异常排查_第16张图片

























你可能感兴趣的:(Java,spring)






    

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • SpringMVC设置全局异常处理器
水岸齐天
javaspring

    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
    

    • 

  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】
还算善良_
私有代码库工具类javalist数据结构

    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
    

    • 

  • springboot集成logback-spring.xml文件
RT_0114
SpringBootspringbootspringlogback

    彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
    

    • 

  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    

    • 

  • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature
zhangfeng1133
ideeclipsejava

    报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
    

    • 

  • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
    

    • 

  • linux安装docker及docker-compose 部署spring boot项目
时而有事儿
dockerlinuxdockerlinuxspringboot

    linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
    

    • 

  • Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython

    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
    

    • 

  • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
    

    • 

  • Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言

    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
    

    • 

  • Java学习笔记01
.wsy.
日常java学习笔记

    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
    

    • 

  • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • java基础相关面试题详细总结
。。。。。96
java开发语言

    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
    

    • 

  • javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript

    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
    

    • 

  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试

    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
    

    • 

  • COMP315 JavaScript Cloud Computing for E Commerce
zhuyu0206girl
javascript开发语言ecmascript

    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
    

    • 

  • JSON与AJAX：网页交互的利器
入冉心
jsonajax前端

    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • javascript的数据类型及转换
田小田txt

    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
    

    • 

  • java线程之Lock的使用
dimdark

    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
    

    • 

  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解
爱跑步的程序员~
刷题蓝桥杯省赛

    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
    

    • 

  • Java学习笔记04：Java_数组
JasonYangQ
Javajava

    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
    

    • 

  • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
    

    • 

  • Websocket服务监听收发消息
beiback
Java服务器问题websocket网络协议网络

    目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
    

    • 

  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java
计算机程序老哥

    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    

    • 

  • 312个免费高速HTTP代理IP（能隐藏自己真实IP地址）
yangshangchuan
高速免费superwordHTTP代理

     
 
124.88.67.20:843
190.36.223.93:8080
117.147.221.38:8123
122.228.92.103:3128
183.247.211.159:8123
124.88.67.35:81
112.18.51.167:8123
218.28.96.39:3128
49.94.160.198:3128
183.20
    

    • 

  • pull解析和json编码
百合不是茶
androidpull解析json

    n.json文件:
[{name:java,lan:c++,age:17},{name:android,lan:java,age:8}]
 
pull.xml文件
<?xml version="1.0" encoding="utf-8"?>
<stu>
    <name>java
    

    • 

  • [能源与矿产]石油与地球生态系统
comsci
能源

    
      按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的....
      那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
    

    • 

  • 类与对象浅谈
沐刃青蛟
java基础

    
       类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
    

    • 

  • 新站开始被收录后，我们应该做什么？
IT独行者
PHPseo

    新站开始被收录后，我们应该做什么？
 
      百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。
      至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
    

    • 

  • oracle 连接碰到的问题
文强chu
oracle

    Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案
作者：草根IT网 来源：未知 人气：813标签：
导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
    

    • 

  • Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据）
小桔子
java继承swing接口监听

            都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。
编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
    

    • 

  • linux常用的命令
aichenglong
linux常用命令

    1 startx切换到图形化界面
2 man命令:查看帮助信息
man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分
name:对命令的简单说明
synopsis:命令的使用格式说明
description:命令的详细说明信息
options:命令的各项说明
3 date:显示时间
语法：date [OPTION]... [+FORMAT]

    

    • 

  • eclipse内存优化
AILIKES
javaeclipsejvmjdk

    一 基本说明      在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。     1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
    

    • 

  • 关键字的使用探讨
百合不是茶
关键字

    //关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的 只能在包中访问*//*final   类 方法 变量 final 类 不能被继承 final 方法 不能被子类覆盖，但可以继承 final 变量 只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
    

    • 

  • JS中定义对象的几种方式
bijian1013
js

        1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)：
<html>
<head>
<title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title>
</head>
<script>
var obj = new Object();

    

    • 

  • 表驱动法实例
bijian1013
java表驱动法TDD

    获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下：
MonthDaysTest.java
package com.study.test;
import org.junit.Assert;
import org.junit.Test;
import com.study.MonthDays;
public class MonthDaysTest {
@T
    

    • 

  • LInux启停重启常用服务器的脚本
bit1129
linux

    启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改
 
#! /bin/bash
Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo);
Ops=(Start, Stop, Restart);
currentDir=$(pwd);
echo
    

    • 

  • 【HBase六】REST操作HBase
bit1129
hbase

    HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作
  1. 启动和停止HBase REST 服务 1.1 启动REST服务
前台启动（默认端口号8080）
[hadoop@hadoop bin]$ ./hbase rest start
 
后台启动
hbase-daemon.sh start rest
 
启动时指定
    

    • 

  • 大话zabbix 3.0设计假设
ronin47

    What’s new in Zabbix 2.0?
去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个：
         :: Performance improvements::Trigger related da
    

    • 

  • http错误码大全
byalias
http协议javaweb

    响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。
响应码分五种类型，由它们的第一位数字表示：
1）1xx：信息，请求收到，继续处理
2）2xx：成功，行为被成功地接受、理解和采纳
3）3xx：重定向，为了完成请求，必须进一步执行的动作
4）4xx：客户端错误，请求包含语法错误或者请求无法实现
5）5xx：服务器错误，服务器不能实现一种明显无效的请求

    

    • 

  • J2EE设计模式-Intercepting Filter
bylijinnan
java设计模式数据结构

    Intercepting Filter类似于职责链模式
有两种实现
其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下：
package com.ljn.filter.custom;
import java.util.ArrayList;
    

    • 

  • 修改jboss端口
chicony
jboss

    修改jboss端口
 
%JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml
 
中找到
<!-- The ports-default bindings are obtained by taking the base bindin
    

    • 

  • c++ 用类模版实现数组类
CrazyMizzz
C++

    最近c++学到数组类，写了代码将他实现，基本具有vector类的功能
#include<iostream>
#include<string>
#include<cassert>
using namespace std;
template<class T>
class Array
{
public:
//构造函数

    

    • 

  • hadoop dfs.datanode.du.reserved 预留空间配置方法
daizj
hadoop预留空间

    对于datanode配置预留空间的方法 为：在hdfs-site.xml添加如下配置
 <property>
    <name>dfs.datanode.du.reserved</name>
    <value>10737418240</value>
 
 
    

    • 

  • mysql远程访问的设置
dcj3sjt126com
mysql防火墙

    第一步: 激活网络设置 你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
    

    • 

  • ios 使用特定的popToViewController返回到相应的Controller
dcj3sjt126com
controller

    1、取navigationCtroller中的Controllers
NSArray * ctrlArray = self.navigationController.viewControllers;
2、取出后，执行，
[self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
    

    • 

  • Linux正则表达式和通配符的区别
eksliang
正则表达式通配符和正则表达式的区别通配符

    转载请出自出处：http://eksliang.iteye.com/blog/1976579
首先得明白二者是截然不同的
通配符只能用在shell命令中,用来处理字符串的的匹配。
判断一个命令是否为bash shell(linux 默认的shell)的内置命令
type -t commad
返回结果含义
file  表示为外部命令
alias  表示该
    

    • 

  • Ubuntu Mysql Install and CONF
gengzg
Install

    http://www.navicat.com.cn/download/navicat-for-mysql
Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html
Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz 
    

    • 

  • 批处理，删除文件bat
huqiji
windowsdos

    @echo off
::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。
::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。
::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log）
rem 指定待删除文件的存放路径
set SrcDir=C:/Test/BatHome
rem 指定天数
set DaysAgo=1
    

    • 

  • 跨浏览器兼容的HTML5视频音频播放器
天梯梦
html5

    HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。   How to enable <video> and <audio> tags in 
    

    • 

  • Bundle自定义数据传递
hm4123660
androidSerializable自定义数据传递BundleParcelable

          我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity
 
把数据放到Intent
    

    • 

  • C＃：异步编程和线程的使用（.NET 4.5 ）
powertoolsteam
.net线程C#异步编程

    异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。
本文中涉及关键知识点
1. 异步编程
2. 线程的使用
3. 基于任务的异步模式
4. 并行编程
5. 总结
异步编程
什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
    

    • 

  • spark 查看 job history 日志
Stark_Summer
日志sparkhistoryjob

    SPARK_HOME/conf 下:
spark-defaults.conf 增加如下内容
spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true
spark-env.sh 增加如下内容
export SP
    

    • 

  • SSH框架搭建
wangxiukai2015eye
springHibernatestruts

    MyEclipse搭建SSH框架 Struts Spring Hibernate
1、new一个web project。
2、右键项目，为项目添加Struts支持。
   选择Struts2 Core Libraries -<MyEclipes-Library>
     点击Finish。src目录下多了struts
    

    •