注解和反射(Annotation)
什么是注解
-
Annotation 是从 JDK 5.0开始引入的新的技术
-
Annotation的作用:
- 不是程序本身,可以对程序作出解释,(这一点和注释(comment)没什么区别)
- 可以被其他程序(比如:编译器等)读取
-
Annotation的格式:
- 注解是以"@注释名"在代码中存在的的,还可以添加一些参数值,例如:@SuppressWarnings(value=“unchecked”)
-
Annotation在哪里使用?
- 可以附加在package,class,method,field等上面,相当于给他们添加了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问
-
public class Test01 extends Object{ @Override public String toString() { return super.toString(); } }
内置注解
- @Override:定义在java.lang.Override中,此注释只适用于修辞手法,表明一个方法声明打算重写超类中的另一个方法声明
- 注释@Deprecated的程序元素是程序员不鼓励使用的程序元素，通常是因为它是危险的，或者因为存在更好的替代方法。 编译器在不被弃用的代码中使用或覆盖不推荐使用的程序元素时发出警告。
- @SuppressWarnings表示在注释元素（以及注释元素中包含的所有程序元素）中应该抑制命名的编译器警告。请注意，给定元素中抑制的一组警告是所有包含元素中抑制的警告的超集。例如，如果您注释一个类来抑制一个警告并注释方法来抑制另一个警告，则两个警告将在该方法中被抑制。作为一种风格，程序员应该始终将这个注释用于最有效的嵌套元素。 如果要在特定方法中抑制警告，则应该注释该方法而不是其类。
元注解
-
//测试元注解 public class Test02 { @MyAnnotation public void test(){ } } //定义一个注解 //Target 表示我们的注解可以用在那个地方 @Target(value = {ElementType.METHOD,ElementType.TYPE}) //Retention 表示我们的注解在什么地方还有效 //runtime>class>sources @Retention(value = RetentionPolicy.CLASS.RUNTIME) //Documented 表示是否将我们的注解生成在JAVAdoc中 @Documented // Inherited 子类可以继承父类的注解 @Inherited @interface MyAnnotation{ }
自定义注解
-
使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口
-
//自定义注解 public class Test03 { // 注解可以显示赋值,如果没有默认值,我们就必须给注解赋值 @MyAnnotation2(name = "张三",schools = {"清华大学"}) public void test(){ } @MyAnnotation3("张三") public void test2(){ } } @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation2{ // 注解的参数:参数类型+参数名(); String name() default ""; int age() default 0; int id() default -1; //如果默认值为-1,代表不存在,indexof,如果找不到就返回-1 String[] schools() default {"北京大学","大同大学"}; } @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation3{ String value(); }
什么是反射
-
反射被认为是Java动态语言的关键，反射机制允许程序在执行期借助于Reflection API获取任何类的内部信息，并能直接操作任意对象的内部属性或方法（包括private修饰的字段）
-
Class c = Class.forName(“java.lang.String”)
-
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了完整的类的结构信息。我们可以通过对象看到类的结构。这个对象就像一面镜子，通过这个镜子看到类的结构。所以称之为反射。
静态语言与动态语言
-
动态语言:
- 一类在运行时可以改变其结构的语言，例如新的函数、对象、已有的函数被删除或是其他结构上的变化。主要动态语言：Object-C、C#、JavaScript、PHP、Python等
-
静态语言
- 运行时结构不可变，如Java、C、C++。Java不是动态语言，但Java可以成为“准动态语言”。即Java有一定的动态性，我们可以利用反射来获得类似动态语言的特性。Java的动态性让编程更加灵活。
反射机制提供的功能
运行时判断任意一个对象所属的类
运行时构造任意一个类的对象
运行时判断任意一个类所具有的成员变量和方法
运行时获取泛型信息
运行时调用任意一个对象的成员变量或方法
运行时处理注解
生成动态代理
优缺点
优点：动态创建对象和编译，灵活性高
缺点：对性能有影响。反射是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
反射相关API
java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Construtor：代表类的构造器
-
//什么是反射 public class Test02 extends Object{ public static void main(String[] args) throws ClassNotFoundException { // 通过反射获取类的class 对象 Class c1 = Class.forName("com.Annotation.reflection.User"); System.out.println(c1); Class c2 = Class.forName("com.Annotation.reflection.User"); Class c3 = Class.forName("com.Annotation.reflection.User"); Class c4 = Class.forName("com.Annotation.reflection.User"); // 一个类在内存中只有一个class对象 // 一个类被加载后,类的整个结构都会被封装在class对象中 System.out.println(c2.hashCode()); System.out.println(c3.hashCode()); System.out.println(c4.hashCode()); } } //实体类:pojo entity class User{ private String name; private int id; private int age; public User() { } public User(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 "User{" + "name='" + name + '\'' + ", id=" + id + ", age=" + age + '}'; } }
Class类
-
对象照镜子后反射可以得到的信息：类的属性、方法、构造器、类实现了哪些接口。对于每个类而言，JRE都会为其保留一个不变的Class类型的对象。
-
Class本身也是一个类
-
Class对象只能有系统创建（文明只能通过反射去获得）
-
一个加载的类在JVM中只会有一个Class实例
-
一个Class对象对应的是一个加载到JVM中的一个.class文件
-
每个类的实例都会记得自己是由哪个Class实例所生成的
-
通过Class可以完整的得到一个勒种的所有被加载的结构
-
Class类是Reflection的根源，任何想要动态加载、运行的类，唯有先获得相应的Class对象
得到Class类的几种方式
前提：知道具体的类 该方法最安全可靠、程序性能高
Class clazz = Person.class
前提：已知类的实例
Class clazz = person.getClass() 这是Object类中定义的方法
前提：已知类的全类名，且该类在类路径下
Class c = Class.forName(“java.lang.String”)
//测试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("com.Annotation.reflection.Student");
System.out.println(c2.hashCode());
// 方式三:通过类名.class获得
Class c3 = Student.class;
System.out.println(c3.hashCode());
// 方式四:基本内置类型的包装类都有一个Type属性
Class<Integer> 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() {
}
@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对象
-
class(外部类、局部内部类、匿名内部类等)、interface、数组、enum（枚举）、注解、基本数据类型、void
-
//所有类型的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); int[] a = new int[10]; int[] b = new int[100]; // 只要元素类型与维度一样,就是同一个Class System.out.println(a.getClass().hashCode()); System.out.println(b.getClass().hashCode()); } }
类加载内存分析
-
public class Test05 { public static void main(String[] args) { A a = new A(); System.out.println(A.m); } } class A{ static { System.out.println("A类静态代码块初始化"); m = 300; } static int m = 100; public A(){ System.out.println("A类的无参构造初始化"); } }
什么时候会发生类初始化
- 类的主动引用(一定会发生类的初始化))
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员(除了final常量)和静态方法
- 使用java.lang.reflect包的方法对类进行反 射调用
- 当初始化一个类, 如果其父类没有被初始化，则先会初始化它的父类
- 类的被动引用(不会发生类的初始化)
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)
-
//测试类什么时候会初始化 public class Test06 { static { System.out.println("Main被加载"); } public static void main(String[] args) throws ClassNotFoundException{ // 主动引用 // Son son = new Son(); // 反射也会产生主动引用 // Class.forName("com.Annotation.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; }
类加载器
- 类加载的作用:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang(Class对象)作为方法区中类数据的访问入口。
- 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某企类被加载到类加载器中，它将维持加载(缓存) 一段时间。不过JVM垃圾回收机制可以回收这些Class对象
-
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.Annotation.reflection.Test07").getClassLoader(); System.out.println(classLoader); // 测试JDK内部的类是谁加载的 Class.forName("java.lang.Object").getClassLoader(); System.out.println(classLoader); // 如何获得系统类加载器可以加载的路径 System.out.println(System.getProperty("java.class.path")); /* D:\winarchser\jdk\jre\lib\charsets.jar; D:\winarchser\jdk\jre\lib\deploy.jar; D:\winarchser\jdk\jre\lib\ext\access-bridge-64.jar; D:\winarchser\jdk\jre\lib\ext\cldrdata.jar; D:\winarchser\jdk\jre\lib\ext\dnsns.jar; D:\winarchser\jdk\jre\lib\ext\jaccess.jar; D:\winarchser\jdk\jre\lib\ext\jfxrt.jar; D:\winarchser\jdk\jre\lib\ext\localedata.jar; D:\winarchser\jdk\jre\lib\ext\nashorn.jar; D:\winarchser\jdk\jre\lib\ext\sunec.jar; D:\winarchser\jdk\jre\lib\ext\sunjce_provider.jar; D:\winarchser\jdk\jre\lib\ext\sunmscapi.jar; D:\winarchser\jdk\jre\lib\ext\sunpkcs11.jar; D:\winarchser\jdk\jre\lib\ext\zipfs.jar; D:\winarchser\jdk\jre\lib\javaws.jar; D:\winarchser\jdk\jre\lib\jce.jar; D:\winarchser\jdk\jre\lib\jfr.jar; D:\winarchser\jdk\jre\lib\jfxswt.jar; D:\winarchser\jdk\jre\lib\jsse.jar; D:\winarchser\jdk\jre\lib\management-agent.jar; D:\winarchser\jdk\jre\lib\plugin.jar; D:\winarchser\jdk\jre\lib\resources.jar; D:\winarchser\jdk\jre\lib\rt.jar; D:\BianCheng\javaSE\基础语法\out\production\基础语法; D:\BianCheng\javaSE\基础语法\src\lib\commons-io-2.11.0.jar; C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.2\lib\idea_rt.jar */ // 双亲委派机制 // java.lang.string-->
获取类的运行时结构
通过反射获取运行时类的完整结构Field、Method, Constructor、 Superclass、 Interface、 Annotation
-
实现的全部接口
-
所继承的父类
-
全部的构造器
-
全部的方法
-
全部的Field
-
注解
-
//获得类的信息 public class Test08 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException { Class c1 = Class.forName("com.Annotation.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); } // 获得指定属性的值 Field name = null; try { name = c1.getDeclaredField("name"); } catch (NoSuchFieldException e) { e.printStackTrace(); } System.out.println(name); // 获得类的方法 System.out.println("--------------------------------"); Method[] methods = c1.getMethods(); //获得奔雷及其父类的全部public方法 for (Method method : methods) { System.out.println("正常的:"+method); } methods = c1.getDeclaredMethods();//获得本类的所有方法 for (Method method : methods) { System.out.println("getDeclaredMethods"+method); } // 获得指定方法 Method getNames = null; getNames = c1.getMethod("getName", null); Method setNames = c1.getMethod("setName",String.class); System.out.println(getNames); // 获得指定的构造器 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 declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class); System.out.println("指定:"+ declaredConstructor); } }
动态创建对象执行方法
-
在实际操作中,取得类的信息的操作代码,并不会经常开发
-
一定要熟悉java.lang.reflect包的作用,反射机制
-
如何取得属性,方法,结构的名称,修饰符等
-
创建类的对象:调用Class对象的newInstance()方法
➢1) 类必须有一个无参数的构造器➢2)类的构造器的访问权限需要足够!
思考?难道没有无参的构造器就不能创建对象了吗?只要在操作的时候明确的调用类中的构造器,并将参数传递进去之后，才可以实例化操作。
步骤如下:-
通过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 对应原方法的返回值，若原方法无返回值，此时返回nul)
➢若原方法若为静态方法，此时形参0bject obj可为null
➢若原方法形参列表为空，则Object[] args为null
➢若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
setAccesslible
➢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("com.Annotation.reflection.User"); // 构造一个对象 // User user = (User) c1.newInstance();//本质上是调用了类的无参构造器 // System.out.println(user); // 通过构造器创建对象 Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class); User user2 = (User) constructor.newInstance("世杰", 001, 20); System.out.println(user2); // 通过反射调用普通方法 User user3 = (User) c1.newInstance(); // 通过反射获取一个方法 Method setName = c1.getDeclaredMethod("setName", String.class); // invoke:激活的意思 // (对象,"方法的值") setName.invoke(user3,"世杰"); System.out.println(user3.getName()); // 通过反射获得属性 User user4 = (User) c1.newInstance(); Field name = c1.getDeclaredField("name"); name.setAccessible(true);//不能直接操作私有属性,我们需要关闭程序的安全检测,属性或者方法的setAccessible(true); name.set(user4,"世杰2"); System.out.println(user4.getName()); } }
性能对比分析
-
//分析性能问题 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("普通方式执行十亿次需要:"+(endTime-startTime)+"ms"); } // 反射方式调用 public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class 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("反射方式执行十亿次需要:"+(endTime-startTime)+"ms"); } // 反射方式调用,关闭检测 public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class 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("关闭检测执行十亿次需要:"+(endTime-startTime)+"ms"); } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { test01(); test02(); test03(); } }
获取泛型信息
➢Java采用泛型擦除的机制来引入泛型, Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题, 但是, 一旦编译完成,所有和泛型有关的类型全部擦除
➢为了通过反射操作这些类型, Java新增了ParameterizedType , GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.
➢ParameterizedType :表示一种参 数化类型,比如Collection
➢GenericArrayType :表示一-种元素类型是参数化类型或者类型变量的数组类型➢TypeVariable :是各种类型变量的公共父接口
➢WildcardType :代表一种通配符类型表达式
-
//通过反射获取泛型 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); } } } }
获取注解信息
-
//练习反射操作注解 public class Test12 { public static void main(String[] args) throws Exception{ Class c1 = Class.forName("com.Annotation.reflection.Student2"); // 通过反射获得注解 Annotation[] annotations = c1.getAnnotations(); for (Annotation annotation : annotations) { System.out.println(annotation); } // 获得注解value的值 TableZhang TableZhang = (TableZhang)c1.getAnnotation(TableZhang.class); String value = TableZhang.value(); System.out.println(value); // 获得类指定的注解 Field f = c1.getDeclaredField("id"); FiledZhang annotation = f.getAnnotation(FiledZhang.class); System.out.println(annotation.columnName()); System.out.println(annotation.type()); System.out.println(annotation.length()); } } @TableZhang("db_student") class Student2{ @FiledZhang(columnName = "db_id",type = "int",length = 10) private int id; @FiledZhang(columnName = "db_age",type = "int",length = 10) private int age; @FiledZhang(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 TableZhang{ String value(); } //属性的注解 @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @interface FiledZhang{ String columnName(); String type(); int length(); }
334
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
