大龄码农生活
大龄码农生活

spring源码学习---@Autowired 注入源码分析和自定义依赖注入

 一、简介

      众所周知，Spring的依赖注入（DI）对Spring IOC 有着举足轻重的作用，是Spring灵魂所在。本篇文章就从日常开发中最常用的注解@Autowired开始，着手分析Spring是如何通过它们将Bean所需的外部资源注入其中.

1.1、@Autowired 注入规则

 @Autowired可以应用在 非静态字段、非静态方法、构造器上面注入bean。

1.2、 @Autowired 注入过程

  1.       元信息解析
  2.       依赖查找
  3.       依赖注入（字段、方法）

1.3、代码准备

@Configuration
public class AnnotationDependencyInjectionResolutionDemo {

    // DependencyDescriptor ->
    // 必须（required=true）
    // 实时注入（eager=true)
    // 通过类型（User.class）
    // 字段名称（"user"）
    // 是否首要（primary = true)
    @Autowired(required = false)         // 依赖查找（处理）
    private User user;
    
    public static void main(String[] args) {

        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册 Configuration Class（配置类） -> Spring Bean
        applicationContext.register(AnnotationDependencyInjectionResolutionDemo.class);

        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);

        String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";
        // 加载 XML 资源，解析并且生成 BeanDefinition
        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);

        // 启动 Spring 应用上下文
        applicationContext.refresh();

        // 依赖查找 QualifierAnnotationDependencyInjectionDemo Bean
        AnnotationDependencyInjectionResolutionDemo demo = applicationContext.getBean(AnnotationDependencyInjectionResolutionDemo.class);

        // 期待输出 superUser Bean
        System.out.println("demo.user = " + demo.user);
        applicationContext.close();

    }
}

xml中的

 
       
       
       
       
   

二、源码分析

2.1 @Autowired的定义

首先，我们看@Autowired的定义里可以发现，它是通过AutowiredAnnotationBeanPostProcessor去实现解析的

 /*
 * @author Juergen Hoeller
 * @author Mark Fisher
 * @author Sam Brannen
 * @since 2.5
 * @see AutowiredAnnotationBeanPostProcessor
 * @see Qualifier
 * @see Value
 */
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

	/**
	 * Declares whether the annotated dependency is required.
	 * 
Defaults to {@code true}.
	 */
	boolean required() default true;

}

2.2 AutowiredAnnotationBeanPostProcessor

在看一下AutowiredAnnotationBeanPostProcessor它的继承图表：

spring源码学习---@Autowired 注入源码分析和自定义依赖注入_第1张图片

由此继承图标我们能得出如下结论：

  • 实现了BeanPostProcessor，所以介入到Bean的初始化前后
  • 实现了InstantiationAwareBeanPostProcessor接口，所以可以介入到Bean的实例化前后
  • 实现了MergedBeanDefinitionPostProcessor，说明它可以合并bean的定义信息（用来合并parent="user" 父类中属性）
  • 实现了BeanFactoryAware（BeanFactory的回调），
  • 实现了PriorityOrdered（排序）

2.3、第一阶段：元信息解析

    解析@Resource注解的不是这个类，而是CommonAnnotationBeanPostProcessor，但本文只会以AutowiredAnnotationBeanPostProcessor为例做深入分析~~~（解析@Autowired）

2.3.1、AutowiredAnnotationBeanPostProcessor 中属性

// 该处理器支持解析的注解们~~~（这里长度设置为4）
	// 默认支持的是3个（当然你可以自己添加自定义的依赖注入的注解   这点非常强大）
	private final Set> autowiredAnnotationTypes = new LinkedHashSet<>();

	// @Autowired(required = false)这个注解的属性值名称
	private String requiredParameterName = "required";

	// 这个值一般请不要改变（若改成false，效果required = false的作用是相反的了）
	private boolean requiredParameterValue = true;

	private int order = Ordered.LOWEST_PRECEDENCE - 2;

	@Nullable
	private ConfigurableListableBeanFactory beanFactory;

	// 对@Lookup方法的支持  本文不讨论
	private final Set lookupMethodsChecked = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
	// 构造函数注入，本文也不讨论
	private final Map, Constructor[]> candidateConstructorsCache = new ConcurrentHashMap<>(256);

	// 方法注入、字段filed注入  本文的重中之重
	// 此处InjectionMetadata这个类非常重要，到了此处@Autowired注解含义已经没有了，完全被准备成这个元数据了
	//  所以方便我们自定义注解的支持~~~优秀
	// InjectionMetadata持有targetClass、Collection injectedElements等两个重要属性
	// 其中InjectedElement这个抽象类最重要的两个实现为：AutowiredFieldElement和AutowiredMethodElement
	private final Map injectionMetadataCache = new ConcurrentHashMap<>(256);

2.3.2、构造方法（也是唯一的一个构造方法）

     AutowiredAnnotationBeanPostProcessor执行构造方法时集合autowiredAnnotationTypes中依次放入了三个注解类@Autowired、@Value和JSR-330标准的@Inject

    // 这是它唯一构造函数  默认支持下面三种租借（当然@Inject需要额外导包）
	// 请注意：此处@Value注解也是被依赖注入解析的~~~~~~~~
	// 当然如果你需要支持到你的自定义注解，你还可以调用下面的set方法添加。
	@SuppressWarnings("unchecked")
	public AutowiredAnnotationBeanPostProcessor() {
		//后置处理器将处理@Autowire注解
		this.autowiredAnnotationTypes.add(Autowired.class);
		//后置处理器将处理@Value注解
		this.autowiredAnnotationTypes.add(Value.class);
		try {
			//后置处理器将处理javax.inject.Inject JSR-330注解
			this.autowiredAnnotationTypes.add((Class)
					ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
			logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}

2.3.4 setAutowiredAnnotationType 是用于实现自定义依赖注入注解类型

      两个setAutowiredAnnotationType是用于实现自定义依赖注入注解类型，首先它会把autowiredAnnotationTypes里面的元素全部clear,然后加入自定义的依赖注入注解类型，所以我们要注意在实现自定义注解注入时，这里会先把默认的注解类型清除

/**
	 *  这两个setAutowiredAnnotationType是用于实现自定义依赖注入注解类型，
	 *  首先它会把autowiredAnnotationTypes里面的元素全部clear,
	 * 然后加入自定义的依赖注入注解类型，所以我们要注意在实现自定义注解注入时，这里会先把默认的注解类型清除
	 */
	public void setAutowiredAnnotationType(Class autowiredAnnotationType) {
		Assert.notNull(autowiredAnnotationType, "'autowiredAnnotationType' must not be null");
		this.autowiredAnnotationTypes.clear();
		this.autowiredAnnotationTypes.add(autowiredAnnotationType);
	}

2.3.5 postProcessMergedBeanDefinition(核心)

    第一个非常重要的核心方法，它负责：
         1、解析@Autowired等注解然后转换
         2、把注解信息转换为InjectionMetadata然后缓存到上面的injectionMetadataCache里面
    postProcessMergedBeanDefinition的执行时机非常早，在doCreateBean()前部分完成bean定义信息的合并

 // 第一个非常重要的核心方法~~~  
	//它负责1、解析@Autowired等注解然后转换
	// 2、把注解信息转换为InjectionMetadata然后缓存到上面的injectionMetadataCache里面
	// postProcessMergedBeanDefinition的执行时机非常早，在doCreateBean()前部分完成bean定义信息的合并
	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
		InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
		metadata.checkConfigMembers(beanDefinition);
	}
 

// 方法名为查找到该bean的依赖注入元信息，内部只要查找到了就会加入到缓存内，下次没必要再重复查找了~
	// 它是一个模版方法，真正做事的方法是：buildAutowiringMetadata
	// 它复杂把标注有@Autowired注解的属性转换为Metadata元数据信息  从而消除注解的定义
	// 此处查找包括了字段依赖注入和方法依赖注入~~~
	//获取给定类的autowire相关注解元信息
	private InjectionMetadata findAutowiringMetadata(String beanName, Class clazz, @Nullable PropertyValues pvs) {
		// Fall back to class name as cache key, for backwards compatibility with custom callers.
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		// Quick check on the concurrent map first, with minimal locking.
		//首先从容器中查找是否有给定类的autowire相关注解元信息
		InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
		if (InjectionMetadata.needsRefresh(metadata, clazz)) {
			synchronized (this.injectionMetadataCache) {
				metadata = this.injectionMetadataCache.get(cacheKey);
				if (InjectionMetadata.needsRefresh(metadata, clazz)) {
					if (metadata != null) {
						//解析给定类autowire相关注解元信息
						metadata.clear(pvs);
					}
					//解析给定类autowire相关注解元信息
					metadata = buildAutowiringMetadata(clazz);
					//将得到的给定类autowire相关注解元信息存储在容器缓存中
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}

// 这里我认为是整个依赖注入前期工作的精髓所在，简单粗暴的可以理解为：
	 // 它把以依赖注入都转换为InjectionMetadata元信息，待后续使用
	// 这里会处理字段注入、方法注入~~~
	// 注意：Autowired使用在static字段/方法上、0个入参的方法上（不会报错 只是无效）
	// 显然方法的访问级别、是否final都是可以正常被注入进来的~~~
	//解析给定类autowire相关注解元信息
	private InjectionMetadata buildAutowiringMetadata(final Class clazz) {
		//创建一个存放注解元信息的集合
		LinkedList elements = new LinkedList<>();
		Class targetClass = clazz;

		//递归遍历当前类及其所有基类，解析全部注解元信息
		do {
			//创建一个存储当前正在处理类注解元信息的集合
			final LinkedList currElements = new LinkedList<>();

			//利用JDK反射机制获取给定类中所有的声明字段，获取字段上的注解信息
			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				//获取给定字段上的注解
				AnnotationAttributes ann = findAutowiredAnnotation(field);
				if (ann != null) {
					//如果给定字段是静态的(static)，则直接遍历下一个字段
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					//判断注解的required属性值是否有效
					boolean required = determineRequiredStatus(ann);
					//将当前字段元信息封装，添加在返回的集合中
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});

			//利用JDK反射机制获取给定类中所有的声明方法，获取方法上的注解信息
			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				//获取给定方法上的所有注解
				AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					//如果方法是静态的，则直接遍历下一个方法
					if (Modifier.isStatic(method.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static methods: " + method);
						}
						return;
					}
					//如果方法的参数列表为空
					if (method.getParameterCount() == 0) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation should only be used on methods with parameters: " +
									method);
						}
					}
					//判断注解的required属性值是否有效
					boolean required = determineRequiredStatus(ann);
					//获取当前方法的属性描述符，即方法是可读的(readable)getter方法，还是可写的(writeable)setter方法
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					//将方法元信息封装添加到返回的元信息集合中
					currElements.add(new AutowiredMethodElement(method, required, pd));
				}
			});

			//将当前类的注解元信息存放到注解元信息集合中
			elements.addAll(0, currElements);
			//获取给定类的父类
			targetClass = targetClass.getSuperclass();
		}
		//如果给定类有基类，并且基类不是Object，则递归获取其基类的元信息
		while (targetClass != null && targetClass != Object.class);

		return new InjectionMetadata(clazz, elements);
	}

    这一步，借助postProcessMergedBeanDefinition()方法完成了对该bean中所有的依赖注入的属性、方法及其父类的属性、方法进行合并Mergerd完成了原始元信息的转换，已经把依赖注入的相关注解全都转换成了InjectionMetadata，这样后面的使用过程中将不再需要再和具体注解打交道，而是做着一些和业务无关的动作即可。接下来进入注入阶段

2.4、注入阶段

      这是核心阶段，也是最为复杂的阶段，当然前面的解析已经为本步骤做好了元数据的铺垫。

     我们知道在Bean的创建过程中，完成Bean的实例化后，会调用方法AbstractAutowireCapableBeanFactory#populateBean()完成对Bean的属性赋值，从而就会触发InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法给属性进行赋值，这处也就是本步骤的入口。

    围绕着这个模板方法postProcessPropertyValues， 我们回到AutowiredAnnotationBeanPostProcessor，找到postProcessPropertyValues的重写： 

//处理类中的属性
	@Override
	public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

		//获取指定类中autowire相关注解的元信息
		// 从缓存中取出这个bean对应的依赖注入的元信息
		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
		try {
			//对Bean的属性进行自动注入
			metadata.inject(bean, beanName, pvs);
		}
		catch (BeanCreationException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
		}
		return pvs;
	}

      综上能够发现核心InjectionMetadata#inject()，最终依赖注入实际做事的是InjectedElement，这个抽象类有好几个实现，此处我们以使用最为广泛的AutowiredFieldElement进行说明

2.4.1、AutowiredFieldElement实现属性依赖注入

       这个类继承自静态抽象内部类InjectionMetadata.InjectedElement，并且它还是AutowiredAnnotationBeanPostProcessor的private内部类，体现出非常高的内聚性：

		// 它的宿主类是AutowiredAnnotationBeanPostProcessor 高内聚低耦合
	private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {

		private final boolean required;
		private volatile boolean cached = false;
		@Nullable
		private volatile Object cachedFieldValue;

		//唯一构造方法
		public AutowiredFieldElement(Field field, boolean required) {
			super(field, null); // 此处显示调用父类的构造函数
			this.required = required;
		}

		// 核心方法：字段的依赖注入
		@Override
		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
			// 显然此处父类的member就指的是filed
			Field field = (Field) this.member;
			Object value;
		
			// 走缓存，关于cachedFieldValue的值  且听下文分解
			if (this.cached) {
				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
			} else {
				// 每个Field都包装成一个DependencyDescriptor
				// 如果是Method包装成DependencyDescriptor,毕竟一个方法可以有多个入参
				// 此处包装成它后，显然和元数据都无关了，只和Field有关了  完全隔离
				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
				desc.setContainingClass(bean.getClass());
				Set autowiredBeanNames = new LinkedHashSet<>(1);
				Assert.state(beanFactory != null, "No BeanFactory available");
				// 转换器使用的bean工厂的转换器~~~
				TypeConverter typeConverter = beanFactory.getTypeConverter();
				try {
					// 获取依赖的value值的工作  最终还是委托给beanFactory.resolveDependency()去完成的~~~~
					// 这个接口方法由AutowireCapableBeanFactory提供，它提供了从bean工厂里获取依赖值的能力~
					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
				} catch (BeansException ex) {
					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
				}

				// 下面代码是把缓存值缓存起来  让同一个Field注入多次能提高效率
				synchronized (this) {
					if (!this.cached) {
				
						// 可以看到value！=null并且required=true才会进行缓存的处理
						// 按照上例 此处value值为A@2277实例
						if (value != null || this.required) {
							this.cachedFieldValue = desc; // 可以看到缓存的值是上面的DependencyDescriptor对象~~~~


							// 这个方法是宿主类AutowiredAnnotationBeanPostProcessor的方法
							// 简单的说就是注册到bean工厂去，比如此处b是依赖a的  所以就注册这个依赖关系进去了
							// 参考this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
							registerDependentBeans(beanName, autowiredBeanNames);

							// autowiredBeanNames里可能会有别名的名称~~~所以size可能大于1
							if (autowiredBeanNames.size() == 1) {

								// beanFactory.isTypeMatch挺重要的~~~~因为@Autowired是按照类型注入的
								String autowiredBeanName = autowiredBeanNames.iterator().next();
								if (beanFactory.containsBean(autowiredBeanName) && beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
									this.cachedFieldValue = new ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());
								}
							}
						} else {
							this.cachedFieldValue = null;
						}
						this.cached = true;
					}
				}
			}
	
			// 不为null，就完成最终的set值  利用反射给filed属性赋值~~~~
			if (value != null) {
				ReflectionUtils.makeAccessible(field);
				field.set(bean, value);
			}
		}
	}

前面准备好的注解的、需要注入的元数据信息，这一步使用执行注入。
从源码中也能发现一个特点，Spring大量的使用到了转换、适配、委托等机制。因此最终最最最重要的一行代码无非是这一句：

//根据容器中Bean定义，解析指定的依赖关系，获取依赖对象
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

委托AutowireCapableBeanFactory来获取到依赖值value，从而最终完成注入（反射执行注入~）。
so，其实最核心还是在Bean工厂里，也就是它的唯一内建实现类DefaultListableBeanFactory。

2.4.2、DefaultListableBeanFactory解析依赖值

  我们跟进这里的beanFactory.resolveDependency，进入DefaultListableBeanFactory, 这个方法有个重要的入参DependencyDescriptor：

/**
 * Descriptor for a specific dependency that is about to be injected.
 * Wraps a constructor parameter, a method parameter or a field,
 * allowing unified access to their metadata.
 *
 * @author Juergen Hoeller
 * @since 2.5
 */
@SuppressWarnings("serial")
public class DependencyDescriptor extends InjectionPoint implements Serializable {
	
	//被申明的类，也就是注入的容器
	private final Class declaringClass;

	@Nullable //方法注入名  这里可为空 因为不都是方法注入
	private String methodName;

	@Nullable //参数类型
	private Class[] parameterTypes;
	
	//参数索引顺序
	private int parameterIndex;

	@Nullable //字段注入的字段名
	private String fieldName;
	
	//是否必需
	private final boolean required;
	
	//是否是饥饿的 对应@Lazy
	private final boolean eager;
	
	//嵌入层次
	private int nestingLevel = 1;

	@Nullable
	private Class containingClass;

	@Nullable //类型处理
	private transient volatile ResolvableType resolvableType;

	@Nullable//类型描述  描述类型相关的内容
	private transient volatile TypeDescriptor typeDescriptor;

通过DependencyDescriptor 的每个描述字段可以大致猜到注入的user依赖对应的相关描述

 // DependencyDescriptor ->
    // 必须（required=true）
    // 实时注入（eager=true)
    // 通过类型（User.class）
    // 字段名称（"user"）
    // 是否首要（primary = true)
    @Autowired(required = false)         // 依赖查找（处理）
    private User user;

在resolveDependency里面debug, 观察DependencyDescriptor 里的值和猜测的基本一致 ：
spring源码学习---@Autowired 注入源码分析和自定义依赖注入_第2张图片

回到resolveDependency方法：

@Override
	@Nullable
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        //此处使用的是DefaultParameterNameDiscoverer 来获取参数名
		// 这就是为什么我们使用@Autowired注入，
		// 即使有多个同类型的Bean，也可以通过field属性名进行区分的根本原因（可以不需要使用@Qualifier注解）
		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		// 支持Optional  原来还是doResolveDependency  暂略
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		//支持ObjectFactory和ObjectProvider（延迟注入）
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			// 绝大部分情况下  肯定走到这里~~~~
			// 此处特别特别的需要重视：这是@Lazy支持的根本原因~~
			// 关于AutowireCandidateResolver我建议小伙伴先看下一个章节~~~
			// 此处若通过AutowireCandidateResolver解析到了值就直接返回了（若标注了@Lazy，此处的result将不会为null了~~~）
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
			// doResolveDependency是绝大多数情况下  最终会去执行的代码（若result仍旧为null的话）
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

（重中之重）
绝大多数情况下，肯定会经由我们的doResolveDependency()方法来处理，因此这个方法的实现才是重中之重。其实getLazyResolutionProxyIfNecessary()它的底层依赖还是doResolveDependency()这个方法

看看DefaultListableBeanFactory对这个"重中之重"的实现：
 

// 此处autowiredBeanNames是在inject的一个空的Set
    // autowired表示最终可以注入进去的bean名称们（因为可能是会有多个符合条件的）
	@Nullable
	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
       //这个方法是通过依赖描述符处理注入多次嵌套
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}

			Class type = descriptor.getDependencyType();
			// 拿到@Value注解的value值（是个字符串）  若没有标注@Value  显然就不用那啥了
			// 从此处其实也可以看出，@Value注解的优先级对于找到bean来说还是蛮高的
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			// ============ 这部分主要是解析@Value注解
			// 解析它的占位符，解析它的SpEL表达式
			// 相关处理类曹靠BeanExpressionResolver和StandardBeanExpressionResolver  StandardEvaluationContext等
			// 因为关于@Value的文章里详细解过，此处一笔带过~~~
			if (value != null) {
				if (value instanceof String) {
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				return (descriptor.getField() != null ?
						converter.convertIfNecessary(value, type, descriptor.getField()) :
						converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
			}

			// 此处处理的是多值注入的情况，比如注入Stream、Map、Array、Collection等等  Spring都是支持的
			// 需要稍微注意一点，Stream这种类型的注入在Spring4以上才得到支持的
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}

			// 显然绝大部分情况下，都会走到这里（因为大部分我们都是单值注入~）
			// findAutowireCandidates可以说又是整个依赖注入的灵魂之一~~~~ 它的查找步骤简述如下：
			//1、BeanFactoryUtils.beanNamesForTypeIncludingAncestors()
			//   找到这种类型的所有的beanNames（candidateNames）（可能有多个哟，但大多数情况下只有一个）
			//2、处理resolvableDependencies比如ApplicationContext的依赖，让他们也能够正常注入进去(他们可不作为bean存在容器里~)
			//3、遍历candidateNames：检查它是否可以被依赖、容器内是否存在bean定义（或者Singleton）
			//      若符合，getBean()出来放在map里
			//4、若返回的Map不为Empty()了，直接return  表示找到了（当然还可能是多个~~）
			//     若返回的还是Empty,那就继续检查requiredType是否为Map、Collection等类型，
			//      从它里面去找。。。（这种注入case使用太少，此处暂略~）
			Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;
            // 若有多个匹配
			// 需要注意的是：@Qualifier注解在上面就已经生效了~~~~
			// 因为AutowireCandidateResolver.isAutowireCandidate是在上面生效的
			if (matchingBeans.size() > 1) {
				// 1、是否标注有@Primary  有这种bean就直接返回（@Primary只允许标注在一个同类型Bean上）
				// 2、看是否有标注有`javax.annotation.Priority`这个注解的
				// 3、根据字段field名，去和beanName匹配  匹配上了也行（这就是为何我们有时候不用@Qulifier也没事的原因之一）
				// 此处注意：descriptor.getDependencyName()这个属性表示字段名，
				// 靠的是`DefaultParameterNameDiscoverer`去把字段名取出来的~
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						return descriptor.resolveNotUnique(type, matchingBeans);
					}
					else {
						// In case of an optional Collection/Map, silently ignore a non-unique case:
						// possibly it was meant to be an empty collection of multiple regular beans
						// (before 4.3 in particular when we didn't even look for collection beans).
						return null;
					}
				}
				instanceCandidate = matchingBeans.get(autowiredBeanName);
			}
			else {
				// 只有一个匹配就啥都说了  干就完了
				// We have exactly one match.
				Map.Entry entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				// 此处getBean() 拿到该类型的实例对象了~~~
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			if (result instanceof NullBean) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				result = null;
			}
			if (!ClassUtils.isAssignableValue(type, result)) {
				throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
			}
			return result;
		}
		finally {
			//设置到当前的注入点
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

    其实本类的doResolveDependency()方法使用非常的广泛，虽然不属于接口方法，但是在DefaultListableBeanFactory类中还是public的访问权限。


 2.5、总结


       Spring使用了大量的委托代理还有模板方法等，实现了高内聚低耦合的特点。整个对@Autowired依赖注入的流程分为两个周期，第一个是解析元信息并放入缓存中，第二个周期是注入，


         每个阶段有每个阶段的核心，解析元信息核心是模仿双亲委派的父类优先的原则去合并BeanDefition, 并全部转换成InjectionMetadata， 第二个阶段就是InjectionMetadata的inject方法的实现，其中会涉及到beanFactory.resolveDependency，这里可以处理多种注入类型的封装，包括Optional、ObjectFactory、ObjectProvider和jsr330 里面的依赖注入方案，最后处理默认注入操作，最终通过反射将值设置到字段当中。


三、Java通用注解注入原理


   与@Autowired等效的@Resource注解虽然注入效果一样，但是是通过另一个BeanPostProcessor–CommonAnnotationBeanPostProcessor去实现的，实现流程大同小异，提供对jdk注入注解和ejb WebServiceRef等注入注解的支持。


  CommonAnnotationBeanPostProcessor 调用优先级高于AutowiredAnnotationBeanPostProcessor。


四、自定义依赖注入注解


基于AutowiredAnnotationBeanPostProcessor 实现
自定义实现 




 • 生命周期处理 
         • InstantiationAwareBeanPostProcessor 
         • MergedBeanDefinitionPostProcessor 
     • 元数据 
         • InjectedElement 
         • InjectionMetadata




4.1、第一种实现：直接继承@Autowired注解


/**
 * 自定义注解（元标注 @Autowired）
 *
 * @author 
 * @since
 */
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Autowired
public @interface MyAutowired {

    /**
     * Declares whether the annotated dependency is required.
     * 
Defaults to {@code true}.
     */
    boolean required() default true;
}


4.2、通过、AutowiredAnnotationBeanPostProcessor


/**
 * 自定义依赖注入注解
 *
 * @author
 * @since
 */
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InjectedUser {
}


   //注意这里要设置成static,不然依赖注入会失效，
    // 因为这个AutowiredAnnotationBeanPostProcessor定义在当前demo类中，
    // 想要拿到自定义的AutowiredAnnotationBeanPostProcessor，就必须实例化demo类 
    //但是在实例化demo类LeonAutowired也同时被处理了，
    // 此时还没有自定义的AutowiredAnnotationBeanPostProcessor，因此不认识@LeonAutowired，
    //因此被注入了null。然后等实例化完了之后自定义的AutowiredAnnotationBeanPostProcessor才拿到
    @Bean
    @Order(Ordered.LOWEST_PRECEDENCE - 3)
    @Scope
    public static AutowiredAnnotationBeanPostProcessor beanPostProcessor() {
        AutowiredAnnotationBeanPostProcessor beanPostProcessor = new AutowiredAnnotationBeanPostProcessor();
        beanPostProcessor.setAutowiredAnnotationType(InjectedUser.class);
        return beanPostProcessor;
    }



 


 


 

























你可能感兴趣的:(spring源码学习)






    

  • Spring源码学习-Spring流程概述（一）
coder_sheep
Springspringjavaaopioc源码

    Spring启动的流程publicclassTest{publicstaticvoidmain(String[]args){ClassPathXmlApplicationContextcontext=newClassPathXmlApplicationContext("applicationContext.xml");Studentbean=context.getBean(Student.clas
    

    • 

  • Spring源码学习---------(最简单易懂的源码学习笔记)
HiSiri666666
Springjavaspring5spring开发语言学习

    哈喽！大家好，我是「奇点」，江湖人称singularity。刚工作几年，想和大家一同进步一位上进心十足的【JavaToB端大厂领域博主】！喜欢java和python，平时比较懒，能用程序解决的坚决不手动解决✨如果有对【java】感兴趣的【小可爱】，欢迎关注我❤️❤️❤️感谢各位大可爱小可爱！❤️❤️❤️————————————————如果觉得本文对你有帮助，欢迎点赞，欢迎关注我，如果有补充欢迎评论
    

    • 

  • Spring源码学习-实例化过程
coder_sheep
Springspring学习javaioc源码面试

    spring源码学习中核心的部分，也是高频面试题，希望经过本章学习，帮助大家理解bean的实例化流程@Overridepublicvoidrefresh()throwsBeansException,IllegalStateException{//省略部分代码。。。//Instantiateallremaining(non-lazy-init)singletons.//初始化剩下的单实例（非懒加载的
    

    • 

  • Spring源码学习
原来~如此
springjava学习spring

    源码学习前提版本：5.3.10形式：注册形式-AnnotationConfigApplicationContext（AppConfig.class）学习内容spring启动注册过程this()阶段创建AnnotationConfigApplicationContext实例创建AnnotatedBeanDefinitionReader实例默认注册几个注解相关的bean后置处理器-注册到beanDef
    

    • 

  • spring源码学习——前置知识
无唯～
spring源码分析spring学习java

    文章目录前言1、BeanFactory与ApplicationContext2、常用注解及回调方法1、Bean注册常用注解2、组件扫描注解3、依赖注入方式3、回调注入4、普通Bean和工厂Bean5、Bean生命周期初始化销毁方法。6、spring的事件机制&监听器7、模块装配8、条件装配9、BeanDefinition1、什么是BeanDefinition？2、为什么需要BeanDefiniti
    

    • 

  • Spring源码学习三
CopyLower
学习spring学习java

    手写Starter我们通过手写Starter来加深对于自动装配的理解1.创建一个Maven项目，quick-starter定义相关的依赖org.springframework.bootspring-boot-starter2.1.6.RELEASEcom.alibabafastjson1.2.56true2.定义Formate接口定义的格式转换的接口，并且定义两个实现类publicinterfac
    

    • 

  • Spring源码学习一
CopyLower
学习spring学习java

    IOC容器概述ApplicationContext接口相当于负责bean的初始化、配置和组装的IoC容器.Spring为ApplicationContext提供了一些开箱即用的实现,独立的应用可以使用ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext，web应用在web.xml配置监听，提供xml位置和org.spring
    

    • 

  • Spring源码学习二
CopyLower
学习spring学习java

    @EnableAutoConfiguration注解的实现原理了解了ImportSelector和ImportBeanDefinitionRegistrar后，对于EnableAutoConfiguration的理解就容易一些了它会通过import导入第三方提供的bean的配置类：AutoConfigurationImportSelector@Import(AutoConfigurationImp
    

    • 

  • Spring源码学习四、Bean的加载
唐小码
springspringjava

    PS：本文参照《Spring源码深度解析2》与spring官方，仅作个人学习这章分析的是,从容器中获取beanStudentstudent=(Student)xmlBeanFactory.getBean("student");bean加载的大体思路@OverridepublicObjectgetBean(Stringname)throwsBeansException{returndoGetBean
    

    • 

  • spring初始化解析xml 配置文件一
nandao158
spring源码学习spring

    从本篇开始我们正式进入spring源码学习，首先从我们最熟悉的解析xml配置文件开始。依次跟踪代码，紧接着上一篇的开始，如下，创建一个测试方法：importcom.xiangxue.jack.bean.Student;importorg.junit.Test;importorg.springframework.context.support.ClassPathXmlApplicationConte
    

    • 

  • Spring源码编译步骤
Marlon520
springjava后端

    Spring源码学习一、Gradle为什么下载gradle呢？我们平时不都是用maven吗？原因只有一个，spring源码是用gradle构建的，所以，你想看spring源码必须安装和学会使用gradle，那么，让我们开始gradle之旅吧，我也是一个gradle小白，边学边记吧，加油吧少年，机会是给有准备的人，相信你就是那一个！！！1.Gradle下载官网下载：https://gradle.or
    

    • 

  • spring源码学习(三)——初始化bean
km56558
springspring

    spring源码学习(一)——ioc初始化spring源码学习(二)——ConfigurationClassPostProcessor(BeanFactory后置处理器的执行)spring源码学习(四)——aop1.2.3初始化bean执行完beanFactoryPostProcessors之后，会找到所有BeanPostProcessor（Bean的后置处理器），注册到beanFactory中。
    

    • 

  • Spring源码学习（二）--手写模拟spring底层原理
从头再来_f
Spring源码springjava

    通过手写模拟，了解Spring的底层源码启动过程,了解BeanDefinition、BeanPostProcessor的概念,了解Spring解析配置类等底层源码工作流程,通过手写模拟，了解依赖注入，Aware回调等底层源码工作流程,通过手写模拟，了解SpringAOP的底层源码工作流程当然,代码实现很粗糙,目的是为了更好的廖家spring底层bean加载的过程项目地址:write-spring:
    

    • 

  • 极客大学 java 进阶训练营怎么样，图文详解
一头狒狒
java开发语言

    Spring思维导图Spring源码学习笔记有关微服务的面试题：Dubbo中zookeeper做注册中心，如果注册中心集群都挂掉，发布者和订阅者之间还能通信么？Dubbo的整体架构设计有哪些分层?什么是SpringBoot？以及SpringBoot的优劣势？你如何理解SpringBoot中的Starters？服务注册和发现是什么意思？SpringCloud如何实现？SpringCloud断路器的作
    

    • 

  • Spring源码学习笔记
zhengtuqi
Spring

    springbean实例化简图更改allowcircularReference为false可以关闭循环依赖，方式有三种。1、更改spring源码2、不要使用带参构造函数改为3、拓展spring（具体不知道怎么做，应该是通过BeanPostProcessor接口）1、SpringIOC笔记：1、重要的区别，别搞混了Instantiation实例化Initialization初始化1、在填充bean属
    

    • 

  • Spring源码学习(四)：容器ApplicationContext的refresh（2）- 执行BeanFactoryPostProcessor
liangsheng_g
spring源码分析springjava

    文章目录前言一、BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor是什么二、Spring执行这些PostProcessor的步骤1.BeanDefinitionRegistryPostProcessor优先级高2.开始执行Spring容器里的BeanDefinitionRegistryPostProcessor2.1执行了Pri
    

    • 

  • Spring源码学习（一）--Spring底层核心原理解析
从头再来_f
Spring源码Springspringjava

    目录Spring中是如何创建一个对象？Bean的创建过程推断构造方法AOP大致流程Spring事务最近在跟视频学习spring源码，将每节课记录下来，以后好来复习。首先把Spring中核心知识点都给大家进行串讲，对Spring的底层有了一个整体的大致了解，比如：Bean的生命周期底层原理依赖注入底层原理初始化底层原理推断构造方法底层原理AOP底层原理Spring事务底层原理但都只是大致流程，后续会
    

    • 

  • Spring源码学习（十）--推断构造方法
从头再来_f
Spring源码springjava源码

    前言之前有篇文章是关于Bean的生命周期，Spring在扫描完成生成BeanDefinition后会去创建bean，Spring在加载beanClass后会进行实例化，就是需要利用该类的构造方法来实例化得到一个对象，因为之前学习和调试过程中自己没有在代码中去写构造方法，都是使用默认的无参构造方法，但是如果一个类存在多个构造方法，就需要进行构造方法的推导。首先，我们先看一下在javaConfig和x
    

    • 

  • spring源码学习_01 本地环境搭建
Louis.No1
springspring

    参考网上各种资源，终于把spring源码运行起来了；步骤总结如下：spring版本：5.2.x本地系统macidea2019.3.2下载地址：https://www.jetbrains.com/idea/download/other.htmljdk11下载地址：https://repo.huaweicloud.com/java/jdk/1.前期准备安装git、gradle；git的安装过程相对简单
    

    • 

  • 好的文章推荐
LeeGaKi
java

    JVMOOP-Klass模式浅谈JVMOOP-Klass二分模型_在云端123的博客-CSDN博客DDD领域驱动设计开发万字长文，结合电商支付业务一文搞懂DDD(qq.com)Spring源码构建spring源码学习_01本地环境搭建_spring源码运行_Louis.No1的博客-CSDN博客
    

    • 

  • Spring源码学习笔记：经典设计模式之委派模式
Jarvis.y
java设计模式Spring源码学习笔记架构师学习笔记java设计模式spring

    1、博客内容均出自于咕泡学院架构师第三期2、架构师系列内容：架构师学习笔记（持续更新）0、委派模式（DelegatePattern）负责任务的调度和分配任务，跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过程，而委派模式注重结果。不属于GOF232种设计模式之一。属于行为型模式。委派模式跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过
    

    • 

  • Spring源码学习笔记：经典设计模式之工厂模式
Jarvis.y
java设计模式Spring源码学习笔记架构师学习笔记设计模式javaspring

    1、博客内容均出自于咕泡学院架构师第三期2、架构师系列内容：架构师学习笔记（持续更新）0、工厂模式（FactoryPattern）工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。工厂模式跟单例模式紧密相关1、简单工厂模式（SimpleFactoryPatt
    

    • 

  • Spring源码学习之IDEA搭建Spring源码Debug环境
掉发的小王
springspring学习intellij-idea

    一、前言大家肯定都debug过spring的源码，看看bean的创建过程，有个缺点不能自己随意的添加注释。学习开源框架的源码时，搭建一个可以方便地进行调试的环境是非常重要的，不明白的地方也可以修改一下源码的东西！看了好多文章，都是比较老的，现在跟着搭建是有问题的，踩了很多坑，最终完成搭建，整理一下思路还是比较清晰的，让我们一起来试试吧！二、下载导入Idea本次小编使用的Idea版本为2021.3，
    

    • 

  • Spring源码学习（三）-- 底层架构核心概念解析
从头再来_f
Spring源码springjava

    前面，我们大概了解了Spring中的一些概念和底层工作流程，这篇是后续看Spring源码所必备的，防止后续看源码的过程中，遇到不会的概念得单独跳出来学习。BeanDefinitionBeanDefinition表示Bean定义，BeanDefinition中存在很多属性用来描述一个Bean的特点。比如：class，表示Bean类型scope，表示Bean作用域，单例或原型等lazyInit：表示B
    

    • 

  • Spring源码学习(未完待续)
兴厚

    IOC一.注册bean过程（xml解析）使用BeanDefinitionReader读取xml配置文件获取到Document对象//XmlBeanDefinitionReader的intdoLoadBeanDefinitions(InputSourceinputSource,Resourceresource)方法Documentdoc=doLoadDocument(inputSource,reso
    

    • 

  • Spring源码学习（十四）-- AOP底层源码解析下
从头再来_f
Spring源码springjava代理模式

    上篇文章学习了动态代理的使用以及spring中动态代理的基础使用和aop的基本概念，本篇文章首先学习spring中ProxyFactory原理以及aop源码ProxyFactory选择cglib或jdk动态代理原理OrderServicetarget=newOrderService();ProxyFactoryproxyFactory=newProxyFactory();proxyFactory.
    

    • 

  • Spring源码学习（八）-- 依赖注入源码解析（下）
从头再来_f
Spring源码springjava源码

    resolveDependency()实现上篇文章分析了Spring中的自动注入(byName,byType)和@Autowired注解的工作原理以及源码，@Autowired注解依赖注入其中注入点注入，无论是属性注入还是方法注入都有一个相同的方法org.springframework.beans.factory.support.DefaultListableBeanFactory#resolve
    

    • 

  • spring源码学习---@Autowired 注入源码分析和自定义依赖注入
大龄码农生活
spring源码学习

    一、简介众所周知，Spring的依赖注入（DI）对SpringIOC有着举足轻重的作用，是Spring灵魂所在。本篇文章就从日常开发中最常用的注解@Autowired开始，着手分析Spring是如何通过它们将Bean所需的外部资源注入其中.1.1、@Autowired注入规则@Autowired可以应用在非静态字段、非静态方法、构造器上面注入bean。1.2、@Autowired注入过程元信息解析
    

    • 

  • Spring源码学习环境搭建
MuziBlogs

    Spring概览一、作者介绍SpringFramework创始人，著名作者。Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。有着相当丰富的C/C++技术背景的Rod早在1996年就开始了对Java服务器端技术的研究。他是一个在保险、电子商务和金融行业有着丰富经验的技术顾问，同时也是JSR-154（Servlet2.4）和
    

    • 

  • Spring源码学习-SpringBoot原理解析
风之轻殇
Spring源码解读springBootspring学习springboot

    目录SpringBoot启动注解@EnableAutoConfiguration@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)Tomcat和SpringMVC组件的准备过程DispatcherServlet自动装配示例@ServletWebServerFactoryAutoConfigurationSe
    

    • 

  • JVM StackMapTable 属性的作用及理解
lijingyao8206
jvm字节码Class文件StackMapTable

     
      在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
    

    • 

  • 回调函数调用方法
百合不是茶
java

    最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记 记录一下
 
代码很简单:
   
      MainDemo  :调用方法  得到方法的返回结果
  
     
    

    • 

  • [时间机器]制造时间机器需要一些材料
comsci
制造

          根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质
    和材料...
      甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......
     
    

    • 

  • 开口埋怨不如闭口做事
邓集海
邓集海 做人 做事 工作

    “开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。 　　 　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。 　　 　　
    

    • 

  • jQuery插件开发全解析，类级别与对象级别开发
IT独行者
jquery开发插件　函数

    jQuery插件的开发包括两种： 一种是类级别的插件开发，即给
jQuery添加新的全局函数，相当于给
jQuery类本身添加方法。
jQuery的全局函数就是属于
jQuery命名空间的函数，另一种是对象级别的插件开发，即给
jQuery对象添加方法。下面就两种函数的开发做详细的说明。
 
1
、类级别的插件开发 类级别的插件开发最直接的理解就是给jQuer
    

    • 

  • Rome解析Rss
413277409
Rome解析Rss

    import java.net.URL; 
import java.util.List; 
 
import org.junit.Test; 
 
import com.sun.syndication.feed.synd.SyndCategory; 
import com.sun.syndication.feed.synd.S
    

    • 

  • RSA加密解密
无量
加密解密rsa

    RSA加密解密代码
代码有待整理
package com.tongbanjie.commons.util;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerat
    

    • 

  • linux 软件安装遇到的问题
aichenglong
linux遇到的问题ftp

    1 ftp配置中遇到的问题
   500 OOPS: cannot change directory
  出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了
  修改方法:1 修改/etc/selinux/config 中SELINUX=disabled
   2 source /etc
    

    • 

  • 面试心得
alafqq
面试

    最近面试了好几家公司。记录下；
支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败；
阿里金融，面试官人也挺和善，只不过我让他吐血了。。。
由于印象比较深，记录下；
1，自我介绍
2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型）
3，什么是包装类，包装类的优点；
4，平时看过什么书？NND，什么书都没看过。。照样
    

    • 

  • java的多态性探讨
百合不是茶
java

    java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况
//package 1;
class A{
public void test(){
System.out.println("A");
}
}
class D extends A{
public void test(){
S
    

    • 

  • 网络编程基础篇之JavaScript-学习笔记
bijian1013
JavaScript

    1.documentWrite
<html>
<head>
<script language="JavaScript">
document.write("这是电脑网络学校");
document.close();
</script>
</h
    

    • 

  • 探索JUnit4扩展：深入Rule
bijian1013
JUnitRule单元测试

            本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。
        在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
    

    • 

  • [CSS]CSS浮动十五条规则
bit1129
css

    这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。
 
1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
    

    • 

  • 【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景
bit1129
partition

    0.Kafka服务器配置
3个broker
1个topic，6个partition，副本因子是2
2个consumer，每个consumer三个线程并发读取
  1. Producer
package kafka.examples.multibrokers.producers;
import java.util.Properties;
import java.util.
    

    • 

  • zabbix_agentd.conf配置文件详解
ronin47
zabbix 配置文件

    Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]， 或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
    

    • 

  • java--19.用矩阵求Fibonacci数列的第N项
bylijinnan
fibonacci

    参考了网上的思路，写了个Java版的：
public class Fibonacci {
final static int[] A={1,1,1,0};
public static void main(String[] args) {
int n=7;
for(int i=0;i<=n;i++){
int f=fibonac
    

    • 

  • Netty源码学习-LengthFieldBasedFrameDecoder
bylijinnan
javanetty

    先看看LengthFieldBasedFrameDecoder的官方API
http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html
API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下：
实
    

    • 

  • AES加密解密
chicony
加密解密

    AES加解密算法，使用Base64做转码以及辅助加密：
package com.wintv.common;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decod
    

    • 

  • 文件编码格式转换
ctrain
编码格式

    
package com.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

    

    • 

  • mysql 在linux客户端插入数据中文乱码
daizj
mysql中文乱码

    1、查看系统客户端，数据库，连接层的编码
 查看方法： http://daizj.iteye.com/blog/2174993
进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+------
    

    • 

  • 好代码是廉价的代码
dcj3sjt126com
程序员读书

     
长久以来我一直主张：好代码是廉价的代码。
当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。 当他们走近看我的表情、知道我是认真的时，才收敛一点。
当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。”
我只
    

    • 

  • Android网络请求库——android-async-http
dcj3sjt126com
android

    在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
    

    • 

  • ORACLE 复习笔记之SQL语句的优化
eksliang
SQL优化Oracle sql语句优化SQL语句的优化

    转载请出自出处：http://eksliang.iteye.com/blog/2097999
  SQL语句的优化总结如下
 
sql语句的优化可以按照如下六个步骤进行：
合理使用索引
避免或者简化排序
消除对大表的扫描
避免复杂的通配符匹配
调整子查询的性能
EXISTS和IN运算符
下面我就按照上面这六个步骤分别进行总结： 
    

    • 

  • 浅析：Android 嵌套滑动机制（NestedScrolling）
gg163
android移动开发滑动机制嵌套

    谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性
NestedScrolling的特性可以体现在哪里呢？<!--[if !supportLineBreakNewLine]--><!--[endif]-->
比如你使用了Toolbar，下面一个ScrollView，向上滚
    

    • 

  • 使用hovertree菜单作为后台导航
hvt
JavaScriptjquery.nethovertreeasp.net

     
hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。
0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm
hovertree插件包含文件：
http://keleyi.com/jq/hovertree/css
    

    • 

  • SVG 教程 （二）矩形
天梯梦
svg

    SVG <rect> SVG Shapes
SVG有一些预定义的形状元素，可被开发者使用和操作：
矩形 <rect>
圆形 <circle>
椭圆 <ellipse>
线 <line>
折线 <polyline>
多边形 <polygon>
路径 <path>

    

    • 

  • 一个简单的队列
luyulong
java数据结构队列

    
public class MyQueue {
private long[] arr;
private int front;
private int end;
// 有效数据的大小
private int elements;
public MyQueue() {
arr = new long[10];
elements = 0;
front 
    

    • 

  • 基础数据结构和算法九：Binary Search Tree
sunwinner
Algorithm

     
A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
    

    • 

  • 项目出现的一些问题和体会
Steven-Walker
DAOWebservlet

         第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。
    这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。
dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。
 &
    

    • 

  • 高手问答：Java老A带你全面提升Java单兵作战能力！
ITeye管理员
java

    本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论!
作者简介：
淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。
CSDN博客地址：
http://blog.csdn.net/xieyuooo
作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，
    

    •