Java Reflection-2021 Interview Questions Series Tutorial (mit Antwortanalyse) -Vernakuläre Interpretation-JavaPub-Version

Java Reflection-2021 Interview Questions Series Tutorial (mit Antwortanalyse) -Vernakuläre Interpretation-JavaPub-Version

Vorwort

Vorwort

Unabhängig davon, wie hoch das Framework ist, erfordert es auch eine solide Grundlage zum Spielen, und hochfrequente Interviewfragen sind der Schlüssel für den tatsächlichen Hochfrequenzkampf in der Grundlage.

Geeignet für Leser

Java-Lernende und -Enthusiasten, Techniker mit bestimmter Berufserfahrung, potenzielle Interviewer usw.

Vorschläge lesen

Dieses Tutorial besteht aus einer Reihe von Tutorials, einschließlich Java-Grundlagen, JVM, Container, Multithreading, Reflexion, Ausnahme, Netzwerk, Objektkopie, JavaWeb, Entwurfsmuster, Spring-Spring-MVC, Spring-Boot / Spring-Cloud, Mybatis / Hibernate, Kafka, RocketMQ , Zookeeper, MySQL, Redis, Elasticsearch, Lucene. Abonnieren Sie, um nicht verloren zu gehen, 2021 gibt Orly.

JavaPub-Wissensliste

微信搜：JavaPub，阅读全套系列面试题教程

[Zapfhahn]

Thema

Vorwort

1. Was ist Reflexion?

Baidu-Enzyklopädie:

Der Reflexionsmechanismus von Java bedeutet, dass Sie im laufenden Zustand des Programms ein Objekt einer beliebigen Klasse erstellen, die Klasse, zu der ein Objekt gehört, verstehen, die Elementvariablen und Methoden einer Klasse verstehen und eine beliebige Klasse aufrufen können Eigenschaften und Methoden des Objekts. Die Funktion, Programminformationen dynamisch zu erfassen und Objekte dynamisch aufzurufen, wird als Reflexionsmechanismus der Java-Sprache bezeichnet. Reflexion wird als Schlüssel zu dynamischen Sprachen angesehen.

Können Sie in der Java-Laufzeitumgebung für jede Klasse wissen, über welche Attribute und Methoden die Klasse verfügt? Für jedes Objekt kann eine seiner Methoden aufgerufen werden

Der Java-Reflexionsmechanismus bietet hauptsächlich die folgenden Funktionen:

1. Bestimmen Sie die Klasse, zu der ein Objekt zur Laufzeit gehört.
2. Erstellen Sie zur Laufzeit ein Objekt einer beliebigen Klasse.
3. Beurteilen Sie die Mitgliedsvariablen und Methoden einer Klasse zur Laufzeit.
4. Rufen Sie zur Laufzeit die Methode eines beliebigen Objekts auf.

JavaPub-Referenzriese: https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html

Wenn Sie an dieser Stelle noch Zweifel an der Java-Reflexion haben, gehe ich zurück zum offiziellen JavaPub-Konto und gebe eine detailliertere Erklärung.

2. Was ist Java-Serialisierung? Unter welchen Umständen muss serialisiert werden?

Serialisierung und Deserialisierung sind die grundlegendsten Wissenspunkte in Java, und es ist leicht, von jedem vergessen zu werden. Obwohl Sie es jeden Tag verwenden, können Sie es möglicherweise nicht klar erklären. Ich glaube, dass viele Freunde nur wenige Konzepte und Schlüsselwörter haben (serialisierbar). Wenn Sie sich erkundigen, wie Serialisierung und Deserialisierung implementiert sind, Verwendungsszenarien usw., sind Sie möglicherweise ratlos. Jedes Mal, wenn ich als Interviewer die Grundlagen von Java untersuche, frage ich normalerweise nach dem Wissen über Serialisierung und Deserialisierung, um die Java-Grundlagen zu messen. Auf die Frage, was ist Java-Serialisierung? Was ist Deserialisierung? In welchen Szenarien wird es verwendet? Wenn Sie es nicht verwenden, welche Probleme treten auf? Im Allgemeinen sind alle Antworten nur ein paar einfache Konzepte. Einige Bewerber, die mehrere Jahre gearbeitet haben, können das Konzept nicht einmal klar erklären und sehen langweilig aus.

Was ist Serialisierung und Deserialisierung?

序列化是指将Java对象转换为字节序列的过程，而反序列化则是将字节序列转换为Java对象的过程。

Java对象序列化是将实现了 Serializable 接口的对象转换成一个字节序列，能够通过网络传输、文件存储等方式传输 ，传输过程中却不必担心数据在不同机器、不同环境下发生改变，也不必关心字节的顺序或其他任何细节，并能够在以后将这个字节序列完全恢复为原来的对象(恢复这一过程称之为反序列化)。

对象的序列化是非常有趣的，因为利用它可以实现轻量级持久性，“持久性”意味着一个对象的生存周期不单单取决于程序是否正在运行，它可以生存于程序的调用之间。通过将一个序列化对象写入磁盘，然后在重新调用程序时恢复该对象，从而达到实现对象的持久性的效果。

本质上讲，序列化就是把实体对象状态按照一定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态。

Einfach ausgedrückt, dient es dazu, den Status verschiedener Objekte im Speicher zu speichern (dh Instanzvariablen, keine Methoden) und den Status des gespeicherten Objekts zu lesen. Obwohl Sie Ihre eigenen Methoden zum Speichern von Objektzuständen verwenden können, bietet Ihnen Java einen Mechanismus, der besser als Ihr eigener sein sollte, um Objektzustände zu speichern, nämlich die Serialisierung.

Unter welchen Umständen muss eine Serialisierung durchgeführt werden?

1. Wenn Sie den Objektstatus im Speicher in einer Datei oder Datenbank speichern möchten;
2. Wenn Sie Sockets zum Übertragen von Objekten im Netzwerk verwenden möchten;
3. Wenn Sie Objekte über RMI übertragen möchten;

Warum Sie Serialisierung und Deserialisierung verwenden müssen

Wir wissen, dass bei der Fernkommunikation zwischen verschiedenen Prozessen / Programmen verschiedene Arten von Daten aneinander gesendet werden können, einschließlich Text, Bilder, Audio, Video usw., und diese Daten werden in Form einer Binärdatei im Netzwerk übertragen Reihenfolge.

Kann also bei der Kommunikation zweier Java-Prozesse die Objektübertragung zwischen Prozessen realisiert werden? Natürlich ist es möglich! Wie es geht? Dies erfordert die Verwendung von Java-Serialisierung und -Deserialisierung. Der Absender muss dieses Java-Objekt in eine Byte-Sequenz konvertieren und dann im Netzwerk übertragen, und der Empfänger muss das Java-Objekt aus der Byte-Sequenz wiederherstellen.

Nachdem wir verstanden haben, warum wir Java-Serialisierung und -Deserialisierung verwenden müssen, denken wir natürlich an die Vorteile der Java-Serialisierung:

Realisieren Sie die Persistenz von Daten. Durch Serialisierung können die Daten dauerhaft auf der Festplatte gespeichert werden (z. B. in einer Datei gespeichert), um eine dauerhafte Aufbewahrung des Objekts zu erreichen.
Verwenden Sie die Serialisierung, um eine Remote-Kommunikation zu erreichen, dh die Möglichkeit, Objekte im Netzwerk zu übertragen.

JavaPub-Referenzriese: https://xcbeyond.blog.csdn.net/article/details/100046212

3. Was ist ein dynamischer Proxy? Was sind die Anwendungen?

Dynamischer Proxy: Wenn Sie zur Laufzeit eine Zielklasse erstellen, können Sie die Methode der Zielklasse aufrufen und erweitern.

Der Weg, um Dynamik in Java zu realisieren: dynamischer Proxy in JDK und Java-Klassenbibliothek CGLib.

Anwendungsszenarien wie:

• Zählen Sie den Zeitverbrauch jeder API-Anfrage

• Einheitliche Protokollausgabe

• Überprüfen Sie, ob die aufgerufene API angemeldet und die Authentifizierung autorisiert wurde

• Der AOP-Funktionsbaustein von Spring verwendet einen dynamischen Proxy-Mechanismus, um die Aspektprogrammierung zu realisieren

JavaPub-Referenzriese: https://www.cnblogs.com/aheizi/p/4861422.html

4. Wie implementiere ich einen dynamischen Proxy?

Im Java-Bereich gibt es zwei häufig verwendete dynamische Proxy-Implementierungsmethoden: Die eine besteht darin, den JDK-Reflektionsmechanismus zum Generieren des Proxys zu verwenden, und die andere darin, den CGLIB-Proxy zu verwenden.

Der JDK-Proxy muss eine Schnittstelle bereitstellen, CGLIB muss die Klasse jedoch nicht direkt vertreten. Beispiele sind unten angegeben.

1. Dynamischer JDK-Proxy:

public interface People {
    public void sayHello();
}

public class Chinese implements People {

    @Override
    public void sayHello() {
        System.out.println("Chinese say hello.");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class PeopleInvocationHandler implements InvocationHandler{

    private Object peolple;

    Intermediary(Object people){
        this.people = people;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {        Object invoke = method.invoke(people, args);
        System.out.println("-------- end ---------");
        return invoke;
    }
}

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        People chinese = new People();
        PeopleInvocationHandler invocationHandler = new PeopleInvocationHandler(chinese);
        People proxy = (People) Proxy.newProxyInstance(chinese.getClass().getClassLoader(), chinese.getClass().getInterfaces(), invocationHandler);
        proxy.sayHello();
    }
}

2. CGLIB Dynamic Agent

需要引入CGLIB相关Jar包

public class Chinese {
    public void sayHello(){
        System.out.println("Chinese say hello");
    }
}

import java.lang.reflect.Method;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ChinesePoxy implements MethodInterceptor {

    @Override
    public Object intercept(Object object, Method method, Object[] args,MethodProxy methodProxy) throws Throwable {
        Object intercept = methodProxy.invokeSuper(object, args);
　　　　 System.out.println("-------- end ---------");
　　　　return intercept; 
　　} 
}

import net.sf.cglib.proxy.Enhancer;

public class Test {
    public static void main(String[] args) {
        ChineseProxy chineseProxy = new ChineseProxy();

        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(Chinese.class);
        enhancer.setCallback(chineseProxy);

        Chinese proxy = (Chinese) enhancer.create();
        proxy.sayHello();
    }
}

JavaPub-Referenzriese: https://www.cnblogs.com/xifengxiaoma/p/9377261.html

Wie verwende ich Javas Reflexion?

• Erstellen Sie ein Objekt mit einem vollständig qualifizierten Klassennamen

1. Class.forName ("Vollständiger Klassenname"); Beispiel: Die Treiberklasse com.mysql.jdbc.Driver wurde in die JVM geladen, und die Initialisierung der Klasse ist abgeschlossen.

2. Klassenname.Klasse; Klasse holen <? > clz Objekt

3. Object.getClass ();

• Holen Sie sich das Konstruktorobjekt und erstellen Sie ein Objekt über den Konstruktor new

1. Clazz.getConstructor ([String.class]);
2. Con.newInstance ([Parameter]);

• Erstellen Sie ein Instanzobjekt über das Klassenobjekt (es entspricht dem neuen Konstruktor ohne Argumente für den Klassennamen ().

1. Cls.newInstance ();

• Erhalten Sie ein Attributobjekt über das Klassenobjekt

1. Feld c = cls.getFields (): Ruft alle öffentlichen (öffentlichen) Felder einer bestimmten Klasse ab, einschließlich der Felder in der übergeordneten Klasse.

2. Feld c = cls.getDeclaredFields (): Ruft alle deklarierten Felder einer bestimmten Klasse ab, einschließlich öffentlicher, privater und geschützter Felder, jedoch ohne die deklarierten Felder der übergeordneten Klasse

• Erhalten Sie ein Methodenobjekt über das Klassenobjekt

1. Cls.getMethod ("Methodenname", Klasse …… parameaType); (nur öffentliche können abgerufen werden)

2. Cls.getDeclareMethod ("Methodenname"); (Beliebig dekorierte Methode abrufen, kann nicht privat ausgeführt werden)

3. M.setAccessible (true); (private Methoden ausführbar machen)

• Lassen Sie die Methode ausführen

1. Method.invoke (obj Instanzobjekt, obj Variablenparameter); ----- (hat einen Rückgabewert)

2021 面试题，认准 JavaPub。