MentaContainer

Rev

Rev 4 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 soliveira 1
package org.mentacontainer.impl;
2
 
3
import java.lang.reflect.Method;
4
import java.util.HashMap;
5
import java.util.Map;
6
 
7
import org.mentacontainer.util.InjectionUtils;
8
 
9
public class Dependency {
10
 
11
        private final String target;
12
 
13
        private String source;
14
 
15
        private final Class<? extends Object> klass;
16
 
17
        private Map<String, Method> cache = new HashMap<String, Method>();
18
 
19
        public Dependency(String target, Class<? extends Object> klass, String source) {
20
 
21
                this.klass = klass;
22
 
23
                this.target = target;
24
 
25
                this.source = source;
26
        }
27
 
28
        public Dependency(String target, Class<? extends Object> klass) {
29
 
30
                this(target, klass, target);
31
        }
32
 
33
        public String getTarget() {
34
 
35
                return target;
36
        }
37
 
38
        public String getSource() {
39
 
40
                return source;
41
        }
42
 
43
        public Class<? extends Object> getDependencyClass() {
44
 
45
                return klass;
46
        }
47
 
48
        public int hashCode() {
49
 
50
                return klass.hashCode() * 62 + target.hashCode() * 31 + source.hashCode();
51
        }
52
 
53
        public boolean equals(Object obj) {
54
 
55
                if (!(obj instanceof Dependency)) return false;
56
 
57
                Dependency d = (Dependency) obj;
58
 
59
                if (!d.klass.equals(this.klass)) return false;
60
 
61
                return true;
62
        }
63
 
64
    public Method getMethod(Class<? extends Object> targetClass) {
65
 
66
        String className = targetClass.getName();
67
 
68
        // first check cache...
69
 
70
        Method m = null;
71
 
72
        synchronized(cache) {
73
 
74
                m = cache.get(className);
75
 
76
        }
77
 
78
        if (m == null && cache.containsKey(className)) return null; // it is null...
79
 
80
        if (m != null) return m;
81
 
82
        m = InjectionUtils.findMethodToInject(targetClass, target, klass);
83
 
84
        if (m != null) {
85
 
86
                synchronized(cache) {
87
 
88
                        cache.put(className, m);
89
 
90
                }
91
 
92
            return m;
93
        }
94
 
95
        synchronized(cache) {
96
 
97
                // save null to indicate there is no method here... (so you don't do again to find null !!!
98
 
99
                cache.put(className, null);
100
 
101
        }
102
 
103
        return null;
104
    }
105
}