一，类的加载概述和加载时机
1.1.1，类的加载概述:
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
- 加载
- 就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
- 连接
- 验证 是否有正确的内部结构，并和其他类协调一致
- 准备 负责为类的静态成员分配内存，并设置默认初始化值
- 解析 将类的二进制数据中的符号引用替换为直接引用
- 初始化
- 就是我们以前讲过的初始化步骤
1.1.2，加载时机:
- 创建类的实例
- 访问类的静态变量，或者为静态变量赋值
- 调用类的静态方法
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
1.2.1，类加载器的概述和分类:
- A.类加载器的概述:
- 负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
- B.类加载器的分类:
- Bootstrap ClassLoader 根类加载器
- Extension ClassLoader 扩展类加载器
- Sysetm ClassLoader 系统类加载器
- C.类加载器的作用:
- Bootstrap ClassLoader 根类加载器
- 也被称为引导类加载器，负责Java核心类的加载
- 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
- Extension ClassLoader 扩展类加载器
- 负责JRE的扩展目录中jar包的加载。
- 在JDK中JRE的lib目录下ext目录
- Sysetm ClassLoader 系统类加载器
- 负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径
二，什么是反射?
1.3.1，反射的概述：
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。
而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。
1.3.2，解剖获取字节码对象的三种方式：
- Object类的getClass()方法,判断两个对象是否是同一个字节码文件
- 静态属性class,锁对象
- Class类中静态方法forName(),读取配置文件
1 package com.bgs.reflect; 2 import com.bgs.pojo.Person; 3 public class ExampleReflect_day01 { 4 public static void main(String[] args) throws ClassNotFoundException { 5 //第一种方式通过Class类中静态方法forName(),读取配置文件 6 Class<?> clazz1 = Class.forName("com.bgs.pojo.Person"); 7 //静态属性class,锁对象 8 Class clazz2 = Person.class; 9 //第三种方式直接new对象通过对象.class来获取对象 10 Person person = new Person(); 11 Class class3 = person.getClass(); 12 //对比三个字节码对象是否一样 13 System.out.println(clazz1 == clazz2); 14 System.out.println(class3 == clazz2); 15 } 16 }
执行结果:true，true（说明这三种获取字节码对象的方式获取的都是同一个字节码对象，所以我们可以选择其中一个使用.forName比较常用）
三，反射各种函数的使用：
1.4.1，通过反射获取带参构造方法并使用:
Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance("张三",20)方法创建对象
先创建一个实体类Person
1 package com.bgs.pojo; 2 3 public class Person { 4 private int age; 5 private String name; 6 7 8 public Person(int age, String name) { 9 super(); 10 this.age = age; 11 this.name = name; 12 } 13 public int getAge() { 14 return age; 15 } 16 public void setAge(int age) { 17 this.age = age; 18 } 19 public String getName() { 20 return name; 21 } 22 public void setName(String name) { 23 this.name = name; 24 } 25 @Override 26 public int hashCode() { 27 final int prime = 31; 28 int result = 1; 29 result = prime * result + age; 30 result = prime * result + ((name == null) ? 0 : name.hashCode()); 31 return result; 32 } 33 @Override 34 public boolean equals(Object obj) { 35 if (this == obj) 36 return true; 37 if (obj == null) 38 return false; 39 if (getClass() != obj.getClass()) //判断调用对象和传入对象的字节码文件是否是同一个字节码文件 40 return false; 41 Person other = (Person) obj; 42 if (age != other.age) 43 return false; 44 if (name == null) { 45 if (other.name != null) 46 return false; 47 } else if (!name.equals(other.name)) 48 return false; 49 return true; 50 } 51 @Override 52 public String toString() { 53 return "Person [age=" + age + ", name=" + name + "]"; 54 } 55 public void eat() { 56 System.out.println("Suppose one day you're gone"); 57 } 58 public void eat(int num) { 59 System.out.println("So does this world still have the meaning that I exist?"+num); 60 61 } 62 }
然后在创建一个测试类，去或者实体类中的私有属性，并且为其赋值(没有通过封装的get，set方法就为其加上了属性是不是很好奇)
1 package com.bgs.reflect; 2 3 import java.lang.reflect.Constructor; 4 5 import com.bgs.pojo.Person; 6 7 public class ExampleReflect_day03 { 8 public static void main(String[] args) throws Exception { 9 Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.bgs.pojo.Person的字节码对象 10 // Person p = (Person) clazz.newInstance(); //通过无参构造创建对象(调用newInstance的方笔必须要有默认参数)假如没有则会报异常 11 // System.out.println(p); 12 Constructor<?> constructor = clazz.getConstructor(int.class,String.class);//获取有参构造 13 Person person = (Person) constructor.newInstance(23,"张三"); //通过有参构造创建对象 14 System.out.println(person); //执行结果为:Person [age=23, name=张三] 15 } 16 }
1.4.2，通过反射获取成员变量并使用：
1 ackage com.bgs.reflect; 2 3 import java.lang.reflect.Constructor; 4 import java.lang.reflect.Field; 5 6 import com.bgs.pojo.Person; 7 8 /** 9 * @author Administrator Field 10 * Class.getField(String)方法可以获取类中的指定字段(可见的), 11 * 如果是私有的可以用getDeclaedField("name")方法获取,通过set(obj, 12 * "李四")方法可以设置指定对象上该字段的值, 13 * 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj) 14 * 可以获取指定对象中该字段的值 15 * 16 */ 17 public class ExampleReflect_day04 { 18 public static void main(String[] args) throws Exception { 19 Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.bgs.pojo.Person的字节码对象 20 Constructor<?> constructor = clazz.getConstructor(int.class,String.class);//获取有参构造 21 Person person = (Person) constructor.newInstance(23,"张三"); //通过有参构造创建对象 22 // Field f = clazz.getField("name"); //反射获取姓名字段 23 // f.set(person, "姜煜");//对姓名字段进行修改 //异常: Class com.example.reflect.ExampleReflect_day04 can not access a member of class com.example.reflect.Person with modifiers "private" 24 Field f = clazz.getDeclaredField("name"); //暴力反射获取姓名字段 25 f.setAccessible(true); //去除私有权限 26 f.set(person, "姜煜"); 27 System.out.println(person); 28 } 29 }
执行结果为:Person [age=23, name=姜煜] 原本用反射给这个对象的私有属性赋值赋的是23，张三，然后用暴力反射去给对象把name的属性李四换成姜煜
1.4.3，通过反射获取方法并使用
Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法,调用invoke(Object, Object...)可以调用该方法,Class.getMethod("eat") invoke(obj) Class.getMethod("eat",int.class) invoke(obj,10)
1 package com.bgs.reflect; 2 3 import java.lang.reflect.Constructor; 4 import java.lang.reflect.Method; 5 6 import com.bgs.pojo.Person; 7 8 public class ExampleReflect_day05 { 9 public static void main(String[] args) throws Exception { 10 Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.example.reflect.Person的字节码对象 11 Constructor<?> constructor = clazz.getConstructor(int.class, String.class);// 获取有参构造 12 Person person = (Person) constructor.newInstance(23, "张三"); // 通过有参构造创建对象 13 14 Method m = clazz.getMethod("eat"); //获取etc方法 15 m.invoke(person); 16 17 Method m2 = clazz.getMethod("eat", int.class);//获取有参的eat方法 18 m2.invoke(person, 10); 19 } 20 }
执行结果:Suppose one day you're gone So does this world still have the meaning that I exist?10 ，可能有的小白不知道为什么执行这个，因为我再实体类中添加的有这个eat方法
1.4.4，通过反射越过泛型检查:
案例演示：
ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？
1 package com.bgs.reflect; 2 3 import java.lang.reflect.Method; 4 import java.sql.Array; 5 import java.util.ArrayList; 6 7 /** 8 * 泛型只在编译器有效,在运行期会被擦除掉 9 */ 10 public class ExampleReflect_day06 { 11 public static void main(String[] args) throws Exception { 12 ArrayList<Integer> list = new ArrayList<>(); 13 list.add(111); 14 list.add(222); 15 Class<?> clazz = Class.forName("java.util.ArrayList"); //获取到字节码对象 16 Method m = clazz.getMethod("add", Object.class); //获取add方法 17 m.invoke(list, "abc"); 18 System.out.println(list); 19 } 20 }
执行结果：[111, 222, abc] 是不是感觉反射特别神奇，竟然连集合的泛型都能无视
1.4.5，动态代理的概述和实现:
动态代理概述
代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。
举例：春节回家买票让人代买
动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
通过代理的过程:
在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
最终会调用InvocationHandler的方法
InvocationHandler Object invoke(Object proxy,Method method,Object[] args)
代码实现:
1.先创建一个接口类Student
1 package com.bgs.动态代理; 2 3 public interface Student { 4 public void login(); 5 6 public void submit(); 7 }
2.再创建一个类去实现Student接口
1 package com.bgs.动态代理; 2 3 public class StudentImp implements Student{ 4 5 @Override 6 public void login() { 7 // System.out.println("校验管理功能"); 8 System.out.println("登陆"); 9 // System.out.println("日志管理功能"); 10 11 } 12 13 @Override 14 public void submit() { 15 // System.out.println("校验管理功能"); 16 System.out.println("提交"); 17 // System.out.println("日志管理功能"); 18 } 19 20 }
假如实现类中我们要加一个校验信息功能，和身份认证功能，我们要在每个实现功能的上面去添加校验管理功能，那个的下面添加日志管理功能，现在才两个功能还好，假如以后代码功能多了我们这样会造成代码耦合度高，代码复用性低，会造成程序执行缓慢，因为都是重复代码（这就是我们为什么要用动态代理的原因）
3.再创建一个动态代理类，去实现InvocationHandler接口实现invoke方法
1 package com.bgs.动态代理; 2 3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Method; 5 6 public class MyInvocationHandler implements InvocationHandler { 7 private Object target; 8 9 public MyInvocationHandler(Object target) { 10 this.target = target; 11 } 12 @Override 13 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 14 System.out.println("校验管理功能"); 15 method.invoke(target, args); //执行被代理target对象的方法 16 System.out.println("日志管理功能"); 17 return null; 18 } 19 }
4.创建一个测试类,
1 package com.bgs.动态代理; 2 3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Proxy; 5 6 7 8 public class Test { 9 public static void main(String[] args) { 10 UserImp uImp = new UserImp(); 11 uImp.add(); 12 uImp.delete(); 13 System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); 14 MyInvocationHandler m = new MyInvocationHandler(uImp); 15 ////参数第一个是传的固定的 第二个参数也是固定的 第三个参数传的事MyInvocationHandler的子类对象 16 User user = (User) Proxy.newProxyInstance(uImp.getClass().getClassLoader(), uImp.getClass().getInterfaces(), m); 17 user.add(); 18 user.delete(); 19 } 20 }
执行结果:
四，反射总结:
灵活使用反射能让我们代码更加灵活，这里比如JDBC原生代码注册驱动，hibernate 的实体类，Spring 的 AOP等等都有反射的实现。但是凡事都有两面性，反射也会消耗系统的性能，增加复杂性等，合理使用才是真！