Java学习：注解,反射,动态编译

时间  2019-12-11
标签 java 学习 注解 反射 动态 编译 栏目 Java 繁體版
原文   原文链接

狂神声明 : 文章均为本身的学习笔记 , 转载必定注明出处 ; 编辑不易 , 防君子不防小人~共勉 ! java

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();
        }
    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程