十六、java注解

注意:一般情况下用不到java自定义注解功能,这是因为我们一般是在别人定义好的框架下面运行程序,只要掌握了别人定义好的框架的运行规律和运行规则就已经足够了

 

 

@是java注解,即annotation。

1可以理解为插件,是代码级别的插件,在类的方法上写:@XXX,就是在代码上插入了一个插件。

2Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。
注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用

3要先学习java的反射机制,然后再来理解java注解

 

5自定义注解:

 

java自定义注解

Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。
注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

1、元注解

元注解是指注解的注解。包括  @Retention @Target @Document @Inherited四种。


1.1、@Retention: 定义注解的保留策略

@Retention(RetentionPolicy.SOURCE)   //注解仅存在于源码中,在class字节码文件中不包含

@Retention(RetentionPolicy.CLASS)     // 默认的保留策略,注解会在class字节码文件中存在,但运行时无法获得,

@Retention(RetentionPolicy.RUNTIME)  // 注解会在class字节码文件中存在,在运行时可以通过反射获取到

 

自定义的注解类:

[java] view plain copy    

  1. @Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在,在运行时可以通过反射获取到  
  2. @Target({ElementType.FIELD,ElementType.METHOD})//定义注解的作用目标**作用范围字段、枚举的常量/方法  
  3. @Documented//说明该注解将被包含在javadoc中  
  4. public @interface FieldMeta {  
  5.   
  6.     /** 
  7.      * 是否为序列号 
  8.      * @return 
  9.      */  
  10.     boolean id() default false;  
  11.     /** 
  12.      * 字段名称 
  13.      * @return 
  14.      */  
  15.     String name() default "";  
  16.     /** 
  17.      * 是否可编辑 
  18.      * @return 
  19.      */  
  20.     boolean editable() default true;  
  21.     /** 
  22.      * 是否在列表中显示 
  23.      * @return 
  24.      */  
  25.     boolean summary() default true;  
  26.     /** 
  27.      * 字段描述 
  28.      * @return 
  29.      */  
  30.     String description() default "";  
  31.     /** 
  32.      * 排序字段 
  33.      * @return 
  34.      */  
  35.     int order() default 0;  
  36. }  

 

 

 

6自定义注解有什么用?

这个例子很有代表性,读懂就明白了。

 

http://blog.csdn.net/tengdazhang770960436/article/details/37886361

本例子旨在使用自定义注解为实体打上标记,为自动生成 sql 提供依据,模拟 hibernate 的注解,至于注解的原理自己搜吧

1.定义 Table 注解

 

[java] view plain copy

  1. package test;  
  2.   
  3. import java.lang.annotation.Documented;  
  4. import java.lang.annotation.ElementType;  
  5. import java.lang.annotation.Inherited;  
  6. import java.lang.annotation.Retention;  
  7. import java.lang.annotation.RetentionPolicy;  
  8. import java.lang.annotation.Target;  
  9.   
  10. @Inherited  
  11. @Target({ElementType.TYPE})  
  12. @Retention(RetentionPolicy.RUNTIME)  
  13. @Documented  
  14. public @interface Table {  
  15.     String value() default "";  
  16. }  

2.定义 Column 注解

 

 

[java] view plain copy

  1. package test;  
  2.   
  3. import java.lang.annotation.Documented;  
  4. import java.lang.annotation.ElementType;  
  5. import java.lang.annotation.Inherited;  
  6. import java.lang.annotation.Retention;  
  7. import java.lang.annotation.RetentionPolicy;  
  8. import java.lang.annotation.Target;  
  9.   
  10. @Inherited  
  11. @Target({ElementType.FIELD})  
  12. @Retention(RetentionPolicy.RUNTIME)  
  13. @Documented  
  14. public @interface Column {  
  15.     String value() default "";  
  16. }  

3.定义使用注解的实体

 

 

[java] view plain copy

  1. package test;  
  2.   
  3.   
  4. @Table("tb_test")  
  5. public class TestDto {  
  6.       
  7.     @Deprecated  
  8.     private String tt;  
  9.       
  10.     @Column("_id")  
  11.     private String id;  
  12.       
  13.     @Column("username")  
  14.     private String name;  
  15.       
  16.     public TestDto(String id, String name) {  
  17.         super();  
  18.         this.id = id;  
  19.         this.name = name;  
  20.     }  
  21.   
  22.     public String getId() {  
  23.         return id;  
  24.     }  
  25.   
  26.     public void setId(String id) {  
  27.         this.id = id;  
  28.     }  
  29.   
  30.     public String getName() {  
  31.         return name;  
  32.     }  
  33.   
  34.     public void setName(String name) {  
  35.         this.name = name;  
  36.     }  
  37.       
  38.       
  39. }  

4.测试注解

 

 

[java] view plain copy

  1. package test;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.lang.reflect.Method;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         TestDto testDto = new TestDto("123""34");  
  9.         TestDto testDto1 = new TestDto("123""test1");  
  10.         TestDto testDto2 = new TestDto("""test1,test2,test3,test4");  
  11.         String sql = assembleSqlFromObj(testDto);  
  12.         String sql1 = assembleSqlFromObj(testDto1);  
  13.         String sql2 = assembleSqlFromObj(testDto2);  
  14.         System.out.println(sql);  
  15.         System.out.println(sql1);  
  16.         System.out.println(sql2);  
  17.     }  
  18.   
  19.     /** 
  20.      * 通过注解来组装查询条件,生成查询语句 
  21.      *  
  22.      * @param obj 
  23.      * @return 
  24.      */  
  25.     public static String assembleSqlFromObj(Object obj) {  
  26.         Table table = obj.getClass().getAnnotation(Table.class); //通过对象,获取该对象的类的相关信息(类的相关信息包括:①用了什么注解 ②类的名称 ③各成员变量的名称等。本例中是通过对象testDto、testDto1、testDto2获取类的名为“Table”的注解),这里就用到了java的反射机制。
  27.         StringBuffer sbSql = new StringBuffer();  
  28.         String tableName = table.value();  //获取成员变量“value”
  29.         sbSql.append("select * from " + tableName + " where 1=1 ");  
  30.         Field[] fileds = obj.getClass().getDeclaredFields();  
  31.         for (Field f : fileds) {  
  32.             String fieldName = f.getName();  
  33.             String methodName = "get" + fieldName.substring(01).toUpperCase()  
  34.                     + fieldName.substring(1);  
  35.             try {  
  36.                 Column column = f.getAnnotation(Column.class);  
  37.                 if (column != null) {  
  38.                     Method method = obj.getClass().getMethod(methodName);  
  39.                     String value = (String) method.invoke(obj);  
  40.                     if (value != null && !value.equals("")) {  
  41.                         if (!isNum(column.value()) && !isNum(value)) {  
  42.                             // 判断参数是不是 in 类型参数 1,2,3  
  43.                             if (value.contains(",")) {  
  44.                                 sbSql.append(" and " + column.value() + " in (" + value + ") ");  
  45.                             } else {  
  46.                                 sbSql.append(" and " + column.value() + " like '%" + value + "%' ");  
  47.                             }  
  48.                         } else {  
  49.                             sbSql.append(" and " + column.value() + "=" + value + " ");  
  50.                         }  
  51.                     }  
  52.                 }  
  53.             } catch (Exception e) {  
  54.                 e.printStackTrace();  
  55.             }  
  56.         }  
  57.         return sbSql.toString();  
  58.     }  
  59.   
  60.     /** 
  61.      * 检查给定的值是不是 id 类型 1.检查字段名称 2.检查字段值 
  62.      *  
  63.      * @param target 
  64.      * @return 
  65.      */  
  66.     public static boolean isNum(String target) {  
  67.         boolean isNum = false;  
  68.         if (target.toLowerCase().contains("id")) {  
  69.             isNum = true;  
  70.         }  
  71.         if (target.matches("\\d+")) {  
  72.             isNum = true;  
  73.         }  
  74.         return isNum;  
  75.     }  
  76. }  

测试结果:

 

select * from tb_test where 1=1  and _id=123  and username=34 
select * from tb_test where 1=1  and _id=123  and username like '%test1%' 
select * from tb_test where 1=1  and username in (test1,test2,test3,test4) 

 

==========

该例子解析:

1本例子是编写了一个简单的类似于Hibernate的框架,框架的作用是,通过对象的操作的方式,替代写sql语句。

2本例用到了映射机制,什么是java映射?我理解就是:通过类的对象,获取该对象的类的相关信息。obj.getClass().getAnnotation(Table.class)

3注解起到配置文件的作用:

 

  1. @Table("tb_test")  
  2. public class TestDto { 
  1.  
意思是,我想将TestDto类和tb_test表绑定起来。

 

 

首先new了一个TestDto对象如testDto1,然后进入我的框架(说白了就是文中的assembleSqlFromObj方法)对testDto1进行处理,通过testDto1获取该对象的类即TestDto.Class,然后获取该类的名为“Table”的注解,获取注解类的成员变量(即value)的值,即“tb_test”。

 

 

 

 

 

总结:

1java的反射机制就是,通过类的对象,获取该对象的类的相关信息。类的相关信息包括:①用了什么注解 ②类的名称 ③各成员变量的名称等。

2什么时候用到注解?我们一般用不到自定义注解,我们平时别人开发好的框架如Hibernate、Spring、Struts等时,只需要按照框架的规则在代码里定义注解即可,而不会在代码里调用和操作注解。只有在自己动手写类似于Hibernate框架的时候,会用到自定义注解。这也是为什么我们一般用不到java反射,因为只有在使用自定义注解的时候,才会用到java反射,而我们平时连自定义注解都用不到

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值