GrepCode: org.springframework.beans.factory.config.DependencyDescriptor (.java) - Class

Maven-Central
/
org.springframework / spring-beans
/
2.5.2

3.1.1.RELEASE
2.5.6
2.5.6.SEC03
2.5.6.SEC02
2.5.6.SEC01
2.5.5
2.5.4
2.5.3
2.5.2
2.5.1
2.5
/
org.springframework.beans.factory.config.DependencyDescriptor
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
  /*
2
   * Copyright 2002-2007 the original author or authors.
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package org.springframework.beans.factory.config;
18
 
19
 import java.lang.reflect.Field;
20
 import java.lang.reflect.Method;
21
 
22
 import org.springframework.core.GenericCollectionTypeResolver;
23
 import org.springframework.core.JdkVersion;
24
 import org.springframework.core.MethodParameter;
25
 import org.springframework.util.Assert;
26
 import org.springframework.util.ClassUtils;
27
 import org.springframework.util.ReflectionUtils;

 Descriptor for a specific dependency that is about to be injected.
 Wraps a constructor parameter, a method parameter or a field,
 allowing unified access to their metadata.

 
 Author(s):Juergen Hoeller Since:2.5
36
 
37
 public class DependencyDescriptor {
38
 
39
 	private static final Method fieldAnnotationsMethod =
40
 			ClassUtils.getMethodIfAvailable(Field.class, "getAnnotations", new Class[0]);
41
 
42
 
43
 	private MethodParameter methodParameter;
44
 
45
 	private Field field;
46
 
47
 	private final boolean required;
48
 
49
 	private Object[] fieldAnnotations;


	
 Create a new descriptor for a method or constructor parameter.
 
 Parameters:methodParameter the MethodParameter to wraprequired whether the dependency is required
56
 
57
 	public DependencyDescriptor(MethodParameter methodParameter, boolean required) {
58
 		Assert.notNull(methodParameter, "MethodParameter must not be null");
59
 		this.methodParameter = methodParameter;
60
 		this.required = required;
61
 	}

	
 Create a new descriptor for a field.
 
 Parameters:field the field to wraprequired whether the dependency is required
67
 
68
 	public DependencyDescriptor(Field field, boolean required) {
69
 		Assert.notNull(field, "Field must not be null");
70
 		this.field = field;
71
 		this.required = required;
72
 	}


	
 Return the wrapped MethodParameter, if any.
 Note: Either MethodParameter or Field is available.
 
 Returns:the MethodParameter, or null if none
79
 
80
 	public MethodParameter getMethodParameter() {
81
 		return this.methodParameter;
82
 	}

	
 Return the wrapped Field, if any.
 Note: Either MethodParameter or Field is available.
 
 Returns:the Field, or null if none
88
 
89
 	public Field getField() {
90
 		return this.field;
91
 	}

	
 Return whether this dependency is required.
 
95
 
96
 	public boolean isRequired() {
97
 		return this.required;
98
 	}


	
 Determine the declared (non-generic) type of the wrapped parameter/field.
 
 Returns:the declared type (never null)
104
105
	public Class getDependencyType() {
106
		return (this.field != null ? this.field.getType() : this.methodParameter.getParameterType());
107
	}

	
 Determine the generic element type of the wrapped Collection parameter/field, if any.
 
 Returns:the generic type, or null if none
112
113
	public Class getCollectionType() {
114
		if (JdkVersion.getMajorJavaVersion() < JdkVersion.JAVA_15) {
115
			return null;
116
		}
117
		return (this.field != null ?
118
				GenericCollectionTypeResolver.getCollectionFieldType(this.field) :
119
				GenericCollectionTypeResolver.getCollectionParameterType(this.methodParameter));
120
	}

	
 Determine the generic key type of the wrapped Map parameter/field, if any.
 
 Returns:the generic type, or null if none
125
126
	public Class getMapKeyType() {
127
		if (JdkVersion.getMajorJavaVersion() < JdkVersion.JAVA_15) {
128
			return null;
129
		}
130
		return (this.field != null ?
131
				GenericCollectionTypeResolver.getMapKeyFieldType(this.field) :
132
				GenericCollectionTypeResolver.getMapKeyParameterType(this.methodParameter));
133
	}

	
 Determine the generic value type of the wrapped Map parameter/field, if any.
 
 Returns:the generic type, or null if none
138
139
	public Class getMapValueType() {
140
		if (JdkVersion.getMajorJavaVersion() < JdkVersion.JAVA_15) {
141
			return null;
142
		}
143
		return (this.field != null ?
144
				GenericCollectionTypeResolver.getMapValueFieldType(this.field) :
145
				GenericCollectionTypeResolver.getMapValueParameterType(this.methodParameter));
146
	}

	
 Obtain the annotations associated with the wrapped parameter/field, if any.
 
 Returns:the parameter/field annotations, or null if there is
 no annotation support (on JDK < 1.5). The return value is an Object array
 instead of an Annotation array simply for compatibility with older JDKs;
 feel free to cast it to Annotation[] on JDK 1.5 or higher.
154
155
	public Object[] getAnnotations() {
156
		if (this.field != null) {
157
			if (this.fieldAnnotations != null) {
158
				return this.fieldAnnotations;
159
			}
160
			if (fieldAnnotationsMethod == null) {
161
				return null;
162
			}
163
			this.fieldAnnotations = (Object[]) ReflectionUtils.invokeMethod(fieldAnnotationsMethod, this.field);
164
			return this.fieldAnnotations;
165
		}
166
		else {
167
			return this.methodParameter.getParameterAnnotations();
168
		}
169
	}
170
171
}