现在的位置: 首页 > 综合 > 正文

JAVA自定义注解（1）

2014年01月07日 ⁄ 综合 ⁄ 共 6119字 ⁄ 字号 小 中 大 ⁄ 评论关闭

1、自定义注解@People

[java]
view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.kute.test.selfannotation;  
  2.   
  3. import java.awt.Color;  
  4. import java.lang.annotation.Documented;  
  5. import java.lang.annotation.ElementType;  
  6. import java.lang.annotation.Retention;  
  7. import java.lang.annotation.RetentionPolicy;  
  8. import java.lang.annotation.Target;  
  9.   
  10. /** 
  11.  * 使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。 
  12.  * 在定义注解时，不能继承其他的注解或接口。 
  13.  * @interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。 
  14.  * 方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。 
  15.  * 可以通过default来声明参数的默认值,如果不指定default，则该参数为必设项 
  16.  *  
  17.  * Annotation类型里面的参数该怎么设定:  
  18.  * 第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型； 
  19.  * 第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型 
  20.  *         和 String,Enum,Class,annotations等数据类型以及这一些类型的数组. 
  21.  * 第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号. 
  22.  *  
  23.  * 注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。 
  24.  * 因此, 使用空字符串或0作为默认值是一种常用的做法。这个约束使得处理器很难表现一个元素的存在或缺失的状态， 
  25.  * 因为每个注解的声明中，所有元素都存在，并且都具有相应的值，为了绕开这个约束，我们只能定义一些特殊的值["",-1]等， 
  26.  * 例如空字符串或者负数，一次表示某个元素不存在，在定义注解时，这已经成为一个习惯用法。 
  27.  *  
  28.  * 定义了注解，并在需要的时候给相关类，类属性加上注解信息，如果没有响应的注解信息处理流程， 
  29.  * 注解可以说是没有实用价值。如何让注解真真的发挥作用，主要就在于注解处理方法 
  30.  *  
  31.  * @Target注解参数 
  32.  * 1.CONSTRUCTOR:构造函数 
  33.  * 2.FIELD:字段，枚举常量 
  34.  * 3.LOCAL_VARIABLE:局部变量 
  35.  * 4.METHOD:方法 
  36.  * 5.PACKAGE:包 
  37.  * 6.PARAMETER:方法参数 
  38.  * 7.TYPE:接口，类，枚举，注解 
  39.  *  
  40.  * 下面就开始定义一个@People的注解 
  41.  */  
  42.   
  43. @Documented  
  44. @Retention(RetentionPolicy.RUNTIME)  
  45. @Target({ElementType.TYPE,ElementType.METHOD})  
  46. public @interface People {  
  47.       
  48.     //定义一个枚举，（男人，女人，好人，坏人，大人，小人）  
  49.     public enum PeopleType{MAN, WOMAN, GOODMAN, BADMAN, BIGMAN, SMALLMAN}  
  50.     //定义了一个注解参数：人的类型，默认为男人  
  51.     public PeopleType type() default PeopleType.MAN;  
  52.       
  53.     public String name() default "";  
  54.     //此参数没有指定default，所以用@People注解的时候必须指定该参数  
  55.     public int age();  
  56.       
  57.     public String[] fruitColor() default { "red", "black" };  
  58.       
  59. }  

2、解析注解

[java]
view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.kute.test.selfannotation;  
  2.   
  3. import java.lang.reflect.Method;  
  4.   
  5. import org.slf4j.Logger;  
  6. import org.slf4j.LoggerFactory;  
  7. import org.springframework.beans.BeansException;  
  8. import org.springframework.beans.factory.InitializingBean;  
  9. import org.springframework.beans.factory.config.BeanPostProcessor;  
  10. import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;  
  11. import org.springframework.util.ReflectionUtils;  
  12.   
  13. import com.kute.test.selfannotation.People.PeopleType;  
  14.   
  15. public class AnnotionParse {  
  16.   
  17.     private static Logger logger = LoggerFactory.getLogger(AnnotionParse.class);  
  18.   
  19.     public void parse(Class clazz) {  
  20.         try {  
  21.             Object clasz = clazz.getConstructor(new Class[] {}).newInstance(  
  22.                     new Object[] {});  
  23.             // clasz类上是否标注有People这个注解  
  24.             if (null != clasz.getClass().getAnnotation(People.class)) {  
  25.                 Method[] methods = clasz.getClass().getDeclaredMethods();  
  26.                 for (Method method : methods) {  
  27.                     // annotation是方法上的注解  
  28.                     People people = method.getAnnotation(People.class);  
  29.                     if (null != people) {  
  30.                         // 得到注解上的type参数的值  
  31.                         Object oType = people.type();  
  32.                         Object oName = people.name();  
  33.                         int oAge = people.age();  
  34.                         String[] fruitColor = people.fruitColor();  
  35.   
  36.                         StringBuffer buffer = new StringBuffer();  
  37.                         for (String s : fruitColor)  
  38.                             buffer.append(s + ",");  
  39.   
  40.                         logger.info("取出了方法的参数：[oType:" + oType + "],[oName:"  
  41.                                 + oName + "],[oAge:" + oAge + "],[fruitColor:"  
  42.                                 + buffer.toString() + "]");  
  43.   
  44.                         // 判断oType的类型是否是要指定的类型  
  45.                         if (method.getParameterTypes()[0]  
  46.                                 .equals("com.kute.test.selfannotation.People.PeopleType")) {  
  47.                             oType = (PeopleType) oType;  
  48.                         }  
  49.                         if (method.getParameterTypes()[1]  
  50.                                 .equals("java.lang.String")) {  
  51.                             oName = oName.toString();  
  52.                         }  
  53.                         // 反射调用方法并传递参数  
  54.                         ReflectionUtils.invokeMethod(method, clasz,  
  55.                                 new Object[] { oType, oName, oAge, fruitColor });  
  56.                     }  
  57.                 }  
  58.             }  
  59.         } catch (Exception e) {  
  60.             e.printStackTrace();  
  61.         }  
  62.     }  
  63. }  

3、应用注解

[java]
view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.kute.test.selfannotation;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. import org.slf4j.Logger;  
  6. import org.slf4j.LoggerFactory;  
  7.   
  8. import com.kute.test.selfannotation.People.PeopleType;  
  9.   
  10. @People(age = 20)  
  11. public class Student implements Serializable {  
  12.   
  13.     private static final long serialVersionUID = 1L;  
  14.     private static Logger logger = LoggerFactory.getLogger(Student.class);  
  15.   
  16.     @People(type = PeopleType.GOODMAN, name = "kute", age = 18, fruitColor = {  
  17.             "blue", "white", "green" })  
  18.     public void setValue(PeopleType stuType, String stuName, int stuAge,  
  19.             String[] fruitColor) {  
  20.   
  21.         StringBuffer buffer = new StringBuffer();  
  22.         for (String color : fruitColor)  
  23.             buffer.append(color + ",");  
  24.         logger.info("成功调用了方法并注入了参数:[" + stuType + "," + stuAge + "," + stuName  
  25.                 + ", {" + buffer.toString() + "} ]");  
  26.     }  
  27.   
  28. }  

4、测试

[java]
view plaincopy在CODE上查看代码片派生到我的代码片
  1. package test;  
  2.   
  3. import org.junit.Test;  
  4.   
  5. import com.kute.test.selfannotation.AnnotionParse;  
  6. import com.kute.test.selfannotation.Student;  
  7.   
  8. public class TestAnnotationParse {  
  9.       
  10.     @Test  
  11.     public void test() {  
  12.         AnnotionParse parse = new AnnotionParse();  
  13.         parse.parse(Student.class);  
  14.     }  
  15. }  

5、运行结果

[java]
view plaincopy在CODE上查看代码片派生到我的代码片
  1. 28 [main] INFO com.kute.test.selfannotation.AnnotionParse - 取出了方法的参数：[oType:GOODMAN],[oName:kute],[oAge:18],[fruitColor:blue,white,green,]  
  2. 28 [main] INFO com.kute.test.selfannotation.Student - 成功调用了方法并注入了参数:[GOODMAN,18,kute, {blue,white,green,} ] 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞