KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > springframework > beans > factory > support > StaticListableBeanFactory


1 /*
2  * Copyright 2002-2007 the original author or authors.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.springframework.beans.factory.support;
18
19 import java.util.ArrayList JavaDoc;
20 import java.util.HashMap JavaDoc;
21 import java.util.Iterator JavaDoc;
22 import java.util.List JavaDoc;
23 import java.util.Map JavaDoc;
24 import java.util.Set JavaDoc;
25
26 import org.springframework.beans.BeansException;
27 import org.springframework.beans.factory.BeanCreationException;
28 import org.springframework.beans.factory.BeanFactoryUtils;
29 import org.springframework.beans.factory.BeanIsNotAFactoryException;
30 import org.springframework.beans.factory.BeanNotOfRequiredTypeException;
31 import org.springframework.beans.factory.FactoryBean;
32 import org.springframework.beans.factory.ListableBeanFactory;
33 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
34 import org.springframework.beans.factory.SmartFactoryBean;
35 import org.springframework.util.StringUtils;
36
37 /**
38  * Static {@link org.springframework.beans.factory.BeanFactory} implementation
39  * which allows to register existing singleton instances programmatically.
40  * Does not have support for prototype beans or aliases.
41  *
42  * <p>Serves as example for a simple implementation of the
43  * {@link org.springframework.beans.factory.ListableBeanFactory} interface,
44  * managing existing bean instances rather than creating new ones based on bean
45  * definitions, and not implementing any extended SPI interfaces (such as
46  * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}).
47  *
48  * <p>For a full-fledged factory based on bean definitions, have a look
49  * at {@link DefaultListableBeanFactory}.
50  *
51  * @author Rod Johnson
52  * @author Juergen Hoeller
53  * @since 06.01.2003
54  * @see DefaultListableBeanFactory
55  */
56 public class StaticListableBeanFactory implements ListableBeanFactory {
57
58     /** Map from bean name to bean instance */
59     private final Map JavaDoc beans = new HashMap JavaDoc();
60
61
62     /**
63      * Add a new singleton bean.
64      * Will overwrite any existing instance for the given name.
65      * @param name the name of the bean
66      * @param bean the bean instance
67      */
68     public void addBean(String JavaDoc name, Object JavaDoc bean) {
69         this.beans.put(name, bean);
70     }
71
72
73     //---------------------------------------------------------------------
74 // Implementation of BeanFactory interface
75 //---------------------------------------------------------------------
76
77     public Object JavaDoc getBean(String JavaDoc name) throws BeansException {
78         String JavaDoc beanName = BeanFactoryUtils.transformedBeanName(name);
79
80         Object JavaDoc bean = this.beans.get(beanName);
81         if (bean == null) {
82             throw new NoSuchBeanDefinitionException(beanName,
83                     "Defined beans are [" + StringUtils.collectionToCommaDelimitedString(this.beans.keySet()) + "]");
84         }
85
86         // Don't let calling code try to dereference the
87 // bean factory if the bean isn't a factory
88 if (BeanFactoryUtils.isFactoryDereference(name) && !(bean instanceof FactoryBean)) {
89             throw new BeanIsNotAFactoryException(beanName, bean.getClass());
90         }
91
92         if (bean instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
93             try {
94                 return ((FactoryBean) bean).getObject();
95             }
96             catch (Exception JavaDoc ex) {
97                 throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
98             }
99         }
100         return bean;
101     }
102     
103     public Object JavaDoc getBean(String JavaDoc name, Class JavaDoc requiredType) throws BeansException {
104         Object JavaDoc bean = getBean(name);
105         if (requiredType != null && !requiredType.isAssignableFrom(bean.getClass())) {
106             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
107         }
108         return bean;
109     }
110
111     public boolean containsBean(String JavaDoc name) {
112         return this.beans.containsKey(name);
113     }
114
115     public boolean isSingleton(String JavaDoc name) throws NoSuchBeanDefinitionException {
116         Object JavaDoc bean = getBean(name);
117         // In case of FactoryBean, return singleton status of created object.
118 return (bean instanceof FactoryBean && ((FactoryBean) bean).isSingleton());
119     }
120
121     public boolean isPrototype(String JavaDoc name) throws NoSuchBeanDefinitionException {
122         Object JavaDoc bean = getBean(name);
123         // In case of FactoryBean, return prototype status of created object.
124 return ((bean instanceof SmartFactoryBean && ((SmartFactoryBean) bean).isPrototype()) ||
125                 (bean instanceof FactoryBean && !((FactoryBean) bean).isSingleton()));
126     }
127
128     public boolean isTypeMatch(String JavaDoc name, Class JavaDoc targetType) throws NoSuchBeanDefinitionException {
129         Class JavaDoc type = getType(name);
130         return (targetType == null || (type != null && targetType.isAssignableFrom(type)));
131     }
132
133     public Class JavaDoc getType(String JavaDoc name) throws NoSuchBeanDefinitionException {
134         String JavaDoc beanName = BeanFactoryUtils.transformedBeanName(name);
135
136         Object JavaDoc bean = this.beans.get(beanName);
137         if (bean == null) {
138             throw new NoSuchBeanDefinitionException(beanName,
139                     "Defined beans are [" + StringUtils.collectionToCommaDelimitedString(this.beans.keySet()) + "]");
140         }
141
142         if (bean instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
143             // If it's a FactoryBean, we want to look at what it creates, not the factory class.
144 return ((FactoryBean) bean).getObjectType();
145         }
146         return bean.getClass();
147     }
148
149     public String JavaDoc[] getAliases(String JavaDoc name) {
150         return new String JavaDoc[0];
151     }
152
153
154     //---------------------------------------------------------------------
155 // Implementation of ListableBeanFactory interface
156 //---------------------------------------------------------------------
157
158     public boolean containsBeanDefinition(String JavaDoc name) {
159         return this.beans.containsKey(name);
160     }
161
162     public int getBeanDefinitionCount() {
163         return this.beans.size();
164     }
165
166     public String JavaDoc[] getBeanDefinitionNames() {
167         return StringUtils.toStringArray(this.beans.keySet());
168     }
169
170     public String JavaDoc[] getBeanNamesForType(Class JavaDoc type) {
171         return getBeanNamesForType(type, true, true);
172     }
173
174     public String JavaDoc[] getBeanNamesForType(Class JavaDoc type, boolean includePrototypes, boolean includeFactoryBeans) {
175         boolean isFactoryType = (type != null && FactoryBean.class.isAssignableFrom(type));
176         List JavaDoc matches = new ArrayList JavaDoc();
177         Set JavaDoc keys = this.beans.keySet();
178         Iterator JavaDoc it = keys.iterator();
179         while (it.hasNext()) {
180             String JavaDoc name = (String JavaDoc) it.next();
181             Object JavaDoc beanInstance = this.beans.get(name);
182             if (beanInstance instanceof FactoryBean && !isFactoryType) {
183                 if (includeFactoryBeans) {
184                     Class JavaDoc objectType = ((FactoryBean) beanInstance).getObjectType();
185                     if (objectType != null && type.isAssignableFrom(objectType)) {
186                         matches.add(name);
187                     }
188                 }
189             }
190             else {
191                 if (type.isInstance(beanInstance)) {
192                     matches.add(name);
193                 }
194             }
195         }
196         return StringUtils.toStringArray(matches);
197     }
198
199     public Map JavaDoc getBeansOfType(Class JavaDoc type) throws BeansException {
200         return getBeansOfType(type, true, true);
201     }
202
203     public Map JavaDoc getBeansOfType(Class JavaDoc type, boolean includePrototypes, boolean includeFactoryBeans)
204             throws BeansException {
205
206         boolean isFactoryType = (type != null && FactoryBean.class.isAssignableFrom(type));
207         Map JavaDoc matches = new HashMap JavaDoc();
208
209         Iterator JavaDoc it = this.beans.entrySet().iterator();
210         while (it.hasNext()) {
211             Map.Entry JavaDoc entry = (Map.Entry JavaDoc) it.next();
212             String JavaDoc beanName = (String JavaDoc) entry.getKey();
213             Object JavaDoc beanInstance = entry.getValue();
214
215             // Is bean a FactoryBean?
216 if (beanInstance instanceof FactoryBean && !isFactoryType) {
217                 if (includeFactoryBeans) {
218                     // Match object created by FactoryBean.
219 FactoryBean factory = (FactoryBean) beanInstance;
220                     Class JavaDoc objectType = factory.getObjectType();
221                     if ((includePrototypes || factory.isSingleton()) &&
222                             objectType != null && type.isAssignableFrom(objectType)) {
223                         matches.put(beanName, getBean(beanName));
224                     }
225                 }
226             }
227             else {
228                 if (type.isInstance(beanInstance)) {
229                     // If type to match is FactoryBean, return FactoryBean itself.
230 // Else, return bean instance.
231 if (isFactoryType) {
232                         beanName = FACTORY_BEAN_PREFIX + beanName;
233                     }
234                     matches.put(beanName, beanInstance);
235                 }
236             }
237         }
238         return matches;
239     }
240
241 }
242
Popular Tags