1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.common.util.spring.service;
17
18 import static java.lang.Thread.currentThread;
19 import static org.apache.commons.lang3.StringUtils.leftPad;
20
21 import java.io.File;
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.Collections;
25 import java.util.List;
26 import java.util.Map;
27
28 import org.apache.commons.lang3.StringUtils;
29 import org.kuali.common.util.Assert;
30 import org.kuali.common.util.CollectionUtils;
31 import org.kuali.common.util.LocationUtils;
32 import org.kuali.common.util.spring.PropertySourceUtils;
33 import org.kuali.common.util.spring.SpringUtils;
34 import org.slf4j.Logger;
35 import org.slf4j.LoggerFactory;
36 import org.springframework.context.ConfigurableApplicationContext;
37 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
38 import org.springframework.context.support.AbstractApplicationContext;
39 import org.springframework.context.support.ClassPathXmlApplicationContext;
40 import org.springframework.core.env.ConfigurableEnvironment;
41 import org.springframework.core.env.MutablePropertySources;
42 import org.springframework.core.env.PropertySource;
43
44
45
46
47 public class DefaultSpringService implements SpringService {
48
49 private static final Logger logger = LoggerFactory.getLogger(DefaultSpringService.class);
50
51 @Override
52 public void load(Class<?> annotatedClass, Map<String, Object> contextBeans) {
53 load(annotatedClass, contextBeans, null);
54 }
55
56 @Override
57 public void load(Class<?> annotatedClass, Map<String, Object> contextBeans, PropertySource<?> propertySource) {
58
59 Assert.notNull(annotatedClass, "annotatedClass is null");
60
61
62 SpringContext context = new SpringContext();
63 context.setAnnotatedClasses(CollectionUtils.asList(annotatedClass));
64 context.setPropertySourceContext(new PropertySourceContext(PropertySourceUtils.asList(propertySource)));
65
66
67 context.setContextBeans(CollectionUtils.toEmptyMap(contextBeans));
68
69
70 load(context);
71 }
72
73 @Override
74 public void load(String location, Map<String, Object> contextBeans) {
75 load(location, contextBeans, null);
76 }
77
78 @SuppressWarnings("deprecation")
79 protected Map<String, Object> getContextBeans(SpringContext context) {
80
81 Map<String, Object> contextBeans = CollectionUtils.toModifiableEmptyMap(context.getContextBeans());
82 CollectionUtils.combine(contextBeans, context.getBeanNames(), context.getBeans());
83 return contextBeans;
84 }
85
86 protected AbstractApplicationContext getXmlChild(String[] locationsArray, AbstractApplicationContext parent, SpringContext context) {
87 ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(locationsArray, false, parent);
88 if (parent == null) {
89 addMetaInfo(ctx, context);
90 }
91 return ctx;
92 }
93
94 @Override
95 public ConfigurableApplicationContext getApplicationContext(SpringContext context) {
96
97 context.setContextBeans(getContextBeans(context));
98 context.setAnnotatedClasses(CollectionUtils.toEmptyList(context.getAnnotatedClasses()));
99 context.setLocations(CollectionUtils.toEmptyList(context.getLocations()));
100 context.setActiveProfiles(CollectionUtils.toEmptyList(context.getActiveProfiles()));
101 context.setDefaultProfiles(CollectionUtils.toEmptyList(context.getDefaultProfiles()));
102
103
104 boolean empty = CollectionUtils.isEmpty(context.getLocations()) && CollectionUtils.isEmpty(context.getAnnotatedClasses());
105 Assert.isFalse(empty, "Both locations and annotatedClasses are empty");
106
107
108 LocationUtils.validateExists(context.getLocations());
109
110
111 List<String> convertedLocations = getConvertedLocations(context.getLocations());
112
113
114 String[] locationsArray = CollectionUtils.toStringArray(convertedLocations);
115
116 AbstractApplicationContext parent = null;
117
118
119 if (!CollectionUtils.isEmpty(context.getContextBeans())) {
120 parent = SpringUtils.getContextWithPreRegisteredBeans(context.getId(), context.getDisplayName(), context.getContextBeans());
121 }
122
123 AbstractApplicationContext child = null;
124 if (!CollectionUtils.isEmpty(context.getAnnotatedClasses())) {
125 child = getAnnotationContext(context, parent);
126 } else if (!CollectionUtils.isEmpty(context.getLocations())) {
127 child = getXmlChild(locationsArray, parent, context);
128 } else {
129 throw new IllegalStateException("Must provide either annotated classes or locations");
130 }
131
132
133 addPropertySources(context, child);
134
135
136 setDefaultProfiles(child, context.getDefaultProfiles());
137
138
139 setActiveProfiles(child, context.getActiveProfiles());
140
141
142 return child;
143 }
144
145 @Override
146 public void load(SpringContext context) {
147 ConfigurableApplicationContext ctx = getApplicationContext(context);
148 try {
149 String id = leftPad(currentThread().getId() + "", 2);
150 String name = currentThread().getName();
151 logger.debug("id: " + id + " name: " + name + " ctx=" + ctx.getClass().getSimpleName() + "@" + Integer.toHexString(ctx.hashCode()));
152 ctx.refresh();
153 SpringUtils.debugQuietly(ctx);
154 } finally {
155 SpringUtils.closeQuietly(ctx);
156 }
157 }
158
159 @Override
160 public void load(String location, Map<String, Object> contextBeans, PropertySource<?> propertySource) {
161
162 Assert.hasText(location, "location is null");
163
164
165 SpringContext context = new SpringContext();
166 context.setLocations(Arrays.asList(location));
167 context.setPropertySourceContext(new PropertySourceContext(PropertySourceUtils.asList(propertySource)));
168
169
170 context.setContextBeans(CollectionUtils.toEmptyMap(contextBeans));
171
172
173 load(context);
174 }
175
176 @Override
177 public void load(Class<?> annotatedClass) {
178 load(annotatedClass, (String) null, (Object) null);
179 }
180
181 @Override
182 public void load(String location) {
183 load(location, (String) null, (Object) null);
184 }
185
186
187
188
189 protected void addMetaInfo(AnnotationConfigApplicationContext ctx, SpringContext sc) {
190 if (!StringUtils.isBlank(sc.getId())) {
191 ctx.setId(sc.getId());
192 }
193 if (!StringUtils.isBlank(sc.getDisplayName())) {
194 ctx.setDisplayName(sc.getDisplayName());
195 }
196 }
197
198
199
200
201 protected void addMetaInfo(ClassPathXmlApplicationContext ctx, SpringContext sc) {
202 if (!StringUtils.isBlank(sc.getId())) {
203 ctx.setId(sc.getId());
204 }
205 if (!StringUtils.isBlank(sc.getDisplayName())) {
206 ctx.setDisplayName(sc.getDisplayName());
207 }
208 }
209
210 protected AbstractApplicationContext getAnnotationContext(SpringContext context, ConfigurableApplicationContext parent) {
211 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
212 if (parent != null) {
213 ctx.setParent(parent);
214 } else {
215 addMetaInfo(ctx, context);
216 }
217 for (Class<?> annotatedClass : context.getAnnotatedClasses()) {
218 ctx.register(annotatedClass);
219 }
220 return ctx;
221 }
222
223 protected void setActiveProfiles(ConfigurableApplicationContext applicationContext, List<String> activeProfiles) {
224 if (!CollectionUtils.isEmpty(activeProfiles)) {
225 ConfigurableEnvironment env = applicationContext.getEnvironment();
226 env.setActiveProfiles(CollectionUtils.toStringArray(activeProfiles));
227 }
228 }
229
230 protected void setDefaultProfiles(ConfigurableApplicationContext applicationContext, List<String> defaultProfiles) {
231 if (!CollectionUtils.isEmpty(defaultProfiles)) {
232 ConfigurableEnvironment env = applicationContext.getEnvironment();
233 env.setDefaultProfiles(CollectionUtils.toStringArray(defaultProfiles));
234 }
235 }
236
237 protected void addPropertySources(SpringContext context, ConfigurableApplicationContext applicationContext) {
238 PropertySourceContext psc = context.getPropertySourceContext();
239 if (psc == null) {
240 return;
241 }
242 ConfigurableEnvironment env = applicationContext.getEnvironment();
243 if (psc.isRemoveExistingSources()) {
244 logger.debug("Removing all existing property sources");
245 PropertySourceUtils.removeAllPropertySources(env);
246 }
247
248 if (CollectionUtils.isEmpty(psc.getSources())) {
249 return;
250 }
251 List<PropertySource<?>> propertySources = psc.getSources();
252 MutablePropertySources sources = env.getPropertySources();
253 if (psc.isLastOneInWins()) {
254 Collections.reverse(propertySources);
255 }
256 PropertySourceAddPriority priority = psc.getPriority();
257 for (PropertySource<?> propertySource : propertySources) {
258 Object[] args = { propertySource.getName(), propertySource.getClass().getName(), priority };
259 logger.debug("Adding property source - [{}] -> [{}] Priority=[{}]", args);
260 switch (priority) {
261 case FIRST:
262 sources.addFirst(propertySource);
263 break;
264 case LAST:
265 sources.addLast(propertySource);
266 break;
267 default:
268 throw new IllegalStateException(priority + " is an unknown priority");
269 }
270 }
271 }
272
273
274
275
276 protected List<String> getConvertedLocations(List<String> locations) {
277 List<String> converted = new ArrayList<String>();
278 for (String location : locations) {
279 if (LocationUtils.isExistingFile(location)) {
280 File file = new File(location);
281
282 String url = LocationUtils.getCanonicalURLString(file);
283 converted.add(url);
284 } else {
285 converted.add(location);
286 }
287 }
288 return converted;
289 }
290
291 @Deprecated
292 @Override
293 public void load(Class<?> annotatedClass, String beanName, Object bean, PropertySource<?> propertySource) {
294 load(annotatedClass, CollectionUtils.toEmptyMap(beanName, bean), propertySource);
295 }
296
297 @Deprecated
298 @Override
299 public void load(Class<?> annotatedClass, String beanName, Object bean) {
300 load(annotatedClass, beanName, bean, null);
301 }
302
303 @Deprecated
304 @Override
305 public void load(String location, String beanName, Object bean, PropertySource<?> propertySource) {
306 load(location, CollectionUtils.toEmptyMap(beanName, bean), propertySource);
307 }
308
309 @Deprecated
310 @Override
311 public void load(String location, String beanName, Object bean) {
312 load(location, beanName, bean, null);
313 }
314
315 }