Java/Reflection/Exception
Содержание
Check whether given exception is compatible with the exceptions declared in a throws clause
import java.lang.reflect.Array;
import java.util.Arrays;
/*
* Copyright 2002-2007 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.
*/
//Revised from springframework
/**
* Miscellaneous object utility methods. Mainly for internal use within the
* framework; consider Jakarta"s Commons Lang for a more comprehensive suite
* of object utilities.
*
* @author Juergen Hoeller
* @author Keith Donald
* @author Rod Johnson
* @author Rob Harrop
* @author Alex Ruiz
* @since 19.03.2004
* @see org.apache.rumons.lang.ObjectUtils
*/
abstract class ObjectUtils {
private static final int INITIAL_HASH = 7;
private static final int MULTIPLIER = 31;
private static final String EMPTY_STRING = "";
private static final String NULL_STRING = "null";
private static final String ARRAY_START = "{";
private static final String ARRAY_END = "}";
private static final String EMPTY_ARRAY = ARRAY_START + ARRAY_END;
private static final String ARRAY_ELEMENT_SEPARATOR = ", ";
/**
* Check whether the given exception is compatible with the exceptions
* declared in a throws clause.
* @param ex the exception to checked
* @param declaredExceptions the exceptions declared in the throws clause
* @return whether the given exception is compatible
*/
public static boolean isCompatibleWithThrowsClause(Throwable ex, Class[] declaredExceptions) {
if (!isCheckedException(ex)) {
return true;
}
if (declaredExceptions != null) {
for (int i = 0; i < declaredExceptions.length; i++) {
if (declaredExceptions[i].isAssignableFrom(ex.getClass())) {
return true;
}
}
}
return false;
}
/**
* Return whether the given throwable is a checked exception:
* that is, neither a RuntimeException nor an Error.
* @param ex the throwable to check
* @return whether the throwable is a checked exception
* @see java.lang.Exception
* @see java.lang.RuntimeException
* @see java.lang.Error
*/
public static boolean isCheckedException(Throwable ex) {
return !(ex instanceof RuntimeException || ex instanceof Error);
}
}
Get StackTraceElement
//----------------------------------------------------------------------------//
// //
// C l a s s U t i l //
// //
// Copyright (C) Herve Bitteur 2000-2009. All rights reserved. //
// This software is released under the GNU General Public License. //
// Please contact users@audiveris.dev.java.net to report bugs & suggestions. //
//----------------------------------------------------------------------------//
//
/**
* Class <code>ClassUtil</code> provides utilities related to Class handling.
*
* @author Hervé Bitteur
* @version $Id: ClassUtil.java,v 1.3 2009/03/03 19:45:51 hbitteur Exp $
*/
public class ClassUtil
{
//~ Methods ----------------------------------------------------------------
//-----------------//
// getCallingFrame //
//-----------------//
/**
* Infer the calling frame, skipping the given classes if so provided.
* Code was derived from a private method found in the JDK Logger class
*
* @param skippedClasses the classes to skip
* @return the frame found, just before the skipped classes (or just before
* the caller of this method)
*/
public static StackTraceElement getCallingFrame (Class... skippedClasses)
{
// Get the current stack trace.
StackTraceElement[] stack = (new Throwable()).getStackTrace();
// Simple case, no classes to skip, just return the caller of the caller
if (skippedClasses.length == 0) {
return stack[2];
}
// More complex case, return the caller, just before the skipped classes
// First, search back to a method in the skipped classes, if any
int ix;
searchingForSkipped:
for (ix = 0; ix < stack.length; ix++) {
StackTraceElement frame = stack[ix];
String cname = frame.getClassName();
for (Class skipped : skippedClasses) {
if (cname.equals(skipped.getName())) {
break searchingForSkipped;
}
}
}
// Now search for the first frame before the skipped classes
searchingForNonSkipped:
for (; ix < stack.length; ix++) {
StackTraceElement frame = stack[ix];
String cname = frame.getClassName();
for (Class skipped : skippedClasses) {
if (cname.equals(skipped.getName())) {
continue searchingForNonSkipped;
}
}
// We"ve found the relevant frame.
return frame;
}
// We haven"t found a suitable frame
return null;
}
//--------//
// nameOf //
//--------//
/**
* Report the full name of the object class, without the package information
*
* @param obj the object to name
* @return the concatenation of (enclosing) simple names
*/
public static String nameOf (Object obj)
{
StringBuilder sb = new StringBuilder();
for (Class cl = obj.getClass(); cl != null;
cl = cl.getEnclosingClass()) {
if (sb.length() > 0) {
sb.insert(0, "-");
}
sb.insert(0, cl.getSimpleName());
}
return sb.toString();
}
}
Is Checked Exception
import java.lang.reflect.Array;
import java.util.Arrays;
/*
* Copyright 2002-2007 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.
*/
//Revised from springframework
/**
* Miscellaneous object utility methods. Mainly for internal use within the
* framework; consider Jakarta"s Commons Lang for a more comprehensive suite
* of object utilities.
*
* @author Juergen Hoeller
* @author Keith Donald
* @author Rod Johnson
* @author Rob Harrop
* @author Alex Ruiz
* @since 19.03.2004
* @see org.apache.rumons.lang.ObjectUtils
*/
abstract class ObjectUtils {
private static final int INITIAL_HASH = 7;
private static final int MULTIPLIER = 31;
private static final String EMPTY_STRING = "";
private static final String NULL_STRING = "null";
private static final String ARRAY_START = "{";
private static final String ARRAY_END = "}";
private static final String EMPTY_ARRAY = ARRAY_START + ARRAY_END;
private static final String ARRAY_ELEMENT_SEPARATOR = ", ";
/**
* Return whether the given throwable is a checked exception:
* that is, neither a RuntimeException nor an Error.
* @param ex the throwable to check
* @return whether the throwable is a checked exception
* @see java.lang.Exception
* @see java.lang.RuntimeException
* @see java.lang.Error
*/
public static boolean isCheckedException(Throwable ex) {
return !(ex instanceof RuntimeException || ex instanceof Error);
}
}
Utilities to use Java reflection without all of the checked exceptions
import java.lang.reflect.Array;
import java.lang.reflect.Method;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*
*/
/**
*
* ReflectUtils is a collection of utilities that allows you to leverage Java
* reflection without all of the checked exceptions (they are converted to
* runtime exceptions or return values). This class was created to get around
* the fact that the classes in java.lang.reflect.* turn every event into an
* exception, which is often cumbersome or inaccurate.
*
* @author Dan Jemiolo (danj)
*
*/
class ReflectUtils {
//
// The class loader used by this class
//
private static final ClassLoader _DEFAULT_CLASS_LOADER;
//
// The class loader used by this class
//
private static ReflectUtilHelper _helper = null;
static {
//
// load the default class loader (we need an instance to do so)
//
ReflectUtils instance = new ReflectUtils();
_DEFAULT_CLASS_LOADER = instance.getClass().getClassLoader();
_helper = null;
}
/**
*
* @param className
* The qualified name of the class to search for.
*
* @return True if the class is in the JVM"s classpath.
*
*/
public static boolean exists(String className) {
if (_helper != null)
return _helper.exists(className);
try {
Class.forName(className);
return true;
}
catch (ClassNotFoundException error) {
return false;
}
}
/**
*
* @param className
* The qualified name of the class to search for.
*
* @param classLoader
* The class loader to use in the class lookup.
*
* @return True if the class is in the JVM"s classpath.
*
*/
public static boolean exists(String className, ClassLoader classLoader) {
try {
classLoader.loadClass(className);
return true;
}
catch (ClassNotFoundException error) {
return false;
}
}
/**
*
* @param theClass
* A "normal", non-array type.
*
* @return The array version of the given type. For example, if you pass
* <em>String.class</em>, you get <em>String[].class</em>. If
* you pass <em>int.class</em>, you get <em>int[].class</em>. If
* the given class is already an array type, it is returned.
*
* @see #getClassFromArrayClass(Class)
*
*/
public static Class getArrayClassFromClass(Class theClass) {
if (theClass.isArray())
return theClass;
return Array.newInstance(theClass, 0).getClass();
}
/**
*
* This method calls getClass(Class, ClassLoader) with this class"
* ClassLoader.
*
* @param className
* The name of the class to load.
*
* @return The Class representing the given class name. A RuntimeException is
* thrown if the class is not found.
*
* @see #exists(String)
*
*/
public static Class getClass(String className) {
if (_helper != null) {
Class clazz = _helper.getClass(className);
if (clazz != null)
return clazz;
}
return getClass(className, _DEFAULT_CLASS_LOADER);
}
/**
*
* @param className
* The name of the class to load.
*
* @param classLoader
* The class loader to use for class lookup.
*
* @return The Class representing the given class name. A RuntimeException is
* thrown if the class is not found.
*
* @see #exists(String)
*
*/
public static Class getClass(String className, ClassLoader classLoader) {
try {
return classLoader.loadClass(className);
}
catch (Throwable error) {
//
// if it failed, try the default loader, if applicable
//
if (_helper != null) {
Class clzz = _helper.getClass(className);
if (clzz != null)
return clzz;
}
if (classLoader != _DEFAULT_CLASS_LOADER) {
try {
return _DEFAULT_CLASS_LOADER.loadClass(className);
}
catch (Throwable error2) {
//
// still failed - ignore this one and throw from the
// original error
//
}
}
Object[] filler = { className };
String message = "JavaClassNotFound";
throw new RuntimeException(message);
}
}
/**
*
* @param arrayClass
* The array version of a given type (<em>YourType[].class</em>)
*
* @return The non-array version of the given type. For example, if you pass
* <em>String[].class</em>, you get <em>String.class</em>. If
* you pass <em>int[].class</em>, you get <em>int.class</em>.
*
* @see #getArrayClassFromClass(Class)
*
*/
public static Class getClassFromArrayClass(Class arrayClass) {
if (arrayClass == null)
throw new NullPointerException("NullClass");
String name = arrayClass.getName();
//
// make sure it"s an array type
//
if (name.charAt(0) != "[") {
Object[] filler = { name };
throw new RuntimeException("NotArrayClass");
}
if (name.charAt(1) == "[") {
Object[] filler = { name };
throw new RuntimeException("NoMultiArrays");
}
//
// the char after the [ signifies the type of the array. these
// values are documented with java.lang.Class.getName()
//
char type = name.charAt(1);
switch (type) {
case "Z":
return boolean.class;
case "B":
return byte.class;
case "C":
return char.class;
case "D":
return double.class;
case "F":
return float.class;
case "I":
return int.class;
case "J":
return long.class;
case "S":
return short.class;
case "L":
return getClass(name.substring(2, name.length() - 1));
default:
Object[] filler = { name, new Character(type) };
String message = "UnsupportedType";
throw new RuntimeException(message);
}
}
public static Method getFirstMethod(Class theClass, String name) {
Method[] methods = theClass.getMethods();
for (int n = 0; n < methods.length; ++n)
if (name.equals(methods[n].getName()))
return methods[n];
return null;
}
/**
*
* @param theClass
*
* @return The full name of the Java package that contains the given class, or
* null if the class is not in a package.
*
*/
public static String getPackageName(Class theClass) {
//
// NOTE: Using the Package would be the easiest way to get this
// data, but the ClassLoader is not required to provide it. Thus,
// we use the more reliable method of parsing the class name.
//
//
// arrays will have the [ as part of their name - no good
//
if (theClass.isArray())
theClass = getClassFromArrayClass(theClass);
return getPackageName(theClass.getName());
}
/**
*
* @param qualifiedName
*
* @return The full name of the Java package that contains the given class, or
* null if the class is not in a package.
*
*/
public static String getPackageName(String qualifiedName) {
int dot = qualifiedName.lastIndexOf(".");
return dot >= 0 ? qualifiedName.substring(0, dot) : null;
}
/**
*
* @param type
*
* @return The unqualified (local) name of the class/interface. If the type is
* an array, the [] characters will be appended.
*
*/
public static String getShortName(Class type) {
if (type.isArray()) {
Class base = getClassFromArrayClass(type);
String name = getShortName(base);
return name + "[]";
}
return getShortName(type.getName());
}
/**
*
* @param qualifiedName
*
* @return The unqualified (local) name.
*
*/
public static String getShortName(String qualifiedName) {
int dot = qualifiedName.lastIndexOf(".");
return qualifiedName.substring(dot + 1);
}
/**
*
* Invokes the Class.newInstance() method on the given Class.
*
* @param theClass
* The type to instantiate.
*
* @return An object of the given type, created with the default constructor.
* A RuntimeException is thrown if the object could not be created.
*
*/
public static Object newInstance(Class theClass) {
try {
return theClass.newInstance();
}
catch (InstantiationException error) {
Object[] filler = { theClass };
String message = "ObjectCreationFailed";
throw new RuntimeException(message);
}
catch (IllegalAccessException error) {
Object[] filler = { theClass };
String message = "DefaultConstructorHidden";
throw new RuntimeException(message);
}
}
/**
*
* This is a convenience method that invokes newInstance(Class) with a Class
* object representing the given type.
*
* @see #getClass(String, ClassLoader)
* @see #newInstance(Class)
*
*/
public static Object newInstance(String className) {
return newInstance(getClass(className));
}
/**
*
* This is a convenience method that invokes newInstance(Class) with a Class
* object loaded by the given ClassLoader
*
* @see #getClass(String, ClassLoader)
* @see #newInstance(Class)
*
*/
public static Object newInstance(String className, ClassLoader classLoader) {
return newInstance(getClass(className, classLoader));
}
/**
*
* This is a setter for the helper object
*
*/
public static void setHelper(ReflectUtilHelper helper) {
_helper = helper;
}
}
/**
*
* @author Joel Hawkins
*
*/
interface ReflectUtilHelper {
boolean exists(String className);
Class getClass(String className);
}
whether method declares the given exception or one of its superclasses
/*
* 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.
*
* <p>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 method explicitly declares the given exception
* or one of its superclasses, which means that an exception of that type
* can be propagated as-is within a reflective invocation.
* @param method the declaring method
* @param exceptionType the exception to throw
* @return <code>true</code> if the exception can be thrown as-is;
* <code>false</code> if it needs to be wrapped
*/
public static boolean declaresException(Method method, Class exceptionType) {
Class[] declaredExceptions = method.getExceptionTypes();
for (int i = 0; i < declaredExceptions.length; i++) {
Class declaredException = declaredExceptions[i];
if (declaredException.isAssignableFrom(exceptionType)) {
return true;
}
}
return false;
}
}
