1 package org.apache.maven.surefire.util;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.lang.reflect.Constructor;
23 import java.lang.reflect.InvocationTargetException;
24 import java.lang.reflect.Method;
25
26
27
28
29 public class ReflectionUtils
30 {
31 private static final Class[] NO_ARGS = new Class[0];
32
33 private static final Object[] NO_ARGS_VALUES = new Object[0];
34
35
36 public static Method getMethod( Object instance, String methodName, Class[] parameters )
37 {
38 return getMethod( instance.getClass(), methodName, parameters );
39 }
40
41 public static Method getMethod( Class clazz, String methodName, Class[] parameters )
42 {
43 try
44 {
45 return clazz.getMethod( methodName, parameters );
46 }
47 catch ( NoSuchMethodException e )
48 {
49 throw new NestedRuntimeException( "When finding method " + methodName, e );
50 }
51 }
52
53 public static Method tryGetMethod( Class clazz, String methodName, Class[] parameters )
54 {
55 try
56 {
57 return clazz.getMethod( methodName, parameters );
58 }
59 catch ( NoSuchMethodException e )
60 {
61 return null;
62 }
63 }
64
65
66 public static Object invokeGetter( Object instance, String methodName )
67 {
68 final Method method = getMethod( instance, methodName, NO_ARGS );
69 return invokeMethodWithArray( instance, method, NO_ARGS_VALUES );
70 }
71
72 public static Constructor getConstructor( Class clazz, Class[] arguments )
73 {
74 try
75 {
76 return clazz.getConstructor( arguments );
77 }
78 catch ( NoSuchMethodException e )
79 {
80 throw new SurefireReflectionException( e );
81 }
82 }
83
84 public static Object newInstance( Constructor constructor, Object[] params )
85 {
86 try
87 {
88 return constructor.newInstance( params );
89 }
90 catch ( InvocationTargetException e )
91 {
92 throw new SurefireReflectionException( e );
93 }
94 catch ( InstantiationException e )
95 {
96 throw new SurefireReflectionException( e );
97 }
98 catch ( IllegalAccessException e )
99 {
100 throw new SurefireReflectionException( e );
101 }
102 }
103
104 public static Object instantiate( ClassLoader classLoader, String classname )
105 {
106 try
107 {
108
109 Class clazz = loadClass( classLoader, classname );
110 return clazz.newInstance();
111 }
112 catch ( InstantiationException e )
113 {
114 throw new SurefireReflectionException( e );
115 }
116 catch ( IllegalAccessException e )
117 {
118 throw new SurefireReflectionException( e );
119 }
120 }
121
122 public static Object instantiateOneArg( ClassLoader classLoader, String className, Class param1Class,
123 Object param1 )
124 {
125
126 try
127 {
128 Class aClass = loadClass( classLoader, className );
129 Constructor constructor = ReflectionUtils.getConstructor( aClass, new Class[]{ param1Class } );
130 return constructor.newInstance( new Object[]{ param1 } );
131 }
132 catch ( InvocationTargetException e )
133 {
134 throw new SurefireReflectionException( e );
135 }
136 catch ( InstantiationException e )
137 {
138 throw new SurefireReflectionException( e );
139 }
140 catch ( IllegalAccessException e )
141 {
142 throw new SurefireReflectionException( e );
143 }
144 }
145
146 public static void invokeSetter( Object o, String name, Class value1clazz, Object value )
147
148 {
149 final Method setter = getMethod( o, name, new Class[]{ value1clazz } );
150 invokeSetter( o, setter, value );
151 }
152
153 public static Object invokeSetter( Object target, Method method, Object value )
154
155 {
156 return invokeMethodWithArray( target, method, new Object[]{ value } );
157 }
158
159 public static Object invokeMethodWithArray( Object target, Method method, Object[] args )
160
161 {
162 try
163 {
164 return method.invoke( target, args );
165 }
166 catch ( IllegalAccessException e )
167 {
168 throw new SurefireReflectionException( e );
169 }
170 catch ( InvocationTargetException e )
171 {
172 throw new SurefireReflectionException( e );
173 }
174
175 }
176
177 public static Object instantiateObject( String className, Class[] types, Object[] params, ClassLoader classLoader )
178 {
179 Class clazz = loadClass( classLoader, className );
180 final Constructor constructor = getConstructor( clazz, types );
181 return newInstance( constructor, params );
182 }
183
184 public static Class tryLoadClass( ClassLoader classLoader, String className )
185 {
186 try
187 {
188 return classLoader.loadClass( className );
189 }
190 catch ( NoClassDefFoundError ignore )
191 {
192 }
193 catch ( ClassNotFoundException ignore )
194 {
195 }
196 return null;
197 }
198
199 public static Class loadClass( ClassLoader classLoader, String className )
200 {
201 try
202 {
203 return classLoader.loadClass( className );
204 }
205 catch ( NoClassDefFoundError e )
206 {
207 throw new SurefireReflectionException( e );
208 }
209 catch ( ClassNotFoundException e )
210 {
211 throw new SurefireReflectionException( e );
212 }
213 }
214 }