Java反射

最新推荐文章于 2022-09-27 00:00:18 发布

fanjia2shao

最新推荐文章于 2022-09-27 00:00:18 发布

阅读量73

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/fanjia2shao/article/details/112845460

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Java反射

反射机制
理解Class类并获取Class实例
有了Class对象，我们能够做什么？
反射性能对比
反射操作泛型
反射操作注解

反射机制

动态语言与静态语言

动态语言

动态语言是一类在运行时可以改变其结构的语言：例如新的函数，对象，甚至代码可以被引进，已有的函数可以被删除或是其它结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构

主要的动态语言有：Object-c、C#、JavaScript、PHP、Python等

静态语言

与动态语言相比，运行时结构不可变的语言就是静态语言。例如Java、C、C++

Java不是动态语言，但是Java可以称为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制来获取类似于动态语言的特性，Java的动态性让编程的时候更加灵活。

Java反射机制概述

什么是反射

Java Reflection：Java反射是Java被视为动态语言的关键，反射机制运行程序在执行期借助于Reflection API 去的任何类内部的信息，并能直接操作任意对象的内部属性及方法。


Class c = Class.forName("java.lang.String")

在加载完类后，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息，我们可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象的称之为：反射
在这里插入图片描述
tip：反射可以获取到private修饰的成员变量和方法

反射的应用

在运行时判断任意一个对象所属类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时候处理注解
生成动态代理

Java反射的优缺点

优点：可以实现动态创建对象和编译，体现出很大的灵活性

缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求，这类操作总是慢于直接执行相同的操作。也就是说new创建和对象，比反射性能更高

反射相关的主要API

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器

理解Class类并获取Class实例

Class类

我们下面通过Class.forName来获取一个实例对象


/**

 * 反射Demo

 *

 * @author: 

 * @create: 2020-03-29-8:21

 */

public class ReflectionDemo {

    public static void main(String[] args) throws ClassNotFoundException {

        // 通过反射获取类的Class对象

        Class c1 = Class.forName("com.moxi.interview.study.annotation.User");

        Class c2 = Class.forName("com.moxi.interview.study.annotation.User");

        Class c3 = Class.forName("com.moxi.interview.study.annotation.User");

        System.out.println(c1.hashCode());

        System.out.println(c2.hashCode());

        System.out.println(c3.hashCode());





    }

}



/**

 * 实体类：pojo，entity

 */

class User {

    private String name;

    private int id;

    private int age;



    public User() {



    }



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    public int getId() {

        return id;

    }



    public void setId(int id) {

        this.id = id;

    }



    public int getAge() {

        return age;

    }



    public void setAge(int age) {

        this.age = age;

    }



    @Override

    public String toString() {

        return "User{" +

                "name='" + name + '\'' +

                ", id=" + id +

                ", age=" + age +

                '}';

    }

}

上面我们通过反射获取了三个对象，我们输出对应对象的hashcode码，会发现

它们的hashcode码是一样的，这就说明了：

一个类在内存中只有一个Class对象

一个类被加载后，类的整体结构都会被封装在Class对象中

在Object类中定义了以下的方法，此方法将被所有子类继承


public final Class getClass()

以上方法的返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
在这里插入图片描述
也就是说，我们通过对象来获取到它的Class，相当于逆过程

通过对照镜子我们可以得到的信息：某个类的属性，方法和构造器，某个类到底实现了那些接口。对于每个类而言，JRE都为其保留一个不变的Class类型对象，一个CLass对象包含了特定某个结构的有关信息

Class本身也是一个类

Class对象只能由系统建立对象

一个加载的类在JVM中只会有一个Class实例

一个Class对象对应的是一个加载到JVM中的一个.class文件

每个类的实例都会记得自己是由哪个Class实例所生成

通过Class可以完整地得到一个类中所有被加载的结构

Class类是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得相应的Class对象

Class类常用的方法

ClassforName(String name)：返回指定类name的Class对象
newInstance()：调用缺省构造函数，返回Class对象的一个实例
getName()：返回此Class对象所表示的实体（类，接口，数组或void）的名称
getSuperClass()：返回当前Class对象的父类Class对象
getinterfaces()：返回当前对象的接口
getClassLoader()：返回该类的类加载器
getConstructors()：返回一个包含某些Constructor对象的数组
getMethod(String name, Class… T)：返回一个Method对象，此对象的形参类型为paramsType
getDeclaredFields()：返回Field对象的一个数组

获取对象实例的方法

若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高(Class clazz = Person.class;)
已知某个类的实例，调用该实例的getClass()方法获取Class对象(Class clazz = person.getClass())
已经一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()获取，HIA可能抛出ClassNotFoundException(Class clazz = Class.forName(“demo01.Sutdent”))
内置数据类型可以直接通过类名.Type
还可以利用ClassLoader


/**

 * Class类创建的方式

 *

 * @author: 

 * @create: 2020-03-29-9:56

 */

class Person {

    public String name;

    public Person() {

    }

    public Person(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "Person{" +

                "name='" + name + '\'' +

                '}';

    }

}



class Student extends Person{

    public Student() {

        this.name = "学生";

    }

}



class Teacher extends Person {

    public Teacher() {

        this.name = "老师";

    }

}





public class ClassCreateDemo {

    public static void main(String[] args) throws ClassNotFoundException {



        Person person = new Student();

        System.out.println("这个人是：" + person.name);



        // 方式1：通过对象获得

        Class c1 = person.getClass();

        System.out.println("c1:" + c1.hashCode());



        //方式2：通过forName获得

        Class c2 = Class.forName("com.moxi.interview.study.annotation.Student");

        System.out.println("c2:" + c2.hashCode());



        // 方式3：通过类名获取（最为高效）

        Class c3 = Student.class;

        System.out.println("c3:" + c3.hashCode());



        // 方式4：基本内置类型的包装类，都有一个Type属性

        Class c4 = Integer.TYPE;

        System.out.println(c4.getName());



        // 方式5：获取父类类型

        Class c5 = c1.getSuperclass();

    }

}

有了Class对象，我们能够做什么？

通过调用Class对象的newInstance()方法创建类的对象

类必须有一个无参数的构造器

类的构造器的权限需要足够

如果没有无参构造器就不能创建对象？

只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。

步骤如下：

通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
向构造器的形参中，传递一个对象数组进去，里面包含了构造器中所需的各个参数

通过Constructor实例化对象

调用指定方法

通过反射，调用类中的方法，通过Method类完成。

通过Class类的getMethod方法取得一个Method对象，并设置此方法操作是所需要的参数类型

之后使用Object invoke进行调用，并向方法中传递要设置的obj对象的参数信息

Invoke方法

Object invoke(Object obj， Object … args)

Object对应原方法的返回值，若原方法无返回值，此时返回null

若原方法为静态方法，此时形参Object 可以为null

若原方法形参列表为空，则Object[] args 为 null

若原方法声明private，则需要在调用此invoke() 方法前，显示调用方法对象的setAccessible(true)方法，将可访问private的方法

setAccessible方法

Method和Field、Constructor对象都有setAccessible()方法

setAccessible作用是启动和禁用访问安全检查的开关

参数值为true则指示反射对象再使用时应该取消Java语言访问检查

提高反射效率，如果代码中必须使用反射，而这句代码需要频繁被嗲用，那么设置成true

使得原本无法访问的私有成员也可以访问

参数值为false则指示反射的对象应该实行Java语言访问检查
在这里插入图片描述

完整代码：


/**

 * 通过反射获取对象

 *

 * @author: 陌溪

 * @create: 2020-03-29-12:43

 */

public class GetObjectByReflectionDemo {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {



        // 获取Class

        Class clazz = Class.forName("com.moxi.interview.study.annotation.User");



        // 构造一个对象，newInstance调用的是无参构造器，如果没有无参构造器的话，本方法会出错

//        User user = (User)clazz.newInstance();



        // 获取class的有参构造器

        Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, int.class);

        User user2 = (User) constructor.newInstance("小溪", 10, 10);

        System.out.println(user2);





        // 通过反射调用普通构造方法

        User user3 = (User)clazz.newInstance();

        // 获取setName 方法

        Method setName = clazz.getDeclaredMethod("setName", String.class);

        // 执行setName方法，传入对象 和 参数

        setName.invoke(user3, "小白");

        System.out.println(user3);



        System.out.println("============");

        Field age = clazz.getDeclaredField("age");

        // 关闭权限检测,这样才能直接修改字段，因为 set方法不能直接操作私有变量

        age.setAccessible(true);

        age.set(user3, 10);

        System.out.println(user3);



    }

}

运行结果


User{name='小溪', id=10, age=10}

User{name='小白', id=0, age=0}

============

User{name='小白', id=0, age=10}

反射性能对比

下面我们编写代码来具体试一试，使用反射的时候和不适用反射，在执行方法时的性能对比


/**

 * 反射性能

 *

 * @author: 陌溪

 * @create: 2020-03-29-14:55

 */

public class ReflectionPerformance {



    /**

     * 普通方式调用

     */

    public static void test01() {

        User user = new User();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {

            user.getName();

        }

        long endTime = System.currentTimeMillis();



        System.out.println("普通方式执行10亿次getName的时间:" + (endTime - startTime) + " ms");

    }



    /**

     * 反射方式调用

     */

    public static void test02() throws Exception {

        Class clazz = Class.forName("com.moxi.interview.study.annotation.User");

        Method getName = clazz.getDeclaredMethod("getName", null);

        User user = (User) clazz.newInstance();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {

            getName.invoke(user, null);

        }

        long endTime = System.currentTimeMillis();



        System.out.println("反射方式执行10亿次getName的时间:" + (endTime - startTime) + " ms");

    }



    /**

     * 反射方式调用，关闭权限检查

     */

    public static void test03() throws Exception {

        Class clazz = Class.forName("com.moxi.interview.study.annotation.User");

        Method getName = clazz.getDeclaredMethod("getName", null);

        User user = (User) clazz.newInstance();

        long startTime = System.currentTimeMillis();

        getName.setAccessible(true);

        for (int i = 0; i < 1000000000; i++) {

            getName.invoke(user, null);

        }

        long endTime = System.currentTimeMillis();



        System.out.println("反射方式执行10亿次getName的时间:" + (endTime - startTime) + " ms");

    }

    public static void main(String[] args) throws Exception {

        test01();

        test02();

        test03();

    }

}

运行结果：


普通方式执行10亿次getName的时间:3 ms

反射方式执行10亿次getName的时间:2554 ms

反射方式执行10亿次getName的时间:1365 ms

我们上面分别是执行了 10亿次 getName的方法，从里面可以看出，通过直接实例化对象后，调用getName耗时最短，同时关闭了权限检查后的比不关闭能提高一倍的性能。

反射操作泛型

Java采用泛型擦除机制来引入泛型，Java中的泛型仅仅是给编译器Java才使用的，确保数据的安全性和免去强制类型转换的问题，但是一旦编译完成后，所有的泛型有关的类型全部被擦除

为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是有何原始类型齐名的类型。

ParameterizedType：表示一种参数化类型，比如Collection
GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable：是各种类型变量的公共父接口
WildcardType：代表一种通配符类型的表达式

下面我们通过代码来获取方法上的泛型，包括参数泛型，以及返回值泛型


/**

 * 通过反射获取泛型

 *

 * @author: 陌溪

 * @create: 2020-03-29-15:15

 */

public class GenericityDemo {



    public void test01(Map<String, User> map, List<User> list) {

        System.out.println("test01");

    }



    public Map<String, User> test02() {

        System.out.println("test02");

        return null;

    }



    public static void main(String[] args) throws Exception{



        Method method = GenericityDemo.class.getMethod("test01", Map.class, List.class);



        // 获取所有的泛型，也就是参数泛型

        Type[] genericParameterTypes = method.getGenericParameterTypes();



        // 遍历打印全部泛型

        for (Type genericParameterType : genericParameterTypes) {

            System.out.println(" # " +genericParameterType);

            if(genericParameterType instanceof ParameterizedType) {

                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();

                for (Type actualTypeArgument : actualTypeArguments) {

                    System.out.println(actualTypeArgument);

                }

            }

        }



        // 获取返回值泛型

        Method method2 = GenericityDemo.class.getMethod("test02", null);

        Type returnGenericParameterTypes = method2.getGenericReturnType();



        // 遍历打印全部泛型

        if(returnGenericParameterTypes instanceof ParameterizedType) {

            Type[] actualTypeArguments = ((ParameterizedType) returnGenericParameterTypes).getActualTypeArguments();

            for (Type actualTypeArgument : actualTypeArguments) {

                System.out.println(actualTypeArgument);

            }

        }



    }

}

得到的结果


 # java.util.Map<java.lang.String, com.moxi.interview.study.annotation.User>

class java.lang.String

class com.moxi.interview.study.annotation.User

 # java.util.List<com.moxi.interview.study.annotation.User>

class com.moxi.interview.study.annotation.User

###################

class java.lang.String

class com.moxi.interview.study.annotation.User

反射操作注解

通过反射能够获取到类、方法、字段。。。等上的注解

getAnnotation

getAnnotations

ORM对象关系映射

ORM即为：Object relationship Mapping，对象关系映射

类和表结构对应

属性和字段对应

对象和记录对应
在这里插入图片描述

下面使用代码，模拟ORM框架的简单使用


/**

 * ORMDemo

 *

 * @author: 

 * @create: 2020-03-29-15:33

 */

@TableKuang("db_student")

class Student2 {

    @FieldKuang(columnName = "db_id", type="int", length = 10)

    private int id;



    @FieldKuang(columnName = "db_age", type="int", length = 10)

    private int age;



    @FieldKuang(columnName = "db_name", type="varchar", length = 10)

    private String name;



    public Student2() {

    }



    public Student2(int id, int age, String name) {

        this.id = id;

        this.age = age;

        this.name = name;

    }



    public int getId() {

        return id;

    }



    public void setId(int id) {

        this.id = id;

    }



    public int getAge() {

        return age;

    }



    public void setAge(int age) {

        this.age = age;

    }



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    @Override

    public String toString() {

        return "Student2{" +

                "id=" + id +

                ", age=" + age +

                ", name='" + name + '\'' +

                '}';

    }

}



/**

 * 自定义注解：类名的注解

 */

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@interface TableKuang {

    String value();

}



/**

 * 自定义注解：属性的注解

 */

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@interface FieldKuang {

    String columnName();

    String type();

    int length() default 0;

}

public class ORMDemo {



    public static void main(String[] args) throws Exception{

        // 获取Student 的 Class对象

        Class c1 = Class.forName("com.moxi.interview.study.annotation.Student2");



        // 通过反射，获取到全部注解

        Annotation [] annotations = c1.getAnnotations();



        for (Annotation annotation : annotations) {

            System.out.println(annotation);

        }



        // 获取注解的value值

        TableKuang tableKuang = (TableKuang)c1.getAnnotation(TableKuang.class);

        String value = tableKuang.value();

        System.out.println(value);



        // 获得类指定的注解

        Field f = c1.getDeclaredField("name");

        FieldKuang fieldKuang = f.getAnnotation(FieldKuang.class);

        System.out.println(fieldKuang.columnName());

        System.out.println(fieldKuang.type());

        System.out.println(fieldKuang.length());

    }

}

fanjia2shao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java反射

Java反射反射机制动态语言与静态语言Java反射机制概述什么是反射反射的应用Java反射的优缺点反射相关的主要API理解Class类并获取Class实例Class类Class类常用的方法获取对象实例的方法有了Class对象，我们能够做什么？通过调用Class对象的newInstance()方法创建类的对象通过Constructor实例化对象Invoke方法setAccessible方法反射性能对比反射操作泛型反射操作注解反射机制动态语言与静态语言动态语言动态语言是一类在运行时可以改变其结构的语言
复制链接

扫一扫