Reflexión (a)

directorio

• reflexión

• La reflexión y la planta de diseño

• Diseño de la única Ejemplo reflexión

• el modo de proxy dinámico

• información de estructura de clases

reflexión

La reflexión es una de las partes más importantes de Java, se puede lograr el uso del código de alta reflexión reutilización.

1, se refiere a un programa Java que se ejecuta el análisis, la modificación y la capacidad de operar la clase de objeto.
2, clase de clase es la base de mecanismo de reflexión de Java, podemos obtener a través de la información de clase de la clase acerca de una clase.
3, el objeto de la clase Clase representan clases e interfaces para el programa de aplicación Java que se ejecuta en la actualidad. clase de clase es un mecanismo de entrada de reflexión de Java.
4, la pluralidad de clases en una clase genérica común, mejorando de este modo la reutilización de código.

Reflexión puede ser obtenida por la instancia de la clase Clase tres formas.

Ejemplo:

public class TestReflection {
    public static void main(String[] args) throws ClassNotFoundException {
        Ball ball = new Ball();
        //第一种
        Class<?> ballClassA = ball.getClass();
        //第二种
        Class<?> ballClassB = Ball.class;
        //第三种,在不考虑复杂开发时,用第三种
        Class<?> ballClassC = Class.forName("com.tx.test.reflection.Ball");
        
        System.out.println(ballClassC);
        System.out.println(ballClassC.getName());
        System.out.println(ballClassC.getSimpleName());
    }
}
class Ball{}

resultados:

class com.tx.test.reflection.Ball
com.tx.test.reflection.Ball
Ball

Cuenta con tres maneras:

1, clase .getClass (): para obtener una clara necesidad de utilizar la instancia de objeto de clase.

2, clase .class: proceso de importación requieren operación de clase explícita.

3, Class.forName (): utilizando el nombre de la clase descrita en una cadena de caracteres (cadena de caracteres mediante el uso de una muy conveniente, no se prefiere cuando se considera el desarrollo del complejo).

La reflexión y la planta de diseño

La planta fue diseñada originalmente para resolver el acoplamiento, el diseño de plantas de acoplamiento estática se puede resolver en cierta medida, pero siempre y cuando no es la nueva palabra clave acoplamiento inevitable.

El uso de una fábrica estática defectos de diseño en la realización, cuando más de una interfaz de sub-clase, hay cientos, miles, la Cada clase creada para una molestia claramente imposible, sino el uso de la reflexión puede diseño de la planta dinámica, sólo necesita implementar la misma interfaz, un método común se puede realizar la operación instantiate.

Ejemplo:

public class TestTrendsFactory {
    public static void main(String[] args) throws Exception {
        IBall ball = Factory.getInstance("com.tx.test.reflection.BasketBallImpl");
        if (ball != null) {	
            ball.play("篮球");
        }
    }
}

interface IBall {
    /**
     * 玩球
     *
     * @param msg 球的种类
     */
    void play(String msg);
}

class BasketBallImpl implements IBall {

    @Override
    public void play(String msg) {
        System.out.println("【球的种类】玩" + msg + "!!!");
    }
}

class Factory {
    private Factory() {
    }

    /**
     * 根据传入的类进行实例化操作
     * @param msg 传入的类
     * @return  返回实例化后的对象
     */
    public static IBall getInstance(String msg) {
        IBall ball;
        try {
            ball = (IBall) Class.forName(msg).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            return null;
        }
        return ball;
    }
}

resultados:

【球的种类】玩篮球!!!

Diseño de la única Ejemplo reflexión

diseño Singleton es la esencia de la base de ser un proceso JVM sólo se le permite tener una instancia.

Ejemplo: cuando una pluralidad de hilos de operar ecuación instanciación perezoso

public class TestSingleton {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
              Animal animal = Animal.getInstance();
            }).start();
        }
    }
}

class Animal {
    private static Animal animal;

    private Animal() {
        System.out.println("懒汉式单例设计多线程测试！！！");
    }

    public static Animal getInstance() {
        if (animal == null) {
            animal = new Animal();
        }
        return animal;
    }
}

resultados:

懒汉式单例设计多线程测试！！！
懒汉式单例设计多线程测试！！！
懒汉式单例设计多线程测试！！！
懒汉式单例设计多线程测试！！！
懒汉式单例设计多线程测试！！！

Cuando la pluralidad de hilos individuales de operación de diseño caso perezoso no puede ser implementado en una sola realización.

Adición sincronizado en el método, pero en un estado multiproceso de alta concurrencia, que afectará seriamente el rendimiento.

Ejemplo: añadido en el método sincronizado.

public class TestSingleton {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
              Animal animal = Animal.getInstance();
            }).start();
        }
    }
}

class Animal {
    private static Animal animal;

    private Animal() {
        System.out.println("懒汉式单例设计多线程测试！！！");
    }

    public synchronized static Animal getInstance() {
        if (animal == null) {
            animal = new Animal();
        }
        return animal;
    }
}

resultados:

懒汉式单例设计多线程测试！！！

Solución dos: el uso resolución de problemas internamente sincronizadas y método de reflexión.

La razón por la el valor nulo determina entonces el bloque de código de sincronización es para asegurar que sólo el primer hilo entrará operación por ejemplo, en un caso donde una pluralidad de hilos, cuando el primero crea una instancia en el exterior del valor nulo también determina convertirse (incluso si hay un retraso de sólo unos pocos hilos entrará), directamente después de la falsa rendimientos de rosca.

Ejemplo:

public class TestSingletonInterior {
    public static void main(String[] args) {

    }
}

class Person {
    private static Person person;

    private Person() {
        System.out.println("内部synchronized懒汉式单例设计!!!");
    }

    public static Person getInstance() {
        if (person == null) {
            synchronized (Person.class) {
                if (person == null) {
                    person = new Person();
                }
            }
        }
        return person;
    }
}

resultados:

内部synchronized懒汉式单例设计!!!

el modo de proxy dinámico

información de estructura de clases

La información estructural puede ser obtenido por la clase Class.

método	explicación
Clase pública <?> [] GetInterfaces ()	Obtener toda la interfaz de los padres
Paquete pública getPackage ()	Recibe el nombre de la clase en la que el paquete
Clase pública <? Super T> getSuperclass ()	Acceder a la información de clase heredada de padres

Ejemplo:

public class TestProgramData {
    public static void main(String[] args) {
        Class<?> clazz = MessageImpl.class;
        System.out.println("clazz->"+clazz.getName());
        System.out.println("getPackage()->"+clazz.getPackage().getName());
        System.out.println("getSuperclass()->"+clazz.getSuperclass().getName());
        System.out.println("getInterfaces()->"+ Arrays.toString(clazz.getInterfaces()));

    }
}
interface IMessage{}
interface IMessageData{}
abstract class AbstractMessage implements IMessage,IMessageData{}
class MessageImpl extends AbstractMessage implements IMessage,IMessageData{}

resultados:

clazz->com.tx.test.reflection.MessageImpl
getPackage()->com.tx.test.reflection
getSuperclass()->com.tx.test.reflection.AbstractMessage
getInterfaces()->[interface com.tx.test.reflection.IMessage, interface com.tx.test.reflection.IMessageData]