MentaContainer

Rev

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

Rev 120 Rev 135
Line 37... Line 37...
37
        private Set<ConstructorDependency> constructorDependencies = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
37
        private Set<ConstructorDependency> constructorDependencies = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
38
       
38
       
39
        private Set<ConstructorDependency> forConstructMethod = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
39
        private Set<ConstructorDependency> forConstructMethod = Collections.synchronizedSet(new HashSet<ConstructorDependency>());
40
       
40
       
41
        @Override
41
        @Override
42
        public Class<? extends Object> getType(String key) {
-
 
-
 
42
        public Class<? extends Object> getType(Object key) {
43
               
43
               
44
                Factory factory = factoriesByName.get(key);
-
 
-
 
44
                Factory factory = factoriesByName.get(key.toString());
45
               
45
               
46
                if (factory == null) return null;
46
                if (factory == null) return null;
47
               
47
               
48
                return factory.getType();
48
                return factory.getType();
49
        }
49
        }
Line 111... Line 111...
111
                        for(ClearableHolder cp : listToClear) cp.clear();
111
                        for(ClearableHolder cp : listToClear) cp.clear();
112
                }
112
                }
113
        }
113
        }
114
       
114
       
115
        @Override
115
        @Override
116
        public <T> T clear(String key) {
-
 
-
 
116
        public <T> T clear(Object key) {
117
               
117
               
118
                if (!factoriesByName.containsKey(key)) return null;
-
 
-
 
118
                String keyString = key.toString();
119
               
119
               
120
                Scope scope = scopes.get(key);
-
 
-
 
120
                if (!factoriesByName.containsKey(keyString)) return null;
-
 
121
               
-
 
122
                Scope scope = scopes.get(keyString);
121
               
123
               
122
                if (scope == Scope.SINGLETON) {
124
                if (scope == Scope.SINGLETON) {
123
                       
125
                       
124
                        ClearableHolder cp = null;
126
                        ClearableHolder cp = null;
125
                       
127
                       
126
                        Object value = null;
128
                        Object value = null;
127
                       
129
                       
128
                        synchronized(this) {
130
                        synchronized(this) {
129
                       
131
                       
130
                        value = singletonsCache.remove(key);
-
 
-
 
132
                        value = singletonsCache.remove(keyString);
131
                       
133
                       
132
                        if (value != null) {
134
                        if (value != null) {
133
                               
135
                               
134
                                Factory factory = factoriesByName.get(key);
-
 
-
 
136
                                Factory factory = factoriesByName.get(keyString);
135
                               
137
                               
136
                                if (factory instanceof Interceptor) {
138
                                if (factory instanceof Interceptor) {
137
                                       
139
                                       
138
                                        Interceptor c = (Interceptor) factory;
140
                                        Interceptor c = (Interceptor) factory;
139
                                       
141
                                       
Line 152... Line 154...
152
                       
154
                       
153
                        Object retVal = null;
155
                        Object retVal = null;
154
                       
156
                       
155
                        synchronized(this) {
157
                        synchronized(this) {
156
                       
158
                       
157
                        ThreadLocal<Object> t = threadLocalsCache.get(key);
-
 
-
 
159
                        ThreadLocal<Object> t = threadLocalsCache.get(keyString);
158
                       
160
                       
159
                        if (t != null) {
161
                        if (t != null) {
160
                               
162
                               
161
                                Object o = t.get();
163
                                Object o = t.get();
162
                               
164
                               
163
                                if (o != null) {
165
                                if (o != null) {
164
                                       
166
                                       
165
                                        Factory factory = factoriesByName.get(key);
-
 
-
 
167
                                        Factory factory = factoriesByName.get(keyString);
166
                                       
168
                                       
167
                                        if (factory instanceof Interceptor) {
169
                                        if (factory instanceof Interceptor) {
168
                                               
170
                                               
169
                                                Interceptor c = (Interceptor) factory;
171
                                                Interceptor c = (Interceptor) factory;
170
                                               
172
                                               
Line 191... Line 193...
191
                        throw new UnsupportedOperationException("Scope not supported: " + scope);
193
                        throw new UnsupportedOperationException("Scope not supported: " + scope);
192
                }
194
                }
193
        }
195
        }
194
196
195
        @Override
197
        @Override
196
        public <T> T get(String key) {
-
 
-
 
198
        public <T> T get(Object key) {
-
 
199
               
-
 
200
                String keyString = key.toString();
197
201
198
                if (!factoriesByName.containsKey(key)) return null;
-
 
-
 
202
                if (!factoriesByName.containsKey(keyString)) return null;
199
203
200
                Factory c = factoriesByName.get(key);
-
 
-
 
204
                Factory c = factoriesByName.get(keyString);
201
               
205
               
202
                Scope scope = scopes.get(key);
-
 
-
 
206
                Scope scope = scopes.get(keyString);
203
               
207
               
204
                Object target = null;
208
                Object target = null;
205
209
206
                try {
210
                try {
207
211
Line 209... Line 213...
209
                               
213
                               
210
                                boolean needsToCreate = false;
214
                                boolean needsToCreate = false;
211
                               
215
                               
212
                                synchronized(this) {
216
                                synchronized(this) {
213
217
214
                                if (singletonsCache.containsKey(key)) {
-
 
-
 
218
                                if (singletonsCache.containsKey(keyString)) {
215
   
219
   
216
                                        target = singletonsCache.get(key);
-
 
-
 
220
                                        target = singletonsCache.get(keyString);
217
   
221
   
218
                                        return (T) target; // no need to wire again...
222
                                        return (T) target; // no need to wire again...
219
   
223
   
220
                                } else {
224
                                } else {
221
                                       
225
                                       
Line 231... Line 235...
231
                                       
235
                                       
232
                                        checkInterceptable(c, target);
236
                                        checkInterceptable(c, target);
233
                                       
237
                                       
234
                                        synchronized(this) {
238
                                        synchronized(this) {
235
239
236
                                                singletonsCache.put(key, target);
-
 
-
 
240
                                                singletonsCache.put(keyString, target);
237
                                        }
241
                                        }
238
                                }
242
                                }
239
                               
243
                               
240
                        } else if (scope == Scope.THREAD) {
244
                        } else if (scope == Scope.THREAD) {
241
                               
245
                               
Line 245... Line 249...
245
                               
249
                               
246
                                ThreadLocal<Object> t = null;
250
                                ThreadLocal<Object> t = null;
247
                               
251
                               
248
                                synchronized(this) {
252
                                synchronized(this) {
249
                               
253
                               
250
                                if (threadLocalsCache.containsKey(key)) {
-
 
-
 
254
                                if (threadLocalsCache.containsKey(keyString)) {
251
                                       
255
                                       
252
                                        t = threadLocalsCache.get(key);
-
 
-
 
256
                                        t = threadLocalsCache.get(keyString);
253
                                       
257
                                       
254
                                        target = t.get();
258
                                        target = t.get();
255
                                       
259
                                       
256
                                        if (target == null) { // different thread...
260
                                        if (target == null) { // different thread...
257
                                               
261
                                               
Line 290... Line 294...
290
                               
294
                               
291
                                if (needsToAddToCache) {
295
                                if (needsToAddToCache) {
292
                                       
296
                                       
293
                                        synchronized(this) {
297
                                        synchronized(this) {
294
                                       
298
                                       
295
                                                threadLocalsCache.put(key, t);
-
 
-
 
299
                                                threadLocalsCache.put(keyString, t);
296
                                        }
300
                                        }
297
                                }
301
                                }
298
                               
302
                               
299
                        } else if (scope == Scope.NONE) {
303
                        } else if (scope == Scope.NONE) {
300
304
Line 316... Line 320...
316
320
317
                                        if (m != null) {
321
                                        if (m != null) {
318
322
319
                                                String sourceKey = d.getSource();
323
                                                String sourceKey = d.getSource();
320
324
321
                                                if (sourceKey.equals(key)) {
-
 
-
 
325
                                                if (sourceKey.equals(keyString)) {
322
326
323
                                                        // cannot depend on itself... also avoid recursive StackOverflow...
327
                                                        // cannot depend on itself... also avoid recursive StackOverflow...
324
328
325
                                                        continue;
329
                                                        continue;
326
330
Line 360... Line 364...
360
                        ((Interceptor) f).onCreated(value);
364
                        ((Interceptor) f).onCreated(value);
361
                }
365
                }
362
        }
366
        }
363
       
367
       
364
        @Override
368
        @Override
365
        public Factory ioc(String key, Factory factory, Scope scope) {
-
 
-
 
369
        public Factory ioc(Object key, Factory factory, Scope scope) {
366
               
370
               
367
                factoriesByName.put(key, factory);
-
 
-
 
371
                String keyString = key.toString();
368
               
372
               
369
                singletonsCache.remove(key); // just in case we are overriding a previous singleton bean...
-
 
-
 
373
                factoriesByName.put(keyString, factory);
370
               
374
               
371
                ThreadLocal<Object> threadLocal = threadLocalsCache.remove(key); // just in case we are overriding a previous thread local...
-
 
-
 
375
                singletonsCache.remove(keyString); // just in case we are overriding a previous singleton bean...
-
 
376
               
-
 
377
                ThreadLocal<Object> threadLocal = threadLocalsCache.remove(keyString); // just in case we are overriding a previous thread local...
372
                if (threadLocal != null) {
378
                if (threadLocal != null) {
373
                        threadLocal.remove();
379
                        threadLocal.remove();
374
                }
380
                }
375
               
381
               
376
                scopes.put(key, scope);
-
 
-
 
382
                scopes.put(keyString, scope);
377
               
383
               
378
                forConstructMethod.add(new ConstructorDependency(key, factory.getType()));
-
 
-
 
384
                forConstructMethod.add(new ConstructorDependency(keyString, factory.getType()));
379
               
385
               
380
                return factory;
386
                return factory;
381
        }
387
        }
382
       
388
       
383
        @Override
389
        @Override
384
        public Factory ioc(String key, Factory factory) {
-
 
-
 
390
        public Factory ioc(Object key, Factory factory) {
385
               
391
               
386
                return ioc(key, factory, Scope.NONE);
392
                return ioc(key, factory, Scope.NONE);
387
        }
393
        }
388
       
394
       
389
        @Override
395
        @Override
390
        public ConfigurableFactory ioc(String key, Class<? extends Object> klass) {
-
 
-
 
396
        public ConfigurableFactory ioc(Object key, Class<? extends Object> klass) {
391
               
397
               
392
                ConfigurableFactory cc = new ClassFactory(this, klass);
398
                ConfigurableFactory cc = new ClassFactory(this, klass);
393
               
399
               
394
                ioc(key, cc);
400
                ioc(key, cc);
395
               
401
               
396
                return cc;
402
                return cc;
397
        }
403
        }
398
       
404
       
399
        @Override
405
        @Override
400
        public ConfigurableFactory ioc(String key, Class<? extends Object> klass, Scope scope) {
-
 
-
 
406
        public ConfigurableFactory ioc(Object key, Class<? extends Object> klass, Scope scope) {
401
               
407
               
402
                ConfigurableFactory cc = new ClassFactory(this, klass);
408
                ConfigurableFactory cc = new ClassFactory(this, klass);
403
               
409
               
404
                ioc(key, cc, scope);
410
                ioc(key, cc, scope);
405
               
411
               
406
                return cc;
412
                return cc;
407
        }
413
        }
408
       
414
       
409
        @Override
415
        @Override
410
        public void autowire(String sourceFromContainer) {
-
 
-
 
416
        public void autowire(Object sourceFromContainer) {
411
               
417
               
412
                // autowire by constructor and setter...
418
                // autowire by constructor and setter...
413
               
419
               
414
                autowireBySetter(sourceFromContainer);
-
 
-
 
420
                String s = sourceFromContainer.toString();
415
               
421
               
416
                autowireByConstructor(sourceFromContainer);
-
 
-
 
422
                autowireBySetter(s);
-
 
423
               
-
 
424
                autowireByConstructor(s);
417
        }
425
        }
418
       
426
       
419
        @Override
427
        @Override
420
        public void autowire(String sourceFromContainer, String beanProperty) {
-
 
-
 
428
        public void autowire(Object sourceFromContainer, String beanProperty) {
421
               
429
               
422
                // autowire by constructor and setter...
430
                // autowire by constructor and setter...
423
               
431
               
424
                autowireBySetter(beanProperty, sourceFromContainer);
-
 
-
 
432
                String s = sourceFromContainer.toString();
-
 
433
               
-
 
434
                autowireBySetter(beanProperty, s);
425
               
435
               
426
                autowireByConstructor(sourceFromContainer);
-
 
-
 
436
                autowireByConstructor(s);
427
        }
437
        }
428
438
429
        private void autowireBySetter(String targetProperty, String sourceFromContainer) {
439
        private void autowireBySetter(String targetProperty, String sourceFromContainer) {
430
               
440
               
431
                Class<? extends Object> sourceType = getType(sourceFromContainer);
441
                Class<? extends Object> sourceType = getType(sourceFromContainer);
Line 490... Line 500...
490
                        throw new RuntimeException("Error populating bean: " + bean, e);
500
                        throw new RuntimeException("Error populating bean: " + bean, e);
491
                }
501
                }
492
        }
502
        }
493
503
494
        @Override
504
        @Override
495
        public synchronized boolean check(String key) {
-
 
-
 
505
        public synchronized boolean check(Object key) {
-
 
506
               
-
 
507
                String keyString = key.toString();
496
               
508
               
497
                if (!factoriesByName.containsKey(key)) return false;
-
 
-
 
509
                if (!factoriesByName.containsKey(keyString)) return false;
498
               
510
               
499
                Scope scope = scopes.get(key);
-
 
-
 
511
                Scope scope = scopes.get(keyString);
500
               
512
               
501
                if (scope == Scope.NONE) {
513
                if (scope == Scope.NONE) {
502
                       
514
                       
503
                        return false; // always...
515
                        return false; // always...
504
                       
516
                       
505
                } else if (scope == Scope.SINGLETON) {
517
                } else if (scope == Scope.SINGLETON) {
506
                       
518
                       
507
                        return singletonsCache.containsKey(key);
-
 
-
 
519
                        return singletonsCache.containsKey(keyString);
508
                       
520
                       
509
                } else if (scope == Scope.THREAD) {
521
                } else if (scope == Scope.THREAD) {
510
                       
522
                       
511
                        ThreadLocal<Object> t = threadLocalsCache.get(key);
-
 
-
 
523
                        ThreadLocal<Object> t = threadLocalsCache.get(keyString);
512
                       
524
                       
513
                        if (t != null) return t.get() != null;
525
                        if (t != null) return t.get() != null;
514
                       
526
                       
515
                        return false;
527
                        return false;
516
                       
528