一.传统简单java类
　　简单的java类主要是由属性所组成,并且提供有相应的setter以及getter的处理方法,同时简单java类最大的特征就是通过对象保存相应的类的属性内容,但是如果使用传统的简单java类的开发,那么也会面临非常麻烦的困难:

  1.  class Emp{
  2.      private String ename;
  3.      private String job;
  4.  
  5.      public void setEname(String ename) {
  6.          this.ename = ename;
  7.      }
  8.  
  9.      public void setJob(String job) {
  10.          this.job = job;
  11.      }
  12.  
  13.      public String getEname() {
  14.          return ename;
  15.      }
  16.  
  17.      public String getJob() {
  18.          return job;
  19.      }
  20.  }

--按照传统的做法,首先应该实例化Emp对象,而后通过实例化对象进行setter方法的调用来设置属性的内容:

  1.  class Emp{
  2.      private String ename;
  3.      private String job;
  4.  
  5.      public void setEname(String ename) {
  6.          this.ename = ename;
  7.      }
  8.  
  9.      public void setJob(String job) {
  10.          this.job = job;
  11.      }
  12.  
  13.      public String getEname() {
  14.          return ename;
  15.      }
  16.  
  17.      public String getJob() {
  18.          return job;
  19.      }
  20.  }
  21.  public class ReflectAndJavaClassDemo {
  22.      public static void main(String[] args) {
  23.          Emp emp = new Emp();
  24.          emp.setEname("Mike");
  25.          emp.setJob("code java");
  26.          System.out.println("姓名: " + emp.getEname() + " 职位: " + emp.getJob());
  27.      }
  28.  }

--在整个进行Emp对象实例化并设置数据的操作过程之中,设置数据的部分是为麻烦的,可以想象如果现在Emp类中提供有50个属性,那么对于整个程序而言,将成为一大堆的setter方法的调用,即使使用构造方法赋值,也会造成很多的麻烦.或者咱们再进一步说明,在一个开发之中,简单java类的个数是非常多的,那么如果所有的简单java类都牵扯到属性赋值的问题时,我们代码的重复率会非常的高.按照传统直观的编程方式所带来的问题就是代码会存在大量的重复操作,如果要想解决对象的重复处理操作,那么唯一的解决方案就是反射机制,反射机制最大的特征就是可以根据其自身的特点(Object类直接操作属性和方法,实现相同功能类的重复操作的抽象处理).

二.属性自动设置解决方案:
　　经过了分析之后已经确认了当前简单java类操作的问题所在,而对于开发者而言就需要想办法通过一种解决方案来实现属性内容的自动设置,那么这个时候的设置强烈建议采用字符串的形式来描述对应的类型:
--1.在进行程序开发的时候我们可以知道String字符串可以描述的类型由很多,并且也可以由开发者自行定义String字符串的结构,我们采用"内容|属性:内容|"的形式来为简单java类中的属性进行初始化;
--2.类设计的基本结构,应该由一个专门的工具类(ClassInstanceFactory类)负责所有的反射处理,即接收反射对象,同时可以获取指定类的实例化对象;
--3.设计的基本结构

  1.  package 反射.反射与java类;
  2.  
  3.  /**
  4.   * @author : S K Y
  5.   * @version :0.0.1
  6.   */
  7.  class Emp {
  8.      private String ename;
  9.      private String job;
  10.  
  11.      public void setEname(String ename) {
  12.          this.ename = ename;
  13.      }
  14.  
  15.      public void setJob(String job) {
  16.          this.job = job;
  17.      }
  18.  
  19.      public String getEname() {
  20.          return ename;
  21.      }
  22.  
  23.      public String getJob() {
  24.          return job;
  25.      }
  26.  }
  27.  
  28.  class ClassInstanceFactory {
  29.      private ClassInstanceFactory() {
  30.      }        //构造方法私有化
  31.  
  32.      /**
  33.       * 实例化对象创建的方法,该对象可以根据传入的字符串的结构"内容|属性:内容|"进行处理
  34.       *
  35.       * @param tClass 要进行反射实例化的Class类对象,有Class就可以反射实例化对象
  36.       * @param value  要设置给对象的属性内容
  37.       * @return  一个已经配置完内容的简单java类对象
  38.       */
  39.      public static <T> T create(Class<T> tClass, String value) {
  40.          return null;
  41.      }
  42.  
  43.  }
  44.  
  45.  public class ReflectAndJavaClassDemo {
  46.      public static void main(String[] args) {
  47.          //在Emp类中,存在两个String类型的成员变量ename,job,以及其相关的getter,setter
  48.          String value = "ename:Mike|job:code java";
  49.          Emp emp = ClassInstanceFactory.create(Emp.class, value);      //产生实例化对象
  50.      }
  51.  }

--这样在当前的开发之中,所需要留给用户完善的就是ClassInstanceFactory.create()方法的具体实现

三.单级属性配置
　　对于此时的Emp类型里面会发现所给出的数据类型都没有其他的引用关联了,只是描述了Emp本类的对象,这样的设置我们称他为单级属性配置,所以此时应该需要处理两件事情:
--1.需要通过反射进行指定类对象的实例化处理;
--2.进行内容的设置(Field属性类型,方法名称,要设置的内容)

  1.  package 反射.反射与java类;
  2.  
  3.  import java.lang.reflect.Field;
  4.  import java.lang.reflect.Method;
  5.  
  6.  /**
  7.   * @author : S K Y
  8.   * @version :0.0.1
  9.   */
  10.  class Emp {
  11.      private String ename;
  12.      private String job;
  13.  
  14.      public void setEname(String ename) {
  15.          this.ename = ename;
  16.      }
  17.  
  18.      public void setJob(String job) {
  19.          this.job = job;
  20.      }
  21.  
  22.      public String getEname() {
  23.          return ename;
  24.      }
  25.  
  26.      public String getJob() {
  27.          return job;
  28.      }
  29.  }
  30.  
  31.  class ClassInstanceFactory {
  32.      private ClassInstanceFactory() {
  33.      }        //构造方法私有化
  34.  
  35.      /**
  36.       * 实例化对象创建的方法,该对象可以根据传入的字符串的结构"内容|属性:内容|"进行处理
  37.       *
  38.       * @param tClass 要进行反射实例化的Class类对象,有Class就可以反射实例化对象
  39.       * @param value  要设置给对象的属性内容
  40.       * @return 一个已经配置完内容的简单java类对象
  41.       */
  42.      public static <T> T create(Class<T> tClass, String value) {
  43.          //如果想采用反射进行简单Java类对象的属性设置的时候,类中必须要有无参构造
  44.          try {
  45.              Object o = tClass.newInstance();
  46.              BeanUtils.setValue(o, value);        //通过反射设置属性
  47.              return tClass.cast(o);    //获取对象
  48.          } catch (Exception e) {
  49.              e.printStackTrace();        //此时如果出现异常,将异常抛出也没有多大作用
  50.              return null;
  51.          }
  52.  
  53.      }
  54.  
  55.  }
  56.  
  57.  class BeanUtils {    //进行Bean处理的工具类
  58.      private BeanUtils() {
  59.      }
  60.  
  61.      /**
  62.       * 实现指定对象的属性设置
  63.       *
  64.       * @param obj   要进行反射操作的实例化对象
  65.       * @param value 包含有指定内容的字符串
  66.       */
  67.      public static void setValue(Object obj, String value) {
  68.          String results[] = value.split("\\|");//按照竖线进行每一组属性的拆分
  69.          for (int i = 0; i < results.length; i++) {  //循环设置属性内容
  70.              String attval[] = results[i].split(":");   //获取属性名称及内容
  71.              try {
  72.                  Field field = obj.getClass().getDeclaredField(attval[0]);
  73.                  Method setMethod = obj.getClass()
  74.                          .getDeclaredMethod("set" + StringUtils.initcap(attval[0]), field.getType());
  75.                  setMethod.invoke(obj,attval[1]);        //使用setter方法进行内容的赋值
  76.              } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
  77.              }
  78.  
  79.          }
  80.      }
  81.  }
  82.  
  83.  class StringUtils {
  84.      private StringUtils() {
  85.      }
  86.  
  87.      public static String initcap(String str) {
  88.          if (str == null || str.equals("")) {
  89.              return str;
  90.          }
  91.          if (str.length() == 1) {
  92.              return str.toUpperCase();
  93.          } else {
  94.              return str.substring(0, 1).toUpperCase() + str.substring(1);
  95.          }
  96.      }
  97.  
  98.  }
  99.  
  100.  public class ReflectAndJavaClassDemo {
  101.      public static void main(String[] args) {
  102.          //在Emp类中,存在两个String类型的成员变量ename,job,以及其相关的getter,setter
  103.          String value = "ename:Mike|job:code java";
  104.          Emp emp = ClassInstanceFactory.create(Emp.class, value);      //产生实例化对象
  105.          System.out.println("姓名: " + emp.getEname() + " 职位: " + emp.getJob());
  106.      }
  107.  }

--运行结果

  1. 姓名: Mike 职位: code java
  2.  
  3. Process finished with exit code 0

--ClassInstanceFactory负责实例化对象并且调用BeanUtils类实现属性代码的设置,此时即便类中的属性再多,那么也可以轻松的实现setter的调用,轻松实现类对象实例化处理

四.设置多种数据类型
　　虽然上述代码可以实现对于属性的配置,但是我们仍然需要考虑一个实际的情况,当前所给定的数据类型只能是String,但是在实际的开发之中,面对简单java类中的属性类型一般的可选为:Long(long),Integer(int),Double(double),String,Date(日期,日期时间),所以这个时候对于当前的程序代码就必须做出修改,要求可以实现各种数据类型的配置.
--既然要求可以实现不同类型的内容设置,并且BeanUtils类主要是完成属性赋值处理的,那么就可以在这个类之中追加有一些列的处理方法:

  1.  package 反射.反射与java类;
  2.  
  3.  import java.lang.reflect.Field;
  4.  import java.lang.reflect.Method;
  5.  import java.text.ParseException;
  6.  import java.text.SimpleDateFormat;
  7.  import java.util.Date;
  8.  
  9.  /**
  10.   * @author : S K Y
  11.   * @version :0.0.1
  12.   */
  13.  class Emp {
  14.      private long empo;
  15.      private String ename;
  16.      private String job;
  17.      private double salary;
  18.      private Date hireDate;
  19.  
  20.      public void setEname(String ename) {
  21.          this.ename = ename;
  22.      }
  23.  
  24.      public void setJob(String job) {
  25.          this.job = job;
  26.      }
  27.  
  28.      public String getEname() {
  29.          return ename;
  30.      }
  31.  
  32.      public String getJob() {
  33.          return job;
  34.      }
  35.  
  36.      public long getEmpo() {
  37.          return empo;
  38.      }
  39.  
  40.      public void setEmpo(long empo) {
  41.          this.empo = empo;
  42.      }
  43.  
  44.      public double getSalary() {
  45.          return salary;
  46.      }
  47.  
  48.      public void setSalary(double salary) {
  49.          this.salary = salary;
  50.      }
  51.  
  52.      public Date getHireDate() {
  53.          return hireDate;
  54.      }
  55.  
  56.      public void setHireDate(Date hireDate) {
  57.          this.hireDate = hireDate;
  58.      }
  59.  
  60.      @Override
  61.      public String toString() {
  62.          return "Emp{" +
  63.                  "empo=" + empo +
  64.                  ", ename='" + ename + '\'' +
  65.                  ", job='" + job + '\'' +
  66.                  ", salary=" + salary +
  67.                  ", hireDate=" + hireDate +
  68.                  '}';
  69.      }
  70.  }
  71.  
  72.  class ClassInstanceFactory {
  73.      private ClassInstanceFactory() {
  74.      }        //构造方法私有化
  75.  
  76.      /**
  77.       * 实例化对象创建的方法,该对象可以根据传入的字符串的结构"内容|属性:内容|"进行处理
  78.       *
  79.       * @param tClass 要进行反射实例化的Class类对象,有Class就可以反射实例化对象
  80.       * @param value  要设置给对象的属性内容
  81.       * @return 一个已经配置完内容的简单java类对象
  82.       */
  83.      public static <T> T create(Class<T> tClass, String value) {
  84.          //如果想采用反射进行简单Java类对象的属性设置的时候,类中必须要有无参构造
  85.          try {
  86.              Object o = tClass.newInstance();
  87.              BeanUtils.setValue(o, value);        //通过反射设置属性
  88.              return tClass.cast(o);    //获取对象
  89.          } catch (Exception e) {
  90.              e.printStackTrace();        //此时如果出现异常,将异常抛出也没有多大作用
  91.              return null;
  92.          }
  93.  
  94.      }
  95.  
  96.  }
  97.  
  98.  class BeanUtils {    //进行Bean处理的工具类
  99.      private BeanUtils() {
  100.      }
  101.  
  102.      /**
  103.       * 实现指定对象的属性设置
  104.       *
  105.       * @param obj   要进行反射操作的实例化对象
  106.       * @param value 包含有指定内容的字符串
  107.       */
  108.      public static void setValue(Object obj, String value) {
  109.          String results[] = value.split("\\|");//按照竖线进行每一组属性的拆分
  110.          for (int i = 0; i < results.length; i++) {  //循环设置属性内容
  111.              String attval[] = results[i].split(":");   //获取属性名称及内容
  112.              try {
  113.                  Field field = obj.getClass().getDeclaredField(attval[0]);
  114.                  Method setMethod = obj.getClass()
  115.                          .getDeclaredMethod("set" + StringUtils.initcap(attval[0]), field.getType());
  116.                  Object val = BeanUtils.getAttributeValue(field.getType().getName(), attval[1]);
  117.                  setMethod.invoke(obj, val);        //使用setter方法进行内容的赋值
  118.              } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
  119.              }
  120.  
  121.          }
  122.      }
  123.  
  124.      /**
  125.       * 实现属性类型转化处理
  126.       *
  127.       * @param type  属性类型,通过Field获取
  128.       * @param value 属性的内容,传入的都是字符串,需要将其转化为指定的类型
  129.       * @return 转化后的数据
  130.       */
  131.      private static Object getAttributeValue(String type, String value) {
  132.          if ("long".equals(type) || "java.lang.Long".equals(type)) {   //长整型
  133.              return Long.parseLong(value);
  134.          } else if ("int".equals(type) || "java.lang.Integer".equals(type)) {
  135.              return Integer.valueOf(value);
  136.          } else if ("double".equals(type) || "java.lang.Double".equals(type)) {
  137.              return Double.valueOf(value);
  138.          } else if ("java.util.Date".equals(type)) {
  139.              SimpleDateFormat dateFormat = null;
  140.              if (value.matches("\\d{4}-\\d{2}-\\d{2}")) { //日期类型
  141.                  dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  142.              } else if (value.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {   //日期时间
  143.                  dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  144.              } else {
  145.                  return new Date();  //当前日期
  146.              }
  147.              try {
  148.                  return dateFormat.parse(value);
  149.              } catch (ParseException e) {
  150.                  return new Date();
  151.              }
  152.          } else {
  153.              return value;
  154.          }
  155.      }
  156.  }
  157.  
  158.  class StringUtils {
  159.      private StringUtils() {
  160.      }
  161.  
  162.      public static String initcap(String str) {
  163.          if (str == null || str.equals("")) {
  164.              return str;
  165.          }
  166.          if (str.length() == 1) {
  167.              return str.toUpperCase();
  168.          } else {
  169.              return str.substring(0, 1).toUpperCase() + str.substring(1);
  170.          }
  171.      }
  172.  
  173.  }
  174.  
  175.  public class ReflectAndJavaClassDemo {
  176.      public static void main(String[] args) {
  177.          //在Emp类中,存在两个String类型的成员变量ename,job,以及其相关的getter,setter
  178.          String value = "ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12";
  179.          Emp emp = ClassInstanceFactory.create(Emp.class, value);      //产生实例化对象
  180.          System.out.println(emp);
  181.      }
  182.  }

--运行结果

  1. Emp{empo=1258, ename='Mike', job='code java', salary=750.0, hireDate=Tue Dec 12 00:00:00 CST 1911}
  2.  
  3. Process finished with exit code 0

--此时只是列举出了常用的几种数据类型,当然如果想将其作为一个产品推广,那就必须要考虑所有可能出现的数据类型,同时可能出现的日期格式也需要考虑

五.级联对象实例化
　　如果说现在给定的类对象之中存在有其他的引用的级联关系的情况下,成为多级设置,例如:一个雇员属于一个部门,一个部门属于一个公司,所以这个时候对于简单Java类的定义如下:

  1.  class Company {
  2.      private String name;
  3.      private Date createDate;
  4.  
  5.      public String getName() {
  6.          return name;
  7.      }
  8.  
  9.      public void setName(String name) {
  10.          this.name = name;
  11.      }
  12.  
  13.      public Date getCreateDate() {
  14.          return createDate;
  15.      }
  16.  
  17.      public void setCreateDate(Date createDate) {
  18.          this.createDate = createDate;
  19.      }
  20.  }
  21.  
  22.  class Dept {
  23.      private String dname;
  24.      private String loc;
  25.      private Company company;
  26.  
  27.      public String getDname() {
  28.          return dname;
  29.      }
  30.  
  31.      public void setDname(String dname) {
  32.          this.dname = dname;
  33.      }
  34.  
  35.      public String getLoc() {
  36.          return loc;
  37.      }
  38.  
  39.      public void setLoc(String loc) {
  40.          this.loc = loc;
  41.      }
  42.  
  43.      public Company getCompany() {
  44.          return company;
  45.      }
  46.  
  47.      public void setCompany(Company company) {
  48.          this.company = company;
  49.      }
  50.  }
  51.  
  52.  class Emp {
  53.      private long empo;
  54.      private String ename;
  55.      private String job;
  56.      private double salary;
  57.      private Date hireDate;
  58.      private Dept dept;
  59.  
  60.      public Dept getDept() {
  61.          return dept;
  62.      }
  63.  
  64.      public void setDept(Dept dept) {
  65.          this.dept = dept;
  66.      }
  67.  
  68.      public void setEname(String ename) {
  69.          this.ename = ename;
  70.      }
  71.  
  72.      public void setJob(String job) {
  73.          this.job = job;
  74.      }
  75.  
  76.      public String getEname() {
  77.          return ename;
  78.      }
  79.  
  80.      public String getJob() {
  81.          return job;
  82.      }
  83.  
  84.      public long getEmpo() {
  85.          return empo;
  86.      }
  87.  
  88.      public void setEmpo(long empo) {
  89.          this.empo = empo;
  90.      }
  91.  
  92.      public double getSalary() {
  93.          return salary;
  94.      }
  95.  
  96.      public void setSalary(double salary) {
  97.          this.salary = salary;
  98.      }
  99.  
  100.      public Date getHireDate() {
  101.          return hireDate;
  102.      }
  103.  
  104.      public void setHireDate(Date hireDate) {
  105.          this.hireDate = hireDate;
  106.      }
  107.  
  108.      @Override
  109.      public String toString() {
  110.          return "Emp{" +
  111.                  "empo=" + empo +
  112.                  ", ename='" + ename + '\'' +
  113.                  ", job='" + job + '\'' +
  114.                  ", salary=" + salary +
  115.                  ", hireDate=" + hireDate +
  116.                  '}';
  117.      }
  118.  }

--如果要通过Emp进行操作,则应该按照使用"."作为级联关系的处理,例: dept.dname,dept.loc,company.name,company.createDate
　　dept.dname:财务部　　Emp类实例对象.getDept().setDname("财务部");
--考虑可以通过级联的配置,实现类中属性的实例化: String value ="ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12|dept.dname:财务部" +"|dept.company.name:一个写java的公司";现在的属性存在多级关系,那么对于多级的关系就必须与单级的配置区分开

  1.  package 反射.反射与java类;
  2.  
  3.  import java.lang.reflect.Field;
  4.  import java.lang.reflect.Method;
  5.  import java.text.ParseException;
  6.  import java.text.SimpleDateFormat;
  7.  import java.util.Arrays;
  8.  import java.util.Date;
  9.  
  10.  /**
  11.   * @author : S K Y
  12.   * @version :0.0.1
  13.   */
  14.  class Company {
  15.      private String name;
  16.      private Date createDate;
  17.  
  18.      public String getName() {
  19.          return name;
  20.      }
  21.  
  22.      public void setName(String name) {
  23.          this.name = name;
  24.      }
  25.  
  26.      public Date getCreateDate() {
  27.          return createDate;
  28.      }
  29.  
  30.      public void setCreateDate(Date createDate) {
  31.          this.createDate = createDate;
  32.      }
  33.  }
  34.  
  35.  class Dept {
  36.      private String dname;
  37.      private String loc;
  38.      private Company company;
  39.  
  40.      public String getDname() {
  41.          return dname;
  42.      }
  43.  
  44.      public void setDname(String dname) {
  45.          this.dname = dname;
  46.      }
  47.  
  48.      public String getLoc() {
  49.          return loc;
  50.      }
  51.  
  52.      public void setLoc(String loc) {
  53.          this.loc = loc;
  54.      }
  55.  
  56.      public Company getCompany() {
  57.          return company;
  58.      }
  59.  
  60.      public void setCompany(Company company) {
  61.          this.company = company;
  62.      }
  63.  }
  64.  
  65.  class Emp {
  66.      private long empo;
  67.      private String ename;
  68.      private String job;
  69.      private double salary;
  70.      private Date hireDate;
  71.      private Dept dept;
  72.  
  73.      public Dept getDept() {
  74.          return dept;
  75.      }
  76.  
  77.      public void setDept(Dept dept) {
  78.          this.dept = dept;
  79.      }
  80.  
  81.      public void setEname(String ename) {
  82.          this.ename = ename;
  83.      }
  84.  
  85.      public void setJob(String job) {
  86.          this.job = job;
  87.      }
  88.  
  89.      public String getEname() {
  90.          return ename;
  91.      }
  92.  
  93.      public String getJob() {
  94.          return job;
  95.      }
  96.  
  97.      public long getEmpo() {
  98.          return empo;
  99.      }
  100.  
  101.      public void setEmpo(long empo) {
  102.          this.empo = empo;
  103.      }
  104.  
  105.      public double getSalary() {
  106.          return salary;
  107.      }
  108.  
  109.      public void setSalary(double salary) {
  110.          this.salary = salary;
  111.      }
  112.  
  113.      public Date getHireDate() {
  114.          return hireDate;
  115.      }
  116.  
  117.      public void setHireDate(Date hireDate) {
  118.          this.hireDate = hireDate;
  119.      }
  120.  
  121.      @Override
  122.      public String toString() {
  123.          return "Emp{" +
  124.                  "empo=" + empo +
  125.                  ", ename='" + ename + '\'' +
  126.                  ", job='" + job + '\'' +
  127.                  ", salary=" + salary +
  128.                  ", hireDate=" + hireDate +
  129.                  '}';
  130.      }
  131.  }
  132.  
  133.  class ClassInstanceFactory {
  134.      private ClassInstanceFactory() {
  135.      }        //构造方法私有化
  136.  
  137.      /**
  138.       * 实例化对象创建的方法,该对象可以根据传入的字符串的结构"内容|属性:内容|"进行处理
  139.       *
  140.       * @param tClass 要进行反射实例化的Class类对象,有Class就可以反射实例化对象
  141.       * @param value  要设置给对象的属性内容
  142.       * @return 一个已经配置完内容的简单java类对象
  143.       */
  144.      public static <T> T create(Class<T> tClass, String value) {
  145.          //如果想采用反射进行简单Java类对象的属性设置的时候,类中必须要有无参构造
  146.          try {
  147.              Object o = tClass.newInstance();
  148.              BeanUtils.setValue(o, value);        //通过反射设置属性
  149.              return tClass.cast(o);    //获取对象
  150.          } catch (Exception e) {
  151.              e.printStackTrace();        //此时如果出现异常,将异常抛出也没有多大作用
  152.              return null;
  153.          }
  154.  
  155.      }
  156.  
  157.  }
  158.  
  159.  class BeanUtils {    //进行Bean处理的工具类
  160.      private BeanUtils() {
  161.      }
  162.  
  163.      /**
  164.       * 实现指定对象的属性设置
  165.       *
  166.       * @param obj   要进行反射操作的实例化对象
  167.       * @param value 包含有指定内容的字符串
  168.       */
  169.      public static void setValue(Object obj, String value) {
  170.          String results[] = value.split("\\|");//按照竖线进行每一组属性的拆分
  171.          for (int i = 0; i < results.length; i++) {  //循环设置属性内容
  172.              String attval[] = results[i].split(":");   //获取属性名称及内容
  173.              try {
  174.                  Object currentObject = obj;
  175.                  if (attval[0].contains(".")) {        //这是多级配置
  176.                      String temp[] = attval[0].split("\\.");
  177.                      //最后一位肯定是指定类中的属性名称,因此不在实例化处理的范畴之内
  178.                      for (int j = 0; j < temp.length - 1; j++) {  //实例化
  179.                          //调用相应的getter方法,如果getter方法返回了空表示该对象为实例化
  180.                          Method getMethod = currentObject.getClass().getDeclaredMethod(
  181.                                  "get" + StringUtils.initcap(temp[j]));
  182.                          if (getMethod.invoke(currentObject) == null) {  //该对象现在并没有被实例化
  183.                              Field field = currentObject.getClass().getDeclaredField(temp[j]);
  184.                              Method method = currentObject.getClass().getDeclaredMethod("set" + StringUtils.initcap(temp[j]), field.getType());
  185.                              Object newObject = field.getType().getDeclaredConstructor().newInstance();
  186.                              method.invoke(currentObject, newObject);
  187.                              currentObject = newObject;
  188.                          } else {
  189.                              currentObject = getMethod.invoke(currentObject);
  190.                          }
  191.                      }
  192.                  } else {
  193.                      Field field = obj.getClass().getDeclaredField(attval[0]);
  194.                      Method setMethod = obj.getClass()
  195.                              .getDeclaredMethod("set" + StringUtils.initcap(attval[0]), field.getType());
  196.                      Object val = BeanUtils.getAttributeValue(field.getType().getName(), attval[1]);
  197.                      setMethod.invoke(obj, val);        //使用setter方法进行内容的赋值
  198.                  }
  199.              } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
  200.              }
  201.  
  202.          }
  203.      }
  204.  
  205.      /**
  206.       * 实现属性类型转化处理
  207.       *
  208.       * @param type  属性类型,通过Field获取
  209.       * @param value 属性的内容,传入的都是字符串,需要将其转化为指定的类型
  210.       * @return 转化后的数据
  211.       */
  212.      private static Object getAttributeValue(String type, String value) {
  213.          if ("long".equals(type) || "java.lang.Long".equals(type)) {   //长整型
  214.              return Long.parseLong(value);
  215.          } else if ("int".equals(type) || "java.lang.Integer".equals(type)) {
  216.              return Integer.valueOf(value);
  217.          } else if ("double".equals(type) || "java.lang.Double".equals(type)) {
  218.              return Double.valueOf(value);
  219.          } else if ("java.util.Date".equals(type)) {
  220.              SimpleDateFormat dateFormat = null;
  221.              if (value.matches("\\d{4}-\\d{2}-\\d{2}")) { //日期类型
  222.                  dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  223.              } else if (value.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {   //日期时间
  224.                  dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  225.              } else {
  226.                  return new Date();  //当前日期
  227.              }
  228.              try {
  229.                  return dateFormat.parse(value);
  230.              } catch (ParseException e) {
  231.                  return new Date();
  232.              }
  233.          } else {
  234.              return value;
  235.          }
  236.      }
  237.  }
  238.  
  239.  class StringUtils {
  240.      private StringUtils() {
  241.      }
  242.  
  243.      public static String initcap(String str) {
  244.          if (str == null || str.equals("")) {
  245.              return str;
  246.          }
  247.          if (str.length() == 1) {
  248.              return str.toUpperCase();
  249.          } else {
  250.              return str.substring(0, 1).toUpperCase() + str.substring(1);
  251.          }
  252.      }
  253.  
  254.  }
  255.  
  256.  public class ReflectAndJavaClassDemo {
  257.      public static void main(String[] args) {
  258.          //在Emp类中,存在两个String类型的成员变量ename,job,以及其相关的getter,setter
  259.          String value =
  260.                  "ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12|dept.dname:财务部" +
  261.                          "|dept.company.name:一个写java的公司";
  262.          Emp emp = ClassInstanceFactory.create(Emp.class, value);      //产生实例化对象
  263.          System.out.println(emp.getDept().getCompany());
  264.      }
  265.  }

--运行结果

  1. 反射.反射与java类.Company@610455d6
  2.  
  3. Process finished with exit code 0

--这些自动的级联配置的实例化处理操作,在进行项目的编写之中将有很大的用处

六.级联属性设置
　　现在已经成功实现级联对象的实例化处理,那么我们应该考虑级联的属性设置了.在之前考虑级联对象实例化处理的时候,循环进行实例化处理时数组的最后一位是没有被进行实例化的,因为数组的最后一位就是我们要操作的成员,按照之前的方式利用对象进行setter方法的调用:

  1.  package 反射.反射与java类;
  2.  
  3.  import java.lang.reflect.Field;
  4.  import java.lang.reflect.Method;
  5.  import java.text.ParseException;
  6.  import java.text.SimpleDateFormat;
  7.  import java.util.Date;
  8.  
  9.  /**
  10.   * @author : S K Y
  11.   * @version :0.0.1
  12.   */
  13.  class Company {
  14.      private String name;
  15.      private Date createDate;
  16.  
  17.      public String getName() {
  18.          return name;
  19.      }
  20.  
  21.      public void setName(String name) {
  22.          this.name = name;
  23.      }
  24.  
  25.      public Date getCreateDate() {
  26.          return createDate;
  27.      }
  28.  
  29.      public void setCreateDate(Date createDate) {
  30.          this.createDate = createDate;
  31.      }
  32.  
  33.      @Override
  34.      public String toString() {
  35.          return "Company{" +
  36.                  "name='" + name + '\'' +
  37.                  ", createDate=" + createDate +
  38.                  '}';
  39.      }
  40.  }
  41.  
  42.  class Dept {
  43.      private String dname;
  44.      private String loc;
  45.      private Company company;
  46.  
  47.      public String getDname() {
  48.          return dname;
  49.      }
  50.  
  51.      public void setDname(String dname) {
  52.          this.dname = dname;
  53.      }
  54.  
  55.      public String getLoc() {
  56.          return loc;
  57.      }
  58.  
  59.      public void setLoc(String loc) {
  60.          this.loc = loc;
  61.      }
  62.  
  63.      public Company getCompany() {
  64.          return company;
  65.      }
  66.  
  67.      public void setCompany(Company company) {
  68.          this.company = company;
  69.      }
  70.  
  71.      @Override
  72.      public String toString() {
  73.          return "Dept{" +
  74.                  "dname='" + dname + '\'' +
  75.                  ", loc='" + loc + '\'' +
  76.                  ", company=" + company +
  77.                  '}';
  78.      }
  79.  }
  80.  
  81.  class Emp {
  82.      private long empo;
  83.      private String ename;
  84.      private String job;
  85.      private double salary;
  86.      private Date hireDate;
  87.      private Dept dept;
  88.  
  89.      public Dept getDept() {
  90.          return dept;
  91.      }
  92.  
  93.      public void setDept(Dept dept) {
  94.          this.dept = dept;
  95.      }
  96.  
  97.      public void setEname(String ename) {
  98.          this.ename = ename;
  99.      }
  100.  
  101.      public void setJob(String job) {
  102.          this.job = job;
  103.      }
  104.  
  105.      public String getEname() {
  106.          return ename;
  107.      }
  108.  
  109.      public String getJob() {
  110.          return job;
  111.      }
  112.  
  113.      public long getEmpo() {
  114.          return empo;
  115.      }
  116.  
  117.      public void setEmpo(long empo) {
  118.          this.empo = empo;
  119.      }
  120.  
  121.      public double getSalary() {
  122.          return salary;
  123.      }
  124.  
  125.      public void setSalary(double salary) {
  126.          this.salary = salary;
  127.      }
  128.  
  129.      public Date getHireDate() {
  130.          return hireDate;
  131.      }
  132.  
  133.      public void setHireDate(Date hireDate) {
  134.          this.hireDate = hireDate;
  135.      }
  136.  
  137.      @Override
  138.      public String toString() {
  139.          return "Emp{" +
  140.                  "empo=" + empo +
  141.                  ", ename='" + ename + '\'' +
  142.                  ", job='" + job + '\'' +
  143.                  ", salary=" + salary +
  144.                  ", hireDate=" + hireDate +
  145.                  ", dept=" + dept +
  146.                  '}';
  147.      }
  148.  }
  149.  
  150.  class ClassInstanceFactory {
  151.      private ClassInstanceFactory() {
  152.      }        //构造方法私有化
  153.  
  154.      /**
  155.       * 实例化对象创建的方法,该对象可以根据传入的字符串的结构"内容|属性:内容|"进行处理
  156.       *
  157.       * @param tClass 要进行反射实例化的Class类对象,有Class就可以反射实例化对象
  158.       * @param value  要设置给对象的属性内容
  159.       * @return 一个已经配置完内容的简单java类对象
  160.       */
  161.      public static <T> T create(Class<T> tClass, String value) {
  162.          //如果想采用反射进行简单Java类对象的属性设置的时候,类中必须要有无参构造
  163.          try {
  164.              Object o = tClass.newInstance();
  165.              BeanUtils.setValue(o, value);        //通过反射设置属性
  166.              return tClass.cast(o);    //获取对象
  167.          } catch (Exception e) {
  168.              e.printStackTrace();        //此时如果出现异常,将异常抛出也没有多大作用
  169.              return null;
  170.          }
  171.  
  172.      }
  173.  
  174.  }
  175.  
  176.  class BeanUtils {    //进行Bean处理的工具类
  177.      private BeanUtils() {
  178.      }
  179.  
  180.      /**
  181.       * 实现指定对象的属性设置
  182.       *
  183.       * @param obj   要进行反射操作的实例化对象
  184.       * @param value 包含有指定内容的字符串
  185.       */
  186.      public static void setValue(Object obj, String value) {
  187.          String results[] = value.split("\\|");//按照竖线进行每一组属性的拆分
  188.          for (int i = 0; i < results.length; i++) {  //循环设置属性内容
  189.              String attval[] = results[i].split(":");   //获取属性名称及内容
  190.              try {
  191.                  Object currentObject = obj;
  192.                  if (attval[0].contains(".")) {        //这是多级配置
  193.                      String temp[] = attval[0].split("\\.");
  194.                      //最后一位肯定是指定类中的属性名称,因此不在实例化处理的范畴之内
  195.                      for (int j = 0; j < temp.length - 1; j++) {  //实例化
  196.                          //调用相应的getter方法,如果getter方法返回了空表示该对象为实例化
  197.                          Method getMethod = currentObject.getClass().getDeclaredMethod(
  198.                                  "get" + StringUtils.initcap(temp[j]));
  199.                          if (getMethod.invoke(currentObject) == null) {  //该对象现在并没有被实例化
  200.                              Field field = currentObject.getClass().getDeclaredField(temp[j]);
  201.                              Method method = currentObject.getClass().getDeclaredMethod("set" + StringUtils.initcap(temp[j]), field.getType());
  202.                              Object newObject = field.getType().getDeclaredConstructor().newInstance();
  203.                              method.invoke(currentObject, newObject);
  204.                              currentObject = newObject;
  205.                          } else {
  206.                              currentObject = getMethod.invoke(currentObject);
  207.                          }
  208.                      }
  209.                      //进行属性内容的 设置
  210.                      Field field = currentObject.getClass().getDeclaredField(temp[temp.length - 1]);
  211.                      Method setMethod = currentObject.getClass().getDeclaredMethod("set" + StringUtils.initcap(temp[temp.length - 1]), field.getType());
  212.                      Object val = BeanUtils.getAttributeValue(field.getType().getName(), attval[1]);
  213.                      setMethod.invoke(currentObject, val);        //使用setter方法进行内容的赋值
  214.                  } else {
  215.                      Field field = obj.getClass().getDeclaredField(attval[0]);
  216.                      Method setMethod = obj.getClass()
  217.                              .getDeclaredMethod("set" + StringUtils.initcap(attval[0]), field.getType());
  218.                      Object val = BeanUtils.getAttributeValue(field.getType().getName(), attval[1]);
  219.                      setMethod.invoke(obj, val);        //使用setter方法进行内容的赋值
  220.                  }
  221.              } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
  222.              }
  223.  
  224.          }
  225.      }
  226.  
  227.      /**
  228.       * 实现属性类型转化处理
  229.       *
  230.       * @param type  属性类型,通过Field获取
  231.       * @param value 属性的内容,传入的都是字符串,需要将其转化为指定的类型
  232.       * @return 转化后的数据
  233.       */
  234.      private static Object getAttributeValue(String type, String value) {
  235.          if ("long".equals(type) || "java.lang.Long".equals(type)) {   //长整型
  236.              return Long.parseLong(value);
  237.          } else if ("int".equals(type) || "java.lang.Integer".equals(type)) {
  238.              return Integer.valueOf(value);
  239.          } else if ("double".equals(type) || "java.lang.Double".equals(type)) {
  240.              return Double.valueOf(value);
  241.          } else if ("java.util.Date".equals(type)) {
  242.              SimpleDateFormat dateFormat = null;
  243.              if (value.matches("\\d{4}-\\d{2}-\\d{2}")) { //日期类型
  244.                  dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  245.              } else if (value.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {   //日期时间
  246.                  dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  247.              } else {
  248.                  return new Date();  //当前日期
  249.              }
  250.              try {
  251.                  return dateFormat.parse(value);
  252.              } catch (ParseException e) {
  253.                  return new Date();
  254.              }
  255.          } else {
  256.              return value;
  257.          }
  258.      }
  259.  }
  260.  
  261.  class StringUtils {
  262.      private StringUtils() {
  263.      }
  264.  
  265.      public static String initcap(String str) {
  266.          if (str == null || str.equals("")) {
  267.              return str;
  268.          }
  269.          if (str.length() == 1) {
  270.              return str.toUpperCase();
  271.          } else {
  272.              return str.substring(0, 1).toUpperCase() + str.substring(1);
  273.          }
  274.      }
  275.  
  276.  }
  277.  
  278.  public class ReflectAndJavaClassDemo {
  279.      public static void main(String[] args) {
  280.          //在Emp类中,存在两个String类型的成员变量ename,job,以及其相关的getter,setter
  281.          String value =
  282.                  "ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12|dept.dname:财务部" +
  283.                          "|dept.company.name:一个写java的公司";
  284.          Emp emp = ClassInstanceFactory.create(Emp.class, value);      //产生实例化对象
  285.          System.out.println(emp);
  286.      }
  287.  }

--运行结果

  1. Emp{empo=1258, ename='Mike', job='code java', salary=750.0, hireDate=Tue Dec 12 00:00:00 CST 1911, dept=Dept{dname='财务部', loc='null', company=Company{name='一个写java的公司', createDate=null}}}
  2.  
  3. Process finished with exit code 0

--这样在以后的简单java类的赋值处理将不再重复调用setter操作来完成,而这种形式,是在正规开发之中普遍采用的方式

java反射(四)--反射与简单java类的更多相关文章

  1. JAVA基础学习之路（四）定义简单java类

    简单java类开发一般原则: 类名称必须有意义,再怎么说,要让人家看的明白吧 类之中所有属性必须使用private封装,并提供setter,getter方法 类之中可以有多个构造方法,但是必须保留有一 ...

  2. 菜鸡的Java笔记 数据表与简单java类映射

    利用实际的数据表实现表与类的操作转换        简单java类是整个项目开发中的灵魂所在,它有自己严格的开发标准,而最为重要的是它需要于数据表是完全对应的        不过考虑到现在没有接触到过 ...

  3. java构造方法的作用以及简单java类

    public class TestDemo{ public static void main(String args[]){ Emp emp1 =new Emp(001,"tom" ...

  4. java--分析简单java类与反射的联系

    分析简单java类与反射的联系 web对反射的操作支持 在JSP之中有一种技术--javaBean.而且在jsp里面也配套有相应的操作方式,javaBean的核心在于简单java类,于是下面演示此操作 ...

  5. 进阶Java编程(10)反射与简单Java类

    1,传统属性自动赋值弊端 简单Java类主要由属性构成,并且提供有setter与getter类,同时简单Java类最大的特征就是通过对象保存相应的类属性的内容.但是如果使用传统的简单Java类开发,那 ...

  6. java中的反射机制，以及如何通过反射获取一个类的构造方法 ，成员变量，方法，详细。。

    首先先说一下类的加载,流程.只有明确了类这个对象的存在才可以更好的理解反射的原因,以及反射的机制. 一.  类的加载 当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三 ...

  7. 深入分析Java反射(四)-动态代理

    动态代理的简介 Java动态代理机制的出现,使得Java开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类.代理类会负责将所有的方法调用分派到委托对象上反射执行,在分 ...

  8. Java 反射理解（一）-- Class 类的使用

    Java 反射理解(一)-- Class 类的使用 概念 这里阐述几个基本概念: 在面向对象的世界里,万事万物皆对象.(在 Java 语言中,静态的成员.普通数据类型除外) 类也是对象,类是 java ...

  9. java反射(三)--反射与操作类

    一.反射与操作类 在反射机制的处理过程之中不仅仅只是一个实例化对象的处理操作,更多的情况下还有类的组成的操作,任何一个类的基本组成结构:父类(父接口),包,属性,方法(构造方法,普通方法)--获取类的 ...

随机推荐

  1. Ride to Office（贪心水题）

    [题目链接] http://noi.openjudge.cn/ch0406/2404/ [算法] 一开始zz了,先按时间排序然后如果速度超过当前男主速度,且在男主到达目的地前超过男主则最终男主和这个人 ...

  2. Codeforces Round #529 (Div. 3) E. Almost Regular Bracket Sequence （思维）

    Codeforces Round #529 (Div. 3) 题目传送门 题意: 给你由左右括号组成的字符串,问你有多少处括号翻转过来是合法的序列 思路: 这么考虑: 如果是左括号 1)整个序列左括号 ...

  3. 1233: [Usaco2009Open]干草堆tower

    传送门 感觉正着做不太好搞,考虑倒过来搞 容易想到贪心,每一层都贪心地选最小的宽度,然后发现 $WA$ 了... 因为一开始多选一点有时可以让下一层宽度更小 然后有一个神奇的结论,最高的方案一定有一种 ...

  4. 故事版(storyBoard)-lllegal configuration connection cannot have a prototype objct as

    今天下午做项目的时候.居然出了一个太不是问题的问题了,这个错误太低级了. lllegal configuration connection 'flagImg' cannot have a protot ...

  5. IntelliJ IDEA 中 Ctrl+Alt+Left/Right 失效

    开发工具:Idea OS:Window 7 在idea中使用ctrl+b跟踪进入函数之后,每次返回都不知道用什么快捷键,在idea中使用ctrl+alt+方向键首先会出现与win7屏幕方向的快捷键冲突 ...

  6. Javascript中中括号的几种形式

    有以下几种形式 var arr = []; var b = [1,1,1]; var c = b[0]; var obj = {'name':'tom','age':23}; var d = obj[ ...

  7. CSS-05 html和body标签

    html和body标签 一直对这两个标签有迷惑,查了一些网上资料整理了一下. 1.html和body标签的背景 1.当给body一个背景色时候,背景图是充满整个窗口的,这里看上去是body标签下的背景 ...

  8. 常见前端面试题CSS部分

    1.盒模型 IE 盒子模型:IE的width部分包含了 border 和 pading; 标准 W3C 盒子模型: width/height+border+padding+margin; 2.清除浮动 ...

  9. ssh-keygen - 认证密钥的产生, 管理和转换

    总览 (SYNOPSIS) ssh-keygen -words [-q ] [-b bits ] -t type [-N new_passphrase ] [-C comment ] [-f outp ...

  10. Linux 下源码安装ngnix

    版本说明: NGINX 版本1.12.0 pcre-8.40 zlib-1.2.11 openssl-1.1.0i   安装过程 # ./configure  --prefix=/usr/ngnix  ...