注解和反射
注解和反射
注解（annotation）
基本情况
- 作用
- 不是程序本身，可以对程序作出解释（这一点和注释(comment)没有什么区别）
- 可以被其他程序(比如：编译器)读取
- 格式
- 注解是以“@注解名”在代码中存在，还可以添加一些参数值
- @SuppressWarnings(value="unchecked")
- 使用位置
- 可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。
package day05;
//测试什么是注解
public class Test01 extends Object{
// @Override:重写
@Override
public String toString() {
return super.toString();
}
}
内置注解
package day05;
//测试什么是注解
//镇压警告
@SuppressWarnings(value = "all")
public class Test01 extends Object{
// @Override:重写
@Override
public String toString() {
return super.toString();
}
// @Deprecated:不推荐使用，但是可以使用，或者存在更好的方式
@Deprecated
public static void test(){
System.out.println("@Deprecated");
}
public static void main(String[] args) {
// 可以使用
test();
}
}
元注解
- 元注解的作用就是负责注解其他注解，
- @Target：注解可以使用在什么地方
- {TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
- @Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期
- SOURCE < CLASS < RUNTIME
- @Documented：说明该注解将被包含在javadoc中
- @Inherited：说明子类可以继承父类中的该注解
- @Target：注解可以使用在什么地方
package day05;
import java.lang.annotation.*;
//测试元注解
@MyAnnotation
public class Test02 {
@MyAnnotation
public void test(){
}
}
//自定义一个注解
//Target:目标；表示我们注解可以使用在什么地方
/*
METHOD：方法
TYPE：类
FIELD：类的成员变量声明（包括枚举常量）
PARAMETER：形式参数声明
CONSTRUCTOR：构造器
LOCAL_VARIABLE：局部变量声明
ANNOTATION_TYPE：注解
PACKAGE：包
TYPE_PARAMETER：参数声明
TYPE_USE：使用类型
*/
//@Retention:生命周期
/*
SOURCE：源码
CLASS：类
RUNTIME：运行时
*/
//@Documented:被包含在javadoc
//@Inherited：子类可以继承父类注解
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@Inherited
@interface MyAnnotation{
// 注解体
}
自定义注解
- 使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口
- 分析
- @interface用来声明一个注解
- 其中的每一个方法实际上是声明了一个配置参数
- 方法的名称就是参数的名称
- 返回值类型，就是参数类型
- 通过default来声明参数的默认值
- 如果只有一个参数成员，一般参数名称为value
- 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值。
package day05;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//自定义注解
public class Test03 {
// 注解可以现实赋值，如果没有默认值，我们就必须给注解赋值
@MyAnnotation2(age = 18,name = "wei")
public static void test(){
System.out.println();
}
@MyAnnotation3("一个参数")
public void test2(){
}
public static void main(String[] args) {
test();
}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
// 注解的参数：参数类型 + 参数名字(); name():参数名称，不是一个方法
String name() default "";
int age() default 0;
int id() default -1; //如果默认值为-1，代表不存在
String[] school() default {"北京大学","清华大学"};
}
//如果参数只有一个，名字用value，使用的时候可以省略，用其他参数名字，不可以。
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
String value();
}
反射(Reflection)
- 让java变成动态语言
- 动态语言：在程序运行时时候，可以改变结构的语言。c#、JavaScript、PHP、Python
- 静态语言：在运行时时候，不可以改变结构。java、C、C++
- 可以获取注解
简单介绍
- 反射（Reflection）：是java被视为动态语言的关键，反射机制允许程序执行期借助于Reflection API取得任何的内部信息，并能够直接操作任意对象的内部属性及方法
- 加载完类后，在堆内存的方法区就会产生了一个class类型的对象（一个类只有一个class对象），这个对象就包含了完整的类的结构信息，我们通过这个对象看到类的接口，这个对象就像一面镜子，所以，我们形象的称为：反射
- 反射机制研究及应用
- 在运行的时候判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取范型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
- 优点
- 可以实现动态创建对象和编译，体现出很大的灵活性
- 缺点：
- 对性能有影响，使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且他们满足我们的要求，
package day05;
//什么叫做反射
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException {
// 通过反射获取类的class对象
Class u1 = Class.forName("day05.User");
Class u2 = Class.forName("day05.User");
Class u3 = Class.forName("day05.User");
Class u4 = Class.forName("day05.User");
// 一个类在内存中只有一个Class对象
// 一个类别加载后，整个结构会被封装在Class对象中
System.out.println(u1.hashCode());
System.out.println(u2.hashCode());
System.out.println(u3.hashCode());
System.out.println(u4.hashCode());
}
}
class User{
String name;
int age;
int id;
public User() {
}
public User(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
}
获取反射对象
- 对象照镜子后可以得到的信息：某个类的属性、方法、构造器、某个类实现了哪些接口
- 对于每个类而言，JRE都为其保留一个不变的Class类型的对象，一个Class对象包好了特定的某个结构的有关信息
- Class对象本身也是一个类
- Class对象只能由系统建立对象
- 一个加载的类在JVM中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个Class实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
获取Class类的几种方式
package day05;
//测试class类的创建方式有哪些
public class Test04 {
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("day05.Student");
System.out.println(c2.hashCode());
// 方式三：通过类名.class
Class<Student> c3 = Student.class;
System.out.println(c3.hashCode());
// 方式四：基本内置类的包装类都有一个Type属性
Class<Integer> type = Integer.TYPE;
System.out.println(type);
// 获得父类类型
Class superclass = c1.getSuperclass();
System.out.println(superclass);
}
}
class Person{
String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@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：枚举
- Annotation：注解
- Primitive type：基本数据类型
- Void：
package day05;
import java.lang.annotation.ElementType;
public class Test05 {
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 = Integer.class;
// 枚举
Class c7 = ElementType.class;
// void
Class c8 = void.class;
// 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.Class对象
- 链接：将Java类的二进制代码合并到JVM的运行之中的过程
- 验证：确保加载的类的信息符合JVM规范，没有安全方面的问题
- 准确：正式为类变量(static)分配内存并设置类变量默认初始化的阶段，这些内存都将在方法区中的进行分配
- 解析：虚拟机常量池的符号引用(常量名)替代为直接引用(地址)的过程。
- 初始化：
- 执行类构造器
()方法的过程，类构造器 ()方法是由编译器自动收集类中所有变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。 - 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
- 虚拟机会保证一个类的
()方法在多线程环境中被正确加锁和同步
- 执行类构造器
什么时候会发生类的初始化
- 类的主动引用(一定会发生类的初始化)
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员(除了final常量)和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父亲没有被初始化，则先回初始化它的父类
- 类的被动引用(不会发生类的初始化)
- 当访问一个静态域，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常来不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)
通过反射操作范型
- Java采用范型擦除的机制来引入范型，Java中的范型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和范型有关的类型全部擦除
- 为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。
- ParameterizedType：表示一种参数化类型，比如Collection
- GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable：是各种类型变量的公共父接口
- WildcardType：代表一种通配符类型表达式
- ParameterizedType：表示一种参数化类型，比如Collection
package day05;
import com.sun.javadoc.ParameterizedType;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
//通过反射获取范型
public class Demo06 {
public static void main(String[] args) throws NoSuchMethodException {
// 通过反射获取这个类中的方法对象
Method method = Demo06.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println(genericParameterType);
}
}
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;
}
}
通过反射获取注解
- 了解什么是ORM：对象关系映射
- 类和表结构对应
- 属性和字段对应
- 对象和记录对应
package day05;
import java.lang.annotation.*;
//测试反射操作注解
public class Demo07 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("day05.Student2");
// 通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获得注解value值
Table table = (Table)c1.getAnnotation(Table.class);
System.out.println(table.value());
// 获得指类指定的注解
java.lang.reflect.Field id = c1.getDeclaredField("id");
Field annotation = id.getAnnotation(Field.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Table("db_student")
class Student2{
@Field(columnName = "db_name",type = "varchar",length = 3)
String name;
@Field(columnName = "db_age",type = "int",length = 10)
int age;
@Field(columnName = "db_id",type = "int",length = 10)
int id;
public Student2() {
}
public Student2(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student2{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
}
//类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field{
String columnName();
String type();
int length();
}
浙公网安备 33010602011771号