L'interface BeanFactory fournit des spécifications pour l'utilisation des conteneurs IOC. Sur cette base, Spring fournit également des principes de conception conformes à cette interface de conteneur IOC. Prenons l'exemple de l'implémentation de XmlBeanFactory pour illustrer le principe de conception d'un simple conteneur IOC.
Ici , nous utilisons un code pour obtenir XmlBeanFactory expliquer:
XmlBeanFactoryLa fonction est construite sur DefaultListableBeanFactoryla base du conteneur de base, et a réalisé d' autres fonctions supplémentaires telles que XML lu ce conteneur de base sur la mise en œuvre des principes de ces caractéristiques , nous voyons un regardez XmlBeanFactoryle code qui implémente il est facile à comprendre.
@Deprecated
@SuppressWarnings({"serial", "all"})
public class XmlBeanFactory extends DefaultListableBeanFactory {
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
/**
* Create a new XmlBeanFactory with the given resource,
* which must be parsable using DOM.
* @param resource the XML resource to load bean definitions from
* @throws BeansException in case of loading or parsing errors
*/
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
/**
* Create a new XmlBeanFactory with the given input stream,
* which must be parsable using DOM.
* @param resource the XML resource to load bean definitions from
* @param parentBeanFactory parent bean factory
* @throws BeansException in case of loading or parsing errors
*/
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
}
XmlBeanFactoryDu point de vue de l'annotation, il a été marqué comme une classe obsolète, mais cela n'affecte pas notre analyse de conception du conteneur de base. XmlBeanFactoryVous devez obtenir l'objet Resource dans la méthode de construction et charger BenDefinition via l'appel de méthode de l' XmlBeanDefinitionReaderobjet loadBeanDefinitions. En mode de fichier de configuration XML, il s'agit d'une partie importante de l'initialisation IOC. Lorsque nous exécutons le code suivant, un conteneur IOC XmlBeanFactory de base est créé.
XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));
Le diagramme de séquence de l'implémentation de code ci-dessus est:
Ici, nous pouvons voir que tout d'abord, lorsque nous définissons un XMLBeanFactory, nous devons passer ici un objet ressource Resource. La méthode de traitement spécifique de l'objet ressource, nous ne l'expliquerons pas ici. Stratégie de chargement unifiée des ressources de printemps . Les classes liées aux ressources terminent l'encapsulation du fichier de configuration, et le fichier de configuration est lu XmlBeanDefinitionReaderet géré. Il existe de nombreuses méthodes d'initialisation pour XmlBeanFactory et de nombreux constructeurs sont fournis dans Spring. Nous analysons ici la méthode d'utilisation d'une Resourceinstance comme paramètre de construction. Le code est le suivant:
/**
* Create a new XmlBeanFactory with the given resource,
* which must be parsable using DOM.
* @param resource the XML resource to load bean definitions from
* @throws BeansException in case of loading or parsing errors
*/
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
Le constructeur appelle à nouveau le constructeur interne en interne:
/**
* Create a new XmlBeanFactory with the given input stream,
* which must be parsable using DOM.
* @param resource the XML resource to load bean definitions from
* @param parentBeanFactory parent bean factory
* @throws BeansException in case of loading or parsing errors
*/
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
L'exécution this.reader.loadBeanDefinitions(resource)dans le code ci - dessus est la véritable implémentation de la résolution des ressources. Dans le diagramme de séquence, nous pouvons voir que les
données de chargement de XmlBeanDefinitionreader sont effectuées ici, mais il existe également un processus d'appel du constructeur de la classe parent avant le chargement des données par XmlBeanDefinitionReader :, super(parentBeanFactory)le code de suivi de la classe parent AbstractAutowireCapableBeanFactoryappelle l'un des constructeurs de la classe parent :
/**
* Create a new AbstractAutowireCapableBeanFactory.
*/
public AbstractAutowireCapableBeanFactory() {
super();
ignoreDependencyInterface(BeanNameAware.class);
ignoreDependencyInterface(BeanFactoryAware.class);
ignoreDependencyInterface(BeanClassLoaderAware.class);
}
ignoreDependencyInterface(Class<?> ifc)La fonction principale de la méthode est d'ignorer la fonction d'assemblage automatique de l'interface donnée, qui est expliquée dans Spring:
ignorer l'interface de dépendance donnée pour le câblage automatique. Elle sera généralement utilisée par les contextes d'application pour enregistrer les dépendances qui sont résolues d'autres manières, comme BeanFactory via BeanFactoryAware ou ApplicationContext via ApplicationContextAware. Par défaut, seule l'interface BeanFactoryAware est ignorée. Pour que d'autres types soient ignorés, appelez cette méthode pour chaque type.
Ignorez l'interface dépendante donnée lors de l'assemblage automatique. Ces interfaces d'assemblage automatique spécifiées seront injectées par d'autres méthodes, par exemple ApplicationContextpar ApplicationContextAwareinjection ou BeanFactorypar BeanFactoryAwareinjection.
