• Java对象之间的深度复制拷贝




    /*
     * 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];
       }
     }
    
    
  • 相关阅读:
    变量和基本数据类型,深浅拷贝问题
    计算机系统与编程语言分类
    关于计算机硬件的基本知识
    Python学习之路——函数
    Python学习之路——Day06 元组
    day--07
    数据类型——可变不可变类型
    数字类型
    流程控制——while循环
    流程控制——if判断
  • 原文地址:https://www.cnblogs.com/ios9/p/9335023.html
Copyright © 2020-2023  润新知