当前位置：移动技术网 > IT编程>开发语言>Java > Java学习：注解,反射,动态编译

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

2019年01月27日 | 移动技术网IT编程 | 我要评论

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

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

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();
        }
    }
}

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

Java 实现简易教务管理系统的代码

main.javaimport java.util.scanner; public class main { public static void main(s... [阅读全文]
解决IDEA中Maven依赖包导入失败报红问题(总结最有效8种解决方案)

问题描述:真的,说来话长,这应该是我花最多时间去解决关于maven依赖包导入的问题,以前粘贴复制导入,自动下载成功了, 这次怎么搞,怎么让他自动下载都还是红红的... [阅读全文]
Java执行cmd命令两种实现方法解析

一般java在执行cmd命令时，通常是使用runtime.getruntime.exec(command)来执行的，这个方法有两种细节要注意：1.一般执行方法，... [阅读全文]
IntelliJ IDEA配置java环境及解决IDEA不能直接运行单个JAVA文件的问题

写java代码选择ieda的原因是我之前用的pycharm写python，而ieda和pycharm几乎一模一样的用法，而且iede可以写java，python... [阅读全文]
IDEA中创建maven项目引入相关依赖无法下载jar问题及解决方案

先如今idea中的spring项目，springboot的项目的开发一般都是基于maven创建的项目。这大大简化我我们对于各种依赖包的管理，同时又使得各种依赖包... [阅读全文]
Java实现UDP互发消息

本文实例为大家分享了java实现udp互发消息的具体代码，供大家参考，具体内容如下udp的发送端package udp;/**udp发送端*/import ja... [阅读全文]
Java实现TCP互发消息

本文实例为大家分享了java实现tcp互发消息的具体代码，供大家参考，具体内容如下tcp客户端：package tcp;import java.io.ioexc... [阅读全文]
如何基于java实现解压ZIP TAR等文件

java实现对常用.zip ， .tar， .tar.bz2， .bz2 ，.tar.gz ，.gz格式文件的解压。　　首先需要引入maven依赖，这里使用的是... [阅读全文]
java利用udp实现发送数据

本文实例为大家分享了java利用udp实现发送数据的具体代码，供大家参考，具体内容如下1.udp的特点数据以包的形式发送数据 udp是面向无连接的 ud... [阅读全文]
甜品消消乐 07 随机颜色的生成

可以通过当前游戏物体是否挂载有每一个脚本来判断游戏物体是否拥有此功能GameSweet.cs //获取甜品... [阅读全文]