org.asteriskjava.util.ReflectionUtil Maven / Gradle / Ivy
Show all versions of asterisk-java Show documentation
/*
* Copyright 2005-2006 Stefan Reuter
*
* 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.
*
*/
package org.asteriskjava.util;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
/**
* Utility class that provides helper methods for reflection that is used by the
* fastagi and manager packages to access getter and setter methods.
* Client code is not supposed to use this class.
*
* @author srt
*/
public class ReflectionUtil
{
private ReflectionUtil()
{
// hide constructor
}
/**
* Returns a Map of getter methods of the given class.
* The key of the map contains the name of the attribute that can be
* accessed by the getter, the value the getter itself (an instance of
* java.lang.reflect.Method). A method is considered a getter if its name
* starts with "get", it is declared public and takes no arguments.
*
* @param clazz the class to return the getters for
* @return a Map of attributes and their accessor methods (getters)
*/
public static Map getGetters(final Class clazz)
{
final Map accessors = new HashMap();
final Method[] methods = clazz.getMethods();
for (Method method : methods)
{
String name;
String methodName;
methodName = method.getName();
if (!methodName.startsWith("get"))
{
continue;
}
// skip methods with != 0 parameters
if (method.getParameterTypes().length != 0)
{
continue;
}
// ok seems to be an accessor
name = methodName.substring("get".length()).toLowerCase(Locale.ENGLISH);
if (name.length() == 0)
{
continue;
}
accessors.put(name, method);
}
return accessors;
}
/**
* Returns a Map of setter methods of the given class.
* The key of the map contains the name of the attribute that can be
* accessed by the setter, the value the setter itself (an instance of
* java.lang.reflect.Method). A method is considered a setter if its name
* starts with "set", it is declared public and takes exactly one argument.
*
* @param clazz the class to return the setters for
* @return a Map of attributes and their accessor methods (setters)
*/
public static Map getSetters(Class clazz)
{
final Map accessors = new HashMap();
final Method[] methods = clazz.getMethods();
for (Method method : methods)
{
String name;
String methodName;
methodName = method.getName();
if (!methodName.startsWith("set"))
{
continue;
}
// skip methods with != 1 parameters
if (method.getParameterTypes().length != 1)
{
continue;
}
// ok seems to be an accessor
name = methodName.substring("set".length()).toLowerCase(Locale.US);
accessors.put(name, method);
}
return accessors;
}
/**
* Strips all illegal charaters from the given lower case string.
* Illegal characters are all characters that are neither characters ('a' to 'z') nor digits ('0' to '9').
*
* @param s the original string
* @return the string with all illegal characters stripped
*/
public static String stripIllegalCharacters(String s)
{
char c;
boolean needsStrip = false;
StringBuffer sb;
if (s == null)
{
return null;
}
for (int i = 0; i < s.length(); i++)
{
c = s.charAt(i);
if (c >= '0' && c <= '9')
{
// continue
} // NOPMD
else if (c >= 'a' && c <= 'z')
{
// continue
} // NOPMD
else
{
needsStrip = true;
break;
}
}
if (!needsStrip)
{
return s;
}
sb = new StringBuffer(s.length());
for (int i = 0; i < s.length(); i++)
{
c = s.charAt(i);
if (c >= '0' && c <= '9')
{
sb.append(c);
}
else if (c >= 'a' && c <= 'z')
{
sb.append(c);
}
}
return sb.toString();
}
/**
* Checks if the class is available on the current thread's context class loader.
*
* @param s fully qualified name of the class to check.
* @return true if the class is available, false otherwise.
*/
public static boolean isClassAvailable(String s)
{
final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
try
{
classLoader.loadClass(s);
return true;
}
catch (ClassNotFoundException e)
{
return false;
}
}
/**
* Creates a new instance of the given class. The class is loaded using the current thread's context
* class loader and instantiated using its default constructor.
*
* @param s fully qualified name of the class to instantiate.
* @return the new instance or null on failure.
*/
public static Object newInstance(String s)
{
final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
try
{
Class clazz = classLoader.loadClass(s);
Constructor constructor = clazz.getConstructor();
return constructor.newInstance();
}
catch (ClassNotFoundException e)
{
return null;
}
catch (IllegalAccessException e)
{
return null;
}
catch (InstantiationException e)
{
return null;
}
catch (NoSuchMethodException e)
{
// no default constructor
return null;
}
catch (InvocationTargetException e)
{
// constructor threw an exception
return null;
}
}
}