反射
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:\Java\jdk1.8.0_101\jre\lib\rt.jar
rt.jar中都是JDK最核心的类库。
如果通过"启动类加载器"加载不到的时候,
会通过“扩展加载类”加载。
注意:扩展类加载器专门加载: F:\Java\jdk1.8.0_101\jre\lib\ext\*.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
根据通用路径以流的形式返回: