JAVA打怪之路 - JAVA反射机制

最新推荐文章于 2024-07-24 00:44:45 发布

爱摸鱼的猫猫

最新推荐文章于 2024-07-24 00:44:45 发布

阅读量171

点赞数

分类专栏： # JAVA打怪文章标签： java 反射设计模式

本文链接：https://blog.csdn.net/qq_40521599/article/details/104388987

版权

JAVA打怪专栏收录该内容

17 篇文章 0 订阅

订阅专栏

JAVA反射机制

一、Java反射机制概述（ Java Reflection ）
在这里插入图片描述
反射相关的主要API：

二、理解Class类并获取Class的实例

① 理解Class类（描述类的类）

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

● public final Class getClass() ，以上的方法返回值的类型是一个Class类，此类是Java反射的源头，即：可以通过对象反射求出类的名称。
在这里插入图片描述
② Class类的常用方法

③ 获取Class类实例的四种方式

④ 哪些类型可以有Class对象？

三、类的加载与ClassLoader的理解

① 类的加载过程
在这里插入图片描述
② ClassLoader（类加载器）
类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。

③ 代码示例：

//1.获取一个系统类加载器
ClassLoader classloader = ClassLoader.getSystemClassLoader();
System.out.println(classloader);
//2.获取系统类加载器的父类加载器，即扩展类加载器
classloader = classloader.getParent();
System.out.println(classloader);
//3.获取扩展类加载器的父类加载器，即引导类加载器
classloader = classloader.getParent();
System.out.println(classloader);
//4.测试当前类由哪个类加载器进行加载
classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
System.out.println(classloader);
//5.测试JDK提供的Object类由哪个类加载器加载
classloader =
Class.forName("java.lang.Object").getClassLoader();
System.out.println(classloader);
//*6.关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流
InputStream in = null;
in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");
System.out.println(in);

四、创建运行时类的对象

创建类的对象：调用Class对象的newInstance()方法，内部调用了运行时类的空参的构造器。要求：1）类必须有一个无参数的构造器。 2）类的构造器的访问权限需要足够。

//1.根据全类名获取对应的Class对象
Class clazz = Class.forName(“atguigu.java.Person");
//2.调用指定参数结构的构造器，生成Constructor的实例
Constructor con = clazz.getConstructor(String.class,Integer.class);
//3.通过Constructor的实例创建对应类的对象，并初始化类属性
Person p2 = (Person) con.newInstance("Peter",20);
System.out.println(p2);

五、获取运行时类的完整结构

通过反射获取运行时类的完整结构，Field、Method、Constructor、Superclass、Interface、Annotation 。使用反射可以取得：
在这里插入图片描述

Class clazz = Person.class;
Class[] interfaces = clazz.getInterfaces();
for(Class c : interfaces){
    System.out.println(c);
}
System.out.println();
//获取运行时类的父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for(Class c : interfaces1){
    System.out.println(c);
}

在这里插入图片描述

Class clazz = Person.class;
//getConstructors():获取当前运行时类中声明为public的构造器
Constructor[] constructors = clazz.getConstructors();
for(Constructor c : constructors){
    System.out.println(c);
}
System.out.println();
//getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for(Constructor c : declaredConstructors){
    System.out.println(c);
}

在这里插入图片描述

Class clazz = Person.class;
//getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
Method[] methods = clazz.getMethods();
for(Method m : methods){
    System.out.println(m);
}
System.out.println();
//getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
    System.out.println(m);
}

Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method m : declaredMethods) {
    //1.获取方法声明的注解
    Annotation[] annos = m.getAnnotations();
    for (Annotation a : annos) {
        System.out.println(a);
    }
    //2.权限修饰符
    System.out.print(Modifier.toString(m.getModifiers()) + "\t");
    //3.返回值类型
    System.out.print(m.getReturnType().getName() + "\t");
    //4.方法名
    System.out.print(m.getName());
    System.out.print("(");
    //5.形参列表
    Class[] parameterTypes = m.getParameterTypes();
    if (!(parameterTypes == null && parameterTypes.length == 0)) {
        for (int i = 0; i < parameterTypes.length; i++) {
            if (i == parameterTypes.length - 1) {
                System.out.print(parameterTypes[i].getName() + " args_" + i);
                break;
            }
            System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
        }
    }
    System.out.print(")");
    //6.抛出的异常
    Class[] exceptionTypes = m.getExceptionTypes();
    if (exceptionTypes.length > 0) {
        System.out.print("throws ");
        for (int i = 0; i < exceptionTypes.length; i++) {
            if (i == exceptionTypes.length - 1) {
                System.out.print(exceptionTypes[i].getName());
                break;
            }
            System.out.print(exceptionTypes[i].getName() + ",");
        }
    }
    System.out.println();
}

在这里插入图片描述

//获取属性结构
Class clazz = Person.class;
//getFields():获取当前运行时类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields();
for(Field f : fields){
    System.out.println(f);
}
System.out.println();
//getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
    System.out.println(f);
}

//权限修饰符  数据类型 变量名
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
    //1.权限修饰符
    int modifier = f.getModifiers();
    System.out.print(Modifier.toString(modifier) + "\t");
    //2.数据类型
    Class type = f.getType();
    System.out.print(type.getName() + "\t");
    //3.变量名
    String fName = f.getName();
    System.out.print(fName);

}

在这里插入图片描述

//获取注解
Class clazz = Person.class;
Annotation[] annotations = clazz.getAnnotations();
for(Annotation annos : annotations){
    System.out.println(annos);
}

@Test
    public void test4(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
//        System.out.println(actualTypeArguments[0].getTypeName());
        System.out.println(((Class)actualTypeArguments[0]).getName());
    }

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

示例代码：通过反射，创建对象，调用类的属性、方法、构造器

@Test
public void test2() throws Exception{
    Class clazz = Person.class;
    //1.通过反射，创建Person类的对象
    Constructor cons = clazz.getConstructor(String.class,int.class);
    Object obj = cons.newInstance("Tom", 12);
    Person p = (Person) obj;
    System.out.println(p.toString());
    //2.通过反射，调用对象指定的属性、方法
    //调用属性
    Field age = clazz.getDeclaredField("age");
    age.set(p,10);
    System.out.println(p.toString());

    //调用方法
    Method show = clazz.getDeclaredMethod("show");
    show.invoke(p);
    System.out.println("*******************************");

    //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
    //调用私有的构造器
    Constructor cons1 = clazz.getDeclaredConstructor(String.class);
    cons1.setAccessible(true);
    Person p1 = (Person) cons1.newInstance("Jerry");
    System.out.println(p1);

    //调用私有的属性
    Field name = clazz.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p1,"HanMeimei");
    System.out.println(p1);

    //调用私有的方法
    Method showNation = clazz.getDeclaredMethod("showNation", String.class);
    showNation.setAccessible(true);
    String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
    System.out.println(nation);
}

六、调用运行时类的指定结构

① 如何操作运行时类中的指定的属性 – 需要掌握

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

② 如何操作运行时类中的指定的方法 – 需要掌握

 @Test
    public void testMethod() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        /*
        1.获取指定的某个方法
        getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2.保证当前方法是可访问的
        show.setAccessible(true);

        /*
        2. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
        invoke()的返回值即为对应类中调用的方法的返回值。
         */
        Object returnValue = show.invoke(p,"CHN"); //String nation = p.show("CHN");
        System.out.println(returnValue);

        System.out.println("*************如何调用静态方法*****************");
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
//        Object returnVal = showDesc.invoke(null);
        Object returnVal = showDesc.invoke(Person.class);
        System.out.println(returnVal);//null
    }

③ 如何调用运行时类中的指定的构造器

 @Test
    public void testConstructor() throws Exception {
        Class clazz = Person.class;
        //private Person(String name)
        /*
        1.获取指定的构造器
        getDeclaredConstructor():参数：指明构造器的参数列表
         */
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        //2.保证此构造器是可访问的
        constructor.setAccessible(true);
        //3.调用此构造器创建运行时类的对象
        Person per = (Person) constructor.newInstance("Tom");
        System.out.println(per);
    }

七、反射的应用：动态代理

动态代理相比于静态代理的优点：

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

代理设计模式的原理:

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上。

Java动态代理相关API:
在这里插入图片描述

动态代理步骤：
在这里插入图片描述

静态代理与动态代理模式示例代码：

静态代理举例特点：代理类和被代理类在编译期间，就确定下来了。

interface ClothFactory{
    void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory;//用被代理类对象进行实例化
    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }
   @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些后续的收尾工作");
    }
}
//被代理类
class NikeClothFactory implements ClothFactory{
    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
              //创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
               //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
              proxyClothFactory.produceCloth();
    }
}

动态代理举例:

interface Human{
    String getBelief();
    void eat(String food);
}
//被代理类
class SuperMan implements Human{
    @Override
    public String getBelief() {
           return "I believe I can fly!";
    }
    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

class HumanUtil{
    public void method1(){
        System.out.println("==============通用方法一========");
    }
    public void method2(){
        System.out.println("============通用方法二===============");
    }
}
/*
要想实现动态代理，需要解决的问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
 */
class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
              handler.bind(obj);
             return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{
    private Object obj;//需要使用被代理类的对象进行赋值
    public void bind(Object obj){
           this.obj = obj;
      }
//当我们通过代理类的对象调用方法a时，会自动的调用如下的方法：invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
  @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil util = new HumanUtil();
        util.method1();
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
   //obj:被代理类的对象
    Object returnValue = method.invoke(obj,args);
        util.method2();
        //上述方法的返回值就作为当前类中的invoke()的返回值。
    return returnValue;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
     Human proxyInstance = (Human)      
        ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
    String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");
        System.out.println("*****************************");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyClothFactory = (ClothFactory)         
       ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyClothFactory.produceCloth();
    }
}

爱摸鱼的猫猫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA打怪之路 - JAVA反射机制

JAVA反射机制一、Java反射机制概述（ Java Reflection ）反射相关的主要API：二、理解Class类并获取Class的实例① 理解Class类（描述类的类）在Object类中定义了以下的方法，此方法将被所有子类继承：● public final Class getClass() ，以上的方法返回值的类型是一个Class类，此类是Java反射的源头...
复制链接

扫一扫

专栏目录