MentaContainer

Rev

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