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(); } } }
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
根据通用路径以流的形式返回：