Java annotations (entry level)

Kingwan 2020-11-08 23:45:57
java annotations entry level


Java annotation

Preface

Recently, I was reading open source projects , Found a lot of strange notes in the project (@DataScope@Log...) I look confused , I don't know if you've had this kind of experience , Think about , Discover your knowledge of annotations , It seems that only stay in @Override... It's awkwardness , So I'll make up for it today annotation This knowledge , And record your harvest here , Communicate with you , If there is something wrong , Please correct me !

I hope this paper can bring readers the following harvest :

  • Understand what annotations are , What's the use
  • Understand the role of annotations in other people's code
  • Can use custom annotations

What is annotation

Want to know something , The first thing I recommend is to check the official website , Let's see below. Java The official interpretation of the note :

Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate.

Annotations are a form of metadata , It provides data about the program , But the data is not part of the program itself . Annotations have no direct effect on the operation of the code they annotate .

A bunch of English , A cloud of mist . No problem , This is normal operation , However, we can still learn from translation that annotations can provide data , And the data is program independent , So we can roughly infer that , Annotation is actually a medium between program and data , Programs and data make a connection through annotations , namely annotation It's like a red line , Put data and programs relation together .

from @Override Start

Through to Java Official translation of explanatory notes , We filtered out a key message —— relation . So how to understand the word ? Don't worry. , From the most familiar strangers @Override Start , Most familiar because we know that this is method rewriting , Subclasses override annotations used by parent methods , It's strange because we've never been able to click in to understand this annotation , Then go in and have a look !

import java.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

Short 5 That's ok , Except for the first line , I don't know anything else ... Don't worry , Let's read it line by line !

  • The annotation imports a annotation package
  • Annotated “ Dolls ” Behavior @Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)
  • Different from the declaration of interfaces and classes public @interface Override { }

Except for the new annotations , We can roughly understand the definition format of annotations , Modifier @interface Annotation name {}.( It's a bit of an interface )

No doll —— Yuan notes

Through to @Override Analysis of , We learned about the definition format of annotations , But we found that there was a new annotation in the annotation , In the spirit of inquisitive curiosity , We continue to enter @Target A note to find out !

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
ElementType[] value();
}

Keep clicking the , The discovery is always in @Documented@Retention@Target Between these notes , adopt Java In the document, we learned that the original annotations are called Yuan notes . Yuan notes (meta-annotation) stay java.lang.annotation It's a bag :

@Retention

Indicates how to store tagged annotations ( Specify the storage level ), There are three levels

  • RetentionPolicy.SOURCE: Only to the source level , It will be ignored in the compilation phase , So they're not written into bytecode .
  • RetentionPolicy.CLASS:( Default ) Compilation level , Reserved by the compiler at compile time , But being Java virtual machine (JVM) Ignore .
  • RetentionPolicy.RUNTIME: from JVM Retain , You can use... In the runtime environment .
@Target

Indicates what kind of annotation marked can be used for java Elements ( class 、 Interface 、 attribute 、 Method ......), There are eight kinds of

Scope explain
ElementType.ANNOTATION_TYPE Can be used for annotation types
ElementType.CONSTRUCTOR Can be used for constructors
ElementType.FIELD Can be used for fields or properties
ElementType.LOCAL_VARIABLE Can be used for local variables
ElementType.METHOD Can be used for method level annotations
ElementType.PACKAGE Can be used for package declaration
ElementType.PARAMETER Parameters that can be used for methods
ElementType.TYPE Can be used for any element of a class
@Documented

Whenever the specified annotation is used , Should be used Javadoc Tools record these elements .( It's going to be generated javadoc Add a note to explain )

@Inherited

Annotation types can be inherited from superclasses , For class declaration only ( Interfaces do not inherit )

@Repeatable

stay Java SE 8 Introduced in , Comments that represent tags can be applied to the same declaration or type use more than once .

Classification of annotations

By understanding meta annotations , I've learned that an annotation is modified by these meta annotations , And we've got an important message —— Annotations can modify annotations

So infinite Dolls , There will be all kinds of annotations , So what are the annotations ? Common annotations can be roughly divided into the following four categories :

Yuan notes

As mentioned above 5 A meta note

jdk annotation

The common ones are @Override @Deprecated @SuppressWarnings @SafeVarargs @FunctionalInterface

Third party comments

That is, annotations provided by third-party frameworks , For example, automatic injection of dependencies @Autowired@Controller etc.

Custom annotation

That is, developers can customize annotations according to project requirements , For some tools in compilation 、 Runtime for parsing and use , Play a show 、 Configured functionality .

actual combat —— Define your own annotations

Yes Java Notes provided , I believe you have a general understanding of annotations . Have you ever thought about , Annotation is how to turn corruption into magic , Added a simple @Autowired We can implement dependency injection 、@Setter Can achieve set Method generation , Let's experience the magic of annotation through simple actual combat !

Actual target :

Use custom annotations , By annotating entity classes and their properties , Realize the query of entity class sql The construction of statements

ps: similar select * from t_user where t_name='kingwan' In the form of

Custom annotation writing rules

Before the actual battle , Let's take a look at writing custom annotations The rules

  • Annotation is defined as @interface, All annotations are automatically inherited java.lang.Annotation This interface , And you can't inherit other classes or interfaces
  • Parameter members can only use public or default( Default ) Access modifiers
  • Parameter members can only use eight basic data types 、StringEnumClassannotations And so on , And these types of arrays
  • To get annotation information for class methods and fields , Must pass java Reflection mechanism to get
  • Annotations can also have no defined members ( It's just a sign )

Understand the definition specification of annotation , Next, we begin to enter the formal actual combat link .

1. Custom annotation @KingwanTableKingwanColumn

For entity class queries sql sentence , We need to know two things :① The table name of the query ② Field name . And we're usually used to putting user tables t_user Corresponding to entity class User, So how do we deal with t_user and User Conduct relation Well ? The thought of connection , Looking back at the information that we first extracted from official documents , you 're right , It's using annotations to associate . Next, define two custom annotations :

  • @KingwanTable: Annotate the table name corresponding to the entity class

    @Target(ElementType.TYPE)// Action on class / On the interface
    @Retention(RetentionPolicy.RUNTIME)// Keep scope : Keep until run time
    public @interface KingwanTable {
    String value();// Parameters : Table name
    }
    
  • @KingwanColumn: Annotate the table field name corresponding to the entity class attribute

    @Target(ElementType.FIELD)// Indicates that it acts on a field
    @Retention(RetentionPolicy.RUNTIME)// Keep until run time
    public @interface KingwanColumn {
    String value();// Parameters : Field name
    }
    
2. Add custom annotation to entity class

With two custom annotations , So we can now add them to entity classes .

  • The following code defines a Student Entity class , Combined with the @KingwanTable("t_student") Mapping table name ,@KingwanColumn("stu_birth") Mapping field name .

    @Data// Simplify the entity class set、get Method
    @KingwanTable("t_student")
    public class Student {
    @KingwanColumn("stu_name")
    private String stuName;
    @KingwanColumn("stu_age")
    private Integer stuAge;
    @KingwanColumn("stu_birth")
    private Date stuBirth;
    }
    
  • The following code creates a student object , And initialize the message

    public static void main(String[] args) {
    Student student = new Student();
    // Initialization information
    init(student);
    }
    private static void init(Student student) {
    student.setStuName("kingwan");
    student.setStuAge(18);
    student.setStuBirth(new Date());
    }
    
3. Reflection gets annotation information

There's a custom annotated Student Entity class , So we want to construct SQL, There are the following ideas :

Get the annotation information ( Get table name 、 Field name )=> Get the value of the property ( field value )=> structure SQL

How to get it ? The rules say , Use Reflection .

The following code is obtained by getting student Of class object , obtain Class Annotations @KingwanTable Information .

aClass.isAnnotationPresent: Determine whether the specified annotation exists

public static void main(String[] args) throws Exception {
StringBuffer sql = new StringBuffer("");// About to be stitched together SQL sentence
Student student = new Student();
// Initialization information
init(student);
// Reflection acquisition class class
Class<? extends Student> aClass = student.getClass();
//1. Determine whether there are annotations on the entity class @KingwanTable
boolean exist = aClass.isAnnotationPresent(KingwanTable.class);// Pass in our custom annotation class
String tableName = null;
if(exist){
//1.1 The existence of an annotation is to obtain the annotation value ---( Table name )
KingwanTable annotation = aClass.getAnnotation(KingwanTable.class);
tableName = annotation.value();
sql.append("select * from ").append(tableName).append(" where 1=1");// Splicing SQL
}
System.out.println(sql);
}

here SQL Printed results :

Get the annotation information on the class , Now let's look at how to get Attribute The annotation information of

//2. Gets an annotation on a property
Field[] fields = aClass.getDeclaredFields();
for (Field field : fields) {
//2.1 Iterate over whether there are KingwanColumn annotation
KingwanColumn column = field.getAnnotation(KingwanColumn.class);
if( column != null){
//2.1.1 Get the value of the property
String fieldName = field.getName();// Property name
String methodName = "get"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);// structure getter Method
Method method = aClass.getMethod(methodName);
// Call through the reflection proxy get Method , Get the value of the property (name='kingwan',age=18....)
Object invoke = method.invoke(student);
if(invoke instanceof String){
String value = (String) invoke;
//sql Splicing
sql.append(" and ").append(column.value()).append("=").append("'")
.append(value).append("'");
}else{
// Think about what else ...
}
}
System.out.println(sql);
}

here SQL Result :

Of course , If you have a small partner to follow this article , Maybe you can't go down at this step , It's because of our get Methods return a variety of field types , So just invoke instanceof String It's not enough. , We need to think about other situations (IntegerDate), Limited to space , I won't give you too much introduction here , You can add , If you want to know my implementation ideas , Walk : Case source address

such , Is it possible to achieve the effect we want , For any simple entity class , We can all implement a simple search by adding this annotation SQL Generation

Did you stop learning !

summary

What is the use of annotations

I believe you may have questions after you look at me , The annotation is so complicated , It took a lot of effort , It's better to go straight ! You bet , At the beginning, I also thought that the annotation was a little chicken bone , But after a long time , Find out how fragrant ! And it's not just about annotations , The purpose of this paper is to give you a simple understanding of annotations , When you see how clever other people's notes are , You may find out , It turns out that annotations are so easy to use !

  • Format check at compile time . Such as @Override
  • Trace code dependencies , Implement alternative profile functions . Generate code by processing annotation information 、XML file .
  • Some comments can be checked at run time
At the end of the picture

A mind map summarizes the content , preserved , Review often !

版权声明
本文为[Kingwan]所创,转载请带上原文链接,感谢

  1. 【计算机网络 12(1),尚学堂马士兵Java视频教程
  2. 【程序猿历程,史上最全的Java面试题集锦在这里
  3. 【程序猿历程(1),Javaweb视频教程百度云
  4. Notes on MySQL 45 lectures (1-7)
  5. [computer network 12 (1), Shang Xuetang Ma soldier java video tutorial
  6. The most complete collection of Java interview questions in history is here
  7. [process of program ape (1), JavaWeb video tutorial, baidu cloud
  8. Notes on MySQL 45 lectures (1-7)
  9. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  10. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  11. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  12. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  13. 【递归,Java传智播客笔记
  14. [recursion, Java intelligence podcast notes
  15. [adhere to painting for 386 days] the beginning of spring of 24 solar terms
  16. K8S系列第八篇(Service、EndPoints以及高可用kubeadm部署)
  17. K8s Series Part 8 (service, endpoints and high availability kubeadm deployment)
  18. 【重识 HTML (3),350道Java面试真题分享
  19. 【重识 HTML (2),Java并发编程必会的多线程你竟然还不会
  20. 【重识 HTML (1),二本Java小菜鸟4面字节跳动被秒成渣渣
  21. [re recognize HTML (3) and share 350 real Java interview questions
  22. [re recognize HTML (2). Multithreading is a must for Java Concurrent Programming. How dare you not
  23. [re recognize HTML (1), two Java rookies' 4-sided bytes beat and become slag in seconds
  24. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  25. RPC 1: how to develop RPC framework from scratch
  26. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  27. RPC 1: how to develop RPC framework from scratch
  28. 一次性捋清楚吧,对乱糟糟的,Spring事务扩展机制
  29. 一文彻底弄懂如何选择抽象类还是接口,连续四年百度Java岗必问面试题
  30. Redis常用命令
  31. 一双拖鞋引发的血案,狂神说Java系列笔记
  32. 一、mysql基础安装
  33. 一位程序员的独白:尽管我一生坎坷,Java框架面试基础
  34. Clear it all at once. For the messy, spring transaction extension mechanism
  35. A thorough understanding of how to choose abstract classes or interfaces, baidu Java post must ask interview questions for four consecutive years
  36. Redis common commands
  37. A pair of slippers triggered the murder, crazy God said java series notes
  38. 1、 MySQL basic installation
  39. Monologue of a programmer: despite my ups and downs in my life, Java framework is the foundation of interview
  40. 【大厂面试】三面三问Spring循环依赖,请一定要把这篇看完(建议收藏)
  41. 一线互联网企业中,springboot入门项目
  42. 一篇文带你入门SSM框架Spring开发,帮你快速拿Offer
  43. 【面试资料】Java全集、微服务、大数据、数据结构与算法、机器学习知识最全总结,283页pdf
  44. 【leetcode刷题】24.数组中重复的数字——Java版
  45. 【leetcode刷题】23.对称二叉树——Java版
  46. 【leetcode刷题】22.二叉树的中序遍历——Java版
  47. 【leetcode刷题】21.三数之和——Java版
  48. 【leetcode刷题】20.最长回文子串——Java版
  49. 【leetcode刷题】19.回文链表——Java版
  50. 【leetcode刷题】18.反转链表——Java版
  51. 【leetcode刷题】17.相交链表——Java&python版
  52. 【leetcode刷题】16.环形链表——Java版
  53. 【leetcode刷题】15.汉明距离——Java版
  54. 【leetcode刷题】14.找到所有数组中消失的数字——Java版
  55. 【leetcode刷题】13.比特位计数——Java版
  56. oracle控制用户权限命令
  57. 三年Java开发,继阿里,鲁班二期Java架构师
  58. Oracle必须要启动的服务
  59. 万字长文!深入剖析HashMap,Java基础笔试题大全带答案
  60. 一问Kafka就心慌?我却凭着这份,图灵学院vip课程百度云