反射

package com.javaSe.reflect;
import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;


public class IoPropertiesTest {
    public static void main(String[] args) throws Exception{
        
        // 获取一个文件的绝对路径！！！！！！
       /* String path = Thread.currentThread().getContextClassLoader().getResource("classinfo2.properties").getPath();
        FileReader reader = new FileReader(path);*/
        
        // 直接以流的形式返回。
        InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("classinfo2.properties");
       
        Properties pro = new Properties();
        pro.load(reader);   
        reader.close();
        // 通过key获取value
        String calssName = pro.getProperty("className");
        System.out.println(calssName);
    }
}

java.util包下提供的资源绑定器

package com.javaSe.reflect;


import java.util.ResourceBundle;


/*
java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下面。
*/
public class ResourceBundleTest {
    public static void main(String[] args) {
        // 资源绑定器，只能绑定xxx.properties文件，并且这个文件必须在类路径下。文件扩展名也必须是properties
        // 并且在写路径的时候，路径后面的扩展名不能写
        // ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
        
        ResourceBundle bundle = ResourceBundle.getBundle("com/javaSe/bean/db");
        
        String className = bundle.getString("className");
        System.out.println(className);
        
    }
}

1 反射机制：
1.1 反射机制有什么用？
通过java语言中的反射机制可以操作字节码文件。
优点类似于黑客。（可以读和修改字节码文件）
通过反射机制可以操作代码片段。（calss文件。）

1.2 反射机制的相关类在哪个包下？
java.lang.reflect.*;

1.3 反射机制相关的重要的类有哪些？

java.lang.Class 代表整个字节码，代表一个类型，代表整个类。

java.lang.reflect.Method 代码字节码中的方法字节码，代表类中的方法

java.lang.reflect.Constructor 代表字节码中的构造方法字节码，代表类中的构造方法

java.lang.reflect.Field 代表字节码中的属性字节码。代表类中的成员变量（静态变量和实例变量）

java.lang.Class:
public class User{
// Field
int no;

// Constructor
public User(){

}

public User(int no){
this.no = no;
}

// Method
public void setNo(int no){
this no = no;
}

public int getNo(){
return no;
}
}

2 关于JDK中自带的类加载器：
2.1 什么是类加载器？
专门负责加载类的命令/工具、
classLoader

2.2 JDK中自带了3个类加载器
启动类加载器 父加载器 rt.jar
扩展类加载器 母加载器 ext/*.jar
应用类加载器 classpath

2.3 假设有这样一段代码
String s = "abc";

代码再开始执行之前，会讲所需要类全部加载到JVM当中。
通过类加载器加载，看到以上代码类加载器会找String.class
文件，找到就加在，那么是怎么进行加载的呢？
首先通过"启动类加载器"加载。
注意：启动类加载器专门加载：F:Javajdk1.8.0_101jrelib t.jar
rt.jar中都是JDK最核心的类库。

如果通过"启动类加载器"加载不到的时候，
会通过“扩展加载类”加载。
注意：扩展类加载器专门加载： F:Javajdk1.8.0_101jrelibext*.jar

如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载。
注意：应用类加载器专门加载：classpath中的类（class文件。）

2.4 java中为了保证类加载的安全，使用了双亲委派机制。
优先从启动类加载器中加载，这个称为“父”
“父”无法加载到，再从扩展类加载器中加载，这个称为“母”。双亲委派。
如果都加载不到，才会考虑从应用类加载器中加载。知道加载到为止。


回顾反射机制：
1.1 什么是反射机制？反射机制有什么用？
反射机制：通过反射机制，我们可以完成我们字节码的访问。可以让我们操作字节码文件。
有什么用：通过类名和反射机制可以实例化对象。可以让程序更灵活，我们只需要更改properties文件中的值，不修改代码的作用。

1.2 反射机制相关的类在哪个包下？
java.lang.reflect.*;

1.3 反射机制相关的主要的类？
java.lang.Class;
java.lang.reflect.Method;
java.lang.reflect.Constructor;
java.lang.reflect.Filed;

1.4 在java中获取Class的三种方式？
第一种：
Class c = Class.forName("完整类名");
第二种：
Class c = 对象.getClass();
第三种：
Class c = int.class;
Class c = String.class;

1.5 获取了Class之后，可以调用无参数构造方法来实例化对象

// c代表的就是日期Date类型
Class c = Class.forName("java.util.Date");

// 实例化一个Date日期类型的对象
Object obj = c.newInstance();

一定要注意：
newInstance()底层调用的事该类型的无参数构造方法。
如果没有这个无参数构造方法会出现“实例化”异常。

1.6 如果你只想让一个类的“静态代码块”执行的话，你可以怎么做？
Class.forName("该类的类名");
这样类就加载，类加载的时候，静态代码块执行！！！
在这里，对该方法的返回值不感兴趣，主要是为了使用“类加载”这个动作。

1.7 关于路径问题？

这种方式是为了获取一个文件的绝对路径。（通过方式，不会受到环境移植的影响）
但是该文件要求放在类路径下，换句话说：也就是放到src下面。
src下是类的根路径。
String path = Thread.currentThread().getContextClassLoader().getResource("写相对路径，但是这个相对路径从src出发开始找").getPath();

String path = Thread.currentThread().getContextClassLoader().getResource("abc").getPath();// 必须保证src下有abc文件

String path = Thread.currentThread().getContextClassLoader().getResource("a/db").getPath();// 必须保证src目录下有a目录，a目录下有db文件

// 必须保证src目录下有com目录，com目录下有javaSe目录，javaSe目录下有bean目录，bean目录下有test.properties文件。
String path = Thread.currentThread().getContextClassLoader().getResource("com/javaSe/bean/test.properties").getPath();

// 直接以流的形式返回。
InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/javaSe/test.properties");

1.8 IO + Properties,怎么快速绑定属性资源文件？

// 要求：第一这个文件必须在类路径下。
// 第二这个文件必须是以.properties结尾。
ResourceBundle bundle = ResourceBundle.getBundle("com/javaSe/test");
String value = bundle.getString("key");

字节码内存图：

如何获取一个类的字节码，案例：

package com.javaSe.reflect;


import java.util.Date;


/*
要操作一个类的字节码，首先需要获取到这个类的字节码，怎么获取java.lang.Class实例？
    三种方式：
        第一种：Class c = Class.forName("完整类名带包名");
        第二种: Class c = 对象.getClass();
        第三种：Class c = 任何类型.class;
*/
public class ReflectTest01 {
    public static void main(String[] args) {
        /*
        Class.forName
            1 静态方法。
            2 方法的参数是一个字符串。
            3 字符串需要的是一个完整类名。
            4 完整类名必须带有包名。java.lang包也不能省略。
         */
        Class c1 = null;
        Class c2 = null;
        Class c3 = null;
        Class c4 = null;
        try {
            c1 = Class.forName("java.lang.String"); // c1代表String.class文件，或者说c1代表String类型。
            c2 = Class.forName("java.util.Date"); // c2代表Date类型
            c3 = Class.forName("java.lang.Integer"); // c3代表Integer类型
            c4 = Class.forName("java.lang.System");// c4代表System类型
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        // java中任何一个对象都有一个方法:getClass()
        String s = "abc";
        Class x = s.getClass(); // x代表String.class字节码文件，x代表String类型
        System.out.println(c1 == x); // true(== 判断的是对象的内存地址)
        
        Date time = new Date();
        Class y = time.getClass();
        System.out.println(c2 == y); // true
    }
}

获取到class之后可以干嘛？案例：

package com.javaSe.reflect;


import com.javaSe.bean.User;


/*
获取到Class，能干什么？
    通过Class的newInstance()方法来实例化对象。
    注意：newInstance()方法内部实际上调用了无参数构造方法，必须保证无参数构造才可以。
*/
public class ReflectTest02 {
    public static void main(String[] args) {
        
        // 这是不使用反射机制，创建对象。
        User user = new User();
        System.out.println(user);
        
        // 下面这段代码是使用了反射机制创建对象。
        try {
            // 通过反射机制，获取class，通过class来实例化对象。
            Class c = Class.forName("com.javaSe.bean.User"); // c代表user类型。
            
            // newInstance()这个方法会调用User这个类的无参数构造方法，完成对象的创建。
            // 重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的。
            Object obj = c.newInstance();
            
            System.out.println(obj); // com.javaSe.bean.User@10f87f48
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

User:

package com.javaSe.bean;


public class User {
    public User() {
        System.out.println("无参数构造方法！");
    }
    
    // 定义了有参数的构造方法
    public User(String s){
        System.out.println("有参数的构造方法！");
    }
}

反射机制的灵活性：

package com.javaSe.reflect;


import com.javaSe.bean.User;


import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;


/*
验证反射机制的灵活性。
    java代码写一遍，在不改变java源代码的基础之上，可以做到不同对象的实例化。
    非常之灵活。（符合OCP开闭原则：对扩展开放，对修改关闭。）
    
后期你们要学习的是高级框架，而工作过程中，也都是使用高级框架。
包括：
    ssh ssm
    Spring SpringMVC Mybatis
    Spring Struts Hibernate
    ...
    这些高级框架底层实现原理：都是采用了反射机制。所以反射机制还是重要的。
    学会了反射机制有利于你理解剖析框架底层的源代码。
*/
public class ReflectTest03 {
    public static void main(String[] args) {
        
        // 这种方式代码就写死了。只能创建一个User类型对象。
        // User user = new User();
        
        // 以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
        // 通过IO流读取classinfo.properties文件
        FileReader fr = null;
    
        try {
            fr = new FileReader("H:\IdeaProjects\javase\Reflect\src\classinfo.properties");
            // 创建属性类对象Map
            Properties pro = new Properties();
            // 加载
            pro.load(fr);
            // 通过key获取value
            String className = pro.getProperty("className");
            // System.out.println(className);
            
            // 通过反射机制实例化对象
            Class c = Class.forName(className);
            Object obj = c.newInstance();
            System.out.println(obj);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

classinfo.properties:

className=java.util.Date

classinfo2.properties:

className=java.util.Date

Class.foName()发生了什么？：

package com.javaSe.reflect;
/*
研究一下：Class.forName()发生了什么？
    记住，重点：
        如果你只是希望一个类的静态代码块执行，其他代码一律不执行，你可以使用：
            Class.forName("完整类名");
        这个方法的执行会导致类加载，类加载时，静态代码块执行。
        
提示：
    后面JDBC技术的时候我们还需要
*/
public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.foName()这个方法的执行会导致：类加载。
            Class.forName("com.javaSe.bean.MyClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

 

MyClass：

package com.javaSe.bean;


public class MyClass {
    // 静态代码块在类加载时执行，并且只执行一次。
    static {
        System.out.println("MyClass类的静态代码块执行了！");
    }
}

通用路径的写法：

package com.javaSe.reflect;


/*
研究一下文件路径的问题。
怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。但是前期是文件需要在类路径下才能用这种方式
*/
public class AboutPath {
    public static void main(String[] args) throws Exception{
        // 这种方式的路径缺点是：移植性查，在IDEA中默认的当前路径是project的根。
        // 这个代码假设离开了IDEA，换到了其它位置，可能当前路径就不是project的根了，这时这个路径就无效了。
        // FileReader fr = new FileReader("H:\IdeaProjects\javase\Reflect\src\classinfo.properties");
        
        // 接下来说一种比较通用的路径。即使代码换位置了，这样编写仍然是通用了。
        // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
        // 什么类路径下？凡是在src下的都是类路径下。【记住它】。
        // src是类的根路径。
        /*
            Thread.currentThread() 当前线程对象。
            getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
            getResource("") 【获取资源】是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
         */
        String path = Thread.currentThread().getContextClassLoader().getResource("classinfo2.properties").getPath();// 这种方式获取文件绝对路径是通用的。
        
        // 采用以上的代码可以拿到一个文件的绝对路径
        // /H:/IdeaProjects/javase/out/production/Reflect/classinfo2.properties
        System.out.println(path);
        
        // 获取db.properties 文件的绝对路径(从类的根路径下作为起点开始)
        String path2 = Thread.currentThread().getContextClassLoader().getResource("com/javaSe/bean/db.properties").getPath();
        System.out.println(path2);
        
    }
}

dp.properties:

className=java.lang.String

根据通用路径以流的形式返回：