Coverage Report

Coverage Report - org.kuali.rice.test.CompositeBeanFactory

Classes in this File

Line Coverage

Branch Coverage

Complexity

CompositeBeanFactory

0/92

0/50

4.917

 /**
  * Copyright 2005-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.test;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.kuali.rice.core.impl.resourceloader.SpringResourceLoader;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 
 import java.util.ArrayList;
 import java.util.Collection;
 
 /** 
  * Wraps a collection of bean factories delegating to the inner bean factories.
  * 
  * The first bean factory that returns a non-null/true result is the value that is returned/
  */
 public final class CompositeBeanFactory implements BeanFactory {
 
         private static final Log LOG = LogFactory.getLog(CompositeBeanFactory.class);
         
         private final Collection<BeanFactory> factories;
         
         public static BeanFactory createBeanFactory(Collection<? extends SpringResourceLoader> rls) {
                 if (rls == null || rls.isEmpty()) {
                         throw new IllegalArgumentException("rls is null or empty");
                 }
                 
                 final Collection<BeanFactory> bfs = new ArrayList<BeanFactory>();
                 for (SpringResourceLoader rl : rls) {
                         bfs.add(rl.getContext());
                 }
                 return new CompositeBeanFactory(bfs);
         }
         
         public CompositeBeanFactory(Collection<? extends BeanFactory> factories) {
                 if (factories == null || factories.isEmpty()) {
                         throw new IllegalArgumentException("factories is null or empty");
                 }
                 
                 this.factories = new ArrayList<BeanFactory>(factories);
         }
 
         @Override
         public Object getBean(String name) throws BeansException {
                 for (BeanFactory f : factories) {
                         try {
                                 Object o = f.getBean(name);
                                 if (o != null) {
                                         return o;
                                 }        
                         } catch (BeansException e) {
                                 LOG.debug("bean exception", e);
                         }
                 }
                 return null;
         }
 
         @Override
         public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
                 for (BeanFactory f : factories) {
                         try {
                                 T t = f.getBean(name, requiredType);
                                 if (t != null) {
                                         return t;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return null;
         }
 
         @Override
         public <T> T getBean(Class<T> requiredType) throws BeansException {
                 for (BeanFactory f : factories) {
                         try {
                                 T t = f.getBean(requiredType);
                                 if (t != null) {
                                         return t;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return null;
         }
 
         @Override
         public Object getBean(String name, Object... args) throws BeansException {
                 for (BeanFactory f : factories) {
                         try {
                                 Object o = f.getBean(name, args);
                                 if (o != null) {
                                         return o;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return null;
         }
 
         @Override
         public boolean containsBean(String name) {
                 for (BeanFactory f : factories) {
                         try {
                                 boolean b = f.containsBean(name);
                                 if (b) {
                                         return b;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return false;
         }
 
         @Override
         public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
                 for (BeanFactory f : factories) {
                         try {
                                 boolean b = f.isSingleton(name);
                                 if (b) {
                                         return b;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return false;
         }
 
         @Override
         public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {
                 for (BeanFactory f : factories) {
                         try {
                                 boolean b = f.isPrototype(name);
                                 if (b) {
                                         return b;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return false;
         }
 
         @Override
         public boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException {
                 for (BeanFactory f : factories) {
                         try {
                                 boolean b = f.isTypeMatch(name, targetType);
                                 if (b) {
                                         return b;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return false;
         }
 
         @Override
         public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
                 for (BeanFactory f : factories) {
                         try {
                                 Class<?> c = f.getType(name);
                                 if (c != null) {
                                         return c;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return null;
         }
 
         @Override
         public String[] getAliases(String name) {
                 for (BeanFactory f : factories) {
                         try {
                                 String[] s = f.getAliases(name);
                                 if (s != null) {
                                         return s;
                                 }        
                         } catch (BeansException e) {
                                 LOG.info("bean exception", e);
                         }
                 }
                 return null;
         }
 }

1		/**
2		* Copyright 2005-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
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		package org.kuali.rice.test;
17
18		import org.apache.commons.logging.Log;
19		import org.apache.commons.logging.LogFactory;
20		import org.kuali.rice.core.impl.resourceloader.SpringResourceLoader;
21		import org.springframework.beans.BeansException;
22		import org.springframework.beans.factory.BeanFactory;
23		import org.springframework.beans.factory.NoSuchBeanDefinitionException;
24
25		import java.util.ArrayList;
26		import java.util.Collection;
27
28		/**
29		* Wraps a collection of bean factories delegating to the inner bean factories.
30		*
31		* The first bean factory that returns a non-null/true result is the value that is returned/
32		*/
33		public final class CompositeBeanFactory implements BeanFactory {
34
35	0	private static final Log LOG = LogFactory.getLog(CompositeBeanFactory.class);
36
37		private final Collection<BeanFactory> factories;
38
39		public static BeanFactory createBeanFactory(Collection<? extends SpringResourceLoader> rls) {
40	0	if (rls == null \|\| rls.isEmpty()) {
41	0	throw new IllegalArgumentException("rls is null or empty");
42		}
43
44	0	final Collection<BeanFactory> bfs = new ArrayList<BeanFactory>();
45	0	for (SpringResourceLoader rl : rls) {
46	0	bfs.add(rl.getContext());
47		}
48	0	return new CompositeBeanFactory(bfs);
49		}
50
51	0	public CompositeBeanFactory(Collection<? extends BeanFactory> factories) {
52	0	if (factories == null \|\| factories.isEmpty()) {
53	0	throw new IllegalArgumentException("factories is null or empty");
54		}
55
56	0	this.factories = new ArrayList<BeanFactory>(factories);
57	0	}
58
59		@Override
60		public Object getBean(String name) throws BeansException {
61	0	for (BeanFactory f : factories) {
62		try {
63	0	Object o = f.getBean(name);
64	0	if (o != null) {
65	0	return o;
66		}
67	0	} catch (BeansException e) {
68	0	LOG.debug("bean exception", e);
69	0	}
70		}
71	0	return null;
72		}
73
74		@Override
75		public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
76	0	for (BeanFactory f : factories) {
77		try {
78	0	T t = f.getBean(name, requiredType);
79	0	if (t != null) {
80	0	return t;
81		}
82	0	} catch (BeansException e) {
83	0	LOG.info("bean exception", e);
84	0	}
85		}
86	0	return null;
87		}
88
89		@Override
90		public <T> T getBean(Class<T> requiredType) throws BeansException {
91	0	for (BeanFactory f : factories) {
92		try {
93	0	T t = f.getBean(requiredType);
94	0	if (t != null) {
95	0	return t;
96		}
97	0	} catch (BeansException e) {
98	0	LOG.info("bean exception", e);
99	0	}
100		}
101	0	return null;
102		}
103
104		@Override
105		public Object getBean(String name, Object... args) throws BeansException {
106	0	for (BeanFactory f : factories) {
107		try {
108	0	Object o = f.getBean(name, args);
109	0	if (o != null) {
110	0	return o;
111		}
112	0	} catch (BeansException e) {
113	0	LOG.info("bean exception", e);
114	0	}
115		}
116	0	return null;
117		}
118
119		@Override
120		public boolean containsBean(String name) {
121	0	for (BeanFactory f : factories) {
122		try {
123	0	boolean b = f.containsBean(name);
124	0	if (b) {
125	0	return b;
126		}
127	0	} catch (BeansException e) {
128	0	LOG.info("bean exception", e);
129	0	}
130		}
131	0	return false;
132		}
133
134		@Override
135		public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
136	0	for (BeanFactory f : factories) {
137		try {
138	0	boolean b = f.isSingleton(name);
139	0	if (b) {
140	0	return b;
141		}
142	0	} catch (BeansException e) {
143	0	LOG.info("bean exception", e);
144	0	}
145		}
146	0	return false;
147		}
148
149		@Override
150		public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {
151	0	for (BeanFactory f : factories) {
152		try {
153	0	boolean b = f.isPrototype(name);
154	0	if (b) {
155	0	return b;
156		}
157	0	} catch (BeansException e) {
158	0	LOG.info("bean exception", e);
159	0	}
160		}
161	0	return false;
162		}
163
164		@Override
165		public boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException {
166	0	for (BeanFactory f : factories) {
167		try {
168	0	boolean b = f.isTypeMatch(name, targetType);
169	0	if (b) {
170	0	return b;
171		}
172	0	} catch (BeansException e) {
173	0	LOG.info("bean exception", e);
174	0	}
175		}
176	0	return false;
177		}
178
179		@Override
180		public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
181	0	for (BeanFactory f : factories) {
182		try {
183	0	Class<?> c = f.getType(name);
184	0	if (c != null) {
185	0	return c;
186		}
187	0	} catch (BeansException e) {
188	0	LOG.info("bean exception", e);
189	0	}
190		}
191	0	return null;
192		}
193
194		@Override
195		public String[] getAliases(String name) {
196	0	for (BeanFactory f : factories) {
197		try {
198	0	String[] s = f.getAliases(name);
199	0	if (s != null) {
200	0	return s;
201		}
202	0	} catch (BeansException e) {
203	0	LOG.info("bean exception", e);
204	0	}
205		}
206	0	return null;
207		}
208		}