注解和反射
注解
内置注解:
@Deprecated 表示不鼓励使用该元素
@SuppressWarnings 抑制编译时的警告信息 需要参数
元注解:
负责解释其他注解的注解,java定义了四个标准的meta-annotation类型
@Target : 用于描述注解的使用范围
@Retention:表示需要在什么级别保存该注释信息,用于描述注解的生命周期(
SOURCE(源码 < CLASS(类上 < RUNTIME(运行时
@Document:说明该注解被包含在Javadoc中
@Inherited:说明子类可以继承父类中的该注解
package annotation; import java.lang.annotation.*; //测试元注解 @MyAnnotation public class Test02 { @MyAnnotation public void test(){ } } //定义一个注解 //@Target : 用于描述注解的使用范围 // //@Retention:表示需要在什么级别保存该注释信息,用于描述注解的生命周期( // // SOURCE(源码 < CLASS(类上 < RUNTIME(运行时 // //@Document:说明该注解被包含在Javadoc中 // //@Inherited:说明子类可以继承父类中的该注解 //ElementType.METHOD 可以在方法上使用 //ElementType.TYPE 可以在类上使用 @Target(value = {ElementType.METHOD,ElementType.TYPE}) @Retention(value = RetentionPolicy.RUNTIME) @Documented @Inherited @interface MyAnnotation{ }
自定义注解:
package annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; //自定义注解 public class Test03 { //有默认值的可以不赋值,没有默认值的必须赋值 @MyAnnotation2(name = "song") public void test(){ } @MyAnnotation3("1") public void test2(){ } } @Target(value = {ElementType.TYPE,ElementType.METHOD}) @Retention(value = RetentionPolicy.RUNTIME) @interface MyAnnotation2{ //注解的参数: 参数类型 + 参数名() String name() default "";//default 默认为: int age() default 0; int id() default -1;//默认值为-1,代表不存在 } @Target(value = {ElementType.TYPE,ElementType.METHOD}) @Retention(value = RetentionPolicy.RUNTIME) @interface MyAnnotation3{ //如果只有一个值,建议使用value命名 因为可以省略 只有Value可以 String value(); }
反射 Reflection
Reflection是java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API 取得任何类的内部信息,并能直接操作任意对象的内部属性及方法
Class c = Class.forName("java.lang.String")
加载完一个类后,在堆内存的方法区中就产生一个Class类型的对象(一个类只有一个Class对象) 这个对象就包含了完整的类的结构信息,我们可以通过这个对象看见类的结构。
对象就好像镜子。
测试Class类的创建方式
package reflection; //测试Class类的创建方式有哪些 public class Test03 { public static void main(String[] args) throws ClassNotFoundException { Person person = new Student(); System.out.println("这个人是:"+person.name); //方式一 通过对象获得 Class c1 = person.getClass(); System.out.println(c1.hashCode()); //方式二 forname获得 Class c2= Class.forName("reflection.Student"); System.out.println(c2.hashCode()); //方式三 通过类名获得 Class c3 = Student.class; System.out.println(c3.hashCode()); //方式四: 基本内置类型的包装类都有一个Type属性 Class c4 = Integer.TYPE; System.out.println(c4); //获得父类的类型 Class c5 = c1.getSuperclass(); System.out.println(c5); } } class Person{ public String name; public Person(String name) { this.name = name; } public Person() { } public String getName() { return name; } public void setName(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 = "老师"; } }
所有类型的Class
package reflection; import java.lang.annotation.ElementType; //所有类型的Class public class Test04 { 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()); } }
java内存分析
堆:存放new的对象和数组
可以被所有的线程共享,不会存放别的对象引用
栈:存放基本变量类型(会包含这个基本类型的具体数值
引用对象的变量(会存放这个引用在堆里面的具体地址
方法区:可以被所有的线程共享
包含了所有的class和static变量
声明数组A时,在栈中创建A
创建数组A[10],在堆中创建一个A空间
数组赋值,把值存入堆的A空间中
类的加载--->类的链接---->类的初始化
package 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; } 最后合并m = 100; */ } class A{ static { System.out.println("A类静态代码块初始化"); m=300; } static int m = 100; public A(){ System.out.println("A类的无参构造初始化"); } }
什么时候会发送类初始化
-
类的主动引用(一定会发送类的初始化
-
虚拟机启动初始化main方法所在的类
-
new一个类的对象
-
调用类的静态成员(除了final常量)和静态方法
-
进行反射调用
-
当一个类初始化,其父类没有被初始化,则先初始化他的父类
-
-
类的被动引用不会发生类的初始化
-
当访问一个静态域时,只有真正声明这个域的类才会被初始化,如:通过子类引用父类的静态变量,不会导致子类初始化
-
通过数组定义类引用
-
引用常量不会触发(常量在链接阶段就存入调用类的常量池中了)
-
什么时候类被加载:
package reflection; //测试类什么时候会初始化 public class Test06 { static { System.out.println("main类被加载"); } public static void main(String[] args) throws ClassNotFoundException { //1主动引用 // Son son = new Son(); //反射也会产生主动引用 // Class.forName("reflection.Son"); //不会产生类的引用的方法 // System.out.println(Son.b); // Son[] array = new Son[5]; 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; }
类加载器·
-
引导类加载器
-
JVM自带加载器,负责java平台核心库,用来装载核心类库,该加载器无法直接获取
-
-
扩展类加载器
-
负责jre/lib/ext 目录下的jar包或—D java.ext.dirs 指定目录下的jar包装入工作库
-
-
系统类加载器
-
负责java - classpath 或-D java.class.path所指的目录下的类于jar包装入工作,是最常用的加载器
-
rt.jar 包里面就是java的内容
package 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("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")); /* 双亲委派机制 保证安全性 如果你重新写了一个包和java自己带的核心jar包名字一样 会使用原来的jar包 保证安全性 */ /*路径: C:\Program Files\Java\jdk1.8.0_291\jre\lib\charsets.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\deploy.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\access-bridge-64.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\cldrdata.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\dnsns.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jaccess.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jfxrt.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\localedata.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\nashorn.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunec.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunjce_provider.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunmscapi.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunpkcs11.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\zipfs.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\javaws.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\jce.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\jfr.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\jfxswt.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\jsse.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\management-agent.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\plugin.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\resources.jar; C:\Program Files\Java\jdk1.8.0_291\jre\lib\rt.jar; E:\idealearn\javase\out\production\javaselearn; E:\idealearn\javase\javaselearn\src\lib\commons-io-2.6.jar; C:\Program Files\JetBrains\IntelliJ IDEA 2021.2\lib\idea_rt.jar */ } }
获取运行时完整类的信息
package reflection; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; //动态的创建对象 通过反射 public class Test09 { public static void main(String[] args) throws Exception{ //获得Class对象 Class c1 = Class.forName("reflection.User"); //构造一个对象 // User user = (User) c1.newInstance();//本质上调用类的无参构造器 // System.out.println(user); //通过构造器创建对象 // Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class); // User song = (User) declaredConstructor.newInstance("song", 001, 18); // System.out.println(song); //通过反射调用普通方法 User user3 = (User) c1.newInstance(); //通过反射获取一个方法 Method setName = c1.getDeclaredMethod("setName", String.class); //invoke 激活的意思 //(对象,“方法的值”) setName.invoke(user3,"song"); System.out.println(user3.getName()); //通过反射操作属性 User user4 = (User) c1.newInstance(); Field name = c1.getDeclaredField("name"); //不能直接操作私有属性,我们需要关闭程序的安全检测 name.setAccessible(true);//取消安全监测 name.set(user4,"song"); System.out.println(user4.getName()); } }
分析性能问题
如果多用反射,可以把安全检测关闭,可以提高执行速度
package 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 < 1000000; i++) { user.getName(); } long endTime = System.currentTimeMillis(); System.out.println("普通方法执行1千万次时间:"+(endTime-startTime)+"ms"); } //通过反射方式调用 public static 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 < 1000000; i++) { getName.invoke(user,null); } long endTime = System.currentTimeMillis(); System.out.println("反射方式调用方法执行1千万次时间:"+(endTime-startTime)+"ms"); } //通过反射方式调用 关闭安全监测 public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class c1 = user.getClass(); Method getName = c1.getMethod("getName", null); getName.setAccessible(true); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1000000; i++) { getName.invoke(user,null); } long endTime = System.currentTimeMillis(); System.out.println("反射方式调用 关闭安全监测方法执行1千万次时间:"+(endTime-startTime)+"ms"); } public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException { test01(); test02(); test03(); } }
反射操作泛型
package 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 = Test11.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:对象关系映射
package 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("reflection.Student2"); //通过反射获得注解 Annotation[] annotations = c1.getAnnotations(); for (Annotation annotation : annotations) { System.out.println(annotation); } //获得注解value的值 TableSong tableSong = c1.getAnnotation(TableSong.class); String value = tableSong.value(); System.out.println(value); //获得类指定的注解 Field f = c1.getDeclaredField("name"); FieldSong annotation = f.getAnnotation(FieldSong.class); System.out.println(annotation.columnName()); System.out.println(annotation.type()); System.out.println(annotation.length()); } } @TableSong("db_student") class Student2{ @FieldSong(columnName = "db_id",type = "int",length = 10) private int id; @FieldSong(columnName = "db_age",type = "int",length = 10) private int age; @FieldSong(columnName = "db_name",type = "varchar",length = 3) public String name; public Student2(int id, int age, String name) { this.id = id; this.age = age; this.name = name; } public Student2() { } 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(value = {ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface TableSong{ String value(); } //属性的注解 @Target(value = {ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @interface FieldSong{ String columnName(); String type(); int length(); }
总结
@interface 用于自定义注解
反射相关的主要API:
java.lang.Class 代表一个类
java.lang.reflect.Method 代表类的方法
java.lang.reflect.Field 代表类的成员变量
java.lang.reflect.Constructor 代表类的构造器