类加载的两种方式:forName()和loadClass()详解

2020-05-19  本文已影响0人  啊啊啊哼哼哼

forName()

 public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException
package jvm.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class reflectTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, NoSuchFieldException, InvocationTargetException {
        Class r = Class.forName("jvm.reflect.Shop");
        //能访问私有的方法,但是不能访问继承或者实现接口的方法
        Method getName = r.getDeclaredMethod("getName", String.class);
        //因为getName是私有方法,所以要把方法设置为true
        getName.setAccessible(true);

        //不能访问私有的方法,但是可以访问继承或者实现接口的方法
        Method outName = r.getMethod("outName");

        //通过newInstance创建一个对象,但是不能传递参数
        Shop s = (Shop) r.newInstance();

        //获得属性name
        Field name = r.getDeclaredField("name");
        //将私有属性设置为可访问
        name.setAccessible(true);
        //传递参数,设置name属性值
        name.set(s, "qinxiaoyu");

        //获得属性name
        Field id = r.getDeclaredField("id");
        //将私有属性设置为可访问
        id.setAccessible(true);
        //传递参数,设置name属性值
        id.set(s, 419);

        System.out.println(getName.invoke(s, "hello"));
        outName.invoke(s);
    }
}

loadClass()

A class loader is an object that is responsible for loading classes. The class <tt>ClassLoader</tt> is an abstract class.  Given the <a href="#name">binary name</a> of a class, a class loader should attempt to locate or generate data that constitutes a definition for the class.  A typical strategy is to transform the name into a file name and then read a "class file" of that name from a file system.

自定义一个类加载器,继承ClassLoader,重写ClassLoader的findClass方法

        public Class findClass(String name) {
              byte[] b = loadClassData(name);
              return defineClass(name, b, 0, b.length);
         }
 
          private byte[] loadClassData(String name) {
              // load the class data from the connection
              &nbsp;.&nbsp;.&nbsp;.
          }
package jvm.reflect;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class MyClassLoader extends ClassLoader {
    //文件路径
    private String path;

    MyClassLoader(String path) {
        this.path = path;
    }

    //加载文件数据,然后通过defineClass将二进制文件数据转换为类的对象
    @Override
    public Class findClass(String name) throws ClassNotFoundException {
        byte[] b = new byte[0];
        try {
            b = loadClassData(name);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return defineClass(name, b, 0, b.length);
    }

    //按照文件名,加载文件,返回二进制数组
    private byte[] loadClassData(String name) throws IOException {
        name = path + name + ".class";
        FileInputStream in = new FileInputStream(new File(name));
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int i;
        while ((i = in.read()) != -1) {
            out.write(i);
        }
        out.close();
        in.close();
        return out.toByteArray();
    }
}

类的隐式加载和显示加载

loadClass与forName的区别

SpringIOC的lazyLoading, SpringIOC为了加快初始化的速度,大量使用延迟加载技术,用ClassLoader不需要进行初始化,可以加快加载速度,

package jvm.reflect;

//public class Shop {
//    private String name;
//    private int id;
//    private String getName(String head){
//        return head+" "+this.name;
//    }
//    public void outName(){
//        System.out.println(id+" "+this.name);
//    }
//    static{
//        System.out.println("load Shop Class");
//    }
//}

public class LoadTest {
    public static void main(String[] args) throws ClassNotFoundException {
//        Class r = Shop.class.getClassLoader().loadClass("jvm.reflect.Shop");
        Class r = Class.forName("jvm.reflect.Shop");
    }
}
上一篇 下一篇

猜你喜欢

热点阅读