Java Tutorial/Reflection/Modifier

AccessController.doPrivileged(new PrivilegedAction() )

   <source lang="java">

import java.io.File; import java.security.AccessController; import java.security.PrivilegedAction;

public class Main {

 static long getLastModified(final File f) {
     return ((Long)
             AccessController.doPrivileged(new PrivilegedAction() {
                 public Object run() {
                     return new Long(f.lastModified());
                 }
             })).longValue();
 }
 

}</source>

Get all object accessible public fields

   <source lang="java">

import java.lang.reflect.Field; import java.util.Date; public class Main {

 public static void main(String[] args) throws Exception {
   GetFields object = new GetFields();
   Class clazz = object.getClass();
   // Get all object accessible public fields.
   Field[] fields = clazz.getFields();
   System.out.println("Number of fields = " + fields.length);
   for (Field field : fields) {
     System.out.println("Field name = " + field.getName());
     System.out.println("Field type = " + field.getType().getName());
   }
   Field field = clazz.getField("id");
   System.out.println("Field name = " + field.getName());
   System.out.println("Field type = " + field.getType().getName());
 }

} class GetFields {

 public Long id;
 protected String name;
 private Date birthDate;
 Double weight;

}</source>

Gets a method and forces it to be accessible, even if it is not.

   <source lang="java">

import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class Main {

 /**
  * Gets a method and forces it to be accessible, even if it is not.
  *
  * @param clazz The class from which the method will be got.
  * @param methodName The name of the method.
  * @param parameterTypes The parameter types that the method must match.
  * @return The method, if it is found.
  * @since 2.0.7
  */
 public static Method getForcedAccessibleMethod(Class<?> clazz,
         String methodName, Class<?>... parameterTypes) {
     Method method;
     try {
         method = clazz.getMethod(methodName, parameterTypes);
     } catch (SecurityException e) {
         throw new RuntimeException("Cannot access method ""
                 + methodName + "" in class "" + clazz.getName()
                 + "" for security reasons", e);
     } catch (NoSuchMethodException e) {
         throw new RuntimeException("The method ""
                 + methodName + "" in class "" + clazz.getName()
                 + "" does not exist", e);
     }
     if (!method.isAccessible()) {
         method.setAccessible(true);
     }
     return method;
 }

}</source>

Listing the Modifiers of a Class Object

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] argv) throws Exception {
   int mods = String.class.getModifiers();
   if (Modifier.isPublic(mods)) {
     System.out.println("class is public");
   }
 }

}</source>

Listing the Modifiers of a Member Object: Field, Constructor, and Method are all subclasses of Member.

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] argv) throws Exception {
   int mods = String.class.getDeclaredMethods()[0].getModifiers();
   if (Modifier.isPublic(mods)) {
     System.out.println("member is public");
   }
 }

}</source>

Make AccessibleObject Accessible

   <source lang="java">

import java.lang.reflect.AccessibleObject; import java.security.AccessController; import java.security.PrivilegedAction;

public class Utils {

 public static void makeAccessible( final AccessibleObject object ) {
     if (!object.isAccessible()) {
         if (System.getSecurityManager() == null) {
             object.setAccessible(true);
         } else {
             AccessController.doPrivileged(new PrivilegedAction<Object>() {
                 public Object run() {
                     object.setAccessible(true);
                     return null;
                 }
             });
         }
     }
 }

}</source>

Make field accessible, explicitly setting it accessible

   <source lang="java">

/*

* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.sql.SQLException; import java.util.Arrays; import java.util.LinkedList; import java.util.List; /**

* Simple utility class for working with the reflection API and handling
* reflection exceptions.
*
* Only intended for internal use.
*
* @author Juergen Hoeller
* @author Rob Harrop
* @author Rod Johnson
* @author Costin Leau
* @since 1.2.2
*/

public abstract class ReflectionUtils {

 /**
  * Make the given field accessible, explicitly setting it accessible if necessary.
  * The setAccessible(true) method is only called when actually necessary,
  * to avoid unnecessary conflicts with a JVM SecurityManager (if active).
  * @param field the field to make accessible
  * @see java.lang.reflect.Field#setAccessible
  */
 public static void makeAccessible(Field field) {
   if (!Modifier.isPublic(field.getModifiers()) ||
       !Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
     field.setAccessible(true);
   }
 }

}</source>

Overriding Default Access

   <source lang="java">

import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class Main {

 public static void main(String[] argv) throws Exception {
   Class cls = java.lang.String.class;
   Method method = cls.getMethods()[0];
   Field field = cls.getFields()[0];
   Constructor constructor = cls.getConstructors()[0];
   field.setAccessible(true);
   constructor.setAccessible(true);
   method.setAccessible(true);
 }

}</source>

Return true if the integer argument includes the abstract modifier, false otherwise.

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] args) throws Exception {
   getClassModifier(String.class);
   getClassModifier(TestA.class);
   getClassModifier(TestB.class);
 }
 private static void getClassModifier(Class clazz) {
   int modifier = clazz.getModifiers();
   if (Modifier.isAbstract(modifier)) {
     System.out.println(clazz.getName() + " class modifier is abstract");
   }
 }
 protected static final class TestA {
 }
 private abstract class TestB {
 }

}</source>

Return true if the integer argument includes the final modifier, false otherwise.

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] args) throws Exception {
   getClassModifier(String.class);
   getClassModifier(TestA.class);
   getClassModifier(TestB.class);
 }
 private static void getClassModifier(Class clazz) {
   int modifier = clazz.getModifiers();
   if (Modifier.isFinal(modifier)) {
     System.out.println(clazz.getName() + " class modifier is final");
   }
 }
 protected static final class TestA {
 }
 private abstract class TestB {
 }

}</source>

Return true if the integer argument includes the private modifier, false otherwise.

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] args) throws Exception {
   getClassModifier(String.class);
   getClassModifier(TestA.class);
   getClassModifier(TestB.class);
 }
 private static void getClassModifier(Class clazz) {
   int modifier = clazz.getModifiers();

   if (Modifier.isPrivate(modifier)) {
     System.out.println(clazz.getName() + " class modifier is private");
   }
 }
 protected static final class TestA {
 }
 private abstract class TestB {
 }

}</source>

Return true if the integer argument includes the protected modifier,false otherwise.

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] args) throws Exception {
   getClassModifier(String.class);
   getClassModifier(TestA.class);
   getClassModifier(TestB.class);
 }
 private static void getClassModifier(Class clazz) {
   int modifier = clazz.getModifiers();
   if (Modifier.isProtected(modifier)) {
     System.out.println(clazz.getName() + " class modifier is protected");
   }
 }
 protected static final class TestA {
 }
 private abstract class TestB {
 }

}</source>

Return true if the integer argument includes the public modifier, false otherwise

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] args) throws Exception {
   getClassModifier(String.class);
   getClassModifier(TestA.class);
   getClassModifier(TestB.class);
 }
 private static void getClassModifier(Class clazz) {
   int modifier = clazz.getModifiers();
   if (Modifier.isPublic(modifier)) {
     System.out.println(clazz.getName() + " class modifier is public");
   }
 }
 protected static final class TestA {
 }
 private abstract class TestB {
 }

}</source>

Return true if the integer argument includes the static modifier, false otherwise.

   <source lang="java">

import java.lang.reflect.Modifier; public class Main {

 public static void main(String[] args) throws Exception {
   getClassModifier(String.class);
   getClassModifier(TestA.class);
   getClassModifier(TestB.class);
 }
 private static void getClassModifier(Class clazz) {
   int modifier = clazz.getModifiers();
   if (Modifier.isStatic(modifier)) {
     System.out.println(clazz.getName() + " class modifier is static");
   }
 }
 protected static final class TestA {
 }
 private abstract class TestB {
 }

}</source>

Set Accessibility

   <source lang="java">

// $Id: ReflectionHelper.java 16271 2009-04-07 20:20:12Z hardy.ferentschik $ /*

• JBoss, Home of Professional Open Source
• Copyright 2008, Red Hat Middleware LLC, and individual contributors
• by the @authors tag. See the copyright.txt in the distribution for a
• full listing of individual contributors.
• Licensed under the Apache License, Version 2.0 (the "License");
• you may not use this file except in compliance with the License.
• You may obtain a copy of the License at
• http://www.apache.org/licenses/LICENSE-2.0
• Unless required by applicable law or agreed to in writing, software
• distributed under the License is distributed on an "AS IS" BASIS,
• WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
• See the License for the specific language governing permissions and
• limitations under the License.
• /

import java.beans.Introspector; import java.lang.annotation.Annotation; import java.lang.reflect.AccessibleObject; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.lang.reflect.WildcardType; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.Map;

/**

* Some reflection utility methods.
*
* @author Hardy Ferentschik
*/

public class ReflectionHelper {

 public static void setAccessibility(Member member) {
   if ( !Modifier.isPublic( member.getModifiers() ) ) {
     //Sun"s ease of use, sigh...
     ( ( AccessibleObject ) member ).setAccessible( true );
   }
 }

}</source>

whether given field is a "public static final" constant

   <source lang="java">

/*

* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.sql.SQLException; import java.util.Arrays; import java.util.LinkedList; import java.util.List; /**

* Simple utility class for working with the reflection API and handling
* reflection exceptions.
*
* Only intended for internal use.
*
* @author Juergen Hoeller
* @author Rob Harrop
* @author Rod Johnson
* @author Costin Leau
* @since 1.2.2
*/

public abstract class ReflectionUtils {

 /**
  * Determine whether the given field is a "public static final" constant.
  * @param field the field to check
  */
 public static boolean isPublicStaticFinal(Field field) {
   int modifiers = field.getModifiers();
   return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
 }

}</source>