/* * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang; /** * {@code RuntimeException} is the superclass of those * exceptions that can be thrown during the normal operation of the * Java Virtual Machine. * * <p>{@code RuntimeException} and its subclasses are <em>unchecked * exceptions</em>. Unchecked exceptions do <em>not</em> need to be * declared in a method or constructor's {@code throws} clause if they * can be thrown by the execution of the method or constructor and * propagate outside the method or constructor boundary. * * @author Frank Yellin * @jls 11.2 Compile-Time Checking of Exceptions * @since JDK1.0 */ public class RuntimeException extends Exception { static final long serialVersionUID = -7034897190745766939L; /** Constructs a new runtime exception with {@code null} as its * detail message. The cause is not initialized, and may subsequently be * initialized by a call to {@link #initCause}. */ public RuntimeException() { super(); } /** Constructs a new runtime exception with the specified detail message. * The cause is not initialized, and may subsequently be initialized by a * call to {@link #initCause}. * * @param message the detail message. The detail message is saved for * later retrieval by the {@link #getMessage()} method. */ public RuntimeException(String message) { super(message); } /** * Constructs a new runtime exception with the specified detail message and * cause. <p>Note that the detail message associated with * {@code cause} is <i>not</i> automatically incorporated in * this runtime exception's detail message. * * @param message the detail message (which is saved for later retrieval * by the {@link #getMessage()} method). * @param cause the cause (which is saved for later retrieval by the * {@link #getCause()} method). (A <tt>null</tt> value is * permitted, and indicates that the cause is nonexistent or * unknown.) * @since 1.4 */ public RuntimeException(String message, Throwable cause) { super(message, cause); } /** Constructs a new runtime exception with the specified cause and a * detail message of <tt>(cause==null ? null : cause.toString())</tt> * (which typically contains the class and detail message of * <tt>cause</tt>). This constructor is useful for runtime exceptions * that are little more than wrappers for other throwables. * * @param cause the cause (which is saved for later retrieval by the * {@link #getCause()} method). (A <tt>null</tt> value is * permitted, and indicates that the cause is nonexistent or * unknown.) * @since 1.4 */ public RuntimeException(Throwable cause) { super(cause); } /** * Constructs a new runtime exception with the specified detail * message, cause, suppression enabled or disabled, and writable * stack trace enabled or disabled. * * @param message the detail message. * @param cause the cause. (A {@code null} value is permitted, * and indicates that the cause is nonexistent or unknown.) * @param enableSuppression whether or not suppression is enabled * or disabled * @param writableStackTrace whether or not the stack trace should * be writable * * @since 1.7 */ protected RuntimeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { super(message, cause, enableSuppression, writableStackTrace); } }
package com.todaytech.pwp.core.exception; public class SysException extends RuntimeException { public SysException() {} public SysException(String message) { super(message); } public SysException(String message, Throwable cause) { super(message, cause); } public SysException(Throwable cause) { super(cause); } }
package com.todaytech.pwp.core.util.beanutils; import com.todaytech.pwp.core.exception.SysException; import java.beans.PropertyDescriptor; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.ConvertUtils; import org.apache.commons.beanutils.DynaBean; import org.apache.commons.beanutils.DynaClass; import org.apache.commons.beanutils.DynaProperty; import org.apache.commons.beanutils.PropertyUtils; import org.apache.commons.beanutils.converters.BigDecimalConverter; public final class ReflectUtil { private ReflectUtil() {} public static String getFieldByName(Object orig, String fieldName, boolean pbIgnoreCase) { Field[] origFields = getDeclaredFieldsForClass(orig.getClass()); String fieldNameToFind = fieldName; if (pbIgnoreCase) { fieldNameToFind = fieldName.toUpperCase(); } Object objValue = null; for (int i = 0; i < origFields.length; i++) { Field origField = origFields[i]; String name = origField.getName(); if (pbIgnoreCase) { name = name.toUpperCase(); } if (name.equals(fieldNameToFind)) { origField.setAccessible(true); try { objValue = origField.get(orig); } catch (IllegalAccessException e) { throw new SysException(e); } origField.setAccessible(false); break; } } if (objValue != null) { return ConvertUtils.convert(objValue); } return null; } public static void setFieldByName(Object orig, String fieldName, String value, boolean pbIgnoreCase) { Field[] origFields = getDeclaredFieldsForClass(orig.getClass()); String fieldNameToFind = fieldName; if (pbIgnoreCase) { fieldNameToFind = fieldName.toUpperCase(); } boolean found = false; for (int i = 0; i < origFields.length; i++) { Field origField = origFields[i]; String name = origField.getName(); if (pbIgnoreCase) { name = name.toUpperCase(); } if (name.equals(fieldNameToFind)) { origField.setAccessible(true); try { origField.set(orig, value); } catch (IllegalAccessException e) { throw new SysException(e); } origField.setAccessible(false); found = true; break; } } if (!found) { throw new IllegalArgumentException("Field not found. fieldName ='" + fieldName + "'"); } } public static Object invokeMethod(Object owner, String methodName, Object... args) { Class ownerClass = owner.getClass(); Class[] argsClass = new Class[args.length]; int i = 0; for (int j = args.length; i < j; i++) { argsClass[i] = args[i].getClass(); } Method method = null; try { method = ownerClass.getMethod(methodName, argsClass); return method.invoke(owner, args); } catch (NoSuchMethodException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } catch (IllegalAccessException e) { throw new SysException(e); } } public static Object invokeStaticMethod(String className, String methodName, Object... args) { Class ownerClass = null; try { ownerClass = Class.forName(className); Class[] argsClass = new Class[args.length]; int i = 0; for (int j = args.length; i < j; i++) { argsClass[i] = args[i].getClass(); } Method method = ownerClass.getMethod(methodName, argsClass); return method.invoke(null, args); } catch (ClassNotFoundException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } catch (NoSuchMethodException e) { throw new SysException(e); } catch (IllegalAccessException e) { throw new SysException(e); } } public static Object newInstance(String className, Object... args) { Class newoneClass = null; try { newoneClass = Class.forName(className); Class[] argsClass = new Class[args.length]; int i = 0; for (int j = args.length; i < j; i++) { argsClass[i] = args[i].getClass(); } Constructor cons = newoneClass.getConstructor(argsClass); return cons.newInstance(args); } catch (ClassNotFoundException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } catch (NoSuchMethodException e) { throw new SysException(e); } catch (InstantiationException e) { throw new SysException(e); } catch (IllegalAccessException e) { throw new SysException(e); } } public static void copyNotNullProperties(Object objFrom, Object objTo) { copyAllPropertiesByName(objFrom, objTo, false); } public static void copyAllProperties(Object objFrom, Object objTo) { ConvertUtils.register(new DateConverter(), java.util.Date.class); ConvertUtils.register(new DateConverter(), java.sql.Date.class); ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class); copyAllPropertiesByName(objFrom, objTo, true); } private static void copyAllPropertiesByName(Object objFrom, Object objTo, boolean bIncludeNull) { if (bIncludeNull) { try { BeanUtils.copyProperties(objTo, objFrom); } catch (IllegalAccessException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } } else { copyProperties(objTo, objFrom, bIncludeNull); } } private static void copyProperties(Object dest, Object orig, boolean bIncludeNull) { if (dest == null) { throw new IllegalArgumentException("No destination bean specified"); } if (orig == null) { throw new IllegalArgumentException("No origin bean specified"); } if ((orig instanceof DynaBean)) { copyDynaBean(dest, (DynaBean)orig, bIncludeNull); } else if ((orig instanceof Map)) { copyBeanMap(dest, (Map)orig, bIncludeNull); } else { copyBeanArray(dest, orig, bIncludeNull); } } private static void copyBeanArray(Object dest, Object orig, boolean bIncludeNull) { PropertyDescriptor[] origDescriptors = PropertyUtils.getPropertyDescriptors(orig); for (int i = 0; i < origDescriptors.length; i++) { String name = origDescriptors[i].getName(); if (!"class".equals(name)) { if ((PropertyUtils.isReadable(orig, name)) && (PropertyUtils.isWriteable(dest, name))) try { Object value = PropertyUtils.getSimpleProperty(orig, name); if ((bIncludeNull) || (value != null)) { BeanUtils.copyProperty(dest, name, value); } } catch (NoSuchMethodException ex) { throw new SysException(ex); } catch (InvocationTargetException e) { throw new SysException(e); } catch (IllegalAccessException e) { throw new SysException(e); } } } } private static void copyBeanMap(Object dest, Map orig, boolean bIncludeNull) { Iterator names = orig.keySet().iterator(); while (names.hasNext()) { String name = (String)names.next(); if (PropertyUtils.isWriteable(dest, name)) { Object value = orig.get(name); if ((bIncludeNull) || (value != null)) { try { BeanUtils.copyProperty(dest, name, value); } catch (IllegalAccessException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } } } } } private static void copyDynaBean(Object dest, DynaBean orig, boolean bIncludeNull) { DynaProperty[] origDescriptors = orig.getDynaClass().getDynaProperties(); for (int i = 0; i < origDescriptors.length; i++) { String name = origDescriptors[i].getName(); if (PropertyUtils.isWriteable(dest, name)) { Object value = orig.get(name); if ((bIncludeNull) || (value != null)) { try { BeanUtils.copyProperty(dest, name, value); } catch (IllegalAccessException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } } } } } public static void setPropertyByName(Object objTo, String sFieldName, Object value, boolean bIgnoreCase) { if (bIgnoreCase) { sFieldName = findPropertyName(objTo.getClass(), sFieldName); } try { BeanUtils.copyProperty(objTo, sFieldName, value); } catch (IllegalAccessException e) { throw new SysException(e); } catch (InvocationTargetException e) { throw new SysException(e); } } private static String findPropertyName(Class objClz, String sFieldName) { Field[] fields = getDeclaredFields(objClz); String sToRet = null; for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String fieldName = field.getName(); if (fieldName.equalsIgnoreCase(sFieldName)) { sToRet = fieldName; break; } } return sToRet; } private static Field[] getDeclaredFields(Class objClz) { ArrayList fields = new ArrayList(); Class curClz = objClz; Collections.addAll(fields, curClz.getDeclaredFields()); while (curClz.getSuperclass() != Object.class) { curClz = curClz.getSuperclass(); Collections.addAll(fields, curClz.getDeclaredFields()); } return (Field[])fields.toArray(new Field[fields.size()]); } private static Field[] getDeclaredFieldsForClass(Class clz) { if (clz == Object.class) { return new Field[0]; } ArrayList<Field> fieldlist = new ArrayList(); fieldlist.addAll(Arrays.asList(clz.getDeclaredFields())); Field[] fieldsOfSuperClz = getDeclaredFieldsForClass(clz.getSuperclass()); if (fieldsOfSuperClz != null) { fieldlist.addAll(Arrays.asList(fieldsOfSuperClz)); } return (Field[])fieldlist.toArray(new Field[0]); } private static Map<String, Object> describeByFields(Object obj, boolean bGetSuperClassToo) { if (obj == null) { throw new IllegalArgumentException("No obj specified"); } Class classToView = obj.getClass(); return describeByFields(obj, classToView, bGetSuperClassToo); } private static Map<String, Object> describeByFields(Object obj, Class pClassToView, boolean bGetSuperClassToo) { Map<String, Object> toReturn = new HashMap(); if (bGetSuperClassToo) { Class superclz = pClassToView.getSuperclass(); if (superclz != Object.class) { toReturn.putAll(describeByFields(obj, superclz, bGetSuperClassToo)); } } Field[] origFields = pClassToView.getDeclaredFields(); for (Field origField : origFields) { String name = origField.getName(); origField.setAccessible(true); try { toReturn.put(name, origField.get(obj)); } catch (IllegalAccessException e) { throw new SysException(e); } } return toReturn; } public static <T> Class<T> getGenericTypeArgument(Class clazz) { return getGenericTypeArgument(clazz, 0); } public static Class getGenericTypeArgument(Class clazz, int index) { Type genType = clazz.getGenericSuperclass(); if (!(genType instanceof ParameterizedType)) { return Object.class; } Type[] params = ((ParameterizedType)genType).getActualTypeArguments(); if ((index >= params.length) || (index < 0)) { return Object.class; } if (!(params[index] instanceof Class)) { return Object.class; } return (Class)params[index]; } }