码迷,mamicode.com
首页 > 编程语言 > 详细

java的反射机制,看完这篇轻松应对高级框架(超详细总结)

时间:2020-04-14 16:54:36      阅读:90      评论:0      收藏:0      [点我收藏+]

标签:catch   row   edit   OLE   private   trace   自定义   保留   扩展名   

导读:很多优秀的高级框架都是通过反射完成的,反射的重要性,由此可见一斑。反射机制可以使得程序更加灵活,只有学习好反射的基础语法,这样才能自己写出优秀的框架。好了一起打卡学习吧,别忘记了素质三连哦!

1.反射机制概述

  • 反射机制有什么作用?
    • java语言中反射机制可以操作字节码文件。
    • 优点:可以直接读和修改字节码文件。通过反射机制可以操作class文件。
    • 反射在框架中使用很多,掌握它,你注定不凡。
  • 在java.lang.reflect.*;包下。
  • 反射机制相关重要的类:
    • java.lang.Class:代表字节码,代表一个类型(整个类)。
    • java.lang.reflect.Method:代表字节码中的方法字节码(类中的方法)
    • java.lang.reflect.Constructor:代表字节码中的构造方法字节码(类中的构造方法)
    • java.lang.reflect.Field:代表字节码中的属性字节码。(类中的静态变量和成员变量)
  • 要操作一个类的字节码,需要首先获取到这个类的字节码,那如何获取java.lang.Class实例呢?
    • 有三种方式:
    • 第一种:class.forName(“ ”)方法:静态方法,方法的参数是一个字符串(完整的类名),不能省略包。返回一个Class类型.(lang.class字节码文件)。使用这个方法会加载类到JVM,使static静态代码块执行(只执行一次),如果你只想让程序执行static静态代码块,只用这个方法就好了。(重点,JDBC中会用)
    • 第二种:getClass()方法,任何一个对象都有这个方法。(返回字节码文件)同一个类的对象返回的java.lang.Class字节码相同(所指的地址相同)。
    • 第三种:java语言中任何一中类型,包括基本数据类型,他都有.class属性。例如:
      • Class x = String.class;
      • Class a = int.class;

2.通过反射机制实例化对象

  • 通过反射机制,获取Class,通过Class来实例化对象.
    • newInstance()方法:创建一个和之前反射相同类型的对象,会自动调用类的无参构造方法。没有无参构造方法,会报异常。(JDK8之后过时了,不过现在主要用的就是JDK8,sun公司长期支持JDK8和JDK11)
    • 举个栗子:
package Day2;


public class ReflectTest1 {
    public static void main(String[] args) {
        Class s1 = null;
        try {
            //通过反射机制获取Class
             s1= Class.forName("Day2.User");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Object a=null;
        try {
           a =s1.newInstance();//用反射获得的Class,创建一个对象
            System.out.println(a);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}
class User{

    public User() {
        System.out.println("无参构造方法!");
    }
}
  • 使用反射机制创建对象有什么作用呢?
    • 反射机制让程序更加灵活。
    • java代码写一遍,在不改变java源代码的基础上,可以做到不同对象的实例化。(符合OCP原则:对外开放,修改关闭。)
    • 高级框架:底层实现原理:采用了反射机制。
    • 举个栗子:(使用IO流,properties集合,通过属性文件来实例化对象)(重点)
package Day2;

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

public class ReflectTest2 {
    public static void main(String[] args) throws Exception {
        //通过IO流读取flie.properties文件
        FileReader reader = new FileReader("file.properties");
        //创建属性类对象(Properties对象,Map集合,key和value都是字符串类型
        Properties pro = new Properties();
        //将文件中的数据加载到Map集合中加载
        pro.load(reader);
        reader.close();//这个流不能在没加载数据之前就关闭了
        //通过key获取value
        String a = pro.getProperty("ClassName");
        Class bb = Class.forName(a);//反射获得Class
        Object c = bb.newInstance();//通过Class,新建一个对象
        System.out.println(c);
    }
}
class User1 {
    public User1() {
        System.out.println("无参构造方法!");
    }
}
  • 如何获取类路径下文件的绝对路径?
    • 为什么聊这个?因为上述代码可能换一个位置,当前路径名就失效了,(即移植性差)所以我们的聊聊这个。
    • 使用以下通用方式,这个文件必须保存在类路径下,(即src目录下)。
    • String path = Thread.currentThread().getContextClassLoader().getResource(" ").getPath();(重点)使用这个方法可以获取文件的绝对路径。(适用于各种操作系统)
    • 哈哈,看不懂?别急解释一下上述程序:
    • Thread.currentThread()当前线程对象
    • getContextClassLoader()使对象的方法,可以获取当前线程的类加载器对象。
    • getResource()这是类加载器对象的方法,当前线程的类加载器默认从类的根路径下加载资源。
    • 示例:
public class Path1 {
    public static void main(String[] args) {
        String path = Thread.currentThread().getContextClassLoader().getResource("File2").getPath();
        System.out.println(path);
    }
}
  • 从执行结果可以看出:源文件和字节码文件存放在不同的位置,执行后与之对应的文件保存在out/production目录下(IDEA中)。
  • 直接以流的方式读取文件,省去获取绝对路径的环节。
    • InputStream reader = Thread.currentThread().getContextClassLoader().getResoutceAsStream("文件名“(类路径下))
    • 举个栗子:
package Day2;


import java.io.InputStream;
import java.util.Properties;

public class Path2 {
    public static void main(String[] args) throws Exception {
        //创建一个流,读取文件
        InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("File2");
        //创建一个Properties集合,保存数据
        Properties pro = new Properties();
            pro.load(reader);//将文件数据加载到集合中
            reader.close();
        String f =pro.getProperty("NewName");
        Class bb = Class.forName(f);//反射获得Class
        Object cc = bb.newInstance();//通过Class实例化对象
        System.out.println(cc);

    }
}
class User2 {
    public User2() {
        System.out.println("无参构造方法!");
    }
}
  • 资源绑定器(重点)
    • 在java.util包下,便于获取属性配置文件的内容。
    • 使用这种方式也必须将属性配置文件放置类路径下。
    • 只能绑定xxx.properties文件。并且不用写路径的扩展名。
    • 此方法简洁简单。所以,以后就用这个方法就好了,集合配合流的方法就不需要用了。
    • 举个栗子:
import java.util.ResourceBundle;

public class Path3 {
    public static void main(String[] args) {
        ResourceBundle bundle = ResourceBundle.getBundle("File2");
        String Name = bundle.getString("NewName");
        System.out.println(Name);
    }
}

3.反射Field(属性)获取字节码

  • 反射属性之前,应该获取整个类。(Class.forName(" ")方法获取。)
  • 获取整个类中的所有的Field。
    • **getFields()方法;用之前获取的整个类调用;**其获取所有public修饰的属性,返回到Field[]数组中。
    • **getDeclaredFields()方法;获取所有属性。**不受修饰符现在,返回到Field[]数组中。
    • getName()方法:可以获取属性名字。对于类也有名字,也用这个方法,对于反射获得的类还有simpleName()方法,来获取简单名字。
    • **getType()方法:获取属性的类型,返回值为类,**然后我们再通过这个得到的类用getName方法获取属性类型的名字。
    • getModifiers()方法:获取属性的修饰符列表,返回的是int类型,每个修饰符的数字是,修饰符的代号。我们可以用toString方法(Modifier.toString),Modefier为reflect的子类,返回一个字符串类型。
    • 举个栗子:
package Day1;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class FieldTest1 {
    public static void main(String[] args) {
        Class First=null;

        try {
            First = Class.forName("Day1.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Field[] fields = First.getDeclaredFields();
        System.out.println(fields.length);
        for(Field arg:fields) {
            int a = arg.getModifiers();
            System.out.println(Modifier.toString(a));//Modefier为reflect的子类
            Class ff = arg.getType();
            System.out.println(ff.getName());
            System.out.println(arg.getName());
        }
    }
}
class Student{
    public String name;
    private int age;
    protected double scroe;
    boolean flag;
}
  • 通过反射机制,反编译一个类的属性Field
  • 怎么通过反射机制访问对象属性?(赋值,获取属性的值)
    • 首先获取整个Class。
    • 然后通过Class实例化对象。
    • 获取对象的属性;依据名字。
    • 属性.set(对象,222)方法:以获取的属性调用,给对象的属性赋值。
    • 反射机制代码复杂,但灵活。
    • 读取属性的值:属性.get(对象)。
    • 举个栗子:
package Day1;

import java.lang.reflect.Field;

public class FieldTest2 {
    public static void main(String[] args) {
        Class fio = null;//获取Class
        Object ff = null;
        {
            try {
                fio = Class.forName("Day1.Student");
                ff = fio.newInstance();//实例化对象
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
        //获取属性
        Field fl = null;
        {
            try {
                fl = fio.getDeclaredField("name");//通过类获取属性,无法通过对象获取
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }
        }
        //给fio对象的fl属性赋值
        try {
            fl.set(ff,"sfdsa");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        //获取属性的值
        try {
            System.out.println(fl.get(ff));
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

  • 可以用上述方法访问私有属性吗?
    • 不可以?当时我们可以用:属性.setAccessible(true)方法打破封装。
    • 因此安全性差。

4.反射Mothod(方法)

反射Mothod

  • 首先获取Class。
  • 获取所有的Method方法。
  • Method[] methods=类.getDeclaredMethod();方法:获取所有的Method.
  • 获取方法的返回值类型:方法.getReturnType().getSimpleName();
  • 获取修饰符列表:Modifer.toString(方法.getModifiers();
  • 获取方法参数的类型:方法.getParameterTypes();返回Class[]数组。再调用getSimpleName()即可。
  • Mothod的反编译(不要求掌握,有兴趣的小伙伴可以自行了解一下)
  • 通过反射机制怎么调用对象的方法。(重点)
  • 1.获取Calss,并用Calss实例化对象。
  • 2.获取Method:使用Method logMethod = 类.getDeclaredMethod("方法名“,类型名.class,类型名.class);方法。
  • 3.调用方法:(对象,方法名,参数,返回值)
    • Object value = 方法.invoke("对象”,“参数值”,“参数值”);invoke方法返回一个Object类型。
    • 举个栗子:
package Day1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MethodTest1 {
    public static void main(String[] args) {
        Class fos =null;
        try {
             fos = Class.forName("Day1.Student1");//获取Class
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Object fis =null;
        try {
            fis = fos.newInstance();//创建对象
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        Method method =null;
        try {
             method = fos.getDeclaredMethod("GetScore",String.class,double.class);//获取方法
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        Object value  = null;
        try {
            value = method.invoke(fis,"jia",520);//调用方法

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println(value);
    }
}
class Student1{
    private String name;
    private  int age;
    private double score;
    public String   GetScore(String name,double score){
        if(score>500){
            System.out.println("恭喜成功!");
        }
        else {
            System.out.println("继续加油!");
        }
        return  name;
    }
}
  • 反射机制的优点:让代码具有通用性,可变化的内容都是写到配置文件中,将来修改配置文件之后,创建的对象不一样了,调用的方法也不同了,但是java代码不需要做任何修改。非常的灵活。

5.反射Constructor(构造方法)

  • 反射机制怎么调用构造方法?
  • 使用反射机制创建对象?
    • 1.调用无参构造方法。(newInstance方法)
    • 2.调用有参构造方法(也可以用这种方法调用无参构造方法)。
    • 第一步:先获取这个有参构造方法;Constructor con = 类.getDeclaredConstructor(int.class,String.classs)第二步:调用构造方法new对象。Object aa =con.newInstance(参数列表)。
    • 举个栗子:
package Day1;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ConstructorTest1 {
    public static void main(String[] args){
        Class fio=null;
        Constructor con=null;
        Object cc = null;
        try {
            //获取类Class
            fio = Class.forName("Day1.Student3");
            //获取构造方法,参数很重要
            con =fio.getDeclaredConstructor(int.class,String.class);
            cc= con.newInstance(11,"Jia");//调用构造方法new对象,这种方法没有过期
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //输出对象
        System.out.println(cc);//自动调用toString方法

    }
}
class Student3{
    private  int age;
    private  String name;
//构造方法
    public Student3() {
    }

    public Student3(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("调用成功!");
    }
}

6.通过反射获取父类和父接口

  • 1.获取类的Class
  • 2.获取Class父类:Class superClass = 子类.getSuperclass();
  • 获取子类实现的所有接口:Class[] interfaces = 子类.getInterfaces();方法。
  • 举个栗子:
package Day1;

public class SuperClassTest1 {
    public static void main(String[] args){
        Class fos =null;
        Class superClass=null;
        try {
            //获取类的Class
            fos= Class.forName("Day1.Student5");
            //获取父类的Class
            superClass = fos.getSuperclass();
            //实例化父类对象
            Object cc = superClass.newInstance();
            System.out.println(cc);
            //获取子类的所有接口
            Class[] interfaces = superClass.getInterfaces();
            for(Class ff : interfaces){
                //获取接口的简称,即不含包名
                System.out.println(ff.getSimpleName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}
//学生类
class Student5 extends Parents{
    private  int age;
    private  String name;
    //构造方法
    public Student5() {
    }

    public Student5(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("调用成功!");
    }
}
//家长类
class Parents implements Study,Sport{
    public Parents() {
        super();
    }
}
//接口
interface Study{

}
interface Sport{

}

7.扩展知识

1.类加载器

  • 什么是类加载器?
    • 专门负责加载类的命令/工具。
    • ClassLoader
  • JDK中自带了3个类加载器
    • 启动类加载器(加载jre\lib\rt.jar)父
    • 扩展类加载器(母)
    • 应用类加载器
  • 假设有这样一段代码:
  • String s = “abc”;
    • 代码在开始执行之前,会将所需要的类全部加载JVM。看到以上代码,类加载器会找到String.class文件,找到就加载,那么是怎么进行加载的呢?
    • 首先通过:启动类加载器”加载。
    • rt.jar中都是Jdk最基本的核心类库。
    • 如果通过“启动类加载器"加载不到的时候:会通过”扩展类加载器“加载。
    • 注意:扩展类加载器专门加载:jre\lib\ext*.jar
    • 如果扩展类加载器没有加载到,那么会通过“应用类加载器”加载。
    • 应用类加载器:classpath中的jar包的类。(class文件)
  • java中为了保证类加载的安全,使用了双亲委派机制。
    • 优先从启动类,(父)然后是扩展类(母),最后是应用类加载器。

2.可变长度参数

  • int…args:这就是可变长度参数。个数为0到N个。
  • 可变长只能在参数的最后一个,且只能有一个。
  • 可变成长度参数可以当做数组看待,具有length属性,有下标,调用的时候可以传一个数组。

3.注解

  • 注解:或者叫做注释(Annotation)
  • 注解有什么作用?
    • 对程序的注释。
  • 注解是一个引用数据类型。编译之后也是生成xxx.class文件。
  • 怎么自定义注解呢?语法格式是怎么样的?
    • [修饰符列表] @interface 注解类型名{
      }
  • 注解怎么使用,用在什么地方?
  • 注解使用时语法格式时:@注解类型名
  • 可以用在构造方法,类,属性,接口,方法,注解等,注解可以修饰注解。
  • 自定义注解:
    • 如果注解中有属性,必须给其赋值。可以在注释的时候@注解名(属性=值),属性名为value时并且只有一个属性的时候,注解的时候可以不写value。定义属性的时候后面需要小括号,可以用default给属性赋默认值。
  • 注解的属性可以是哪些类型?
    • byte,short,int, long,double,boolean,char,float,String,枚举,Class类型,和其数组类型。如果数组中只有一个元素给其赋值时大括号可以省略。
  • 什么是元注解?
    • 用来标注“注解类型”的注解。
  • 常见的元注解:
    • Target注解:(用来标注,被注解的注解可以出现在哪个位置上,其由后面的小括号参数决定。)如:@Target({ElementType.Type,ElementType.MEYHOD})只允许该注解标注类,方法
    • Retention注解:用来标注“被注解的注解”最终保存在哪里。
    • @Retention(RetentionPolicy,SOURCE)表示只被保留在java源文件中。
    • @Retention(RetentionPolicy,CLASS)class文件中。
    • @Retention(RetentionPolicy,RUNTIME)class文件中,并能被注解。//RetentionPolicy是一个枚举类型。
  • JDK内置的注解。
  • java.lang包下:
  • 1.Override注解:只能注解方法,只给编译器参考。如果这个方法不是重写父类的方法,编译器报错。(标识性注解)
  • 2.Deprecated注解:表示某个类,方法已过时。为了告知别人某个类,方法等已过时。

反射注解

如何获取注解类的属性?
1.获取类Class
* Class dd = Class.forName(“完整类名”);
2.判断类上面是否存在特定的注解。
* if(dd(类).isAnnotationPresent(注解类名.class)
3.如果存在特定的注解,则获取注解对象。
* 注解类名 fs = (注解类名)dd.getAnnotation(注解类名.class);
4.获取注解对象的属性。
* 注解对象.属性();
如果获取方法上的注解信息?
1.获取类Class。
2.获取方法。
3.判断方法上是否存在该注解。存在的话,获取方法上的注解。调用方式为:方法.getAnnotation(注解类名.class)
4.再通过得到的注解获得属性。
注解在开发中的使用场景:
举个栗子:假设存在一个注解,只能出现在类上面;当这个类有这个注解:类必须有int类型的属性,否则报异常。

原创不易,码字不易,点个赞再走吧!

java的反射机制,看完这篇轻松应对高级框架(超详细总结)

标签:catch   row   edit   OLE   private   trace   自定义   保留   扩展名   

原文地址:https://www.cnblogs.com/huangjiahuan1314520/p/12698754.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!