简单模拟Java中反射的应用场景

有人说Java是一门静态语言。那么何为静态语言，动态语言又是什么？

1、动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以 被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运 行时代码可以根据某些条件改变自身结构。 主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
2、静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如C、 C++。

Java不是动态语言，但也不能简单的说成静态语言。Java可以称之为“准动态语言”。即Java有一定的动 态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。
Java的动态性让编程的时候更加灵活！

因此我们可以通过反射，将Java“变成”动态语言，即可以通过反射改变程序运行时的结构。举一个简单的例子模拟一下：

package day_12_30.reflection_test;

import day_12_30.reflection.java.Person;

import java.util.Date;
import java.util.Random;

/**
 * @author soberw
 * @Classname RefTest
 * @Description 体会反射的动态性
 * @Date 2021-12-30 20:56
 */
public class RefTest {

    public static void main(String[] args) throws Exception {
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            int j = random.nextInt(3);
            Class clazz = switch (j) {
                case 1 -> User.class;
                case 2 -> Date.class;
                default -> Person.class;
            };
            Object o = clazz.getDeclaredConstructor().newInstance();
            System.out.println(o);
        }
    }
}

class User {
    private String name;
    private int age;
    public User() {}
    {
        this.age = 18;
        this.name = "wang";
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在程序跑起来之前谁也不知道程序会造哪个类的对象。

下面我再简单举例两个Java的反射机制在实际开发中的应用场景，帮助大家更好的掌握反射：
例如我们在连接数据库的时候，随着需求的改变，可能今天会用到MySQL，明天又用到Oracle了，那我们总不能频繁的去创建对象，多麻烦。这时候我们就可以用反射的机制去设计实现，简单举例一下：
我有一个连接接口：

public interface Connect {
    /**
     * 保存数据库文件
     */
    void safe();
}

有两个实现类：

public class MysqlConnect implements Connect{
    @Override
    public void safe() {
        System.out.println("数据保存在mysql中...");
    }
}

public class OracleConnect implements Connect{
    @Override
    public void safe() {
        System.out.println("数据保存在oracle中...");
    }
}

现在我想随时去切换调用哪个数据库，只需要声明一个文件，保存全类名，这里命名为：bean.properties


然后我再创建一个工厂类，通过工厂类去调用数据库连接：

package day_12_31.mybean;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;

/**
 * @author soberw
 * @Classname MyBeanFactory
 * @Description
 * @Date 2021-12-31 9:00
 */
public class MyBeanFactory {
    private static Properties props;
    private static String className;
    static{
        String path = MyBeanFactory.class.getClassLoader().getResource("data/bean.properties").getPath();
        props = new Properties();
        try {
            props.load(new FileInputStream(path));
        } catch (IOException e) {
            e.printStackTrace();
        }
        className = props.getProperty("user");
    }

    public static Object getBean(){
        Class clazz = null;
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            return clazz.getDeclaredConstructor().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试如下：

public class FactoryTest {
    public static void main(String[] args) {
        Object bean = MyBeanFactory.getBean();
        Connect c = (Connect) bean;
        c.safe();
    }
}

此时如果想改为mysql连接，只需在配置文件里改就行了：

当然方法远不止这一种，我们都知道，注解在Java高级部分也是非常重要的，很多框架大量运用到了注解，比如JPA是基于注解的，Spring2.5以上都是基于注解的，甚至在一定程度上来说：框架 = 注解 + 反射 + 设计模式。
而且使用注解比配置文件会更高效，满足了工厂设计模式的高内聚低耦合的性质。
下面我就简单模拟一下：
首先声明一个注解类：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "";
}

编写新的工厂类：

package day_12_31.mybean;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
 * @author soberw
 * @Classname AnnotationFactory
 * @Description
 * @Date 2021-12-31 10:00
 */
public class AnnotationFactory {
    private static String packageName = "day_12_31.mybean";
    private static List<String> list = new ArrayList<>();

    static {
        StringBuilder path = new StringBuilder(AnnotationFactory.class.getClassLoader().getResource("").getPath());
        String[] split = packageName.split("[.]");
        for (String s : split) {
            path.append(s).append("/");
        }
        File file = new File(path.toString());
        File[] files = file.listFiles();
        for (File f : files) {
            String s = f.getName().substring(0, f.getName().lastIndexOf("."));
            String className = packageName + "." + s;
            list.add(className);
        }
    }

    public static Object getBean() {
        for (String s : list) {
            try {
                if (Class.forName(s).isAnnotationPresent(MyAnnotation.class)) {
                    return Class.forName(s).getDeclaredConstructor().newInstance();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

测试一下：

package day_12_31.mytest;

import day_12_31.mybean.AnnotationFactory;
import day_12_31.mybean.Connect;

/**
 * @author soberw
 * @Classname AnnnotationFactoryTest
 * @Description
 * @Date 2021-12-31 9:59
 */
public class AnnotationFactoryTest {
    public static void main(String[] args) {
        Object bean = AnnotationFactory.getBean();
        if (bean != null) {
            Connect c = (Connect) bean;
            c.safe();
        }else {
            System.out.println("数据保存失败...");
        }
    }
}

我们想要连接哪个数据库，就在连接类上添加注解就行了，也不用再去修改配置文件了：

那么这就是Java中反射的应用场景，当然，在实际中，其应用场景会更加广泛，所以，熟练掌握反射，在实际开发中会更加得心应手!