java反射--反射与简单java类
Posted skykuqi
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java反射--反射与简单java类相关的知识，希望对你有一定的参考价值。
一.传统简单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类中,存在两个String类型的成员变量ename,job,以及其相关的getter,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("\\d4-\\d2-\\d2")) //日期类型
142 dateFormat = new SimpleDateFormat("yyyy-MM-dd");
143 else if (value.matches("\\d4-\\d2-\\d2 \\d2:\\d2:\\d2")) //日期时间
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类中,存在两个String类型的成员变量ename,job,以及其相关的getter,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
--运行结果
Empempo=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("\\d4-\\d2-\\d2")) //日期类型
223 dateFormat = new SimpleDateFormat("yyyy-MM-dd");
224 else if (value.matches("\\d4-\\d2-\\d2 \\d2:\\d2:\\d2")) //日期时间
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类中,存在两个String类型的成员变量ename,job,以及其相关的getter,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类.Company@610455d6
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("\\d4-\\d2-\\d2")) //日期类型
245 dateFormat = new SimpleDateFormat("yyyy-MM-dd");
246 else if (value.matches("\\d4-\\d2-\\d2 \\d2:\\d2:\\d2")) //日期时间
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类中,存在两个String类型的成员变量ename,job,以及其相关的getter,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
--运行结果
Empempo=1258, ename=‘Mike‘, job=‘code java‘, salary=750.0, hireDate=Tue Dec 12 00:00:00 CST 1911, dept=Deptdname=‘财务部‘, loc=‘null‘, company=Companyname=‘一个写java的公司‘, createDate=null
Process finished with exit code 0
--这样在以后的简单java类的赋值处理将不再重复调用setter操作来完成,而这种形式,是在正规开发之中普遍采用的方式
以上是关于java反射--反射与简单java类的主要内容，如果未能解决你的问题，请参考以下文章