注解与反射
注解:annotation
注释:comment
一 注解入门
1.1 什么是注解?
可以被其他程序读取 -->不同于注释
格式:@注释名
可以通过反射机制编程实现对元数据的访问
二 内置注解
2.1 内置注解
@Override:定义在java.lang.Override
中,表示重写 超类中一个方法
@Deprecated:定义在java.lang.Deprdcated
中,表示不鼓励程序员使用这样的元素
@SuppressWarnings:定义在java.lang.SuppressWarnings
中,用来抑制编译时的警告信息
三 自定义注解、元注解
3.1 元注解
作用:负责注解其他注解。java中定义了4个标准的meta-annotation,分别是:
@Target:用于描述注解的使用范围
@Retention:表示在什么级别保存该注释信息,用于描述注解生命周期(SOURCE<CLASS<RUNTIME)
@Documented:说明该注解将被包含在javadoc中
@Inherited:说明子类可以继承父类中的该注解
3.2 自定义注解
使用@interface可以自定义注解,自动继承了java.lang.annotation.Annotation
接口
四 反射
4.1 反射机制
反射:Reflection
java Reflection
- Reflection:是java被视为动态语言的关键,反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息,并能直接操作任意对象的内部属性以及方法
Class c = Class.forName("java.lang.String")
- 加载完类之后,在堆内存的方法区中就产生了一个class类型的对象(一个类只有一个class对象),这个对象就包含了完成整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像是一面镜子,透过这个镜子看到类的结构,所以形象的称之为反射
4.2 java反射机制研究及应用
java反射机制提供的功能:
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理
java反射优点和缺点:
优点:实现动态创建对象和编译,有很大的灵活性
缺点:对性能有影响。
反射相关的主要API:
java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
Class类
在Object类中定义了一下的方法,此方法将被所有子类继承
public final Class getClass();
获取Class类的实例
- 若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高
Class clazz = Person.class;
- 已知某个类的实例,调用该实例的getClass()方法获取class对象
Class clazz = person.getClass();
- 已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException
Class clazz = Class.forName("demo01.Student");
哪些类型可以有Class对象
- class:外部类,成员(成员内部类、静态内部类)、局部内部类、匿名内部类
- interface:接口
- []:数据
- enum:枚举
- annotation:注解@interface
- primitive type:基本数据类型
- void
4.3 java内存分析
- java内存:
- 堆
- 存放new的对象和数组
- 可以被所有的线程共享,不会存放别的对象引用
- 栈
- 存放基本变量类型(会包含这个基本类型的值)
- 引用对象的变量(会存放这个引用在堆里面的具体地址)
- 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量
- 堆
4.4 通过反射创建类的对象
- 调用Class对象newInstance()方法
- 类必须有一个无参数的构造器
- 类的构造器的访问权限需要足够
- 如果没有无参构造器,需要在操作的时候明确的调用类中的构造器,并将参数传递进去之后,才可以实例化操作
- 通过Class类的getDeclaredConstructor(Class)取得本类的指定形参类型的构造器
- 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数
- 通过Constructor实例化对象
调用指定的方法
通过反射,调用类中的方法,通过Method类完成
- 通过Class类中分getMethod(String name,Class…)方法获得一个Method对象,并设置此方法操作时所需要的参数类型。
- 之后使用Object invoke(Object obj, Object[] args)进行调用,并向方法传递要设置的obj对象的参数信息。
Object invoke(Object obj, Object[] args)
- Object对应原方法的返回值
- 若原方法为静态方法,形参Object obj可为null
- 若原方法形参列表为空,则Object[] args为null
- 若原方法为private,则需要在调用此invoke()方法前,显式的调用方法对象的setAccessible(true)方法,才可访问private方法
setAccessible
- Method、Field和Constructor对象都有setAccessible方法
- setAccessible作用是启动和禁用访问安全检查的开关
- 参数值为true则指反射的对象在使用时应该取消java语言访问检查
- 提高反射效率,如果代码中必须用反射,而该句代码要频繁的被调用,那么请设置为true
- 使得原本无法访问的私有成员也可以访问
- 参数值为false则指示反射的对象应该实施java对象语言访问
4.5 性能比较测试
package reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//分析性能问题
public class Test05 {
//普通方式调用
public static void test01(){
User user = new User();
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
user.getName();
}
long endTime = System.currentTimeMillis();
System.out.println("普通方式调用10亿次:"+(endTime-startTime)+"ms");
}
//反射方式调用
public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getDeclaredMethod("getName", null);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射方式调用10亿次:"+(endTime-startTime)+"ms");
}
//反射方式调用 关闭检测
public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getDeclaredMethod("getName", null);
getName.setAccessible(true);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("关闭检测反射方式调用10亿次:"+(endTime-startTime)+"ms");
}
public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
test01();
test02();
test03();
}
}
4.6 反射操作泛型
- java采用泛型擦除的机制来引入泛型,java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题,但是一旦编译完成,所有和泛型有关的类型全部被擦除
- 为了通过反射操作这些类型,java新增了ParameterizedType,GeneericArrayType,TypeVariable和WildcardType几种类型来代表不能被归一到class类中的类型,但是又和原始类型齐名的类型。
- ParameterizedType:表示一种参数化类型,比如Collection
- GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable:是各种类型变量的公共父接口
- WildcardType:代表一种通配符类型表达式
package reflection;
import javax.lang.model.element.NestingKind;
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 Test06 {
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;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test06.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.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);
}
}
}
method = Test06.class.getMethod("test02",null);
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
4.7 反射操作注解
ORM:Object relationship Mapping–>对象关系映射
- 类和表结构对应
- 属性和字段对应
- 对象和记录对应
package reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
//联系反射操作注解
public class Test07 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("reflection.Student2");
//通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得注解的value的值
Table1 tabel1 = (Table1) c1.getAnnotation(Table1.class); //获得指定注解
String value = tabel1.value(); //获取指定注解的值
System.out.println(value);
//获得类指定注解
// Field f = c1.getDeclaredField("name");
// Field1 annotation = f.getAnnotation(Field1.class);
// System.out.println(annotation.columnName());
// System.out.println(annotation.type());
// System.out.println(annotation.length());
Field f = c1.getDeclaredField("id");
Field1 annotation = f.getAnnotation(Field1.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Table1("db_student")
class Student2{
@Field1(columnName = "db_id",type = "int",length = 10)
private int id;
@Field1(columnName = "db_age",type = "int",length = 10)
private int age;
@Field1(columnName = "db_name",type = "var char",length = 3)
private String name;
public Student2() {
}
public Student2(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student2{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
//类名的注释
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table1{
String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field1{
String columnName();
String type();
int length();
}