感谢原文作者：yejg1212
原文链接
https://www.cnblogs.com/yejg1212/p/3187362.html
https://www.cnblogs.com/yejg1212/p/3188751.html
https://www.cnblogs.com/yejg1212/p/3188791.html
超通俗易懂的注解入门文章：https://blog.csdn.net/shengzhu1/article/details/81271409
Bilibili：https://www.bilibili.com/video/av55440782
Ⅰ. 简单介绍Jave的内置注解（7个：4个元注解）
Java从JDK 5开始引入注解（annotation）。
注解使得Java源代码中不但可以包含功能性的实现代码，还可以添加元数据。
注解的功能类似于代码中的注释，所不同的是注解不是提供代码功能的说明，而是实现程序功能的重要组成部分。
Java注解已经在很多框架中得到了广泛的使用，用来简化程序中的配置。
下面先来看看java中常用的注解。
一、常用注解
① @Override注解
package java.lang;
import java.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
@Override注解表示子类要重写父类的对应方法。
如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
顺便说一句：@override注解在JDK 5环境下只能用于对继承的类的方法的重写，实现接口中的方法不能用@override注解。但是JDK1.6可以。
② @Deprecated注解
package java.lang;
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}
@Deprecated注解表示方法是不被建议使用的。
③ @SuppressWarnings注解
package java.lang;
import java.lang.annotation.*;
import java.lang.annotation.ElementType;
import static java.lang.annotation.ElementType.*;
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
String[] value();
}
@SuppressWarnings注解表示抑制警告。
例如下面的代码，声明了2个未使用的变量，加上2个@SuppressWarnings来抑制警告。
@SuppressWarnings("unused")
int a=10;
@SuppressWarnings({ "rawtypes", "unused" })
List list =new ArrayList();
上面给出了Java自带的几个常用的注解，下面先来了解下代码中出现的诸如@Target,@Retention,@Documented(这些也叫元注解)的意义。
二、元注解
① @Target
@Target 表示该注解用于什么地方，可取的值包括：
-
ElemenetType.CONSTRUCTOR 构造器声明
-
ElemenetType.FIELD 域声明（包括 enum 实例）
-
ElemenetType.LOCAL_VARIABLE 局部变量声明
-
ElemenetType.METHOD 方法声明
-
ElemenetType.PACKAGE 包声明
-
ElemenetType.PARAMETER 参数声明
-
ElemenetType.TYPE 类，接口（包括注解类型）或enum声明
-
ElementType.ANNOTATION_TYPE 注解
② @Retention
@Retention 表示在什么级别保存该注解信息。可选的 RetentionPolicy 参数包括：
- RetentionPolicy.SOURCE 注解将被编译器丢弃
- RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃
- RetentionPolicy.RUNTIME JVM将在运行期也保留注释，因此可以通过反射机制读取注解的信息。
③ @Documented
@Documented 将此注解包含在 javadoc 中
④ @Inherited
@Inherited 允许子类继承父类中的注解
Ⅱ. 自定义注解及注射提取的简单介绍
自定义注解其实很简单，直接上代码：
import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
/*
1. 定义注解 Test
2. 注解中含有两个元素 id 和 description
3. description 元素 有默认值 "hello anntation"
*/
public @interface Test {
public int id();
public String description() default "hello annotation";
}
根据上一篇对元注解的解释，我们知道：
- 这个注解可以用于方法
- JVM运行期间该注解都有效
- 该注解包含在 javadoc 中
- 该注解允许子类继承
下面看下通过注解我们能取到什么
public class TestMain {
/*
* 被注解的三个方法
*/
@Test(id = 1, description = "hello methodA")
public void methodA() {
}
@Test(id = 2)
public void methodB() {
}
@Test(id = 3, description = "last method")
public void methodC() {
}
/*
* 解析注解，将类被注解方法 的信息打印出来
*/
public static void main(String[] args) {
Method[] methods = TestMain.class.getDeclaredMethods();
for (Method method : methods) {
/*
* 判断方法中是否有指定注解类型的注解
*/
boolean hasAnnotation = method.isAnnotationPresent(Test.class);
if (hasAnnotation) {
/*
* 根据注解类型返回方法的指定类型注解
*/
Test annotation = method.getAnnotation(Test.class);
System.out.println("Test( method = " + method.getName() + " , id = " + annotation.id()
+ " , description = " + annotation.description() + " )");
}
}
}
}
上面的Demo打印的结果如下：
Test( method = methodA , id = 1 , description = hello methodA )
Test( method = methodB , id = 2 , description = hello annotation )
Test( method = methodC , id = 3 , description = last method )
例其实也说明了，我们一般通过反射来取RUNTIME保留策略的注解信息。
Ⅲ. 简单实例
目标：将实体bean保存到数据库
先来定义一个实体注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Entity {
String getTableName();
}
这个注解可用在类上，它有一个变量参数getTableName。
其实意义很明显，就是一个实体类对应一张数据库的表，通过Entity注解将类和数据库表名关联起来
那么，通过什么将类的参数和数据库表中的列关联起来呢？再来定义一个注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String getName();
}
有了Column注解，类里面的属性就和表中的列关联起来了。
POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。
EJB是的Enterprise Java Beans技术的简称, 又被称为企业Java Beans。这种技术最早是由美国计算公司研发出来的。
下面来看看POJO中怎么用这两个注解：
@Entity(getTableName = "user")
public class User {
@Column(getName = "user_id")
private String id;
@Column(getName = "user_name")
private String name;
@Column(getName = "user_age")
private int age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
通过Entity和Column注解，就将一个实体bean和一张数据库表连接起来了。很多ORM映射就是采取这种方式实现的。
最后，来感受一下注解给我们带来的便利，来个方法见证下~~
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
public class Session {
public static void main(String[] args) {
Session session = new Session();
System.out.println(session.getInsertSql(new User()));
}
//在实际项目中，你可以save(obj)方法来保存一个bean
public void save(Object obj) {
// get a connection
//PreparedStatement pstmt = getStatement(con, obj);
//pstmt.execute();
}
//得到PreparedStatement
public PreparedStatement getStatement(Connection con, Object obj)
throws Exception {
PreparedStatement pstmt = con.prepareStatement(getInsertSql(obj));
Class<?> c = obj.getClass();
Field[] fs = c.getDeclaredFields();
for (int i = 0; i < fs.length; i++) {
fs[i].setAccessible(true);
pstmt.setObject(i + 1, fs[i].get(obj));
}
return pstmt;
}
//insert into tableName(ziduan1,ziduan2...) values(?,?...)
public String getInsertSql(Object obj) {
StringBuilder s = new StringBuilder();
s.append("insert into ");
Class<?> c = obj.getClass();
String tableName = c.getSimpleName();//类名，不包含包名 User
Entity entity = (Entity) c.getAnnotation(Entity.class);
if (entity != null) {
tableName = entity.getTableName();
}
s.append(tableName).append("(");
Field[] fs = c.getDeclaredFields();
for (int i = 0; i < fs.length; i++) {
String fieldName = fs[i].getName();
Column column = fs[i].getAnnotation(Column.class);
if (column != null) {
fieldName = column.getName();
}
s = i == 0 ? s.append(fieldName) : s.append(",").append(fieldName);
}
s.append(") values").append(getString(fs.length));
return s.toString();
}
//得到(?,?,?,...?,?)
private String getString(int length) {
StringBuilder s = new StringBuilder();
s.append("(");
for (int i = 0; i < length; i++) {
s = i == 0 ? s.append("?") : s.append(",?");
}
s.append(")");
return s.toString();
}
}
OK，That’s all！