反射的基础(反射的基本概念)

反射

概述：Reflection(反射) 是java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

正常方式：引入需要的“包类”名称 -> new实例化 -> 取得实例化对象

反射方式：实例化对象 -> getClass()方法 -> 得到完整的“包类名称”

Java反射机制提供的功能

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

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

对象照镜子后可以得到的信息：某个类的属性、方法和构造器对于每个类而言，jre都为其保留一个不变的Class类型的对象。

Class本身也是一个类Class对象只能由系统建立对象一个加载的类在JVM中只会有一个Class实例每个类的实例都会记得自己是由哪个Class实例所生成通过Class可以完整的得到一个类中所有被加载的结构Class类是Reflection的根源，针对任何你想被动态加载、运行的类，唯有先获得Class对象 Class类的常用方法

static ClassforName(String name):返回指定类名的Class对象

Object newInstance():调用缺省构造函数，返回Class对象的一个实例

getName():返回此Class对象所表示的实体（类、接口、数组类或void）的名称

Class getSuperClass():获取当前Class对象的父类Class对象

Class[] getinterfaces():获取当前Class对象的接口

ClassLoader getClassLoader():返回该类的类加载器

Constructer[] getConstructors():返回一个包含某些Constructor对象的数组

Method getMothed(String name,Class… T):返回一个Method对象，此对象的形参类型为paramType

Field[] getDeclaredFields():返回Field对象的一个数组

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是"+person.name);
        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        //方式二：forName获得
        Class c2 = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Student");
        System.out.println(c2.hashCode());
        //方式三：通过类名.class获取
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        //获得父类类型
        Class c4 = c1.getSuperclass();
        System.out.println(c4);
        
    }
}
//实体类，含name属性
class Person{
    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 = "老师";
    }
}

哪些类型可以有Class对象

class:外部类、成员（成员内部类，静态内部类），局部内部类，匿名内部类

interface:接口

[]:数组

enum:枚举

annotation:注解@interface

primitive type:基本数据类型

void

import java.lang.annotation.ElementType;
//所有类型的Class
public class Test03 {
    public static void main(String[] args) {
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = Override.class;
        Class c6 = ElementType.class;
        Class c7 = Integer.class;
        Class c8 = void.class;
        Class c9 = Class.class;
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
        //只要元素类型和维度一样，就是同一个Class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
        
    }
}

类加载过程

静态代码块类的无参构造方法静态变量

分析类初始化

当虚拟机启动，先初始化main方法所在的类new一个类的对象调用类的静态成员（除了final常量）和静态方法使用java.lang.reflect包的方法对类进行反射调用当初始化一个类，如果其父类没有被初始化，则先回初始化它的父类类的被动引用（不会发生初始化）

当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化通过数组定义类引用，不会触发此类的初始化引用常量不会触发此类的初始化

类加载器

作用：把类装载进内存，去百度

分类

引导类加载器：C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。扩展类加载器：负责jre/lib/ext目录下的jar包或 -D java.ext.dirs指定目录下的jar包装入工作库。系统类加载器：负责java -classpath或 -D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。

public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取系统类加载器的父类加载器 -> 扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的父类加载器 -> 根加载器（C/C++）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        //获取当前类是哪个类加载器加载的
        ClassLoader classLoader = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Test04").getClassLoader();
        System.out.println(classLoader);
        //测试JDK内部类是哪个类加载器加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);
        
        //如何获得系统类加载器可以加载的路径:jre下的一系列包
        System.out.println(System.getProperty("java.class,pass"));
    }
}

获取类的运行时结构

//获取类的信息
public class Test05 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.archforce.aclub.module.AclubUser");
        //获取类的名字
        System.out.println(c1.getName());//获得包名+类名com.archforce.aclub.module.AclubUser
        System.out.println(c1.getSimpleName());//获得类名AclubUser
        //获得类的属性
        Field[] fields = c1.getFields();//只能找到public属性
        fields=c1.getDeclaredFields();//全部属性（包括private私有）
        for(Field field:fields){
            System.out.println(field);
        }
        //获取指定属性的值
        Field name = c1.getDeclaredField("userName");
        //获取类的方法
        Method[] methods = c1.getMethods();//获取public属性的方法
        methods = c1.getDeclaredMethods();//获取所有方法
        //获取指定方法
        Method getName = c1.getMethod("getUserName",null);
        Method setName = c1.getMethod("setUserName", String.class);
        //获取所有构造器
        Constructor[] constructors = c1.getConstructors();
        constructors = c1.getDeclaredConstructors();
        //获取指定构造器
        Constructor constructor = c1.getConstructor(String.class,int.class,int.class);
    }
}

动态创建对象执行方法

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

//动态的创建对象，通过反射
public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获取Class对象
        Class c1 = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Person");
        //构造一个对象，本质是调用了类的无参构造器
        Person person = (Person)c1.newInstance();
        //通过反射调用普通方法,invoke是激活的意思，invoke(对象,"方法的值")
        Method setName = c1.getMethod("setName",String.class);
        setName.invoke(person,"任建勇");
        System.out.println(person.getName());
        //通过反射操作属性
        Person person2 = (Person)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性，需要关闭程序的安全监测,通过属性或者方法的setAccessible(true)
        name.setAccessible(true);
        name.set(person2,"renjianyogn");
        System.out.println(person2.getName());
    }
}

性能对比分析

正常调用 > 反射方式（关闭检测） > 反射方式

通过反射获取泛型信息

ParameterizedType：表示一种参数化类型，比如Collection

GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable：是各种类型变量的公共父接口

WildcardType：代表一种通配符类型表达式

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
//通过反射获取泛型信息
public class Test07 {
    public void Test1(Map map, List list){
        System.out.println("Test1");
    }
    public Map Test2(){
        System.out.println("Test2");
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test07.class.getMethod("Test1", Map.class, List.class);
        //获取方法Test1的参数信息
        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 = Test07.class.getMethod("Test2", null);
        //获取方法Test2的返回值类型
        Type genericReturnType = method2.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for(Type actualTypeArgument:actualTypeArguments){
                //打印真实参数信息
                System.out.println(actualTypeArgument);
            }
        }

    }
}

反射操作注解

ORM（Object relationship Mapping） --> 对象关系映射

类和表结构对应（实体类，数据库表）属性和字段对应对象和记录对应（数据库每条记录代表一个对象）

练习：利用注解和反射完成类和表结构的映射关系

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Student2");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for(Annotation annotation:annotations){
            System.out.println(annotation);
        }
        //获得注解的value的值
        Tablerenjianyong tablerenjianyong = (Tablerenjianyong)c1.getAnnotation(Tablerenjianyong.class);
        String value = tablerenjianyong.value();
        System.out.println(value);

        //获取类指定的注解（属性/字段）
        Field field = c1.getDeclaredField("name");
        Fieldrenjianyong tablerenjianyong1 = field.getAnnotation(Fieldrenjianyong.class);
        System.out.println(tablerenjianyong1.column());
        System.out.println(tablerenjianyong1.type());
        System.out.println(tablerenjianyong1.length());
        
    }
}
@Tablerenjianyong(value = "db_student")
class Student2{

    @Fieldrenjianyong(column = "db_id",type = "int",length = 10)
    private int id;
    @Fieldrenjianyong(column = "db_age",type = "int",length = 10)
    private int age;
    @Fieldrenjianyong(column = "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 Tablerenjianyong{
    String value();
}
//属性（参数）的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldrenjianyong{
    String column();
    String type();
    int length();
}

反射的基础(反射的基本概念)

Java相关栏目本月热门文章