View Javadoc
1   package org.apache.maven.surefire.util;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.lang.reflect.Constructor;
23  import java.lang.reflect.InvocationTargetException;
24  import java.lang.reflect.Method;
25  
26  /**
27   * @author Kristian Rosenvold
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 RuntimeException( "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( param1 );
131         }
132         catch ( InvocationTargetException e )
133         {
134             throw new SurefireReflectionException( e.getTargetException() );
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 Object instantiateTwoArgs( ClassLoader classLoader, String className, Class param1Class,
147                                              Object param1, Class param2Class, Object param2 )
148     {
149 
150         try
151         {
152             Class aClass = loadClass( classLoader, className );
153             Constructor constructor = ReflectionUtils.getConstructor( aClass, new Class[]{ param1Class, param2Class } );
154             return constructor.newInstance( param1, param2 );
155         }
156         catch ( InvocationTargetException e )
157         {
158             throw new SurefireReflectionException( e.getTargetException() );
159         }
160         catch ( InstantiationException e )
161         {
162             throw new SurefireReflectionException( e );
163         }
164         catch ( IllegalAccessException e )
165         {
166             throw new SurefireReflectionException( e );
167         }
168     }
169 
170 
171     public static void invokeSetter( Object o, String name, Class value1clazz, Object value )
172 
173     {
174         final Method setter = getMethod( o, name, new Class[]{ value1clazz } );
175         invokeSetter( o, setter, value );
176     }
177 
178     public static Object invokeSetter( Object target, Method method, Object value )
179 
180     {
181         return invokeMethodWithArray( target, method, new Object[]{ value } );
182     }
183 
184     public static Object invokeMethodWithArray( Object target, Method method, Object[] args )
185 
186     {
187         try
188         {
189             return method.invoke( target, args );
190         }
191         catch ( IllegalAccessException e )
192         {
193             throw new SurefireReflectionException( e );
194         }
195         catch ( InvocationTargetException e )
196         {
197             throw new SurefireReflectionException( e.getTargetException() );
198         }
199 
200     }
201 
202     public static Object invokeMethodWithArray2( Object target, Method method, Object[] args )
203         throws InvocationTargetException
204 
205     {
206         try
207         {
208             return method.invoke( target, args );
209         }
210         catch ( IllegalAccessException e )
211         {
212             throw new SurefireReflectionException( e );
213         }
214 
215     }
216 
217     public static Object instantiateObject( String className, Class[] types, Object[] params, ClassLoader classLoader )
218     {
219         Class clazz = loadClass( classLoader, className );
220         final Constructor constructor = getConstructor( clazz, types );
221         return newInstance( constructor, params );
222     }
223 
224     @SuppressWarnings( "checkstyle:emptyblock" )
225     public static Class tryLoadClass( ClassLoader classLoader, String className )
226     {
227         try
228         {
229             return classLoader.loadClass( className );
230         }
231         catch ( NoClassDefFoundError ignore )
232         {
233         }
234         catch ( ClassNotFoundException ignore )
235         {
236         }
237         return null;
238     }
239 
240     public static Class loadClass( ClassLoader classLoader, String className )
241     {
242         try
243         {
244             return classLoader.loadClass( className );
245         }
246         catch ( NoClassDefFoundError e )
247         {
248             throw new SurefireReflectionException( e );
249         }
250         catch ( ClassNotFoundException e )
251         {
252             throw new SurefireReflectionException( e );
253         }
254     }
255 }