Annotations and reflection are things in Java that are very easy to ignore, but they are very important. In the mainstream Spring, they are full of annotations. Annotations and annotations are very similar. In fact, the essence is almost the same. Comments are for us programmers to see, while annotations are actually for programs to see.
(Recommended tutorial: java learning website)
As mentioned above, I hope you will pay attention to the following two points:
1. Annotations and annotations are very similar.
2. Comments are for our programmers, and annotations are for programs.
Our initial understanding of annotations starts from the above two points. Let’s look at the annotations first, for example:
This is a comment, so what is the use of comments?
To put it simply, it is to explain the relevant classes or methods, such as the Test class here. The above comments roughly tell us who wrote this class, what it did and when it was written. Of course, , the information can actually be more.
So you have to understand what the comments are for. They are for programmers like us. When we see the comments, we will understand, oh, this class turns out to be like this...
Comments are for programmers to read, but what about annotations? There is only one word difference, the annotation is for the program to read, just remember it first.
Further understanding of annotations
First of all, let’s intuitively understand what annotations are, such as this one we wrote in the code:
/**
* @Description 用户类
* @Author ithuangqing
* @Date 2020-07-31 15:33
**/
@Repository
public class UserBean {
private String name;
private int age;
}@Repository here It's just an annotation. Look at this code. There are comments on it. When we see the annotations, we can understand them all. But after seeing @Repository, we don't understand so much. What is this and what is its use?
So we checked and roughly knew, oh, this is an annotation. With this annotation, UserBean will be loaded into the Spring container. We can know this information, but what does it actually do? How it works, that is, how to hand over UserBean to Spring for processing, we don't know the internal implementation.
However, although we don’t know clearly, there is something we know clearly. What is it? It is a specific program, that is to say, there is a special program. When it sees that there is a @Repository on this UserBean, this program knows that it is necessary to load this UserBean into the Spring container, so this program Start executing a series of operation areas to load this UserBean into the Spring container.
(Video tutorial recommendation: java learning)
Let’s further summarize what annotations are:
In the program , you can think of annotations as a special mark, generally used to mark classes, methods or interfaces, etc. These marks have some characteristics, such as they can be used during compilation (the javac command compiles java source files into bytecode files class ), when the class is loaded and run (when using the java command to execute a bytecode file, the life cycle of the class begins, from loading to unloading) is read (usually there is a special program to read these annotations, using reflection technology to parse the annotations, and then perform corresponding processing based on the information obtained)
Yes, you need to know this knowledge point about annotations:
There is a special program for annotations Read it, parse it, and then perform corresponding operations based on the message.
Regarding this program, it depends on the specific scenario, which means that this program is different. So how does this program know which annotation it reads and what to do? This still relies on the definition of the annotation itself, such as @Repository Annotation is defined as loading the annotated into the Spring container, then the specific program will know what to do after getting the annotation.
The above is the detailed content of what are java annotations. For more information, please follow other related articles on the PHP Chinese website!