Tutorial de la serie de preguntas de entrevista Java Reflection-2021 (con análisis de respuestas) -Interpretación vernácula-Versión JavaPub

Tutorial de la serie de preguntas de entrevista Java Reflection-2021 (con análisis de respuestas) -Interpretación vernácula-Versión JavaPub

Prefacio

No importa qué tan alto sea el marco, también requiere una base sólida para jugar, y las preguntas de entrevistas de alta frecuencia son la clave para el combate real de alta frecuencia en la base.

Apto para lectores

Estudiantes y entusiastas de Java, técnicos con cierta experiencia laboral, posibles entrevistadores, etc.

Leer sugerencias

Este tutorial es una serie de tutoriales que incluyen conceptos básicos de Java, JVM, contenedor, subprocesos múltiples, reflexión, excepción, red, copia de objeto, JavaWeb, patrones de diseño, Spring-Spring MVC, Spring Boot / Spring Cloud, Mybatis / Hibernate, Kafka, RocketMQ , Zookeeper, MySQL, Redis, Elasticsearch, Lucene. Suscríbete para no perderte, Orly 2021 regala.

Lista de conocimientos de JavaPub

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

[grifo]

tema

Prefacio

1. ¿Qué es la reflexión?

Enciclopedia de Baidu:

El mecanismo de reflexión de Java significa que en el estado de ejecución del programa, puede construir un objeto de cualquier clase, puede comprender la clase a la que pertenece cualquier objeto, puede comprender las variables miembro y los métodos de cualquier clase, y puede llamar a cualquier Propiedades y métodos del objeto. La función de adquirir información del programa de forma dinámica y llamar a los objetos de forma dinámica se denomina mecanismo de reflexión del lenguaje Java. La reflexión se considera la clave de los lenguajes dinámicos.

En el entorno de ejecución de Java, para cualquier clase, ¿puede saber qué atributos y métodos tiene la clase? Para cualquier objeto, ¿se puede llamar a cualquiera de sus métodos?

El mecanismo de reflexión de Java proporciona principalmente las siguientes funciones:

Determine la clase a la que pertenece cualquier objeto en tiempo de ejecución.
Construya un objeto de cualquier clase en tiempo de ejecución.
Juzgue las variables miembro y los métodos de cualquier clase en tiempo de ejecución.
Llame al método de cualquier objeto en tiempo de ejecución.

Gigante de referencia JavaPub: https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html

En este punto, si todavía tiene algunas dudas sobre la reflexión de Java, volveré a la cuenta oficial de JavaPub y daré una explicación más detallada.

2. ¿Qué es la serialización de Java? ¿En qué circunstancias necesita la serialización?

La serialización y deserialización son los puntos de conocimiento más básicos en Java, y es fácil que todos lo olviden. Aunque lo use todos los días, es posible que no pueda explicarlo claramente. Creo que muchos amigos solo tienen algunos conceptos y palabras clave (serializables) .Si preguntas acerca de cómo se implementan la serialización y deserialización, escenarios de uso, etc., es posible que no estés en una situación adecuada. Cada vez que yo, como entrevistador, examino los conceptos básicos de Java, suelo preguntar acerca del conocimiento de la serialización y deserialización para medir sus conceptos básicos de Java. Cuando se le preguntó qué es la serialización de Java? ¿Qué es la deserialización? ¿En qué escenarios se utilizará? Si no lo usa, ¿qué problemas surgirán? Generalmente, la respuesta de todos son solo unos pocos conceptos simples. Algunos solicitantes que han trabajado durante varios años ni siquiera pueden explicar el concepto con claridad y parecen aburridos.

¿Qué es la serialización y deserialización?

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

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

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

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

En pocas palabras, se trata de guardar el estado de varios objetos en la memoria (es decir, variables de instancia, no métodos) y leer el estado del objeto guardado. Aunque puede utilizar sus propios métodos para guardar estados de objetos, Java le proporciona un mecanismo que debería ser mejor que el suyo para guardar estados de objetos, que es la serialización.

Bajo que circunstancias necesita serialización

Cuando desee guardar el estado del objeto en la memoria en un archivo o base de datos;
Cuando desee utilizar sockets para transferir objetos en la red;
Cuando desee transferir objetos a través de RMI;

Por qué necesita usar serialización y deserialización

Sabemos que cuando la comunicación remota entre diferentes procesos / programas, se pueden enviar varios tipos de datos entre sí, incluidos texto, imágenes, audio, video, etc., y estos datos se transmitirán en la red en forma de binario. secuencia.

Entonces, cuando dos procesos Java se comunican, ¿se puede realizar la transferencia de objetos entre procesos? ¡Por supuesto que es posible! ¿Cómo hacerlo? Esto requiere el uso de serialización y deserialización de Java. El remitente necesita convertir este objeto Java en una secuencia de bytes y luego transmitirlo en la red, y el receptor necesita restaurar el objeto Java a partir de la secuencia de bytes.

Una vez que entendemos por qué necesitamos usar la serialización y deserialización de Java, naturalmente pensamos en los beneficios de la serialización de Java:

Darse cuenta de la persistencia de los datos A través de la serialización, los datos se pueden guardar permanentemente en el disco duro (como: almacenados en un archivo) para lograr la preservación permanente del objeto.
Utilice la serialización para lograr una comunicación remota, es decir, la capacidad de transmitir objetos en la red.

Gigante de referencia JavaPub: https://xcbeyond.blog.csdn.net/article/details/100046212

3. ¿Qué es un proxy dinámico? Cuales son las aplicaciones?

Proxy dinámico: en tiempo de ejecución, cree una clase de destino, puede llamar y extender el método de la clase de destino.

La forma de realizar dinámicas en Java: proxy dinámico en JDK y biblioteca de clases Java CGLib.

Escenarios de aplicación como:

Cuente el consumo de tiempo de cada solicitud de API
Salida de registro unificada
Verifique si la API llamada ha iniciado sesión y ha autorizado la autenticación
El módulo de función AOP de Spring utiliza un mecanismo de proxy dinámico para realizar la programación de aspectos

Gigante de referencia JavaPub: https://www.cnblogs.com/aheizi/p/4861422.html

4. ¿Cómo implementar un proxy dinámico?

En el campo de Java, hay dos métodos de implementación de proxy dinámico que se usan comúnmente, uno es usar el mecanismo de reflexión JDK para generar el proxy y el otro es usar el proxy CGLIB.

El proxy JDK debe proporcionar una interfaz, pero CGLIB no necesita proxy de la clase directamente. A continuación se dan ejemplos.

1. Proxy dinámico 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. Agente dinámico 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();
    }
}

Gigante de referencia JavaPub: https://www.cnblogs.com/xifengxiaoma/p/9377261.html

¿Cómo utilizar la reflexión de Java?

Crea un objeto con un nombre de clase completamente calificado

Class.forName ("Nombre de clase completo"); Por ejemplo: la clase com.mysql.jdbc.Driver Driver se ha cargado en el jvm y la inicialización de la clase está completa.
Nombre de clase.clase; Obtener clase <? > objeto clz
Object.getClass ();

Obtenga el objeto constructor y cree un objeto a través del constructor nuevo

Clazz.getConstructor ([String.class]);
Con.newInstance ([Parámetro]);

Cree un objeto de instancia a través del objeto de clase (es equivalente al nuevo constructor sin argumentos de nombre de clase ())

Cls.newInstance ();

Obtener un objeto de atributo a través del objeto de clase

Campo c = cls.getFields (): Obtiene todos los campos públicos (públicos) de una determinada clase, incluidos los campos de la clase principal.
Campo c = cls.getDeclaredFields (): Obtiene todos los campos declarados de una determinada clase, incluidos los públicos, privados y protegidos, pero sin incluir los campos declarados de la clase principal

Obtener un objeto de método a través del objeto de clase

Cls.getMethod ("nombre del método", clase …… parameaType); (solo se pueden obtener los públicos)
Cls.getDeclareMethod ("nombre del método"); (Obtener método decorado arbitrariamente, no se puede ejecutar en privado)
M.setAccessible (verdadero); (hacer que los métodos privados sean ejecutables)

Deja que el método se ejecute

Method.invoke (objeto de instancia obj, parámetro de variable obj); ----- (tiene un valor de retorno)

2021 面试题，认准 JavaPub。