spring注解源码分析-解析和注入注解配置的资源

最新推荐文章于 2024-06-24 11:35:19 发布
最新推荐文章于 2024-06-24 11:35:19 发布
阅读量1.7k 收藏 6
点赞数 1
分类专栏： spring/hibernate/mybatis 秒扒Spring

类内部的注解，如@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.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);  
    }


注解只不过是利用JDK的反射机制，在编译时或者运行时动态获取所配置的信息而已，注解的真正意义在于通过注解标识获取注解所在对象的信息以及注解中配置的信息。

 

最后欢迎大家访问我的个人网站：1024s

​​​​​​​

崔世勋
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring对注解(Annotation)处理源码分析
04-28
Spring对注解(Annotation)处理源码分析 解析和注入注解配置的资源 源码级别的分析
第一节课-Spring源码分析之-常见底层核心注解-2 (2)1
08-03
本文将深入探讨Spring框架中的核心注解和核心模块，以便更好地理解和利用这一框架。 首先，Spring框架的核心部分由Core和Beans模块组成，它们是整个框架的基础。Core模块包含Spring框架的基本核心工具类，是其他...
Spring注解开发源码解析
Z2658172512的博客
01-30 1178
1：默认情况下，加在容器中的组件，在容器启动时就会调用无参构造函数来创建对象，然后初始化，把@Autowired标注在方法上，该方法如果有参数（组件），会使用autowired的方式（byType）在容器中查找是否有该组件。2：标注在带参构造函数上，如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件可以自动从容器中获取。原因：@Configuration这个注解的作用就是为MainConfig类加上Cglib动态代理，保证容器中的对象都是单例的。
Spring注解源码解析
最新发布
alan_gaohaodong的博客
06-24 375
AnnotationConfigApplicationContext的其中一个构造方法，传入Java config类，refresh过程实例化Bean（排除懒加载Bean）；二、基于注解容器AnnotationConfigApplicationContext。三、AnnotationConfigApplicationContext处理流程。一、Spring IOC常用注解。2、用于定义Bean配置的注解。1、用于Bean申明的注解。
Spring注解源码分析
likunpeng6656201的博客
09-28 418
我们知道如果想使用spring注解你需要在applicationContext.xml配置文件中设置context:component-scan base-package='xxx’这样spring会帮助我们扫描你所设置的目录里面所有的Bean，如果Bean上面有相应的@Service,@Controller注解（当然还有其他的，这里就不一一列出来），那么Spring的IOC容器将会帮我实例对象，...
Spring注解及源码分析
CLAY
04-08 1708
本文记录自己学习spring注解驱动开发教程笔记 参考： 1、https://blog.csdn.net/yerenyuan_pku/category_10613855.html 2、B站视频 12 如何使用@Bean注解指定初始化和销毁的方法 @Scope("prototype") @Bean(initMethod = "init",destroyMethod = "destroy") 一、什么情况使用？ 典型场景：数据源的管理（初始化的时候需要赋值，销毁的时候需要对连接进行关闭清..
Spring注解模式的相关源码解析
zhang442472的博客
10-26 156
基于注解实现的bean注册，要完成的目标 1.1.能够扫描指定包下的类 1.2 基于扫描的类生成定义的bean定义 了解spring是如何描述一个类的信息的 开始注解的扫描及注册源码的解析 由持有的ClasspathBeandefinitionScan开始扫描 3.1 这里主要实现由包名到资源的过程 3.1.1 我们只有包名，需要把它转换成我们需要的资源类型 PathMatchingR...
Spring Ioc源码分析系列--@Autowired注解的实现原理.doc
07-09
Spring Ioc源码分析系列--@Autowired注解的实现原理 @ Автоwired注解是 Spring Framework 中的一个重要组件，它提供了自动装配的功能，能够将 Bean 之间的依赖关系自动解析和注入。今天，我们将深入探讨 @...
Spring 源码分析文档----自用
12-12
### Spring 源码分析——设计模式篇 #### 一、引言 Spring框架作为Java企业级开发领域中不可或缺的一部分，其内部集成了多种设计模式，不仅有助于提高系统的可维护性和扩展性，还能够帮助开发者更好地理解和应用...
Spring注解源码
06-24
在源码分析过程中，我们还会接触到如`@Profile`（环境配置）、`@Scope`（bean的作用域）、`@Value`（注入值）等注解。它们各自都有独特的功能和用法，共同构建了Spring强大的注解驱动开发体系。 理解Spring注解的...
Spring注解源码解析三
qq_35873436的博客
03-22 772
上一节，我们已经分析了通过注解来配置bean，也就是通过@Coponent注解来配置bean,Spring容器启动时就会到指定的路径下扫描，如果发现某个类上标注了@Component注解，就会像扫描xml中的bean标签一样，将类中的信息封装为BeanDefinition并注册Spring容器中。接下来我们学习通过注解@Configuration和注解@Bean来配置bean。
Spring 自定义注解的解析
05-12
在spring环境中通过component-scan配置处理自定义java注解
Spring注解版源码分析（一）
hk700wang_的博客
08-18 402
Spring注解版源码分析（一）基础概念什么是Bean？什么是BeanFactory？最简单的类子？ 基础概念 什么是Bean？ 借用下官方的解释 In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembl
Spring源码(九)-SpringBoot中的注解
liagnzi1259的专栏
08-29 1069
前言上一篇写了Spring相关的注解，由于我的源码分析主要采用的是Springboot的方式，所以这里也顺便把springboot相关的注解也进行一些简单的分析。1、配置类Springboot比Spring之前的xml那种配置方式比较优秀的方式，我觉得最大就在于，减少了大量的配置文件，提供了很多spring-boot-starter-*的包，提供这些开箱即用的方式。当然配置也改用这种注解式的。1.1
Spring注解源码解析二
qq_35873436的博客
03-21 601
在前面的章节中，我们了解了注解的一些用法，并且模拟了Spring是如何通过注解来加载bean的，这一节我们就要开始深入到Spring源码，看下我们常用的注解是如何发挥作用的。 我们先看下这个@Component是如何使用的，我们通过一个案例体验一下： 我们新建一个user8 类，但是我们不需要将User8通过xml进行配置，而是在类上面新增了一个@Component注解。 我们现在是分析的是注解相关的操作，所以我们这里采用的是Spring容器的类型是AnnoationConfigApplicationC
Spring注解详细解析
yaminvsasheng的专栏
08-18 690
基于注释（Annotation）的配置有越来越流行的趋势，Spring 2.5 顺应这种趋势，提供了完全基于注释配置 Bean、装配 Bean 的功能，您可以使用基于注释的 Spring IoC 替换原来基于 XML 的配置。本文通过实例详细讲述了 Spring 2.5 基于注释
Spring源码解析（注解方式）（一）
qq_28526115的博客
09-01 502
Spring源码解析（注解方式）（一） 先来看我们注解容器类AnnotationConfigApplicationContext AnnotationConfig容器类 指定我们所需要的配置类 我们进来看一下其构造方法 参数列表中传入一个可变参数 参数为多个组件类 由于配置类上贴有注解@Configuration注解 为@Component子注解 所以也可以作为组件类传入含参构造器 我们先来看this()方法 指向当前类无参构造器 当前构造器做了两件事 创建了 AnnotatedBeanDefinit
Spring源码解析（一）
weixin_42346558的博客
10-01 76
Spring源码解析（一） 文章目录Spring源码解析（一）1.AnnotationConfigApplicationContext 的构造方法--this()分析2.AnnotationConfigApplicationContext 的构造方法--register()分析2.AnnotationConfigApplicationContext 的构造方法--refresh()分析-未完待续 由于当前更多是使用Spring注解进行开发，所以从Spirng的注解容器AnnotationConfig
Spring 源码-Spring的注解是如何解析的？（7）
qq_39652397的博客
05-12 501
我们知道 ConfigurationClassPostProcessor实际上是BeanFactoryPostProcessor的一个实现类，他特殊的地方是他还实现了BeanDefinitionRegisterPostProcessor接口，所以ConfigurationClassPostProcessor 既要实现BeanFactoryPostProcessor的接口方法postProcessBeanFactory也要实现BeanDefinitionRegisterPostProcessor的接口方法po
Spring核心注解详解：简化开发与维护
5. **Spring源码分析**：文章提到Spring CoreContainer模块，这是Spring框架的基础，负责提供IoC和DI功能，其中BeanFactory是核心。它通过消除单例模式，实现依赖关系和配置的分离。Context模块基于Core和Beans扩展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值