java的反射与注解

最新推荐文章于 2023-07-17 15:55:08 发布

LKIDTI数据

最新推荐文章于 2023-07-17 15:55:08 发布

阅读量442

点赞数 2

分类专栏：大数据文章标签： java spring 反射 python 编程语言

本文链接：https://blog.csdn.net/weixin_45014634/article/details/119086651

版权

大数据专栏收录该内容

11 篇文章 3 订阅

订阅专栏

java的反射与注解

文章目录

java的反射与注解

一、反射

1.1、反射概述

JAVA反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

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

在这里插入图片描述

反射的应用：

1. 通过使用类全名创建类实例来使用外部用户定义的类。

例如Java数据库开发中，需要在运行时使用JDBC驱动包中的驱动类，可以通过反射机制在运行中获取。
Class.forName( “com.mysql.cj.jdbc.Driver” );

2. 开发类浏览器和智能IDE。

例如Eclipse工具，左侧的包浏览器可以查看类的结构，右侧代码编辑区，如果启用了提示功能，在对象后输入“.”运算符，会自动提示该对象所属类的所有可用属性和方法。这些IDE工具的功能需要反射机制实现。

3. 在测试工具中用于检测类的内部结构。

例如Java的单元测试框架Junit就是基于反射和注解实现的

4. 在框架开发中用于实现配置信息的处理。

例如Java Web开发中要学习的Struts2，Spring的框架功能的实现都需要用到反射

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

/**
 *
 * 动态代理的举例
 *
 * @author shkstart
 * @create 2019 上午 10:18
 */

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("====================通用方法二====================");
    }

}


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();

    }
}

最后思考体会反射的动态性
框架 = 反射 + 注解 + 设计模式。

1.2、使用反射

1.2.1 Class类

java.lang.Class类是所有Reflection API的切入点，是所有反射操作的入口。
在Java程序运行过程中，对程序中每种类型的对象，Java虚拟机都会实例化一个不可变的java.lang.Class实例，每个对象都是引用或者原始类型。

反射机制里主要会用到以下四种类

1.java.lang.Class.java：类对象；

2.java.lang.reflect.Constructor.java：类的构造器对象；

3.java.lang.reflect.Method.java：类的方法对象；

4.java.lang.reflect.Field.java：类的属性对象；

1.获取Class实例的三种方法，最常用的是第3种；

对象.getClass()
类型名.class
Class.forName()

（示例代码于code/ClassEx.java）

2.获取类的成员

这时候就用到了java.lang.reflect.Field.java类。一个Field提供类或接口中一个成员变量（属性）的信息，也可以动态访问。

Class中提供了两类用于访问成员变量，成员方法和构造方法的方法：

列出所有成员的方法
根据名字搜索特定成员的方法

public Field getDeclaredField(String name)
//根据名字获取类中定义的成员变量，不包括继承父类的成员

public Field getField(String name)
//根据名字获取类中定义的公有成员变量，包括继承父类的成员

public Field[] getDeclaredFields()
//获取类中声明的所有成员变量，返回Field[]类型，不含继承父类的成员
    
public Field[] getFields()
//获取类中声明的所有公有成员变量，返回Field[]类型

(示例代码于 code/RefEx)

3.获取类的成员方法

public Method getDeclaredMethod(String name,
                                Class<?>... parameterTypes)
//根据名字获取类中定义的成员方法，不包括继承父类的成员方法

public Method getMethod(String name,
                        Class<?>... parameterTypes)
//根据名字获取类中定义的公有成员方法，包括继承父类的成员方法

public Method[] getDeclaredMethods()
//获取类中声明的所有成员方法，返回Method[]类型，不含继承父类的成员

public Method[] getMethods()
//获取类中声明的所有公有成员方法，返回Method[]类型

(示例代码于 code/RefEx)

4.获取类的构造方法

public Constructor<T> getDeclaredConstructor(Class<?>… parameterTypes)
//根据参数类型列表获取类中定义的构造方法

public Constructor<T> getConstructor(Class<?>… parameterTypes)
//根据参数类型列表获取类中定义的公有构造方法

public Constructor<?>[] getDeclaredConstructors()
//获取类中声明的所有构造方法，返回Constructor[]类型

public Constructor<?>[] getConstructors()
//获取类中声明的所有公有构造方法，返回Constructor[]类型

5.调用成员方法

**Method.invoke(Object obj, Object… args)**实现方法调用，多用于不得不用反射的的情况下。
第一个参数是调用这个方法的类实例，如果该方法是静态的，第一个参数为null
后面几个参数是该方法的参数，如果方法没有参数，可以省略

调用成员方法的案例：示例代码见 code/Deet.java

6.用反射的方式给对象的属性设置值，获取对象的属性值

给定类的实例，可以使用反射来设置该类实例中成员变量的值。
通常是以常规方式无法设置的情况下才这样操作。
因为这种访问违反了类的封装性的设计意图，耗费额外的系统开销，所以应该尽可能的酌情使用。

(示例代码见 code/Test.java)

7**.通过Constructor实例创建对象。**

创建类实例（类对象）（重点掌握）：
常规情况下是使用new操作符调用类的构造方法来创建类实例：

Date date = new Date（）；

使用反射创建类实例有两种方法：

Class.newInstance()
//只能调用类的无参数的非私有构造方法
//抛出构造方法的异常
Constructor.newInstance(Object... initargs)
//可以调用类的任何构造方法
//用InvocationTargetException封装异常来抛出

使用反射的注意事项：
反射是强大的，但不应滥用。如果可以在不使用反射的情况下进行操作，则优选避免使用反射。
反射增加了JVM的系统开销，性能上比不使用反射慢。
反射可能违反某些安全策略。
反射允许访问私有成员，打破了封装，可能破坏可移植性。

二、注解

2.1 什么是注解

注解，一种元数据形式，提供有关程序的数据，该数据不属于程序本身。注释对其注释的代码的操作没有直接影响。

注解的语法：

@注解类型名

注释有多种用途，其中包括：

编译前：为编译器提供编译检查的依据，辅助检查代码错误或抑制检查异常。
编译中或发布时：给编译器提供信息生成代码或给其他工具提供信息生成文档等。
运行时：在运行过程中提供信息给解释器，辅助程序执行。
- 注解经常和反射结合起来用，多用于框架中。

2.2 内置的注解

2.2.1 Override

加在方法前
表示重写（覆盖）父类的方法；
如果重写（覆盖）有错误，则报错。

因此重写父类方法，请加上@Override注解。

class Parent {
    String name;
    public Parent(){}
    public Parent(String name)
    {
        this.name = name;
    }
    public void sayHello()
    {
        System.out.println("你好，我是" + name )；
    }
}

public class Child extends Parent
{
    String name;
    public Child{}
    @Override
    public void sayHello(String str)
    {
        //这里会报错
        super.sayHello();
        System.out.println("Hello,im Datawhale");
    }
}

/**
本段代码则不会提示错误

public class Child extends Parent
{
    String name;
    public Child{}
    @Override
    public void sayHello()
    {
        super.sayHello();
        System.out.println("Hello,im Datawhale");
    }
}
**/

2.3 自定义注解

日常开发中我们使用class、interface比较多，而注解和它们一样，也是一种类的类型，他是用的修饰符为 @interface @元注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，语法如下：

public @interface MyTestAnnotation {
     注解属性  [default 默认值]
}

2.4 元注解

元注解负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。
@Target,
@Retention,
@Documented,
@Inherited

@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。
　取值(ElementType)有：
　 1.CONSTRUCTOR:用于描述构造器
　　2.FIELD:用于描述域
　　3.LOCAL_VARIABLE:用于描述局部变量
　　4.METHOD:用于描述方法
　　5.PACKAGE:用于描述包
　　6.PARAMETER:用于描述参数
　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

@Target(ElementType.TYPE)
public @interface Table {
 }

@Target(ElementType.FIELD)
public @interface NoDBColumn {

}

@Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。

ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

最后如果本文对您有所帮助，望一键三连哦，非常感谢。