注解和反射
注解
- Annotation从1.5开始引入
- Annotation作用
- 不是程序本分，可以对程序做出解释（跟comment没有区别）
- 可以被其他程序（编译器等）读取
- Annotation的格式
- 注解是以”@注释名“在代码中存在的，还可以添加一些参数值
- 例@SupperWarnings(value=“unchecked”)
- Annotation使用
- 可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问
元注解
-
元注解的作用就是负责注解其他注解，java定义了四个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明
-
这些类型和他们所支持的类在java.lang.annotation包中可以找到。(@Target , @Retention , @Documented , @Inherited)
- @Target：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
- @Retention：表示需要在什么级别保存该注解注释信息，用于描述注解的生命周期（source<class<runtime)
- @Document：说明该注解将被包含在javadoc中
- @Inherited：说明子类可以继承父类中的该注解
-
自定义注解：@interface 注解名{……}
-
import java.lang.annotation.*; public class test01 { public static void main(String[] args) { test("lala"); } @MyAnnotation public static void test(String name){ System.out.println(name); } } @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @interface MyAnnotation{ String value() default "GLeak"; }
反射
动态语言
- 是一类在运行时可以改变自身其结构的语言：例如新的函数、对象、甚至是代码可以被引进，已有函数可以被删除或者其自身结构上的变换。通俗讲就是在运行时代码可以根据某些条件改变自身结构
- 主要的动态语言：Object-C、C#、javaScript、PHP、Python等
静态语言
- 与动态语言相对应、运行时结构不可变的语言就是静态语言。如java、C、C++
- java不是动态语言，但JAVA可以成为准动态语言。java有一定的动态性，我们可以根据反射机制获得类似动态语言的特性。java的动态性让编程更加的灵活。
- 鱼和熊掌不能兼得！
反射
-
Reflection(反射)是java被视为动态语言的关键，反射机制允许程序在执行期间借助于反射API取得类的任何内部信息，并且能直接操作任意对象和内部属性及方法。
-
加载完类之后，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象。这个对象包含了完整的类的结构信息，我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这面镜子看到类的结构。所以我们形象的称之为：反射
-
正常方式：引入需要的”包类“ --> new 实例对象 --> 取得实例对象 -
反射方法：实例化对象 --> getClass() 方法 --> 得到完整的“包类”名 -
public class test02 { public static void main(String[] args) throws ClassNotFoundException { Student student = new Student(); Class c1 = student.getClass(); System.out.println(c1); Class c2 = Class.forName("annotation.Student"); System.out.println(c2); Class<Student> c3 = Student.class; System.out.println(c3); Class<Integer> c4 = Integer.TYPE; System.out.println(c4); } } class Person{ String name; public Person() { } public Person(String name) { this.name = name; } } class Student extends Person{ String name; public Student() { } public Student(String name) { this.name = name; } } -
拥有class对象的类型
import java.lang.annotation.ElementType; public class Test03 { 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; Class c9 = 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 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 } } -
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ySHN9j2-1637636325796)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20211103105916093.png)]
-
类的加载和产生
- 加载：将class文件字节码内容加载到内存中，并将这些类静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的Class对象
- 链接：将java类的二进制代码合并到JVM的运行状态之中的过程
- 验证：确保加载的类信息符合JVM规范，没有安全问题
- 准备：正式成为类变量（static）分配内存并设置类变量默认初始值得阶段，这些内存都将在方法区中进行分配
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
- 初始化：
- 执行类构造器()方法的过程，类构造去()是由编译器自动搜集类中所有类变量的赋值动作和静态代码块中的语句合并产生。（类构造器是构造类信息的，不是构造该类对象的构造器）
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步
-
什么时候会发生类的加载
- 类的主动引用
- 但虚拟机启动，先初始化main方法所在类
- new一个对类的象
- 调用类的静态成员（除final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，这会先初始化他的父类
- 类的被动引用
- 当访问一个静态域时，只有真正声明这个域的类时才会被初始化。如子类引用父类的静态产量，不会导致子类的初始化
- 通过数组定义引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就已经存入调用类的常量池中了
- 类的主动引用
-
类加载器的作用
-
类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。
-
类的缓存：标准的JAVASE类加载器可以按照要求查找类，但一旦某个类被加载到类加载器中，他将维持缓存一段时间，不过JVM的垃圾回收机制可以回收这些Class对象
-
public class Test04 { public static void main(String[] args) { //获取用户加载器 sun.misc.Launcher$AppClassLoader ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); System.out.println(systemClassLoader); //获取扩展加载器 sun.misc.Launcher$ExtClassLoader ClassLoader parent = systemClassLoader.getParent(); System.out.println(parent); //获取根加载器 C/C++编写，java代码无法获取 ClassLoader parent1 = parent.getParent(); System.out.println(parent1); System.out.println(System.getProperty("java.class.path")); //E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\charsets.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\deploy.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\access-bridge-64.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\cldrdata.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\dnsns.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\jaccess.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\jfxrt.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\localedata.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\nashorn.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\sunec.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\sunjce_provider.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\sunmscapi.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\sunpkcs11.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\ext\zipfs.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\javaws.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\jce.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\jfr.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\jfxswt.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\jsse.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\management-agent.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\plugin.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\resources.jar; // E:\java-2018-12\Java\jdk1.8.0_201\jre\lib\rt.jar; -->核心类库C/C++编写 // C:\Users\DELL\Desktop\JAVA\JavaSE\基础语法\lib\commons-io-2.6.jar; // C:\Users\DELL\Desktop\JAVA\JavaSE\out\production\基础语法; // D:\IDEA2020.1\IntelliJ IDEA 2020.1\lib\idea_rt.jar } }
-
获取类运行时信息
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class test05 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
// User user = new User();
// Class c1 = user.getClass();
// System.out.println(c1);
Class c = Class.forName("annotation.User");
System.out.println(c.getName());
System.out.println(c.getSimpleName());
System.out.println("==========================================================");
Field[] fields = c.getFields();
Field[] declaredFields = c.getDeclaredFields();
for (Field field :
fields) {
System.out.println(field);
}
System.out.println("==============================================================");
for (Field f :
declaredFields) {
System.out.println(f);
}
Field name = c.getDeclaredField("name");
System.out.println(name);
System.out.println("===================================================================");
Method[] methods = c.getMethods();
for (Method method :
methods) {
System.out.println(method);
}
System.out.println("==============================================================");
Method[] declaredMethods = c.getDeclaredMethods();
for (Method method :
declaredMethods) {
System.out.println(method);
}
System.out.println("==============================================================");
Method to = c.getMethod("to" , null);
System.out.println(to);
Method form = c.getMethod("form", int.class);
System.out.println(form);
System.out.println("==============================================================");
Constructor[] constructors = c.getConstructors();
for (Constructor ca :
constructors) {
System.out.println(ca);
}
System.out.println("==============================================================");
Constructor constructor = c.getDeclaredConstructor(String.class, Integer.class);
System.out.println(constructor);
System.out.println("==============================================================");
Constructor constructor1 = c.getConstructor(String.class, Integer.class);
System.out.println(constructor1);
}
}
class User {
private String name;
Integer id;
public User() {
}
public User(String name, Integer id) {
this.name = name;
this.id = id;
}
public void to() {
System.out.println(this.name + ":" + this.id);
}
private void in() {
System.out.println("lallalalla");
}
public int form(int a){
return a;
}
}
使用反射操作对象
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test06 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class c = Class.forName("annotation.Users");
System.out.println(c.getName());
System.out.println(c.getSimpleName());
System.out.println("==========================================================");
//构造一个对象
Users user = (Users) c.newInstance();
System.out.println(user);
//通过一个构造器创造一个对象
Constructor constructor = c.getDeclaredConstructor(String.class, Integer.class);
Users users = (Users) constructor.newInstance("小张", 18);
System.out.println(users.toString());
System.out.println("==========================================================");
//获取一个方法
Method form = c.getMethod("form", int.class);
//激活函数，激活form方法
int a = (int) form.invoke(user, 3);
System.out.println(a);
System.out.println("==========================================================");
Field name = c.getDeclaredField("name");
//关闭权限检测 not access a member of class annotation.Users with modifiers "private"
name.setAccessible(true);
name.set(user , "小张");
System.out.println(user.toString());
}
}
class Users {
private String name;
Integer id;
public Users() {
}
public Users(String name, Integer id) {
this.name = name;
this.id = id;
}
public void to() {
System.out.println(this.name + ":" + this.id);
}
private void in() {
System.out.println("lallalalla");
}
public int form(int a){
return a;
}
@Override
public String toString() {
return "Users{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
}
性能分析
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test07 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Userss userss = new Userss("小张" ,124);
long starttime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
userss.getName();
}
long endtime = System.currentTimeMillis();
System.out.println("new代码执行了"+ (endtime - starttime) + "ms");
Class c = Class.forName("annotation.Userss");
Constructor constructor = c.getDeclaredConstructor(String.class, Integer.class);
Userss userd = (Userss) constructor.newInstance("小王", 111);
Method getName = c.getMethod("getName", null);
getName.setAccessible(true);
long starttimes = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(userd);
}
long endtimes = System.currentTimeMillis();
System.out.println("反射代码执行了"+ (endtimes - starttimes) + "ms");
// new代码执行了3ms
// 反射代码执行了1502ms
// 关闭权限反射代码执行了685ms
}
}
class Userss {
private String name;
Integer id;
public Userss() {
}
public Userss(String name, Integer id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
反射操作泛型
-
JAVA采用泛型擦除机制来引入泛型，JAVA中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题。但是一旦编译完成，所有和泛型有关的类型全部擦除
-
为了通过反射操作这些泛型，java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但又和原始类型齐名的类型
-
ParameterizedType：表示一种参数化类型，如Collection
-
GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
-
TypeVariable：是各种类型变量的公共接口
-
WildcardType：代表一种通配符类型表达式
import java.lang.reflect.InvocationTargetException; 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 Test07 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Method test01 = Userss.class.getMethod("test01", Map.class, List.class); //获得参数通用类型 Type[] genericParameterTypes = test01.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); } } } System.out.println("=========================================================="); Method test02 = Userss.class.getMethod("test02", null); //获得返回值通用类型 Type genericParameterTypes1 = test02.getGenericReturnType(); if (genericParameterTypes1 instanceof ParameterizedType){ Type[] actualTypeArguments = ((ParameterizedType) genericParameterTypes1).getActualTypeArguments(); for (Type actualTypeArgument : actualTypeArguments) { System.out.println(actualTypeArgument); } } } } class Userss { public void test01(Map<String , User> map , List<String> list){ System.out.println("test01程序测试"); } public Map<String ,Integer> test02(){ System.out.println("rest02程序测试"); return null; } }
获取注解信息
ORM
-
Object Relationship Mapping -->对象关系映射
-
类和表结构对应
-
属性和字段对应
-
对象和记录对应
-
利用注解完成类和表结构的映射关系
//利用反射获取注解信息，找到关系映射 import java.lang.annotation.*; import java.lang.reflect.Field; public class Test08 { public static void main(String[] args) throws ClassNotFoundException { Class c = Class.forName("annotation.Teacher"); Annotation[] tableGleak = c.getAnnotations(); for (Annotation annotation : tableGleak) { System.out.println(annotation); } TableGleak annotation = (TableGleak) c.getAnnotation(TableGleak.class); System.out.println(annotation.value()); Field[] fields = c.getDeclaredFields(); for (Field field : fields) { System.out.println(field); FieldGleak fieldGleak = field.getAnnotation(FieldGleak.class); System.out.println(fieldGleak.columnName()); System.out.println(fieldGleak.type()); System.out.println(fieldGleak.length()); } } } @TableGleak("db_teacher") class Teacher{ @FieldGleak(columnName = "db_id",type = "INT",length = 8) private int id; @FieldGleak(columnName = "db_name",type = "VARCHAR",length = 20) private String name; public Teacher() { } public Teacher(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; } } @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @interface TableGleak{ String value(); } @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @interface FieldGleak{ String columnName(); String type(); int length(); } @annotation.TableGleak(value=db_teacher) db_teacher private int annotation.Teacher.id db_id INT 8 private java.lang.String annotation.Teacher.name db_name VARCHAR 20
134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
