设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java 注解Annotation

2016-12-20 13:13| 发布者: zhangjf| 查看: 428| 评论: 0

摘要: 1.创建一个注解 创建注解跟接口差不多，不过要在interface前加个@，可以用default在方法后面设置默认值，方法的返回类型包括基本类型、String、Class、enum、Annotation、以上类型数组。还要通过元注解(@Retention ...

1.创建一个注解

创建注解跟接口差不多，不过要在interface前加个@，可以用default在方法后面设置默认值，方法的返回类型包括基本类型、String、Class、enum、Annotation、以上类型数组。还要通过元注解(@Retention、@Target)定义其作用域、有效范围。举一个例子

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({ElementType.ANNOTATION_TYPE})
  3. public @interface demo{
  4. public int value();//只有当value()是唯一需要使用时赋值，才可以这样简写@demo(0)
  5. public String bbb() default "demo";
  6. public Class<?> ccc() default Date.class;
  7. public ElementType ddd() default ElementType.TYPE;
  8. public Target eee() default @Target(value = { ElementType.TYPE });
  9. public char[] fff() default {'a','b'};
  10. }
复制代码


2.元注解

元注解专职负责注解其他注解，共四种 @Target、@Retention、@Documented（将此注解包含在Javadoc中）、@Inherited(允许子类继承父类)，其实元注解跟泛型的通配符（？）差不多概念。先介绍下注解中用到的两个枚举参数

元注解@Target的参数

  1. public enum ElementType
  2. {// 分别表示的作用范围
  3. TYPE, // 类、接口、注解、泛型
  4. FIELD, // 域
  5. METHOD, // 方法
  6. PARAMETER, // 参数
  7. CONSTRUCTOR, // 构造方法
  8. LOCAL_VARIABLE, // 局部变量
  9. ANNOTATION_TYPE, // 应用于另一个注解上
  10. PACKAGE; // 包
  12. private ElementType() {}
  13. }
复制代码

元注解@Retention的参数

  1. public enum RetentionPolicy
  2. {
  3. SOURCE, //注解将被编译器丢弃
  4. CLASS, //保存在class文件中，VM 丢弃
  5. RUNTIME; //运行时保留，可通过反射获取
  7. private RetentionPolicy() {}
  8. }
复制代码

元注解@Target，表示该注解可以用在什么地方

  1. @Documented
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target({ElementType.ANNOTATION_TYPE})
  4. public @interface Target
  5. {
  6. ElementType[] value();
  7. }
复制代码

元注解@Retention，注解的保存级别

  1. @Documented
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target({ElementType.ANNOTATION_TYPE})
  4. public @interface Retention
  5. {
  6. RetentionPolicy value();
  7. }
复制代码

3. Java内置注解

@Override, 表示当前方法覆盖父类中的方法，如果父类没有该方法，编译器错误

  1. //源码
  2. @Target({ElementType.METHOD})
  3. @Retention(RetentionPolicy.SOURCE)
  4. public @interface Override {}
复制代码

@Deprecated, 用这个标注方法，就会出现一条横线，方法就基本废了

  1. //源码
  2. @Documented
  3. @Retention(RetentionPolicy.RUNTIME)
  4. @Target({ElementType.CONSTRUCTOR,
  5. ElementType.FIELD,
  6. ElementType.LOCAL_VARIABLE,
  7. ElementType.METHOD,
  8. ElementType.PACKAGE,
  9. ElementType.PARAMETER,
  10. ElementType.TYPE})
  11. public @interface Deprecated {}
复制代码

@SuppressWarnings({"all"}) 消除警告用

  1. //源码
  2. @Target({ElementType.TYPE,
  3. ElementType.FIELD,
  4. ElementType.METHOD,
  5. ElementType.PARAMETER,
  6. ElementType.CONSTRUCTOR,
  7. ElementType.LOCAL_VARIABLE})
  8. @Retention(RetentionPolicy.SOURCE)
  9. public @interface SuppressWarnings {
  10. String[] value();// 这个数组的参数在下面
  11. }
复制代码
关键字 用途
all to suppress all warnings
boxing to suppress warnings relative to boxing/unboxing operations
cast to suppress warnings relative to cast operations
dep-ann to suppress warnings relative to deprecated annotation
deprecation to suppress warnings relative to deprecation
fallthrough to suppress warnings relative to missing breaks in switch statements
finally to suppress warnings relative to finally block that don’t return
hiding to suppress warnings relative to locals that hide variable
incomplete-switch to suppress warnings relative to missing entries in a switch statement (enum case)
nls to suppress warnings relative to non-nls string literals
null to suppress warnings relative to null analysis
rawtypes to suppress warnings relative to un-specific types when using generics on class params
restriction to suppress warnings relative to usage of discouraged or forbidden references
serial to suppress warnings relative to missing serialVersionUID field for a serializable class
static-access o suppress warnings relative to incorrect static access
synthetic-access to suppress warnings relative to unoptimized access from inner classes
unchecked to suppress warnings relative to unchecked operations
unqualified-field-access to suppress warnings relative to field access unqualified
unused to suppress warnings relative to unused code


下面举一个栗子

  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  5. import java.lang.reflect.InvocationHandler;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Proxy;
  8. import java.util.Collections;
  9. import java.util.LinkedList;
  10. import java.util.Queue;
  12. public class AnnotationTest implements InvocationHandler {
  13. private Object obj;
  15. public AnnotationTest(Object obj) {
  16. this.obj = obj;
  17. }
  19. // ----------------定义注解--------------------
  20. // 让此枚举保留到运行时
  21. @Retention(RetentionPolicy.RUNTIME)
  22. // 用在方法上
  23. @Target({ ElementType.METHOD })
  24. public @interface Transaction {
  25. public boolean value() default true;
  26. }
  28. // ---------------定义一个接口------------------
  29. public interface IDao {
  30. @Transaction
  31. // 使用注解
  32. public void remove();
  33. }
  35. // --------------实现接口---------------------
  36. public static class DaoImpl implements IDao {
  37. Queue<String> queue;
  39. public DaoImpl(Queue<String> queue) {
  40. this.queue = queue;
  41. }
  43. @Override
  44. public void remove() {
  45. // 删除报错，要求回滚
  46. if (queue.peek().equals("stop")) {
  47. throw new NullPointerException();
  48. }
  49. System.err.println(queue.poll());
  50. }
  51. }
  53. // --------------得到代理类---------------------
  54. public Object getProxy() {
  55. return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(), this);
  56. }
  58. @Override
  59. public Object invoke(Object paramObject, Method paramMethod,
  60. Object[] paramArrayOfObject) throws Exception {
  61. // 取方法上面的注解Transaction
  62. Transaction tran = paramMethod.getAnnotation(Transaction.class);
  63. boolean isTran = false;
  64. if (tran != null) {
  65. isTran = tran.value();// 判断是否需要事务
  66. }
  67. Object rtnObj = null;
  68. try {
  69. if(isTran){System.err.println("启动事务");}
  70. rtnObj = paramMethod.invoke(obj, paramArrayOfObject);
  71. if(isTran){System.err.println("提交事务");}
  72. }catch(Exception e){
  73. if(isTran){System.err.println("回滚事务");}
  74. throw e;
  75. }
  76. return rtnObj;
  77. }
  79. public static void main(String[] args) {
  80. Queue<String> queue = new LinkedList<String>();
  81. Collections.addAll(queue, "1", "stop", "2");
  83. AnnotationTest test = new AnnotationTest(new DaoImpl(queue));
  84. IDao dao = (IDao) test.getProxy();
  85. try {
  86. while (queue.peek() != null) {
  87. dao.remove();
  88. }
  89. } catch (Exception e) {
  90. System.out.println("-----------------");
  91. for (String str : queue) {
  92. System.out.println(str);
  93. }
  94. }
  95. }
  96. }
复制代码

输出：


启动事务
1
提交事务
启动事务
回滚事务
-----------------
stop
2

转自：http://flyouwith.iteye.com/blog/2174420

收藏 邀请
上一篇：Linux与JVM的内存关系分析下一篇：Java 9中新的货币API

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-8 03:06

Copyright 2015-2025 djqfx

返回顶部