java反射(四)--反射与简单java类

发布时间：2020-12-15 07:54:14 所属栏目：Java 来源：网络整理

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

一.传统简单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 
 58 class BeanUtils {    //进行Bean处理的工具类
 59     private BeanUtils() {  60  }  61 
 62     /**
 63  * 实现指定对象的属性设置  64  *  65  * @param obj 要进行反射操作的实例化对象  66  * @param value 包含有指定内容的字符串  67      */
 68     public static void setValue(Object obj,String value) {  69         String results[] = value.split("|");//按照竖线进行每一组属性的拆分
 70         for (int i = 0; i < results.length; i++) {  //循环设置属性内容
 71             String attval[] = results[i].split(":");   //获取属性名称及内容
 72             try {  73                 Field field = obj.getClass().getDeclaredField(attval[0]);  74                 Method setMethod = obj.getClass()  75                         .getDeclaredMethod("set" + StringUtils.initcap(attval[0]),field.getType());  76                 setMethod.invoke(obj,attval[1]);        //使用setter方法进行内容的赋值
 77             } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
 78  }  79 
 80  }  81  }  82 }  83 
 84 class StringUtils {  85     private StringUtils() {  86  }  87 
 88     public static String initcap(String str) {  89         if (str == null || str.equals("")) {  90             return str;  91  }  92         if (str.length() == 1) {  93             return str.toUpperCase();  94         } else {  95             return str.substring(0,1).toUpperCase() + str.substring(1);  96  }  97  }  98 
 99 } 100 
101 public class ReflectAndJavaClassDemo { 102     public static void main(String[] args) { 103         //在Emp类中,setter
104         String value = "ename:Mike|job:code java"; 105         Emp emp = ClassInstanceFactory.create(Emp.class,value);      //产生实例化对象
106         System.out.println("姓名: " + emp.getEname() + " 职位: " + emp.getJob()); 107  } 108 }

--运行结果

姓名: Mike 职位: code java 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 
 99 class BeanUtils {    //进行Bean处理的工具类
100     private BeanUtils() { 101  } 102 
103     /**
104  * 实现指定对象的属性设置 105  * 106  * @param obj 要进行反射操作的实例化对象 107  * @param value 包含有指定内容的字符串 108      */
109     public static void setValue(Object obj,String value) { 110         String results[] = value.split("|");//按照竖线进行每一组属性的拆分
111         for (int i = 0; i < results.length; i++) {  //循环设置属性内容
112             String attval[] = results[i].split(":");   //获取属性名称及内容
113             try { 114                 Field field = obj.getClass().getDeclaredField(attval[0]); 115                 Method setMethod = obj.getClass() 116                         .getDeclaredMethod("set" + StringUtils.initcap(attval[0]),field.getType()); 117                 Object val = BeanUtils.getAttributeValue(field.getType().getName(),attval[1]); 118                 setMethod.invoke(obj,val);        //使用setter方法进行内容的赋值
119             } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
120  } 121 
122  } 123  } 124 
125     /**
126  * 实现属性类型转化处理 127  * 128  * @param type 属性类型,通过Field获取 129  * @param value 属性的内容,传入的都是字符串,需要将其转化为指定的类型 130  * @return 转化后的数据 131      */
132     private static Object getAttributeValue(String type,String value) { 133         if ("long".equals(type) || "java.lang.Long".equals(type)) {   //长整型
134             return Long.parseLong(value); 135         } else if ("int".equals(type) || "java.lang.Integer".equals(type)) { 136             return Integer.valueOf(value); 137         } else if ("double".equals(type) || "java.lang.Double".equals(type)) { 138             return Double.valueOf(value); 139         } else if ("java.util.Date".equals(type)) { 140             SimpleDateFormat dateFormat = null; 141             if (value.matches("d{4}-d{2}-d{2}")) { //日期类型
142                 dateFormat = new SimpleDateFormat("yyyy-MM-dd"); 143             } else if (value.matches("d{4}-d{2}-d{2} d{2}:d{2}:d{2}")) {   //日期时间
144                 dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 145             } else { 146                 return new Date();  //当前日期
147  } 148             try { 149                 return dateFormat.parse(value); 150             } catch (ParseException e) { 151                 return new Date(); 152  } 153         } else { 154             return value; 155  } 156  } 157 } 158 
159 class StringUtils { 160     private StringUtils() { 161  } 162 
163     public static String initcap(String str) { 164         if (str == null || str.equals("")) { 165             return str; 166  } 167         if (str.length() == 1) { 168             return str.toUpperCase(); 169         } else { 170             return str.substring(0,1).toUpperCase() + str.substring(1); 171  } 172  } 173 
174 } 175 
176 public class ReflectAndJavaClassDemo { 177     public static void main(String[] args) { 178         //在Emp类中,setter
179         String value = "ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12"; 180         Emp emp = ClassInstanceFactory.create(Emp.class,value);      //产生实例化对象
181  System.out.println(emp); 182  } 183 }

--运行结果

Emp{empo=1258,ename=‘Mike‘,job=‘code java‘,salary=750.0,hireDate=Tue Dec 12 00:00:00 CST 1911} 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 
160 class BeanUtils {    //进行Bean处理的工具类
161     private BeanUtils() { 162  } 163 
164     /**
165  * 实现指定对象的属性设置 166  * 167  * @param obj 要进行反射操作的实例化对象 168  * @param value 包含有指定内容的字符串 169      */
170     public static void setValue(Object obj,String value) { 171         String results[] = value.split("|");//按照竖线进行每一组属性的拆分
172         for (int i = 0; i < results.length; i++) {  //循环设置属性内容
173             String attval[] = results[i].split(":");   //获取属性名称及内容
174             try { 175                 Object currentObject = obj; 176                 if (attval[0].contains(".")) {        //这是多级配置
177                     String temp[] = attval[0].split("."); 178                     //最后一位肯定是指定类中的属性名称,因此不在实例化处理的范畴之内
179                     for (int j = 0; j < temp.length - 1; j++) {  //实例化 180                         //调用相应的getter方法,如果getter方法返回了空表示该对象为实例化
181                         Method getMethod = currentObject.getClass().getDeclaredMethod( 182                                 "get" + StringUtils.initcap(temp[j])); 183                         if (getMethod.invoke(currentObject) == null) {  //该对象现在并没有被实例化
184                             Field field = currentObject.getClass().getDeclaredField(temp[j]); 185                             Method method = currentObject.getClass().getDeclaredMethod("set" + StringUtils.initcap(temp[j]),field.getType()); 186                             Object newObject = field.getType().getDeclaredConstructor().newInstance(); 187  method.invoke(currentObject,newObject); 188                             currentObject = newObject; 189                         } else { 190                             currentObject = getMethod.invoke(currentObject); 191  } 192  } 193                 } else { 194                     Field field = obj.getClass().getDeclaredField(attval[0]); 195                     Method setMethod = obj.getClass() 196                             .getDeclaredMethod("set" + StringUtils.initcap(attval[0]),field.getType()); 197                     Object val = BeanUtils.getAttributeValue(field.getType().getName(),attval[1]); 198                     setMethod.invoke(obj,val);        //使用setter方法进行内容的赋值
199  } 200             } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
201  } 202 
203  } 204  } 205 
206     /**
207  * 实现属性类型转化处理 208  * 209  * @param type 属性类型,通过Field获取 210  * @param value 属性的内容,需要将其转化为指定的类型 211  * @return 转化后的数据 212      */
213     private static Object getAttributeValue(String type,String value) { 214         if ("long".equals(type) || "java.lang.Long".equals(type)) {   //长整型
215             return Long.parseLong(value); 216         } else if ("int".equals(type) || "java.lang.Integer".equals(type)) { 217             return Integer.valueOf(value); 218         } else if ("double".equals(type) || "java.lang.Double".equals(type)) { 219             return Double.valueOf(value); 220         } else if ("java.util.Date".equals(type)) { 221             SimpleDateFormat dateFormat = null; 222             if (value.matches("d{4}-d{2}-d{2}")) { //日期类型
223                 dateFormat = new SimpleDateFormat("yyyy-MM-dd"); 224             } else if (value.matches("d{4}-d{2}-d{2} d{2}:d{2}:d{2}")) {   //日期时间
225                 dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 226             } else { 227                 return new Date();  //当前日期
228  } 229             try { 230                 return dateFormat.parse(value); 231             } catch (ParseException e) { 232                 return new Date(); 233  } 234         } else { 235             return value; 236  } 237  } 238 } 239 
240 class StringUtils { 241     private StringUtils() { 242  } 243 
244     public static String initcap(String str) { 245         if (str == null || str.equals("")) { 246             return str; 247  } 248         if (str.length() == 1) { 249             return str.toUpperCase(); 250         } else { 251             return str.substring(0,1).toUpperCase() + str.substring(1); 252  } 253  } 254 
255 } 256 
257 public class ReflectAndJavaClassDemo { 258     public static void main(String[] args) { 259         //在Emp类中,setter
260         String value =
261                 "ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12|dept.dname:财务部" +
262                         "|dept.company.name:一个写java的公司"; 263         Emp emp = ClassInstanceFactory.create(Emp.class,value);      //产生实例化对象
264  System.out.println(emp.getDept().getCompany()); 265  } 266 }

--运行结果

反射.反射与java类[email?protected] 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 
177 class BeanUtils {    //进行Bean处理的工具类
178     private BeanUtils() { 179  } 180 
181     /**
182  * 实现指定对象的属性设置 183  * 184  * @param obj 要进行反射操作的实例化对象 185  * @param value 包含有指定内容的字符串 186      */
187     public static void setValue(Object obj,String value) { 188         String results[] = value.split("|");//按照竖线进行每一组属性的拆分
189         for (int i = 0; i < results.length; i++) {  //循环设置属性内容
190             String attval[] = results[i].split(":");   //获取属性名称及内容
191             try { 192                 Object currentObject = obj; 193                 if (attval[0].contains(".")) {        //这是多级配置
194                     String temp[] = attval[0].split("."); 195                     //最后一位肯定是指定类中的属性名称,因此不在实例化处理的范畴之内
196                     for (int j = 0; j < temp.length - 1; j++) {  //实例化 197                         //调用相应的getter方法,如果getter方法返回了空表示该对象为实例化
198                         Method getMethod = currentObject.getClass().getDeclaredMethod( 199                                 "get" + StringUtils.initcap(temp[j])); 200                         if (getMethod.invoke(currentObject) == null) {  //该对象现在并没有被实例化
201                             Field field = currentObject.getClass().getDeclaredField(temp[j]); 202                             Method method = currentObject.getClass().getDeclaredMethod("set" + StringUtils.initcap(temp[j]),field.getType()); 203                             Object newObject = field.getType().getDeclaredConstructor().newInstance(); 204  method.invoke(currentObject,newObject); 205                             currentObject = newObject; 206                         } else { 207                             currentObject = getMethod.invoke(currentObject); 208  } 209  } 210                     //进行属性内容的 设置
211                     Field field = currentObject.getClass().getDeclaredField(temp[temp.length - 1]); 212                     Method setMethod = currentObject.getClass().getDeclaredMethod("set" + StringUtils.initcap(temp[temp.length - 1]),field.getType()); 213                     Object val = BeanUtils.getAttributeValue(field.getType().getName(),attval[1]); 214                     setMethod.invoke(currentObject,val);        //使用setter方法进行内容的赋值
215                 } else { 216                     Field field = obj.getClass().getDeclaredField(attval[0]); 217                     Method setMethod = obj.getClass() 218                             .getDeclaredMethod("set" + StringUtils.initcap(attval[0]),field.getType()); 219                     Object val = BeanUtils.getAttributeValue(field.getType().getName(),attval[1]); 220                     setMethod.invoke(obj,val);        //使用setter方法进行内容的赋值
221  } 222             } catch (Exception e) { //捕获异常,否则的话一个属性不存在将会导致所有的属性都无法正常赋值
223  } 224 
225  } 226  } 227 
228     /**
229  * 实现属性类型转化处理 230  * 231  * @param type 属性类型,通过Field获取 232  * @param value 属性的内容,需要将其转化为指定的类型 233  * @return 转化后的数据 234      */
235     private static Object getAttributeValue(String type,String value) { 236         if ("long".equals(type) || "java.lang.Long".equals(type)) {   //长整型
237             return Long.parseLong(value); 238         } else if ("int".equals(type) || "java.lang.Integer".equals(type)) { 239             return Integer.valueOf(value); 240         } else if ("double".equals(type) || "java.lang.Double".equals(type)) { 241             return Double.valueOf(value); 242         } else if ("java.util.Date".equals(type)) { 243             SimpleDateFormat dateFormat = null; 244             if (value.matches("d{4}-d{2}-d{2}")) { //日期类型
245                 dateFormat = new SimpleDateFormat("yyyy-MM-dd"); 246             } else if (value.matches("d{4}-d{2}-d{2} d{2}:d{2}:d{2}")) {   //日期时间
247                 dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 248             } else { 249                 return new Date();  //当前日期
250  } 251             try { 252                 return dateFormat.parse(value); 253             } catch (ParseException e) { 254                 return new Date(); 255  } 256         } else { 257             return value; 258  } 259  } 260 } 261 
262 class StringUtils { 263     private StringUtils() { 264  } 265 
266     public static String initcap(String str) { 267         if (str == null || str.equals("")) { 268             return str; 269  } 270         if (str.length() == 1) { 271             return str.toUpperCase(); 272         } else { 273             return str.substring(0,1).toUpperCase() + str.substring(1); 274  } 275  } 276 
277 } 278 
279 public class ReflectAndJavaClassDemo { 280     public static void main(String[] args) { 281         //在Emp类中,setter
282         String value =
283                 "ename:Mike|job:code java|empo:1258|salary:750|hireDate:1911-12-12|dept.dname:财务部" +
284                         "|dept.company.name:一个写java的公司"; 285         Emp emp = ClassInstanceFactory.create(Emp.class,value);      //产生实例化对象
286  System.out.println(emp); 287  } 288 }

--运行结果

Emp{empo=1258,hireDate=Tue Dec 12 00:00:00 CST 1911,dept=Dept{dname=‘财务部‘,loc=‘null‘,company=Company{name=‘一个写java的公司‘,createDate=null}}} Process finished with exit code 0

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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!