注解和反射
1. 注解(Annotation)
1.1 介绍
Annotation 是 JDK5.0 引入的新技术,不是程序本身,可以对程序做出解释,可以被其他程序(如:编译器等)读取,可以附加在 package,class,method,field等上面,相当于给他们添加了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问。
注解格式: @注释名
还可以添加一些参数值,@SuppressWarning(value="unchecked")
1.2 内置注解
-
@Override:定义在 java.lang.Override 中,只适用于修饰方法,表示一个方法生命打算重写超类中的另一个方法声明
//注解 public class Test01 extends Object{ @Override //注解,重写注解,具有约束的作用 public String toString() { return super.toString(); }
-
@Deprecated:定义在 java.lang.Deprecated 中,可以用于修饰方法,属性,类,表示不鼓励使用这样的元素,通常是因为危险或者存在更好的选择
public class Test01 extends Object{ @Deprecated //表示不推荐使用,但是可以使用或者存在更好的替换方式 public static void test(){ System.out.println("@Deprecated"); } public static void main(String[] args) { test(); } }
-
@SuppressWarnings:定义在 java.lang.SuppressWarnings 中,用来抑制编译时的警告信息,该注解需要添加一个参数才能正确使用,参数是已经定义好的
- all 2. unchecked 3. value={“unchecked”,“deprecation”}
1.3 自定义注解
-
使用 @interface 自定义注解,自动继承了 java.lang.annotation.Annotation 接口
-
@interface 用来声明一个注解,格式:public @interface 注解名 {内容}
其中的每一个方法实际上是声明了一个配置参数,方法的名称就是参数的名称,返回值类型就是参数的类型(返回值只能是基本类型,class,string,enum),可以通过 default 来声明参数的默认值,如果只有一个参数成员,一般参数名为 value,注解元素必须要有值,我们定义注解元素时,经常使用空字符串,0作为默认值
//自定义注解 public class Test03 { @MyAnnotation2(name = "李") @MyAnnotation3("张") public void test(){ } } @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation2{ //注解参数格式:参数类型 参数名() //default 有的话使用注解的使用可以不用带有参数 String name() default ""; } @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation3{ //如果注解中只有一个参数可以使用value //这样使用注解的使用不用加 value="" String value(); }
-
1.4 元注解
元注解作用就是负责注解其他注解,Java 定义了 4 个标准的 meta-annotation 类型,他们被用来提供对其他 annotation 类型作说明
这些类型和它们所支持的类在 java.lang.annotation 包中可以找到
- @Target:用于描述注解的使用范围,即被描述的注解可以用在什么地方
- @Retention:表示需要在什么级别保存该注解信息,用于描述注解的生命周期 (source < class < runtime)
- @Document:说明该注解被包含在 javadoc 中
- @Inherited:说明子类可以继承父类中的该注解
//元注解
public class Test02 {
@MyAnnotation
public void test(){
}
}
//定义一个注解
//Target 表示注解可以用在什么地方
@Target(value = ElementType.METHOD)
//Retention 表示注解在什么地方有效, RUNTIME 运行时有效
@Retention(value = RetentionPolicy.RUNTIME)
//@Documented 表示是否将我们的注解生成在 Javadoc 中
@Documented
//Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
}
2. 反射(Reflection)
了解:
**动态语言:**在运行时可以改变其结构的语言:如函数、对象、代码可以引进,已有的函数可以被删除或是其他结构上的变化,就是在运行时代码可以根据某些条件改变自身结构。 主要语言:C#、JS、php、py 等
**静态语言:**运行时结构不可变,主要语言:Java、C、C++
Java 不是动态语言,但 Java 可以称为 “准动态语言”。即 Java 有一定的动态性,可以利用反射机制获得类似动态语言的特性。Java 的动态性让编程的时候更加灵活
2.1 反射简介
反射是 Java 被视为动态语言的关键,反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息,并能直接操作任意对象的内部属性及方法
Class c = Class.forName("java.lang.String")
加载完类之后,在堆内存的方法区中就产生了一个 Class 类型的对象(一个类只有一个 Class 对象),这个对象就包含了完整的类的结构信息,我们可以通过这个对象看到类的结构。通过这个对象就可以清楚的看到类的结构,所以称之为:反射
反射机制提供的功能及优缺点
-
功能
在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时获取泛型信息;在运行时调用任意一个对象的成员变量和方法;在运行时处理注解;生成动态代理;
-
优点
可以实现动态创建对象和编译,体现出很大的灵活性
-
缺点
对性能有影响,使用反射基本上是一种解释操作,可以告诉 JVM 系统做什么并且它满足我们的要求,这类操作总是慢于直接执行相同的操作
2.2 获得反射对象
-
Class 类
在 Object 类中定义了以下方法,此方法被所有子类继承
public final Class getClass()
该方法的返回值类型是一个 Class 类,此类是 Java 反射的源头,实际上所谓反射从程序的运行结果来看也很好理解,即:可以通过对象反射求出类的名称
public class Test04 {
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取类的 Class 对象
//一个类在内存中只有一个 Class 对象,
// 一个类被加载后,类的整个结构都会被封装在 Class 对象中
Class c1 = Class.forName("demo01.User");
System.out.println(c1);
}
}
//实体类
class User{
private String name;
//省略 set/get 方法,toString 方法等
}
2.3 得到 Class 类方法
2.3.1 Class 类
对象照镜子后可以得到的信息:类的属性、方法和构造器、类到底实现了那些接口。对于每个类而言,JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包好了特定某个结构 (class/interface/enum/annotation/primitive type/void/[]) 的有关信息
- Class 本身也是一个类
- Class 对象只能由系统建立对象
- 一个加载的类在 JVM 中只会有一个 Class 实例
- 一个 Class 对象对应的是一个加载到 JVM 中的一个 .class 文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过 Class 可以完整地得到一个类中的所有被加载的结构
- Class 类是 Reflection 的根源,针对任何你想动态加载、运行的类,唯有先获得相应的 Class 对象
2.3.2 Class 类的常用方法
2.3.3 获取 Class 类的实例
-
若已知具体的类,通过类的 class 属性获取,该方法最为安全可靠,程序性能最高
Class user = User.class;
-
已知某个类的实例,调用该实例的 getClass() 方法获取 Class 对象
Class user1 = user.getClass();
-
已知一个类的全类名,且该类在类路径下,可通过 Class 类的静态方法 forName() 获取,可能抛出异常:ClassNotFoundException
Class user1 = Class.forName("demo01.User");
-
内置基本数据类型可以直接使用 类名.TYPE
Class c4 = Integer.TYPE;
//测试 Class 类的创建方法
public class Test05 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
//方式一:通过对象获得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
//方式二:forName 获得
Class c2 = Class.forName("demo01.Student");
System.out.println(c2.hashCode());
//方式三:通过类名.class 获得
Class c3 = Student.class;
System.out.println(c3.hashCode());
//方式四:基本内置类型的包装类都有一个 TYPE 属性
Class c4 = Integer.TYPE;
System.out.println(c4);
//获得父类类型
System.out.println(c1.getSuperclass());
}
}
class Person{
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person{
public Student(){
this.name = "学生";
}
}
class Teacher extends Person{
public Teacher() {
this.name = "老师";
}
}
2.4 不同类型的 class
//所有类型的 class
public class Test06 {
public static void main(String[] args) {
Class c1 = Object.class;//类
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);
//只要元素类型与维度一样,就是同一个 class
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}
运行结果:
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
void
class java.lang.Class
356573597
356573597
2.5 创建运行时类的对象
//获得类的信息
public class Test08 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("demo01.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.println(field);
}
//获取指定属性的值
Field name = c1.getDeclaredField("name");
System.out.println(name);
//获得类的方法
Method[] methods = c1.getMethods();//获得本类及其父类的全部 public 方法
for (Method method : methods) {
System.out.println(method);
}
methods = c1.getDeclaredMethods();//获得本类的所有方法
for (Method method : methods) {
System.out.println(method);
}
//获得指定方法
Method getName = c1.getMethod("getName",null);
Method setName = c1.getMethod("setName",String.class);
System.out.println(getName);
System.out.println(setName);
//获得指定的构造器
Constructor[] constructors = c1.getConstructors();//public
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
constructors = c1.getDeclaredConstructors();//全部
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
//获得指定的构造器
System.out.println(c1.getDeclaredConstructor(String.class));
}
}
2.6 动态创建对象执行
创建类的对象:调用 Class 对象的 newInstance() 方法
- 必须有一个无参数的构造器
- 类的构造器的访问权限需要足够
创建步骤:
- 通过 Class 类的 getDeclaredConstructor(Class … parameterTypes) 取得本类的指定形参类型的构造器
- 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数
- 通过 Constructor 实例化对象
调用指定方法
通过反射,调用类中的方法,通过 Method 类完成
-
通过 Class 类的 getMethod(String name,Class … parameterTypes) 方法取得一个 Method 对象,并设置此方法操作时所需要的参数类型
-
之后使用 Object invoke(Object obj, Object[] args) 进行调用,并向方法中传递要设置的 obj 对象的参数信息
Object invoke(Object obj, Object[] args) - Object 对应原方法的返回值,若原方法无法返回值,此时返回 null - 若原方法若为静态方法,此时形参 Object obj 可以为 null - 若原方法形参列表为空,则 Obejct[] args 为 null - 若原方法声明为 private,则需要在调用此 invoke() 方法前,显式调用方法对象的 setAccessible(true) 方法,将可访问 private 的方法 setAccessible: Method 和 Field、Constructor 对象都有 setAccessible() 方法 setAccessible 作用是启动和禁用访问安全检查的开关 参数值为 true 则表示反射的对象在使用时应该取消 Java 语言访问检查 提高反射的效率,如果代码中必须用反射,而该句代码需要频繁的被调用,那么请设置为 true 使得原本无法访问的私有成员也可以访问 参数值为 false 则表示反射的对象应该实施 Java 语言访问检查
//动态的创建对象,通过反射
public class Test09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//获得Class对象
Class c1 = Class.forName("demo01.User");
//构造一个对象
User user = (User) c1.newInstance();//调用了类的无参构造器
System.out.println(user);
//通过构造器创建对象
Constructor constructor = c1.getDeclaredConstructor(String.class);
User user1 = (User) constructor.newInstance("李");
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
name.setAccessible(true);
name.set(user3,"张三");
System.out.println(user3.getName());
}
}
2.7 反射操作泛型
Java 采用泛型擦除的机制来引入泛型,Java 中的泛型仅仅是给编译器 javac 使用的,确保数据的安全性和免去强制类型转换问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除
为了通过反射操作这些类型,Java 新增了 ParameterizedType,GenericArrayType,TypeVariable 和 WildcardType 几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
- ParameterizedType:表示一种参数化类型,比如 Collection
- GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable:是各种类型变量的公共父接口
- WildcardType:代表一种通配符类型表达式
//通过反射获取泛型
public class Test10 {
public void test01(Map<String, User> map, List<User> list) {
System.out.println("test01");
}
public Map<String, User> test02() {
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test10.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 = Test10.class.getMethod("test02");
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
2.8 通过反射操作注解
//通过反射操作注解
public class Test11 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("demo01.Students");
//通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得注解的 value 的值
TableCheck tableCheck = (TableCheck) c1.getAnnotation(TableCheck.class);
String value = tableCheck.value();
System.out.println(value);
//获得类指定的注解
Field name = c1.getDeclaredField("name");
FieldCheck annotation = name.getAnnotation(FieldCheck.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableCheck("db_Students")
class Students{
@FieldCheck(columnName = "db_id",type = "int",length = 10)
private int id;
@FieldCheck(columnName = "db_name",type = "varchar",length = 10)
private String name;
public Students() {
}
public Students(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Students{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableCheck{
String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldCheck{
String columnName();
String type();
int length();
}
运行结果:
@demo01.TableCheck(value=db_Students)
db_Students
db_name
varchar
10
3. 扩展 — 类加载器
3.1 类加载器作用
将 class 文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的 java.lang.Class 对象,作为方法区中类数据的访问入口。
**类缓存:**标准的 JavaSE 类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。不过 JVM 垃圾回收机制可以回收这些 Class 对象。
类加载器作用就是把类class 装载进内存的,JVM 规范定义了下面类型的类加载器
- 引导类加载器:用 C++ 编写的,是 JVM 自带的类加载器,负责 Java 平台核心库(rt.jar 包),用来装载核心类库,该加载器无法直接获取
- 扩展类加载器:负责 jre/lib/ext 目录下的 jar 包或 -D java.ext.dirs 指定目录下的 jar 包装入工作库
- 系统类加载器:负责 java -classpath 或 -D java.class.path 所指的目录下的类与 jar 包装入工作,是常用的加载器。
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++),获取不到为 null
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
//测试当前类是哪个加载器加载的
ClassLoader classLoader = Class.forName("demo01.Test07").getClassLoader();
System.out.println(classLoader);
//测试 JDK 内置的类是谁加载的
ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader1);
//获得系统类加载器可以加载的路径
String property = System.getProperty("java.class.path");
System.out.println(property);
}
}
学习参考视频 一起学习一起进步💪