全面解析Java注解

为什么学习注解？学习注解有什么好处？学完能做什么？

能够读懂别人写的代码，特别是框架相关的代码

让编程更加简洁，代码更加清晰

JDK 中常见的注解

@Override 表示当前方法覆盖了父类的方法

@Deprecation 表示方法已经过时,方法上有横线，会有警告。

@SuppviseWarnings 表示关闭一些警告信息(通知java编译器忽略特定的编译警告)

常见的第三方注解

Spring：

@Autowired 自动装配 Bean

@Component 基本注解, 标识了一个受 Spring 管理的组件

@Respository 标识持久层组件

@Service 标识服务层(业务层)组件

@Controller 标识表现层组件

Mybatis：

@InsertProvider@UpdateProvider@DeleteProvider@SelectProvider 允许创建动态 SQL。这些可选的 SQL 注解允许你指定一个类名和一个方法在执行时来返回运行 的 SQL

@Options 映射语句的属性

注解的分类

按照运行机制分

源码注解：注解只在源码中存在，编译成.class文件就不存在了

编译时注解：注解在源码和.class文件中都存在（如：JDK内置系统注解）

按照来源分

JDK内置系统注解、元注解、自定义注解、第三方注解

元注解：注解的注解

自定义注解

语法格式

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//下面四行为元注解（注解的注解）
/*
* Target 注解的作用域
* 包括 CONSTRUCTOR（构造方法声明）、FIELD（字段声明）、LOCAL_VARIABLE（局部变量声明）、METHOD（方法声明）、PACKAGE（包声明）、PARAMETER（参数声明）、TYPE（类和接口）
*/
@Target({ElementType.METHOD,ElementType.TYPE})
/*
* Retention 生命周期
* 包括 SOURCE（只在源码显示，编译时会丢弃）、CLASS（编译时会记录到class中，运行时忽略）、RUNTIME（运行时存在，可以通过反射读取）
*/
@Retention(RetentionPolicy.RUNTIME)
/*
* Inherited 允许子类继承
*/
@Inherited
/*
* Documented 生成JavaDoc 时会包含注解信息
*/
@Documented
//使用 @interface 关键字定义注解
public @interface Description {
//成员类型是受限的，合法的类型包括原始类型及String，Class，Annotation，Enumeration
//成员以无参无异常方式声明
String desc();
//如果注解只有一个成员，则成员名必须取名为value()，在使用时可以忽略成员名和赋值号（=）
String author();
//可以用default为成员指定一个默认值
int age() default 18;
//注解类可以没有成员，没有成员的注解称为标识注解
}

使用自定义注解

/*
* 使用注解的语法
* @<注解名>(<成员名1>=<成员值1>,<成员名2>=<成员值2>,...)
*/
@Description(desc="I am eyeColor",author="Mooc boy",age=18)
public String eyeColor() {
return "red";
}

解析注解

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class ParseAnn {
public static void main(String[] args) throws ClassNotFoundException {
//1. 使用类加载器加载类
Class c = Class.forName("com.ann.test.Child");
//2. 找到类上面的注解
boolean isExist = c.isAnnotationPresent(Description.class);
if(isExist) {
//3. 拿到注解实例
Description d = (Description) c.getAnnotation(Description.class);
System.out.println(d.value());
}

//4. 找到方法上的注解
Method[] ms = c.getMethods();
for(Method m : ms) {
boolean isMExist =  m.isAnnotationPresent(Description.class);
if(isMExist) {
Description d = m.getAnnotation(Description.class);
System.out.println(d.value());
}
}
//另外一种解析方法
for(Method m : ms) {
Annotation[] as = m.getAnnotations();
for(Annotation a : as) {
Description d = (Description) a;
System.out.println(d.value());
}
}
}
}
//通过反射获取类、函数或成员上的运行时注解信息，从而实现动态控制程序运行的逻辑

代码案例，Java 注解 hibernate ORM

@Table("student")
public class Filter {

@Column("id")
private int stuId;
@Column("name")
private String stuName;
@Column("email")
private String email;

public int getStuId() {
return stuId;
}
public void setStuId(int stuId) {
this.stuId = stuId;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String value();
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
public String value();
}

public class Test {
public static void main(String[] args) {

Filter f1 = new Filter();
f1.setStuId(10);

Filter f2 = new Filter();
f2.setStuId(10);
f2.setStuName("baoyou");

Filter f3 = new Filter();
f3.setEmail("1223716098@qq.com,curiousby@163.com");

String sql1 = query(f1);
String sql2 = query(f2);
String sql3 = query(f3);

System.out.println(sql1);
System.out.println(sql2);
System.out.println(sql3);
}
private static String query(Filter f) {
StringBuffer sb = new StringBuffer();
Class c=  f.getClass();
boolean isExist = c.isAnnotationPresent(Table.class);
if (!isExist) {
return null;
}
Table t = (Table) c.getAnnotation(Table.class);
String  tableName = t.value();
sb.append(" select * from ").append(tableName).append(" 1=1 ");
Field[] fArray = c.getDeclaredFields();
for (Field field : fArray) {
boolean fExist = field.isAnnotationPresent( Column.class);
if (!fExist) {
continue;
}
Column column = field.getAnnotation(Column.class);
String columnName = column.value();
String fieldName = field.getName();
String getMethodName = "get" +fieldName.substring(0, 1).toUpperCase()+fieldName.substring(1);
Object fieldValue=null;
try {
Method getMethod =c.getMethod(getMethodName);
fieldValue = getMethod.invoke(f);
} catch (Exception e) {
}
if (fieldValue == null || (fieldValue instanceof Integer && (Integer)fieldValue == 0) ) {
continue;
}
sb.append(" and ").append( columnName );
if (fieldValue instanceof String){
if (((String) fieldValue ).contains(",")) {
String[] values = ((String) fieldValue ).split(",");
sb.append(" in ( ");
for (String v : values) {
sb.append("'").append(v).append("',");
}
sb.deleteCharAt(sb.length()-1);
sb.append(" )");
} else{
sb.append(" = '").append(fieldValue).append("' ");
}
}else if (fieldValue instanceof Integer){
sb.append(" = ").append(fieldValue).append(" ");
}
}
return sb.toString();
}
}