2. 程式人生 > >spring註解原始碼分析-解析和注入註解配置的資源

spring註解原始碼分析-解析和注入註解配置的資源

阿新 • • 發佈：2019-01-31

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

當使用Spring的註解功能時，

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


上面的配置將隱式地向Spring容器註冊：CommonAnnotationBeanPostProcessor, PersistenceAnnotationBeanPostProcessor以及這4個專門用於處理註解的Bean後置處理器。

AutowiredAnnotationBeanPostProcessor

是spring容器專門處理配置了自動依賴注入裝配相關注解的Bean後置處理器。

（1）建構函式

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）指定類選擇合適的構造方法

//為自動依賴注入裝配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);  
    }

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

（3）對屬性的依賴注入

//為自動依賴注入裝配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);  
    }

（4）對欄位進行注入

//為自動依賴注入裝配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);  
    }

（5）對方法進行注入

//為自動依賴注入裝配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);  
    }

CommonAnnotationBeanPostProcessor

是對JavaEE中常用註解的處理，可以處理@PostConstruct、@PreDestroy等，處理最核心的是@Resource註解。

//為自動依賴注入裝配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);  
    } 
//為自動依賴注入裝配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);  
    } 
//為自動依賴注入裝配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);  
    } 
//為自動依賴注入裝配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);  
    } 
//為自動依賴注入裝配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);  
    } 
//為自動依賴注入裝配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);  
    }

RequiredAnnotationBeanPostProcessor

處理@Required註解，@Required註解強制要求Bean屬性必須被配置，當Spring容器對Bean屬性進行依賴注入時，配置了@Required註解的屬性，Spring容器會檢查依賴關係是否設定。

//為自動依賴注入裝配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);  
    }

PersistenceAnnotationBeanPostProcessor

用於處理JPA相關注解的Bean後置處理器，主要解析和處理@PersistenceUnit @PersistenceContext註解，其主要作用是為JPA的實體管理器工廠和實體管理器注入相應的持久化單元或上下文。

//為自動依賴注入裝配Bean選擇合適的構造方法  
public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {  
        //首先從容器的快取中查詢是否有指定Bean的構造方法  
        Constructor[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);  
        ／/容器快取中沒有給定類的構造方法  
        if (candidateConstructors == null) {  
            //執行緒同步以確保容器中資料一致性  
            synchronized (this

相關推薦

spring註解原始碼分析-解析和注入註解配置的資源

類內部的註解，如@Autowire、@Value、@Required、@Resource以及EJB和WebService相關的註解，是容器對Bean例項化和依賴注入時，通過容器中註冊的Bean後置處理處理這些註解的。 當使用Spring的註解功能時， <cont

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

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

spring 註解原始碼分析-掃描和讀取bean定義

1.概述 從spring2.0以後的版本中，spring也引入了基於註解方式的配置，註解是jdk1.5中引入的一個新特性，用於簡化Bean的配置，某些場合可以取代xml配置檔案。 Spring IoC容器對於類級別的註解和類內部的註解分以下兩種策略： （1）類級別的註解

spring下應用@Resource, @Autowired 和 @Inject註解進行依賴注入的差異

為了探尋 ‘@Resource’, ‘@Autowired’, 和‘@Inject’如何解決依賴注入中的問題，我建立了一個“Party”介面，和它的兩個實現類“Person”，“Organization”。這樣我就可以在注入Bean的時候不必使用具體型別（指使用介面型別即可）。這樣做也方便我研究當一個介面有多

【Spring Boot原始碼分析】@EnableAutoConfiguration註解（一）@AutoConfigurationImportSelector註解的處理

一、概述 @EnableAutoConfiguration註解是Spring Boot中配置自動裝載的總開關。本文將從@EnableAutoConfiguration入手，嘗試通過原始碼分析增強對Spring Boot的理解。   所用版本：Spring Boot 2.2.0.M5 + Spring

Spring Ioc 原始碼分析之Bean的載入和構造

我們都知道，Spring Ioc和Aop是Spring的核心的功能，因此花一點時間去研究還是很有意義的，如果僅僅是知其所以然，也就體會不到大師設計Spring的精華，還記得那句話，Spring為JavaEE開發帶來了春天。IOC就是Inversion of control 也就是控制反轉的意思，另一種稱呼叫做

shiro原始碼分析之自定義註解RequiredPermission(可代替RequiresPermissions)

1.現象 shiro使用RequiresPermissions等註解必須新增如下切面，否則不生效 @Bean public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(Security

springboot條件註解原始碼分析

上篇我們講到springboot註解之:@EnableAutoConfiguration，主要講到springboot如何自動載入配置，核心類是ConfigurationClassPostProcessor。在spring容器啟動的時候去掃描有@Component的類，然後對掃描到的類進

spring boot 專案中元件和各種註解

spring boot 專案分析 最近一直在做專案，都是有一塊補一塊，也沒系統的整理下spring boot個元件的功能和使用方式，就大致總結下，也是為了方便以後快速構建專案 (1) web 容器 spring-boot-starter-web 預設tomcat 可以去除tomcat (2)

spring beans原始碼解讀之--Bean的註解(annotation)

隨著spring註解的引入，越來越多的開發者開始使用註解，這篇文章將對註解的機制進行串聯式的講解，不求深入透徹，但求串起spring beans註解的珍珠，展示給大家。 1. spring beans常用的註解：   public @interface Autowired：可以對成員變數、方法和建構函式進

Spring中Bean的註冊與注入——註解方式

<beans> // 註解Autowired的註解處理器 <bean class="....AutowiredAnnotationBeanPostProcessor"

Spring Security原始碼分析六：Spring Social社交登入原始碼解析

在Spring Security原始碼分析三：Spring Social實現QQ社交登入和Spring Security原始碼分析四：Spring Social實現微信社交登入這兩章中，我們使用Spring Social已經實現了國內最常用的QQ和微信社交

Spring MVC原始碼(三) ----- @RequestBody和@ResponseBody原理解析

概述 在SpringMVC的使用時，往往會用到@RequestBody和@ResponseBody兩個註解，尤其是處理ajax請求必然要使用@ResponseBody註解。這兩個註解對應著Controller方法的引數解析和返回值處理，開始時都是隻知其用，不知原理。我們來看個例子。 @RequestM

簡明易理解的@SpringBootApplication註解原始碼分析

@SpringBootApplication public class MicroServiceApplication { public static void main(String[] args) { SpringApplication.run(MicroServiceAppl

曹工說Spring Boot原始碼（18）-- Spring AOP原始碼分析三部曲，終於快講完了 (aop：config完整解析【下】)

寫在前面的話 相關背景及資源： 曹工說Spring Boot原始碼（1）-- Bean Definition到底是什麼，附spring思維導圖分享 曹工說Spring Boot原始碼（2）-- Bean Definition到底是什麼，咱們對著介面，逐個方法講解 曹工說Spring Boot原始碼（3）--

[01] 註解的基本認識和元註解

ons 方法 ide 參考 ive img 重寫 列表 bject 1、什麽是註解用一個詞就可以描述註解，那就是元數據，即一種描述數據的數據。所以，可以說註解就是源代碼的元數據。@Overridepublic String toString() { return "T

Spring AOP原始碼分析

概述 定義 官方定義：Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about prog

Spring IOC原始碼分析

Spring IOC原始碼分析 Spring 應用 1 注入巢狀Bean 在Spring中，如果某個Bean所依賴的Bean不想被Spring容器直接訪問，可以使用巢狀Bean。和普通的Bean一樣，使用元素來定義巢狀的Bean，巢狀Bean只對它的外部的Bean有效，Sprin

Spring-AOP原始碼分析

一、概述 Spring的兩大特性：IOC和AOP。 AOP是面向切面程式設計，Spring內建了自己實現的基於動態代理技術的AOP，同時還支援成熟的AspectJ框架，我們這裡主要講述的還是內建的基於動態代理的AOP實現。因為面對一些普通的需求，Spring內建的AOP已經綽綽有餘。

Spring Devtools 原始碼初步解析

前言 最近在閱讀spring cloud原始碼的時候 發現spring devtools這個包 覺得比較有趣,就研究了一下.然後寫了這篇文章。 主要解決三個疑問 1 如何初始化 2 如何實時監聽 3 如何遠端重啟 1構造 Restarter Restarter是在spring容器啟動過程中通過Res