MentaContainer

Rev

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

Rev 51 Rev 57
Line 8... Line 8...
8
8
9
import org.mentacontainer.Component;
9
import org.mentacontainer.Component;
10
import org.mentacontainer.ConfigurableComponent;
10
import org.mentacontainer.ConfigurableComponent;
11
import org.mentacontainer.Container;
11
import org.mentacontainer.Container;
12
import org.mentacontainer.Dependency;
12
import org.mentacontainer.Dependency;
-
 
13
import org.mentacontainer.Scope;
13
import org.mentacontainer.util.InjectionUtils;
14
import org.mentacontainer.util.InjectionUtils;
14
import org.mentacontainer.util.InjectionUtils.Provider;
15
import org.mentacontainer.util.InjectionUtils.Provider;
15
16
16
/**
17
/**
17
 * The implementation of the IoC container.
18
 * The implementation of the IoC container.
Line 20... Line 21...
20
 */
21
 */
21
public class MentaContainer implements Container {
22
public class MentaContainer implements Container {
22
23
23
        private Map<String, Component> beans = new HashMap<String, Component>();
24
        private Map<String, Component> beans = new HashMap<String, Component>();
24
       
25
       
25
        private Set<String> singletons = new HashSet<String>();
-
 
-
 
26
        private Map<String, Scope> scopes = new HashMap<String, Scope>();
26
       
27
       
27
        private Map<String, Object> singletonsCache = new HashMap<String, Object>();
28
        private Map<String, Object> singletonsCache = new HashMap<String, Object>();
-
 
29
       
-
 
30
        private Map<String, ThreadLocal<Object>> threadLocalsCache = new HashMap<String, ThreadLocal<Object>>();
28
31
29
        private Set<Dependency> dependencies = new HashSet<Dependency>();
32
        private Set<Dependency> dependencies = new HashSet<Dependency>();
-
 
33
       
-
 
34
        public void clear(Scope scope) {
-
 
35
               
-
 
36
                if (scope == Scope.SINGLETON) {
-
 
37
                       
-
 
38
                        singletonsCache.clear();
-
 
39
                       
-
 
40
                } else if (scope == Scope.THREAD) {
-
 
41
                       
-
 
42
                        for(ThreadLocal<Object> t : threadLocalsCache.values()) {
-
 
43
                               
-
 
44
                                t.set(null);
-
 
45
                        }
-
 
46
                }
-
 
47
        }
30
48
31
        public <T> T get(String key) {
49
        public <T> T get(String key) {
32
50
33
                if (!beans.containsKey(key)) return null;
51
                if (!beans.containsKey(key)) return null;
34
52
35
                Component c = beans.get(key);
53
                Component c = beans.get(key);
36
               
54
               
37
                boolean isSingleton = singletons.contains(key);
-
 
38
-
 
-
 
55
                Scope scope = scopes.get(key);
-
 
56
               
39
                Object target = null;
57
                Object target = null;
40
58
41
                try {
59
                try {
42
60
43
                        if (isSingleton) {
-
 
-
 
61
                        if (scope == Scope.SINGLETON) {
44
62
45
                                if (singletonsCache.containsKey(key)) {
63
                                if (singletonsCache.containsKey(key)) {
46
64
47
                                        target = singletonsCache.get(key);
65
                                        target = singletonsCache.get(key);
48
66
49
                                        return (T) target;
-
 
-
 
67
                                        return (T) target; // no need to wire again...
50
68
51
                                } else {
69
                                } else {
52
70
53
                                        target = c.getInstance();
71
                                        target = c.getInstance();
54
72
55
                                        singletonsCache.put(key, target);
73
                                        singletonsCache.put(key, target);
56
                                }
74
                                }
57
-
 
58
                        } else {
-
 
-
 
75
                               
-
 
76
                        } else if (scope == Scope.THREAD) {
-
 
77
                               
-
 
78
                                if (threadLocalsCache.containsKey(key)) {
-
 
79
                                       
-
 
80
                                        ThreadLocal<Object> t = threadLocalsCache.get(key);
-
 
81
                                       
-
 
82
                                        target = t.get();
-
 
83
                                       
-
 
84
                                        if (target == null) { // different thread...
-
 
85
                                               
-
 
86
                                                target = c.getInstance();
-
 
87
                                               
-
 
88
                                                t.set(target);
-
 
89
                                               
-
 
90
                                                // don't return... let it be wired...
-
 
91
                                               
-
 
92
                                        } else {
-
 
93
                                       
-
 
94
                                                return (T) target; // no need to wire again...
-
 
95
                                               
-
 
96
                                        }
-
 
97
                                       
-
 
98
                                } else {
-
 
99
                                       
-
 
100
                                        ThreadLocal<Object> t = new ThreadLocal<Object>();
-
 
101
                                       
-
 
102
                                        target = c.getInstance();
-
 
103
                                       
-
 
104
                                        t.set(target);
-
 
105
                                       
-
 
106
                                        threadLocalsCache.put(key, t);
-
 
107
                                       
-
 
108
                                        // let it be wired...
-
 
109
                                }
-
 
110
                               
-
 
111
                        } else if (scope == Scope.NONE) {
59
112
60
                                target = c.getInstance();
113
                                target = c.getInstance();
61
114
-
 
115
                               
-
 
116
                        } else {
-
 
117
                               
-
 
118
                                throw new UnsupportedOperationException("Don't know how to handle scope: " + scope);
62
                        }
119
                        }
63
120
64
                        if (target != null) {
121
                        if (target != null) {
65
122
66
                                for (Dependency d : dependencies) {
123
                                for (Dependency d : dependencies) {
Line 111... Line 168...
111
168
112
                        throw new RuntimeException(e);
169
                        throw new RuntimeException(e);
113
                }
170
                }
114
        }
171
        }
115
172
116
        public Component ioc(String key, Component component, boolean isSingleton) {
-
 
-
 
173
        public Component ioc(String key, Component component, Scope scope) {
117
               
174
               
118
                beans.put(key, component);
175
                beans.put(key, component);
119
               
176
               
120
                singletonsCache.remove(key); // just in case we are overriding a previous singleton bean...
177
                singletonsCache.remove(key); // just in case we are overriding a previous singleton bean...
121
               
178
               
122
                if (isSingleton) {
-
 
123
                       
-
 
124
                        singletons.add(key);
-
 
125
                       
-
 
126
                } else {
-
 
-
 
179
                threadLocalsCache.remove(key); // just in case we are overriding a previous thread local...
-
 
180
               
-
 
181
                scopes.put(key, scope);
127
               
182
               
128
                        singletons.remove(key); // just in case...
-
 
129
                }
-
 
130
-
 
131
                return component;
183
                return component;
132
        }
184
        }
133
       
185
       
134
        public Component ioc(String key, Component component) {
186
        public Component ioc(String key, Component component) {
135
               
187
               
136
                return ioc(key, component, false);
-
 
-
 
188
                return ioc(key, component, Scope.NONE);
137
        }
189
        }
138
       
190
       
139
        public ConfigurableComponent ioc(String key, Class<? extends Object> klass) {
191
        public ConfigurableComponent ioc(String key, Class<? extends Object> klass) {
140
               
192
               
141
                ConfigurableComponent cc = new MentaComponent(klass);
193
                ConfigurableComponent cc = new MentaComponent(klass);
Line 143... Line 195...
143
                ioc(key, cc);
195
                ioc(key, cc);
144
               
196
               
145
                return cc;
197
                return cc;
146
        }
198
        }
147
       
199
       
148
        public ConfigurableComponent ioc(String key, Class<? extends Object> klass, boolean singleton) {
-
 
-
 
200
        public ConfigurableComponent ioc(String key, Class<? extends Object> klass, Scope scope) {
149
               
201
               
150
                ConfigurableComponent cc = new MentaComponent(klass);
202
                ConfigurableComponent cc = new MentaComponent(klass);
151
               
203
               
152
                ioc(key, cc, singleton);
-
 
-
 
204
                ioc(key, cc, scope);
153
               
205
               
154
                return cc;
206
                return cc;
155
        }
207
        }
156
208
157
        public Dependency autowire(Dependency d) {
209
        public Dependency autowire(Dependency d) {