（学习记录）注解和反射
文章目录
- 注解和反射
- 一、基本注解
- 1、最常用注解
- 2、元注解
- 二、自定义注解
- 1、分析
- 三、反射机制
- 1、概述
- 2、反射机制研究及应用
- 3、反射相关的主要API
- 4、反射的实现
- 四、Class类
- 1、概述
- 2、Class类的常用方法
- 3、获取Class类的实例
- 4、哪些类型可以有Class对象？
- 5、类加载内存分析（初始化）
- 6、什么时候会发生类的初始化
- 7、类加载器的作用
- 8、类的加载全过程
- 五、创建运行时类的对象
- 1、获取运行时完成结构
- 2、动态创建对象与执行方法
- 3、性能对比分析
- 六、反射操作泛型
- 七、反射操作注解
- 1、方法
- 2、练习：ORM
- 附：英文单词参考
注解和反射
学习视频链接（狂神说Java）：https://www.bilibili.com/video/BV1p4411P7V3
一、基本注解
1、最常用注解
@Override //重写注解
@Deprecated //不推荐程序员使用，但是可以使用，或者纯在更好的方式
@SuppressWarnings //镇压警告
2、元注解
元注解的作用就是负责注解其他注释，java定义了四个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明
@Target //用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
@Retention //表示需要在什么级别保存该注释信息，用于描述注解的生命周期
// SOURCE < CLASS < RUNTIME 在什么地方有效
@Document //表示是否将我们的注解生成在JAVAdoc中
@Inherited //子类可以继承父类的注解
二、自定义注解
使用@interface自定义注解时，自动继承了java.long.annotation.Annotation接口
1、分析
- @interface用来声明一个注解，格式：public @interface 注解名{定义内容}
- 其中的每一个方法实际上是声明了一个配置参数
- 方法的名称就是参数的名称
- 返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）
- 可以通过default来声明参数的默认值
- 如果只有一个参数成员，一般参数名为value
- 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值
public class Test{
@MyAnnotation
public void test() {}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
//注解的参数：参数类型 + 参数名 ()；
//default ：默认值
String value() default "";
}
三、反射机制
Java不是动态语言，但Java可以称之为 “准动态语言” 。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！
1、概述
- Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
- 加载完类之后，在堆内存的方法去中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为反射。
正常实例化方式：
反射方式：
2、反射机制研究及应用
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
- …
优点：可以实现动态创建对象和编译，体现出很大的灵活性
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
3、反射相关的主要API
- java.lang.Class：代表一个类
- java.lang.reflect.Method：代表一个类的方法
- java.lang.reflect.Field：代表类的成员变量
- java.lang.reflect.Constructor：代表类的构造器
- …
4、反射的实现
所有类都继承Object类，在Object类中定义public final Class getClass() 方法，此方法被所有子类继承
- 以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
四、Class类
1、概述
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构（calss/interface/enum/annotation/primitive type/void/[]）的有关信息。
- Class本身也是一个类
- Class对象只能由系统建立对象
- 一个加载的类在JVM中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个Class实例所生成
- 通过Class可以完整的得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
2、Class类的常用方法
static ClassforName(String name) //返回指定类名name的Class对象
Object newlnstance() //调用省缺构造函数，返回Class对象的一个实例
getName() //返回此Class对象所表示的实体（类，接口，数组类或void）的名称
Class getSuperClass() //返回当前Class对象的父类的Class对象
Class[] gettinterfaces() //获取当前Class对象的接口
ClassLoader getClassLoader() //返回该类的加载器
Constructor[] getConstructors //返回一个包含某些Constructor对象的数组
Method getMothed(String name,Class.. T)
//返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields() //返回Field对象的一个数组
3、获取Class类的实例
//1、若一直具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
Class u = User.calss;
//2、已知某个类的实例，调用该实例的getClass()方法获取Class对象
Class u = user.getClass();
//3、已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，
//可能抛出ClassNotFoundException
Class u = Class.forName("deom01.Student");
//4、内置基本数据类型可以直接用类名.Type
Class<Integer> i = Integer.TYPE;
//5、还可以利用ClassLoader 之后介绍
4、哪些类型可以有Class对象？
- calss：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
- interface：接口
- []：数组
- enum：枚举
- annotation：注解@interface
- primitive type：基本数据类型
- void
注：只要元素类型与维度一样，就是同一个Class
int[] a = new int[10];
int[] b = new int[100];
// 输出结果相同
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
5、类加载内存分析（初始化）
本节内容过于抽象，有时间单开个链接。（PS：主要还是本人画图太丑了）
6、什么时候会发生类的初始化
- 类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化其父类
- 类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。（如：当通过子类引用父类的静态变量，不会导致子类初始化）
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中）
7、类加载器的作用
- 类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
- 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
类加载器的作用是用来把类（class）装载进内存的。JVM规范了如下类型的类加载器。
启动/引导类加载器：用C++那么编写的，是JVM自带的类加载器，复制Java平台核心库，用来装载核心类库。该加载器无法直接获取。
**扩展类加载器：**复制jre/lib/ext目录下的jar包或 -D java.ext.dirs 指定目录下的jar包装入工作库。
**系统类加载器：**负责java -classpath 或 - D java.class.path 所指的目录下的类与jar包装入工作，是最常用的加载器。
public static void main(String[] args) throws ClassNotFoundException {
//获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println("systemClassLoader = " + systemClassLoader);
//获取系统类加载器的父类加载器 => 扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println("parent = " + parent);
//获取扩展类加载器的父类加载器 => 根加载器（c/c++）
ClassLoader parent1 = parent.getParent();
System.out.println("parent1 = " + parent1);
//测试当前类加载器
ClassLoader classLoader = Class.forName("test.test04").getClassLoader();
System.out.println("当前类加载器 = " + classLoader);
//测试jdk内置类是谁加载的
ClassLoader classLoader1 = Class.forName("java.lang.String").getClassLoader();
System.out.println("jdk类加载器 = " + classLoader1);
}
//输出结果：
// systemClassLoader = sun.misc.Launcher$AppClassLoader@18b4aac2
// parent = sun.misc.Launcher$ExtClassLoader@1b6d3586
// parent1 = null
// 当前类加载器 = sun.misc.Launcher$AppClassLoader@18b4aac2
// jdk类加载器 = null
**扩展 — 双亲委派机制：**当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载，自己才会去加载这个类。
8、类的加载全过程
-
**加载：**将.class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
-
**链接：**将Java类的二进制代码合并到JVM的运行状态之中的过程
- 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
- 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
-
初始化：
- 执行类构造器 () 方法的过程。类构造器 () 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
- 虚拟机会保证一个类的 () 方法在多线程环境中正确加锁和同步。
五、创建运行时类的对象
1、获取运行时完成结构
- getName() 包名+类名
- getSimpleName() 类名
- getFields() 找到public属性
- getDeclaredFields() 能找到全部属性
- getDeclaredField(“属性名”) 获得指定的属性
- getMethods() 获得本类及分类的所有public方法
- getDeclaredMethods() 获得本类的所有方法
- getMethod(“方法名”, “方法参数，没有写 null”) 获得指定的方法 有参方法要参数类型的Class对象
- getConstructor(属性，属性 …) 获取指定构造器
2、动态创建对象与执行方法
- 创建对象：调用Class对象的 newInstance() 方法
- 类必须有一个无参数的构造器
- 类的构造器的访问权限需要足够
- 创建步骤：
- ⑴ 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
- ⑵ 向构造器的形参中传递一个对象数组进去，如果包含了构造器中所需的各个参数。
- ⑶ 通过Constructor实例化对象
- 创建步骤：
- 通过反射，调用类中的方法，通过Method类完成
- 通过Class类的getMethod（String name，Class…parameterTypes）方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
- 之后使用Object invoke（Object obj，Object[] args）进行调用，并向方法中传递要设置的obj对象的参数信息。
//动态创建对象，通过反射
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//获得Class对象
Class user = Class.forName("test.User");
//构造一个对象
User ref_user = (User) user.newInstance(); //本质是调用了类的无参构造器
System.out.println(ref_user);
//通过构造器创建对象
Constructor constructor = user.getDeclaredConstructor(long.class,String.class);
User ref_user2 = (User) constructor.newInstance(100,"lyn");
System.out.println(ref_user2);
//通过反射调用普通方法
//通过反射获取一个方法
Method setName = user.getDeclaredMethod("setName",String.class);
//invoke : 激活
//使用 .invoke（对象，"方法值"）
setName.invoke(ref_user,"西红柿炒鸡蛋");
System.out.println(ref_user);
Method getName = user.getDeclaredMethod("getName",null);
System.out.println(getName.invoke(ref_user,null));
//通过反射调用一个属性
Field name = user.getDeclaredField("name");
//因为name属性 修饰符 pravate 私有，不能直接访问
//在反射里可以关掉权限访问,setAccessible(true) 关闭
//setAccessible 默认为 false 开启；
name.setAccessible(true);
name.set(ref_user,"鸡蛋炒西红柿");
System.out.println(ref_user);
}
方法扩展：
invoke（Object obj，Object…args）
- 若原方法为静态方法，此时形参Object obj可为null
- 若原方法形参列表为空，则Object[] args为null
- 若原方法声明为 private，则需要在调用此 invoke() 方法前，显示调用方法对象的setAccessible(true) 方法，将可访问 private 的方法。
setAccessible
- Method 和 Field、Constructor 对象都有setAccessible() 方法。
- setAccessible 作用是启动哦和禁用访问安全检查的开关。
- 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
- 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
- 使得原本无法访问的私有成员也可以访问。
- 参数值为false则指示反射的对象应该实施Java语言访问检查。
3、性能对比分析
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
method1();
method2();
method3();
}
//普通调用方法
public static void method1() {
User user = new User();
long begintime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) { user.getName(); }
long endtime = System.currentTimeMillis();
System.out.println("普通调用方法执行时间：" + (endtime - begintime) + "ms");
}
//反射调用方法
public static void method2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class user = Class.forName("test.User");
User ref_user = (User) user.newInstance();
Method getName = user.getDeclaredMethod("getName");
long begintime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) { getName.invoke(ref_user,null);}
long endtime = System.currentTimeMillis();
System.out.println("反射调用方法执行时间：" + (endtime - begintime) + "ms");
}
//反射调用方法,关闭检测
public static void method3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class user = Class.forName("test.User");
User ref_user = (User) user.newInstance();
Method getName = user.getDeclaredMethod("getName");
long begintime = System.currentTimeMillis();
getName.setAccessible(true);
for (int i = 0; i < 1000000000; i++) { getName.invoke(ref_user,null);}
long endtime = System.currentTimeMillis();
System.out.println("反射，关闭检测调用方法执行时间：" + (endtime - begintime) + "ms");
}
//输出结果：以本机性能为准
//普通调用方法执行时间：3ms
//反射调用方法执行时间：2097ms
//反射，关闭检测调用方法执行时间：1039ms
六、反射操作泛型
- Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译期javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。
- 为了通过反射操作这些类型，Java行新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型，但是又和原始类型齐名的类型。
- ParameterizedType：表示一种参数化类型，比如Collection
- GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable：是各种类型变量的公共父接口
- WildcardType：代表一种通配符类型表达式
public static void main(String[] args) throws NoSuchMethodException {
Method method = test07.class.getDeclaredMethod("method1", Map.class, List.class);
//获得泛型参数类型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
//genericParameterType是否为ParameterizedType类型
if (genericParameterType instanceof ParameterizedType) {
System.out.println(genericParameterType);
//获取真实参数类型
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
System.out.println("-----------------------------------------------");
Method method2 = test07.class.getDeclaredMethod("method2");
Type genericReturnType = method2.getGenericReturnType();
//genericReturnType是否为ParameterizedType类型
if (genericReturnType instanceof ParameterizedType) {
System.out.println(genericReturnType);
//获取真实参数类型
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
public void method1(Map<String,User> map, List<String> list) {
}
public Map<String,Integer> method2() {
return null;
}
// 输出结果：
// java.util.Map七、反射操作注解
1、方法
- Class.getAnnotations() 获取所有的注解，包括自己声明的以及继承的
- Class.getAnnotation(Class< A > annotationClass) 获取指定的注解，该注解可以是自己声明的，也可以是继承的
- Class.getDeclaredAnnotations() 仅获取自己声明的注解
2、练习：ORM
- 了解什么是ORM？
- Object relationship Mapping --> 对象关系映射
- 类和表结构对应
- 属性和字段对应
- 对象和记录对应
- 要求：利用注解和反射完成类和表结构的映射关系
//练习反射操作注解
public class demo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class worker_class = Class.forName("test.Worker");
//通过反射获得注解
Annotation[] annotations = worker_class.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得注解的value
LynTable lynTable = (LynTable)worker_class.getAnnotation(LynTable.class);
String value = lynTable.value();
System.out.println(value);
//获得类指定的注解
Field name = worker_class.getDeclaredField("name");
LynField lynField = (LynField)name.getAnnotation(LynField.class);
System.out.println("colunmName = " + lynField.colunmName());
System.out.println("type = " + lynField.type());
System.out.println("length = " + lynField.length());
}
}
@LynTable("db_worker")
class Worker {
@LynField(colunmName = "worker_id",type = "int",length = 10)
private int id;
@LynField(colunmName = "worker_name",type = "varchar",length = 20)
private String name;
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface LynTable{
String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface LynField{
String colunmName();
String type();
int length();
}
// 输出结果：
// @test.LynTable(value=db_worker)
// db_worker
// colunmName = worker_name
// type = varchar
// length = 20
附：英文单词参考
actual 真实的
annotation 注解
arguments 参数
generic 泛型
invoke 激活
reflection 反射