1、注解 Annotation

也称为元数据，和注释 comment 的区别：Annotation 可以提供编译期的一些操作，比如类型检查。Annotation 是Java 5 引入的新特性。Java 5 在 java.lang 中内置了三种标准注解。

@Override：表示当前方法其实是覆盖父类的方法

@Deprecated：表示该类或方法不建议使用了，未来有可能被废弃或者移除。

@SuppressWarnings：给编译器一条指令，告诉它对范围内的某些类型的警告保持静默。

同一个元素上可以使用多个不同注解。

2、自定义注解

因为 Java 内置的注解无法满足五花八门的需求，所以就需要我们自定义注解。

Java 内置了四种元注解，帮助申明自定义注解。

@Target：表示该注解可以使用在什么地方，参数是枚举类 ElementType：

TYPE：类，接口(包括注解类型)，枚举类

FIELD：字段，变量

METHOD：方法

PARAMETER：参数

CONSTRUCTOR：构造器

LOCAL_VARIABLE：局部变量

ANNOTATION_TYPE：注解

PACKAGE：包

TYPE_PARAMETER：自定义类型参数

TYPE_USE：该注解能使用在使用类型的任意语句中，使用方法见下图

TYPE_USE

@Retention：表示需要在什么级别保存该注解信息(生命周期)，参数 RetentionPolicy 包括

SOURCE：源码级别，注解将被编译器丢弃

CLASS：在编译器生成的 CLASS 文件中可用，但是会被 VM 丢弃。(默认的就是该级别)

RUNTIME：运行期保留该注解，所以此时可以通过反射机制来读取注解的信息

@Documented：将注解包含在 javadoc 中

@Inherited：允许子类继承父类的注解

自定义注解案列：

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface UseCase {

public int id();

public String description() default "no description";

}

public class PasswordUtils {

@UseCase(id = 47, description = "password must contain one number")

public boolean validatePassword(String password){

return true;

}

@UseCase(id = 48)

public String encryptPassword(String password){

return "encryptPassword()";

}

@UseCase(id = 49, description = "new password can't equal previously used ones")

public boolean checkouForNewPassword(){

return false;

}

}

配置参数可以使用的类型如下：

所有的基本类型。(int,float,boolean等)

String

Class

enum

Annotation

以上类型的数组

对于上面 UseCase 的demo，写一个程序来进行处理

public class UseCaseTracker {

public static void main(String[] args) {

// TODO Auto-generated method stub

List useCases = new ArrayList();

Collections.addAll(useCases, 47, 48, 49, 50);

trackUseCases(useCases, PasswordUtils.class);

}

public static void trackUseCases(List useCases, Class> cl) {

for (Method m : cl.getDeclaredMethods()){

// getDeclaredAnnotation 返回指定类型的 注解对象

UseCase uc = m.getDeclaredAnnotation(UseCase.class);

if (uc != null){

System.out.println("Found UseCase :" + uc.id() + "\t" + uc.description());

useCases.remove(new Integer(uc.id()));

}

}

System.out.println("--------------------------------------");

for (int i : useCases){

System.out.println("Warning : Miss use case --" + i);

}

}

}

结果如下：

Found UseCase :47 password must contain one number

Found UseCase :48 no description

Found UseCase :49 new password can't equal previously used ones

--------------------------------------

Warning : Miss use case --50

看一个复杂的案列

//告诉注解处理器，需要生成一个数据库表

//这个注解只能用于类，接口，enum

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

public @interface DBTable {

public String name() default "";

}

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Constraints {

//这些元素都有默认值，这样我们就不必强迫程序员必须赋值了

boolean primaryKey() default false;

boolean allowNull() default true;

boolean unique() default false;

}

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

public @interface SQLString {

//定义了元素名为value，在符合条件时，我们使用时，可以直接在括号内输入value的值就ok了。

int value() default 0;

String name() default "";

Constraints constraints() default @Constraints;

}

/**

* SQLInteger 和 SQLString一样，都是要求在javabean上，根据不同的数据类型使用不同的注解

*/

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

public @interface SQLInteger {

String name() default "";

//注解嵌套

Constraints constraints() default @Constraints;

}

/**

* 我们的目的就是为该javabean生成一个创建表的语句

*/

@DBTable(name = "MEMBER")

public class Member {

@SQLString(30)

String firstName;

@SQLString(50)

String lastName;

@SQLInteger

Integer age;

@SQLString(value = 30,

constraints = @Constraints(primaryKey = true))

String handle;

static int memberCount;

}

public class TableCreator {

public static void main(String[] args) throws Exception{

StringBuilder createCommand = new StringBuilder();

String className = "test.annotation.database.Member";

Class> cl = Class.forName(className);

DBTable dbTable = cl.getAnnotation(DBTable.class);

String tableName = dbTable.name();

//如果名字为空，就使用类名

if (tableName.length() < 1){

tableName = cl.getName().toUpperCase();

}

createCommand.append(

"CREATE TABLE " + tableName + "(");

List columnDefs = new ArrayList();

for (Field field : cl.getDeclaredFields()){

String columnName = null;

Annotation[] anns = field.getDeclaredAnnotations();

if (anns.length < 1){

continue;

}

//这里的写法之所以简单，因为我们每个Field上面最多只有一个 注解

if (anns[0] instanceof SQLInteger){

SQLInteger sInt = (SQLInteger)anns[0];

//没有名字的话，我们就使用Field的名字来做为 列名

if (sInt.name().length() < 1){

columnName = field.getName();

}else {

columnName = sInt.name();

}

columnDefs.add(columnName + " INT " + getConstraints(sInt.constraints()));

}

if (anns[0] instanceof SQLString){

SQLString sString = (SQLString)anns[0];

if (sString.name().length() < 1){

columnName = field.getName();

}else {

columnName = sString.name();

}

columnDefs.add(columnName + " VARCHAR(" + sString.value()

+ ")" + getConstraints(sString.constraints()));

}

}

for (String columnDef : columnDefs){

createCommand.append("\n\t" + columnDef + ",");

}

//移除最后的一个逗号

String tableCreate = createCommand.substring(0, createCommand.length()-1) + ");";

System.out.println("TABLE Creation SQL for " + className + " is: \n" + tableCreate);

}

//解析出 Constraints 注解的内容

private static String getConstraints(Constraints con){

String constraints = "";

if (!con.allowNull()){

constraints += " Not Null";

}

if (con.primaryKey()){

constraints += " PRIMARY KEY ";

}

if (con.unique()){

constraints += " NNIQUE ";

}

return constraints;

}

}

输出结果：

TABLE Creation SQL for test.annotation.database.Member is:

CREATE TABLE MEMBER(

firstName VARCHAR(30),

lastName VARCHAR(50),

age INT ,

handle VARCHAR(30) PRIMARY KEY );