001/* 002 * Copyright 2002-2017 the original author or authors. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * https://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017package org.springframework.beans.factory.support; 018 019import org.springframework.beans.factory.BeanDefinitionStoreException; 020import org.springframework.core.io.Resource; 021import org.springframework.core.io.ResourceLoader; 022import org.springframework.lang.Nullable; 023 024/** 025 * Simple interface for bean definition readers. 026 * Specifies load methods with Resource and String location parameters. 027 * 028 * <p>Concrete bean definition readers can of course add additional 029 * load and register methods for bean definitions, specific to 030 * their bean definition format. 031 * 032 * <p>Note that a bean definition reader does not have to implement 033 * this interface. It only serves as suggestion for bean definition 034 * readers that want to follow standard naming conventions. 035 * 036 * @author Juergen Hoeller 037 * @since 1.1 038 * @see org.springframework.core.io.Resource 039 */ 040public interface BeanDefinitionReader { 041 042 /** 043 * Return the bean factory to register the bean definitions with. 044 * <p>The factory is exposed through the BeanDefinitionRegistry interface, 045 * encapsulating the methods that are relevant for bean definition handling. 046 */ 047 BeanDefinitionRegistry getRegistry(); 048 049 /** 050 * Return the resource loader to use for resource locations. 051 * Can be checked for the <b>ResourcePatternResolver</b> interface and cast 052 * accordingly, for loading multiple resources for a given resource pattern. 053 * <p>A {@code null} return value suggests that absolute resource loading 054 * is not available for this bean definition reader. 055 * <p>This is mainly meant to be used for importing further resources 056 * from within a bean definition resource, for example via the "import" 057 * tag in XML bean definitions. It is recommended, however, to apply 058 * such imports relative to the defining resource; only explicit full 059 * resource locations will trigger absolute resource loading. 060 * <p>There is also a {@code loadBeanDefinitions(String)} method available, 061 * for loading bean definitions from a resource location (or location pattern). 062 * This is a convenience to avoid explicit ResourceLoader handling. 063 * @see #loadBeanDefinitions(String) 064 * @see org.springframework.core.io.support.ResourcePatternResolver 065 */ 066 @Nullable 067 ResourceLoader getResourceLoader(); 068 069 /** 070 * Return the class loader to use for bean classes. 071 * <p>{@code null} suggests to not load bean classes eagerly 072 * but rather to just register bean definitions with class names, 073 * with the corresponding Classes to be resolved later (or never). 074 */ 075 @Nullable 076 ClassLoader getBeanClassLoader(); 077 078 /** 079 * Return the BeanNameGenerator to use for anonymous beans 080 * (without explicit bean name specified). 081 */ 082 BeanNameGenerator getBeanNameGenerator(); 083 084 085 /** 086 * Load bean definitions from the specified resource. 087 * @param resource the resource descriptor 088 * @return the number of bean definitions found 089 * @throws BeanDefinitionStoreException in case of loading or parsing errors 090 */ 091 int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException; 092 093 /** 094 * Load bean definitions from the specified resources. 095 * @param resources the resource descriptors 096 * @return the number of bean definitions found 097 * @throws BeanDefinitionStoreException in case of loading or parsing errors 098 */ 099 int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException; 100 101 /** 102 * Load bean definitions from the specified resource location. 103 * <p>The location can also be a location pattern, provided that the 104 * ResourceLoader of this bean definition reader is a ResourcePatternResolver. 105 * @param location the resource location, to be loaded with the ResourceLoader 106 * (or ResourcePatternResolver) of this bean definition reader 107 * @return the number of bean definitions found 108 * @throws BeanDefinitionStoreException in case of loading or parsing errors 109 * @see #getResourceLoader() 110 * @see #loadBeanDefinitions(org.springframework.core.io.Resource) 111 * @see #loadBeanDefinitions(org.springframework.core.io.Resource[]) 112 */ 113 int loadBeanDefinitions(String location) throws BeanDefinitionStoreException; 114 115 /** 116 * Load bean definitions from the specified resource locations. 117 * @param locations the resource locations, to be loaded with the ResourceLoader 118 * (or ResourcePatternResolver) of this bean definition reader 119 * @return the number of bean definitions found 120 * @throws BeanDefinitionStoreException in case of loading or parsing errors 121 */ 122 int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException; 123 124}