文档库 最新最全的文档下载
当前位置:文档库 › 解决实体类噩梦:联合实体类(Java反射+泛型实际应用)

解决实体类噩梦:联合实体类(Java反射+泛型实际应用)

解决实体类噩梦:联合实体类(Java反射+泛型实际应用)
解决实体类噩梦:联合实体类(Java反射+泛型实际应用)

解决实体类噩梦:联合实体类(Java反射+泛型实际应用)

小菜提到的实体类,即项目中业务或者数据库表的映射,貌似也可以称为模型,不同的语言中叫法不同吧!!

举个例子,比如在某个Web页面中,表单上有大量的数据需要提交,如果是初学者,很可能这样接收参数:

String param1;String param2;String param3;……

这样做的坏处很多,比如:代码会显得很乱,可能会出现大量重复代码,最主要的就是没有做到面向对象的“封装性”,导致程序不容易维护。

由此,聪明的程序员们提出了实体类的概念,也就是用类来封装业务所需要的数据。

public class User {

private String uid;

private String pwd;

public String getUid() {

return uid;

}

public void setUid(String uid) {

this.uid = uid;

}

…..

}

这样一来,我们在保存数据时,只需创建一个对象,然后通过“.”的方式来访问对象的属性,提高扩展性、提高复用性、代码简洁等等好处不言而喻。

在实际使用中,实体类往往是和某个业务或者数据库表相对应的,看起来很简单,但随着需求的复杂化,业务和业务之间可能会交叉,表和表之间可能会联合查询。

这样一来,以前一一对应的实体类,便无法满足需求,因为某个实体类中可能找不到我们需要的属性,但是它却在另一个实体类中,而我们又不想随便在某个实体类中添加一个毫不相关的属性,因为这样做可能会打破类的职责单一原则。

因此,我们不得不再新建一个实体类ClassAAndClassB,这个实体类包含了类A和类B的所有属性,对于稍有经验的程序员来说,这绝对是个噩梦,因为组合的可能性是在是太多,而且可能是很多个实体组合,等待我们的将是无数的实体类,导致程序混乱不堪。

小菜一直苦于此事,今天终于通过Java的反射和泛型写了一个“联合实体类”。

通过这个联合实体类,可以把任意多个实体类融合成一个实体类。

联合实体类代码:

1import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Method;

2import java.util.List;

3

4/**

5* 联合实体类

6* @author杨元

7*

8*/

9public class UniteEntity {

10

11//联合实体对象集合

12List entitys = null;

13//方法名称

14String fnName = "";

15//方法对象

16Method method = null;

17

18/**

19* 构造方法

20* @param entitys 需要联合的实体对象集合

21*/

22public UniteEntity(List entitys){

23this.entitys = entitys;

24}

25

26/**

27* 获取某个取值方法

28* @param fnName 方法名称

29* @return该取值方法返回值类型

30*/

31public Class getFunction(String fnName){

32//保存方法名称

33this.fnName = fnName;

34//查找方法

35Method m = findMethod();

36//判断方法是否存在

37if(m != null){

38//获取目标方法的返回值类型

39Class type = m.getReturnType();

40//保存取值方法对象

41method = m;

42//返回该取值方法返回值类型

43return type;

44}else{

45return null;

46}

47}

48

49/**

50* 获取某个赋值方法

51* @param fnName 方法名称

52* @return该赋值方法参数类型

53*/

54public Class setFunction(String fnName){

55//保存方法名称

56this.fnName = fnName;

57//查找方法

58Method m = findMethod();

59//判断方法是否存在

60if(m != null){

61//获取目标方法的参数类型

62Class type = m.getParameterTypes()[0]; 63//保存赋值方法对象

64method = m;

65//返回该赋值方法参数类型

66return type;

67}else{

68return null;

69}

70}

71

72/**

73* 调用某个方法,为属性赋值

74* @param 赋值方法的参数类型

75* @param c

76* @param value 值内容

77*/

78public void setValue(Class c,T value){ 79//遍历实体类集合

80for(Object o : entitys){

81//出错继续执行

82try{

83method.invoke(o, value);

break;

84}catch(Exception ex){}

85}

86}

87

88/**

89* 调用某个方法,取得属性的值

90* @param 取值方法的返回值类型

91* @param c

92* @return取得值的内容

93*/

94public T getValue(Class c){

95//遍历实体类集合

96for(Object o : entitys){

97//出错继续运行

98try{

99//由于invoke返回的是Object类型,因此要强制转换成T类型

100return(T)method.invoke(o);

101}catch(Exception ex){}

102}

103return null;

104}

105

106/**

107* 从实体对象集合中查找某个方法

108* @return方法对象

109*/

110private Method findMethod(){

111//遍历集合,寻找方法

112for(Object o : entitys){

113//保证出错能继续运行

114try{

115//获取对象所有公有方法

116Method[] methods = o.getClass().getMethods();

117

118//遍历方法

119for(Method m : methods){

120//匹配是否有目标方法

121if(fnName.equals(m.getName())){

122//返回方法对象

123return m;

124}

125}

126}catch(Exception ex){}

127}

128return null;

129}

130}

调用方法:

1//创建一个对象集合

2List list = new ArrayList();

3

4//将需要融合的实体类填入集合

5list.add(new User());

6list.add(new Enterprise());

7

8//创建联合实体类对象

9UniteEntity ue = new UniteEntity(list);

10

11int i = 109;

12

13//调用实体类中方法名为setEnno的方法(赋值方法),并给一个参数i

14ue.setValue(ue.setFunction("setEnno"), i);

15//调用实体类中方法名为getEnno的方法(取值方法),并打印返回值

16System.out.println(ue.getValue(ue.getFunction("getEnno")));

说明:

用法很简单,创建联合实体对象的时候必须传入需要融合的实体对象集合。

如果想调用的方法是取值方法,则先调用联合实体对象的getFunction方法,参数是方法的名称,一定要写对!!最好是复制!!这个步骤会查找到指定的方法,并且确定该方法的返回值类型,然后把getFunction方法的返回值作为参数,调用联合实体对象的getValue方法,即可取得属性值。

如果想调用的方法是赋值方法,则先调用联合实体对象的setFunction方法,同理,该方法会确定参数的类型,把setFunction方法的返回值作为参数,调用联合实体对象的setValue方法,再加上需要赋给的值,即可给属性赋值。

由于使用了泛型技术,所以本类比较安全、稳定。调用赋值方法时,如果传入的值和方法的参数类型不同,直接赋值失败,不会抛出异常;调用取值方法时,直接对取出来的值进行强制类型转换即可,无需验证数据类型(例如:int[] items = (int[])ue.getValue(ue.getFunction("getEmp"));)。

注意事项:

使用本类肯定会降低程序效率,慎重使用。

本类只支持带有一个参数的属性赋值方法。

如果多个实体类中有重复的方法名称,则默认使用的是在集合中靠前的那个实体类的方法。

写在后面的话:

本文只是提供一种思路,肯定不是最好的解决方案,也不一定能满足读者的需求,高手勿喷。。。

JAVA反射机制原理

运行时类型识别(Run-time Type Identification, RTTI)主要有两种方式,一种是我们在编译时和运行时已经知道了所有的类型,另外一种是功能强大的“反射”机制。 要理解RTTI在Java中的工作原理,首先必须知道类型信息在运行时是如何表示的,这项工作是由“Class对象”完成的,它包含了与类有关的信息。类是程序的重要组成部分,每个类都有一个Class对象,每当编写并编译了一个新类就会产生一个Class对象,它被保存在一个同名的.class文件中。在运行时,当我们想生成这个类的对象时,运行这个程序的Java 虚拟机(JVM)会确认这个类的Class对象是否已经加载,如果尚未加载,JVM就会根据类名查找.class文件,并将其载入,一旦这个类的Class对象被载入内存,它就被用来创建这个类的所有对象。一般的RTTI形式包括三种: 1. 传统的类型转换。如“(Apple)Fruit”,由RTTI确保类型转换的正确性,如果执行了一个错误的类型转换,就会抛出一个ClassCastException异常。 2. 通过Class对象来获取对象的类型。如 Class c = Class.forName(“Apple”); Object o = c.newInstance(); 3. 通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例,准确的说,应该是instanceof / Class.isInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例,这和equals() / ==不一样,它们用来比较两个对象是否属于同一个类的实例,没有考虑继承关系。 反射 如果不知道某个对象的类型,可以通过RTTI来获取,但前提是这个类型在编译时必须已知,这样才能使用RTTI来识别。即在编译时,编译器必须知道所有通过RTTI来处理的类。 使用反射机制可以不受这个限制,它主要应用于两种情况,第一个是“基于构件的编程”,在这种编程方式中,将使用某种基于快速应用开发(RAD)的应用构建工具来构建项目。这是现在最常见的可视化编程方法,通过代表不同组件的图标拖动到图板上来创建程序,然后设置构件的属性值来配置它们。这种配置要求构件都是可实例化的,并且要暴露其部分信息,使得程序员可以读取和设置构件的值。当处理GUI时间的构件时还必须暴露相关方法的细细,以便RAD环境帮助程序员覆盖这些处理事件的方法。在这里,就要用到反射的机制来检查可用的方法并返回方法名。Java通过JavaBeans提供了基于构件的编程架构。 第二种情况,在运行时获取类的信息的另外一个动机,就是希望能够提供在跨网络的远程平台上创建和运行对象的能力。这被成为远程调用(RMI),它允许一个Java程序将对象分步在多台机器上,这种分步能力将帮助开发人员执行一些需要进行大量计算的任务,充

java基础-反射总结

第一节Class 一、概述: 1、Class是Java程序中各个Java类的总称;它是反射的基石,通过Class类来使用反射。 2、Class和class的区别 1)class:Java中的类用于描述一类事物的共性,该类事物有什么属性,没有什么属性,至于这个属性的值是什么,则由此类的实例对象确定,,不同的实例对象有不同的属性值。2)Class:指的是Java程序中的各个Java类是属于同一类事物,都是Java程序的类,这些类称为Class。例如人对应的是Person类,Java类对应的就是Class。 3、属性:类名,类的访问属性,类所属包名,字段名称列表,方法名称列表等。 二、对象的创建和使用: 1、创建实例对象:不可用new Class()的方式,因为Class没有这样的构造方法。而是将字节码对象赋值给Class变量。如Class c1 = Person.class。 如Person类,它的字节码:首先要将Person的java文件编译为class文件放于硬盘上,即为二进制代码,再将这些代码加载到内存中,接着用它创建一个个对象。就是把类的字节码加载进内存中,再用此字节码创建一个个对象。当有如Person、Math、Date等等的类,那么这些字节码就是分别的一个Class对象。即Class c2 = Date.class;。 2、获得类的字节码对象:如Class.forName(”https://www.wendangku.net/doc/fd16518273.html,ng.String”)即获得String.class。得到这个字节码对象有两种情况: 1)此类已经加载进内存:若要得到此类字节码,不需要再加载。 2)此类还未加载进内存:类加载器加载此类后,将字节码缓存起来,forName()方法返回加载进来的字节码。 3、得到各字节码对应的实例对象(Class类型)的方式: 1)类名.class:如System.class,String.class等等 2)对象.class:如new Date().getClass()或者d.getClass()。(Date d = new Date()) 3)Class.forName(“类名”):如Class.forName(”https://www.wendangku.net/doc/fd16518273.html,ng.String”) 当获取类名的时候,是不知道此类的名称的,forName(字符串参数)方法中传入字符串型的变量作为对外访问的入口,即传入什么类名就获得什么类名,从而得知相应的类名。 注: forName()是静态方法,是反射中使用的一种方式获取字节码的实例对象。 每个类的字节码对象只有唯一的一个,如任何字符串对象,对应唯一的String.clas字节码。 4、九个预定义的Class: 1)包括八种基本类型(byte、short、int、long、float、double、char、boolean)的字节码对象和一种返回值为void类型的void.class。 2)Integer.TYPE是Integer类的一个常量,它代表此包装类型包装的基本类型的字节码,所以和int.class是相等的。 基本数据类型的字节码都可以用与之对应的包装类中的TYPE常量表示 数组类型的Class实例对象,可以用Class.isArray()方法判断是否为数组类型的。 5、总结:只要是在源程序中出现的类型都有各自的Class实例对象,如int[].class、void.class 等。 三、方法: 1、static Class forName(String className) ---> 返回与给定字符串名的类或接口的相关联的Class对象。 2、Class getClass() ---> 返回的是Object运行时的类,即返回Class对象即字节码对象

JAVA反射机制(内含大量实例)

反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统、操作系统和文件系统中。 反射本身并不是一个新概念,它可能会使我们联想到光学中的反射概念,尽管计算机科学赋予了反射概念新的含义,但是,从现象上来说,它们确实有某些相通之处,这些有助于我们的理解。在计算机科学领域,反射是指一类应用,它们能够自描述和自控制。也就是说,这类应用通过采用某种机制来实现对自己行为的描述(self-representation)和监测(examination),并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。可以看出,同一般的反射概念相比,计算机科学领域的反射不单单指反射本身,还包括对反射结果所采取的措施。所有采用反射机制的系统(即反射系统)都希望使系统的实现更开放。可以说,实现了反射机制的系统都具有开放性,但具有开放性的系统并不一定采用了反射机制,开放性是反射系统的必要条件。一般来说,反射系统除了满足开放性条件外还必须满足原因连接(Causally-connected)。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实

际状态和行为上的情况,反之亦然。开放性和原因连接是反射系统的两大基本要素。 Java中,反射是一种强大的工具。它使您能够创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行源代表链接。反射允许我们在编写与执行时,使我们的程序代码能够接入装载到JVM中的类的内部信息,而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是:如果使用不当,反射的成本很高。 二、Java中的类反射: Reflection 是 Java 程序开发语言的特征之一,它允许运行中的Java 程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 1.检测类: 1.1 reflection的工作机制 考虑下面这个简单的例子,让我们看看 reflection 是如何工作的。

java反射机制

Java的反射机制是Java特性之一,反射机制是构建框架技术的基础所在。灵活掌握Java反射机制,对大家以后学习框架技术有很大的帮助。 那么什么是Java的反射呢? 大家都知道,要让Java程序能够运行,那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载,是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。 Java的反射机制是在编译并不确定是哪个类被加载了,而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。 那么Java反射有什么作用呢? 假如我们有两个程序员,一个程序员在写程序的时候,需要使用第二个程序员所写的类,但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢?这是不能通过编译的。利用Java反射的机制,就可以让第一个程序员在没有得到第二个程序员所写的类的时候,来完成自身代码的编译。 Java的反射机制它知道类的基本结构,这种对Java类结构探知的能力,我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候,去调用该对象的方法和属性的时候。一按点,编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来,供用户进行选择。这就是利用了Java反射的原理,是对我们创建对象的探知、自审。 Class类 要正确使用Java反射机制就得使用https://www.wendangku.net/doc/fd16518273.html,ng.Class这个类。它是Java反射机制的起源。当一个类被加载以后,Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。 反射API ◆反射API用于反应在当前Java虚拟机中的类、接口或者对象信息 ◆功能 —获取一个对象的类信息. —获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息. —检获属于一个接口的常量和方法声明. —创建一个直到程序运行期间才知道名字的类的实例. —获取并设置一个对象的成员,甚至这个成员的名字是 在程序运行期间才知道. —检测一个在运行期间才知道名字的对象的方法 利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信

JAVA中的反射机制

JAVA中的反射机制 一,先看一下反射的概念: 主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。 反射是java中一种强大的工具,能够使我们很方便的创建灵活的代码,这些代码可以再运行时装配,无需在组件之间进行源代码链接。但是反射使用不当会成本很高! 看概念很晕的,继续往下看。 二,反射机制的作用: 1,反编译:.class-->.java 2,通过反射机制访问java对象的属性,方法,构造方法等; 这样好像更容易理解一些,下边我们具体看怎么实现这些功能。 三,在这里先看一下sun为我们提供了那些反射机制中的类: https://www.wendangku.net/doc/fd16518273.html,ng.Class; https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Constructor; https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Field; https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Method; https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Modifier; 很多反射中的方法,属性等操作我们可以从这四个类中查询。还是哪句话要学着不断的查询API,那才是我们最好的老师。 四,具体功能实现:

1,反射机制获取类有三种方法,我们来获取Employee类型 [java]view plain copy print? 1.//第一种方式: 2.Class c1 = Class.forName("Employee"); 3.//第二种方式: 4.//java中每个类型都有class 属性. 5.Class c2 = Employee.class; 6. 7.//第三种方式: 8.//java语言中任何一个java对象都有getClass 方法 9.Employee e = new Employee(); 10.Class c3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) 2,创建对象:获取类以后我们来创建它的对象,利用newInstance: 1.Class c =Class.forName("Employee"); 2. 3.//创建此Class 对象所表示的类的一个新实例 4.Objecto = c.newInstance(); //调用了Employee的无参数构造方法. 3,获取属性:分为所有的属性和指定的属性: a,先看获取所有的属性的写法: 1.//获取整个类 2. Class c = Class.forName("https://www.wendangku.net/doc/fd16518273.html,ng.Integer"); 3.//获取所有的属性? 4. Field[] fs = c.getDeclaredFields(); 5. 6.//定义可变长的字符串,用来存储属性 7. StringBuffer sb = new StringBuffer(); 8.//通过追加的方法,将每个属性拼接到此字符串中 9.//最外边的public定义 10. sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n"); 11.//里边的每一个属性 12.for(Field field:fs){ 13. sb.append("\t");//空格 14. sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符,例如 public,static等等 15. sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字 16. sb.append(field.getName()+";\n");//属性的名字+回车

Java 面试题精编版—反射

Java 面试题精编版—反射 ——动力节点java 面试题 什么是reflection?其他语言有这种特点吗? 答案:Java中的反射是一种强大的工具,它能够创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行链接。反射允许在编写与执行时,使程序代码能够接入装载到JVM 中的类的内部信息,而不是源代码中选定的类协作的代码。这使反射成为构建灵活应用的主要工具。需要注意的是,如果使用不当,发射的成本会很高。 Java中的类发射reflection是Java程序开发语言的特征之一,它允许运行中的Java程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性。Java的这一能力在实际应用中也许用的不是很多,但是在其他程序语言中根本就不存在这一特性,例如,Pascal、C、或者C++中就没有办法在程序中获得与函数定义相关的信息。 拓展知识 反射主要是指程序可以访问,检测和修改它本身的状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域相关应用反射性的研究。它首先被程序语言的设计领域所应用,并在LISP和面向对象方面取得了成绩,其中LEAD/LEAD++、OpenC++、MetaXa和OpenJava 等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统、操作系统和文件系统中。 反射本身并不是一个新概念,他可能会被联想到光学中的反射概念,尽管计算机科学赋予了反射概念新的含义,但是从现象上来说,它们能够自描述和自控制。也就是说,这类应用通过采用某种机制来实现对自己行为的描述和监测,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。可以看出,与一般的反射概念相比,计算机科学领域的反射不单单指反射本身,还包括堆发射结果所采取的措施。所有采用发反射机制的系统都希望使系统的实现更开放。可以说,实现了反射机制的系统都具有开放性,但具有开放性的系统并不一定采用了反射机制,开放性是反射系统的必要条件。一般来说,反射系统除了满足开放性条件外,还必须满足原因连接。所谓原因连接,是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况,反之亦然。开放性和原因连接是反射系统的两大基本要素。

一个例子让你了解Java反射机制

一个例子让你了解Java反射机制 JAVA反射机制: 通俗地说,反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们. 理论的东东太多也没用,下面我们看看实践 Demo ~ Demo: 1.package cn.lee.demo; 2. 3.import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Constructor; 4.import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Field; 5.import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.InvocationTargetException; 6.import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Method; 7.import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.Modifier; 8.import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.TypeVariable; 9. 10.public class Main { 11. /** 12. * 为了看清楚Java反射部分代码,所有异常我都最后抛出来给虚拟机处 理! 13. * @param args 14. * @throws ClassNotFoundException 15. * @throws InstantiationException 16. * @throws IllegalAccessException 17. * @throws InvocationTargetException 18. * @throws IllegalArgumentException 19. * @throws NoSuchFieldException 20. * @throws SecurityException 21. * @throws NoSuchMethodException 22. */

java基础反射代码详解总结

1工厂设计模式 1.1工厂方法模式 概述 ?工厂:就是生产特定产品的 ?实现方式: 1>创建一个抽象工厂类,声明抽象方法 2>写一个具体的抽象工厂类的子类,由子类负责对象的创建?优点:后期维护容易,增强了系统的扩展性 ?缺点:需要额外的编写代码,增加了工作量 代码

1.2简单工厂模式 概述 ?又叫静态工厂方法模式,它定义一个具体的工厂类负责创建一些类的实例?特点:一个类负责很多对象的创建 代码

2类的加载 2.1类加载的过程 当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三步来实现对这个类进行初始化。 加载 就是指将class文件读入内存,并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。 连接 验证是否有正确的内部结构,并和其他类协调一致 准备负责为类的静态成员分配内存,并设置默认初始化值 解析将类的二进制数据中的符号引用替换为直接引用 初始化 就是给属性赋值 2.2类加载时机-【面试题】 ?加载的原则-用到的时候才加字节码 ?比如: ?创建类的实例 ?访问类的静态变量,或者为静态变量赋值 ?调用类的静态方法 ?初始化某个类的子类 ?直接使用java.exe命令来运行某个主类 ?使用反射方式来强制创建某个类或接口对应的https://www.wendangku.net/doc/fd16518273.html,ng.Class对象 2.3类加载器 类加载器的概述 负责将.class文件加载到内存中,并为之生成对应的Class对象。虽然我们不需要关心类加载机制,但是了解这个机制我们就能更好的理解程序的运行。

类加载器的分类 ?Bootstrap ClassLoader 根类加载器 ?Extension ClassLoader 扩展类加载器 ?System ClassLoader 系统类加载器 各类加载器的作用 Bootstrap ClassLoader 根类加载器 也被称为引导类加载器,负责Java核心类的加载 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中 Extension ClassLoader 扩展类加载器 负责JRE的扩展目录中jar包的加载。 在JDK中JRE的lib目录下ext目录 System ClassLoader 系统类加载器 负责在JVM启动时加载来自java命令的class文件,以及classpath环境变量所指定的jar 包和类路径 3 反射 3.1反射概述 ?JAVA反射机制是在运行状态中,对于任意一个类都能够知道这个类的所有属性和方法;?对于任意一个对象,都能通过反射够调用它的任意一个方法和属性; ?要想解剖一个类,必须先要获取到该类的字节码文件对象。 3.2 获取字节码对象三种方式 ?Object类的getClass()方法,判断两个对象是否是同一个字节码文件 ?静态属性class,锁对象 ?Class类中静态方法forName()

深入理解Java反射机制汇总

深入理解Java反射机制 本文较为详细的分析了Java反射机制。分享给大家供大家参考,具体如下: 一、预先需要掌握的知识(java虚拟机) java虚拟机的方法区: java虚拟机有一个运行时数据区,这个数据区又被分为方法区,堆区和栈区,我们这里需要了解的主要是方法区。方法区的主要作用是存储被装载的类的类型信息,当java虚拟机装载某个类型的时候,需要类装载器定位相应的class文件,然后将其读入到java虚拟机中,紧接着虚拟机提取class 中的类型信息,将这些信息存储到方法区中。这些信息主要包括: 1、这个类型的全限定名 2、这个类型的直接超类的全限定名 3、这个类型是类类型还是接口类型 4、这个类型的访问修饰符 5、任何直接超接口的全限定名的有序列表 6、该类型的常量池 7、字段信息 8、方法信息 9、除了常量以外的所有类变量 10、一个到class类的引用 等等(读者可以参考《深入java虚拟机》这本书的叙述) Class类: Class类是一个非常重要的java基础类,每当装载一个新的类型的时候,java虚拟机都会在java堆中创建一个对应于新类型的Class实例,该实例就代表此类型,通过该Class实例我们就可以访问该类型的基本信息。上面说到在方法区中会存储某个被装载类的类型信息,我们就可以通过Class实例来访问这些信息。比如,对于上面说到的信息Class中都有对应的方法,如下:

1、getName();这个类型的全限定名 2、getSuperClass();这个类型的直接超类的全限定名 3、isInterface();这个类型是类类型还是接口类型 4、getTypeParamters();这个类型的访问修饰符 5、getInterfaces();任何直接超接口的全限定名的有序列表 6、getFields();字段信息 7、getMethods();方法信息 等等(读者可以自己参看jdk帮助文档,得到更多的信息) 二、java反射详解 反射的概念:所谓的反射就是java语言在运行时拥有一项自观的能力,反射使您的程序代码能够得到装载到JVM中的类的内部信息,允许您执行程序时才得到需要类的内部信息,而不是在编写代码的时候就必须要知道所需类的内部信息,这使反射成为构建灵活的应用的主要工具。 反射的常用类和函数:Java反射机制的实现要借助于4个类:Class,Constructor,Field,Method;其中class代表的是类对象,Constructor-类的构造器对象,Field-类的属性对象,Method -类的方法对象,通过这四个对象我们可以粗略的看到一个类的各个组成部分。其中最核心的就是Class类,它是实现反射的基础,它包含的方法我们在第一部分已经进行了基本的阐述。应用反射时我们最关心的一般是一个类的构造器、属性和方法,下面我们主要介绍Class 类中针对这三个元素的方法: 1、得到构造器的方法 Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数,Constructor[] getConstructors() -- 获得类的所有公共构造函数 Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关) Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 2、获得字段信息的方法

反射(reflection)学习整理

反射学习整理 【摘要】 本文主要通过自己对反射机制的总结编写的文档,主要目的就是为了自己以后能可以参考温习也可以方便刚刚入门的同仁们学习指导,通过doc的编写相信可以在帮助别人的同时提高自己。 反射机制; Reflection API; 如何使用反射机制; 反射机制的应用举例; 第一节反射机制 什么是反射机制,说的通俗一些就是在java运行期间动态加载一些不确定的类对象,那么我们如何使用一个类的呢?当然大多数情况下我们是使用一个确定的类,然后通过在内存中的加载再使用之。 其实在一个project中会有很多类,虚拟机并不是在每一次运行时都将所有的类都进行加载然后解析的,是在我们使用的过程中才会被加载,这个大家可以看一下ClassLoader(在后期中我也会编写ClassLoader相关的文章总结) 反射机制提供的功能: 加载运行时才能确定的数据类型; 解析类的结构,获取其内部的信息; 能够操作的类型或者实例; 1. 访问属性; 2. 调用方法; 3. 创建新的对象; 以上的功能我会在接下来的文字中都进行阐述,然后每一个功能点都会通过代码的形式进行逐一的说明举例; 1.1动态加载类 Java虚拟机在运行是能加载的类型有如下几种: 类接口; 数组; 枚举; 注解(Annotation,可以参见我的另一篇文档,《java Annotation学习文档》); 基本数据类型; 在类加载的时候,JVM会自动加载上述类型对应的Class对象。 package com.wangwenjun.demo;

import java.util.ArrayList; public class ReflectionDemo1 { private final static String LIST_STRING="java.util.ArrayList"; //动态加载java.util.ArrayList的类路径 @SuppressWarnings("unchecked") public static void main(String[] args) { try { Class clazz=Class.forName(LIST_STRING); //通过反射获取运行时的Class ArrayList list=(ArrayList) clazz.newInstance(); //通过newInstance方法获取Object list.add("hello"); System.out.println(list.size()+":"+list.get(0)); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } 执行结果为:1:hello 通过上面的代码我们可以总结出来使用Reflection大致需要如下的几步: 获取目标对象的Class对象; 调用Class对象内省方法获取目标对类成员信息; 访问目标类的成员属性; 1.2解析类的结构 通过第一步的操作,我们获取了目标对象的class之后就可以解析出来class对应的内部结构;别不多说直接上代码,来看看如何解析出来目标对象; 我们定义一个Teacher类 package com.wangwenjun.demo; public class Teacher { private String username; private int age;

Java中类反射机制基本原理

Java中的类反射机制 一、反射的概念 反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、Open C++ 、Meta Xa和Open Java等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统、操作系统和文件系统中。 反射本身并不是一个新概念,它可能会使我们联想到光学中的反射概念,尽管计算机科学赋予了反射概念新的含义,但是,从现象上来说,它们确实有某些相通之处,这些有助于我们的理解。在计算机科学领域,反射是指一类应用,它们能够自描述和自控制。也就是说,这类应用通过采用某种机制来实现对自己行为的描述(self-representation)和监测(examination),并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。可以看出,同一般的反射概念相比,计算机科学领域的反射不单单指反射本身,还包括对反射结果所采取的措施。所有采用反射机制的系统(即反射系统)都希望使系统的实现更开放。可以说,实现了反射机制的系统都具有开放性,但具有开放性的系统并不一定采用了反射机制,开放性是反射系统的必要条件。一般来说,反射系统除了满足开放性条件外还必须满足原因连接(Causally-connected)。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况,反之亦然。开放性和原因连接是反射系统的两大基本要素。 Java中,反射是一种强大的工具。它使您能够创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行源代表链接。反射允许我们在编写与执行时,使我们的程序代码能够接入装载到JVM中的类的内部信息,而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是:如果使用不当,反射的成本很高。 二、Java类反射 Reflection 是Java 程序开发语言的特征之一,它允许运行中的Java 程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,Pascal、C 或者C++ 中就没有办法在程序中获得函数定义相关的信息。 1.检测类 1.1 reflection的工作机制 考虑下面这个简单的例子,让我们看看reflection 是如何工作的。 import https://www.wendangku.net/doc/fd16518273.html,ng.reflect.*; public class DumpMethods { public static void main(String args[]) { try { Class c = Class.forName(args[0]); Method m[] = c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) System.out.println(m[i].toString()); } catch (Throwable e) { System.err.println(e); }

技术-Java防反编译技术

Java防反编译技术 1简介 1.1 Java软件面临的挑战 目前,由于黑客的频繁活动,使得Java类文件面临着反编译的挑战。有一些工具能够对Java 源代码进行反工程,其结果甚至以比普通Java文件更可读的方式, 尽管普通的Java文件(由于代码风格不同)有注释。许可证和软件过期对于用户们来说将变得无用。因此,防止软件被反编译或使得反编译的结果变得无意义对于Java来说非常重要。 一个Java类文件不一定非要存储在一个真正的文件里;它可以存在存贮器缓冲区,或从一个网络流获得。尽管防火墙和网络协议如TCP/IP有安全策略,黑客仍能打破访问限制获取一些类。尽管这些类能被混淆,他们(黑客)能够一步一步地分析和猜出每个指令的目的。如果这些代码是关键技术部分,例如是大产品的许可证或时间期满部分,反编译和分析指令的努力似乎很值得。如果这些关键类被隐藏或被一个关键字加密,黑客的非法入侵就很困难了。而且,未认证的软件复制对智能产权是普遍的攻击。还没有一个较好的通用方案来解决这类问题。 目前关于JA V A程序的加密方式不外乎JA V A混淆处理(Obfuscator)和运用ClassLoader 方法进行加密处理这两种方式(其他的方式亦有,但大多是这两种的延伸和变异)。 1.2 混淆处理 关于JA V A程序的加密方式,一直以来都是以JA V A混淆处理(Obfuscator)为主。这方面的研究结果也颇多,既有混淆器(如现在大名鼎鼎的JODE,SUN开发的JADE),也有针对反编译器的"炸弹"(如针对反编译工具Mocha的"炸弹" Crema和HoseMocha)。混淆器,从其字面上,我们就可以知道它是通过混淆处理JA V A代码,具体的说,就是更换变量名,函数名,甚至类名等方法使其反编译出来的代码变得不可理解。它的目的是:让程序无法被自动反编译,就算被反编译成功,也不容易被程序员阅读理解 其实这只是做到了视觉上的处理,其业务逻辑却依然不变,加以耐心,仍是可以攻破的,如果用在用户身份验证等目的上,完全可以找到身份验证算法而加以突破限制。 1.3 采用ClassLoader加密 JA V A虚拟机通过一个称为ClassLoader的对象装来载类文件的字节码,而ClassLoader 是可以由JA V A程序自己来定制的。ClassLoader是如何装载类的呢?ClassLoader根据类名在jar包中找到该类的文件,读取文件,并把它转换成一个Class对象。该方法的原理就是,

JAVA的类反射机制

JAVA的类反射机制 一、什么是反射: 反射的概念是由Smith 在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp 和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa 和 OpenJava 等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统、操作系统和文件系统中。 反射本身并不是一个新概念,尽管计算机科学赋予了反射概念新的含义。在计算机科学领域,反射是指一类应用,它们能够自描述和自控制。也就是说,这类应用通过采用某种机制来实现对自己行为的描述(self-representation)和监测(examination),并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。 二、什么是Java 中的类反射: Reflection 是Java 程序开发语言的特征之一,它允许运行中的Java 程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性和方法。Java 的这一能力在实际应用中用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,Pascal、C 或者 C++ 中就没有办法在程序中获 得函数定义相关的信息。 Reflection 是Java 被视为动态(或准动态)语言的关键,允许程序于执行期Reflection APIs 取得任何已知名称之class 的內部信息,包括package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers,並可于执行期生成instances、变更fields 內容或唤起methods。 三、Java 类反射中所必须的类: Java 的类反射所需要的类并不多,它们分别是:Field、Constructor、Method、Class、Object,下面我将对这些类做一个简单的说明。 Field 类:提供有关类或接口的属性的信息,以及对它的动态访问权限。反射的字段可能是一个类(静态)属性或实例属性,简单的理解可以把它看成一个封装反射类的属性的类。

java反射机制详解与应用

java有着一个非常突出的动态相关机制:Reflection。这个字的意思是“反射、映象、倒影”,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods1。这种“看透class”的能力(the ability of the program to examine itself)被称为introspection(内省、内观、反省)。Reflection和introspection是常被并提的两个术语。 这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息,包括其modifiers(诸如public, static 等等)、superclass(例如Object)、实现之interfaces (例如Cloneable),也包括fields和methods的所有信息,并可于运行时改变fields内容或唤起methods。 目前好多框架都会用到java的反射机制。比如struts2,sping,hibernate。 如果我们不用struts2,自己写一个类似的功能也是可以实现的,比如浏览器通过HTTP发送数据,而这些数据都是字符串,我们接受到这些字符串时,可以通过反射去构造一个对象(通过拦截器做成框架的功能),这样就可以用对象的get和set方法了,而不用原始的getPeremter 方法。事实上,在struts2出来之前,我们又不想用struts1的ActionForm就做过这样项目。 一、Class object 的产生方式有以下几种。 1、运用getClass() 注:每个class 都有此函数 String str = "abc"; Class c1 = str.getClass(); 2、运用static method Class.forName()(最常被使用) Class c1 = Class.forName ("https://www.wendangku.net/doc/fd16518273.html,ng.String"); Class c2 = Class.forName ("java.awt.Button"); 3、运用.class 语法 Class c1 = String.class; Class c2 = java.awt.Button.class; 4、运用primitive wrapper classes的TYPE 语法 Class c1 = Integer.TYPE; Class c2 = Long.TYPE; 二、Java类反射中的主要方法 对于以下三类组件中的任何一类来说-- 构造函数、字段和方法-- https://www.wendangku.net/doc/fd16518273.html,ng.Class 提供四种

Java反射访问私有变量和私有方法

Java反射访问私有变量和私有方法 引言 对于软件开发人员来说,单元测试是一项必不可少的工作。它既可以验证程序的有效性,又可以在程序出现BUG 的时候,帮助开发人员快速的定位问题所在。但是,在写单元测试的过程中,开发人员经常要访问类的一些非公有的成员变量或方法,这给测试工作带来了很大的困扰。本文总结了访问类的非公有成员变量或方法的四种途径,以方便测试人员在需要访问类非公有成员变量或方法时进行选择。 尽管有很多经验丰富的程序员认为不应该提倡访问类的私有成员变量或方法,因为这样做违反了Java 语言封装性的基本规则。然而,在实际测试中被测试的对象千奇百怪,为了有效快速的进行单元测试,有时我们不得不违反一些这样或那样的规则。本文只讨论如何访问类的非公有成员变量或方法,至于是否应该在开发测试中这样做,则留给读者自己根据实际情况去判断和选择。 方法一:修改访问权限修饰符 先介绍最简单也是最直接的方法,就是利用Java 语言自身的特性,达到访问非公有成员的目的。说白了就是直接将private 和protected 关键字改为public 或者直接删除。我们建议直接删除,因为在Java 语言定义中,缺省访问修饰符是包可见的。这样做之后,我们可以另建一个源码目录——test 目录(多数IDE 支持这么做,如Eclipse 和JBuilder),然后将测试类放到test 目录相同包下,从而达到访问待测类的成员变量和方法的目的。此时,在其它包的代码依然不能访问这些变量或方法,在一定程度上保障了程序的封装性。 下面的代码示例展示了这一方法。 清单1. 原始待测类 A 代码 public class A { private String name = null; private void calculate() { } }

java 6个机制

*克隆机制 克隆就是在内存中复制对象,Java克隆(Clone)是Java语言的特性之一,但在实际中应用比较少见。但有时候用克隆会更方便更有效率。(缺点应该是多分配了一块空间,占内存吧,如果数据量大,内存占用的就大) 对于克隆(Clone),Java有一些限制: 1、被克隆的类必须自己实现Cloneable 接口,以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。Cloneable 接口实际上是个标识接口,没有任何接口方法。 2、实现Cloneable接口的类应该使用公共方法重写 Object.clone(它是受保护的)。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的,也无法保证它将获得成功。 3、在https://www.wendangku.net/doc/fd16518273.html,ng.Object类中克隆方法是这么定义的: protected Object clone()throws CloneNotSupportedException{ } 创建并返回此对象的一个副本。表明是一个受保护的方法,同一个包中可见。 按照惯例,返回的对象应该通过调用 super.clone 获得。 克隆分为深克隆和浅克隆 浅度克隆:浅度克隆对于要克隆的对象,对于其基本数据类型的属性,复制一份给新产生的对象,对于非基本数据类型的属性,仅仅复制一份引用给新产生的对象,即新产生的对象和原始对象中的非基本数据类型的属性都指向的是同一个对象; 深度克隆:在浅度克隆的基础上,对于要克隆的对象非基本数据类型的属性对应的类,也实现克隆,这样对于非基本数据类型的属性,复制的不是同一份引用,即新产生的对象和原始对象中的非基本数据类型的属性指向的不是同一个对象。 *序列化机制 序列化也叫串行化,试讲对象转换成紧凑的二进制域的形式,使该对象具备可以被持久化即永久保存的特性。 序列化的必要性 Java中,一切都是对象,在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。 这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。 如何序列化一个对象

相关文档 最新文档