随笔-java注解,反射,枚举

package aresoft.controller.test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class Demo3 {
    @SuppressWarnings("unchecked")
    public static <T>  void test(){
        try {
            //1,加载类
            Class clazz=Class.forName("aresoft.controller.test.DemoBean");
            //2、根据构造器参数类型获取相应的构造器对象      
            Constructor csr = clazz.getConstructor(String[].class);  
            String str[]={"1","testname","man"};  
            //3、创建实体对象  
            T t1 = (T)csr.newInstance((Object)str);  
            
            List<Field> fieldList=getFields(clazz);
            int flag=0;
            Object obj=null;
            for(Field f:fieldList){
                if(isClassType(f)){   
                    flag=flag+1;
                    Method method=commonMethod(Meiju.GET.getName(),clazz,f);
//                    System.out.println(method.getReturnType());
                    if(!method.getReturnType().toString().equals("void")){
                        obj=method.invoke(t1,new Object[]{});
                    }
                    System.out.println(obj.toString());
                    
                    if(flag>2){
                        break;
                    }
                    Annotation[] as=f.getAnnotations();   //每个Field 的注释
                    if(as.length >=0){
                        for(Annotation a:as){
                        //    System.out.println("annotation:"+a.toString());
                        }
                    }
                }
            }
            
            
            //方法注解
            Zhujie zjmethod=clazz.getMethod(commonMethod(Meiju.GET.getName(),clazz,fieldList.get(1)).getName(),new Class[]{}).getAnnotation(Zhujie.class);
            System.out.println("getName()方法的注解:"+zjmethod.name());
            //字段注解
            Zhujie zjfield=clazz.getDeclaredField((fieldList.get(1)).getName()).getAnnotation(Zhujie.class);
            System.out.println("name字段的注解:"+zjfield.name());
            
            
                                         //利用枚举获得方法的前面是get还是set
            Method setmethod=commonMethod(Meiju.SET.getName(),clazz,fieldList.get(3));
            if(setmethod.getReturnType().toString().equals("void")){ //如果返回类型 void
                System.out.println("无返回类型");
            }
            Integer i=new Integer(1);
            setmethod.invoke(t1,i);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//得到所有的Field包括父类的
    public static List<Field> getFields(Class<?> clazz){
        List<Field> fieldList=new ArrayList<Field>();
        do{
            Field[] fields=clazz.getDeclaredFields();
            for(Field f:fields){
                fieldList.add(f);
            }
            clazz=clazz.getSuperclass();
        }while(clazz != Object.class && clazz!=null);
        return fieldList;
    }

//判断Field是否是基本类型
    public static Boolean isClassType(Field field){
        Class<?> type=field.getType();
        Boolean isBaseClass=false;
        if(type.isPrimitive() || type.getPackage() !=null
                || type.getPackage().getName().equals("java.lang")
                || type.getPackage().getName().equals("java.math")
                || type.getPackage().getName().equals("java.math")){
            isBaseClass=true;
        }else if(type.isArray()){
            isBaseClass=false;
        }
        return isBaseClass;
    }

//Method  get
    public static Method getMethod(Class<?> clazz,Field field){
        StringBuffer sb =new StringBuffer();
        sb.append(Meiju.GET.getName());
        Method method=null;
        try {
            String firstChar=field.getName().substring(0, 1).toUpperCase();
            sb.append(firstChar);
            sb.append(field.getName().substring(1, field.getName().length()));
            method=clazz.getDeclaredMethod(sb.toString(),new Class[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
        return method;
    }

//Method  set
    public static Method setMethod(Class<?> clazz,Field field){
        StringBuffer sb =new StringBuffer();
        sb.append(Meiju.SET.getName());
        Method method=null;
        try {
            String firstChar=field.getName().substring(0, 1).toUpperCase();
            sb.append(firstChar);
            sb.append(field.getName().substring(1, field.getName().length()));
            method=clazz.getDeclaredMethod(sb.toString(),field.getType());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return method;
    }
    
    //Method common
    public static Method commonMethod(String gsmethod,Class<?> clazz,Field field){
        StringBuffer sb =new StringBuffer();
        sb.append(gsmethod);//get or set
        Method method=null;
        try {
            String firstChar=field.getName().substring(0, 1).toUpperCase();
            sb.append(firstChar);
            sb.append(field.getName().substring(1, field.getName().length()));
            if(gsmethod.equals(Meiju.GET.getName())){
                method=clazz.getDeclaredMethod(sb.toString(),new Class[]{});
            }else if(gsmethod.equals(Meiju.SET.getName())){
                method=clazz.getDeclaredMethod(sb.toString(),field.getType());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return method;
    }

public static void main(String[] args) {
        test();
    }
}

//实体类

package aresoft.controller.test;

import javax.persistence.Column;

@Zhujie(name="jeecg_demo")
public class DemoBean {
    /**id*/
    @Zhujie(name="id")
    private String id;
    /**姓名*/
    @Zhujie(name="name")
    private String name;
    /**性别*/
    private String sex;
    /**年龄*/
    private Integer age;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    @Zhujie(name="jeecg_demo_method")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public DemoBean(String[] string) {
        super();
        this.id = string[0];
        this.name = string[1];

this.sex = string[2];
    
    }
    public DemoBean() {
        super();
        // TODO Auto-generated constructor stub
    }
    
}

//注解

package aresoft.controller.test;

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;

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

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Zhujie {
     String name() default "test";
    
}

//枚举

package aresoft.controller.test;

public enum Meiju {
    GET("get"),SET("set");
    private String name;

private Meiju(String name) {
        this.name = name;
    }

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }
    
}

时间: 2024-10-15 03:40:38

随笔-java注解,反射,枚举的相关文章

java ----&gt; 注解/反射

注解 一个例子,摘自Junit-4.12.jar源码. 1 @Retention(RetentionPolicy.RUNTIME) 2 @Target({java.lang.annotation.ElementType.METHOD}) 3 public @interface Test{ 4 5 //...... 6 } 关注两个元注解和两个类,它们位于java.lang.annotation包中. @Retention(RetentionPolicy.RUNTIME)@Target(java.

Java注解教程:自定义注解示例,利用反射进行解析

Java注解能够提供代码的相关信息,同时对于所注解的代码结构又没有直接影响.在这篇教程中,我们将学习Java注解,如何编写自定义注解,注解的使用,以及如何使用反射解析注解. 注解是Java 1.5引入的,目前已被广泛应用于各种Java框架,如Hibernate,Jersey,Spring.注解相当于是一种嵌入在程序中的元数据,可以使用注解解析工具或编译器对其进行解析,也可以指定注解在编译期或运行期有效. 在注解诞生之前,程序的元数据存在的形式仅限于java注释或javadoc,但注解可以提供更多

java注解中的元注解

一:java注解中的元注解 四个元注解分别是:@Target,@Retention,@Documented,@Inherited , 再次强调下元注解是java API提供,是专门用来定义注解的注解,其作用分别如下: @Target 表示该注解用于什么地方,可能的值在枚举类 ElemenetType 中,包括: ElemenetType.CONSTRUCTOR----------------------------构造器声明 ElemenetType.FIELD ----------------

Java:反射

初识Java反射机制: 从上面的描述可以看出Java的反射机制使得Java语言可以在运行时去认识在编译时并不了解的类/对象的信息,并且能够调用相应的方法或修改属性的值.Java反射机制的核心就是允许在运行时通过Java Reflection APIs来取得已知名字的class类的内部信息(包括其modifiers(如public, static等).superclass(如Object).interfaces(如Serializable),也包括fields和methods的所有信息),动态地生

Java注解全面解析

1.基本语法 注解定义看起来很像接口的定义.事实上,与其他任何接口一样,注解也将会编译成class文件. @Target(ElementType.Method) @Retention(RetentionPolicy.RUNTIME) public @interface Test {} 除了@符号以外,@Test的定义很像一个空的接口.定义注解时,需要一些元注解(meta-annotation),如@Target和@Retention @Target用来定义注解将应用于什么地方(如一个方法或者一个

java注解(Annotation)解析

注解(Annotation)在java中应用非常广泛.它既能帮助我们在编码中减少错误,(比如最常见的Override注解),还可以帮助我们减少各种xml文件的配置,比如定义AOP切面用@AspectJ模式代替Schema模式,特别是最近接触了一点Spring MVC,每次编写Controller的时候用@RequestMapping(),@RequestParam,@ResponseBody等等. 我们所用的java中自带的注解都是定义好了的,直接拿来用,它就能发挥作用.当然了,自己也可以定义注

Java注解再学习

注解就是一个标识符,用来标识身份.处理规则等.注解是出现可以代替XML配置文件,使程序更加清晰明了.注解也是框架配置的发展方向,对于Spring而言,虽然有人反对使用注解对Spring进行配置,说这是违背了Spring的IoC的理念,其实不然.使用注解将Java类注解为配置文件和使用XML是一样的,还可以减少配置文件,并且更加自由化的定义bean的初始化过程. 注解是一门比较简单却很实用的技术,定义注解使用@interface关键字: 1 public @interface MyAnnotati

Java注解介绍

原文链接: Java Annotations: An Introduction原文日期: 2005年10月14日翻译日期: 2014年07月20日翻译人员: 铁锚 翻译完后,感觉这篇文章是不是在http://www.developer.com被挖坟了? Java注解介绍 基于注解(Annotation-based)的Java开发无疑是最新的开发趋势.[译者注: 这是05年的文章,在2014年,毫无疑问,多人合作的开发,使用注解变成很好的合作方式,相互之间的影响和耦合可以很低]. 基于注解的开发将

深入理解Java注解类型(@Annotation)

"-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 深入理解Java注解类型(@Annotation) - zejian的博客 - 博客频道 - CSDN.NET zejian的博客 目录视图 摘要视图 订阅 [活动]2017 CSDN博客专栏评选 &nbsp [5月书讯]流畅的Python,终于等到你!    &am