## Java专题十八：注解
[TOC]
### 18.1. 元注解
| 所在包 | 类名 | 描述 |
| --- | --- | --- |
| java.lang | `Override` | 表示此方法是重写的，如果父类或接口中不含该方法，则编译报错|
| java.lang| `Deprecated` |表示方法已过时，不鼓励使用，因为方法是危险的或者有其它更好的方法选择，在程序中使用该方法，会报编译警告|
| java.lang | `SuppressWarnings` |告诉编译器忽略掉注解中声明的警告|
| java.lang.annotation | `Documented` |表示可以包含在javadoc等工具生成的文档中|
| java.lang.annotation | `Inherited` |表示注解类型会被继承到子类中|
| java.lang.annotation | `Retention` |表示注解类型要保留多久，取值于枚举类`java.lang.annotation.RetentionPolicy`|
| java.lang.annotation | `Target` |表示注解适用那种Java成员，取值于枚举类`java.lang.annotation.ElementType`|
| java.lang.annotation | `Native` |表示一个字段定义常量值引用自native代码，1.8新增|
| java.lang.annotation | `Repeatable` |表示注解可以声明多次的，1.8新增|
枚举类`java.lang.annotation.RetentionPolicy`：
~~~
public enum RetentionPolicy {
/**
* Annotations are to be discarded by the compiler.
*/
SOURCE,
/**
* Annotations are to be recorded in the class file by the compiler
* but need not be retained by the VM at run time. This is the default
* behavior.
*/
CLASS,
/**
* Annotations are to be recorded in the class file by the compiler and
* retained by the VM at run time, so they may be read reflectively.
*
* @see java.lang.reflect.AnnotatedElement
*/
RUNTIME
}
~~~
枚举类`java.lang.annotation.ElementType`：
~~~
public enum ElementType {
/** Class, interface (including annotation type), or enum declaration */
TYPE,
/** Field declaration (includes enum constants) */
FIELD,
/** Method declaration */
METHOD,
/** Formal parameter declaration */
PARAMETER,
/** Constructor declaration */
CONSTRUCTOR,
/** Local variable declaration */
LOCAL_VARIABLE,
/** Annotation type declaration */
ANNOTATION_TYPE,
/** Package declaration */
PACKAGE,
/**
* Type parameter declaration
*
* @since 1.8
*/
TYPE_PARAMETER,
/**
* Use of a type
*
* @since 1.8
*/
TYPE_USE
}
~~~
### 18.2. 自定义注解
> 假设我们设计一个数据库Helper类，用于JDBC插入数据，实现类似mybatis的ORM模型
首先定义2个注解，注解`Table`标识数据库中表，适用于`TYPE`类上，注解`Column`标识数据库中的列，适用于`FIELD`字段上
~~~
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Table {
String value();
}
~~~
~~~
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {
String value();
}
~~~
现在有2个`javabean`类，`Student`类和`Book`类
因为数据库中的字段与我们实体类中字段名字可能不一致，因此我们使用注解标识实体类与数据库中相关字段的对应关系
~~~
@Table("student")
public class Student {
@Column(value = "std_id")
int id;
@Column(value = "std_name")
String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
~~~
~~~
@Table("book")
public class Book {
@Column("book_name")
String name;
@Column("book_author")
String author;
@Column("price")
int price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}
~~~
使用反射获取字段的值，使用注解获取数据库中字段的名字，拼接SQL语句
~~~
import java.lang.reflect.Field;
import java.util.logging.Level;
import java.util.logging.Logger;
public class SQLHelper<T> {
final Logger logger = Logger.getLogger(SQLHelper.class.getName());
public int insert(T t){
if (null == t){
throw new NullPointerException();
}
StringBuilder builder = new StringBuilder();
Class cls = t.getClass();
Table table = (Table)cls.getAnnotation(Table.class);
String tableName = table.value();
Field[] fields = cls.getDeclaredFields();
if (0 == fields.length) {
throw new NullPointerException("No Field");
} else if (1 == fields.length) {
String columnName = fields[0].getAnnotation(Column.class).value();
Object columnValue = null;
try{
columnValue = fields[0].get(t);
if (columnValue instanceof String){
columnValue = "\"" + columnValue + "\"";
}
}catch (IllegalAccessException e){
columnValue = "NULL";
}
builder.append("INSERT INTO ").append(tableName)
.append(" (").append(columnName).append(") ")
.append("VALUES(").append(columnValue).append(");");
} else {
StringBuilder columnNames = new StringBuilder();
StringBuilder columnValues = new StringBuilder();
for (int i = 0; i < fields.length; i++) {
Column column = fields[i].getAnnotation(Column.class);
if (null == column)
throw new NullPointerException("Unknown Column");
if (i != fields.length - 1) {
columnNames.append(column.value()).append(", ");
Object columnValue = null;
try{
columnValue = fields[i].get(t);
if (columnValue instanceof String){
columnValue = "\"" + columnValue + "\"";
}
}catch (IllegalAccessException e){
columnValue = "NULL";
}
columnValues.append(columnValue).append(", ");
}
else {
columnNames.append(column.value());
Object columnValue = null;
try{
columnValue = fields[i].get(t);
if (columnValue instanceof String){
columnValue = "\"" + columnValue + "\"";
}
}catch (IllegalAccessException e){
columnValue = "NULL";
}
columnValues.append(columnValue);
}
}
builder.append("INSERT INTO ").append(tableName)
.append("(").append(columnNames).append(") ")
.append("VALUES(").append(columnValues).append(");");
}
return insert0(builder.toString());
}
private int insert0(String sql){
logger.log(Level.INFO, sql);
//System.out.println(sql);
return 1;
}
}
~~~
使用如下代码验证：
~~~
Book book0 = new Book();
book0.setName("Thinking in java");
book0.setAuthor("Json");
book0.setPrice(80);
new SQLHelper<Book>().insert(book0);
Student student = new Student();
student.setId(1637);
student.setName("Tom");
new SQLHelper<Student>().insert(student);
~~~
输出：
```
四月 14, 2020 1:24:08 上午 SQLHelper insert0
信息: INSERT INTO book(book_name, book_author, price) VALUES("Thinking in java", "Json", 80);
四月 14, 2020 1:24:08 上午 SQLHelper insert0
信息: INSERT INTO student(std_id, std_name) VALUES(1637, "Tom");
```
- JavaCook
- Java专题零：类的继承
- Java专题一：数据类型
- Java专题二：相等与比较
- Java专题三：集合
- Java专题四：异常
- Java专题五：遍历与迭代
- Java专题六：运算符
- Java专题七：正则表达式
- Java专题八：泛型
- Java专题九：反射
- Java专题九（1）：反射
- Java专题九（2）：动态代理
- Java专题十：日期与时间
- Java专题十一：IO与NIO
- Java专题十一（1）：IO
- Java专题十一（2）：NIO
- Java专题十二：网络
- Java专题十三：并发编程
- Java专题十三（1）：线程与线程池
- Java专题十三（2）：线程安全与同步
- Java专题十三（3）：内存模型、volatile、ThreadLocal
- Java专题十四：JDBC
- Java专题十五：日志
- Java专题十六：定时任务
- Java专题十七：JavaMail
- Java专题十八：注解
- Java专题十九：浅拷贝与深拷贝
- Java专题二十：设计模式
- Java专题二十一：序列化与反序列化
- 附加专题一：MySQL
- MySQL专题零：简介
- MySQL专题一：安装与连接
- MySQL专题二：DDL与DML语法
- MySQL专题三：工作原理
- MySQL专题四：InnoDB存储引擎
- MySQL专题五：sql优化
- MySQL专题六：数据类型
- 附加专题二：Mybatis
- Mybatis专题零：简介
- Mybatis专题一：配置文件
- Mybatis专题二：映射文件
- Mybatis专题三：动态SQL
- Mybatis专题四：源码解析
- 附加专题三：Web编程
- Web专题零：HTTP协议
- Web专题一：Servlet
- Web专题二：Cookie与Session
- 附加专题四：Redis
- Redis专题一：数据类型
- Redis专题二：事务
- Redis专题三：key的过期
- Redis专题四：消息队列
- Redis专题五：持久化