注解和反射

qq_53706119

已于 2022-04-14 16:14:26 修改

阅读量445

点赞数

文章标签： java

于 2022-04-09 20:39:36 首次发布

本文链接：https://blog.csdn.net/qq_53706119/article/details/124067048

版权

注解

Annotation是从JDK5.0开始弓|入的新技术.

Annotation的作用:

不是程序本身，可以对程序作出解释.(这一点和注释(comment)没什么区别)

可以被其他程序(比如:编译器等)读取.

Annotation的格式:

注解是以"@注释名"在代码中存在的,还可以添加一些参数值,例如:

@SuppressWarnings(value="unchecked").

Annotation在哪里使用?

可以附加在package , class , method , field等上面,相当于给他们添加了额外的辅助信息，

我们可以通过反射机制编程实现对这些元数据的访问

内置注解

@Override : 定义在java.lang.Override中,此注释只适用于修辞方法,表示-个方法声明打算

重写超类中的另一个方法声明.

@Deprecated :定义在java.lang.Deprecated中,此注释可以用于修辞方法,属性，类,表示不

鼓励程序员使用这样的元素, 通常是因为它很危险或者存在更好的选择.

@SuppressWarnings :定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息

与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的,

我们选择性的使用就好了.

@SuppressWarnings("all")

@SuppressWarnings("unchecked")

@SuppressWarnings(value={"unchecked","deprecation"}) 等等.

元注解

元注解的作用就是负责注解其他注解, Java定义了4个标准的meta- annotation类型,他们被用来提供对其他annotation类型作说明.

这些类型和它们所支持的类在java.lang annotation包中可以找到

.( @ Target , @Retention，@Documented , @Inherited )

@Target :用于描述注解的使用范围(即:被描述的注解可以用在什么地方)

@Target(value = {ElemenType.METHOD,ElementType.TYPE})

@Retention :表示需要在什么级别保存该注释信息,用于描述注解的生命周期

( RUNTIME> CLASSS>OURCE)

@Retention(value = RetentionPolicy.RUNTIME)

@Document: 表示该注解将生成在javadoc中

@Inherited: 说明子类可以继承父类中的该注解

自定义注解

使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口

分析:

@ interface用来声明一个注解,格式: public @ interface 注解名{定义内容}

其中的每一个方法实际上是声明了一个配置参数.

方法的名称就是参数的名称.

返回值类型就是参数的类型(返回值只能是基本类型,Class , String , enum ).

可以通过default来声明参数的默认值

如果只有一个参数成员，一-般参数名为value

注解元素必须要有值, 我们定义注解元素时,经常使用空字符串，0作为默认值.

反射

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

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

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。

这个对象就像一面镜子，透过这个镜子看到类的结构，所以,我们形象的称之为:反射

优点:

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

缺点:

对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM,我们希望

做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

反射相关的主要API

java.lang.Class :代表一个类

java.lang.reflect.Method :代表类的方法

java.lang.reflect.Field :代表类的成员变量

java.lang.reflect.Constructor :代表类的构造器

public class Test0 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1=Class.forName("User");
        System.out.println(c1);
    }
}
//实体类
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

    public String getName() {
        return name;
    }

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

    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 +
                '}';
    }
}

Class类

对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。

对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特

定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

Class 本身也是一个类

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

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

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

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

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

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

Class常用方法

方法名	功能说明
static ClassforName(String name)	返回指定类名name的Class对象
Object newInstance()	调用缺省构造函数，返回Class对象的一一个实例
getName()	返回此Class对象所表示的实体(类，接口，数组类或void)的名称。
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class[] getinterfaces()	获取当前Class对象的接口
ClassL oader getClassLoader()	返回该类的类加载器
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Method getMothed(String name,Class.. T)	返回一一个Method对象，此对象的形参类型为paramType
Field[ ] getDeclaredFields()	返回Field对象的一个数组

获取class类的实例

a)若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

Class c1 = Person.class;

b) 已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class c2 = person.getClass();

//获得父类类型

Class c5 = Person.getSuperClass();

c)已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取,

可能抛出ClassNotFoundException

Class c3 = Class .forName("demo01.Student");

d)内置基本数据类型可以直接用类名.Type

Class c4 = Integer.TYPE;

所有类型的CLASS对象

class:外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类。

interface:接口

[]: 数组

enum:枚举

annotation:注解@interface

primitive type:基本数据类型

void

类加载内存分析

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化

类的加载：将类的CLASS文件读入内存，并为之创建一个java.lang.Class对象。

类的连接：将类的二进制数据合并到JRE中

类的初始化：JVM负责对类进行初始化.执行类构造器<clinit>()方法的过程。

当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化

什么时候发生类的初始化

类的主动引用(一定会发生类的初始化)

当虚拟机启动，先初始化main方法所在的类

new一个类的对象

//Son son = new Son();

调用类的静态成员(除了final常量)和静态方法

使用java.lang.reflect包的方法对类进行反射调用

Class.forName(“Son”);

当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用(不会发生类的初始化)

当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化

通过数组定义类引用，不会触发此类的初始化

Son[ ] array = new Son[ 5];

引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

类加载器

类加载器作用是用来把类装载金内存的，JVM规范定义了如下类型的类的加载器：

1.引导类加载器:用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。

2.扩展类加载器:负责jre/ib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库

3.系统类加载器:负责java -classpath或- _Djava.class. path所指的目录下的类与jar包装入工作，是最常用的加载器

//获取系统类的加载器

ClassLoader systemClassLoader = ClassLoader . getSys temClassLoader();

System. out . println( sys temClassLoader);

//获取系统类加载器的父类加载器-- > 扩展类加载器

ClassLoader parent = systemClassLoader .getParent() ;

System. out .pr intln(parent);

//获取扩展类加载器的父类加载器->根加载器(C/c++)

ClassLoader parent1 = parent. getParent() ;

System. out .pr intln(parent1);

//测试当前类是哪个加载器加载的

ClassLoader classLoader = Class.forName ("com. kuang. reflection. Test07") . getClassLoader() ;

System. out .pr intln(classLoader);

//测试JDK内置的类是谁加载的

classLoader = Class . forName ("java. lang.0bject'") .getClassLoader();

System. out . pr intln(classLoader);

//如何获得系统类加载器可以加载的路径

System. out .println(System.getProperty("java.class.path"));

获取类的运行时结构

通过反射获取运行时类的完整结构

Field、Method、 Constructor、 Superclass、 Interface、 Annotation

//获得类的信息

public class Test08 {

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

Class c1 = Class. forName ("com. kuang. reflection.User") ;

   //获得类的名字

   System. out. println(c1.getName()); //获得包名 +类名

   System. out . println(c1. getSimpleName()); //获得类名

   //获得类的属性

   Field[] fields = c1.getFields(); //只能找到public属性

   fields = c1. getDeclaredFields(); //找到全部的属性

   for (Field field : fields) {

      System. out.pr intln(field);

   }

   //获得指定属性的值

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

   System. out .pr intln(name) ;

   //获得类的方法

   Method[] methods = c1. getMethods(); // 获得本类及其父类的全部public方法

   for (Method method : methods) {

      System. out . pr intln("正常的:"+method) ;

   }

   methods = c1. getDeclaredMethods(); //获得本类的所有方法

   for (Method method : methods) {

      System. out . pr intln("getDeclaredMethods:"+method) ;

   }

   //获得指定方法

   //重载

  Method getName = c1. getMethod( name: "getName"，..paramneterTypes: null) ;

Method setName = c1. getMethod( name: "setName", .aramneterTypes: String.class) ;

System. out .println(getName) ;

System. out .println( setName) ;

   //获得指定的构造器

   Constructor[] constructors = C1. getConstructors() ;

   for (Constructor constructor : constructors) {

      System. out . pr intln(constructor);

   }

   constructors = C1 . getDeclaredConstructors() ;

   for (Constructor constructor : constructors) {

      System.out . println("#'"+constructor) ;

   }

   //获得指定的构造器

Constructor declaredConstructor = c1 . getDeclaredConstructor(String.class，int.class， int.class) ;

   System. out. println("指定:"+declaredConstructor) ;

动态创建对象执行方法

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

类必须有一个无参的构造器
类的构造器的访问权限需要足够

//获得Class对象

Class c1 = Class. forName ("com. kuang. reflection.User") ;

//构造一个对象

//User user = (User)c1. newInstance(); //本质是调用了类的无参构造器

//System. out. println(user);

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

步骤如下：

1 .通过Class类的getDeclaredConstructor(Class ... parameterTypes)取得本类的指定形参类型的构造器

2.向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

3.通过Constructor实例化对象

//通过构造器创建对象

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

User user2 = (User) constructor. newInstance("秦疆'，001, 18);

System. out. println(user2);

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

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

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

①通过Class类的getMethod(String name,Class..parameterTypes)方法取得一个Method对象并设置此方法操作时所需要的参数类型。

②之后使用Object invgke(Object obj, Obje'ct[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

//通过反射获取一个方法

Method setName = c1. getDeclaredMethod( name: "setName", String.class) ;

Object invoke(Object obj, Object ... args)

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

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

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

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

//invoke :激活的意思

// (对象，"方法的值")

setName. invoke (user3, ..rgs. "1");

System. out . pr intln(user3. getName()) ;|

//通过反射操作属性

System. out . println("888888888888888888888888") ;

User user4 = (User )c1. newInstance() ;

Field name = c1. getDeclaredField( name: "name'") ;

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

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

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

提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置true。

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

参数值为false则指示反射的对象应该实施Java语言访问检查

//不能直接操作私有属性，我们需要关闭程序的安全检测，属性或者方法的setAccessible(true) 。

name . setAccessible(true); //

name. set(user4, "2") ;

System. out . pr intln(user4.getName()) ;

反射操作泛型

Java采用泛型擦除的机制来弓|入泛型, Java中的泛型仅仅是给编译器javac使用的,确保数据

的安全性和免去强制类型转换问题，但是,一旦编译完成,所有和泛型有关的类型全部擦除

为了通过反射操作这些类型, Java新增了ParameterizedType , GenericArrayType，

TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原

始类型齐名的类型.

ParameterizedType : 表示一种参数化类型,比如Collection<String>

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

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

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

public static void main(String[] args) throws NoSuchMethodException {
    Method method=test1.class.getMethod("test01", Map.class, List.class);

    Type[] genericParamenterTypes=method.getGenericExceptionTypes();

    for (Type genericParamenterType : genericParamenterTypes) {
        if (genericParamenterType instanceof ParameterizedType){
            Type[] actualTypeArguments=((ParameterizedType)genericParamenterType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }

    method =test1.class.getMethod("test02",null);
    Type genericReturnType=method.getGenericReturnType();

    if (genericReturnType instanceof ParameterizedType){
        Type[] actualTypeArguments=((ParameterizedType)genericReturnType).getActualTypeArguments();
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}

ORM

Object Relationship Mapping --->对象关系映射

类和表结构对应

属性和字段对应

对象和记录对应

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

public class Test2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1=Class.forName("Student");

        //通过反射获得注解
        Annotation[] annotations=c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解的value的值
        Table1 table1=(Table1)c1.getAnnotation(Table1.class);
        String value=table1.value();
        System.out.println(value);

        //获得指定类注解
        Field f=c1.getDeclaredField("name");
        Field1 annotation=f.getAnnotation(Field1.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.lenth());
    }
}
@Table1("db_student")
class Student{

    @Field1(columnName = "db_id",type = "int",lenth = 10)
    private int id;
    @Field1(columnName = "db_age",type = "int",lenth = 10)
    private int age;
    @Field1(columnName = "db_name",type = "varchar",lenth = 10)
    private  String name;

    public Student() {
    }

    public Student(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 "Student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}


//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table1{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field1{
    String columnName();
    String type();
    int lenth();
}

qq_53706119

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
注解和反射

注解Annotation是从JDK5.0开始弓|入的新技术.Annotation的作用:不是程序本身，可以对程序作出解释.(这一点和注释(comment)没什么区别)可以被其他程序(比如:编译器等)读取.Annotation的格式:注解是以"@注释名"在代码中存在的,还可以添加一些参数值,例如:@SuppressWarnings(value="unchecked").Annotation在哪里使用?可以附加在package , class , method
复制链接

扫一扫