Java注解与反射

喝口茶

已于 2023-03-04 17:09:07 修改

阅读量128

点赞数

分类专栏： Computer 文章标签： java

于 2022-09-17 10:31:10 首次发布

本文链接：https://blog.csdn.net/kkoyy459/article/details/126902107

版权

Computer 专栏收录该内容

42 篇文章 1 订阅

订阅专栏

根据以下学习视频，个人整理的学习笔记

https://www.bilibili.com/video/BV1p4411P7V3?spm_id_from=333.999.0.0&vd_source=7a8946d22777450e46486d5fd60d8d4d

注解 Java.Annotation

注解入门

Annotation的作用

不是程序本身，可以对程序作出解释（这点和注释没什么区别）
可以被其它程序（比如编译器）读取

注解（Annotation）的格式

@注释名
还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”)

注解在哪里使用

可以附加在package，class，method，field等上面，相当于给它们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元素的访问

例子

package annotation;


//什么是注解
public class Test01 extends Object{

	//@Override 重写的注解  这是比较常见的注解
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
	
}

内置注解

Java比较常见的三个内置注解

@Override
@Deprecated
@SuppressWarnings()

例子

package annotation;

import java.util.ArrayList;
import java.util.List;


//什么是注解
@SuppressWarnings("all")
public class Test01 extends Object{

	//@Override 重写的注解  这是比较常见的注解
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
	
	//@Deprecated 表示已过时的程序元素，不推荐程序员使用。仍然可以使用
	@Deprecated
	public void test() {
		
	}
	
	//@SuppressWarnings() 需要参数  镇压警告 不仅可以放在方法上，也可以放在类上
	@SuppressWarnings("all")
	public void test02() {
		List list = new ArrayList();
	}
	
}

元注解

元注解（meta-annotation）

元注解的作用就是负责注解其他注解
Java定义了4个标准的meta-annotation类型，它们被用来提供对其他annotation类型作说明
- @Target（描述注解的使用范围）
- @Retention（表示我们的注解在什么级别还有效）
  - 三个级别的有效范围大小（SOURCE<CLASS<RUNTIME）
- @Documented（表示是否将我们的注解生成在JAVAdoc中）
- @Inherited（表示子类可以继承父类的注解）

例子

package annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//测试元注解
@MyAnnotation
public class Test02 {
	
	@MyAnnotation
	public void test() {
		
	}
}



//定义一个注解
//@Target 表示我们的注解可以用在哪些地方
//@Retention 表示我们的注解在什么级别还有效
//@Documented 表示是否将我们的注解生成在JAVAdoc中
//@Inherited 表示子类可以继承父类的注解

@Target(value = {ElementType.METHOD,ElementType.TYPE} )
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface MyAnnotation {//一个类只能有一个public class
	
}

自定义注解

注意点

注解中的配置参数是带()的，看上去有点像方法，但其实是参数

例子

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//自定义注解
public class Test03 {
	
	@MyAnnotation2(name = "Hatea",schools = {"西北大学","西工大"})//如果参数有默认值，可以不写
	public void test() {
		
	}
	
	@MyAnnotation3("")//如果只有一个参数，且参数名字为value，则value可以省略
	public void test2() {
		
	}
	
}


@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
	
	//注解的参数：参数类型 + 参数名（）；
	//这里设置参数默认值为空
	String name() default "";//这里是注解的参数，并不是方法！！！
	
	int age() default 0;
	int id() default -1;//如果默认值为-1，代表不存在
	
	String[] schools() default {"西部开源","清华大学"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
	
	String value();//如果注解只有一个参数，建议使用value命名
	
}

反射 Reflection

静态语言
- 运行时结构不可变的语言
- 主要的静态语言有：Java、C、C++
- Java不是动态语言，但Java可以称为“准动态语言”，即Java有一定的动态性。是因为反射机制的存在，使Java获得类似动态语言的特性
动态语言
- 是一类在运行时可以改变其结构的语言
- 主要的动态语言有：Object-C、C#、JavaScript、PHP、Python等

反射机制

反射机制允许程序在执行期借助于Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法（可以直接获取private修饰的对象）

在这里插入图片描述

Java反射机制提供的功能

在运行时
- 判断任意一个对象所属的类
- 构造任意一个类的对象
- 判断任意一个类所具有的成员变量和方法
- 获取泛型信息
- 调用任意一个对象的成员变量和方法
- 处理注解
生成动态代理

在这里插入图片描述

反射的通俗理解：可以通过对象反射求出类的名称

例子

package reflection;

//什么叫反射
public class Test02 extends Object{
	public static void main(String[] args) throws ClassNotFoundException {
		//通过反射获取类的Class对象
		
		Class c1 = Class.forName("reflection.User");
		
		System.out.println(c1);
		
		Class c2 = Class.forName("reflection.User");
		Class c3 = Class.forName("reflection.User");
		Class c4 = Class.forName("reflection.User");

		//如果hashCode一样，说明它们是同一个类
		//说明一个类在内存中只有一个Class对象
		//一个类被加载后，类的整个结构都会被封装在Class对象中，通过这个Class对象可以获得类中的所有东西
		System.out.println(c2.hashCode());
		System.out.println(c3.hashCode());
		System.out.println(c4.hashCode());
		
	}
	
}

//定义实体类：pojo ，entity
class User{
	private String name;
	private int id;
	private int age;
	
	
	public User() {
		
	}
	
	public User(String name,int id,int age) {
		this.name = name;
		this.id = id;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		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;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", id=" + id + ", age=" + age + "]";
	}
}

Class类

Class 本身也是一个类
Class 对象只能由系统建立对象（咱们只能通过反射得到这个对象）
一个加载的类在JVM中只会有一个Class对象
一个Class对象对应的是一个加载到JVM中的一个 .class 文件
每个类的实例都会记得自己是由哪个 Class对象所生成
通过Class类可以完整地得到一个类中的所有被加载的结构
Class类是Reflection（反射）的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

在这里插入图片描述

例子

package reflection;

//测试Class类的创建方式有哪些
public class Test03 {
	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("reflection.Student");
		System.out.println(c2.hashCode());
		
		//方式三：通过类名.class获得
		Class c3 = Student.class;
		System.out.println(c3.hashCode());
		
		
		
		//方式四：基本内置类型的包装类都有一个Type属性
		Class c4 = Integer.TYPE;
		System.out.println(c4);
		
		
		
		//获得父类的类型
		Class c5 = c1.getSuperclass();//c1,c2,c3  都一样
		System.out.println(c5);
		
		
	}
	
	
	
}


class Person{
	public 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：注解@interface
primitive type：基本数据类型
void

例子

package reflection;

import java.lang.annotation.ElementType;

//所有类型的Class对象
public class Test04 {
	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 = ElementType.class;//枚举
		
		Class c7 = Integer.class;//基本数据类型
		
		Class c8 = void.class;//void
		
		Class c9 = Class.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
		int[] a = new int[10];
		int[] b = new int[100];
		System.out.println(a.getClass().hashCode());
		System.out.println(b.getClass().hashCode());
	}
}

Java内存分析

Java内存

堆
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
栈
- 存放基本变量类型
- 引用对象的变量
方法区（特殊的堆）
- 可以被所有线程共享
- 包含了所有的class和static变量

类的加载过程

类的加载（Load）
- 将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成（所以说我们只能获取Class对象）
类的链接（Link）
- 将类的二进制数据合并到JRE中
类的初始化（Initialize）
- JVM负责对类进行初始化

在这里插入图片描述

例子

package reflection;


//讲解类的加载
public class Test05 {
	public static void main(String[] args) {
		A a = new A();
		System.out.println(A.m);
		
		
		/*
		 * 1.加载到内存，会产生一个类对应的Class对象
		 * 2.链接，链接结束后，m = 0；
		 * 3.初始化
		 * 		<clinit>(){
		 * 			System.out.println("A类静态代码块初始化");
					m = 300;
					
					m = 100;
		 * 		}
		 * 4.初始化完后 m = 100
		 * 
		 */
		
	}
}

class A{
	static {
		System.out.println("A类静态代码块初始化");
		
		m = 300;
	}
	static int m = 100;
	
	public A() {
		System.out.println("A类的无参构造初始化");
	}
}

什么时候会发生类的初始化

类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如：当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（因为常量在链接阶段就存入调用类的常量池中了）

例子

package reflection;

//测试类什么时候会初始化
public class Test06 {

	static {
		System.out.println("main所在的类被加载");
	}
	
	
	public static void main(String[] args) throws ClassNotFoundException {
		//主动引用
		//Son son = new Son();
		
		//反射也会产生主动引用
		//Class.forName("reflection.Son");
		
		
		
		//不会产生类的引用的方法
		//System.out.println(Son.b);
		
		//Son[] array = new Son[5];
		
		System.out.println(Son.M);
		
	}
	
}

class Father{
	
	static int b = 2;
	
	static {
		System.out.println("父类被加载");
	}
}


class Son extends Father{
	
	static {
		System.out.println("子类被加载");
		m = 300;
	}
	
	static int m = 100;
	static final int M = 1;
	
}

类加载器的作用

类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象

JVM规范定义了如下类型的类加载器

引导类加载器（负责Java平台核心库）
扩展类加载器
系统类加载器（最常用的加载器）

例子

package reflection;

public class Test07 {
	public static void main(String[] args) throws ClassNotFoundException {
		
		//获取系统类加载器
		ClassLoader cl = ClassLoader.getSystemClassLoader();
		System.out.println(cl);
	
		
		//获取系统类加载器的父类加载器--->扩展类加载器
		ClassLoader clp = cl.getParent();
		System.out.println(clp);
		
		//获取扩展类加载器的父类加载器--->根加载器(C/C++编写的，java无法读取，返回null)
		ClassLoader clpp = clp.getParent();
		System.out.println(clpp);
		
		
		
		
		//测试当前类是哪个加载器加载的
		ClassLoader cl1 = Class.forName("reflection.Test07").getClassLoader();
		System.out.println(cl1);
		
		//测试JDK内置的类是哪个加载器加载的
		ClassLoader cl2 = Class.forName("java.lang.Object").getClassLoader();
		System.out.println(cl2);
		
		
		
		//如何获得系统类加载器可以加载的路径
		System.out.println(System.getProperty("java.class.path"));
		
		
		//双亲委派机制（作为了解）
	}
}

创建运行时类的对象

通过反射获取运行时类的完整结构

Field（字段）
Method
Constructor
Superclass
Interface
Annotation

例子

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//获得类的信息
public class Test08 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, NoSuchMethodException {
		Class c1 = Class.forName("reflection.User");
		
		//获得类的名字
		System.out.println(c1.getName());//获得包名 + 类名
		System.out.println(c1.getSimpleName());
		
		//获得类的属性
		System.out.println("===============================");
		/*
		 * Field[] fields = c1.getFields(); //只能找到public属性
		 */
		
		Field[] fields = c1.getDeclaredFields();//可以找到全部的属性
		for (Field field : fields) {
			System.out.println(field);
		}
		
		//获得指定属性的值
		Field fields2 = c1.getDeclaredField("name");
		System.out.println(fields2);
		
		System.out.println("===============================");
		
		//获得类的方法
		Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法
		for (Method method : methods) {
			System.out.println("正常的：" + method);
		}
		
		methods = c1.getDeclaredMethods();//获得本类的所有方法（包括私有方法）
		for (Method method : methods) {
			System.out.println("getDeclaredMethods：" + method);
		}
		
		//获得指定的方法
		Method getName = c1.getMethod("getName", null);
		System.out.println(getName);
		
		Method setName = c1.getMethod("setName", String.class);
		System.out.println(setName);
		
		System.out.println("===============================");
		
		//获得指定的构造器
		Constructor[] constructors = c1.getConstructors();
		for(Constructor constructor : constructors) {
			System.out.println(constructor);
		}
		
		constructors = c1.getDeclaredConstructors();//获得本类全部
		for(Constructor constructor : constructors) {
			System.out.println("====" + constructor);
		}
		
		
		//获得指定的构造器
		Constructor declaredConstructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
		System.out.println("-----" + declaredConstructor);
		
	}
}

package reflection;

public class Test02 extends Object{
	public static void main(String[] args) throws ClassNotFoundException {
		Class c1 = Class.forName("reflection.User");
		
		System.out.println(c1);
        
		Class c2 = Class.forName("reflection.User");
		Class c3 = Class.forName("reflection.User");
		Class c4 = Class.forName("reflection.User");

		System.out.println(c2.hashCode());
		System.out.println(c3.hashCode());
		System.out.println(c4.hashCode());
	}
}
//定义实体类：pojo ，entity
class User{
	private String name;
	private int id;
	private int age;
	
	public User() {
		
	}
	
	public User(String name,int id,int age) {
		this.name = name;
		this.id = id;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		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;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", id=" + id + ", age=" + age + "]";
	}	
}

动态创建对象执行方法

例子

reflection.User 的代码参考上面给出的

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//动态的创建对象，通过反射
public class Test09 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
		//获得Class对象
		Class c1 = Class.forName("reflection.User");
		
		//构造一个对象
		//Object user = c1.newInstance();//我们转为User类型，因为我们知道是User类型
		User user = (User)c1.newInstance();//本质上是调用了类的无参构造器
		
		System.out.println(user);
		
		//调用Class对象的newInstance()方法：1.类必须有一个无参数的构造器  2.类的构造器的访问权限需要足够
		
		
		
		
		//通过构造器创建对象
		Constructor declaredConstructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
		User user1 = (User)declaredConstructor.newInstance("Hatea",1,18);
		System.out.println(user1);
		
		
		
		//通过反射调用普通方法
		User user2 = (User)c1.newInstance();
		
		//通过反射获取一个方法
		Method method = c1.getDeclaredMethod("setName", String.class);
		//invoke   激活
		method.invoke(user2, "Hatea");//给user2这个对象的setName方法传递一个String值
		
		System.out.println(user2.getName());
		
		
		
		//通过反射操作属性
		User user3 = (User)c1.newInstance();
		Field name = c1.getDeclaredField("name");
		
		//不能直接操作私有属性或方法，我们需要关闭程序的安全检测，通过属性或者方法的setAccessible(true) 关闭
		name.setAccessible(true);//取消name的安全检测，因为这里的name是private修饰的
		
		name.set(user3, "Hatea2");
		System.out.println(user3.getName());
		
		}
}

性能对比分析

例子

reflection.User 的代码参考上面给出的

package reflection;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//分析性能问题
public class Test10 {
	
	//普通方式调用
	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 ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		User user = new User();
		Class c1 = user.getClass();
		Method method1 =  c1.getDeclaredMethod("getName", null);
		
		long startTime = System.currentTimeMillis();
		
		for(int i=0; i<1000000000; i++) {
			method1.invoke(user, null);
		}
		
		long endTime = System.currentTimeMillis();
		
		System.out.println("反射方式执行10亿次：" + (endTime-startTime) + "ms");
		
	}
	
	//反射方式调用 关闭检测
	public static void test03() throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		User user = new User();
		Class c1 = user.getClass();
		Method method1 =  c1.getDeclaredMethod("getName", null);
		
		long startTime = System.currentTimeMillis();
		
		method1.setAccessible(true);
		
		for(int i=0; i<1000000000; i++) {
			method1.invoke(user, null);
		}
		
		long endTime = System.currentTimeMillis();
		
		System.out.println("关闭检测，反射方式执行10亿次：" + (endTime-startTime) + "ms");
		
	}
	
	
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		test01();
		test02();
		test03();
	}
	
	/*
	 * 普通方式执行10亿次：3ms
       反射方式执行10亿次：2790ms
       关闭检测，反射方式执行10亿次：1340ms
	 */
	
}

获取泛型信息

例子

package reflection;

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 Test11 {

	public static 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, SecurityException {
		Method m1 = Test11.class.getMethod("test01", Map.class,List.class);
		Type[] types = m1.getGenericParameterTypes();//获得泛型的参数类型
	
		for(Type type : types) {
			System.out.println(type);
			
			if(type instanceof ParameterizedType) {
				Type[] types1 = ((ParameterizedType)type).getActualTypeArguments();
				for(Type types11 : types1) {
					System.out.println(types11);
				}
			}
		}
		
		m1 = Test11.class.getMethod("test02", null);
		Type genericReturnType = m1.getGenericReturnType();//获得泛型的返回类型
		if(genericReturnType instanceof ParameterizedType) {
			Type[] types1 = ((ParameterizedType)genericReturnType).getActualTypeArguments();
			for(Type types11 : types1) {
				System.out.println(types11);
			}
		}
	}
	
}

反射操作注解

ORM：对象关系映射

例子

package reflection;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;

//练习反射操作注解
public class Test12 {
	
	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
		Class c1 = Class.forName("reflection.Student2");
		
		//通过反射获得注解
		Annotation[] annotations = c1.getAnnotations();
		for (Annotation annotation : annotations) {
			System.out.println(annotation);
		}
		
		//获得注解的value的值
		TableHatea an = (TableHatea)c1.getAnnotation(TableHatea.class);
		String value = an.value();
		System.out.println(value);
		
		
		//获得类指定的注解
		Field field = c1.getDeclaredField("name");
		FieldHatea ans = field.getAnnotation(FieldHatea.class);
		System.out.println(ans.columnName());
		System.out.println(ans.type());
		System.out.println(ans.length());
	}
	
	
}

@TableHatea("db_student")
class Student2{
	
	@FieldHatea(columnName = "db_id",type = "int", length = 10)
	private int id;
	@FieldHatea(columnName = "db_age",type = "int", length = 10)
	private int age;
	@FieldHatea(columnName = "db_name",type = "varchar", 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 TableHatea{
	String value();
}


//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldHatea{
	String columnName();//列名
	String type();
	int length();
}