java重新加载类

㈠ java编程细节 java是怎么加载类的

一.加载 通过类的全限定名转换为二进制字节流,在jvm堆中生成代表这个Class的对象,作为方法区域的方法入口.
二.连接 1.验证:验证class的字节流是否对jvm虚拟机造成伤害,是否符合jvm的规范,这里包含几个验证. 2.准备:为类的static变量赋初始值,其中不包含类其它实例成员的初始化. 3.解析:将常量池内的符号引用替换成直接引用三.初始化 这里是static{}块,构造函数,代码块{}的执行过程.四.使用 对象的属性,方法等调用操作.五.销毁 jvm通过确定对象没有引用后进行gc操作.

㈡ java重载和重写的区别

首先我们来讲讲：重载(Overloading)

（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。

（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

然后我们再来谈谈 重写（Overriding）

（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。

（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

（3）子类函数的访问修饰权限不能少于父类的；

㈢ java如何实现类加载

重新定义类加载器，也就是ClassLoader，覆盖其中的一个方法findClass
例如，应用程序可以创建一个网络类加载器，从服务器中下载类文件。示例代码如下所示：

ClassLoader loader = new NetworkClassLoader(host, port);
Object main = loader.loadClass("Main", true).newInstance();
. . .

㈣ java 怎么向getsystemclassloader中加载新的类

ClassLoader: ClassLoader是一个抽象类，一般的系统有一个缺省的ClassLoader用来装载Class， 用ClassLoader.getSystemClassLoader()可以得到。不过有时候为了安全或有其它的特殊需要可以自定义自己的ClassLoader来进行loader一些需要的Class， 比如有的产品它用了自己的ClassLoader可以指定Class只从它指定的特定的JAR文件里面来loader，如果想通过覆盖ClassPath方法来想让它用Class是行不通的。 有兴趣的可以参照Java API 的更详细的用法说明。

㈤ JAVA中如何重新加载.properties文件，使其他引用实时改变

*Spring提供的PropertiesLoaderUtils允许您直接通过基于类路径的文件地址加载属性资源

*最大的好处就是：实时加载配置文件，修改后立即生效，不必重启

*/
privatestaticvoidspringUtil(){
Propertiesprops=newProperties();
while(true){
try{
props=PropertiesLoaderUtils.loadAllProperties("message.properties");
for(Objectkey:props.keySet()){
System.out.print(key+":");
System.out.println(props.get(key));
}
}catch(IOExceptione){
System.out.println(e.getMessage());
}
try{
Thread.sleep(5000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}

㈥ Java 类加载器怎么实现将同一个对象加载两次

类A中有一个字段a，它的类型为X
类B中有一个字段b，它的类型也为X
类A由classLoaderA所加载，类B由classLoaderB所加载
执行赋值语句A.a
=
B.b，由于这两个类型均为X，可以执行，但是有一个要求，这个要求就是在A中所装载类X的装载器必须和在B中装载类X的装载器相同，否则赋值语句失败！

㈦ java类加载顺序

记住 3 条原则：
1、父类优先于子类
2、属性优先于代码块优先于构造方法
3、静态优先于非静态
因此，类加载顺序为：
父类静态变量->父类静态语句块->子类静态变量->子类静态语句块->父类普通成员变量->父类动态语句块->父类构造器->子类普通成员变量->子类动态语句块->子类构造器

㈧ java重新加载class文件

Java类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类(像是基类)完全加载到jvm中，至于其他类，则在需要的时候才加载。这当然就是为了节省内存开销。
Java的类加载器有三个，对应Java的三种类:
Bootstrap Loader // 负责加载系统类 (指的是内置类，像是String，对应于C#中的System类和C/C++标准库中的类)
|
- - ExtClassLoader // 负责加载扩展类(就是继承类和实现类)
|
- - AppClassLoader // 负责加载应用类(程序员自定义的类)
三个加载器各自完成自己的工作，但它们是如何协调工作呢？哪一个类该由哪个类加载器完成呢？为了解决这个问题，Java采用了委托模型机制。
委托模型机制的工作原理很简单：当类加载器需要加载类的时候，先请示其Parent(即上一层加载器)在其搜索路径载入，如果找不到，才在自己的搜索路径搜索该类。这样的顺序其实就是加载器层次上自顶而下的搜索，因为加载器必须保证基础类的加载。之所以是这种机制，还有一个安全上的考虑：如果某人将一个恶意的基础类加载到jvm，委托模型机制会搜索其父类加载器，显然是不可能找到的，自然就不会将该类加载进来。
我们可以通过这样的代码来获取类加载器:
ClassLoader loader = ClassName.class.getClassLoader();
ClassLoader ParentLoader = loader.getParent();

注意一个很重要的问题，就是Java在逻辑上并不存在BootstrapKLoader的实体！因为它是用C++编写的，所以打印其内容将会得到null。
前面是对类加载器的简单介绍，它的原理机制非常简单，就是下面几个步骤:
1.装载:查找和导入class文件;
2.连接:
(1)检查:检查载入的class文件数据的正确性;
(2)准备:为类的静态变量分配存储空间;
(3)解析:将符号引用转换成直接引用(这一步是可选的)
3.初始化:初始化静态变量，静态代码块。
这样的过程在程序调用类的静态成员的时候开始执行，所以静态方法main()才会成为一般程序的入口方法。类的构造器也会引发该动作。

㈨ 如何使用javassist修改已经加载的类的方法

参考手册：

1、读取和输出字节码

ClassPool pool = ClassPool.getDefault();
//会从classpath中查询该类
CtClass cc = pool.get("test.Rectangle");
//设置.Rectangle的父类
cc.setSuperclass(pool.get("test.Point"));
//输出.Rectangle.class文件到该目录中
cc.writeFile("c://");
//输出成二进制格式
//byte[] b=cc.toBytecode();
//输出并加载class 类，默认加载到当前线程的ClassLoader中，也可以选择输出的ClassLoader。
//Class clazz=cc.toClass();

这里可以看出，Javassist的加载是依靠ClassPool类，输出方式支持三种。

2、新增Class
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");
//新增方法
cc.addMethod(m);
//新增Field
cc.addField(f);

从上面可以看出，对Class的修改主要是依赖于CtClass 类。API也比较清楚和简单。

3、冻结Class
当CtClass 调用writeFile()、toClass()、toBytecode() 这些方法的时候，Javassist会冻结CtClass Object，对CtClass object的修改将不允许。这个主要是为了警告开发者该类已经被加载，而JVM是不允许重新加载该类的。如果要突破该限制，方法如下：
CtClasss cc = ...;
:
cc.writeFile();
cc.defrost();
cc.setSuperclass(...); // OK since the class is not frozen.

当 ClassPool.doPruning=true的时 候，Javassist 在CtClass object被冻结时，会释放存储在ClassPool对应的数据。这样做可以减少javassist的内存消耗。默认情况 ClassPool.doPruning=false。例如

CtClasss cc = ...;
cc.stopPruning(true);
:
cc.writeFile(); // convert to a class file.
// cc没有被释放

提示：当调试时，可以调用debugWriteFile()，该方法不会导致CtClass被释放。

4、Class 搜索路径
从上面可以看出Class 的载入是依靠ClassPool，而ClassPool.getDefault() 方法的搜索Classpath 只是搜索JVM的同路径下的class。当一个程序运行在JBoss或者Tomcat下，ClassPool Object 可能找到用户的classes。Javassist 提供了四种动态加载classpath的方法。如下

//默认加载方式如pool.insertClassPath(new ClassClassPath(this.getClass()));
ClassPool pool = ClassPool.getDefault();

//从file加载classpath
pool.insertClassPath("/usr/local/javalib")

//从URL中加载
ClassPath cp = new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist.");
pool.insertClassPath(cp);

//从byte[] 中加载
byte[] b = a byte array;
String name = class name;
cp.insertClassPath(new ByteArrayClassPath(name, b));

//可以从输入流中加载class
InputStream ins = an input stream for reading a class file;
CtClass cc = cp.makeClass(ins);

5、ClassPool
5.1 减少内存溢出
ClassPool是一个CtClass objects的装载容器。当加载了CtClass object后，是不会被ClassPool释放的（默认情况下）。这个是因为CtClass object 有可能在下个阶段会被用到。
当加载过多的CtClass object的时候，会造成OutOfMemory的异常。为了避免这个异常，javassist提供几种方法，一种是在上面提到 的 ClassPool.doPruning这个参数，还有一种方法是调用 CtClass.detach()方法，可以把CtClass object 从ClassPool中移除。例如：
CtClass cc = ... ;
cc.writeFile();
cc.detach();

另外一中方法是不用默认的ClassPool即不用 ClassPool.getDefault()这个方式来生成。这样当ClassPool 没被引用的时候，JVM的垃圾收集会收集该类。例如
//ClassPool(true) 会默认加载Jvm的ClassPath
ClassPool cp = new ClassPool(true);
// if needed, append an extra search path by appendClassPath()

5.2 级联ClassPools
javassist支持级联的ClassPool，即类似于继承。例如：
ClassPool parent = ClassPool.getDefault();
ClassPool child = new ClassPool(parent);
child.insertClassPath("./classes");

5.3 修改已有Class的name以创建一个新的Class
当调用setName方法时，会直接修改已有的Class的类名，如果再次使用旧的类名，则会重新在classpath路径下加载。例如：
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.setName("Pair");
//重新在classpath加载
CtClass cc1 = pool.get("Point");

对于一个被冻结（Frozen)的CtClass object ，是不可以修改class name的，如果需要修改，则可以重新加载，例如：
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.writeFile();
//cc.setName("Pair"); wrong since writeFile() has been called.
CtClass cc2 = pool.getAndRename("Point", "Pair");

6、Class loader
上面也提到，javassist同个Class是不能在同个ClassLoader中加载两次的。所以在输出CtClass的时候需要注意下，例如：

// 当Hello未加载的时候，下面是可以运行的。
ClassPool cp = ClassPool.getDefault();
CtClass cc = cp.get("Hello");
Class c = cc.toClass();

//下面这种情况，由于Hello2已加载，所以会出错
Hello2 h=new Hello2();
CtClass cc2 = cp.get("Hello2");
Class c2 = cc.toClass();//这里会抛出java.lang.LinkageError 异常

//解决加载问题，可以指定一个未加载的ClassLoader
Class c3 = cc.toClass(new MyClassLoader());

6.1 使用javassist.Loader
从上面可以看到，如果在同一个ClassLoader加载两次Class抛出异常，为了方便javassist也提供一个Classloader供使用，例如
ClassPool pool = ClassPool.getDefault();
Loader cl = new Loader(pool);
CtClass ct = pool.get("test.Rectangle");
ct.setSuperclass(pool.get("test.Point"));
Class c = cl.loadClass("test.Rectangle");
Object rect = c.newInstance();
:
为了方便监听Javassist自带的ClassLoader的生命周期，javassist也提供了一个listener，可以监听ClassLoader的生命周期，例如：
//Translator 为监听器
public class MyTranslator implements Translator {
void start(ClassPool pool)
throws NotFoundException, CannotCompileException {}
void onLoad(ClassPool pool, String classname)
throws NotFoundException, CannotCompileException
{
CtClass cc = pool.get(classname);
cc.setModifiers(Modifier.PUBLIC);
}
}
//示例
public class Main2 {
public static void main(String[] args) throws Throwable {
Translator t = new MyTranslator();
ClassPool pool = ClassPool.getDefault();
Loader cl = new Loader();
cl.addTranslator(pool, t);
cl.run("MyApp", args);
}
}
//输出
% java Main2 arg1 arg2...

6.2 修改系统Class
由JVM规范可知，system classloader 是比其他classloader 是优先加载的，而system classloader 主要是加载系统Class，所以要修改系统Class，如果默认参数运行程序是不可能修改的。如果需要修改也有一些办法，即在运 行时加入-Xbootclasspath/p: 参数的意义可以参考其他文件。下面修改String的例子如下：
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("java.lang.String");
CtField f = new CtField(CtClass.intType, "hiddenValue", cc);
f.setModifiers(Modifier.PUBLIC);
cc.addField(f);
cc.writeFile(".");
//运行脚本
% java -Xbootclasspath/p:. MyApp arg1 arg2...

6.3 动态重载Class
如果JVM运行时开启JPDA（Java Platform Debugger Architecture），则Class是运行被动态重新载入的。具体方式可以参考java.lang.Instrument。javassist也提 供了一个运行期重载Class的方法，具体可以看API 中的javassist.tools.HotSwapper。

7、Introspection和定制
javassist封装了很多很方便的方法以供使用，大部分使用只需要用这些API即可，如果不能满足，Javassist也提供了一个低层的API（具体参考javassist.bytecode 包）来修改原始的Class。

7.1 插入source 文本在方法体前或者后
CtMethod 和CtConstructor 提供了 insertBefore()、insertAfter()和 addCatch()方法，它们可以插入一个souce文本到存在的方法的相应的位置。javassist 包含了一个简单的编译器解析这souce文本成二进制插入到相应的方法体里。
javassist 还支持插入一个代码段到指定的行数，前提是该行数需要在class 文件里含有。
插入的source 可以关联fields 和methods，也可以关联方法的参数。但是关联方法参数的时，需要在程序编译时加上 -g 选项（该选项可以把本地变量的声明保存在class 文件中，默认是不加这个参数的。）。因为默认一般不加这个参数，所以Javassist也提供了一些特殊的变量来代表方法参 数：$1,$2,$args...要注意的是，插入的source文本中不能引用方法本地变量的声明，但是可以允许声明一个新的方法本地变量，除非在程序 编译时加入-g选项。
方法的特殊变量说明：
$0, $1, $2, ... this and actual parameters
$args An array of parameters. The type of $args is Object[].
$$ All actual parameters.For example, m($$) is equivalent to m($1,$2,...)
$cflow(...) cflow variable
$r The result type. It is used in a cast expression.
$w The wrapper type. It is used in a cast expression.
$_ The resulting value
$sig An array of java.lang.Class objects representing the formal parameter types
$type A java.lang.Class object representing the formal result type.
$class A java.lang.Class object representing the class currently edited.

7.1.1 $0, $1, $2, ...
$0代表的是this，$1代表方法参数的第一个参数、$2代表方法参数的第二个参数,以此类推，$N代表是方法参数的第N个。例如：
//实际方法
void move(int dx, int dy)
//javassist
CtMethod m = cc.getDeclaredMethod("move");
//打印dx，和dy
m.insertBefore("{ System.out.println($1); System.out.println($2); }");
注意：如果javassist改变了$1的值，那实际参数值也会改变。

7.1.2 $args
$args 指的是方法所有参数的数组，类似Object[]，如果参数中含有基本类型，则会转成其包装类型。需要注意的时候，$args[0]对应的是$1,而不是$0，$0!=$args[0]，$0=this。

7.1.3 $$
$$是所有方法参数的简写，主要用在方法调用上。例如：
//原方法
move(String a,String b)
move($$) 相当于move($1,$2)
如果新增一个方法，方法含有move的所有参数，则可以这些写：
exMove($$, context) 相当于 exMove($1, $2, context)

7.1.4 $cflow
$cflow意思为控制流（control flow），是一个只读的变量，值为一个方法调用的深度。例如：
//原方法
int fact(int n) {
if (n <= 1)
return n;
else
return n * fact(n - 1);
}

12 import

㈩ java运行显示“找不到或无法加载主类”！

该如何解决呢？解决办法如下：

1.由于是在运行阶段出现的问题，那么可能是环境变量配置不当的问题，即可能是classpath路径配置错误，而导致.class文件无法加载。那么此时你可以检查是否配置好classpath路径，一般来说classpath路径配置如下：

.;%java_home%lib;%java_home%lib ools.jar； （注意前面的 . 以及 ； 缺一不可）

其中.表示当前路径，；表示分隔符。

2.如果你试过了很多次，classpath也配置对了，依旧出现这个错误，注意你使用的测试代码，是否在某一个包名的下面；

比如说如下测试代码：

在文件所在的当前目录下，运行javac TestPlusPlus.java编译成功，生成TestPlusPlus.class文件，这个时

候，你用javaTestPlusPlus想运行程序，总会出现”找不到或无法加载主类“的错误。这个时候要注意，

之所以找不到，是因为TestPlusPlus在HelloWorld包名的下面。

解决办法：

1.去掉 ”packageHelloWorld;“ 重新用javac 编译TestPlusPlus.java,再运行javaTestPlusPlus就可以了。

2.新建一个包名一样的文件夹，在本例中，为建立一个HelloWorld的文件夹，把TestPlusPlus.java文件移到该目录下。

然后在HelloWorld文件夹的平级下，打开DOS命令窗口，运行javacHelloWorld/TestPlusPlus.java编译程序，

运行javaHelloWorld/TestPlusPlus(或者javaHelloWorld.TestPlusPlus也可以)，则可以运行含有包名的java程序。

注意:包名不要含有'.'(点),' '(空格)等特殊符号，这样的话命令行无法判断包名与java程序名的分割点在哪里，

从而还是找到或者无法加载主类。

原理说明：

java程序运行class文件,对于有包名的类,java把包名当成文件夹处理."包名+类名"相当于"文件夹目录+类名"来寻找类。