[Java] Annotation

Annotation

• Types such as class interfaces and marks that can be given to members
• ** You can add incidental information to your code that is not directly related to the original logic of the app **
• Described at the beginning of the target declaration

@Override

• Annotations provided by the standard library
• Declare that the target method ** overrides the base class method **
• The compiler will warn you even if you cannot override due to a mistake in the argument.

public class Person {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return String.format("Name is,%s %s.",
        this.lastName, this.firstName);
  }

  public String getLastName() {
    return this.lastName;
  }

  public String getFirstName() {
    return this.firstName;
  }
}

@WebServlet

• What is a Servlet? ** A type of basic technology for running Java applications in a server environment **
• Basic configuration information of Servlet
• ** urlPatterns **: URL to call the Servlet
• ** initParams **: Parameter information available in Servlet

Annotation points

• ** Annotation nesting is possible **
• ** Array {...} can be omitted if there is one element **
  • urlPatterns = "/init-param"
• ** Attribute name values can be omitted **
  • @WebServlet (values="init-param")
  • @WebServlet ("init-param")
• ** Can be omitted if there is no attribute **
• Marker annotation (@Override, etc.)

Standard annotation

• @Override: Declares that you are overriding a method in the base class
• @Deprecated: Declares that classes, members, etc. are deprecated
• @SuppressWarnings: Suppress compiler warnings
• @SafeVarargs: Declare type safety for variadic arguments
• @FunctionalInterface: Declares to define the interface as a functional interface

@Deprecated

• Declare class, method, etc. ** deprecated **
• Integer constructor is deprecated in Java 9 and above (since =" 9 ")
• Also described in the documentation
• Compiles, but a warning appears

Integer.java

/**
 *Omission
 * @deprecated
 * It is rarely appropriate to use this constructor. The static factory
 * {@link #valueOf(int)} is generally a better choice, as it is
 * likely to yield significantly better space and time performance.
 */

@Deprecated(since="9")
public Integer(int value) {
    this.value = value;
}

@SuppressWarnings

• ** Hide specific range / type compiler warnings **
• Prevents oversight of other warnings that should be confirmed
• Manifestation of intention to use the warning code

public class AnnotationBasic {

  public static Integer process() {
   @SuppressWarnings("deprecation")
    var i = new Integer(108);
   return i;
  }

  public static void main(String[] args) {
    System.out.println(process());
  }
}

@SafeVarargs

• ** Declare variadic type safety and no warning is displayed **
• Warning appears when generic type is variadic
• Declaration that the developer is aware that it is type-safe

Self-made annotation

• Annotations can be created by yourself, unlike modifiers
• ** Annotation is defined by @interface instruction **
• ** Declare attributes that can be used in annotations under @interface **
• In the following @ClassInfo, specify the version attribute with version attribute and value attribute
• @ ClassInfo (version =" 2.1 ", description =" annotation test ") * @ClassInfo(version="2.1")
• ** Describe meta-annotation to declare annotation configuration information **
• @Documented: Reflect annotation information in javadoc
• @Target: Decide which element to apply the annotation to
• @Inherited: Annotation inherits to derived class
• @Retention: How long to retain annotation information

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//Configuration information declaration
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
//@Annotation definition with interface instruction
public @interface ClassInfo {
  //Declare attributes that can be used in annotations
  String value() default "";
  String version() default "";
  String description() default "";
}

Use annotations in reflection

• ** Reflection **: Get and manipulate type information during code execution
• Below, the type information specified by ** Class.forName method ** is acquired by Class class.
• Marker annotation: I am interested in the existence of the annotation itself, not the information (attribute) held by the annotation **
• ** Check for annotation with isAnnotationPresent method **

package mypackage;

//ClassInfo annotation specification
@ClassInfo(version = "2.1", description = "Annotation operation test")
// @ClassInfo("2.1")
public class AnnotationClient {
  public static void main(String[] args) throws ClassNotFoundException {
    //Get subordinate members via Class object
    var clazz = Class.forName("mypackage.AnnotationClient");
    //Get annotation given to class by getAnnotation method
    var info = (ClassInfo)
 clazz.getAnnotation(ClassInfo.class);
    System.out.println("version:" +
        (info.value().equals("") ? info.version() : info.value()));
    System.out.println("Explanation:" + info.description());
  }
}

Reflection method

Object creation

• Instantiate via constructor
• Generate the constructor to call with ** getConstructor method ** of Class class
• ** Create object by calling with newInstance method **
• ** Array.newInstance method ** to generate an array
• ** Set array element with set method **

import java.io.File;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;

public class ReflectInstance {

  public static void main(String[] args) {
    try {
      //Get File class
      var clazz = File.class;

      //File object creation via constructor
      var c = clazz.getConstructor(String.class);
      var fl = c.newInstance("./data/data.txt");
      System.out.println(fl);

      //Size 2 array generation
      var list = (File[]) Array.newInstance(File.class, 2);
      Array.set(list, 0, fl);
      System.out.println(Arrays.toString(list));
    } catch (InstantiationException | IllegalAccessException |
        IllegalArgumentException | InvocationTargetException
        | NoSuchMethodException | SecurityException e) {
      e.printStackTrace();
    }
  }
}

Get all methods

• ** Public method enumeration of File class with getMethods method **
• Returns a public method as an array of Method objects
• If you want to take something other than public, get all methods with ** getDeclaredMethods method **

import java.io.File;

public class ReflectMethods {

  public static void main(String[] args) {
    //Get File class
    var str = File.class;
    //List method names with getName for public methods under File class
    for (var m : str.getMethods()) {
      System.out.println(m.getName());
    }
  }
}

Method execution

• ** Run via Method object **
• ** GetMethod method ** to get individual method and ** invoke method ** to execute

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectInvoke {

  public static void main(String[] args) {
    try {
      //Get File class
      var clazz = File.class;
      //File object creation
      var f1 = clazz.getConstructor(String.class).newInstance("./data/data.txt");
      var f2 = clazz.getConstructor(String.class).newInstance("./data/sample.txt");
      //get and execute renameTo method
      Method m = clazz.getMethod("renameTo", File.class);
      System.out.println(m.invoke(f1, f2));
    } catch (NoSuchMethodException | SecurityException |
        InstantiationException | IllegalAccessException
        | IllegalArgumentException | InvocationTargetException e) {
      e.printStackTrace();
    }
  }
}

Field acquisition, setting

• public field is obtained by ** getField method **
• Other fields can be obtained with ** getDeclaredFiled method **
• Argument specifies the name of the field you want to get
• After getting the Field object, get / set the field value with ** get / set method **
• Private fields cannot be accessed as they are, so explicitly allow access with ** setAccessible method **
• Note: Reflection is ** slow **

//Get lastName field of Person class

import java.lang.reflect.InvocationTargetException;
import example.Person;

public class ReflectField {

  public static void main(String[] args) {
    try {
      var clazz = Person.class;
      var con = clazz.getConstructor(String.class, String.class);
      var p = con.newInstance("Taro", "Yamada");
      //Field acquisition
      var last = clazz.getDeclaredField("lastName");
      //Explicitly allow access to private fields
      last.setAccessible(true);
      //get/Get field value with set method/Configuration
      last.set(p, "Suzuki");
      System.out.println(last.get(p)); //Suzuki
    } catch (NoSuchMethodException | SecurityException |
        InstantiationException | IllegalAccessException
        | IllegalArgumentException | InvocationTargetException |
        NoSuchFieldException e) {
      e.printStackTrace();
    }
  }
}

package example;
public class Person {
  private String firstName;
  private String lastName;
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  @Override
  public String toString() {
    return String.format("Name is,%s %s.",
        this.lastName, this.firstName);
  }
  public String getLastName() {
    return this.lastName;
  }
  public String getFirstName() {
    return this.firstName;
  }
}