java annotations and reflection

Keywords: Java

Crazy God learning notes on this site

1, Annotation

1. What is annotation

Annotation is a concept introduced from JDK 5.0

eg: @ override overriding annotation

  • 1. It is not the procedure itself that explains the procedure ()
  • 2. It can be read by other programs
  • Not necessary
  • 3. Format: @ comment + comment name, and some parameter values can be added
  • 4. It has the function of inspection and restraint
  • It can be placed on methods or classes, etc

... annotations are for people, annotations are for people and machines

2. Built in annotation

@Override indicates that the method declaration is intended to override the method declaration in the supertype.
@Deprecated obsolete deprecated code
@SuppressWarnings suppress warnings (can be put in parameters)

3. Meta annotation

Role: responsible for annotation and other annotations
Four standard meta annotation types:

  • @Where can the annotation described by Target be used
@Target(value =ElementType.METHOD)  Explain that the scope is on the method 
@Target(ElementType.FIELD) Scope on property (member variable)
@Target(value ={ElementType.METHOD,ElementType.TYPE})  Explain that the scope is on methods and classes 

  • @Retention indicates the level at which annotation information needs to be saved (usually RUNTIME)
    Indicates where our comments are still valid
@Retention(value =RetentionPolicy.RUNTIME)
  • @Documented is our annotation generated in JAVAdoc
  • @Inherited indicates that the subclass can inherit the annotation from the parent class

4. User defined annotation

  • When using @ interface to customize annotations, the annotation interface is automatically inherited
  • Parameter format written in the annotation: parameter type + parameter name ();
  • Default set default
    The annotation shows the assignment. If there is no default value, we must assign it
@interface MyAnnotion{
string name() default ""
int id() default -1   //Generally, negative one represents nonexistence

@interface MyAnnotion2{
string value()

@MyAnnotion2("abc")  //When there is only one and the name is value, it is equivalent to (value="'abc '")
public viod test(){

2, Reflection

1. Concept

Java (static language) is regarded as the key of quasi dynamic language. Reflection mechanism allows programs to obtain the internal information of any class with the help of Reflection API during execution, and can directly operate the internal properties and methods of any object. private can also be operated

After loading the Class, a Class object is generated in the method area of heap memory (a Class has only one Class object), which contains the complete Class structure information. We can see the structure of the Class through this object. This object is like a mirror, through which we can see the structure of the Class. Therefore, we vividly call it reflection

Normal method: introduce the required "package class" name 1 > instantiate through new - > obtain the instantiated object
Reflection method: instantiate object I > getClass method - > get the complete "package class" name

2. Creation method of class

public class test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person =new Student();
        System.out.println("This person is:";
        //Obtained by object
        Class c1 = person.getClass();
        //forname get
        Class c2 = Class.forName("lesson05.Student");
        //Obtained by class name. Class
        Class c3 = Student.class;
        //Get parent type
        Class c5 = c1.getSuperclass();


class Person{
   public String name;

    public Person() {

    public Person(String name) { = name;

    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +

class Student extends Person{
    public Student() {"student";

class Teacher extends Person{
    public Teacher() {"teacher";

3. Which types have Class objects

public class test04 {
    public static void main(String[] args) {
        Class objectClass = Object.class;//class
        Class comparableClass = Comparable.class;//Interface
        Class aClass = String[].class;//One dimensional array
        Class aClass1 = int[][].class; //Two dimensional array
        Class overrideClass = Override.class;//annotation
        Class elementTypeClass = ElementType.class; //enumeration
        Class  integerClass = Integer.class;//Basic data type
        Class voidClass = void.class;//void
        Class classClass = Class.class;//Class

4. Analysis class initialization

(1.) active reference of class (class initialization must occur)

  • When the virtual machine starts, initialize the class where the main method is located first

  • new is an object of a class

  • Call static members (except final constants) and static methods of the class

  • Use the methods of the java.lang.reflect package to make reflection calls to the class

  • When initializing a class, if its parent class is not initialized, its parent class will be initialized first
    (2.) passive reference of class (class initialization will not occur)

  • When accessing a static domain, only the class that actually declares the domain will be initialized. For example, when a static variable of a parent class is referenced through a subclass, the subclass will not be initialized

  • Defining a class reference through an array does not trigger the initialization of this class

  • The reference constant (final) will not trigger the initialization of this class (constants are stored in the constant pool of the calling class in the link phase)

    public class test05 {
        public static void main(String[] args) throws ClassNotFoundException {
            System.out.println("main call");
            //(1.) active reference of class (class initialization must occur)
            ///zi son = new zi();
          // Class.forName("lesson05.zi");
            //(2.) passive reference of class (class initialization will not occur)
            //zi[] zis = new zi[5];
    class Fu {
        static int b=2;
        static {
            System.out.println("Parent class called");
    class zi extends Fu{
       final static int m=0;
        static {
            System.out.println("Subclass called");


1.static method

Static methods are generally called static methods. Because static methods can be accessed without relying on any object, there is no this for static methods, because they do not depend on any object. Since there are no objects, there is no this. Moreover, due to this feature, non static member variables and non static member methods of the class cannot be accessed in static methods, because non static member methods / variables must rely on specific objects to be called.

However, it should be noted that although non static member methods and non static member variables cannot be accessed in static methods, static member methods / variables can be accessed in non static member methods.

2.static variable

Static variables are also called static variables. The difference between static variables and non static variables is that static variables are shared by all objects and have only one copy in memory. It will be initialized when and only when the class is first loaded. Non static variables are owned by objects. They are initialized when creating objects. There are multiple copies, and the copies owned by each object do not affect each other.

static member variables are initialized in the defined order.

3.static code block

Static keyword also plays a key role in forming static code blocks to optimize program performance. Static blocks can be placed anywhere in the class, and there can be multiple static blocks in the class. When the class is first loaded, each static block is executed in the order of static blocks, and only once.

4.static is used on member variables to indicate that only one copy is saved. final is used to ensure that variables are immutable

5. Class loading memory analysis

Test code:

Operation results:


Note: the order in which static code blocks and static variables are executed depends on the order in which the code is written, and is completed at

6. Class loader

  • bootstrap class loader
bootstrap class loader :use C++Written by, yes JVM Self contained class
 Loader, responsible for Java Platform core library( rt.jar),Used to load core classes
 Library. The loader cannot get it directly
  • extensions class loader
extensions class loader :be responsible for jre/ib/ext Under directory jar Package or-
D java.ext.dirs Specified directory jar Package into work warehouse
  • system class loader
system class loader :be responsible for java - classpath or-D
java.class. path The class under the directory and jar Packaging entry
 As a library, it is the most commonly used loader

7. Get the complete structure of the runtime class

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

//Get class information
public class test06 {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        USer uSer = new USer();
        Class c1 = uSer.getClass();
        //Gets the name of the class

//        //Get the properties of the class
//        System.out.println("===========================================");
//        Field[] fields = c1.getFields(); / / only public attributes can be found
//        for (Field field : fields) {
//            System.out.println(field);
//        }
//        System.out.println("===========================================");
//        Field [] Fields1 = C1. Getdeclaraedfields(); / / find all attributes
//        for (Field field : fields1) {
//            System.out.println(field);

        //Gets the specified attribute

        //Method to get class
            Method[] methods = c1.getMethods();  //All methods of this class and its parent class
            for (Method method : methods) {
            Method[] declaredMethods = c1.getDeclaredMethods();//All methods of this class
            for (Method declaredMethod : declaredMethods) {
                System.out.println("getDeclaredMethods Of:"+declaredMethod);
        //Gets the specified method
        //Overloading may occur, so you need to throw in a type for the incoming parameter
            Method getName = c1.getMethod("getName", null);
            Method setName = c1.getMethod("setName", String.class);
        //Construction method
            Constructor[] constructors = c1.getConstructors();//public constructor of this class
            for (Constructor constructor : constructors) {

            Constructor[] constructors1 = c1.getDeclaredConstructors(); //All construction methods of this class
            for (Constructor constructor1 : constructors1) {

        //Gets the specified constructor
            System.out.println(c1.getConstructor(String.class, int.class, int.class));


7. Dynamically create object execution methods

null if there are no parameters

//Create objects dynamically through reflection
public class test07 {
    public static void main(String[] args) throws Exception {
        //Get class object
        Class c1 = Class.forName("lesson05.USer");

        //Construction object
        USer user = (USer) c1.newInstance();//Essentially called a parameterless constructor

        //Creating objects through constructors
        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        USer user2  = (USer) constructor.newInstance("dongGEi", 01, 18);

        //Call normal methods through reflection
        USer user3 = (USer) c1.newInstance();
        //Method of obtaining by reflection
        Method setName = c1.getMethod("setName", String.class);
        setName.invoke(user3,"abcd"); //Activate invoke and give user3 the object parameter abcd
        //Operation properties by reflection
        USer user4 = (USer) c1.newInstance();
        Field name = c1.getDeclaredField("name");
            //Private properties cannot be operated directly. You need to turn off security detection first. Both properties and methods are setAccessible(true)
        name.setAccessible(true);//Set permissions


8. Performance comparison

  • The common method new User comes out to perform operations such as set and get
  • Reflect the method uesr.getClass and get the method invoke
  • Turn off the reflection call of permission detection and add a setAccessible (true)

Normal speed > turn off reflection for permission detection > reflection method

When reflection is needed, permission detection can be turned off to improve speed

9. Get generic information by reflection

Explain the above code: test01 is a method with Map and List parameters,

Reflection takes this method and gets the parameter list

Traverse the parameter list, and then strongly convert the parameter type that is a parameterized type (plus < >; generic type) to a parameterized type

Then traverse to get the true parameters

(colloquialism is a little windy =. =)

10. Get annotation information by reflection

ORM object relational mapping

◆ correspondence between class and table structure

◆ attribute and field correspondence

◆ object and record correspondence

Requirement: use annotation and reflection to complete the mapping relationship between class and table structure

Look below before you look at psvm

package test;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Test {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("test.Student");
        //Get annotations through reflection
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
        //Get the value of annotation value
        //Gets the class of the specified annotation passed into the annotation
        TableDong tableDong = c1.getAnnotation(TableDong.class);
        String value = tableDong.value();

        //Gets the specified attribute (member variable)
        Field f = c1.getDeclaredField("name");
        //Get the specified annotation on the attribute and take out the value of the annotation
        FieldDong fieldDong = f.getAnnotation(FieldDong.class);

        f = c1.getDeclaredField("id");
        //Gets the specified annotation
        fieldDong = f.getAnnotation(FieldDong.class);
class Student{
    @FieldDong(columName = "db_id",type = "varchar",length = 10)
    private String id;
    @FieldDong(columName = "db_age",type = "int",length = 3)
    private int age;
    @FieldDong(columName = "db_name",type = "varchar",length = 10)
    private String name;

    public Student() {

    public Student(String id, int age, String name) { = id;
        this.age = age; = name;

    public String getId() {
        return id;

    public void setId(String id) { = id;

    public int getAge() {
        return age;

    public void setAge(int age) {
        this.age = age;

    public String getName() {
        return name;

    public void setName(String name) { = name;

    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", age=" + age +
                ", name='" + name + '\'' +

//Annotation of class name
@interface TableDong{
    String value();

//Attribute annotation
@interface FieldDong{
    String columName(); //Column name (not student name)
    String type();
    int length();

My blog
(I still don't understand the JVM in-depth part of this article. I'll learn more about it later -. -)

Posted by sriphp on Thu, 02 Dec 2021 10:56:03 -0800