Penjelasan terperinci tentang mekanisme refleksi penyahserialisasian Java dengan contoh

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu yang berkaitan dengan mekanisme refleksi java Fungsi mendapatkan maklumat program secara dinamik dan memanggil objek secara dinamik dipanggil pantulan bahasa Java , saya harap ia akan membantu semua orang.

Pembelajaran yang disyorkan: "tutorial java"

Setiap kali saya mendengar bos besar bercakap atau menonton forum dan cara lain untuk belajar java Apabila menyahsiri kelemahan, terdapat perkataan yang dipanggil mekanisme refleksi. Bos menggunakan perkataan ini untuk membuat muatan untuk anda. jadi saya cepat mengambil pengajaran, jika tidak jurang antara saya dan orang besar akan menjadi lebih luas dan lebih luas. Jadi artikel ini terutamanya bercakap tentang mekanisme pantulan Java

mekanisme pantulan Java

mekanisme pantulan Java (refleksi) bermaksud bahawa dalam keadaan berjalan program, objek dari mana-mana kelas boleh dibina boleh memahami Kelas yang mana objek kepunyaan boleh memahami pembolehubah ahli dan kaedah mana-mana kelas, dan boleh memanggil sifat dan kaedah mana-mana objek. Fungsi mendapatkan maklumat program secara dinamik dan memanggil objek secara dinamik ini dipanggil mekanisme pantulan bahasa Java. Refleksi dilihat sebagai kunci kepada bahasa dinamik.

Saya tidak begitu mahir untuk menyatakan diri saya dengan kata-kata, jadi saya hanya akan melakukannya dalam gambar di atas

Contoh tidak menggunakan mekanisme pantulan

//定义一个animals接口interface animals {
    public abstract void print();}//定义类来实现animals接口的抽象方法class Dog implements animals {
    public void print() {
        System.out.println("Dog");
    }}class Cat implements animals {
    public void print() {
        System.out.println("Cat");
    }}// 构造一个zoo类// 之后如果我们在添加其他的实例的时候只需要修改zoo类class zoo {

    public static animals getInstance(String animalsName) {
        animals a = null;
        if ("Dog".equals(animalsName)) {
            a = new Dog();
        }
        if ("Cat".equals(animalsName)) {
            a = new Cat();
        }
        return a;
    }}public class reflection {
    public static void main(String[] args) {
        //借助zoo类寻找对应的类来实现接口
        animals a=zoo.getInstance("Cat");
        if(a!=null)
            a.print();
    }}

Untuk menambah haiwan pada masa ini, hanya

• Tambah kelas
• Ubah suai zoo
• Ubah suai kelas haiwan bagi fungsi utama

Ubah suai di atas kepada mekanisme pantulan

//定义一个animals接口interface animals {
    public abstract void print();}//定义类来实现animals接口的抽象方法class Dog implements animals {
    public void print() {
        System.out.println("Dog");
    }}class Cat implements animals {
    public void print() {
        System.out.println("Cat");
    }}// 构造一个zoo类// 之后如果我们在添加其他的实例的时候只需要修改zoo类class zoo {

    public static animals getInstance(String className) {
        animals a = null;
        try {
            //借助Class.forName寻找类名，并用newInstance实例化类似于new
            a = (animals) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return a;
    }}public class reflection {
    public static void main(String[] args) {
        //借助zoo类寻找对应的类来实现接口(classname为当前包名加类名)
        animals a = zoo.getInstance("com.cc1.Dog");
        if (a != null)
            a.print();
    }}

Pada masa ini, untuk menambah haiwan, anda hanya perlu

• Tambah kelas
• Ubah suai kelas haiwan bagi fungsi utama

, yang menyimpan satu langkah dan nama kelas masuk boleh dikawal Nampaknya semua kelas sedia ada boleh melaraskan

kaedah mekanisme refleksi

Yang paling kami gunakan mungkin

forName (kelas panggilan)
• getMethod (panggil kaedah di bawah kelas)
• invoke (laksana)
• newInstance (instantiate objek)

Class.forName(className).getMethod(methodName).invoke(Class.forName(className).newInstance());

Di bawah kami menggunakan mekanisme pantulan untuk muncul komputer ( calc) atau Notepad (notepad)

Sejak terdapat terlalu banyak tetingkap timbul pada komputer, saya akan munculkan Notepad kali ini Secara keseluruhannya, sangat bagus untuk dapat memaparkannya

Runtime.getRuntime().exec("notepad");

Jom ambil. lihat fungsi getRuntime

dan ketahui bahawa fungsi ini adalah cara untuk kelas Runtime mendapatkan objek Secara peribadi, saya rasa sukar untuk memanggilnya setiap kali ia digunakan untuk memanggilnya sekali untuk mencipta objek, ia dirangkumkan ke dalam Fungsi

Cara mendapatkan objek kelas

Class.forName (mendapatkan nama kelas)
• zoo.class (kelas sudah dimuatkan )
• obj.class (contoh)
• 
  

Pengamatan kelas

Ubah suai kelas zoo dan tambahkan blok awal, Blok permulaan statik dan pembina

class zoo {
    //初始块
    {
        System.out.println("1  " + this.getClass());
    }

    //静态初始块
    static {
        System.out.println("2  " + zoo.class);
    }

    public zoo() {
        System.out.println("3  " + this.getClass());
    }

    public static animals getInstance(String className) {
        animals a = null;
        try {
            //借助Class.forName寻找类名，并用newInstance实例化类似于new
            a = (animals) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return a;
    }}

Perintah pelaksanaan permulaan kelas: Blok permulaan statik

Perintah pelaksanaan instansi kelas : Blok permulaan statik - > Blok permulaan - > >
Seterusnya Tambahkan kelas zoo1 untuk mewarisi kelas zoo
urutan pemulaan subkelas

: blok pemula statik kelas induk - > >

class zoo1 extends zoo{
    //初始块
    {
        System.out.println("11  " + this.getClass());
    }

    //静态初始块
    static {
        System.out.println("12  " + zoo.class);
    }

    public zoo1() {
        System.out.println("13  " + this.getClass());
    }}

Jujukan instantiasi subkelas

: Blok pemula statik kelas induk - > Blok pemula kelas induk - > ;Fungsi pembinaan subkelas
Seperti yang dapat dilihat dari di atas, apabila Class.forName digunakan dan blok permulaan statik kelas boleh dikawal, sebarang kod boleh dilaksanakan

panggil Inner class
Class.forName("java.lang.Runtime") untuk mendapatkan kelas (java.lang.Runtime ialah laluan penuh Runtime kelas)

getMethod

Fungsi getMethod adalah untuk mendapatkan kaedah awam khusus kelas melalui refleksi.

Java menyokong pembebanan kelas, tetapi fungsi tidak boleh ditentukan dengan hanya nama fungsi, jadi apabila memanggil getMethod, anda perlu menghantar senarai jenis parameter kaedah

Class.forName("java.lang.Runtime ") .getMethod(“exec”, String.class)

invoke

静态和动态方法的区别

invoke方法在getMethod类下，作用时传递参数，执行方法
public Object invoke(Object obj, Object… args)
第一个参数是getMethod获取的方法的类对象（如果方法是静态方法则传类）
获取exec函数的类对象
Class.forName(“java.lang.Runtime”).getMethod(“getRuntime”).invoke(Class.forName(“java.lang.Runtime”))
由于getRuntime是静态方法，所以传类
invoke(Class.forName(“java.lang.Runtime”).getMethod(“getRuntime”).invoke(Class.forName(“java.lang.Runtime”))，“calc.exe”)

最后我们合并一下

Class.forName("java.lang.Runtime").
                getMethod("exec", String.class).
                invoke(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime")), "notepad");

指定构造方法生成实例

String str="notepad";ProcessBuilder pb = new ProcessBuilder(str);pb.start();

getConsturctor(函数可以选定指定接口格式的构造函数(由于构造函数也可以根据参数来进行重载)
选定后我们可以通过newInstance(),并传入构造函数的参数执行构造函数

ProcessBuilder类有两个构造函数

• public ProcessBuilder(String… command)（String…变长的字符串数组String[].class）
• public ProcessBuilder(List command)

分别使用构造方法

• Class.forName(“java.lang.ProcessBuilder”).getConstructor(String[].class).newInstance(new String[][]{{“notepad”}})
• Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))

执行完构造方法实例后，在进行强制转化使用start函数即可

( (ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))).start();

实际中，肯定用不了，哪有这么好的事，还是接着反射把

Class.forName(“java.lang.ProcessBuilder”).getMethod(“start”).invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList(“notepad”)));

这里可能有人会好奇我写的里那的另一个构造函数，String…command这个传参为什么用new String[][]{{“notepad”}}，不应该是new String[]{“notepad”},现在用应该的

((ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(String[].class).newInstance(new String[]{“notepad”})).start();

在这行打断点调试

我们传的是一个字符串数组到了实例化的时候变成了一个字符串，再看看另一个构造函数（List）

( (ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))).start();

依旧还是这行打断点

由此可知，List传入时会被当作Object的第一项，而String[]会被当做Object，所以多加一层[]{}

执行私有方法

通过函数getDeclaredConstructor获取私有方法，再利用setAccessible(true)打破私有方法限制

Class cls = Class.forName("java.lang.Runtime"); 
Constructor m = cls.getDeclaredConstructor();
 m.setAccessible(true); 
 cls.getMethod("exec", String.class).invoke(m.newInstance(), "notepad");

 推荐学习：《java视频教程》

Atas ialah kandungan terperinci Penjelasan terperinci tentang mekanisme refleksi penyahserialisasian Java dengan contoh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!