注解与反射
1、注解(Annotation)
1.1、什么是注解?
像我们在实现接口一个方法时,会有@Override注解。注解说白了就是对程序做出解释,
与我们在方法,类上的注释没有区别,但是注解可以被其他程序所读取,进行信息处理,
否则与注释没有太大的区别。
1.2、内置注解
内置注解就是我们的 jdk 所带的一些注解。
常用的三个注解:
-
@Override
修辞方法,表示打算重写超类中的方法声明
-
@Deprecated
在使用方法时会出现横线,表示废弃,这个注解可以修饰方法,属性,类,表示不鼓励程序员使用这样的元素,
通常是因为他很危险或者有更好的选择
-
@SuperWarnings
这个注解主要是用来抑制警告信息的,我们在写程序时,可能会报出很多黄线的警告,
但是不影响运行,我们就可以用这个注解来抑制隐藏它。与前俩个注解不同的是我们
必须给注解参数才能正确使用他。
参数 | 说明 |
---|---|
deprecation | 使用了过时的类或方法的警告 |
unchecked | 执行了未检查的转换时的警告 如:使用集合时未指定泛型 |
fallthrough | 当在switch语句使用时发生case穿透 |
path | 在类路径,源文件路径中有不存在路径的警告 |
serial | 当在序列化的类上缺少serialVersionUID定义时的警告 |
finally | 任何finally子句不能完成时的警告 |
all | 关于以上所有的警告 |
上表中就是@SuperWarnings注解的一些参数,按需使用即可
@SuperWarnings(“finally”)
@SuperWarnings(value={“unchecked”,“path”})
1.3、自定义注解
格式:public @interface 注解名{定义体}
- 在使用了@interface自定义注解时,自动继承了java.lang.annotation,Annotation接口
- 其中的每一个方法实际上是声明了一个配置参数
- 方法的名称就是参数的名称
- 返回值类型就是参数的类型(返回值类型只能是基本类型,Class,String,enum)
- 可以通过default来声明参数的默认值
- 如果只有一个参数成员,一般参数名为value
- 我们在使用注解元素时必须要有值,可以定义默认值,空字符串,0或者-1
public @interface TestAnnotation{
// 参数默认为“”
String value() default "";
}
1.4、元注解
我们在自定义注解时,需要使用java提供的元注解,就是负责注解的其他注解。java定义
了四个标准的 meta-annotation类型,他们被用来提供对其他注解类型声明
-
@Target
这个注解的作用主要是用来描述注解的使用范围,说白了就是我们自己定义的注解可以使用在哪个地方
所修饰范围 取值ElementType package PACKAGE 类,接口,枚举,Annotation类型 TYPE 类型成员(方法,构造方法,成员变量,枚举值) CONSTRUCTOR:用于描述构造器。 FIELD:用于描述域。 METHOD:用于描述方法 方法参数和本地变量 LOCAL_VARIABLE:用于描述局部变量。 PARAMETER:用于描述参数 我们自定义一个注解,在声明元注解时可以看到提供我们的所有常量
-
@Retention
表示需要在什么级别保存该注释信息,用于描述注解的生命周期,即我们的注解在什么地方还有效
(SOURCE < CLASS < RUNTIME)
-
@Documented
说明该注解将被包含在javadoc中
-
@Inherited
说明子类可以继承父类中的该注解
package com.hou.study;
import java.lang.annotation.*;
@MyAnnotation
public class Test02 {
public void test(){}
}
// 表示注解的作用域
@Target(value = ElementType.TYPE)
// 表示注解在运行时还有效
@Retention(value = RetentionPolicy.RUNTIME)
// 表示该注解被包含在javadoc中
@Documented
// 该注解表示子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
}
2、反射(Reflection)
2.1、什么是反射?
反射指的是 我们可以在运行期间加载、探知、使用编译期间完全未知的类。
是一个动态的机制,允许我们通过字符串来指挥程序实例化,操作属性,调用方法。
使用代码提高了灵活性,但是同时也带来了更多的资源开销。
加载完类之后,在堆内存中,就产生了一个Class 类型的对象(一个类只有一个Class对象),
这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,
透过这个镜子看到类的结构,所以,我们形象的称之为:反射。
2.2、class类
我们在使用反射时,需要先获得我们需要的类,而java.lang.Class这个类必不可少,他十分特殊,用来表示java中的类型
(class/interface/enum/annotation/primitive type/void)本身。
- Class 类的对象包含了某个被加载类的结构。一个被加载的类对应一个Class对象。
- 当一个class被加载,或当加载器(classloader)的defineClass() 被JVM调用,JVM便自动产生一个Class对象。
获取Class类的对象
首先创建一普通的实体类
package com.hou.reflection;
// 实体类
public class User{
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- 通过 Class.forName() 获取
package com.hou.reflection;
public class Test {
public static void main(String[] args) {
try {
// 通过反射获取类的Class对象 forName()
Class c1 = Class.forName("com.hou.reflection.User");
System.out.println(c1);
Class c2 = Class.forName("com.hou.reflection.User");
Class c3 = Class.forName("com.hou.reflection.User");
Class c4 = Class.forName("com.hou.reflection.User");
// 一个类在内存中只有一个Class对象
// 一个类被加载后,类的整个结构都会被封装在class对象中
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4.hashCode());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
- 通过 getClass() 获取
package com.hou.reflection;
public class Test02 {
public static void main(String[] args) {
// 通过getClass来获取
User user = new User();
Class c1 = user.getClass();
System.out.println(c1);
}
}
- 通过 .class 获取
package com.hou.reflection;
public class Test03 {
public static void main(String[] args) {
// 通过.class 获取
Class c1 = User.class;
System.out.println(c1);
}
}
2.3、所有类型的Class对象
package com.hou.reflection;
import java.lang.annotation.ElementType;
// 所有类型的Class对象
public class Test04 {
public static void main(String[] args) {
Class c1 = Object.class; // Object类
Class c2 = Comparable.class; // 接口
Class c3 = String[].class; // 一维数组
Class c4 = int[][].class; // 二维数组
Class c5 = Override.class; // 注解
Class c6 = ElementType.class; // 枚举
Class c7 = Integer.class; // 基本数据类型
Class c8 = void.class; // void
Class c9 = Class.class; // Class
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}
2.4、类加载内存分析
类的加载与ClassLoader的理解
-
加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象
-
链接:将Java类的二进制代码合并到JVM的运行状态之中的过程
- 验证:确保加载的类信息符合JVM规范,没有安全方面的问题
- 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配
- 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程
-
初始化:
- 执行类构造器()方法的过程,类构造器()方法是由编译器自动收集类中所有类变量的赋值动作
和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类对象的构造器)
-
当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化
-
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步
package com.hou.reflection;
public class Test05 {
public static void main(String[] args) {
A a = new A();
System.out.println(A.m);
/**
* 1.加载到内存,会产生一个类对应的class对象
* 2.链接,链接结束后 m = 0
* 3.初始化
* <clinit>(){
* System.out.println("A类静态代码快初始化");
* m = 300;
* m = 100;
* }
*/
}
}
class A{
static {
System.out.println("A类静态代码快初始化");
m = 300;
}
static int m = 100;
public A() {
System.out.println("A类的无参构造初始化");
}
}
2.5、分析类初始化
什么时候会发生类的初始化?
- 类的主动引用(一定会发生类的初始化)
- 当虚拟机启动,先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员(除了final常量)和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类,如果其父类没有被初始化,则会先初始化它的父类
- 类的被动引用(不会发生类的初始化)
- 当访问一个静态域时,只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
- 通过数组定义类引用,不会触发此类的初始化
- 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)
package com.hou.reflection;
public class Test06 {
static {
System.out.println("main类被加载");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1.主动引用
// Son son = new Son();
// 反射也会产生主动引用
// Class.forName("com.hou.reflection.Son");
// 不会产生类的引用的方法
// System.out.println(Son.b); // 子类调用父类,没有产生子类的加载
// Son[] array = new Son[5]; // 只有main类被加载
System.out.println(Son.M); // 父类和子类都没被加载
}
}
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;
}
2.6、类加载器的作用
-
类加载的作用:将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包装入工作,是最常用的加载器
package com.hou.reflection;
public class Test07 {
public static void main(String[] args) throws ClassNotFoundException {
// 获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
// 获取系统类加载器的父类加载器--》扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
// 获取扩展类加载器的父类加载器--》根加载器(C/C++)
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
// 测试当前类是哪个加载器加载的
ClassLoader classLoader = Class.forName("com.hou.reflection.Test07").getClassLoader();
System.out.println(classLoader);
// 测试JDK内置的类是谁加载的
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader);
// 如何获得系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));
}
}
2.7、获取类的运行时结构
通过反射获取运行时类的完整结构:
Field、Method、Constructor、Superclass、Interface、Annotation
package com.hou.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.hou.reflection.User");
// User user = new User();
// c1 = user.getClass();
// 获得类的名字
System.out.println(c1.getName()); // 获得包名 + 类目
System.out.println(c1.getSimpleName()); // 获得类名
System.out.println("===================");
// 获得类的属性
Field[] fields = c1.getFields(); // 获得 public属性
fields = c1.getDeclaredFields(); // 获得全部属性
for (Field field : fields) {
System.out.println(field);
}
// 获得指定属性的值
System.out.println("======================");
Field name = c1.getDeclaredField("name");
System.out.println(name);
// 获得类的方法
System.out.println("===================");
Method[] methods = c1.getMethods();
for (Method method : methods) {
System.out.println("正常的:" + method);
}
Method[] declaredMethods = c1.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("getDeclaredMethods:" + declaredMethod);
}
// 获得指定方法 因为可能有重载,所以需要参数 (指定方法,方法参数)
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
// 获得构造器
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);
}
// 获得指定的构造器
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
System.out.println("指定的构造器:" + constructor);
}
}
2.8、动态创建对象执行方法
- 创建类的对象:调用Class对象的newInstance()方法
-
- 类必须有一个无参数的构造器
- 类的构造器的访问权限需要足够
-
- 步骤如下:
-
- 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
- 向构造器的形参中传递一个对象数组进去
- 通过Constructor实例化对象
-
- Object invoke(Object obj, Object … args)
- Object 对应原方法的返回值,若原方法无返回值,此时返回null
- 若原方法为静态方法,此时形参Object obj可为null
- 若原方法形参列表为空,则Object[] args 为null
- 若原方法声明为private,则需要在调用此invoke() 方法前,显示调用方法对象的setAccessible(true)方法,将可访问private的方法
- setAccessible(boolean flag)
- Method 和 Field、Constructor对象都有setAccessible()方法
- setAccessible作用是启动和禁用访问安全检查的开关
- 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查
- 提高反射的效率,如果代码中必须使用反射,而该句代码需要频繁的被调用,那么请设置为true
- 使得原本无法访问的私有成员也可以访问
- 参数值为false则指示反射的对象应该实施Java语言访问检查
package com.hou.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
// 动态的创建对象,通过反射
public class Test09 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class c1 = Class.forName("com.hou.reflection.User");
// 构造一个对象
User user = (User) c1.newInstance(); // 本质上是调用了类的无参构造器
System.out.println(user);
// 通过构造器创建对象
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
User user1 = (User) constructor.newInstance("liu", 18);
System.out.println(user1);
// 通过反射调用普通方法
User user2 = (User) c1.newInstance();
// 通过反射调用一个方法
Method setName = c1.getDeclaredMethod("setName", String.class);
// invoke: 激活的意思
// (对象,“方法的值”)
setName.invoke(user2,"侯");
System.out.println(user2.getName());
// 通过反射操作属性
User user3 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
// 不能直接操作私有属性 , 我们需要关闭程序的安全检测 , 属性或者方法的setAccessible(true)
name.setAccessible(true); // 取消安全检查
name.set(user3,"鹏");
System.out.println(user3.getName());
}
}
2.9、性能测试分析
关闭检测会提高反射效率
setAccessible(true);
package com.hou.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test10 {
// 普通方式调用
public 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 void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getMethod("getName", null);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null); // invoke 激活
}
long endTime = System.currentTimeMillis();
System.out.println("反射方式执行10亿次:" + (endTime-startTime) + "ms");
}
// 反射方式调用 关闭检测
public void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c1 = user.getClass();
long startTime = System.currentTimeMillis();
Method getName = c1.getMethod("getName", null);
getName.setAccessible(true);
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("关闭检测的反射方式调用:" + (endTime-startTime) + "ms");
}
public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
Test10 test10 = new Test10();
test10.test01();
test10.test02();
test10.test03();
}
}
2.10、反射操作泛型
-
Java采用泛型擦除的机制来引入泛型,Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和
免去强制类型转化问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除
-
为了通过反射操作这些类型,Java新增了ParameterizedType,GenericArrayType,TypeVariable 和 WildcardType
几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
- ParameterizedType:表示一种参数化类型,比如Collection
- GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable:是各种类型变量的公共父接口
- WildcardType:代表一种通配符类型表达式
package com.hou.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){
System.out.println("test01");
}
public Map<String,User> test02(){
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test11.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes(); // 获得方法的参数类型
for (Type genericParameterType : genericParameterTypes) {
System.out.println(genericParameterType);
if (genericParameterType instanceof ParameterizedType){
// 获得真实参数信息
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
Method method1 = Test11.class.getMethod("test02",null);
Type genericReturnType = method1.getGenericReturnType(); // 获取返回值类型
if (genericReturnType instanceof ParameterizedType){
// 获得真实参数类型
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
2.11、反射操作注解
- getAnnotations
- getAnnotation
练习:ORM
- 了解什么是ORM?
- Object relationship Mapping --> 对象关系映射
- 类和表结构对应
- 属性和字段对应
- 对象和记录对应
- 要求:利用注解和反射完成类和表结构的映射关系
package com.hou.reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
// 练习反射操作注解
public class Test12 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("com.hou.reflection.Student2");
// 通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获得注解 value 的值
TableHou tableHou = (TableHou) c1.getAnnotation(TableHou.class);
String value = tableHou.value();
System.out.println(value);
// 获得类指定的注解
Field f = c1.getDeclaredField("id");
FieldHou annotation = f.getAnnotation(FieldHou.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableHou("db_student")
class Student2{
@FieldHou(columnName = "db_id",type = "int",length = 10)
private int id;
@FieldHou(columnName = "db_age",type = "int",length = 10)
private int age;
@FieldHou(columnName = "db_name",type = "varchar",length = 3)
private String name;
public Student2() {
}
public Student2(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 "Student2{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
// 类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableHou{
String value();
}
// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldHou{
String columnName();
String type();
int length();
}
小结
-
Java.Annotation 注解
-
Annotation的作用:
-
不是程序本身,可以对程序做出解释。(这一点和注释 (comment) 没什么区别)
-
可以被其他程序读取(比如:编译器等)
-
-
内置注解
-
自定义注解
-
元注解
-
-
Java.Reflection 反射
- 相关的API:
- java.lang.Class : 代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造器
- 类的加载过程:
- 类的加载(Load)将类的class文件读入内存,并为之创建一个java.lang.Class对象。此过程由类加载器完成
- 类的链接(Link)将类的二进制数据合并到 JRE 中
- 类的初始化(Initialize)JVM 负责对类进行初始化,初始化执行() 方法
- 如果父类没有被初始化,那触发父类的初始化
- newInstance() 创建类的对象
- Object invoke(Object obj, Object[] args) 激活
- setAccessible(true) 取消安全检查
- 相关的API:
-
双亲委派机制:ClassLoader(类加载器) 即把请求交由父类处理,它是一种任务委派机制 (向上查找)
- 优势:
- 避免类的重复加载
- 保护程序安全
- 优势: