Java中的反射机制

一，反射的概念

Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，但反射能直接操作类私有属性。反射可以在运行时获取一个类的所有信息，（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

        要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法。所以先要获取到每一个字节码文件对应的Class类型的对象。

        反射就是把java类中的各种成分映射成一个个的Java对象。
        例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把一个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
        加载的时候：Class对象的由来是将 .class 文件读入内存，并为之创建一个Class对象。

        Class类

        Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）
        Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

        我们知道Spring框架可以帮我们创建和管理对象。需要对象时，我们无需自己手动new对象，直接从Spring提供的容器中的Beans获取即可。Beans底层其实就是一个Map<String,Object>，最终通过getBean(“user”)来获取。而这其中最核心的实现就是利用反射技术。   

        Bean

        1、Java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化）；

        2、凡是有方法或属性的类都需要实例化，这样才能具象化去使用这些方法和属性；

        3、规律：凡是子类及带有方法或属性的类都要加上注册Bean到Spring IoC的注解；（@Component , @Repository , @ Controller , @Service , @Configration）

        4、把Bean理解为类的代理或代言人（实际上确实是通过反射、代理来实现的），这样它就能代表类拥有该拥有的东西了

        5、在Spring中，你标识一个@符号，那么Spring就会来看看，并且从这里拿到一个Bean（注册）或者给出一个Bean（使用）

 二，反射的使用

1、获取Class对象的三种方式
1.1 Object ——> getClass();
1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
1.3 通过Class类的静态方法：forName（String  className）(常用）

三，反射的书写步骤

1，创建项目，导入jar包

 2，创建dao包，接口，类

public class BookDaoImpl implements BookDao {
    @Override
    public void add() {
        System.out.println("BookDaoImpl...add");
    }
}

public interface BookDao {
    public void add();
}

  3，创建service包，接口，类

public class BookServiceImpl implements BookService {
    public String name;
    int age;
    protected String sex;
    private String address;

    public BookServiceImpl(){
    }

    public BookServiceImpl(String name){
        this.name = name;
    }

    private BookServiceImpl(String name,int age,String sex,String address){
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }


    BookDao bookDao = new BookDaoImpl();
    @Override
    public void add() {
        System.out.println("BookSeiviceImpl...add");
        bookDao.add();
    }

    @Override
    public void fun() {
        System.out.println("BookSeiviceImpl...fun");
    }
}

public class BoookServiceVip implements BookService {
    BookDao bookDao = new BookDaoImpl();
    @Override
    public void add() {
        System.out.println("BoookServiceVip...add");
    }

    @Override
    public void fun() {
        System.out.println("BoookServiceVip...fun");
    }
}

public interface BookService {
    public void add();

    public void fun();
}

4，创建servlet包，接口，类,测试类

public class BookServlet {
    BookService bookService = new BoookServiceVip();
    @Test
    public void add(){
        System.out.println("BookServlet.add");
        bookService.add();
    }
}

public class Test01 {
    public static void main(String[] args) throws Exception {
        Class cla = Class.forName("com.gao.service.impl.BookServiceImpl");

        Field[] fields = cla.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("---------");

        Field[] fields1 = cla.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
        System.out.println("===========");

        Constructor[] constructors = cla.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("-------------");
        Constructor[] constructors1 = cla.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }

        System.out.println("======================");
        Method[] methods = cla.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-------------");
        Method[] methods1 = cla.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
    }
}

public class Test02 {
    public static void main(String[] args) throws Exception {
        //读取配置文件，获取内容
//        File file=new File("D:\\code\\IdeaProjects\\spring2105\\spring01\\src\\info.properties");
//        InputStream stream=new FileInputStream(file);
        InputStream stream = Test02.class.getClassLoader().getResourceAsStream("info.properties");

        Properties p=new Properties();
        p.load(stream);
        String className=p.getProperty("className");

        //1.通过全类名获取类的Class对象
        Class cla = Class.forName(className);
        //2.通过Class对象获取类的无参构造器
        Constructor constructor = cla.getDeclaredConstructor();
        //3.使用构造器创建对象
        BookService bookService = (BookService) constructor.newInstance();
        //4.使用对象调用方法
        bookService.add();
    }
}

public class Test03 {
    public static void main(String[] args) throws Exception {
        //读取配置文件，获取内容
//        File file=new File("D:\\code\\IdeaProjects\\spring2105\\spring01\\src\\info.properties");
//        InputStream stream=new FileInputStream(file);
        InputStream stream = Test03.class.getClassLoader().getResourceAsStream("info.properties");

        Properties p=new Properties();
        p.load(stream);
        String className=p.getProperty("className");
        String methodName=p.getProperty("methodName");

        //1.通过全类名获取类的Class对象
        Class cla = Class.forName(className);
        //2.通过Class对象获取类的无参构造器
        Constructor constructor = cla.getDeclaredConstructor();
        //3.使用构造器创建对象
        BookService bookService = (BookService) constructor.newInstance();
        //4.获取方法名
        Method method = cla.getDeclaredMethod(methodName);
        //5.执行方法
        method.invoke(bookService);
    }
}