注解与反射-复习

目录

  • 注解

    • 内置注解
    • 元注解
    • 自定义注解
  • 反射机制
    • 简介
    • Class类
    • Java内存
    • 类加载的过程
    • ClassLoader
    • 反射获取运行时类的结构信息
    • 动态创建对象
      • 通过反射创建对象 (一般情况)
      • 通过"构造器对象"创建对象 (不存在无参构造)
      • 通过反射调用成员:
        • method
        • field
    • 测试: 性能分析
    • 反射获取泛型数据
    • 反射获取注解数据

基于B站秦疆老师的课. 感谢!

注解

@since JDK1.5

不是程序本身, 可以对程序做出解释, 可以被其他程序读取(如 编译器)

内置注解

  • @Override
  • @SuppressWarnings(value="all") //"unchecked" ...

    抑制编译器的警告信息

  • @Deprecated

    不鼓励使用被修饰的方法\属性\类, 即将弃用

元注解

meta-annotation

给注解作注解

在java.lang.annotation, Java定义了4个标准的元注解:

  • @Target: 描述注解的使用范围, 如类\方法或构造器等
  • @Retention: 描述需要在什么级别保留该注解信息

    ? SOURCE < CLASS < RUNTIME, 框架里很多用RUNTIME

  • @Documented: 表示该注解讲被保留在Javadoc中
  • @Inherited: 表示子类可以继承父类中的该注解

简单代码演示:

@Target(value = {ElementType.METHOD, ElementType.TYPE})	// 描述注解可以作用的语句类型
public @interface MyAnnotation{	// 自定义注解的声明语句

}

自定义注解

  • 使用@interface 声明自定义注解, 自动继承了java.lang.annotation.Annotation接口
  • 其中的成员, 类似于 "方法"
    • 其实是配置参数
    • 方法名是参数名. 如果只有一个参数, 建议参数名为value, 使用时可以免写参数名
    • 返回值类型是参数的类型, 只能为基本类型Class, String, enum
    • 定义了参数, 如果没有定义默认值, 则使用时必须赋值
    • 用default关键字修饰默认值
    • 注解元素必须有值, 哪怕是用空字符串\0作为默认值. 如果定义为-1则表示不存在

反射机制

简介

课程内容梗概

  1. Java反射机制概述
  2. 理解Class类并获取Class实例
  3. 类的加载 (包含Classloader)
  4. 创建运行时类的对象
  5. 获取运行时类的完整信息
  6. 调用运行时类

Java是准动态语言

因为它有反射机制, 才可以视之为"准动态语言"

从内存角度理解反射

类加载完毕后, 在堆内存的方法区就产生了一个唯一Class类型的对象, 其中包含了完整的类的结构信息. 我们可以通过它看到类的完整结构

反射对性能有一定影响

因为反射是一种"解释操作", 总是慢于"直接执行"

Class类

对Class类的认识

  • Class本身也是一个类
  • Class对象只能由系统建立
  • 一个类加载到JVM, 只会对应一个Class对象
  • 且对应一个.class文件
  • 每个类的实例都会记得自己是由哪个Class对象生成的
  • 通过Class对象可以完整得到这个类中所有的结构信息
  • Class类是Relection的根源, 任何想动态加载\运行的类, 只能先获取其Class对象
  • 两个元素类型相同的数组, 即使size不同, 实际也是一个对象(hashCode相等. 同维度数组)
// 数组
int[] a = new int[10];
int[] b = new int[100];
// hashcode打印结果相等
460141958
460141958

哪些可以拥有Class对象?

  • 普通类(包括内部类)
  • interface
  • []
  • enum
  • annotation
  • primitive type, 基本数据类型
  • void
Class<Object> c1 = Object.class;            // 类
Class<Comparable> c2 = Comparable.class;    // 接口
Class<String[]> c3 = String[].class;        // 数组 class [Ljava.lang.String;
Class<int[][]> c4 = int[][].class;          // 数组 class [[I
Class<Override> c5 = Override.class;        // 注解
Class<ElementType> c6 = ElementType.class;  // 枚举
Class<Integer> c7 = Integer.class;          // 基本数据类型
Class<Integer> c72 = Integer.TYPE;          // 基本数据另一种
Class<Void> c8 = void.class;				// void
Class<Class> c9 = Class.class;				// Class
// system out结果
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
int
void
class java.lang.Class

获取Class对象的方式

// 已有对象. Object超类提供的
public final Class getClass();
对象.getClass();
// Class类的静态方法
Class.forName("包名.类名");
// 已知类名, 最安全可靠, 性能高######################
类名.class();

// 基本数据类型的包装类, 可以直接用类名.TYPE
Integer.TYPE;	// int
// 也可以通过ClassLoader

Class类的常用方法

static ClassforNae(String name); // 传入类名, 返回Class对象
Object newInstance(); // 调用缺省构造器, 返回返回Class对象的一个实例
getName(); // 返回此Class对象所表示的实体的名称, (如类\接口\数组类\void)
Class getSuperClass(); // 返回父类Class对象
Class[] getinterfaces(); // 获取当前Class对象的接口
ClassLoadder getClassLoader(); //获取该类的类加载器
Constructor[] getConstructors(); // 获取构造器对象们, 以数组保存
Method getMethod(String name, Class... T);	// 返回一个Method对象, 对象形参为paramType
Field[] getDeclaredFields();	// 返回属性对象们, 以数组保存

Java内存

内存的基本结构

  • 栈

    • 存放基本类型变量, 包含数值
    • 存放引用对象, 在堆中的地址值
  • 堆 (所有线程共享)
    • 存放new的对象 (包括数组)
  • 方法区 (特殊的堆, 所有线程共享)
    • 存放class对象
    • 存放static修饰的东西

类加载的过程

  1. Load

    加载类的过程

    1. 将.class字节码文件内容读取并加载到内存中
    2. 将static数据转换成方法区的运行时数据
    3. 生成一个代表被加载类的java.lang.Class对象
  2. Link

    链接过程, 将类的二进制数据合并到JVM的运行状态, static变量赋默认初始化值, 常量赋指定值, 具体为:

    1. 验证: 确保所加载的类信息符合JVM规范
    2. 准备: 为static的数据()分配位于方法区的内存空间, 并设置默认初始 (例子中int m = 0)
    3. 解析: JVM常量池中的符号引用 (常量名) 替换为直接引用 (地址)

      [不太懂, 估计是常量赋指定常量值]

  3. Initialize

    执行"类构造器"<clinit>()方法

    另外有说明:

    • 初始化类需要先初始化该类的父类
    • JVM会保证<clinit>()方法在多线程环境中被正确加锁和同步

      <clinit>()方法:

      • 是由编译器自动收集的类中的所有类变量的赋值动作和静态代码块中的语句合并产生的. [个人理解: 所有static修饰的数据]
      • 是构造类信息的"类构造器" [个人理解: 不是constructor构造器!]

类加载过程, 自己理解的小结:

  1. Load, 加载 在堆中生成该类对应的Class类对象
  2. Link, 链接, 静态变量分配内存空间, 赋默认初值(int是0, 常量则是具体常量真实值, 云云...)
  3. Initialize, 初始化, 执行static修饰的部分 + 赋程序意图指定的值

什么时候类会初始化?

结论: "类的主动引用", 会初始化类; "类的被动引用", 不会初始化类

  • 主动引用

    • JVM启动, main()所在类
    • new 对象

      注: 如果有父类, 需要先初始化父类

    • 类名直接调用static成员

      注: 不包括static final, 也就是常量

    • 反射, 得到Class对象

      注: 只有Class.forName()是主动引用, 类名.class不是主动引用

  • 被动引用
    • 访问静态field, 声明该field的类才会初始化. (通过子类访问父类的静态属性, 只初始化父类)
    • new以该类为元素类型的数组, 只开辟相应内存空间, 不主动初始化该类
    • 类名直接调用常量. (常量是static final, 这一点与主动引用中类名调用static成员相结合理解)

代码演示:

package com.kuang.reflection;
// 测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main所在类被加载");
    }
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        // 1. new 类
//        Son son = new Son();
        // 2. 反射
//        Class<?> aClass1 = Class.forName("com.kuang.reflection.Son");   // 只是反射, 就已经全部加载
//        Class<Son> sonClass = Son.class;    // 只加载main
//        Class<? extends Son> aClass = son.getClass(); // 全部加载
//        aClass.newInstance();
//        sonClass.newInstance();

        // 不会产生类主动引用的操作
//        System.out.println(Son.b);  // 只加载main和父

//        Son[] arr = new Son[5]; // 只加载main, 说明数组只开辟了空间

        System.out.println(Son.M);  // 只加载main, 因: 常量池中

        /*
        测试调用静态成员方法
         */
//        System.out.println(Son.m);

        /*
        结果猜测: 不过顺序不是本例重点
            main类被加载
            子类被加载
            父类被加载
        正确答案: 猜测错误!
            main
            父类
            子类
         */
    }
}
class Father{
    static int b = 2;

    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

ClassLoader

类加载器的作用

  1. 将*.class源文件内容加载到内存中, 将这些静态数据转换成方法区的运行时数据
  2. 在堆中生成一个代表这个类的java.lang.Class对象, 作为方法区中类数据的访问入口

"类缓存"

类加载到类加载器中, 将维持加载(缓存)一段时间, Class对象会存在一段时间, 就是类缓存. JVM的GC会回收这些Class对象.

JVM规范定义了如下类型的类加载器:

  • Bootstap Classloader: 引导类加载器, C++编写, 负责Java平台核心库rt.jar, 该类加载器无法直接获取注

    无法直接获取, 表现为执行.getParent()返回null

  • Extension Classloader: 扩展类加载器, 负责jre/lib/ext/*.jar
  • System\Application Classloader: 系统类加载, java -classpath下的.jar, 最常用的加载器
  • 自定义类加载器

补充: rt.jar是什么? java.lang的根目录在哪里?

// 位置:
位于jdk文件, ...jdk1.8.0_71\jre\lib\rt.jar
// 用解压缩软件打开rt.jar:
com, java, javax, jdk, META-INF, org, sun
// 打开java:
applet, awt, io, lang, math, rio, rmi, security, sql, text, time, util

**代码演示: 获取各类加载器 **

/*获取类加载器*/
public class Test07 {
    public static void main(String[] args) {
        // 获取SystemClassLoader
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);  // [email protected]
        // 获取SystemClassLoader的父类加载器: ExtClassLoader
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);     // [email protected]
        // 获取扩展类加载器的父类加载器: 根加载器 (c++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);    // null, 可能是java语言层面无法理解, 无法直接获取

        // 获取当前Test07类是哪个类加载器负责的
        Class<?> c1 = Class.forName("com.kuang.reflection.Test07");
        ClassLoader classLoader = c1.getClassLoader();
        System.out.println(classLoader);    // [email protected]

        // 获取Object类是由哪个类加载器负责加载的
        Class<?> c2 = Class.forName("java.lang.Object");
        ClassLoader classLoader2 = c2.getClassLoader();
        System.out.println(classLoader2);   // null

    }
}

双亲委派机制

此机制可以确保, 假如手写的包如果和核心类库包路径\名称雷同时, 不会错误地加载自己手写的包, 从而保证了Java核心类库的安全

反射获取运行时类的结构信息

package com.kuang.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*获得类的信息*/
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class<?> c1 = Class.forName("com.kuang.reflection.User");

        // 获得类的名字
        System.out.println(c1.getName());       // 获得完整类名
        System.out.println(c1.getSimpleName()); // 获得单纯类名

        // 获得类的所有属性
        Field[] fields = c1.getFields();    // 只能找到public属性
        for (Field field : fields) {
            System.out.println(field);  // 结果猜错了, 无结果
        }

        fields = c1.getDeclaredFields();    // 这个才能获取非public的, 更完整的属性们
        for (Field field : fields) {
            System.out.println(field);
        }
        /*
          private java.lang.String com.kuang.reflection.User.name
          private int com.kuang.reflection.User.id
          private int com.kuang.reflection.User.age
         */
        System.out.println("######################################");

        // 获得指定field值
//        Field name = c1.getField("name");   // 报错, 找不到这个field, 因为方法找不到private的
//        System.out.println(name);
        Field name2 = c1.getDeclaredField("name");
        System.out.println(name2);

        // 获得method
        System.out.println("方法: ");
        Method[] methods = c1.getMethods(); // 获得本类及父类的全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("Declared方法");   // 获得本类的所有方法
        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        // 获得指定方法
        System.out.println(c1.getMethod("getName", null));
        System.out.println(c1.getMethod("setName", String.class));
        System.out.println("######################################");

        // 获得所有构造器
        Constructor<?>[] constructors = c1.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("######################################");
        Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(declaredConstructor);
    }
}

动态创建对象

通过反射创建对象 (一般情况)

User (目标类) 的Class对象调用.newInstance(), 要求:

  1. 必须确保该类有无参构造器
  2. 必须确保该构造器的访问权限合适
// 获得Class对象
Class c1 = Class.forName("com.kuang.reflection.User");
// 构造一个对象
User user = (User)c1.newInstance();  // 本质是调用了类的无参构造

通过"构造器对象"创建对象 (不存在无参构造)

假如不存在无参构造器, 就不能通过上一条途径, 但还可以通过Constructor对象, 传入指定参数构建对象, 步骤如下:

  1. 获得指定某重载构造器对象, .getDeclaredConstructor(Class... parameterTypes), 参数为目标对象参数类型的Class对象String.class, int.class...
  2. 构造器对象.newInstance(目标对象需要具体参数)
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
User user2 = (User) constructor.newInstance("zhangsan", 1001, 18);

通过反射调用成员:

method

借助Method类完成, 步骤如下:

  1. c1.getDeclaredMethod()\getMethod(), 参数: 方法名, 参数类型.class...
  2. method对象.invoke(对象, 具体参数们...)
// 通过反射调用成员方法
User user3 = (User) c1.newInstance();
// 通过反射获取方法
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user3, "狂神");    // 调用

field

// 通过反射操作属性
User user4 = (User) c1.newInstance();
Field name = c1.ge tDeclaredField("name");
name.setAccessible(true);   // 操作私有属性之前需要操作
name.set(user4, "李四");
System.out.println(user4);  // 报错, 属性是private的, 不能直接操作,需要setAccessible

注意: 如果目标方法\构造器或属性为private, 则需要提前.setAccessible(true);

setAccessible(),是"访问安全检查的开关"

  • true, 取消访问安全检查, 代码效率也会更高
  • false, 实施访问安全检查

测试: 性能分析

package com.kuang.reflection;

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

/*分析性能问题*/
public class Test10 {
    // 普通方式调用
    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亿次:" + (endTime - startTime) + "ms");
    }
    // 反射方式调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class<? extends User> c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射1方式执行10亿次:" + (endTime - startTime) + "ms");
    }
    // 关闭访问安全检测
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class<? extends User> c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射2方式执行10亿次:" + (endTime - startTime) + "ms");
    }
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        test01();
        test02();
        test03();
    }

}

结果:

普通方式执行10亿次:4ms
反射1方式执行10亿次:2134ms
反射2方式执行10亿次:1266ms

普通方式执行10亿次:5ms
反射1方式执行10亿次:2183ms
反射2方式执行10亿次:1246ms

普通方式执行10亿次:5ms
反射1方式执行10亿次:2087ms
反射2方式执行10亿次:1252ms

反射获取泛型数据

代码演示:

package com.kuang.reflection;

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 Test11 {
    public void test01 (Map<String, User> map, List<User> list, String string, User user) {
        System.out.println("test01");
    }
    public Map<String, User> test02(){
        System.out.println("test02");
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        /*1. 获取方法参数列表中的泛型数据*/
        System.out.println("test01()");
        Method methodTest01 = Test11.class.getMethod("test01", Map.class, List.class, String.class, User.class);
        Type[] genericParameterTypes = methodTest01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {   // 遍历方法的参数, 还需要取具体泛型
            System.out.println(genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {    // 如果是泛型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();// 就获取真实类型(ActualType)
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println("方法参数列表中的泛型: " + actualTypeArgument);
                }
            }
        }
        /*2. 获取方法返回值中的泛型数据*/
        System.out.println("test02()");
        Method test02Method = Test11.class.getMethod("test02");
        Class<?> returnType = test02Method.getReturnType(); // 这种方法不能获取其中的泛型部分
        Type genericReturnType = test02Method.getGenericReturnType();
        System.out.println(returnType);
        System.out.println(genericReturnType);
        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println("方法返回值中的泛型类型:" + actualTypeArgument);
            }
        }
    }
}
D:\Software\jdk1.8.0_71\bin\java.exe "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64909:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath D:\Software\jdk1.8.0_71\jre\lib\charsets.jar;D:\Software\jdk1.8.0_71\jre\lib\deploy.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\access-bridge-64.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\cldrdata.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\dnsns.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\jaccess.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\jfxrt.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\localedata.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\nashorn.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunec.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunjce_provider.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunmscapi.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunpkcs11.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\zipfs.jar;D:\Software\jdk1.8.0_71\jre\lib\javaws.jar;D:\Software\jdk1.8.0_71\jre\lib\jce.jar;D:\Software\jdk1.8.0_71\jre\lib\jfr.jar;D:\Software\jdk1.8.0_71\jre\lib\jfxswt.jar;D:\Software\jdk1.8.0_71\jre\lib\jsse.jar;D:\Software\jdk1.8.0_71\jre\lib\management-agent.jar;D:\Software\jdk1.8.0_71\jre\lib\plugin.jar;D:\Software\jdk1.8.0_71\jre\lib\resources.jar;D:\Software\jdk1.8.0_71\jre\lib\rt.jar;D:\Software-idea\Project-QinJiang\JavaSE\out\production\reflectandnotation com.kuang.reflection.Test11
test01()
java.util.Map<java.lang.String, com.kuang.reflection.User>
方法参数列表中的泛型: class java.lang.String
方法参数列表中的泛型: class com.kuang.reflection.User
java.util.List<com.kuang.reflection.User>
方法参数列表中的泛型: class com.kuang.reflection.User
class java.lang.String
class com.kuang.reflection.User
test02()
interface java.util.Map
java.util.Map<java.lang.String, com.kuang.reflection.User>
方法返回值中的泛型类型:class java.lang.String
方法返回值中的泛型类型:class com.kuang.reflection.User

涉及到的独特而重要的方法:

  • methodTest01.getGenericParameterTypes(), 返回方法对象中所有参数的Type[], 包括泛型和泛型参数的
  • genericParameterType instanceof ParameterizedType, 判断这个Type对象是否属于"泛型Type(参数化类型)"
  • ((ParameterizedType) genericParameterType).getActualTypeArguments(), 抽取Map<String, User>中的String, User的Type对象. 注意需要强转.

反射获取注解数据

代码演示:

package com.kuang.reflection;

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

/*反射获取注解*/
public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        /*获取类的Student2类的注解的Class对象*/
        Class<?> c1 = Class.forName("com.kuang.reflection.Student2");
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        /*获取注解对象的成员: value*/
        Tablekuang tablekuang = c1.getAnnotation(Tablekuang.class);
        String value = tablekuang.value();
        System.out.println(value);

        /*获取类成员的注解*/
        Field field = c1.getDeclaredField("name");
        Annotation[] annotations1 = field.getAnnotations();
        for (Annotation annotation : annotations1) {
            System.out.println(annotation);
        }
        Fieldkuang annotation = field.getAnnotation(Fieldkuang.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

/*声明类名的注解*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@interface Tablekuang{
    String value();
}
/*声明属性的注解*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@interface Fieldkuang{

    String columnName();
    String type();
    int length();
}

/*POJO*/
@Tablekuang("db_student")
class Student2{

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

    public Student2() {
    }

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

    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 "Student2{" +
                "name=‘" + name + ‘\‘‘ +
                ", id=" + id +
                ", age=" + age +
                ‘}‘;
    }
}

运行结果:

D:\Software\jdk1.8.0_71\bin\java.exe "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64741:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath D:\Software\jdk1.8.0_71\jre\lib\charsets.jar;D:\Software\jdk1.8.0_71\jre\lib\deploy.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\access-bridge-64.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\cldrdata.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\dnsns.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\jaccess.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\jfxrt.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\localedata.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\nashorn.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunec.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunjce_provider.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunmscapi.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\sunpkcs11.jar;D:\Software\jdk1.8.0_71\jre\lib\ext\zipfs.jar;D:\Software\jdk1.8.0_71\jre\lib\javaws.jar;D:\Software\jdk1.8.0_71\jre\lib\jce.jar;D:\Software\jdk1.8.0_71\jre\lib\jfr.jar;D:\Software\jdk1.8.0_71\jre\lib\jfxswt.jar;D:\Software\jdk1.8.0_71\jre\lib\jsse.jar;D:\Software\jdk1.8.0_71\jre\lib\management-agent.jar;D:\Software\jdk1.8.0_71\jre\lib\plugin.jar;D:\Software\jdk1.8.0_71\jre\lib\resources.jar;D:\Software\jdk1.8.0_71\jre\lib\rt.jar;D:\Software-idea\Project-QinJiang\JavaSE\out\production\reflectandnotation com.kuang.reflection.Test12
@com.kuang.reflection.Tablekuang(value=db_student)
db_student
@com.kuang.reflection.Fieldkuang(columnName=db_name, type=varchar, length=10)
db_name
varchar
10

原文地址：https://www.cnblogs.com/clzhang/p/12640830.html

时间： 2024-11-05 09:06:00

注解与反射-复习的相关文章

Java高级之注解、反射

Java的注解.反射等机制的产生,让动态代理成为可能,一般通过全限定名+类名,找到类,可以invoke它的构造方法以及其他方法,可以获取它的参数(Field)名称和值. 注解一般用在代码的注释上.代码审查上(有没有按标准写,比如inspect).代码注入(hook,asbectj),需要考虑的是,在何时注入(编译期还运行期) 反射一般用在动态将json和Object互相转化,执行相关底层代码,比如设置某个类的Accessible为false,防止别人hook修改 例:阿里的FastJson解析:

利用注解和反射将map转化成bean

一.java注解 java注解相关的类放在 java.lang.annotation 包下,其主要内容包含4个元注解和其中两个元注解的枚举类值,相对比较简单,从jdk问答即可了解 4个元注解: Documented:指示某一类型的注释将通过 javadoc 和类似的默认工具进行文档化.应使用此类型来注释这些类型的声明:其注释会影响由其客户端注释的元素的使用.如果类型声明是用 Documented 来注释的,则其注释将成为注释元素的公共 API 的一部分. Inherited:指示注释类型被自动继

理解Android中的注解与反射

前言 最近一段时间在研究EventBus和Retrofit 的过程中,都遇到了注解这个概念.由于在学习Java的时候对这方面没有深入了解过,所以看起相关的代码来,总会有点不知其所以然,这里就注解和反射的使用做一下总结. 这里我们先从反射说起,了解了反射的意义及用法后,我们在看看注解的使用,最后叙述一下在Android开发中是怎样结合使用注解与反射. 反射 Java反射(Reflection)定义 Java反射机制是指在运行状态中 对于任意一个类,都能知道这个类的所有属性和方法: 对于任何一个对象

java自定义注解与反射

java注解与反射一.Java中提供了四种元注解,专门负责注解其他的注解,分别如下 1.@Retention元注解,表示需要在什么级别保存该注释信息(生命周期).可选的RetentionPoicy参数包括: RetentionPolicy.SOURCE: 停留在java源文件,编译器被丢掉 RetentionPolicy.CLASS:停留在class文件中,但会被VM丢弃(默认) RetentionPolicy.RUNTIME:内存中的字节码,VM将在运行时也保留注解,因此可以通过反射机制读取注

[杂记]自定义注解以及反射的应用

序:对于注解的认知是从spring开始的,不管是aop还是ioc,对于其概念是比较清楚的,但真正的实现却没有一个比较好的认知,前段时间看了下<从零开始写web框架>,但当时看的比较仓促,再说因为时间的原因,并没有细揪很多东西,这两天研究了下公司一个系统的代码,突然间对于这块有了比较好的理解,故做潦草记录. 项目使用自定义注解和反射主要是为了在webSocket请求发过来的时候,通过请求中的参数定位到类和方法,然后去执行具体的业务逻辑,具体整个流程如下. 1.自定义注解 @Target(Elem

java注解和反射的结合使用

首先反射注解,那么保留策略必须是Runtime,也就是@Retention(RetentionPolicy.RUNTIME) ①定义一个注解类 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.FIELD}) public @interface MyAnnotation { int value(); } ②在定义一个类使用注解类 public class MyBean { @MyAnnotation(20) private int

java注解和反射制作dao基类的练习

首先是三个注解 主键注解 package comments; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lan

注解与反射 ---Spring与Mybatis等框架的实现原理

Java中各大框架,无论是AOP 还是 IoC 其基本实现思路都是源自Java 运行时支撑的反射功能, 而反射最基本的一点就是 任何一个类 其在JVM环境中,都有一个对象的Class对象,这个对象提供一些方面描述了类的 方法 构造函数 注解 等等等 下面就是一个反射跟注解的小例子,是一个比较好入门的小demo 理解之后,几乎所有的框架都是依照这个思路来实现的 package pw.jonwinters.annotation; import java.lang.annotation.Documen

使用自定义注解和反射 ，自动生成查询语句

1.自定义表名注解 package com.lf.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; //自定义表名注解 @Target(ElementType.TYPE) @Retention(Reten