Java Reflection-2021 Interview Questions Series Tutorial (with answer analysis) -Vernacular interprétation-JavaPub version

Java Reflection-2021 Interview Questions Series Tutorial (with answer analysis) -Vernacular interprétation-JavaPub version

Préface

Quelle que soit la hauteur du cadre, il nécessite également une base solide pour jouer, et les questions d'entretien à haute fréquence sont la clé du combat réel à haute fréquence dans la fondation.

Convient aux lecteurs

Apprenants et passionnés de Java, personnes techniques ayant une certaine expérience de travail, intervieweurs potentiels, etc.

Lire les suggestions

Ce tutoriel est une série de tutoriels, y compris les bases de Java, JVM, conteneur, multithreading, réflexion, exception, réseau, copie d'objet, JavaWeb, modèles de conception, Spring-Spring MVC, Spring Boot / Spring Cloud, Mybatis / Hibernate, Kafka, RocketMQ , Zookeeper, MySQL, Redis, Elasticsearch, Lucene. Abonnez-vous pour ne pas vous perdre, Orly donne 2021.

Liste de connaissances JavaPub

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

[robinet]

sujet

Préface

1. Qu'est-ce que la réflexion?

Encyclopédie Baidu:

Le mécanisme de réflexion de Java signifie que dans l'état d'exécution du programme, vous pouvez construire un objet de n'importe quelle classe, vous pouvez comprendre la classe à laquelle appartient n'importe quel objet, vous pouvez comprendre les variables membres et les méthodes de n'importe quelle classe, et vous pouvez appeler n'importe quel Propriétés et méthodes de l'objet. La fonction d'acquisition dynamique d'informations de programme et d'appel dynamique d'objets est appelée le mécanisme de réflexion du langage Java. La réflexion est considérée comme la clé des langages dynamiques.

Dans l'environnement d'exécution Java, pour n'importe quelle classe, pouvez-vous connaître les attributs et méthodes de la classe? Pour tout objet, l'une de ses méthodes peut-elle être appelée

Le mécanisme de réflexion Java fournit principalement les fonctions suivantes:

Déterminez la classe à laquelle appartient un objet au moment de l'exécution.
Construisez un objet de n'importe quelle classe au moment de l'exécution.
Jugez les variables membres et les méthodes de n'importe quelle classe au moment de l'exécution.
Appelez la méthode de n'importe quel objet au moment de l'exécution.

Géant de référence JavaPub: https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html

À ce stade, si vous avez encore des doutes sur la réflexion Java, je reviendrai sur le compte officiel JavaPub et donnerai une explication plus détaillée.

2. Qu'est-ce que la sérialisation Java? Dans quelles circonstances besoin d'une sérialisation?

La sérialisation et la désérialisation sont les connaissances les plus élémentaires de Java, et il est facile de se faire oublier par tout le monde. Bien que vous l'utilisiez tous les jours, vous ne pourrez peut-être pas l'expliquer clairement. Je pense que beaucoup d'amis n'ont que quelques concepts et mots-clés (sérialisable). Si vous vous demandez comment la sérialisation et la désérialisation sont implémentées, les scénarios d'utilisation, etc., vous risquez d'être perdu. Chaque fois que j'examine, en tant qu'intervieweur, les bases de Java, je pose généralement des questions sur la connaissance de la sérialisation et de la désérialisation pour mesurer ses bases de Java. Lorsqu'on lui a demandé ce qu'est la sérialisation Java? Qu'est-ce que la désérialisation? Dans quels scénarios sera-t-il utilisé? Si vous ne l’utilisez pas, quels problèmes se poseront? En général, la réponse de chacun ne se résume qu’à quelques concepts simples. Certains candidats qui travaillent depuis plusieurs années ne peuvent même pas expliquer clairement le concept et ont l’air ennuyeux.

Qu'est-ce que la sérialisation et la désérialisation

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

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

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

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

En termes simples, il s'agit de sauvegarder l'état de divers objets en mémoire (c'est-à-dire des variables d'instance, pas de méthodes) et de lire l'état de l'objet sauvegardé. Bien que vous puissiez utiliser vos propres méthodes pour enregistrer les états d'objet, Java vous fournit un mécanisme qui devrait être meilleur que le vôtre pour enregistrer les états d'objet, à savoir la sérialisation.

Dans quelles circonstances besoin de sérialisation

Lorsque vous souhaitez enregistrer l'état de l'objet en mémoire dans un fichier ou une base de données;
Lorsque vous souhaitez utiliser des sockets pour transférer des objets sur le réseau;
Lorsque vous souhaitez transférer des objets via RMI;

Pourquoi vous devez utiliser la sérialisation et la désérialisation

Nous savons que lors de la communication à distance entre différents processus / programmes, différents types de données peuvent être envoyés les uns aux autres, y compris du texte, des images, de l'audio, de la vidéo, etc., et ces données seront transmises sur le réseau sous la forme d'un binaire. séquence.

Ainsi, lorsque deux processus Java communiquent, le transfert d'objets entre processus peut-il être réalisé? Bien sur, c'est possible! Comment faire? Cela nécessite l'utilisation de la sérialisation et de la désérialisation Java. L'expéditeur doit convertir cet objet Java en une séquence d'octets, puis le transmettre sur le réseau, et le récepteur doit restaurer l'objet Java à partir de la séquence d'octets.

Après avoir compris pourquoi nous devons utiliser la sérialisation et la désérialisation Java, nous pensons naturellement aux avantages de la sérialisation Java:

Réaliser la persistance des données Grâce à la sérialisation, les données peuvent être enregistrées en permanence sur le disque dur (par exemple: stockées dans un fichier) pour obtenir une conservation permanente de l'objet.
Utilisez la sérialisation pour obtenir une communication à distance, c'est-à-dire la possibilité de transmettre des objets sur le réseau.

Géant de référence JavaPub: https://xcbeyond.blog.csdn.net/article/details/100046212

3. Qu'est-ce qu'un proxy dynamique? Quelles sont les applications?

Proxy dynamique: au moment de l'exécution, créez une classe cible, vous pouvez appeler et étendre la méthode de la classe cible.

La manière de réaliser des dynamiques en Java: proxy dynamique en JDK et bibliothèque de classes Java CGLib.

Scénarios d'application tels que:

Comptez la consommation de temps de chaque demande d'API
Sortie de journal unifiée
Vérifiez si l'API appelée a été connectée et authentifiée
Le module de fonction AOP de Spring utilise un mécanisme de proxy dynamique pour réaliser la programmation d'aspect

Géant de référence JavaPub: https://www.cnblogs.com/aheizi/p/4861422.html

4. Comment implémenter un proxy dynamique?

Dans le domaine Java, il existe deux méthodes d'implémentation de proxy dynamique couramment utilisées, l'une consiste à utiliser le mécanisme de réflexion JDK pour générer le proxy et l'autre à utiliser le proxy CGLIB.

Le proxy JDK doit fournir une interface, mais CGLIB n'a pas besoin de proxy de la classe directement. Des exemples sont donnés ci-dessous.

1. Proxy dynamique JDK:

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. Agent dynamique CGLIB

需要引入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();
    }
}

Géant de référence JavaPub: https://www.cnblogs.com/xifengxiaoma/p/9377261.html

Comment utiliser la réflexion de Java?

Créer un objet avec un nom de classe complet

Class.forName ("Nom complet de la classe"); Par exemple: la classe com.mysql.jdbc.Driver Driver a été chargée dans le jvm et l'initialisation de la classe est terminée.
Nom de la classe.classe; Obtenir la classe <? > objet clz
Object.getClass ();

Obtenez l'objet constructeur et créez un objet via le constructeur new

Clazz.getConstructor ([String.class]);
Con.newInstance ([Paramètre]);

Créez un objet instance via l'objet de classe (il est équivalent au nouveau constructeur sans argument de nom de classe ())

Cls.newInstance ();

Obtenir un objet attribut via l'objet de classe

Field c = cls.getFields (): Récupère tous les champs publics (publics) d'une certaine classe, y compris les champs de la classe parent.
Field c = cls.getDeclaredFields (): Récupère tous les champs déclarés d'une certaine classe, y compris public, private et protected, mais sans inclure les champs déclarés de la classe parent

Obtenir un objet méthode via l'objet classe

Cls.getMethod ("nom de la méthode", classe …… parameaType); (seuls les publics peuvent être obtenus)
Cls.getDeclareMethod ("nom de la méthode"); (Obtient une méthode arbitrairement décorée, ne peut pas exécuter en privé)
M.setAccessible (true); (rendre les méthodes privées exécutables)

Laisser la méthode s'exécuter

Method.invoke (objet instance obj, paramètre variable obj); ----- (a une valeur de retour)

2021 面试题，认准 JavaPub。