Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2001-2004 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package sun.reflect;
27
 

The master factory for all reflective objects, both those in java.lang.reflect (Fields, Methods, Constructors) as well as their delegates (FieldAccessors, MethodAccessors, ConstructorAccessors).

The methods in this class are extremely unsafe and can cause subversion of both the language and the verifier. For this reason, they are all instance methods, and access to the constructor of this factory is guarded by a security check, in similar style to sun.misc.Unsafe. 

46
 
47
 
48
 public class ReflectionFactory {
49
 
50
     private static boolean initted = false;
51
     private static Permission reflectionFactoryAccessPerm
52
         = new RuntimePermission("reflectionFactoryAccess");
53
     private static ReflectionFactory soleInstance = new ReflectionFactory();
54
     // Provides access to package-private mechanisms in java.lang.reflect
55
     private static volatile LangReflectAccess langReflectAccess;
56
 
57
     //
58
     // "Inflation" mechanism. Loading bytecodes to implement
59
     // Method.invoke() and Constructor.newInstance() currently costs
60
     // 3-4x more than an invocation via native code for the first
61
     // invocation (though subsequent invocations have been benchmarked
62
     // to be over 20x faster). Unfortunately this cost increases
63
     // startup time for certain applications that use reflection
64
     // intensively (but only once per class) to bootstrap themselves.
65
     // To avoid this penalty we reuse the existing JVM entry points
66
     // for the first few invocations of Methods and Constructors and
67
     // then switch to the bytecode-based implementations.
68
     //
69
     // Package-private to be accessible to NativeMethodAccessorImpl
70
     // and NativeConstructorAccessorImpl
71
     private static boolean noInflation        = false;
72
     private static int     inflationThreshold = 15;
73
 
74
     private ReflectionFactory() {
75
     }

    
A convenience class for acquiring the capability to instantiate reflective objects. Use this instead of a raw call to ReflectionFactory.getReflectionFactory() in order to avoid being limited by the permissions of your callers.

An instance of this class can be used as the argument of AccessController.doPrivileged. 

85
 
86
     public static final class GetReflectionFactoryAction
87
         implements PrivilegedAction {
88
         public Object run() {
89
             return getReflectionFactory();
90
         }
91
     }

    
Provides the caller with the capability to instantiate reflective objects.

First, if there is a security manager, its checkPermission method is called with a java.lang.RuntimePermission with target "reflectionFactoryAccess". This may result in a security exception.

The returned ReflectionFactory object should be carefully guarded by the caller, since it can be used to read and write private data and invoke private methods, as well as to load unverified bytecodes. It must never be passed to untrusted code.

Throws:
java.lang.SecurityException if a security manager exists and its checkPermission method doesn't allow access to the RuntimePermission "reflectionFactoryAccess".
111
    public static ReflectionFactory getReflectionFactory() {
112
        SecurityManager security = System.getSecurityManager();
113
        if (security != null) {
114
            // TO DO: security.checkReflectionFactoryAccess();
115
            security.checkPermission();
116
        }
117
        return ;
118
    }
120
    //--------------------------------------------------------------------------
121
    //
122
    // Routines used by java.lang.reflect
123
    //
124
    //
125

    
Called only by java.lang.reflect.Modifier's static initializer
127
    public void setLangReflectAccess(LangReflectAccess access) {
128
         = access;
129
    }

    
Note: this routine can cause the declaring class for the field be initialized and therefore must not be called until the first get/set of this field.

Parameters:
field the field
override true if caller has overridden aaccessibility
138
    public FieldAccessor newFieldAccessor(Field field, boolean override) {
139
        checkInitted();
140
        return UnsafeFieldAccessorFactory.newFieldAccessor(field, override);
141
    }
143
    public MethodAccessor newMethodAccessor(Method method) {
144
        checkInitted();
146
        if () {
147
            return new MethodAccessorGenerator().
148
                generateMethod(method.getDeclaringClass(),
149
                               method.getName(),
150
                               method.getParameterTypes(),
151
                               method.getReturnType(),
152
                               method.getExceptionTypes(),
153
                               method.getModifiers());
154
        } else {
155
            NativeMethodAccessorImpl acc =
156
                new NativeMethodAccessorImpl(method);
157
            DelegatingMethodAccessorImpl res =
158
                new DelegatingMethodAccessorImpl(acc);
159
            acc.setParent(res);
160
            return res;
161
        }
162
    }
165
        checkInitted();
167
        Class declaringClass = c.getDeclaringClass();
168
        if (Modifier.isAbstract(declaringClass.getModifiers())) {
169
            return new InstantiationExceptionConstructorAccessorImpl(null);
170
        }
171
        if (declaringClass == Class.class) {
172
            return new InstantiationExceptionConstructorAccessorImpl
173
                ("Can not instantiate java.lang.Class");
174
        }
175
        // Bootstrapping issue: since we use Class.newInstance() in
176
        // the ConstructorAccessor generation process, we have to
177
        // break the cycle here.
178
        if (Reflection.isSubclassOf(declaringClass,
179
                                    ConstructorAccessorImpl.class)) {
180
            return new BootstrapConstructorAccessorImpl(c);
181
        }
183
        if () {
184
            return new MethodAccessorGenerator().
185
                generateConstructor(c.getDeclaringClass(),
186
                                    c.getParameterTypes(),
187
                                    c.getExceptionTypes(),
188
                                    c.getModifiers());
189
        } else {
190
            NativeConstructorAccessorImpl acc =
191
                new NativeConstructorAccessorImpl(c);
192
            DelegatingConstructorAccessorImpl res =
193
                new DelegatingConstructorAccessorImpl(acc);
194
            acc.setParent(res);
195
            return res;
196
        }
197
    }
199
    //--------------------------------------------------------------------------
200
    //
201
    // Routines used by java.lang
202
    //
203
    //
204

    
Creates a new java.lang.reflect.Field. Access checks as per java.lang.reflect.AccessibleObject are not overridden.
207
    public Field newField(Class declaringClass,
208
                          String name,
209
                          Class type,
210
                          int modifiers,
211
                          int slot,
212
                          String signature,
213
                          byte[] annotations)
214
    {
215
        return langReflectAccess().newField(declaringClass,
216
                                            name,
217
                                            type,
218
                                            modifiers,
219
                                            slot,
220
                                            signature,
221
                                            annotations);
222
    }

    
Creates a new java.lang.reflect.Method. Access checks as per java.lang.reflect.AccessibleObject are not overridden.
226
    public Method newMethod(Class declaringClass,
227
                            String name,
228
                            Class[] parameterTypes,
229
                            Class returnType,
230
                            Class[] checkedExceptions,
231
                            int modifiers,
232
                            int slot,
233
                            String signature,
234
                            byte[] annotations,
235
                            byte[] parameterAnnotations,
236
                            byte[] annotationDefault)
237
    {
238
        return langReflectAccess().newMethod(declaringClass,
239
                                             name,
240
                                             parameterTypes,
241
                                             returnType,
242
                                             checkedExceptions,
243
                                             modifiers,
244
                                             slot,
245
                                             signature,
246
                                             annotations,
247
                                             parameterAnnotations,
248
                                             annotationDefault);
249
    }

    
Creates a new java.lang.reflect.Constructor. Access checks as per java.lang.reflect.AccessibleObject are not overridden.
253
    public Constructor newConstructor(Class declaringClass,
254
                                      Class[] parameterTypes,
255
                                      Class[] checkedExceptions,
256
                                      int modifiers,
257
                                      int slot,
258
                                      String signature,
259
                                      byte[] annotations,
260
                                      byte[] parameterAnnotations)
261
    {
262
        return langReflectAccess().newConstructor(declaringClass,
263
                                                  parameterTypes,
264
                                                  checkedExceptions,
265
                                                  modifiers,
266
                                                  slot,
267
                                                  signature,
268
                                                  annotations,
269
                                                  parameterAnnotations);
270
    }

    
Gets the MethodAccessor object for a java.lang.reflect.Method
274
        return langReflectAccess().getMethodAccessor(m);
275
    }

    
Sets the MethodAccessor object for a java.lang.reflect.Method
278
    public void setMethodAccessor(Method m, MethodAccessor accessor) {
279
        langReflectAccess().setMethodAccessor(m, accessor);
280
    }

    
Gets the ConstructorAccessor object for a java.lang.reflect.Constructor
285
        return langReflectAccess().getConstructorAccessor(c);
286
    }

    
Sets the ConstructorAccessor object for a java.lang.reflect.Constructor
290
    public void setConstructorAccessor(Constructor c,
291
                                       ConstructorAccessor accessor)
292
    {
293
        langReflectAccess().setConstructorAccessor(c, accessor);
294
    }

    
Makes a copy of the passed method. The returned method is a "child" of the passed one; see the comments in Method.java for details.
299
    public Method copyMethod(Method arg) {
300
        return langReflectAccess().copyMethod(arg);
301
    }

    
Makes a copy of the passed field. The returned field is a "child" of the passed one; see the comments in Field.java for details.
306
    public Field copyField(Field arg) {
307
        return langReflectAccess().copyField(arg);
308
    }

    
Makes a copy of the passed constructor. The returned constructor is a "child" of the passed one; see the comments in Constructor.java for details.
313
    public Constructor copyConstructor(Constructor arg) {
314
        return langReflectAccess().copyConstructor(arg);
315
    }
317
    //--------------------------------------------------------------------------
318
    //
319
    // Routines used by serialization
320
    //
321
    //
324
        (Class classToInstantiate, Constructor constructorToCall)
325
    {
326
        // Fast path
327
        if (constructorToCall.getDeclaringClass() == classToInstantiate) {
328
            return constructorToCall;
329
        }
331
        ConstructorAccessor acc = new MethodAccessorGenerator().
332
            generateSerializationConstructor(classToInstantiate,
333
                                             constructorToCall.getParameterTypes(),
334
                                             constructorToCall.getExceptionTypes(),
335
                                             constructorToCall.getModifiers(),
336
                                             constructorToCall.getDeclaringClass());
337
        Constructor c = newConstructor(constructorToCall.getDeclaringClass(),
338
                                       constructorToCall.getParameterTypes(),
339
                                       constructorToCall.getExceptionTypes(),
340
                                       constructorToCall.getModifiers(),
341
                                       langReflectAccess().
342
                                       getConstructorSlot(constructorToCall),
343
                                       langReflectAccess().
344
                                       getConstructorSignature(constructorToCall),
345
                                       langReflectAccess().
346
                                       getConstructorAnnotations(constructorToCall),
347
                                       langReflectAccess().
348
                                       getConstructorParameterAnnotations(constructorToCall));
349
        setConstructorAccessor(c, acc);
350
        return c;
351
    }
353
    //--------------------------------------------------------------------------
354
    //
355
    // Internals only below this point
356
    //
358
    static int inflationThreshold() {
359
        return ;
360
    }

    
We have to defer full initialization of this class until after the static initializer is run since java.lang.reflect.Method's static initializer (more properly, that for java.lang.reflect.AccessibleObject) causes this class's to be run, before the system properties are set up.
367
    private static void checkInitted() {
368
        if () return;
369
        AccessController.doPrivileged(new PrivilegedAction() {
370
                public Object run() {
371
                    // Tests to ensure the system properties table is fully
372
                    // initialized. This is needed because reflection code is
373
                    // called very early in the initialization process (before
374
                    // command-line arguments have been parsed and therefore
375
                    // these user-settable properties installed.) We assume that
376
                    // if System.out is non-null then the System class has been
377
                    // fully initialized and that the bulk of the startup code
378
                    // has been run.
380
                    if (. == null) {
381
                        // java.lang.System not yet fully initialized
382
                        return null;
383
                    }
385
                    String val = System.getProperty("sun.reflect.noInflation");
386
                    if (val != null && val.equals("true")) {
387
                         = true;
388
                    }
390
                    val = System.getProperty("sun.reflect.inflationThreshold");
391
                    if (val != null) {
392
                        try {
393
                             = Integer.parseInt(val);
394
                        } catch (NumberFormatException e) {
395
                            throw (RuntimeException)
396
                                new RuntimeException("Unable to parse property sun.reflect.inflationThreshold").
397
                                    initCause(e);
398
                        }
399
                    }
401
                     = true;
402
                    return null;
403
                }
404
            });
405
    }
407
    private static LangReflectAccess langReflectAccess() {
408
        if ( == null) {
409
            // Call a static method to get class java.lang.reflect.Modifier
410
            // initialized. Its static initializer will cause
411
            // setLangReflectAccess() to be called from the context of the
412
            // java.lang.reflect package.
413
            Modifier.isPublic(.);
414
        }
415
        return ;
416
    }
New to GrepCode? Check out our FAQ X