MentaContainer

Rev

Rev 141 | Rev 143 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 141 Rev 142
Line 10... Line 10...
10
import java.util.Set;
10
import java.util.Set;
11
11
12
import org.mentacontainer.ConfigurableFactory;
12
import org.mentacontainer.ConfigurableFactory;
13
import org.mentacontainer.Container;
13
import org.mentacontainer.Container;
14
import org.mentacontainer.Creator;
14
import org.mentacontainer.Creator;
15
import org.mentacontainer.Interceptor;
-
 
16
import org.mentacontainer.Pool;
15
import org.mentacontainer.Pool;
17
import org.mentacontainer.Scope;
16
import org.mentacontainer.Scope;
18
import org.mentacontainer.util.InjectionUtils;
17
import org.mentacontainer.util.InjectionUtils;
19
import org.mentacontainer.util.InjectionUtils.Provider;
18
import org.mentacontainer.util.InjectionUtils.Provider;
20
19
Line 38... Line 37...
38
        private Set<ConstructorDependency> constructorDependencies = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
37
        private Set<ConstructorDependency> constructorDependencies = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
39
       
38
       
40
        private Set<ConstructorDependency> forConstructMethod = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
39
        private Set<ConstructorDependency> forConstructMethod = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
41
       
40
       
42
        @Override
41
        @Override
43
        public Class<? extends Object> getType(Object key) {
-
 
-
 
42
        public Class<?> getType(Object key) {
44
               
43
               
45
                String k = InjectionUtils.getKeyName(key);
44
                String k = InjectionUtils.getKeyName(key);
46
               
45
               
47
                Creator<?> factory = factoriesByName.get(k);
46
                Creator<?> factory = factoriesByName.get(k);
48
               
47
               
Line 213... Line 212...
213
                                if (needsToCreate) {
212
                                if (needsToCreate) {
214
                                       
213
                                       
215
                                        // getInstance needs to be in a non-synchronized block
214
                                        // getInstance needs to be in a non-synchronized block
216
                                       
215
                                       
217
                                        target = c.createInstance();
216
                                        target = c.createInstance();
218
                                       
-
 
219
                                        checkInterceptable(c, target);
-
 
220
                                       
217
                                       
221
                                        synchronized(this) {
218
                                        synchronized(this) {
222
219
223
                                                singletonsCache.put(keyString, target);
220
                                                singletonsCache.put(keyString, target);
224
                                        }
221
                                        }
Line 267... Line 264...
267
                                if (needsToCreate) {
264
                                if (needsToCreate) {
268
                                       
265
                                       
269
                                        // getInstance needs to be in a non-synchronized block
266
                                        // getInstance needs to be in a non-synchronized block
270
                                       
267
                                       
271
                                        target = c.createInstance();
268
                                        target = c.createInstance();
272
                                       
-
 
273
                                        checkInterceptable(c, target);
-
 
274
                                       
269
                                       
275
                                        t.set(target);
270
                                        t.set(target);
276
                                }
271
                                }
277
                               
272
                               
278
                                if (needsToAddToCache) {
273
                                if (needsToAddToCache) {
Line 284... Line 279...
284
                                }
279
                                }
285
                               
280
                               
286
                        } else if (scope == Scope.NONE) {
281
                        } else if (scope == Scope.NONE) {
287
282
288
                                target = c.createInstance();
283
                                target = c.createInstance();
289
                               
-
 
290
                                checkInterceptable(c, target);
-
 
291
                               
284
                               
292
                        } else {
285
                        } else {
293
                               
286
                               
294
                                throw new UnsupportedOperationException("Don't know how to handle scope: " + scope);
287
                                throw new UnsupportedOperationException("Don't know how to handle scope: " + scope);
295
                        }
288
                        }
Line 333... Line 326...
333
                        return (T) target; // return target nicely with all the dependencies
326
                        return (T) target; // return target nicely with all the dependencies
334
327
335
                } catch (Exception e) {
328
                } catch (Exception e) {
336
329
337
                        throw new RuntimeException(e);
330
                        throw new RuntimeException(e);
338
                }
-
 
339
        }
-
 
340
       
-
 
341
        private final void checkInterceptable(Creator<?> f, Object value) {
-
 
342
               
-
 
343
                if (f instanceof Interceptor) {
-
 
344
                       
-
 
345
                        Interceptor i = (Interceptor) f;
-
 
346
                       
-
 
347
                        ((Interceptor) f).onCreated(value);
-
 
348
                }
331
                }
349
        }
332
        }
350
       
333
       
351
        private static <T> Pool<T> fromFactory(final Creator<T> creator) {
334
        private static <T> Pool<T> fromFactory(final Creator<T> creator) {
352
               
335
               
Line 369... Line 352...
369
                };
352
                };
370
        }
353
        }
371
       
354
       
372
        @Override
355
        @Override
373
        public <T> Creator<T> ioc(Object key, Creator<T> factory, Scope scope) {
356
        public <T> Creator<T> ioc(Object key, Creator<T> factory, Scope scope) {
-
 
357
                return ioc(key, fromFactory(factory), scope);
-
 
358
        }
-
 
359
       
-
 
360
        @Override
-
 
361
        public <T> Pool<T> ioc(Object key, Pool<T> factory, Scope scope) {
374
               
362
               
375
                String keyString = InjectionUtils.getKeyName(key);
363
                String keyString = InjectionUtils.getKeyName(key);
376
               
364
               
377
                factoriesByName.put(keyString, fromFactory(factory));
-
 
-
 
365
                factoriesByName.put(keyString, factory);
378
               
366
               
379
                singletonsCache.remove(keyString); // just in case we are overriding a previous singleton bean...
367
                singletonsCache.remove(keyString); // just in case we are overriding a previous singleton bean...
380
               
368
               
381
                ThreadLocal<Object> threadLocal = threadLocalsCache.remove(keyString); // just in case we are overriding a previous thread local...
369
                ThreadLocal<Object> threadLocal = threadLocalsCache.remove(keyString); // just in case we are overriding a previous thread local...
382
                if (threadLocal != null) {
370
                if (threadLocal != null) {
Line 389... Line 377...
389
               
377
               
390
                return factory;
378
                return factory;
391
        }
379
        }
392
       
380
       
393
        @Override
381
        @Override
394
        public Creator<?> ioc(Object key, Creator<?> factory) {
-
 
-
 
382
        public <T> Creator<T> ioc(Object key, Creator<T> factory) {
-
 
383
               
-
 
384
                return ioc(key, fromFactory(factory));
-
 
385
        }
-
 
386
       
-
 
387
        @Override
-
 
388
        public <T> Pool<T> ioc(Object key, Pool<T> pool) {
395
               
389
               
396
                return ioc(key, factory, Scope.NONE);
-
 
-
 
390
                return ioc(key, pool, Scope.NONE);
397
        }
391
        }
398
       
392
       
399
        @Override
393
        @Override
400
        public <T> ConfigurableFactory<T> ioc(Object key, Class<T> klass) {
394
        public <T> ConfigurableFactory<T> ioc(Object key, Class<T> klass) {
401
               
395