在运行时刻从文件中调入Class(defineClass 的使用)
时间：2010-06-10 来源：lzn_sc
了解JAVA的类装载器：
Java 编程语言编译器把源代码代码转换成为一个假定机器（即虚拟机）上的 机器语言。虚拟机代码保存在一个后缀为.class的类文件中。每个类文件保存这
个类的所有方法的虚拟机代码。
当运行时用一个解释程序解释这些类文件，把这些文件内的虚拟机指信信令翻 译成本地的机器语言，分存内存，确定程序入口点。
类装载器功能类似与C中调入dll文件文法，在C中是调入dll文件分配内存，确定 程序入口点（分配入口指针），而在java中调入一个class文件，同样是从本地或网络
中调入文件，转换为本地机器代码，分配内存，确定程序入口点。
当我们在使用中有时要使用一个新类，知道它的文件路径和它的文件名字，我们 要把它调入系统并使用它或者说一个类文件已经被加密处理，类文件里面的内容
是我们加密后的密文，不能直接使用，只能是对文件内容解密后才能使用，就可 以用类库加载器ClassLoader，把类文件当做数据流读入到一个byte[]中，对
这个 byte[]进行解密处理后（没加密当然就不用做这步了），再通过 byte[] 生成一个类，并加载到系统中。
对于使用中有以下两种方法：
方法1
使用接口类,新调用的class是对它的具体实现
1) 写一个接口类 newface.class
public interface newface {
public void out(String xx);
public int outsize(String x1,String x2);
}
2) 写接口文件实现 testfacea.class 并更名为 testfacea.file 或其它文件名全可以
/*
newface的实现
*/
public class testfacea implements newface{
public void out(String xx) {
System.out.println(xx+" for testfacea ");
}
public int outsize(String x1,String x2) {
return x1.length()+x2.length();;
}
}
执行的的命令
javac testfacea.java
ren testfacea.class testfacea.file
3) 在主程序中调入文件到byte[]中,可以在文件可以在本地,也可用网络无论如何只要能将编译后的文件内容的类代码放到 byte[]当中就可以
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
4) 转换成一个Class并初始化
return defineClass(classname,classbyte,0,readsize);
5) 实现接口
实际上就是对一个接口类用调入的文件实现,当然可以用不同的文件进行不同的实现也可以对一个文件进行加解密操作,
//方法 1 的例子代码,newface是本地接口类,newface.class本地已经存在 开始
testc=cl.load("testfacea.file","testfacea");
testo=testc.newInstance();
((newface)testo).out("方法1 第(1)种使用方法");
System.out.println("outsize="+((newface)testo).outsize("1111","aaaa"));
或
testc=cl.load("testfacea.fisle","testfacea");
testo=testc.newInstance();
newface newface1=(newface)testo;
newface1.out("方法1 第(2)种使用方法");
System.out.println("outsize="+newface1.outsize("22222","bbbbb"));
要注意的是对一个要调入的文件,一定要是一个已经存在的接口类的实现这个有点EJB中的调用的中远程接口要在本地,而调入的文件就是EJBobject了这种方法的的好处是要调入的class中的方法是可以说是已知的,相对来讲这种方法简明易用以下是主程序的完整代码
//使用的主程序
public class testnewface {
public static void main(String[] args) throws java.lang.Exception
{
// 共用初使化参数,开始
Class testc;
Object testo;
cloader cl=new cloader();
// 共用初使化参数,结束
//方法 1 的例子代码,newface是本地接口类,newface.class本地已经存在 开始
testc=cl.load("testfacea.file","testfacea");
testo=testc.newInstance();
((newface)testo).out("方法1 第(1)种使用方法");
System.out.println("outsize="+((newface)testo).outsize("1111","aaaa"));
testc=cl.load("testfacea.fisle","testfacea");
testo=testc.newInstance();
newface newface1=(newface)testo;
newface1.out("方法1 第(2)种使用方法");
System.out.println("outsize="+newface1.outsize("22222","bbbbb"));
//方法 1 的例子代码,结束
}
}
/*
要想自己完成从一个 byte[] 转换到一个Class 必须要 extends ClassLoader
因为ClassLoader中的方法defineClass是 protected 要使用只有 extends ClassLoader
*/
class cloader extends ClassLoader {
static int maxsize=10000;
public Class load(String namefile,String classname) throws java.lang.Exception
{
try {
//进行判断这个class是否已经调入,已经有就直接返回,不然就调入
Class ctmp=this.findLoadedClass(classname);
System.out.println(ctmp.getName()+" is load");
return ctmp;
}
catch (Exception e) {
//System.out.println(e);
}
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
//实际应用时完全可以对一个文件进行加解密处理,只要保证使用defineClass时classbyte中
//已经解密后的内容就可以
int readsize;
readsize=in.read(classbyte);
// System.out.println("读文件长:"+readsize);
in.close();
return defineClass(classname,classbyte,0,readsize);
}
}
方法2
不使用本地接口类的方法,这种方法class从文件定义成一个class和方法1是相同的,但要使用这个class就不同了,这种方法不需要接口类,
1) 写一个类 testfacea.class (本例中为了方便还是使用了testfacea,实际上已经可以不用 implements
newface,即可以完全不用接口类)
public class testfacea {
public void out(String xx) {
System.out.println(xx+" for testfacea ");
}
public int outsize(String x1,String x2) {
return x1.length()+x2.length();;
}
}
为明析起见还有一个测试用类型：一个列系统信息表的类
public class listinfo {
public static void main(String[] args) {
//列系统信息表 begin
String skey,sinfo;
Object so;
java.util.Enumeration hlistkey=System.getProperties().propertyNames();
while (hlistkey.hasMoreElements())
{
skey=(String)hlistkey.nextElement();
so=System.getProperty(skey);
System.out.println("key="+skey+" info="+so);
}
//列系统信息表 end
}
}
2) 生成 testfacea.class 更名为 testfacea.file 或其它文件名也可以
生成 listinfo.class 更名为 listinfo.file 或其它文件名也可以
执行的的命令
javac testfacea.java
ren testfacea.class testfacea.file
javac listinfo.java
ren listinfo.class listinfo.file
3) 主程序中调入文件到byte[]中,可以在本地文件调用,也可用网络无论如何只要能将编译后的文件内容的类代码放到 byte[]当中就可以
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
4) 转换成一个Class
return defineClass(classname,classbyte,0,readsize);
5)如果调用的方法不是static,那么要初始化一个 Object
6) 用java.lang.Class 中的 getMethod(方法名,Class 类型的参数数组) 得到一个
java.lang.reflect.Method 就是说从一个class取到它的方法后调用这个方法
7 ) 使用java.lang.reflect.Method 中的 invoke(Object,new Object[]{参数1,参数2,...})
调用方法,invoke 返回一个Object,Object 的实际就是相应方法的返回类型,如果调用的方法不是static,那么Object
就放入初始化一个的Object,否则放一个 null 值
8) 转换相应的类型到正确对应的Class
本方法要在写程序时已知要调入的class中的方法名,参数,返回类型和相应功能,相对来讲复杂一些
主程序代码：
*/
//使用的主程序
public class testnewface {
public static void main(String[] args) throws java.lang.Exception
{
// 共用初使化参数,开始
Class testc;
Object testo;
cloader cl=new cloader();
// 共用初使化参数,结束
//方法 2 的例子代码,开始
testc=cl.load("testfacea.fisle","testfacea");
testo=testc.newInstance();
String x="方法2 第(1)种使用方法--进行 Instance";
java.lang.reflect.Method mout=testc.getMethod("out",new Class[]{x.getClass()});
System.out.println("mout name="+mout.getName());
mout.invoke(testo,new Object[]{x});
String x1="33333",x2="cccccc";
java.lang.reflect.Method moutsize=testc.getMethod("outsize",new Class[]{x1.getClass(),x2.getClass()});
System.out.println("mout name="+moutsize.getName());
Integer xx=(Integer)moutsize.invoke(testo,new Object[]{x1,x2});
System.out.println(xx.intValue());
//方法(2) 不进行Instance,---调用了另外一个有main的类
testc=cl.load("listinfo.file","listinfo");
System.out.println("testc="+testc.getName());
java.lang.reflect.Method m=testc.getMethod("main",new Class[]{args.getClass()});
System.out.println("m="+m.getName());
m.invoke(null,new Object[]{args});
//方法 2 的例子代码,结束
}
}
/*
要想自己完成从一个 byte[] 转换到一个Class 必须要 extends ClassLoader
因为ClassLoader中的方法defineClass是 protected 要使用只有 extends ClassLoader
*/
class cloader extends ClassLoader {
static int maxsize=10000;
public Class load(String namefile,String classname) throws java.lang.Exception
{
try {
//进行判断这个class是否已经调入,已经有就直接返回,不然就调入
Class ctmp=this.findLoadedClass(classname);
System.out.println(ctmp.getName()+" is load");
return ctmp;
}
catch (Exception e) {
//System.out.println(e);
}
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
//实际应用时完全可以对一个文件进行加解密处理,只要保证使用defineClass时classbyte中
//已经解密后的内容就可以
int readsize;
readsize=in.read(classbyte);
// System.out.println("读文件长:"+readsize);
in.close();
return defineClass(classname,classbyte,0,readsize);
}
}
小结:
但是Java并不提供一个类似于类库卸载器(ClassUnloader) 的功能，能够把已经装载的模块从内存里面清除掉。所以如果一个class已经调入,就放在了内存当中,并在程序信息表内记录本class已经调入,如果再一次使用就从内存当中调入,如果实际文件更新也只能是程序下次运行时间再调入,而不能在运行期间更新一个class,如果强行再一次调入就会
Linkage Error: duplicate class definition (重复定义class) 所以在每次调用前用 findLoadedClass 方法进行一下判断。
Java 编程语言编译器把源代码代码转换成为一个假定机器（即虚拟机）上的 机器语言。虚拟机代码保存在一个后缀为.class的类文件中。每个类文件保存这
个类的所有方法的虚拟机代码。
当运行时用一个解释程序解释这些类文件，把这些文件内的虚拟机指信信令翻 译成本地的机器语言，分存内存，确定程序入口点。
类装载器功能类似与C中调入dll文件文法，在C中是调入dll文件分配内存，确定 程序入口点（分配入口指针），而在java中调入一个class文件，同样是从本地或网络
中调入文件，转换为本地机器代码，分配内存，确定程序入口点。
当我们在使用中有时要使用一个新类，知道它的文件路径和它的文件名字，我们 要把它调入系统并使用它或者说一个类文件已经被加密处理，类文件里面的内容
是我们加密后的密文，不能直接使用，只能是对文件内容解密后才能使用，就可 以用类库加载器ClassLoader，把类文件当做数据流读入到一个byte[]中，对
这个 byte[]进行解密处理后（没加密当然就不用做这步了），再通过 byte[] 生成一个类，并加载到系统中。
对于使用中有以下两种方法：
方法1
使用接口类,新调用的class是对它的具体实现
1) 写一个接口类 newface.class
public interface newface {
public void out(String xx);
public int outsize(String x1,String x2);
}
2) 写接口文件实现 testfacea.class 并更名为 testfacea.file 或其它文件名全可以
/*
newface的实现
*/
public class testfacea implements newface{
public void out(String xx) {
System.out.println(xx+" for testfacea ");
}
public int outsize(String x1,String x2) {
return x1.length()+x2.length();;
}
}
执行的的命令
javac testfacea.java
ren testfacea.class testfacea.file
3) 在主程序中调入文件到byte[]中,可以在文件可以在本地,也可用网络无论如何只要能将编译后的文件内容的类代码放到 byte[]当中就可以
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
4) 转换成一个Class并初始化
return defineClass(classname,classbyte,0,readsize);
5) 实现接口
实际上就是对一个接口类用调入的文件实现,当然可以用不同的文件进行不同的实现也可以对一个文件进行加解密操作,
//方法 1 的例子代码,newface是本地接口类,newface.class本地已经存在 开始
testc=cl.load("testfacea.file","testfacea");
testo=testc.newInstance();
((newface)testo).out("方法1 第(1)种使用方法");
System.out.println("outsize="+((newface)testo).outsize("1111","aaaa"));
或
testc=cl.load("testfacea.fisle","testfacea");
testo=testc.newInstance();
newface newface1=(newface)testo;
newface1.out("方法1 第(2)种使用方法");
System.out.println("outsize="+newface1.outsize("22222","bbbbb"));
要注意的是对一个要调入的文件,一定要是一个已经存在的接口类的实现这个有点EJB中的调用的中远程接口要在本地,而调入的文件就是EJBobject了这种方法的的好处是要调入的class中的方法是可以说是已知的,相对来讲这种方法简明易用以下是主程序的完整代码
//使用的主程序
public class testnewface {
public static void main(String[] args) throws java.lang.Exception
{
// 共用初使化参数,开始
Class testc;
Object testo;
cloader cl=new cloader();
// 共用初使化参数,结束
//方法 1 的例子代码,newface是本地接口类,newface.class本地已经存在 开始
testc=cl.load("testfacea.file","testfacea");
testo=testc.newInstance();
((newface)testo).out("方法1 第(1)种使用方法");
System.out.println("outsize="+((newface)testo).outsize("1111","aaaa"));
testc=cl.load("testfacea.fisle","testfacea");
testo=testc.newInstance();
newface newface1=(newface)testo;
newface1.out("方法1 第(2)种使用方法");
System.out.println("outsize="+newface1.outsize("22222","bbbbb"));
//方法 1 的例子代码,结束
}
}
/*
要想自己完成从一个 byte[] 转换到一个Class 必须要 extends ClassLoader
因为ClassLoader中的方法defineClass是 protected 要使用只有 extends ClassLoader
*/
class cloader extends ClassLoader {
static int maxsize=10000;
public Class load(String namefile,String classname) throws java.lang.Exception
{
try {
//进行判断这个class是否已经调入,已经有就直接返回,不然就调入
Class ctmp=this.findLoadedClass(classname);
System.out.println(ctmp.getName()+" is load");
return ctmp;
}
catch (Exception e) {
//System.out.println(e);
}
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
//实际应用时完全可以对一个文件进行加解密处理,只要保证使用defineClass时classbyte中
//已经解密后的内容就可以
int readsize;
readsize=in.read(classbyte);
// System.out.println("读文件长:"+readsize);
in.close();
return defineClass(classname,classbyte,0,readsize);
}
}
方法2
不使用本地接口类的方法,这种方法class从文件定义成一个class和方法1是相同的,但要使用这个class就不同了,这种方法不需要接口类,
1) 写一个类 testfacea.class (本例中为了方便还是使用了testfacea,实际上已经可以不用 implements
newface,即可以完全不用接口类)
public class testfacea {
public void out(String xx) {
System.out.println(xx+" for testfacea ");
}
public int outsize(String x1,String x2) {
return x1.length()+x2.length();;
}
}
为明析起见还有一个测试用类型：一个列系统信息表的类
public class listinfo {
public static void main(String[] args) {
//列系统信息表 begin
String skey,sinfo;
Object so;
java.util.Enumeration hlistkey=System.getProperties().propertyNames();
while (hlistkey.hasMoreElements())
{
skey=(String)hlistkey.nextElement();
so=System.getProperty(skey);
System.out.println("key="+skey+" info="+so);
}
//列系统信息表 end
}
}
2) 生成 testfacea.class 更名为 testfacea.file 或其它文件名也可以
生成 listinfo.class 更名为 listinfo.file 或其它文件名也可以
执行的的命令
javac testfacea.java
ren testfacea.class testfacea.file
javac listinfo.java
ren listinfo.class listinfo.file
3) 主程序中调入文件到byte[]中,可以在本地文件调用,也可用网络无论如何只要能将编译后的文件内容的类代码放到 byte[]当中就可以
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
4) 转换成一个Class
return defineClass(classname,classbyte,0,readsize);
5)如果调用的方法不是static,那么要初始化一个 Object
6) 用java.lang.Class 中的 getMethod(方法名,Class 类型的参数数组) 得到一个
java.lang.reflect.Method 就是说从一个class取到它的方法后调用这个方法
7 ) 使用java.lang.reflect.Method 中的 invoke(Object,new Object[]{参数1,参数2,...})
调用方法,invoke 返回一个Object,Object 的实际就是相应方法的返回类型,如果调用的方法不是static,那么Object
就放入初始化一个的Object,否则放一个 null 值
8) 转换相应的类型到正确对应的Class
本方法要在写程序时已知要调入的class中的方法名,参数,返回类型和相应功能,相对来讲复杂一些
主程序代码：
*/
//使用的主程序
public class testnewface {
public static void main(String[] args) throws java.lang.Exception
{
// 共用初使化参数,开始
Class testc;
Object testo;
cloader cl=new cloader();
// 共用初使化参数,结束
//方法 2 的例子代码,开始
testc=cl.load("testfacea.fisle","testfacea");
testo=testc.newInstance();
String x="方法2 第(1)种使用方法--进行 Instance";
java.lang.reflect.Method mout=testc.getMethod("out",new Class[]{x.getClass()});
System.out.println("mout name="+mout.getName());
mout.invoke(testo,new Object[]{x});
String x1="33333",x2="cccccc";
java.lang.reflect.Method moutsize=testc.getMethod("outsize",new Class[]{x1.getClass(),x2.getClass()});
System.out.println("mout name="+moutsize.getName());
Integer xx=(Integer)moutsize.invoke(testo,new Object[]{x1,x2});
System.out.println(xx.intValue());
//方法(2) 不进行Instance,---调用了另外一个有main的类
testc=cl.load("listinfo.file","listinfo");
System.out.println("testc="+testc.getName());
java.lang.reflect.Method m=testc.getMethod("main",new Class[]{args.getClass()});
System.out.println("m="+m.getName());
m.invoke(null,new Object[]{args});
//方法 2 的例子代码,结束
}
}
/*
要想自己完成从一个 byte[] 转换到一个Class 必须要 extends ClassLoader
因为ClassLoader中的方法defineClass是 protected 要使用只有 extends ClassLoader
*/
class cloader extends ClassLoader {
static int maxsize=10000;
public Class load(String namefile,String classname) throws java.lang.Exception
{
try {
//进行判断这个class是否已经调入,已经有就直接返回,不然就调入
Class ctmp=this.findLoadedClass(classname);
System.out.println(ctmp.getName()+" is load");
return ctmp;
}
catch (Exception e) {
//System.out.println(e);
}
java.io.FileInputStream in=new java.io.FileInputStream(namefile);
byte[] classbyte=new byte[maxsize];
//实际应用时完全可以对一个文件进行加解密处理,只要保证使用defineClass时classbyte中
//已经解密后的内容就可以
int readsize;
readsize=in.read(classbyte);
// System.out.println("读文件长:"+readsize);
in.close();
return defineClass(classname,classbyte,0,readsize);
}
}
小结:
但是Java并不提供一个类似于类库卸载器(ClassUnloader) 的功能，能够把已经装载的模块从内存里面清除掉。所以如果一个class已经调入,就放在了内存当中,并在程序信息表内记录本class已经调入,如果再一次使用就从内存当中调入,如果实际文件更新也只能是程序下次运行时间再调入,而不能在运行期间更新一个class,如果强行再一次调入就会
Linkage Error: duplicate class definition (重复定义class) 所以在每次调用前用 findLoadedClass 方法进行一下判断。
相关阅读 更多 +
