MentaContainer

Rev

Rev 105 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 105 Rev 139
1
package org.mentacontainer.example;
1
package org.mentacontainer.example;
2
2
3
import java.util.Date;
3
import java.util.Date;
4
4
5
import org.mentacontainer.Container;
5
import org.mentacontainer.Container;
6
import org.mentacontainer.Scope;
6
import org.mentacontainer.Scope;
7
import org.mentacontainer.impl.MentaContainer;
7
import org.mentacontainer.impl.MentaContainer;
8
8
9
public class BasicOperations {
9
public class BasicOperations {
10
10
11
        public static void main(String[] args) {
11
        public static void main(String[] args) {
12
12
13
                case1();
13
                case1();
14
                case2();
14
                case2();
15
                case3();
15
                case3();
16
                case4();
16
                case4();
17
                case5();
17
                case5();
18
                case6();
18
                case6();
19
                case7();
19
                case7();
20
                case8();
20
                case8();
21
                case9();
21
                case9();
22
                case10();
22
                case10();
23
        }
23
        }
24
24
25
        public static class Connection {
25
        public static class Connection {
26
26
27
        }
27
        }
28
28
29
        public static interface UserDAO {
29
        public static interface UserDAO {
30
30
31
                public String getUsername(int id);
31
                public String getUsername(int id);
32
        }
32
        }
33
33
34
        public static class JdbcUserDAO implements UserDAO {
34
        public static class JdbcUserDAO implements UserDAO {
35
35
36
                private Connection conn;
36
                private Connection conn;
37
37
38
                public void setConnection(Connection conn) {
38
                public void setConnection(Connection conn) {
39
                        this.conn = conn;
39
                        this.conn = conn;
40
                }
40
                }
41
41
42
                @Override
42
                @Override
43
                public String getUsername(int id) {
43
                public String getUsername(int id) {
44
44
45
                        // connection will be injected by the container...
45
                        // connection will be injected by the container...
46
                        if (conn == null) throw new IllegalStateException("conn is null!");
46
                        if (conn == null) throw new IllegalStateException("conn is null!");
47
47
48
                        // use the connection to get the username...
48
                        // use the connection to get the username...
49
49
50
                        return "saoj";
50
                        return "saoj";
51
                }
51
                }
52
        }
52
        }
53
53
54
        public static interface AccountDAO {
54
        public static interface AccountDAO {
55
55
56
                public double getBalance(int id);
56
                public double getBalance(int id);
57
        }
57
        }
58
58
59
        public static class JdbcAccountDAO implements AccountDAO {
59
        public static class JdbcAccountDAO implements AccountDAO {
60
60
61
                private final Connection conn;
61
                private final Connection conn;
62
62
63
                public JdbcAccountDAO(Connection conn) {
63
                public JdbcAccountDAO(Connection conn) {
64
                        this.conn = conn;
64
                        this.conn = conn;
65
                }
65
                }
66
66
67
                @Override
67
                @Override
68
                public double getBalance(int id) {
68
                public double getBalance(int id) {
69
69
70
                        assert conn != null;
70
                        assert conn != null;
71
71
72
                        // use the connection to get the balance...
72
                        // use the connection to get the balance...
73
                        return 1000000D;
73
                        return 1000000D;
74
                }
74
                }
75
        }
75
        }
76
       
76
       
77
        private static void case9() {
77
        private static void case9() {
78
               
78
               
79
                Container c = new MentaContainer();
79
                Container c = new MentaContainer();
80
80
81
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
81
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
82
                c.ioc("accountDAO", JdbcAccountDAO.class);
82
                c.ioc("accountDAO", JdbcAccountDAO.class);
83
                c.ioc("userDAO", JdbcUserDAO.class);
83
                c.ioc("userDAO", JdbcUserDAO.class);
84
84
85
                c.autowire("connection"); // all beans that need a connection in the constructor or setter will receive one...
85
                c.autowire("connection"); // all beans that need a connection in the constructor or setter will receive one...
86
86
87
                AccountDAO accountDAO = c.get("accountDAO");
87
                AccountDAO accountDAO = c.get("accountDAO");
88
                UserDAO userDAO = c.get("userDAO");
88
                UserDAO userDAO = c.get("userDAO");
89
89
90
                System.out.println(accountDAO.getBalance(25)); // => 1000000
90
                System.out.println(accountDAO.getBalance(25)); // => 1000000
91
                System.out.println(userDAO.getUsername(45)); // => "saoj"
91
                System.out.println(userDAO.getUsername(45)); // => "saoj"
92
        }
92
        }
93
93
94
        private static void case1() {
94
        private static void case1() {
95
95
96
                Container c = new MentaContainer();
96
                Container c = new MentaContainer();
97
97
98
                c.ioc("myString1", String.class);
98
                c.ioc("myString1", String.class);
99
99
100
                String myString1 = c.get("myString1");
100
                String myString1 = c.get("myString1");
101
101
102
                System.out.println(myString1); // ==> "" ==> default constructor new String() was used
102
                System.out.println(myString1); // ==> "" ==> default constructor new String() was used
103
103
104
                c.ioc("myString2", String.class).addInitValue("saoj");
104
                c.ioc("myString2", String.class).addInitValue("saoj");
105
105
106
                String myString2 = c.get("myString2");
106
                String myString2 = c.get("myString2");
107
107
108
                System.out.println(myString2); // ==> "saoj" ==> constructor new String("saoj") was used
108
                System.out.println(myString2); // ==> "saoj" ==> constructor new String("saoj") was used
109
109
110
                c.ioc("myDate1", Date.class).addPropertyValue("hours", 15) // setHours(15)
110
                c.ioc("myDate1", Date.class).addPropertyValue("hours", 15) // setHours(15)
111
                        .addPropertyValue("minutes", 10) // setMinutes(10)
111
                        .addPropertyValue("minutes", 10) // setMinutes(10)
112
                        .addPropertyValue("seconds", 45); // setSeconds(45)
112
                        .addPropertyValue("seconds", 45); // setSeconds(45)
113
113
114
                Date myDate1 = c.get("myDate1");
114
                Date myDate1 = c.get("myDate1");
115
115
116
                System.out.println(myDate1); // ==> a date with time 15:10:45
116
                System.out.println(myDate1); // ==> a date with time 15:10:45
117
        }
117
        }
118
118
119
        private static void case5() {
119
        private static void case5() {
120
120
121
                Container c = new MentaContainer();
121
                Container c = new MentaContainer();
122
122
123
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
123
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
124
124
125
                c.ioc("accountDAO", JdbcAccountDAO.class).addInitDependency("connection");
-
 
-
 
125
                c.ioc("accountDAO", JdbcAccountDAO.class).addConstructorDependency("connection");
126
126
127
                AccountDAO accountDAO = c.get("accountDAO");
127
                AccountDAO accountDAO = c.get("accountDAO");
128
128
129
                System.out.println(accountDAO.getBalance(25)); // => 1000000
129
                System.out.println(accountDAO.getBalance(25)); // => 1000000
130
        }
130
        }
131
131
132
        private static void case7() {
132
        private static void case7() {
133
133
134
                Container c = new MentaContainer();
134
                Container c = new MentaContainer();
135
135
136
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
136
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
137
137
138
                c.ioc("accountDAO", JdbcAccountDAO.class);
138
                c.ioc("accountDAO", JdbcAccountDAO.class);
139
139
140
                c.autowire("connection"); // all beans that need a connection in the constructor will get one...
140
                c.autowire("connection"); // all beans that need a connection in the constructor will get one...
141
141
142
                AccountDAO accountDAO = c.get("accountDAO");
142
                AccountDAO accountDAO = c.get("accountDAO");
143
143
144
                System.out.println(accountDAO.getBalance(25)); // => 1000000
144
                System.out.println(accountDAO.getBalance(25)); // => 1000000
145
145
146
        }
146
        }
147
147
148
        private static void case6() {
148
        private static void case6() {
149
149
150
                Container c = new MentaContainer();
150
                Container c = new MentaContainer();
151
151
152
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
152
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
153
153
154
                c.ioc("userDAO", JdbcUserDAO.class).addPropertyDependency("connection");
154
                c.ioc("userDAO", JdbcUserDAO.class).addPropertyDependency("connection");
155
155
156
                UserDAO userDAO = c.get("userDAO");
156
                UserDAO userDAO = c.get("userDAO");
157
157
158
                System.out.println(userDAO.getUsername(54)); // => "saoj"
158
                System.out.println(userDAO.getUsername(54)); // => "saoj"
159
        }
159
        }
160
160
161
        private static void case8() {
161
        private static void case8() {
162
162
163
                Container c = new MentaContainer();
163
                Container c = new MentaContainer();
164
164
165
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
165
                c.ioc("connection", Connection.class); // in real life this will be a connection pool factory...
166
166
167
                c.ioc("userDAO", JdbcUserDAO.class);
167
                c.ioc("userDAO", JdbcUserDAO.class);
168
168
169
                c.autowire("connection");
169
                c.autowire("connection");
170
170
171
                UserDAO userDAO = c.get("userDAO");
171
                UserDAO userDAO = c.get("userDAO");
172
172
173
                System.out.println(userDAO.getUsername(54)); // => "saoj"
173
                System.out.println(userDAO.getUsername(54)); // => "saoj"
174
174
175
        }
175
        }
176
176
177
        private static void case2() {
177
        private static void case2() {
178
178
179
                Container c = new MentaContainer();
179
                Container c = new MentaContainer();
180
180
181
                c.ioc("myString", String.class, Scope.SINGLETON).addInitValue("saoj");
181
                c.ioc("myString", String.class, Scope.SINGLETON).addInitValue("saoj");
182
182
183
                String s1 = c.get("myString");
183
                String s1 = c.get("myString");
184
184
185
                String s2 = c.get("myString");
185
                String s2 = c.get("myString");
186
186
187
                System.out.println(s1 == s2); // ==> true ==> same instance
187
                System.out.println(s1 == s2); // ==> true ==> same instance
188
188
189
                System.out.println(s1.equals(s2)); // ==> true => of course
189
                System.out.println(s1.equals(s2)); // ==> true => of course
190
        }
190
        }
191
191
192
        private static void case3() {
192
        private static void case3() {
193
193
194
                Container c = new MentaContainer();
194
                Container c = new MentaContainer();
195
195
196
                c.ioc("userDAO", JdbcUserDAO.class);
196
                c.ioc("userDAO", JdbcUserDAO.class);
197
197
198
                c.ioc("connection", Connection.class); // in real life this would be a connection pool
198
                c.ioc("connection", Connection.class); // in real life this would be a connection pool
199
                                                       // or the hibernate SessionFactory
199
                                                       // or the hibernate SessionFactory
200
200
201
                // "conn" = the name of the property
201
                // "conn" = the name of the property
202
                // Connection.class = the type of the property
202
                // Connection.class = the type of the property
203
                // "connection" = the source from where the dependency will come from
203
                // "connection" = the source from where the dependency will come from
204
                c.autowire("connection");
204
                c.autowire("connection");
205
205
206
                UserDAO userDAO = c.get("userDAO");
206
                UserDAO userDAO = c.get("userDAO");
207
207
208
                // the container detects that userDAO has a dependency: name = "conn" and type = "Connection.class"
208
                // the container detects that userDAO has a dependency: name = "conn" and type = "Connection.class"
209
                // where does it go to get the dependency to insert?
209
                // where does it go to get the dependency to insert?
210
                // In itself: it does a Container.get("connection") => "connection" => the source
210
                // In itself: it does a Container.get("connection") => "connection" => the source
211
211
212
                System.out.println(userDAO.getUsername(11)); // ==> "saoj" ==> connection is not null as expected...
212
                System.out.println(userDAO.getUsername(11)); // ==> "saoj" ==> connection is not null as expected...
213
        }
213
        }
214
214
215
        public static class SomeService {
215
        public static class SomeService {
216
216
217
                private UserDAO userDAO;
217
                private UserDAO userDAO;
218
218
219
                public void setUserDAO(UserDAO userDAO) {
219
                public void setUserDAO(UserDAO userDAO) {
220
                        this.userDAO = userDAO;
220
                        this.userDAO = userDAO;
221
                }
221
                }
222
222
223
                public void doSomething() {
223
                public void doSomething() {
224
                        System.out.println(userDAO.getUsername(11));
224
                        System.out.println(userDAO.getUsername(11));
225
                }
225
                }
226
        }
226
        }
227
227
228
        private static void case4() {
228
        private static void case4() {
229
229
230
                Container c = new MentaContainer();
230
                Container c = new MentaContainer();
231
231
232
                c.ioc("userDAO", JdbcUserDAO.class);
232
                c.ioc("userDAO", JdbcUserDAO.class);
233
233
234
                c.ioc("connection", Connection.class);
234
                c.ioc("connection", Connection.class);
235
235
236
                c.autowire("connection");
236
                c.autowire("connection");
237
237
238
                SomeService service = new SomeService();
238
                SomeService service = new SomeService();
239
239
240
                c.inject(service); // populate (inject) all properties of SomeService with
240
                c.inject(service); // populate (inject) all properties of SomeService with
241
                                     // beans from the container
241
                                     // beans from the container
242
242
243
                service.doSomething(); // ==> "saoj"
243
                service.doSomething(); // ==> "saoj"
244
        }
244
        }
245
       
245
       
246
        public static class SomeService2 {
246
        public static class SomeService2 {
247
247
248
                private final UserDAO userDAO;
248
                private final UserDAO userDAO;
249
249
250
                public SomeService2(UserDAO userDAO) {
250
                public SomeService2(UserDAO userDAO) {
251
                        this.userDAO = userDAO;
251
                        this.userDAO = userDAO;
252
                }
252
                }
253
               
253
               
254
                public void doSomething() {
254
                public void doSomething() {
255
                        System.out.println(userDAO.getUsername(11));
255
                        System.out.println(userDAO.getUsername(11));
256
                }
256
                }
257
        }
257
        }
258
258
259
        private static void case10() {
259
        private static void case10() {
260
260
261
                Container c = new MentaContainer();
261
                Container c = new MentaContainer();
262
262
263
                c.ioc("userDAO", JdbcUserDAO.class);
263
                c.ioc("userDAO", JdbcUserDAO.class);
264
264
265
                c.ioc("connection", Connection.class);
265
                c.ioc("connection", Connection.class);
266
266
267
                c.autowire("connection");
267
                c.autowire("connection");
268
               
268
               
269
                SomeService2 service = c.construct(SomeService2.class);
269
                SomeService2 service = c.construct(SomeService2.class);
270
270
271
                service.doSomething(); // ==> "saoj"
271
                service.doSomething(); // ==> "saoj"
272
        }      
272
        }      
273
273
274
}
274
}