反射概论

功能

屏幕截图 2022-04-17 180237.jpg

实例

  1. public class ReflectionTest {
  3.     //反射之前，对于Person的操作
  4.     @Test
  5.     public void test1(){
  7.         //1.创建Person类的对象
  8.         Person p1 = new Person("Tom",19);
  10.         //2.通过对象，调用其内部的属性、方法
  11.         p1.age = 10;
  12.         System.out.println(p1.toString());
  14.         p1.show();
  15.         //在Person类的外部，不可以通过Person类的对象调用其内部私有的结构
  16.         //比如：name、showNation()以及私有构造器
  17.     }
  19.     //反射之后，对于Person的操作
  20.     @Test
  21.     public void test2() throws Exception {
  22.         Class clazz = Person.class;
  23.         //1.通过反射，创建Person类的对象
  24.         Constructor cons = clazz.getConstructor(String.class, int.class);
  26.         Object obj = cons.newInstance("Tom", 19);
  27.         Person p = (Person) obj;
  28.         System.out.println(p.toString());
  29.         //2.通过反射，调用对象指定的属性、方法
  30.         Field age = clazz.getDeclaredField("age");
  31.         age.set(p,10);
  32.         System.out.println(p.toString());
  34.         //调用方法
  35.         Method show = clazz.getDeclaredMethod("show");
  36.         show.invoke(p);
  38.         //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
  39.         //调用私有构造器
  40.         Constructor cons1 = clazz.getDeclaredConstructor(String.class);;
  41.         cons1.setAccessible(true);
  42.         Person p1 = (Person) cons1.newInstance("Jerry");
  43.         System.out.println(p1);
  45.         //调用私有属性
  46.         Field name = clazz.getDeclaredField("name");
  47.         name.setAccessible(true);
  48.         name.set(p1,"Lilei");
  49.         System.out.println(p1);
  51.         //调用私有方法
  52.         Method showNation = clazz.getDeclaredMethod("showNation", String.class);
  53.         showNation.setAccessible(true);
  54.         showNation.invoke(p1, "中国");//相当于p1.showNation("中国")
  57.     }
  58. }
  1. public class Person {
  2.     private String name;
  3.     public int age;
  5.     public Person(String name, int age) {
  6.         this.name = name;
  7.         this.age = age;
  8.     }
  9.     private Person(String name) {
  10.         this.name = name;
  11.     }
  13.     public Person() {
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  32.     @Override
  33.     public String toString() {
  34.         return "Person{" +
  35.                 "name='" + name + '\'' +
  36.                 ", age=" + age +
  37.                 '}';
  38.     }
  40.     public void show(){
  41.         System.out.println("你好，我是个人");
  42.     }
  43.     private String showNation(String nation){
  44.         System.out.println("我的国籍是：" + nation);
  45.         return nation;
  46.     }
  47. }

java.lang.Class类

理解

类的加载过程

程序经过javac.exe命令后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解析运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例
也就是说，Class的实例就对应着一个运行时类
屏幕截图 2022-04-18 135653.jpg

获取Class的实例的方式

加载到内存的运行时类，会缓存一定时间。在此时间之内，我们可以通过不同的方式类获取此运行类

  1. //获取Class的实例的方式
  2.     @Test
  3.     public void test3() throws ClassNotFoundException {
  4.         //方式一：调用运行时类的属性：.class
  5.         Class clazz1 = Person.class;
  6.         System.out.println(clazz1);
  8.         //方式二：通过运行时类的对象
  9.         Person p1 = new Person();
  10.         Class clazz2 = p1.getClass();
  11.         System.out.println(clazz2);
  13.         //方式三：调用Class的静态方法：forName(String classPath)
  14.         Class clazz3 = Class.forName("Java5.Person");
  15.         System.out.println(clazz3);
  17.         System.out.println(clazz1 == clazz2);//true
  18.         System.out.println(clazz1 == clazz3);//true
  20.         //方式四：使用类的加载器：ClassLoader
  21.         ClassLoader classLoader = ReflectionTest.class.getClassLoader();
  22.         Class clazz4 = classLoader.loadClass("Java5.Person");
  23.         System.out.println(clazz4);
  25.         System.out.println(clazz1 == clazz4);//true
  27.     }

Class实例对应的结构

屏幕截图 2022-04-18 135139.jpg
屏幕截图 2022-04-18 135241.jpg

ClassLoader

理解

屏幕截图 2022-04-18 140514.jpg
屏幕截图 2022-04-18 142231.jpg

  1. public void test1(){
  2.         //对于自定义类，使用系统类加载器进行加载
  3.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
  4.         System.out.println(classLoader);
  5.         //调用系统类加载器的getParent()：获取扩展类加载器
  6.         ClassLoader classLoader1 = classLoader.getParent();
  7.         System.out.println(classLoader1);
  8.         //调用扩展类加载器的getParent()：无法获取引导类加载器
  9.         //引导类加载器主要负责加载java的核心类库，无法加载自定义类
  10.         ClassLoader classLoader2 = classLoader1.getParent();
  11.         System.out.println(classLoader2);//null
  13.         ClassLoader classLoader3 = String.class.getClassLoader();
  14.         System.out.println(classLoader3);//null
  15.     }

使用ClassLoader加载配置文件

  1. public void test2() throws Exception {
  3.         Properties pros = new Properties();
  4.         //此时的文件默认在当前的module下
  5.         //读取配置文件的方式一：
  6.         /*FileInputStream fis = new FileInputStream("jdbc.properties");
  7.         pros.load(fis);*/
  9.         //配置文件默认识别为：当前module的src下
  10.         //读取配置文件的方式二：使用ClassLoader
  11.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
  12.         InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
  13.         pros.load(is);
  15.         String user = pros.getProperty("user");
  16.         String password = pros.getProperty("password");
  17.         System.out.println("user = " + user + ",password = " + password);
  18.     }

创建运行时类的对象

要想此方法正常的创建运行时类，要求：
1.运行时类必须提供空参的构造器
2.空参的构造器的访问权限要够 。通常设置为public
在javabean中要求提供一个public的空参构造器，原因：
1.便于通过反射，创建运行类的对象
2.便于子类继承此运行时类时，默认调用super()时，保证父亲有此构造器

  1. public void test1() throws InstantiationException, IllegalAccessException {
  3.         Class clazz = Person.class;
  5.         //newInstance():调用此方法，创建对应的运行时类的对象,内部调用了运行时类的空参的构造器
  7.         Person obj = (Person) clazz.newInstance();
  8.         System.out.println(obj);
  9.     }

获取运行时类的完整结构

获取属性及其内部结构

  1. public void test1(){
  3.         Class clazz = Person.class;
  5.         //获取属性结构
  6.         //getFields()：获取当前运行时类及其父类中声明为public访问权限的属性
  7.         Field[] fields = clazz.getFields();
  8.         for(Field f : fields){
  9.             System.out.println(f);
  10.         }
  12.         //getDeclaredFields():获取当前运行时类中声明的所有属性（不包含父类）
  13.         Field[] declaredFields = clazz.getDeclaredFields();
  14.         for(Field f : declaredFields){
  15.             System.out.println(f);
  16.         }
  18.     }
  21.     @Test
  22.     public void test2(){
  24.         Class clazz = Person.class;
  25.         Field[] declaredFields = clazz.getDeclaredFields();
  26.         for (Field f : declaredFields){
  27.             //1.权限修饰符
  28.             int modifier = f.getModifiers();
  29.             System.out.println(Modifier.toString(modifier));
  31.             //2.数据类型
  32.             Class type = f.getType();
  33.             System.out.println(type.getName());
  35.             //3.变量名
  36.             String fName = f.getName();
  37.             System.out.println(fName);
  38.         }
  39.     }

获取方法及其内部结构

  1.  public void test1(){
  3.         Class clazz = Person.class;
  5.         //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
  6.         Method[] methods = clazz.getMethods();
  7.         for (Method m : methods){
  8.             System.out.println(m);
  9.         }
  11.         //getDeclaredMethods():获取当前运行时类中声明的所有方法
  12.         Method[] declaredMethods = clazz.getDeclaredMethods();
  13.         for (Method m : declaredMethods){
  14.             System.out.println(m);
  15.         }
  16.     }
  17.     @Test
  18.     public void test2(){
  19.         Class clazz = Person.class;
  20.         Method[] declaredMethods = clazz.getDeclaredMethods();
  21.         for (Method m : declaredMethods){
  22.             //1.获取方法声明的注解
  23.             Annotation[] annos = m.getAnnotations();
  24.             for (Annotation a : annos){
  25.                 System.out.println(a);
  26.             }
  28.             //2.权限修饰符
  29.             System.out.println(Modifier.toString(m.getModifiers()) + "\t");
  31.             //3.返回值类型
  32.             System.out.println(m.getReturnType().getName() + "\t");
  34.             //4.方法名
  35.             System.out.println(m.getName() + "\t");
  37.             //5.形参列表
  38.             Class[] parameterTypes = m.getParameterTypes();
  39.             if (! (parameterTypes == null && parameterTypes.length == 0)){
  40.                 for (int i = 0;i < parameterTypes.length;i++){
  41.                     if (i == parameterTypes.length - 1){
  42.                         System.out.println(parameterTypes[i].getName() + "args_" + i);
  43.                         break;
  44.                     }
  45.                     System.out.println(parameterTypes[i].getName() + "args_" + i + ",");
  47.                 }
  48.             }
  50.             //6.抛出的异常
  51.             Class[] exceptionTypes = m.getExceptionTypes();
  52.             if(exceptionTypes.length > 0){
  53.                 System.out.print("throws");
  55.                 for (int i = 0;i < exceptionTypes.length;i++){
  56.                     if (i == exceptionTypes.length - 1){
  57.                         System.out.println(exceptionTypes[i].getName());
  58.                         break;
  59.                     }
  60.                     System.out.print(exceptionTypes[i].getName() + ",");
  61.                 }
  62.             }
  64.             System.out.println();
  65.         }
  66.     }

获取构造器

  1. //获取构造器
  2.     @Test
  3.     public void test1(){
  5.         Class clazz = Person.class;
  7.         //getConstructors():获取当前运行时类中声明为public的构造器
  8.         Constructor[] constructors = clazz.getConstructors();
  9.         for (Constructor c : constructors){
  10.             System.out.println(c);
  11.         }
  13.         System.out.println();
  15.         //getDeclaredConstructors()：获取当前运行类中声明的所有的构造器
  16.         Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
  17.         for (Constructor c : declaredConstructors){
  18.             System.out.println(c);
  19.         }
  20.     }

获取父类及父类的泛型

  1. //获取运行时类的父类
  2.     @Test
  3.     public void test2(){
  4.         Class clazz = Person.class;
  6.         Class superclass = clazz.getSuperclass();
  7.         System.out.println(superclass);
  9.     }
  10.     //获取运行时类的带泛型的父类
  11.     @Test
  12.     public void test3(){
  13.         Class clazz = Person.class;
  15.         Type genericSuperclass = clazz.getGenericSuperclass();
  16.         System.out.println(genericSuperclass);
  17.     }
  18.     //获取运行时类的带泛型的父类的泛型
  19.     @Test
  20.     public void test4(){
  21.         Class clazz = Person.class;
  23.         Type genericSuperclass = clazz.getGenericSuperclass();
  24.         ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
  25.         //获取泛型类型
  26.         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
  27.         System.out.println(actualTypeArguments[0]);
  28.     }

获取接口

  1. //运行时类实现的接口
  2.     @Test
  3.     public void test5(){
  4.         Class clazz = Person.class;
  6.         Class[] interfaces = clazz.getInterfaces();
  7.         for (Class c : interfaces){
  8.             System.out.println(c);
  9.         }
  11.         System.out.println();
  13.         //获取运行时类的父类实现的接口
  14.         Class[] interface1 = clazz.getSuperclass().getInterfaces();
  15.         for (Class c : interface1){
  16.             System.out.println(c);
  17.         }
  19.     }

获取所在的包

  1. //获取运行时类所在的包
  2.     @Test
  3.     public void test6(){
  4.         Class clazz = Person.class;
  6.         Package pack = clazz.getPackage();
  7.         System.out.println(pack);
  8.     }

获取注解

  1. //获取运行时类的注解
  2.     @Test
  3.     public void test7(){
  4.         Class clazz = Person.class;
  6.         Annotation[] annotations = clazz.getAnnotations();
  7.         for (Annotation annotation : annotations){
  8.             System.out.println(annotation);
  9.         }
  10.     }

调用运行时类的指定结构

调用指定属性

  1. public void test2() throws Exception {
  2.         Class clazz = Person.class;
  4.         //创建运行时类的对象
  5.         Person p = (Person) clazz.newInstance();
  7.         //1.getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
  8.         Field name = clazz.getDeclaredField("name");
  10.         //2.保证当前对象是可访问的
  11.         name.setAccessible(true);
  12.         //3.获取、设置指定对象的属性值
  13.         name.set(p,"Tom");
  15.         System.out.println(name.get(p));
  17.     }

调用指定方法

  1. public void test3() throws Exception {
  3.         Class clazz = Person.class;
  5.         Person p = (Person) clazz.newInstance();
  7.         //1.获取指定的某个方法
  8.         //getDeclaredMethod():参数1：指明获取的方法的名称 参数2：指明获取的方法的形参列表
  9.         Method show = clazz.getDeclaredMethod("show", String.class);
  11.         //2.保证当前方法可访问
  12.         show.setAccessible(true);
  14.         //3.调用invoke()
  16.         //invoke()：参数一：方法的调用者 参数二：给方法赋值的实参
  17.         show.invoke(p,"CHN");
  18.         //invoke()的返回值即为对应类中调用的方法的返回值
  19.         Object returnValue = show.invoke(p, "CHN");
  20.         System.out.println(returnValue);
  21. }

调用静态方法

  1. public void test4() throws Exception {
  3.         Class clazz = Person.class;
  5.         Person p = (Person) clazz.newInstance();
  6.         Method showDesc = clazz.getDeclaredMethod("showDesc");
  7.         showDesc.setAccessible(true);
  9.         //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
  10.         Object returnVal = showDesc.invoke(Person.class);
  11.         System.out.println(returnVal);//null
  12.     }

调用指定构造器

  1. public void test4() throws Exception {
  2.         Class clazz = Person.class;
  4.         //1.获取指定的构造器
  5.         Constructor Constructor = clazz.getDeclaredConstructor(String.class);
  7.         //2.保证此构造器是可访问的
  8.         Constructor.setAccessible(true);
  10.         //3.调用此构造器创建运行时类的对象
  11.         Person per = (Person) Constructor.newInstance("Tom");
  12.         System.out.println(per);
  13.     }

代理模式

静态代理

  1. //静态代理
  2. interface ClothFactory{
  4.     void produceCloth();
  6. }
  8. //代理类
  9. class ProxyClothFactory implements ClothFactory{
  11.     private ClothFactory factory;
  13.     public ProxyClothFactory(ClothFactory factory){
  14.         this.factory = factory;
  15.     }
  17.     @Override
  18.     public void produceCloth() {
  20.         System.out.println("代理工厂做一些准备工作");
  22.         factory.produceCloth();
  24.         System.out.println("代理工厂做一些后续的收尾工作");
  25.     }
  26. }
  28. //被代理类
  29. class NikeClothFactory implements ClothFactory{
  31.     @Override
  32.     public void produceCloth() {
  33.         System.out.println("Nike工厂生产一些运动服");
  34.     }
  35. }
  37. public class StaticProxyTest {
  38.     public static void main(String[] args) {
  39.         //创建被代理类的对象
  40.         NikeClothFactory nike = new NikeClothFactory();
  41.         //创建代理类的对象
  42.         ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
  44.         proxyClothFactory.produceCloth();
  45.     }
  47. }

动态代理

解决问题

1.如何根据加载到内存的被代理类，动态的创建一个代理类及其对象
2.当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法

  1. //动态代理的举例
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. interface Human{
  9.     String getBelief();
  11.     void eat(String food);
  13. }
  15. //被代理类
  16. class SuperMan implements Human{
  18.     @Override
  19.     public String getBelief() {
  20.         return "I believe I can fly!";
  21.     }
  23.     @Override
  24.     public void eat(String food) {
  25.         System.out.println("我喜欢吃" + food);
  26.     }
  27. }
  29. class ProxyFactory{
  30.     //调用此方法，返回一个代理类的对象。解决问题一
  31.     public static Object getProxyInstance(Object obj){//obj:被代理类的对象
  32.         MyInvocationHandler handler = new MyInvocationHandler();
  34.         handler.bind(obj);
  36.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),handler);
  37.     }
  39. }
  41. class MyInvocationHandler implements InvocationHandler{
  43.     private Object obj;//赋值时，需要使用被代理类的对象进行赋值
  45.     public void bind(Object obj){
  46.         this.obj = obj;
  47.     }
  49.     //当我们通过代理类的对象，调用方法a时，就会自动的调用如下方法：invoke()
  50.     //将被代理类要执行的方法a的功能就声明在invoke()中
  51.     @Override
  52.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  54.         //method:即为代理类对象调用的方法，此对象也就作为了被代理类对象要调用的方法
  55.         //obj:被代理类的对象
  56.         Object returnValue = method.invoke(obj, args);
  57.         //上述方法的返回值就作为当前类中的invoke()的返回值
  58.         return returnValue;
  59.     }
  60. }
  62. public class ProxyTest {
  63.     public static void main(String[] args) {
  64.         SuperMan superMan = new SuperMan();
  65.         //proxyInstance:代理类的对象
  66.         Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
  67.         //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
  68.         String belief = proxyInstance.getBelief();
  69.         System.out.println(belief);
  70.         proxyInstance.eat("香辣面");
  72.         System.out.println();
  73.         //体现动态创建代理类
  74.         NikeClothFactory nikeClothFactory = new NikeClothFactory();
  76.         ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
  78.         proxyClothFactory.produceCloth();
  80.     }
  81. }