注解与反射

最新推荐文章于 2024-09-30 10:36:33 发布

龙崎流河

最新推荐文章于 2024-09-30 10:36:33 发布

阅读量340

点赞数 1

分类专栏： javaweb 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Jiaodaqiaobiluo/article/details/122398615

版权

javaweb 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

注解与反射

注解

内置注解：java定义了一套注解，一共有7个，3个在java.lang中，剩下4个在java.lang.annotation中。

作用在代码上的注解：

@Override -检查该方法是否是重写方法。如果发现其父类或者引用的接口没有使用该方法会报编译错误。
@Deprecated -标记过时方法，如果使用该方法会报编译错误，
@SuppressWarnings -指示编译器去忽略注解中声明的警告。

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

//什么是注解
public class Test01 extends Object{
//    重写的注解
    @Override
    public String toString() {
        return super.toString();
    }
//    不推荐程序员使用，但是可以使用，或者存在更好的方式
    @Deprecated
    public static void test(){
        System.out.println("Deprecated");
    }
//    需要添加一个参数才能正确使用，这些参数都是已经定义好的，我们选择性的使用就好了
    @SuppressWarnings("all")
    public void test02(){
        List list = new ArrayList();
    }
    public static void main(String[] args) {
        test();
    }
}

作用在其他注解的注解（元注解）：

@Retention -标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行的时候可以通过反射访问。（以前游戏的外挂就是利用运行时反射操作）
@Documented -标记这些注解是否包含在用户文档中。
@Target -表示我们的注解可以用在哪些地方
@Inherited -标记这个注解是继承于哪个注解类（默认注解并没有继承于任何子类）

import java.lang.annotation.*;

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

    }
//    定义一个注解
//    Target 表示我们的注解可以用在哪些地方
    @Target(value= {ElementType.METHOD,ElementType.TYPE})
//    表示我们的注解在什么地方还有效
//    RUNTIME>CLASS>SOURCE
    @Retention(value = RetentionPolicy.RUNTIME)
//    表示我们的注解是否生成在JAVAdoc中
    @Documented
//    表示子类可以继承父类的注解
    @Inherited
    @interface MyAnnotation{

}
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,
    /** Field declaration (includes enum constants) */
    FIELD,
    /** Method declaration */
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE,
    ANNOTATION_TYPE,
    PACKAGE,
    TYPE_PARAMETER,
    TYPE_USE,
    MODULE
}
public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

自己定义一个注解，注意注解的参数是参数类型+参数名()，没有默认值就得必须给注解赋值，否则报错，如果注解参数名是value那么可以不用写value = 。

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 = "wzc")
    public void test(){

    }
    @MyAnnotation3("wzc")
    public void test2(){

    }
//    自定义注解
    @Target({ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation2{
//        注解的参数：参数类型+参数名（）；
        String name() default "";
        int age() default 0;
//        如果默认值为-1代表不存在
        int id() default -1;
}
    @Target({ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation3{
        String value();
    }
}

反射

java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息和动态调用对象的方法的功能称为java语言反射机制。

java不是动态语言，但是可以称之为“准动态语言”，也就是java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。

Java反射机制提供的功能：

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

优点：可以在程序运行过程中，操作这些对象，动态加载类，可以解耦，提高代码灵活性。（反射是框架的灵魂）
缺点：反射相当于一系列解释操作，通知JVM要做的事，性能比直接的java代码要慢的多，并且动态操作改变类的属性同时增加安全隐患。

class类：
```
public final native Class<?> getClass();
```
这个方法返回值类型是一个Class类，此类是java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，可以通过反射求出类的名称。

对象照镜子后可以得到的信息：某个类的属性，方法和构造器，某个类到底实现了哪些接口，对于每个类而言，JRE都为其保留一个不变的Class类型的对象。
1. Class本身也是个类
2. Class对象只能由系统建立对象
3. 一个加载的类在JVM中只会有一个Class实例
4. 一个Class对象对应的是一个加载到JVM中的一个class文件
5. 每个类的实例都会记得自己是由哪个Class实例所生成的
6. 通过Class可以完整地得到一个类中的所有被加载的结构
7. Class是反射的根源，针对任何你想动态加载，运行的类，唯有获得相应的Class对象。
Class.forName(“全类名”)：将字节码文件加载到内存中，返回class对象多用于配置文件，将类名定义在配置文件中，读取文件，加载类。

public class Test04 extends Object{
    public static void main(String[] args) throws ClassNotFoundException {
//        通过反射获取类的class对象
        Class c1 = Class.forName("User");
        Class c2 = Class.forName("User");
        Class c3 = Class.forName("User");
        Class c4 = Class.forName("User");
        System.out.println(c1);
//        一个类在内存中只有一个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;
    }
    private void test(){}
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

在这里插入图片描述

类名.class:通过类名属性class获取，多用于参数的传递。

对象.getClass（）：getClass（）方法在Object类中定义，多用于对象获取字节码的方式。

在这里插入图片描述

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

    }
    public Person(String name) {
        this.name = name;
    }
}
class Student extends  Person{
    public Student(){
        this.name = "学生";
    }
}
class Teacher extends  Person{
    public Teacher(){
        this.name = "老师";
    }
}

在这里插入图片描述

**类加载：**当一个程序要使用某个类的时候，如果类还没被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化，如果不发生意外，JVM会连续完成这三个步骤。

在这里插入图片描述

哪些类可以有Class对象:

class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
interface：接口
[]:数组
enum：枚举
annotaion:注解@interface
primitive type:基本数据类型
void

import java.lang.annotation.ElementType;

public class Test06 {
//    所有类型的class
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;
//    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。
    int[] a = new int[10];
    int[] b = new int[100];
    System.out.println(a.getClass().hashCode());
    System.out.println(b.getClass().hashCode());
}
}

在这里插入图片描述

类加载与内存分析：

当程序主动使用某个类时，如果该类还没被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。
在这里插入图片描述

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表整个类的java.lang.Class对象（获取，不能主动创建）。
链接：将java类的二进制代码合并到JVM的运行状态之中的过程。首先验证，确保加载的类信息符合JVM规范，没有安全方面的问题，然后准备，正式为类变量（static）分配内存并设置类变量默认初始值阶段，这些内存都将在方法区进行分配，最后解析，虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
初始化：执行类构造器方法的过程，类构造器方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。当初始化一个类的时候，如果发现其父类还没被进行初始化，则需要先触发其父类的初始化。虚拟机会保证一个类的方法在多线程环境中被正确加锁和同步。

public class Test07 {
    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;
        *
        * */
    }
}
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包的方法对类进行反射调用，当初始化一个类，如果其父类没有被初始化，则会初始化它的父类。

类的被动引用（不会发生类的初始化）：当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如：当通过子类引用父类的静态变量，不会导致子类初始化；通过数组定义类引用，不会触发此类的初始化；引用常量不会触发此类的初始化。

public class Test08 {
//    测试类什么时候会初始化
    static {
    System.out.println("Main类被加载");
}

    public static void main(String[] args) throws ClassNotFoundException {
//        主动引用
//        Son son = new Son();
//        反射也会产生主动引用
//        Class.forName("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;
}

在这里插入图片描述

类加载器的作用：

类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.class对象。作为方法区类数据的访问入口。

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

在这里插入图片描述

引导类加载器：用c++编写，JVM自带的类加载器，负责java平台的核心库，用来装载核心类库。该加载器无法直接获取。
扩展类加载器：负责jre/lib/ext目录下的jar包
系统类加载器：负责java -classpath所指的目录下的类与jar包装入工作，是最常用的加载器。

public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException {
//        获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
//        获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
//        获取扩展类加载器的父类加载器-->根加载器（c/c++）
        ClassLoader parent1 = parent.getParent();
//        根加载器是用来装核心类库的，该加载器无法直接获取
        System.out.println(parent1);
//        测试当前类是哪个加载器加载的
        ClassLoader test07 = Class.forName("Test07").getClassLoader();
        System.out.println(test07);
//        测试JDK内部的类是由谁加载的
        ClassLoader classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);
//        如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
//        双亲委派机制
//        java.lang.String--> 会一直往上找，自己定义的没有作用
    }
}

在这里插入图片描述

import org.w3c.dom.ls.LSOutput;

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

//获取类信息
public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("User");
//        User user = new User();
//        c1 = user.getClass();
//        获得类的名字
        System.out.println(c1.getName());//获得包名+类名
        System.out.println(c1.getSimpleName());//获得类名
//        获得类的属性
        System.out.println("=============");
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
//        获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
//        获得类的方法
        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);
        Method setName = c1.getMethod("setName",String.class);
        System.out.println(getName);
        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);
    }
}

在这里插入图片描述

Object invoke(Object obj,Object … args)

1.Objectb对应原方法的返回值，若原方法无返回值，此时返回null

2.若原方法若为静态方法，此时形参Object obj可为null

3.若原方法形参列表为空，则Object[] args为null

4.若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

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

public class Test11 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//获得class对象
        Class c1 = Class.forName("User");
//        构造一个对象
//        本质上调用了User的无参构造器
//        1.类必须有一个无参数的构造器
//        2。类的构造器的访问权限需要足够
//        User user = (User) c1.getDeclaredConstructor().newInstance();
//        System.out.println(user);
//        通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User) constructor.newInstance("wzc", 001, 18);
        System.out.println(user2);
//        通过反射调用普通方法
        User user3 = (User) c1.getDeclaredConstructor().newInstance();
//        通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
//        invoke:激活
//        （对象，”方法的值“）
        setName.invoke(user3,"王哥");
        System.out.println(user3.getName());
//        通过反射操作属性
        System.out.println("==============================");
        User user4 = (User)c1.getDeclaredConstructor().newInstance();
        Field name = c1.getDeclaredField("name");
//        不能直接操作私有属性，我们需要关闭程序的安全检测，属性或者方法的setAccessible(true)
        name.setAccessible(true);//
        name.set(user4,"王哥2");
        System.out.println(user4.getName());
//        Method和Field，Constructor对象都有setAccessible（）方法，该方法是启动和禁止访问安全检查的开关

    }
}

在这里插入图片描述

分析性能：

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

//分析性能问题
public class Test12 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        test01();
        test02();
        test03();
    }
//    普通方式调用
     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");
}
}

在这里插入图片描述

反射操作泛型：

java采用泛型擦除机制来引入泛型，java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射获取泛型
public class Test13 {
    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 = Test13.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 = Test13.class.getMethod("test02", null);
        Type genericReturnType = method.getGenericReturnType();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#"+genericParameterType);
//            判断泛型是否是一个参数化类型
            if (genericReturnType instanceof ParameterizedType){
//                强转成参数化类型,获得参数化信息
                Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
    }
}

在这里插入图片描述

获取注解信息案例：

类和表结构对应
属性和字段对应
对象和记录对应

在这里插入图片描述

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Test14 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("Student2");
//        通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
//        获得注解的value的值
        Tablewang tablewang = (Tablewang)c1.getAnnotation(Tablewang.class);
        String value = tablewang.value();
        System.out.println(value);
//        获得类指定的注解
        Field name = c1.getDeclaredField("name");
        Fieldwang annotation = name.getAnnotation(Fieldwang.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@Tablewang("db_student")
class Student2{
    @Fieldwang(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Fieldwang(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Fieldwang(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 Tablewang{
    String value();
}
//    属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldwang{
    String columnName();
    String type();
    int length();
}