狂神声明 : 文章均为自己的学习笔记 , 转载一定注明出处 ; 编辑不易 , 防君子不防小人~共勉 !
Java学习:注解,反射,动态编译
Annotation 注解
什么是注解 ?
- Annotation是从JDK5.0开始引入的新技术 .
-
Annotation的作用 :
- 不是程序本身 , 可以对程序作出解释.(这一点和注释没什么区别)
- 可以被其他程序(比如:编译器等)读取.(注解信息处理流程,是注解和注释的重大区别.如果没有注解信息处理流程,则注解毫无意义)
-
Annotation的格式 :
- 注解是以"@注释名"在代码中存在的 , 还可以添加一些参数值 , 例如:@SuppressWarnings(value="unchecked").
-
Annotation在哪里使用?
- 可以附加在package , class , method , field 等上面 , 相当于给他们添加了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问
内置注解
- @Override : 定义在 java.lang.Override 中 , 此注释只适用于修辞方法 , 表示一个方法声明打算重写超类中的另一个方法声明.
- @Deprecated : 定义在java.lang.Deprecated中 , 此注释可以用于修辞方法 , 属性 , 类 , 表示不鼓励程序员使用这样的元素 , 通常是因为它很危险或者存在更好的选择 .
- @SuppressWarnings : 定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息.
- 与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,我们选择性的使用就好了,参数如下 :
- @SuppressWarnings("unchecked")
- @SuppressWarnings(value={"unchecked","deprecation"})
元注解
- 元注解的作用就是负责注解其他注解 , Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明 .
- 这些类型和它们所支持的类在java.lang.annotation包中可以找到 .( @Target , @Retention , @Documented , @Inherited )
-
@Target : 用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
- @Target(value=ElementType.TYPE)
-
@Retention : 表示需要在什么级别保存该注释信息 , 用于描述注解的生命周期
自定义注解
- 使用 @interface自定义注解时 , 自动继承了java.lang.annotation.Annotation接口
package com.test.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(value={ElementType.METHOD,ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface Annotation01 { String studentName() default ""; int age() default 0; int id() default -1; //String indexOf("abc") -1 String[] schools() default {"清华大学","北京大学"}; }
- 要点 :
- @ interface用来声明一个注解
- 其中的每一个方法实际上是声明了一个配置参数.
- 方法的名称就是参数的名称
- 返回值类型就是参数的类型 ( 返回值只能是基本类型,Class , String , enum ).
- 可以通过default来声明参数的默认值
- 如果只有一个参数成员 , 一般参数名为value
- 注解元素必须要有值 , 我们定义注解元素时 , 经常使用空字符串,0作为默认值.
- 也经常使用负数(-1)表示不存在的含义
package com.test.annotation; /** * 测试自定义注解的使用 */ public class Demo02 { @Annotation01(age=22,studentName="狂神",id=10001,schools={"北京大学","清华大学"}) public void test(){} }
注解作业
- 实现一个小Demo利用反射读取注解的信息
- 什么是ORM ? -->对象Object 关系relationship 映射Mapping
- 类和表结构对应
- 属性和字段对应
- 对象和记录对应
-
@AnnoTable("tb_student") public class Student { @AnnoField(columnName = "id",type="int",length = 10) private int id; @AnnoField(columnName = "studentName",type="varchar",length = 10) private String studentName; @AnnoField(columnName = "age",type="int",length = 3) private int age; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getStudentName() { return studentName; } public void setStudentName(String studentName) { this.studentName = studentName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
import java.lang.annotation.Annotation; import java.lang.reflect.Field; //使用反射读取注解的信息,模拟处理注解信息的流程 public class ReadAnno { public static void main(String[] args) { try { Class c = Class.forName("Student"); //获得类的所有有效注解 Annotation[] annotations = c.getAnnotations(); for (Annotation a:annotations){ System.out.println(a); } //获得类的指定注解 AnnoTable at = (AnnoTable)c.getAnnotation(AnnoTable.class); System.out.println(at.value()); //获得类的属性的注解 Field f = c.getDeclaredField("studentName"); AnnoField af = f.getAnnotation(AnnoField.class); System.out.println(af); System.out.println( af.columnName()+"--"+ af.length()+"--"+ af.type() ); //根据获得的表名,字段的信息,拼出DDL语句,然后 //使用JDBC执行这个SQL,在数据库中生成相关的表 } catch (Exception e) { e.printStackTrace(); } } }
-
import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(value = {ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) public @interface AnnoField { String columnName(); String type(); int length(); }
import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface AnnoTable { String value(); }
反射机制 reflection
java的动态性
- 反射机制
- 动态编译
- 动态执行JavaScript 代码
- 动态字节码操作
动态语言
- 程序运行时 ,可以改变程序结构或变量类型 , 典型的语言 :
- Python , Ruby , JavaScript等...
- C , C++ , Java不是动态语言 , 但是Java具有一定的动态性 , 我们可以利用反射机制 , 字节码操作获得类似动态语言的特性 . Java的动态性让编程的时候更加灵活 !
反射机制
- 指的是可以于运行时加载 , 探知 , 使用编译期间完全未知的类 .
- 程序在运行状态中 , 可以动态加载一个只有名称的类 , 对于任意一个已加载的类 , 都能够知道这个类的所有属性和方法 , 对于任意一个对象 , 都能够调用它的任意一个方法和属性 ;
-
Class c = Class.forName("com.kuangstudy.User")
加载完类之后 , 在堆内存中 , 就产生了一个Class类型的对象(一个类只有一个Class对象) , 这个对象就包含了完整的类的结构信息 . 我们可以通过这个对象看到类的结构 , 这个对象就像一面镜子 , 透过这个镜子看到类的结构 , 所以我们形象的称之为 : 反射 .
Class类介绍
- java.lang.Class类十分特殊 , 用来表示 java 中类型 ( class / interface / enum / annotation / primitive type / void ) 本身
- Class类的对象包含了某个被加载类的结构 , 一个被加载的类对应一个Class对象 .
- 当一个class被加载 , 或当加载器( class loader ) 的defineClass() 被JVM调用 , JVM便自动产生一个Class对象 .
- Class类是Reflection(反射)的根源 .
- 针对任何您想动态加载 , 运行的类 . 唯有先获得相应的Class对象 ,
Class类的对象如何获取 ?
- 运用getClass()
- 运用Class.forName() -->最常被使用
- 运用.class 语法
//测试各种类型(class,interface,enum,annotation,primitive type,void)对应的java.lang.Class对象的获取方式 @SuppressWarnings("all") public class Demo01 { public static void main(String[] args) { String path = "com.test.bean.User"; try { Class clazz = Class.forName(path); //对象是表示或封装一些数据。 一个类被加载后,JVM会创建一个对应该类的Class对象,类的整个结构信息会放到对应的Class对象中。 //这个Class对象就像一面镜子一样,通过这面镜子我可以看到对应类的全部信息。 System.out.println(clazz.hashCode()); Class clazz2 = Class.forName(path); //一个类只对应一个Class对象 System.out.println(clazz2.hashCode()); Class strClazz = String.class; Class strClazz2 = path.getClass(); System.out.println(strClazz==strClazz2); Class intClazz =int.class; int[] arr01 = new int[10]; int[][] arr02 = new int[30][3]; int[] arr03 = new int[30]; double[] arr04 = new double[10]; System.out.println(arr01.getClass().hashCode()); System.out.println(arr02.getClass().hashCode()); System.out.println(arr03.getClass().hashCode()); System.out.println(arr04.getClass().hashCode()); } catch (Exception e) { e.printStackTrace(); } } }
反射机制的常见作用
- 动态加载类 , 动态获取类的信息(属性,方法,构造器)
- 动态构造对象
- 动态调用类和对象的任意方法 , 构造器
- 动态调用和处理属性
- 获取泛型信息
- 处理注解
import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 应用反射的API,获取类的信息(类的名字、属性、方法、构造器等) */ public class Demo01 { public static void main(String[] args) { String path = "com.test.bean.User"; try { Class clazz = Class.forName(path); //获取类的名字 System.out.println(clazz.getName());//获得包名+类名:com.bjsxt.test.bean.User System.out.println(clazz.getSimpleName()); //获的类名:User //获取属性信息 // Field[] fields = clazz.getFields(); //只能获得public的field Field[] fields = clazz.getDeclaredFields();//获得所有的field Field f = clazz.getDeclaredField("uname"); System.out.println(fields.length); for(Field temp:fields){ System.out.println("属性:"+temp); } //获取方法信息 Method[] methods = clazz.getDeclaredMethods(); Method m01 = clazz.getDeclaredMethod("getUname", null); //如果方法有参,则必须传递参数类型对应的class对象 Method m02 = clazz.getDeclaredMethod("setUname", String.class); for(Method m:methods){ System.out.println("方法:"+m); } //获得构造器信息 Constructor[] constructors = clazz.getDeclaredConstructors(); Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class); System.out.println("获得构造器:"+c); for(Constructor temp:constructors){ System.out.println("构造器:"+temp); } } catch (Exception e) { e.printStackTrace(); } } }
import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 通过反射API动态的操作:构造器、方法、属性 */ public class Demo01 { public static void main(String[] args) { String path = "com.test.bean.User"; try { Class<User> clazz = (Class<User>) Class.forName(path); //通过反射API调用构造方法,构造对象 User u = clazz.newInstance(); //其实是调用了User的无参构造方法 System.out.println(u); Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class); User u2 = c.newInstance(1001,18,"测试一"); System.out.println(u2.getUname()); //通过反射API调用普通方法 User u3 = clazz.newInstance(); Method method = clazz.getDeclaredMethod("setUname", String.class); method.invoke(u3, "测试三"); //u3.setUname("测试三"); System.out.println(u3.getUname()); //通过反射API操作属性 User u4 = clazz.newInstance(); Field f = clazz.getDeclaredField("uname"); f.setAccessible(true); //这个属性不需要做安全检查了,可以直接访问 f.set(u4, "测试四"); //通过反射直接写属性 System.out.println(u4.getUname()); //通过反射直接读属性的值 System.out.println(f.get(u4)); } catch (Exception e) { e.printStackTrace(); } } }
反射机制性能问题
- setAccessible
- 启用和禁用访问安全检查的开关 , 值为true 则指示反射的对象在使用时应该取消Java语言访问检查, 值为false 则指示反射的对象应该实施Java语言访问检查,并不是为true就能访问为false就不能访问
- 禁止安全检查 , 可以提高反射的运行速度
- 可以考虑使用 : cglib / javaassist字节码操作
反射操作泛型(Generic)
- Java采用泛型擦除的机制来引入泛型 , Java中的泛型仅仅是给编译器javac使用的 , 确保数据的安全性和免去强制类型转换的麻烦, 但是 , 一旦编译完成 , 所有的和泛型有关的类型全部擦除
- 为了通过反射操作这些类型以迎合实际开发的需求 , Java新增了ParameterizedType,GenericArrayType , TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.
- ParameterizedType:表示一种参数化的类型 , 比如Collection<String>
- GenericArrayType : 表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable : 是各种类型变量的公共父接口
- WildcardType: 代表一种通配符类型的表达式 , 比如 ?.? extends Number , ? super Integer
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 Demo01 { public void test01(Map<String,User> map,List<User> list){ System.out.println("Demo01.test01()"); } public Map<Integer,User> test02(){ System.out.println("Demo01.test02()"); return null; } public static void main(String[] args) { try { //获得指定方法参数泛型信息 Method m = Demo01.class.getMethod("test01", Map.class,List.class); Type[] t = m.getGenericParameterTypes(); for (Type paramType : t) { System.out.println("#"+paramType); if(paramType instanceof ParameterizedType){ Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments(); for (Type genericType : genericTypes) { System.out.println("泛型类型:"+genericType); } } } //获得指定方法返回值泛型信息 Method m2 = Demo01.class.getMethod("test02", null); Type returnType = m2.getGenericReturnType(); if(returnType instanceof ParameterizedType){ Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments(); for (Type genericType : genericTypes) { System.out.println("返回值,泛型类型:"+genericType); } } } catch (Exception e) { e.printStackTrace(); } } }
反射操作注解(annotation)
- 可以通过反射API : getAnnotations , getAnnotation获得相关的注解信息 .
import java.lang.annotation.Annotation; import java.lang.reflect.Field; /** * 通过反射获取注解信息 */ public class Demo01 { public static void main(String[] args) { try { Class clazz = Class.forName("com.test.annotation.Student"); //获得类的所有有效注解 Annotation[] annotations=clazz.getAnnotations(); for (Annotation a : annotations) { System.out.println(a); } //获得类的指定的注解 tTable st = (tTable) clazz.getAnnotation(tTable.class); System.out.println(st.value()); //获得类的属性的注解 Field f = clazz.getDeclaredField("studentName"); tField tField = f.getAnnotation(tField.class); System.out.println(tField.columnName()+"--"+tField.type()+"--"+tField.length()); //根据获得的表名、字段的信息,拼出DDL语句,然后,使用JDBC执行这个SQL,在数据库中生成相关的表 } catch (Exception e) { e.printStackTrace(); } } }
动态编译
- Java 6.0 引入了动态编译机制
- 动态编译的应用场景 :
- 可以做一个浏览器端编写java代码 , 上传服务器编译和运行的在线评测系统
- 服务器动态加载某些类文件进行编译
- 动态编译的两种做法 :
- 通过Runtime调用javac , 启动新的进程去操作
Runtime run = Runtime.getRuntime(); Process process = run.exec("javac -cp d:/java/ Hello.java");
- 通过JavaCompiler动态编译
-
- 第一个参数 : 为Java编译器提供参数(inputStream)
- 第二个参数 : 得到Java编译器的输出信息(outputStream)
- 第三个参数 : 接收编译器的错误信息(outputStream)
- 第四个参数 : 可变参数(是一个String数组)能传入一个或多个Java源文件
- 返回值 : 0表示编译成功 , 非0表示编译失败
import javax.tools.JavaCompiler; import javax.tools.ToolProvider; import java.lang.reflect.Method; import java.net.URLClassLoader; public class Demo01 { public static void main(String[] args) throws Exception { //通过IO流操作,将字符串存储成一个临时文件(Hi.java),然后调用动态编译方法! String str = "public class Hi {public static void main(String[] args){System.out.println(\"HaHa!\");}}"; JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); int result = compiler.run(null, null, null, "c:/myjava/HelloWorld.java"); System.out.println(result==0?"编译成功":"编译失败"); //通过Runtime调用执行类 // Runtime run = Runtime.getRuntime(); // Process process = run.exec("java -cp c:/myjava HelloWorld"); // // InputStream in = process.getInputStream(); // BufferedReader reader = new BufferedReader(new InputStreamReader(in)); // String info = ""; // while((info=reader.readLine())!=null){ // System.out.println(info); // } try { URL[] urls = new URL[] {new URL("file:/"+"C:/myjava/")}; URLClassLoader loader = new URLClassLoader(urls); Class c = loader.loadClass("HelloWorld"); //调用加载类的main方法 Method m = c.getMethod("main",String[].class); m.invoke(null, (Object)new String[]{}); //由于可变参数是JDK5.0之后才有。 //m.invoke(null, (Object)new String[]{});会编译成:m.invoke(null,"aa","bb"),就发生了参数个数不匹配的问题。 //因此,必须要加上(Object)转型,避免这个问题。 //public static void main(String[] args) } catch (Exception e) { e.printStackTrace(); } } }
- 通过Runtime调用javac , 启动新的进程去操作