反射（上）

目录

• 反射

• 反射与工厂设计

• 反射与单例设计

• 动态代理模式

• 类的结构信息

反射

反射是Java最重要的部分之一，利用反射可以实现高复用的代码。

1、指一种Java程序在运行时分析、修改、操作类和对象的能力。
2、Class类是Java反射机制的基础，通过Class类我们可以获得关于一个类的相关信息。
3、Class类的对象用于表示当前运行的 Java 应用程序中的类和接口。Class类是Java反射机制的入口。
4、把多个类整合成一个通用的公共类，提高了代码的重用性。

反射可以通过三种形式获取Class类的实例。

示例：

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{}

结果：

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

三种方式的特点：

1、类.getClass()：需要明确的获得使用类的实例化对象。

2、类.class：需要明确的进行操作类的导入处理。

3、Class.forName()：可以通过字符串的描述使用类的名称（通过字符串使用非常方便，在不考虑复杂开发时首选）。

反射与工厂设计

工厂设计的初衷是为了解决耦合性，静态的工厂设计可以在一定程度上解决耦合性，但只要有new关键字就不可避免的存在耦合性。

​ 使用静态的工厂设计在实现上有缺陷，当接口的子类不止一个，有几百个、几千个时，为每一个类都创建一个显然是不可能的，太麻烦了，而使用反射就可以实现动态的工厂设计，只需要实现同一个接口，就可以共用一个方法，实现实例化操作。

示例：

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;
    }
}

结果：

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

反射与单例设计

单例设计的核心本质在于一个JVM进程之中只允许拥有一个实例。

示例： 当多个线程对懒汉式进行实例化操作

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;
    }
}

结果：

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

所以当多个线程对懒汉式单例设计进行操作时，不能够在实现单例。

解决方案一：在方法上加上synchronized，但是在多线程高并发的状态，会严重影响性能。

示例： 在方法上加入synchronized。

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;
    }
}

结果：

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

解决方法二：在方法内部synchronized使用和反射解决问题。

之所以在同步代码块再进行空值判断是为了保证线程只有第一个进入才会进行实例化操作,在多个线程的情况下，当第一个进入实例化后，外面的空值判断也会变（就算有延迟也只有少数的线程会进入），之后的线程就直接false返回了。

示例：

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;
    }
}

结果：

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

动态代理模式

类的结构信息

类的结构信息可以通过Class获取。

方法	说明
public Class<?>[] getInterfaces()	获取所有的父接口
public Package getPackage()	获取类所在包的名称
public Class<? super T> getSuperclass()	获取继承的父类信息

示例：

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{}

结果：

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]