当前位置:首页 > Java技术 > Java反射及其应用

Java反射及其应用

2022年08月05日 14:35:45Java技术2

定义

大家都知道,要让Java程序能够运行,那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载,是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。

Java的反射机制是在编译并不确定是哪个类被加载了,而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类,这样的特点就是反射

作用

Java的反射机制可以知道类的基本结构,这种对Java类结构探知的能力,我们称为Java类的“自审”。

大家都用过IDEA和eclipse。当我们构建出一个对象的时候,去调用该对象的方法和属性的时候,一按点(智能提示),编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来,供用户进行选择。这就是利用了Java反射的原理,是对我们创建对象的探知、自审。

解释

反射之中包含了一个“反”的概念,所以要想解释反射就必须先从“正”开始解释,一般而言,当用户使用一个类的时候,应该先知道这个类,而后通过这个类产生实例化对象,但是“反”指的是通过对象找到类。

基础Person类:

package com.xm.reflect;

/**
 * Created by xuming on 2016/7/21.
 */
public class Person {
     
    private Long id;

    private String name;

    private int age;

    public Person() {

    }

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

应用示例:

package com.xm.reflect;

public class BaseDemo {
    public static void main(String[] args) throws Exception {
        Person per = new Person(); // 正着操作
        System.out.println(per.getClass().getName()); // 反着来
    }
}

以上的代码使用了一个getClass()方法,而后就可以得到对象所在的“包.类”名称,这就属于“反”了,但是在这个“反”的操作之中有一个getClass()就作为发起一切反射操作的开端。

Person的父类是Object类,而上面所使用getClass()方法就是Object类之中所定义的方法。

取得Class对象:public final Class<?> getClass(),反射之中的所有泛型都定义为?,返回值都是Object。

取class对象的三种方法

  1. 通过Object类的getClass()方法取得,基本不用
  2. 使用“类.class”取得,在Hibernate开发的时候使用
  3. 使用Class类内部定义的一个static方法,主要使用

应用示例:

package com.xm.reflect;

/**
 * Created by xuming on 2016/7/21.
 */
public class ClassDemo {
     
    public static void main(String[] args) throws Exception {
        Person per = new Person(); // 正着操作
        Class<?> cls = per.getClass(); // 取得Class对象
        System.out.println(cls.getName() + ";toString:" + cls.toString()); // 反着来

        Class<?> clss = Person.class; // 取得Class对象
        System.out.println(clss.getName()); // 反着来

        Class<?> cls1 = Class.forName("com.xm.reflect.Person"); // 取得Class对象
        System.out.println(cls1.getName()); // 反着来


        Object obj = cls.newInstance(); // 实例化对象,和使用关键字new一样
        Person pers = (Person) obj; // 向下转型
        System.out.println(pers);

    }
}

结果:
Java反射及其应用 _ JavaClub全栈架构师技术笔记

上面用到了通过反射实例化对象:public T newInstance() throws InstantiationException, IllegalAccessException;,可以发现,对于对象的实例化操作,除了使用关键字new之外又多了一个反射机制操作,而且这个操作要比之前使用的new复杂一些,可是有什么用?

对于程序的开发模式之前一直强调:尽量减少耦合,而减少耦合的最好做法是使用接口,但是就算使用了接口也逃不出关键字new,所以实际上new是造成耦合的关键元凶

工厂模式问题造成的关键性的病因是new,那么如果说现在不使用关键字new了,变为了反射机制呢?
反射机制实例化对象的时候实际上只需要“包.类”就可以,于是根据此操作,修改工厂设计模式。

    package com.xm.reflect;

    /**
     * Created by xuming on 2016/7/21.
     */

    interface Fruit {
     
        void eat();
    }

    class Apple implements Fruit {
     
        public void eat() {
            System.out.println("吃苹果。");
        }

    }

    class Orange implements Fruit {
     
        public void eat() {
            System.out.println("吃橘子。");
        }

    }

    class Factory {
     
        public static Fruit getInstance(String className) {
            Fruit f = null;
            try {
                f = (Fruit) Class.forName(className).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return f;
        }
    }

    public class FactoryDemo {
     
        public static void main(String[] args) {
            Fruit f = Factory.getInstance("com.xm.reflect.Orange");
            f.eat();
        }
    }

发现,这个时候即使增加了接口的子类,工厂类照样可以完成对象的实例化操作,这个才是真正的工厂类,可以应对于所有的变化。一些框架技术这个就是它实现的命脉,在日后的程序开发上,如果发现操作的过程之中需要传递了一个完整的“包.类”名称的时候几乎都是反射机制作用

调用构造及实例化

取得构造方法有两个,实例化对象还是newInstance:

  • 取得一个类的全部构造:
public Constructor<?>[] getConstructors() throws SecurityException
  • 取得一个类的指定参数构造:
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
  • 实例化对象:
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException

应用示例:

package com.xm.reflect;

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

/**
 * Created by xuming on 2016/7/21.
 */
public class ConstructDemo {
     
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> cls = Class.forName("com.xm.reflect.Person"); // 取得Class对象
        Constructor<?> cons[] = cls.getConstructors(); // 取得全部构造
        for (int x = 0; x < cons.length; x++) {
            System.out.println(cons[x]);
        }

        Object obj = cls.newInstance(); // 实例化对象
        System.out.println(obj);

        Constructor<?> cons1 = cls.getConstructor(String.class,int.class) ;
        Object obj1 = cons1.newInstance("张三", 20); // 为构造方法传递参数
        System.out.println(obj1);

    }
}

结果:
Java反射及其应用 _ JavaClub全栈架构师技术笔记

调用普通方法

  • 取得全部方法:public Method[] getMethods() throws SecurityException;
  • 取得指定方法:public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

发现以上的方法返回的都是java.lang.reflect.Method类的对象。
取得了Method类对象之后还有一个最大的功能,就是可以利用反射调用类中的方法:

  • 调用方法:public Object invoke(Object obj, Object... args)

之前调用类中方法的时候使用的都是“对象.方法”,但是现在有了反射之后,可以直接利用Object类调用指定子类的操作方法。

应用示例:

package com.xm.reflect;

import java.lang.reflect.Method;

/**
 * Created by xuming on 2016/7/21.
 */
public class MethodDemo {
     
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("com.xm.reflect.Person"); // 取得Class对象
        Method met[] = cls.getMethods(); // 取得全部方法
        for (int x = 0; x < met.length; x++) {
            System.out.println(met[x]);
        }

        Object obj = cls.newInstance(); // 实例化对象,没有向Person转型
        String attribute = "name"; // 要调用类之中的属性
        Method setMet = cls.getMethod("set"+ initcap(attribute), String.class);// setName()
        Method getMet = cls.getMethod("get"+ initcap(attribute));// getName()
        setMet.invoke(obj, "张三") ; // 等价于:Person对象.setName("张三")
        System.out.println(getMet.invoke(obj));// 等价于:Person对象.getName()
    }
    public static String initcap(String str) {
        return str.substring(0,1).toUpperCase().concat(str.substring(1)) ;
    }

}

结果:
Java反射及其应用 _ JavaClub全栈架构师技术笔记

调用成员

  • 取得本类的全部成员:public Field[] getDeclaredFields() throws SecurityException
  • 取得指定的成员:public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException

  • 设置属性内容(类似于:对象.属性= 内容):
    public void set(Object obj, Object value)

  • 取得属性内容(类似于:对象.属性):public Object get(Object obj) throws IllegalArgumentException, IllegalAccessException

可是从类的开发要求而言,一直都强调类之中的属性必须封装,所以现在调用之前要想办法解除封装。

  • 解除封装:public void setAccessible(boolean flag) throws SecurityException

应用示例:

Field nameField = cls.getDeclaredField("name") ; // 找到name属性
nameField.setAccessible(true) ; // 解除封装了
nameField.set(obj, "张三") ; // Person对象.name = "张三"
System.out.println(nameField.get(obj)); // Person对象.name

利用反射拷贝对象的应用实例

希望大家通过该例子进一步掌握反射的应用方法:

package com.xm.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Created by xuming on 2016/7/21.
 */
public class ReflectDemo {
     
    /**
     * 通过反射拷贝对象
     *
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public Object copy(Object object) throws Exception {
        Class<?> classType = object.getClass();
        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
        //获取对象的所有成员变量
        Field[] fields = classType.getDeclaredFields();
        for (Field field : fields) {
            String name = field.getName();//获得成员变量的名称
            String firstLetter = name.substring(0, 1).toUpperCase();//将属性的首字母变为大写

            String getMethodName = "get" + firstLetter + name.substring(1);
            String setMethodeName = "set" + firstLetter + name.substring(1);

            Method getMethod = classType.getMethod(getMethodName, new Class[]{});
            Method setMethod = classType.getMethod(setMethodeName, new Class[]{field.getType()});

            Object value = getMethod.invoke(object, new Object[]{});
            setMethod.invoke(objectCopy, new Object[]{value});
        }
        return objectCopy;
    }

    public static void main(String[] args) throws Exception {
        Person p = new Person("lili", 23);
        p.setId(1L);
        ReflectDemo test = new ReflectDemo();
        Person person = (Person) test.copy(p);
        System.out.println(person);
        System.out.println("ID:" + person.getId() + ",name:" + person.getName() + ",age:" + person.getAge());
    }
}

理解:

1. 要想使用反射,首先需要获得待处理类或对象所对应的Class对象。  
2. 获取某个类或某个对象所对应的Class对象的常用的3种方式:   
     a) 使用Class类的静态方法forName:Class.forName(“java.lang.String”);     
     b)使用类的.class语法:String.class;       
     c) 使用对象的getClass()方法:String s = “aa”; Class<?> clazz = s.getClass();  
3. 若想通过类的不带参数的构造方法来生成对象,我们有两种方式:   
    a) 先获得Class对象,然后通过该Class对象的newInstance()方法直接生成即可:   Class<?> classType = String.class;   Object obj = classType.newInstance();   
    b) 先获得Class对象,然后通过该对象获得对应的Constructor对象,再通过该Constructor对象的newInstance()方法生成: Class<?> classType = Customer.class;   Constructor cons = classType.getConstructor(new Class[]{});   Object obj = cons.newInstance(new Object[]{});  
4. 若想通过类的带参数的构造方法生成对象,只能使用下面这一种方式:   Class<?> classType = Customer.class;   Constructor cons = classType.getConstructor(new Class[]{
      String.class, int.class});   Object obj = cons.newInstance(new Object[]{“hello”, 3});  
5. Integer.TYPE返回的是int,而Integer.class返回的是Integer类所对应的Class对象。

结果:
Java反射及其应用 _ JavaClub全栈架构师技术笔记

以上具体代码见我的github

参考文献:

sql驱动的反射机制:https://segmentfault.com/q/1010000000315618
知乎中关于反射的讨论:https://www.zhihu.com/question/24304289
利用反射拷贝的方法:http://inotgaoshou.iteye.com/blog/849676

作者:狮子座明仔
来源链接:https://blog.csdn.net/shibing624/article/details/51981274

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/java/17825.html

分享给朋友:

“Java反射及其应用” 的相关文章

java反射的应用(Hibernate)

java反射的应用(Hibernate)          Hibernate是一个屏蔽了JDBC,实现了ORM的java框架,利用该框架我们可...

java反射详解之反射作用

java反射详解之反射作用

本文转载两篇文章,前一部分很好的解释了Java 反射在开发中的作用机制,后一部分详细给出了反射的运用案例。 第一部分: 反射作用 Java的反射机制是Java特性之一,反射机制是构建框架技术的基础所在。灵活掌握Java反射机制,对大家以后学习框架技术有很大的帮助。...

Java反射笔记

Java反射笔记

Java反射笔记 1:Class类 同Object,String等类一样,Class也是一个类 构造函数只可由JVM调用,不可由开发者调用。 任何一个类均是Class类的实例对象。 任何继承Object的对象均有 g...

Java异常处理之InvocationTargetException(反射异常)

 Java异常处理之InvocationTargetException(反射异常)   InvocationTargetException异常由Method.invoke(obj, args...)方法抛出。当被调用的方法的内部抛出了异常而没有被捕获时,...

Java 反射之Class介绍和三种创建方式

反射的好处(为什么需要反射机制): 通过反射机制可以获取到一个类的完整信息,例如:所有(包含private修饰)属性和方法,包信息等。 换句话说,Class本身表示一个类的本身,通过Class可以完整获取一个类中的完整结构,包含此...

java反射及应用

java反射及应用

1.反射概述 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文...

JAVA中的反射机制以及在Spring中的应用

文章目录 一 反射机制 二 反射机制的使用-Class类 三 为什么要使用反射 3.1 静态编译 3.2 动态编译 3.3 反射的好处...

利用JAVA反射,读取数据库表名,自动生成对应实体类

本代码是利用java反射,读取数据库表自动根据表名生成实体类,数据库采用老牌SQLSERVER 2000,驱动为JTDS,其他数据库可根据情况自定修改。 代码中包含了大部分数据库类型与JAVA类型的转换,少数未包含进去的会在生成代码时打印出来,方面后期查找修改。 本文...

java反射机制及Method.invoke方法(转载)

java反射机制及Method.invoke方法(转载)

1.java反射机制主要提供了以下功能 在运行时判断任意一个对象所属的类 在运行时构造任意一个类的对象 在运行时判断任意一个类所具有的成员变量和方法 在运行时调用任意一个对象的方法 Reflection 是Java被视为动态(或准动态)语言的一个关...

Java反射机制及用途

Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法; 对于任意一个对象,都能够调用它的任意一个方法和属性; class.forName(类名)//获得类      这种动态获取的信息以及...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。