Spring對註解(Annotation)處理原始碼分析2——解析和注入註解配置的資源

1.類內部的註解，如：@Autowire、@Value、@Required、@Resource以及EJB和WebSerivce相關的註解，是容器對Bean物件例項化和依賴注入時，通過容器中註冊的Bean後置處理器處理這些註解的。

2.Spring中處理註解的Bean後置處理器：

當使用Spring的註解功能時，在Spring配置檔案中新增如下配置開啟Spring的註解處理器：

<context:annotation-config> < context:component-scan >

上面的配置將隱式地向Spring容器註冊、CommonAnnotationBeanPostProcessor

、PersistenceAnnotationBeanPostProcessor以及這4個專門用於處理註解的Bean後置處理器。

下面將具體介紹這4個註解後置處理器。

是Spring容器專門處理配置了自動依賴注入裝配相關注解(@Autowire、@Value以及其他JSR-330註解)的Bean後置處理器，其主要功能原始碼如下：

(1).的構造方法：

AutowiredAnnotationBeanPostProcessor只有一個的構造方法，其原始碼如下：

public AutowiredAnnotationBeanPostProcessor() { //後置處理器將處理@Autowire註解 this.autowiredAnnotationTypes.add(Autowired.class); //後置處理器將處理@Value註解 this.autowiredAnnotationTypes.add(Value.class); //獲取當前類的類載入器 ClassLoader cl = AutowiredAnnotationBeanPostProcessor.class.getClassLoader(); try { //後置處理器將處理javax.inject.Inject JSR-330註解 this.autowiredAnnotationTypes.add((Class<? extends Annotation>) cl.loadClass("javax.inject.Inject")); logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } }

(2).為指定類選擇其合適的構造方法：

容器對指定類進行自動依賴注入裝配(autowiring)時，容器需要對Bean呼叫合適的構造方法建立例項物件，AutowiredAnnotationBeanPostProcessor為指定類選擇相應的構造方法，原始碼如下：

//為自動依賴注入裝配Bean選擇合適的構造方法 public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException { //首先從容器的快取中查詢是否有指定Bean的構造方法 Constructor[] candidateConstructors = this.candidateConstructorsCache.get(beanClass); ／/容器快取中沒有給定類的構造方法 if (candidateConstructors == null) { //執行緒同步以確保容器中資料一致性 synchronized (this.candidateConstructorsCache) { candidateConstructors = this.candidateConstructorsCache.get(beanClass); if (candidateConstructors == null) { //通過JDK反射機制，獲取指定類的中所有宣告的構造方法 Constructor[] rawCandidates = beanClass.getDeclaredConstructors(); //存放候選構造方法的集合 List<Constructor> candidates = new ArrayList<Constructor>(rawCandidates.length); //autowire註解中required屬性指定的構造方法 Constructor requiredConstructor = null; //預設的構造方法 Constructor defaultConstructor = null; //遍歷所有的構造方法，檢查是否添加了autowire註解，以及是否 //指定了required屬性 for (Constructor<?> candidate : rawCandidates) { //獲取指定類中所有關於autowire的註解(Annotation) Annotation annotation = findAutowiredAnnotation(candidate); //如果指定類中有關於antowire的註解 if (annotation != null) { //如果antowire註解中指定了required屬性 if (requiredConstructor != null) { throw new BeanCreationException("Invalid autowire-marked constructor: " + candidate + ". Found another constructor with 'required' Autowired annotation: " + requiredConstructor); } //如果autowire註解的引數列表為空 if (candidate.getParameterTypes().length == 0) { throw new IllegalStateException( "Autowired annotation requires at least one argument: " + candidate); } //獲取autowire註解中required屬性值 boolean required = determineRequiredStatus(annotation); //如果獲取到autowire註解中required的屬性值 if (required) { //如果候選構造方法集合不為空 if (!candidates.isEmpty()) { throw new BeanCreationException( "Invalid autowire-marked constructors: " + candidates + ". Found another constructor with 'required' Autowired annotation: " + requiredConstructor); } //當前的構造方法就是required屬性所配置的構造方法 requiredConstructor = candidate; } //將當前的構造方法新增到哦啊候選構造方法集合中 candidates.add(candidate); } //如果類中沒有autowire的相關注解，並且構造方法引數列表為空 else if (candidate.getParameterTypes().length == 0) { //當前的構造方法是預設構造方法 defaultConstructor = candidate; } } //如果候選構造方法集合不為空 if (!candidates.isEmpty()) { //如果所有的構造方法都沒有配置required屬性，且有預設構造方法 if (requiredConstructor == null && defaultConstructor != null) { //將預設構造方法新增到候選構造方法列表 candidates.add(defaultConstructor); } //將候選構造方法集合轉換為陣列 candidateConstructors = candidates.toArray(new Constructor[candidates.size()]); } //如果候選構造方法集合為空，則建立一個空的陣列 else { candidateConstructors = new Constructor[0]; } //將類的候選構造方法集合存放到容器的快取中 this.candidateConstructorsCache.put(beanClass, candidateConstructors); } } } //返回指定類的候選構造方法陣列，如果沒有返回null return (candidateConstructors.length > 0 ? candidateConstructors : null); }

(3).AutowiredAnnotationBeanPostProcessor對方法和屬性的依賴注入：

當Spring容器對配置了autowire相關注解的Bean進行依賴注入時，後置處理器對屬性和物件進行自動注入處理，原始碼如下：

//處理類中的屬性 public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { //獲取指定類中autowire相關注解的元資訊 InjectionMetadata metadata = findAutowiringMetadata(bean.getClass()); try { //對Bean的屬性進行自動注入 metadata.inject(bean, beanName, pvs); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex); } return pvs; } //處理物件的注入 public void processInjection(Object bean) throws BeansException { //獲取給定Bean的Class物件 Class<?> clazz = bean.getClass(); //獲取給定類中autowire相關注解元資訊 InjectionMetadata metadata = findAutowiringMetadata(clazz); try { //對Bean物件進行自動注入 metadata.inject(bean, null, null); } catch (Throwable ex) { throw new BeanCreationException("Injection of autowired dependencies failed for class [" + clazz + "]", ex); } } //獲取給定類的autowire相關注解元資訊 private InjectionMetadata findAutowiringMetadata(Class clazz) { //首先從容器中查詢是否有給定類的autowire相關注解元資訊 InjectionMetadata metadata = this.injectionMetadataCache.get(clazz); if (metadata == null) { synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(clazz); if (metadata == null) { //解析給定類autowire相關注解元資訊 metadata = buildAutowiringMetadata(clazz); //將得到的給定類autowire相關注解元資訊儲存在容器快取中 this.injectionMetadataCache.put(clazz, metadata); } } } return metadata; } //解析給定類autowire相關注解元資訊 private InjectionMetadata buildAutowiringMetadata(Class clazz) { //建立一個存放註解元資訊的集合 LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>(); Class<?> targetClass = clazz; //遞迴遍歷當前類及其所有基類，解析全部註解元資訊 do { //建立一個儲存當前正在處理類註解元資訊的集合 LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>(); //利用JDK反射機制獲取給定類中所有的宣告欄位，獲取欄位上的註解資訊 for (Field field : targetClass.getDeclaredFields()) { //獲取給定欄位上的註解 Annotation annotation = findAutowiredAnnotation(field); if (annotation != null) { //如果給定欄位是靜態的(Static)，則直接遍歷下一個欄位 if (Modifier.isStatic(field.getModifiers())) { if (logger.isWarnEnabled()) { logger.warn("Autowired annotation is not supported on static fields: " + field); } continue; } //判斷註解的required屬性值是否有效 boolean required = determineRequiredStatus(annotation); //將當前欄位元資訊封裝，新增在返回的集合中 currElements.add(new AutowiredFieldElement(field, required)); } } //利用JDK反射機制獲取給定類中所有的宣告方法，獲取方法上的註解資訊 for (Method method : targetClass.getDeclaredMethods()) { //獲取給定方法上的所有註解 Annotation annotation = findAutowiredAnnotation(method); if (annotation != 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); } continue; } //如果方法的引數列表為空 if (method.getParameterTypes().length == 0) { if (logger.isWarnEnabled()) { logger.warn("Autowired annotation should be used on methods with actual parameters: " + method); } } //判斷註解的required屬性值是否有效 boolean required = determineRequiredStatus(annotation); //獲取當前方法的屬性描述符，即方法是可讀的(readable)getter方法， //還是可寫的(writeable)setter方法 PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); //將方法元資訊封裝新增到返回的元資訊集合中 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); } //獲取給定物件的autowire相關注解 private Annotation findAutowiredAnnotation(AccessibleObject ao) { //遍歷所有autowire相關的註解:@Autowire、@Value以及JSR-330等 for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) { //獲取給定物件上的指定型別的註解 Annotation annotation = ao.getAnnotation(type); if (annotation != null) { return annotation; } } return null; }

(4).AutowiredAnnotationBeanPostProcessor對欄位和方法的注入：

a.AutowiredAnnotationBeanPostProcessor對欄位的注入是通過AutowiredFieldElement類的inject方法實現的，原始碼如下：

//對欄位進行注入 protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable { //獲取注入元素物件 Field field = (Field) this.member; try { Object value; //如果當前物件在容器中被快取 if (this.cached) { //根據Bean名稱解析快取中的欄位值 value = resolvedCachedArgument(beanName, this.cachedFieldValue); } //如果當前物件沒有被容器快取 else { //建立一個欄位依賴描述符 DependencyDescriptor descriptor = new DependencyDescriptor(field, this.required); Set<String> autowiredBeanNames = new LinkedHashSet<String>(1); //獲取容器中的型別轉換器 TypeConverter typeConverter = beanFactory.getTypeConverter(); //根據容器中Bean定義，解析指定的依賴關係，獲取依賴物件 value = beanFactory.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); //執行緒同步，確保容器中資料一致性 synchronized (this) { //如果當前物件沒有被容器快取 if (!this.cached) { //獲取到了當前物件的依賴物件，並且required屬性為true if (value != null || this.required) { this.cachedFieldValue = descriptor; //為指定Bean註冊依賴Bean registerDependentBeans(beanName, autowiredBeanNames); if (autowiredBeanNames.size() == 1) { String autowiredBeanName = autowiredBeanNames.iterator().next(); //如果容器中有指定名稱的Bean物件 if (beanFactory.containsBean(autowiredBeanName)) { //依賴物件型別和欄位型別匹配，預設按型別注入 if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) { //建立一個依賴物件的引用，同時快取 this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName); } } } } //如果獲取的依賴關係為null，且獲取required屬性為false else { //將欄位值的快取設定為null this.cachedFieldValue = null; } //容器已經對當前欄位的值快取 this.cached = true; } } } //如果欄位依賴值不為null if (value != null) { //顯式使用JDK的反射機制，設定自動的訪問控制權限為允許訪問 ReflectionUtils.makeAccessible(field); //為Bean物件的欄位設定值 field.set(bean, value); } } catch (Throwable ex) { throw new BeanCreationException("Could not autowire field: " + field, ex); } } }

b.AutowiredAnnotationBeanPostProcessor對欄位的注入是通過AutowiredMethodElement類的inject方法實現的，原始碼如下：

//對方法進行注入 protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable { //如果屬性被顯式設定為skip，則不進行注入 if (checkPropertySkipping(pvs)) { return; } //獲取注入元素物件 Method method = (Method) this.member; try { Object[] arguments; //如果容器對當前方法快取 if (this.cached) { //獲取快取中指定Bean名稱的方法引數 arguments = resolveCachedArguments(beanName); } //如果沒有快取 else { //獲取方法的引數列表 Class[] paramTypes = method.getParameterTypes(); //建立一個存放方法引數的陣列 arguments = new Object[paramTypes.length]; DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length]; Set<String> autowiredBeanNames = new LinkedHashSet<String>(paramTypes.length); //獲取容器的型別轉換器 TypeConverter typeConverter = beanFactory.getTypeConverter(); for (int i = 0; i < arguments.length; i++) { //建立方法引數物件 MethodParameter methodParam = new MethodParameter(method, i); //解析方法的輸入引數和返回值型別 GenericTypeResolver.resolveParameterType(methodParam, bean.getClass()); //為方法引數建立依賴描述符 descriptors[i] = new DependencyDescriptor(methodParam, this.required); //根據容器中Bean定義解析依賴關係，獲取方法引數依賴物件 arguments[i] = beanFactory.resolveDependency( descriptors[i], beanName, autowiredBeanNames, typeConverter); //如果容器解析的方法引數為null，且方法required屬性為false if (arguments[i] == null && !this.required) { //設定方法的引數列表為null arguments = null; break; } } //執行緒同步，以確保容器中資料一致性 synchronized (this) { //如果當前方法沒有被容器快取 if (!this.cached) { //如果方法的引數列表不為空 if (arguments != null) { //為容器中快取方法引數的物件賦值 this.cachedMethodArguments = new Object[arguments.length]; for (int i = 0; i < arguments.length; i++) { this.cachedMethodArguments[i] = descriptors[i]; } //為指定Bean註冊依賴Bean registerDependentBeans(beanName, autowiredBeanNames); //如果依賴物件集合大小等於方法引數個數 if (autowiredBeanNames.size() == paramTypes.length) { Iterator<String> it = autowiredBeanNames.iterator(); //為方法引數設定依賴物件 for (int i = 0; i < paramTypes.length; i++) { String autowiredBeanName = it.next(); //如果容器中存在指定名稱的Bean物件 if (beanFactory.containsBean(autowiredBeanName)) { //如果引數型別和依賴物件型別匹配 if (beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) { //建立一個依賴物件的引用，複製給方法相應的引數 this.cachedMethodArguments[i] = new RuntimeBeanReference(autowiredBeanName); } } } } } //如果方法引數列表為null，則設定容器對該方法引數的快取為null else { this.cachedMethodArguments = null; } //設定容器已經對該方法快取 this.cached = true; } } } //如果方法引數依賴物件不為null if (arguments != null) { //使用JDK的反射機制，顯式設定方法的訪問控制權限為允許訪問 ReflectionUtils.makeAccessible(method); //呼叫Bean的指定方法 method.invoke(bean, arguments); } } catch (InvocationTargetException ex) { throw ex.getTargetException(); } catch (Throwable ex) { throw new BeanCreationException("Could not autowire method: " + method, ex); } }

beanFactory.resolveDependency和registerDependentBeans方法我們在Spring容器依賴注入原始碼分析中已經分析過，這裡就不再具體分析。

後置處理器主要解析autowire相關的註解，即@Autowire、@Value等。

4.：

CommonAnnotationBeanPostProcessor是Spring中用於處理JavaEE5中常用註解(主要是EJB相關的註解)和Java6中關於JAX-WS相關的註解，可以處理PostConstruct、@PreDestroy等Bean生命週期相關事件的註解，該後置處理最核心的是處理@Resource註解，同時還可以處理JAX-WS相關的註解，按照其主要功能分析其主要實現原始碼：

(1).靜態初始化塊和建構函式：

//WebService關於JAX-WS的相關注解 private static Class<? extends Annotation> webServiceRefClass = null; //EJB相關的註解 private static Class<? extends Annotation> ejbRefClass = null; //靜態初始化塊 static { //獲取當前類的類載入器 ClassLoader cl = CommonAnnotationBeanPostProcessor.class.getClassLoader(); try { //使用類載入器載入WebService相關的類 webServiceRefClass = (Class) cl.loadClass("javax.xml.ws.WebServiceRef"); } catch (ClassNotFoundException ex) { webServiceRefClass = null; } try { //使用類載入器載入EJB相關的類 ejbRefClass = (Class) cl.loadClass("javax.ejb.EJB"); } catch (ClassNotFoundException ex) { ejbRefClass = null; } } //構造方法 public CommonAnnotationBeanPostProcessor() { setOrder(Ordered.LOWEST_PRECEDENCE - 3); //設定初始的註解型別為@PostConstruct setInitAnnotationType(PostConstruct.class); //設定消耗的註解為@ PreDestroy setDestroyAnnotationType(PreDestroy.class); //當使用@Resource註解時，忽略JAX-WS的資源型別 ignoreResourceType("javax.xml.ws.WebServiceContext"); }

從CommonAnnotationBeanPostProcessor的靜態初始化塊和構造方法可以看出該後置處理器主要處理EJB和WebService相關的註解，以及Bean生命週期事件的相關注解。

(2).CommonAnnotationBeanPostProcessor對屬性值的查詢：

CommonAnnotationBeanPostProcessor對普通屬性的處理與AutowiredAnnotationBeanPostProcessor的處理基本相同，不同在於查詢屬性值的方法不同，通過autowire相關注解的required配置獲取依賴的屬性值，則通過對@Resource註解的解析獲取屬性的值，CommonAnnotationBeanPostProcessor獲取屬性值的主要原始碼：

//處理屬性值 public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { //獲取@Resource註解中配置的屬性值元資料 InjectionMetadata metadata = findResourceMetadata(bean.getClass()); try { //注入屬性值，與AutowiredAnnotationBeanPostProcessor中處理相同 metadata.inject(bean, beanName, pvs); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex); } return pvs; } //獲取@Resource註解中配置的屬性值元資料 private InjectionMetadata findResourceMetadata(final Class clazz) { //首先從容器快取中查詢 InjectionMetadata metadata = this.injectionMetadataCache.get(clazz); //快取中沒有給定類的註解元資訊資料 if (metadata == null) { //執行緒同步，以確保容器中資料一致 synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(clazz); if (metadata == null) { //建立一個用於存放註解元資料的集合 LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>(); Class<?> targetClass = clazz; //遞迴地的解析給定類及其所有基類的註解元資訊 do { //建立一個存放當前類註解元資料的集合 LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>(); //遍歷給定類中所有的欄位，查詢符合的註解 for (Field field : targetClass.getDeclaredFields()) { //如果欄位上配置了WebService相關的註解 if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) { //如果欄位是靜態的，則註解對靜態欄位無效 if (Modifier.isStatic(field.getModifiers())) { throw new IllegalStateException("@WebServiceRef annotation is not supported on static fields"); } //如果欄位不是靜態，則將當前欄位封裝為WebService引用元素 currElements.add(new WebServiceRefElement(field, null)); } //如果當前欄位上配置了EJB相關的註解 else if (ejbRefClass != null && field.isAnnotationPresent(ejbRefClass)) { if (Modifier.isStatic(field.getModifiers())) { throw new IllegalStateException("@EJB annotation is not supported on static fields"); } //將當前欄位封裝為EJB引用元素 currElements.add(new EjbRefElement(field, null)); } //如果當前欄位上配置了@Resource註解 else if (field.isAnnotationPresent(Resource.class)) { if (Modifier.isStatic(field.getModifiers())) { throw new IllegalStateException("@Resource annotation is not supported on static fields"); } //如果當前自動的型別不再被忽略的Resource型別中， //則將當前欄位封裝為資源元素 if (!ignoredResourceTypes.contains(field.getType().getName())) { currElements.add(new ResourceElement(field, null)); } } } //遍歷給定類中的所有方法，查詢相關的註解 for (Method method : targetClass.getDeclaredMethods()) { //如果方法上配置了WebService相關的註解 if (webServiceRefClass != null && method.isAnnotationPresent(webServiceRefClass) && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { //如方法是靜態的，則註解不支援靜態方法 if (Modifier.isStatic(method.getModifiers())) { throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods"); } //如果方法引數個數不等於1 if (method.getParameterTypes().length != 1) { throw new IllegalStateException("@WebServiceRef annotation requires a single-arg method: " + method); } //獲取方法的屬性描述 PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); //將當前方法物件和方法屬性描述封裝為WebService引用元素 currElements.add(new WebServiceRefElement(method, pd)); } //如果方法上配置了EJB相關的註解 else if (ejbRefClass != null && method.isAnnotationPresent(ejbRefClass) && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { if (Modifier.isStatic(method.getModifiers())) { throw new IllegalStateException("@EJB annotation is not supported on static methods"); } if (method.getParameterTypes().length != 1) { throw new IllegalStateException("@EJB annotation requires a single-arg method: " + method); } PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); currElements.add(new EjbRefElement(method, pd)); } //如果方法上配置了@Resource註解 else if (method.isAnnotationPresent(Resource.class) && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { if (Modifier.isStatic(method.getModifiers())) { throw new IllegalStateException("@Resource annotation is not supported on static methods"); } Class[] paramTypes = method.getParameterTypes(); if (paramTypes.length != 1) { throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method); } if (!ignoredResourceTypes.contains(paramTypes[0].getName())) { PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); currElements.add(new ResourceElement(method, pd)); } } } //將當前類註解元資訊存放到註解元資訊集合中 elements.addAll(0, currElements); //獲取當前物件的基類 targetClass = targetClass.getSuperclass(); } //如果基類不為null，且基類不是Object while (targetClass != null && targetClass != Object.class); metadata = new InjectionMetadata(clazz, elements); //快取給定類的註解元資訊 this.injectionMetadataCache.put(clazz, metadata); } } } return metadata; }

從上面的原始碼中，我們可以看到，對於方法上面的註解，EJB和WebService相關注解以及@Resource只能在單個引數的方法上配置，否則會有異常丟擲。

(3).根據給定名稱或者型別獲取資源物件：

WebService和EJB相關注解以及@Resource主要是為所新增的欄位或者方法注入所需要的資源，CommonAnnotationBeanPostProcessor類中獲取資源的原始碼如下：

//根據給定名稱或者型別獲取資源物件 protected Object getResource(LookupElement element, String requestingBeanName) throws BeansException { //如果註解物件元素的mappedName屬性不為空 if (StringUtils.hasLength(element.mappedName)) { //根據JNDI名稱和型別去Spring的JNDI容器中獲取Bean return this.jndiFactory.getBean(element.mappedName, element.lookupType); } //如果該後置處理器的alwaysUseJndiLookup屬性值為true if (this.alwaysUseJndiLookup) { //從Spring的JNDI容器中查詢指定JDNI名稱和型別的Bean return this.jndiFactory.getBean(element.name, element.lookupType); } if (this.resourceFactory == null) { throw new NoSuchBeanDefinitionException(element.lookupType, "No resource factory configured - specify the 'resourceFactory' property"); } //使用autowiring自動依賴注入裝配，通過給定的名稱和型別從資源容器獲取Bean物件 return autowireResource(this.resourceFactory, element, requestingBeanName); } //自動依賴注入裝配資源物件 protected Object autowireResource(BeanFactory factory, LookupElement element, String requestingBeanName) throws BeansException { Object resource; Set<String> autowiredBeanNames; String name = element.name; if (this.fallbackToDefaultTypeMatch && element.isDefaultName && factory instanceof AutowireCapableBeanFactory && !factory.containsBean(name)) { autowiredBeanNames = new LinkedHashSet<String>(); //根據容器中Bean定義解析給定的依賴關係，將依賴以資源物件返回 resource = ((AutowireCapableBeanFactory) factory).resolveDependency( element.getDependencyDescriptor(), requestingBeanName, autowiredBeanNames, null); } //根據給定JDNI名稱和型別從Spring的JDNI容器查詢資源 else { resource = factory.getBean(name, element.lookupType); autowiredBeanNames = Collections.singleton(name); } //為指定的Bean註冊依賴的Bean if (factory instanceof ConfigurableBeanFactory) { ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory; for (String autowiredBeanName : autowiredBeanNames) { beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName); } } return resource; }

(4)[email protected]、WebService和EJB相關注解的解析和屬性注入：

Spring中，@Resource註解是由類解析的，WebService相關注解是由類解析的，EJB相關注解是由EjbRefElement類解析的，下面就具體分析其解析的實現

a.ResourceElement解析@Resource註解和屬性注入：

ResourceElement是Spring中用於解析@Resource註解和屬性注入的類，原始碼如下：

//解析@Resource註解 protected void initAnnotation(AnnotatedElement ae) { //獲取元素物件的@Resource註解 Resource resource = ae.getAnnotation(Resource.class); //獲取@Resource註解的name屬性值作為資源名稱 String resourceName = resource.name(); //獲取@Resource註解的type屬性值作為資源型別 Class resourceType = resource.type(); //根據註解配置的資源名稱是否為空，判斷元素是否有預設名稱 this.isDefaultName = !StringUtils.hasLength(resourceName); //如果元素有預設名稱 if (this.isDefaultName) { //獲取元素物件名稱作為資源名稱 resourceName = this.member.getName(); //如果當前添加註解的物件是方法，且方法名稱以set開頭，且屬性名稱 //不為空(方法名長度大於3，即除了set之外還有其他字元) if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) { //利用JDK的內省機制格式化物件名稱，轉換為Java標準的駝峰命名法 resourceName = Introspector.decapitalize(resourceName.substring(3)); } } //如果當前的容器是ConfigurableBeanFactory型別容器 else if (beanFactory instanceof ConfigurableBeanFactory){ //解析給定的物件名的內嵌值做為資源名稱 resourceName = ((ConfigurableBeanFactory) beanFactory).resolveEmbeddedValue(resourceName); } //如果註解配置的資源型別不為空，且不說Object型別 if (resourceType != null && !Object.class.equals(resourceType)) { //檢查資源型別是欄位還是方法 checkResourceType(resourceType); } else { //如果註解中沒有配置資源型別，則利用JDK反射機制判斷是欄位還是方法 resourceType = getResourceType(); } //設定當前註解元素的資源名稱 this.name = resourceName; //設定當前註解元素的JNDI型別 this.lookupType = resourceType; //獲取@Resource註解的mappedName屬性值，設定當前註解元素的JNDI名稱 this.mappedName = resource.mappedName(); //獲取@Resource註解的shareable屬性值，設定當前註解元素是否在容器中共享 this.shareable = resource.shareable(); } //注入屬性 protected Object getResourceToInject(Object target, String requestingBeanName) { //呼叫我們在(3)中分析的原始碼，注入依賴的資源物件 return getResource(this, requestingBeanName); }

解析WebService相關的註解和屬性注入：

WebServiceRefElement是Spring中用於解析WebService相關注解和屬性注入的類，原始碼如下：

//解析WebService相關的註解 protected void initAnnotation(AnnotatedElement ae) { //獲取元素物件上的@WebServiceRef註解 WebServiceRef resource = ae.getAnnotation(WebServiceRef.class); //獲取@WebServiceRef註解的name屬性值作為資源名稱 String resourceName = resource.name(); //獲取@WebServiceRef註解的type屬性值作為資源型別 Class resourceType = resource.type(); //根據資源名稱是否為空判斷當前元素是否有預設名稱 this.isDefaultName = !StringUtils.hasLength(resourceName); //如果當前元素有預設名稱 if (this.isDefaultName) { //獲取當前元素物件的名稱作用資源名稱 resourceName = this.member.getName(); //如果添加註解的當前元素是方法，且方法名以set開頭，且資源物件名稱不為空 if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) { //利用JDK的內省機制，將格式化資源名稱(將去掉set之後的名稱首字//母小寫)，是資源名稱符合java變數的駝峰命名規則 resourceName = Introspector.decapitalize(resourceName.substring(3)); } } //如果@WebServiceRef註解的type屬性值不為空 if (resourceType != null && !Object.class.equals(resourceType)) { //根據註解配置的資源型別值檢查資源物件是欄位還是方法 checkResourceType(resourceType); } //如果@WebServiceRef註解沒有配置type屬性 else { //容器通過JDK的反射機制檢查資源物件是欄位還是方法型別 resourceType = getResourceType(); } //將資源名稱賦值給元素的名稱 this.name = resourceName; //為元素設定資源型別 this.elementType = resourceType; //指定型別的資源可以Service被訪問 if (Service.class.isAssignableFrom(resourceType)) { //設定JNDI的型別 this.lookupType = resourceType; } //如果指定型別的資源不能被Service訪問 else { //根據@WebServiceRef註解的value屬性值是否是Object，設定JNDI型別 this.lookupType = (!Object.class.equals(resource.value()) ? resource.value() : Service.class); } //獲取@WebServiceRef註解的mappedName屬性值，設定JNDI名稱 this.mappedName = resource.mappedName(); //獲取@WebServiceRef註解的wsdlLocation屬性值，設定元素的wsdl路徑 this.wsdlLocation = resource.wsdlLocation(); } //屬性注入 protected Object getResourceToInject(Object target, String requestingBeanName) { Service service; try { //根據JNDI名稱和型別獲取指定資源物件 service = (Service) getResource(this, requestingBeanName); } catch (NoSuchBeanDefinitionException notFound) { //如果JNDI型別是Service if (Service.class.equals(this.lookupType)) { throw new IllegalStateException("No resource with name '" + this.name + "' found in context, " + "and no specific JAX-WS Service subclass specified. The typical solution is to either specify " + "a LocalJaxWsServiceFactoryBean with the given name or to specify the (generated) Service " + "subclass as @WebServiceRef(...) value."); } //如果元素的wsdl路徑不為空 if (StringUtils.hasLength(this.wsdlLocation)) { try { //根據wsdl獲取構造方法 Constructor ctor = this.lookupType.getConstructor(new Class[] {URL.class, QName.class}); //獲取元素JDNI型別的@WebServiceClient註解，建立WebService客戶端物件 WebServiceClient clientAnn = this.lookupType.getAnnotation(WebServiceClient.class); if (clientAnn == null) { throw new IllegalStateException("JAX-WS Service class [" + this.lookupType.getName() + "] does not carry a WebServiceClient annotation"); } //根據構造方法和wsdl檔案WebService例項物件 service = (Service) BeanUtils.instantiateClass(ctor, new URL(this.wsdlLocation), new QName(clientAnn.targetNamespace(), clientAnn.name())); } catch (NoSuchMethodException ex) { throw new IllegalStateException("JAX-WS Service class [" + this.lookupType.getName() + "] does not have a (URL, QName) constructor. Cannot apply specified WSDL location [" + this.wsdlLocation + "]."); } catch (MalformedURLException ex) { throw new IllegalArgumentException( "Specified WSDL location [" + this.wsdlLocation + "] isn't a valid URL"); } } //如果元素沒有配置wsdl檔案路徑，則根據JNDI型別建立WebService例項 //通過JDK的反射機制，呼叫合適的構造方法建立例項物件 else { service = (Service) BeanUtils.instantiateClass(this.lookupType); } } //根據資源型別建立WebService提供服務的代理物件 return service.getPort(this.elementType); }

通過上面的原始碼分析，我們知道Spring容器在對WebSerice進行注入時，首先通過JNDI查詢容器中的例項物件，如果沒有找到，則根據wsdl檔案例項化WebService物件，如果沒有指定wsdl檔案的路徑，則根據型別利用JDK的反射機制生成WebService例項物件，完成注入。

c.EjbRefElement解析EJB相關的註解和屬性注入：

EjbRefElement是Spring中用於解析EJB相關注解和屬性注入的類，原始碼如下：

//解析EJB相關的註解 protected void initAnnotation(AnnotatedElement ae) { //獲取元素上的@EJB註解 EJB resource = ae.getAnnotation(EJB.class); //獲取@EJB註解的beanName屬性值，作為資源Bean名稱 String resourceBeanName = resource.beanName(); //獲取@EJB註解的name屬性值，作為資源名稱 String resourceName = resource.name(); //根據資源名稱是否為空判斷元素是否有預設名稱 this.isDefaultName = !StringUtils.hasLength(resourceName); //如果元素有預設名稱 if (this.isDefaultName) { //獲取元素物件名稱作用資源名稱 resourceName = this.member.getName(); //如果元素是方法，且是以set開頭的方法，並且元素名稱不為空 if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) { //利用JDK內省機制格式化資源名稱 resourceName = Introspector.decapitalize(resourceName.substring(3)); } } //獲取@EJB註解中的beanInterface屬性值，作用資源型別 Class resourceType = resource.beanInterface(); //如果資源型別不為空，且不是Object if (resourceType != null && !Object.class.equals(resourceType)) { //根據資源型別判斷資源是欄位還是方法 checkResourceType(resourceType); } //如果@EJB註解中沒有指定資源型別 else { //利用JDK反射機制判斷資源是欄位還是方法型別 resourceType = getResourceType(); } //設定元素的Bean名稱為@EJB註解中配置的resourceBeanName屬性值 this.beanName = resourceBeanName; //設定元素名稱為資源名稱 this.name = resourceName; //設定JNDI型別為資源型別 this.lookupType = resourceType; //獲取@EJB註解中的mappedName屬性值，作為JDNI名稱 this.mappedName = resource.mappedName(); } //屬性注入 protected Object getResourceToInject(Object target, String requestingBeanName) { //如果當前Bean名稱不為空 if (StringUtils.hasLength(this.beanName)) { //如果容器不為null，並且容器中存在指定名稱的Bean if (beanFactory != null && beanFactory.containsBean(this.beanName)) { //直接從本地容器中獲取指定名稱的Bean Object bean = beanFactory.getBean(this.beanName, this.lookupType); //向容器註冊Bean名稱 if (beanFactory instanceof ConfigurableBeanFactory) { ((ConfigurableBeanFactory) beanFactory).registerDependentBean(this.beanName, requestingBeanName); } //返回從本地容器中獲取到的Bean物件 return bean; } //如果元素有預設名稱，且元素的JNDI名稱為空 else if (this.isDefaultName && !StringUtils.hasLength(this.mappedName)) { throw new NoSuchBeanDefinitionException(this.beanName, "Cannot resolve 'beanName' in local BeanFactory. Consider specifying a general 'name' value instead."); } } //通過JNDI查詢指定名稱資源 return getResource(this, requestingBeanName); } }

從上面對@Resource、WebService和EJB相關注解解析原始碼的分析中，我們可以看出，Spring主要使用JDNI查詢方式獲取這三類註解資源，另外，由原始碼的“if (this.memberinstanceof Method&& resourceName.startsWith("set") && resourceName.length() > 3)”判斷條件，我們可以看出這三類註解只能新增在欄位上，或者set屬性方法上，在get屬性方法上新增這三類註解將是無法被解析的。

5.RequiredAnnotationBeanPostProcessor：

是Spring中用於處理@Required註解的，@Required註解強制要求Bean屬性必須被配置，當Spring容器對Bean的屬性進行依賴注入時，配置了@Required註解的屬性，Spring容器會檢查依賴關係是否設定，按照其主要功能分析其主要實現原始碼：

//注入屬性 public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { //如果容器快取中沒有指定Bean名稱 if (!this.validatedBeanNames.contains(beanName)) { //如果指定Bean定義中沒有設定skipRequiredCheck屬性 if (!shouldSkip(this.beanFactory, beanName)) { List<String> invalidProperties = new ArrayList<String>(); //遍歷所有屬性 for (PropertyDescriptor pd : pds) { //如果屬性添加了@Required註解，且屬性集合中不包含指定名稱的屬性 if (isRequiredProperty(pd) && !pvs.contains(pd.getName())) { //當前屬性為無效的屬性 invalidProperties.add(pd.getName()); } } //如果無效屬性集合不為空 if (!invalidProperties.isEmpty()) { throw new BeanInitializationException(buildExceptionMessage(invalidProperties, beanName)); } } //將Bean名稱快取到容器中 this.validatedBeanNames.add(beanName); } //返回經過驗證的屬性值 return pvs; } //檢查給定屬性上是否添加了@Required註解 protected boolean isRequiredProperty(PropertyDescriptor propertyDescriptor) { //獲取給定屬性的寫方法(setter方法) Method setter = propertyDescriptor.getWriteMethod(); //檢查給定屬性方法上是否存在指定型別的註解 return (setter != null && AnnotationUtils.getAnnotation(setter, getRequiredAnnotationType()) != null); }

6.：

PersistenceAnnotationBeanPostProcessor是Spring中用於處理JPA相關注解的Bean後置處理器，主要解析和處理@PersistenceUnit、@PersistenceContext註解，其主要作用是為JPA的實體管理器工廠(EntityManagerFactory)和實體管理器(EntityManager)注入相應的持久化單元(PersistenceUnit)或持久化上下文(PersistenceContext)。按照其主要功能分析其主要實現原始碼：

(1).處理和查詢持久化元資訊：

//處理持久化相關屬性 public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { //查詢給定類中持久化元資訊 InjectionMetadata metadata = findPersistenceMetadata(bean.getClass()); try { //為Bean注入持久化屬性 metadata.inject(bean, beanName, pvs); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of persistence dependencies failed", ex); } return pvs; } //查詢給定類中的持久化元資訊 private InjectionMetadata findPersistenceMetadata(final Class clazz) { //首先從容器快取中查詢給定類的元資訊 InjectionMetadata metadata = this.injectionMetadataCache.get(clazz); //容器快取中沒有給定類的元資訊 if (metadata == null) { //執行緒同步，以確保容器中資料的一致性 synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(clazz); if (metadata == null) { //建立一個儲存所有注入元資訊的集合 LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>(); Class<?> targetClass = clazz; //遞迴遍歷給定類及其所有非Object型別的基類 do { //建立一個儲存當前類注入資訊的集合 LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>(); //遍歷給定類的所有宣告欄位 for (Field field : targetClass.getDeclaredFields()) { //獲取當前欄位上的@PersistenceContext註解 PersistenceContext pc = field.getAnnotation(PersistenceContext.class); //獲取當前欄位上的@PersistenceUnit註解 PersistenceUnit pu = field.getAnnotation(PersistenceUnit.class); //當前欄位上配置了@PersistenceContext或者@PersistenceUnit註解 if (pc != null || pu != null) { //持久化註解不支援在靜態欄位上配置 if (Modifier.isStatic(field.getModifiers())) { throw new IllegalStateException("Persistence annotations are not supported on static fields"); } //將配置了持久化註解的欄位新增到當前類的注入元資訊集合中 currElements.add(new PersistenceElement(field, null)); } } //遍歷給定類的所有宣告方法 for (Method method : targetClass.getDeclaredMethods()) { //獲取當前方法上的@PersistenceContext註解 PersistenceContext pc = method.getAnnotation(PersistenceContext.class); //獲取當前方法上的@PersistenceUnit註解 PersistenceUnit pu = method.getAnnotation(PersistenceUnit.class); //當前方法上配置了@PersistenceContext或者@PersistenceUnit註解 if (pc != null || pu != null && //靜態方法上不支援配置持久化註解 method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { if (Modifier.isStatic(method.getModifiers())) { throw new IllegalStateException("Persistence annotations are not supported on static methods"); } //持久化註解只能配置了只有一個引數的方法上 if (method.getParameterTypes().length != 1) { throw new IllegalStateException("Persistence annotation requires a single-arg method: " + method); } //獲取當前方法的屬性描述符 PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); //將配置了持久化註解的方法新增到當前類的注入元資訊集合中 currElements.add(new PersistenceElement(method, pd)); } } //將當前類的注入元資訊新增到注入元資訊集合中 elements.addAll(0, currElements); //獲取當前類的基類 targetClass = targetClass.getSuperclass(); } //當前類的基類不為null，且不是Object，遞迴注入基類元資訊 while (targetClass != null && targetClass != Object.class); metadata = new InjectionMetadata(clazz, elements); //向容器中快取給定類的注入元資訊 this.injectionMetadataCache.put(clazz, metadata); } } } //返回查詢到的注入元資訊 return metadata; }

(2).根據持久化單元名稱獲取持久化上下文、持久化單元和實體管理器工廠：

PersistenceAnnotationBeanPostProcessor最重要的核心功能就是根據持久化單元名稱獲取相應的持久化上下文，持久化單元或者實體管理器工廠，原始碼如下：

//根據持久化單元名稱獲取實體管理器工廠 protected EntityManagerFactory getPersistenceUnit(String unitName) { //如果持久化單元不為null if (this.persistenceUnits != null) { //獲取持久化單元名稱 String unitNameForLookup = (unitName != null ? unitName : ""); //如果持久化單元名稱為空 if ("".equals(unitNameForLookup)) { //將預設的持久化單元名稱作為持久化單元名稱 unitNameForLookup = this.defaultPersistenceUnitName; } //獲取持久化單元的JNDI名稱 String jndiName = this.persistenceUnits.get(unitNameForLookup); if (jndiName == null && "".equals(unitNameForLookup) && this.persistenceUnits.size() == 1) { //從持久化單元中獲取JNDI名稱 jndiName = this.persistenceUnits.values().iterator().next(); } if (jndiName != null) { try { //查詢指定JNDI名稱的實體管理器工廠 return lookup(jndiName, EntityManagerFactory.class); } catch (Exception ex) { throw new IllegalStateException("Could not obtain EntityManagerFactory [" + jndiName + "] from JNDI", ex); } } } return null; } //查詢給定持久化單元名稱的實體管理器 protected EntityManager getPersistenceContext(String unitName, boolean extended) { //獲取持久化上下文 Map<String, String> contexts = (extended ? this.extendedPersistenceContexts : this.persistenceContexts); //持久化上下文不為null if (contexts != null) { String unitNameForLookup = (unitName != null ? unitName : ""); if ("".equals(unitNameForLookup)) { unitNameForLookup = this.defaultPersistenceUnitName; } //從持久化上下文中獲取給定持久化單元名稱的JNDI String jndiName = contexts.get(unitNameForLookup); if (jndiName == null && "".equals(unitNameForLookup) && contexts.size() == 1) { jndiName = contexts.values().iterator().next(); } if (jndiName != null) { try { //查詢指定JNDI名稱的實體管理器 return lookup(jndiName, EntityManager.class); } catch (Exception ex) { throw new IllegalStateException("Could not obtain EntityManager [" + jndiName + "] from JNDI", ex); } } } return null; } //從Spring容器中查詢給定名稱的實體管理器工廠 protected EntityManagerFactory findEntityManagerFactory(String unitName, String requestingBeanName) throws NoSuchBeanDefinitionException { //當前Spring容器為null if (this.beanFactory == null) { throw new IllegalStateException("ListableBeanFactory required for EntityManagerFactory bean lookup"); } //獲取持久化單元名稱 String unitNameForLookup = (unitName != null ? unitName : ""); //如果持久化單元名稱為空，則將容器預設持久化單元名稱作用持久化單元名稱 if ("".equals(unitNameForLookup)) { unitNameForLookup = this.defaultPersistenceUnitName; } //如果持久化單元名稱不為空，查詢給定持久化單元名稱的實體管理器工廠 if (!"".equals(unitNameForLookup)) { return findNamedEntityManagerFactory(unitNameForLookup, requestingBeanName); } //如果持久化單元名稱為空，獲取容器中預設的實體管理器工廠 else { return findDe </div> <div class="entry-footer"> <div class="entry-tag"> </div> <div class="entry-page"> <center><script type="text/javascript" src="/js/article.js"></script></center> </div> <h3 class="entry-related-title">相關推薦</h3> <style> .r{ margin-bottom:10px; border-bottom:1px solid #f1f1f1; padding-bottom:10px;} .r p{ color:#999; line-height:25px;} .r h5 a{ font-size:16px; line-height:25px;} .r h5 a:hover{ color:#ff6600} </style> <div class="r"> <h5><a href="/content/1548519126.html" target="_blank"><font color=red>Spring</font><font color=red>對</font><font color=red>註解</font>(<font color=red>Annotation</font>)<font color=red>處理</font><font color=red>原始碼</font><font color=red>分析</font><font color=red>2</font>——<font color=red>解析</font><font color=red>和</font><font color=red>注入</font><font color=red>註解</font><font color=red>配置</font>的<font color=red>資源</font></a></h5> <p> 1.類內部的註解，如：@Autowire、@Value、@Required、@Resource以及EJB和WebSerivce相關的註解，是容器對Bean物件例項化和依賴注入時，通過容器中註冊的Bean後置處理器處理這些註解的。 2.Spring中處理註解的Bean後置處 </p> </div> <div class="r"> <h5><a href="/content/1547572004.html" target="_blank"><font color=red>Spring</font><font color=red>對</font><font color=red>註解</font>(<font color=red>Annotation</font>)<font color=red>處理</font><font color=red>原始碼</font><font color=red>分析</font>1——掃描<font color=red>和</font>讀取Bean定義</a></h5> <p> 1.從Spring2.0以後的版本中，Spring也引入了基於註解(Annotation)方式的配置，註解(Annotation)是JDK1.5中引入的一個新特性，用於簡化Bean的配置，某些場合可以取代XML配置檔案。開發人員對註解(Annotation)的態度也是蘿蔔 </p> </div> <div class="r"> <h5><a href="/content/1547279223.html" target="_blank"><font color=red>Spring</font> Transaction 5.1.3 <font color=red>原始碼</font><font color=red>分析</font> : AnnotationTransactionAttributeSource <font color=red>解析</font><font color=red>註解</font>式事務屬性</a></h5> <p> 概述 Spring支援使用註解指定服務方法的事務屬性。這些事務註解可以用在類上，也可以用在方法上，如下例子所示。 Spring事務註解例子–應用在類級別將事務註解標記到服務元件類級別,相當於為該服務元件的每個服務方法都應用了這個註解。 import org.sprin </p> </div> <div class="r"> <h5><a href="/content/1548884529.html" target="_blank"><font color=red>spring</font><font color=red>註解</font><font color=red>原始碼</font><font color=red>分析</font>-<font color=red>解析</font><font color=red>和</font><font color=red>注入</font><font color=red>註解</font><font color=red>配置</font>的<font color=red>資源</font></a></h5> <p> 類內部的註解，如@Autowire、@Value、@Required、@Resource以及EJB和WebService相關的註解，是容器對Bean例項化和依賴注入時，通過容器中註冊的Bean後置處理處理這些註解的。當使用Spring的註解功能時， <cont </p> </div> <div class="r"> <h5><a href="/content/1546264834.html" target="_blank">React<font color=red>原始碼</font><font color=red>分析</font><font color=red>2</font> — 元件<font color=red>和</font>物件的建立（createClass，createElement）</a></h5> <p> 1 元件的建立 React受大家歡迎的一個重要原因就是可以自定義元件。這樣的一方面可以複用開發好的元件，實現一處開發，處處呼叫，另外也能使用別人開發好的元件，提高封裝性。另一方面使得程式碼結構很清晰，元件間耦合減少，方便維護。ES5建立元件時，呼叫React. </p> </div> <div class="r"> <h5><a href="/content/1544816168.html" target="_blank"><font color=red>Spring</font> component-scan<font color=red>原始碼</font><font color=red>分析</font>（二） -- @Configuration<font color=red>註解</font><font color=red>處理</font></a></h5> <p> 上篇文章Spring component-scan原始碼分析（一） – XML解析分析了Spring解析<context:component-scan …/>標籤時，把掃描到的合適的類封裝成BeanDefinition加入Sping容器中，本篇分析S </p> </div> <div class="r"> <h5><a href="/content/1542630306.html" target="_blank"><font color=red>Spring</font><font color=red>原始碼</font><font color=red>分析</font>(十五)<font color=red>Spring</font>中常用<font color=red>註解</font>使用以及<font color=red>原始碼</font><font color=red>分析</font></a></h5> <p> 從Java5.0開始，Java開始支援註解。Spring做為Java生態中的領軍框架，從2.5版本後也開始支援註解。相比起之前使用xml來配置Spring框架，使用註解提供了更多的控制Spring框架的方式。現在越來越多的專案也都在使用註解做相關的配置，但Spring的註解非常多，相信 </p> </div> <div class="r"> <h5><a href="/content/1546334837.html" target="_blank">MyBatis<font color=red>原始碼</font>閱讀——MyBatis<font color=red>對</font>事務的<font color=red>處理</font>過程<font color=red>分析</font></a></h5> <p> 事務管理器在 MyBatis 中有兩種型別的事務管理器（也就是 type=”[JDBC|MANAGED]”）： <environments default="development"> <environment id=" </p> </div> <div class="r"> <h5><a href="/content/1547484662.html" target="_blank">電影網站增刪改查 <font color=red>spring</font> boots/MVC/neo4j <font color=red>原始碼</font><font color=red>分析</font>-<font color=red>2</font> DATA 實體建模(noe4j)</a></h5> <p> 模型設計部分：分為節點實體和關係實體兩個節點實體 actor , movie ，一個關係實體 actor in movies (roles) 前提， NEO4J 必須配置 1.neo4j依賴 spring-data-neo4j jackson-jsog 2.con </p> </div> <div class="r"> <h5><a href="/content/1547760627.html" target="_blank"><font color=red>Spring</font> 3.1新特性之二：@Enable*<font color=red>註解</font>的<font color=red>原始碼</font>,<font color=red>spring</font><font color=red>原始碼</font><font color=red>分析</font>之定時任務Scheduled<font color=red>註解</font></a></h5> <p> 分析SpringBoot的自動化配置原理的時候，可以觀察下這些@Enable*註解的原始碼，可以發現所有的註解都有一個@Import註解。@Import註解是用來匯入配置類的，這也就是說這些自動開啟的實現其實是匯入了一些自動配置的Bean。如：freemarker的自動化配置類FreeMarkerAuto </p> </div> <div class="r"> <h5><a href="/content/1541488397.html" target="_blank">Netty Pipeline<font color=red>原始碼</font><font color=red>分析</font>(<font color=red>2</font>)</a></h5> <p> 原文連結：wangwei.one/posts/netty… 前面，我們分析了Netty Pipeline的初始化及節點新增與刪除邏輯。接下來，我們將來分析Pipeline的事件傳播機制。 Netty版本：4.1.30 inBound事件傳播示例我們通過下面這個例子來演示Ne </p> </div> <div class="r"> <h5><a href="/content/1541752809.html" target="_blank">lucene<font color=red>原始碼</font><font color=red>分析</font>(<font color=red>2</font>)讀取過程例項</a></h5> <p> 1.官方提供的程式碼demo Analyzer analyzer = new StandardAnalyzer(); // Store the index in memory: Directory directory = new RAMDirec </p> </div> <div class="r"> <h5><a href="/content/1541899323.html" target="_blank">x264裡的2pass指的是什麼意思 x264<font color=red>原始碼</font><font color=red>分析</font><font color=red>2</font> encode</a></h5> <p> 分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！ </p> </div> <div class="r"> <h5><a href="/content/1542125883.html" target="_blank">Shiro<font color=red>原始碼</font><font color=red>分析</font>(<font color=red>2</font>) - 會話管理器(SessionManager)</a></h5> <p> 本文在於分析Shiro原始碼，對於新學習的朋友可以參考 [開濤部落格](http://jinnianshilongnian.iteye.com/blog/2018398)進行學習。本文對Shiro中的SessionManager進行分析，SessionMan </p> </div> <div class="r"> <h5><a href="/content/1542246809.html" target="_blank">Java程式設計師從笨鳥到菜鳥之（八十一）細談<font color=red>Spring</font>（十）深入<font color=red>原始碼</font><font color=red>分析</font><font color=red>Spring</font>之HibernateTemplate</a></h5> <p> 分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！ </p> </div> <div class="r"> <h5><a href="/content/1543129400.html" target="_blank">《<font color=red>2</font>.uboot<font color=red>和</font>系統移植-第6部分-<font color=red>2</font>.6.uboot<font color=red>原始碼</font><font color=red>分析</font><font color=red>2</font>-啟動第二階段》</a></h5> <p> 《2.uboot和系統移植-第6部分-2.6.uboot原始碼分析2-啟動第二階段》第一部分、章節目錄 2.6.1.start_armboot函式簡介 2.6.2.start_armboot解析1 2.6.3.記憶體使用排布 2.6.4.start_armboot解析2 2.6.5.s </p> </div> <div class="r"> <h5><a href="/content/1543714384.html" target="_blank">am335x 核心<font color=red>原始碼</font><font color=red>分析</font><font color=red>2</font> LCD移植</a></h5> <p> 1、/arch/arm/mach-omap2/board-am335xevm.c/lcdc_init(){得到LCD硬體引數struct da8xx_lcdc_platform_data} -> am33xx_register_lcdc() -> omap_device_ </p> </div> <div class="r"> <h5><a href="/content/1543887015.html" target="_blank">MyBatis<font color=red>原始碼</font><font color=red>分析</font>-<font color=red>2</font>-基礎支援層-反射模組-TypeParameterResolver/ObjectFactory</a></h5> <p> TypeParameterResolver： TypeParameterResolver的功能是：當存在複雜的繼承關係以及泛型定義時， TypeParameterResolver 可以幫助我們解析欄位、方法引數或方法返回值的型別。TypeParameterResolver 是在Refelctor </p> </div> <div class="r"> <h5><a href="/content/1544348881.html" target="_blank">muduo<font color=red>原始碼</font><font color=red>分析</font>(<font color=red>2</font>) --記憶體分配</a></h5> <p> 寫在前面：這個原始碼是分析libevent-2.0.20-stable, 並非最新版本的libevent，作者並沒有全看原始碼，在這裡會推薦以下參考的一些網站，也歡迎大家在不足的地方提出來進行討論。什麼都沒包裝的記憶體管理預設情況下,l </p> </div> <div class="r"> <h5><a href="/content/1544553368.html" target="_blank">Minix3<font color=red>原始碼</font><font color=red>分析</font>(<font color=red>2</font>)——系統初始化</a></h5> <p> minix3的啟動牽扯到幾次控制權轉移，它們發生在mpx386.s中的組合語言例程和start.c及main.c中的C語言例程之間。彙編程式碼需要做許多工作，包括建立一個棧幀以便為C編譯器編譯的程式碼提供適當的環境，複製處理器所使用的表格來定義儲存器段，建 </p> </div>  </div> </div> </article> </div> <aside class="sidebar"> <div id="search-7" class="widget widget_search"> <h3 class="widget-title">搜尋</h3> <form name="formsearch" class="search-form" action="https://www.796t.com/public/api.php" method="get"> <input type="hidden" name="app" value="search"/> <input type="text" class="keyword" name="q" placeholder="輸入關鍵詞..." value=""> <input type="submit" class="submit" value=""> </form> </div> <div id="wpcom-image-ad-4" class="widget widget_image_ad"></div> <div id="tag_cloud-3" class="widget widget_tag_cloud"> <h3 class="widget-title">基礎教學</h3> <div class="tagcloud"> <a href="https://www.796t.com/category.php?cid=18" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Mysql入門</a> <a href="https://www.796t.com/category.php?cid=19" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Sql入門</a> <a href="https://www.796t.com/category.php?cid=20" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Android入門</a> <a href="https://www.796t.com/category.php?cid=21" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Docker入門</a> <a href="https://www.796t.com/category.php?cid=22" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Go語言入門</a> <a href="https://www.796t.com/category.php?cid=23" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Ruby程式入門</a> <a href="https://www.796t.com/category.php?cid=24" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Python入門</a> <a href="https://www.796t.com/category.php?cid=25" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Python進階</a> <a href="https://www.796t.com/category.php?cid=26" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Django入門</a> <a href="https://www.796t.com/category.php?cid=27" class="tag-cloud-link tag-link-66 tag-link-position-1" style="font-size: 22pt;">Python爬蟲入門</a> </div> </div> <div id="wpcom-image-ad-12" class="widget widget_image_ad"> </div> <div id="wpcom-post-thumb-3" class="widget widget_post_thumb"> <h3 class="widget-title">最近訪問</h3> <ul> <p><a href="/content/.html" style="font-size:16px;"> </a> </p> </ul> </div> </aside> </div> </div> <footer class="footer"> <div class="container"> <div class="clearfix"> <div class="footer-col footer-col-copy"> <ul class="footer-nav hidden-xs"> <li id="menu-item-109589" class="menu-item current-menu-item current_page_item menu-item-109589"><a href="https://www.796t.com/" aria-current="page">首頁</a></li><li class="menu-item menu-item-373"><a href="https://www.796t.com/category.php?cid=9">前端設計</a></li><li class="menu-item menu-item-373"><a href="https://www.796t.com/category.php?cid=10">程式設計</a></li><li class="menu-item menu-item-373"><a href="https://www.796t.com/category.php?cid=13">免費資源</a></li><li class="menu-item menu-item-373"><a href="https://www.796t.com/category.php?cid=14">實用技巧</a></li><li class="menu-item menu-item-373"><a href="https://www.796t.com/category.php?cid=15">資料庫</a></li><li class="menu-item menu-item-373"><a href="https://www.796t.com/category.php?cid=29">資訊</a></li><li class="menu-item menu-item-373"><a href="https://www.3du.tw/zidian.php">字典</a></li></ul> <div class="copyright"> <p>Copyright © 2002-2020 <a href="https://www.796t.com/">程式人生</a> 796T.COM All rights reserved. </p> </div> </div> <div class="footer-col footer-col-sns"> <div class="footer-sns"> </div> </div> </div> </div> </footer> <style> .footer{padding-bottom: 20px;} </style> <script type="text/javascript" src="/css/main.js"></script> <script type="text/javascript" src="/css/wp-embed.js"></script> <script type="text/javascript" src="/css/lazysizes.min.js"></script> <script src="https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@10.1.2/build/highlight.min.js"></script> <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/highlight.js@10.1.2/styles/atelier-estuary-light.css"> <script>hljs.initHighlightingOnLoad();</script> </body> </html>