Java Annotations

Published on August 3, 2022


Java Annotations

Java Annotations provides information about the code. Java annotations have no direct effect on the code they annotate. In java annotations tutorial, we will look into the following;

  1. Built-in Java annotations
  2. How to write Custom Annotation
  3. Annotations usage and how to parse annotations using Reflection API.

Java Annotations

java annotations, annotations in java, java annotation example, java annotations tutorial, java custom annotation Java 1.5 introduced annotations and now it’s heavily used in Java EE frameworks like Hibernate, Jersey, and Spring. Java Annotation is metadata about the program embedded in the program itself. It can be parsed by the annotation parsing tool or by the compiler. We can also specify annotation availability to either compile time only or till runtime. Before java annotations, program metadata was available through java comments or by Javadoc but annotation offers more than that. Annotations metadata can be available at runtime too and annotation parsers can use it to determine the process flow. For example, in Jersey webservice we add PATH annotation with URI string to a method and at runtime, jersey parses it to determine the method to invoke for given URI pattern.

Java Custom Annotation

Creating custom annotation is similar to writing an interface, except that the interface keyword is prefixed with _@_ symbol. We can declare methods in annotation. Let’s see java custom annotation example and then we will discuss its features and important points.

package com.journaldev.annotations;

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

public @interface MethodInfo{
	String author() default "Pankaj";
	String date();
	int revision() default 1;
	String comments();

Some important points about java annotations are:

  1. Annotation methods can’t have parameters.
  2. Annotation methods return types are limited to primitives, String, Enums, Annotation or array of these.
  3. Java Annotation methods can have default values.
  4. Annotations can have meta annotations attached to them. Meta annotations are used to provide information about the annotation.

Meta annotations in java

There are five types of meta annotations:

  1. @Documented - indicates that elements using this annotation should be documented by javadoc and similar tools. This type should be used to annotate the declarations of types whose annotations affect the use of annotated elements by their clients. If a type declaration is annotated with Documented, its annotations become part of the public API of the annotated elements.
  2. @Target - indicates the kinds of program element to which an annotation type is applicable. Some possible values are TYPE, METHOD, CONSTRUCTOR, FIELD etc. If Target meta-annotation is not present, then annotation can be used on any program element.
  3. @Inherited - indicates that an annotation type is automatically inherited. If user queries the annotation type on a class declaration, and the class declaration has no annotation for this type, then the class’s superclass will automatically be queried for the annotation type. This process will be repeated until an annotation for this type is found, or the top of the class hierarchy (Object) is reached.
  4. @Retention - indicates how long annotations with the annotated type are to be retained. It takes RetentionPolicy argument whose Possible values are SOURCE, CLASS and RUNTIME
  5. @Repeatable - used to indicate that the annotation type whose declaration it annotates is repeatable.

Built-in annotations in Java

Java Provides five built-in annotations.

  1. @Override - When we want to override a method of Superclass, we should use this annotation to inform compiler that we are overriding a method. So when superclass method is removed or changed, compiler will show error message. Learn why we should always use java override annotation while overriding a method.
  2. @Deprecated - when we want the compiler to know that a method is deprecated, we should use this annotation. Java recommends that in javadoc, we should provide information for why this method is deprecated and what is the alternative to use.
  3. @SuppressWarnings - This is just to tell compiler to ignore specific warnings they produce, for example using raw types in java generics. It’s retention policy is SOURCE and it gets discarded by compiler.
  4. @FunctionalInterface - This annotation was introduced in Java 8 to indicate that the interface is intended to be a functional interface.
  5. @SafeVarargs - A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter.

Java Annotations Example

Let’s see a java example showing the use of built-in annotations in java as well as the use of custom annotation created by us in the above example.

package com.journaldev.annotations;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class AnnotationExample {

	public static void main(String[] args) {

	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 1)
	public String toString() {
		return "Overriden toString method";

	@MethodInfo(comments = "deprecated method", date = "Nov 17 2012")
	public static void oldMethod() {
		System.out.println("old method, don't use it.");

	@SuppressWarnings({ "unchecked", "deprecation" })
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 10)
	public static void genericsTest() throws FileNotFoundException {
		List l = new ArrayList();


I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

Java Annotations Parsing

We will use Reflection to parse java annotations from a class. Please note that Annotation Retention Policy should be RUNTIME otherwise its information will not be available at runtime and we won’t be able to fetch any data from it.

package com.journaldev.annotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class AnnotationParsing {

	public static void main(String[] args) {
		try {
			for (Method method : AnnotationParsing.class.getClassLoader()
					.loadClass(("com.journaldev.annotations.AnnotationExample")).getMethods()) {
				// checks if MethodInfo annotation is present for the method
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// iterates all the annotations available in the method
						for (Annotation anno : method.getDeclaredAnnotations()) {
							System.out.println("Annotation in Method '" + method + "' : " + anno);
						MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
						if (methodAnno.revision() == 1) {
							System.out.println("Method with revision no 1 = " + method);

					} catch (Throwable ex) {
		} catch (SecurityException | ClassNotFoundException e) {


Output of the above program is:

Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)
Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)
Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)

Reflection API is very powerful and used widely in Java, J2EE frameworks like Spring, Hibernate, JUnit, check out Reflection in Java. That’s all for the java annotations example tutorial, I hope you learned something from it. Java Annotations Updates:

  1. Servlet Specs 3.0 introduced use of annotations for Servlet Configuration and init parameters, read more at Java Servlet Tutorial.
  2. We can use annotations in Struts 2 to configure it’s action classes and result pages, check working example at Struts 2 Hello World Annotation Example.

Reference: Oracle website

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

About the authors
Default avatar


While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Still looking for an answer?

Ask a questionSearch for more help

Was this helpful?
DigitalOcean Employee
DigitalOcean Employee badge
July 16, 2019

Hi Pankaj, What do you mean when you say Retention policy is Source or Target. Can you give an example as well?

- Sagar Vora

    DigitalOcean Employee
    DigitalOcean Employee badge
    October 7, 2017

    Hi thanks for this tutorial. Please go for writtring an annotation processor thanks alot

    - hossein

      DigitalOcean Employee
      DigitalOcean Employee badge
      September 25, 2017

      All the concepts are easily explained. Post some more concepts of java 8 i need to know some basics, Thanks for sharing.

      - priya

        DigitalOcean Employee
        DigitalOcean Employee badge
        July 17, 2017

        very - very nice article about java annotation. the example is also very nice and simple very useful post thank you for this post

        - Anurag Singh

          DigitalOcean Employee
          DigitalOcean Employee badge
          October 8, 2016

          good sample with completed example, compared to other tutorials, which got various inconveniences to learner, like java files lumped together, or missing “import” some classes, etc. good work …

          - Victor

            DigitalOcean Employee
            DigitalOcean Employee badge
            August 25, 2016

            HI Buddy thanks for sharing useful and helpful information about Annotation.The Target annotation specifies which elements of our code can have annotations of the defined type. A concrete example will help explain this concept. Add the Target annotation to the Task annotation we defined earlier in the last post, as shown here: https://www.mindstick.com/Articles/12141/annotations-in-java-target-and-retention

            - Royceroy

              DigitalOcean Employee
              DigitalOcean Employee badge
              June 28, 2016

              Good explanation. Succinct and to the point without being verbose. My first working annotation! Thank you.

              - Shiraz

                DigitalOcean Employee
                DigitalOcean Employee badge
                January 7, 2016

                Hey Hi, I’m new to Java world and am trying to explore more thus am not sure if my question is worth your time - i want to initialize a bean with some parameters using java annotations. I’m able to achieve the same using XML though. Background - I’m trying to fetch the student (bean) details from classs (bean) where i want to initialize the studentid, student name and student age at bean initialization time. Any help here will be a great support

                - Mann

                  DigitalOcean Employee
                  DigitalOcean Employee badge
                  December 28, 2015

                  Hi Pankaj, Question: I currently have the situation that I can’t import the 3rd party package “com.journaldev.annotations” in my class so I have to load it using reflection. In this case, can you guide me how to use reflection to implement the toString() below with the @MethodInfo annotation? Thank you so much. @Override @MethodInfo(author = “Pankaj”, comments = “Main method”, date = “Nov 17 2012”, revision = 1) public String toString() { return “Overriden toString method”; }

                  - Key Naugh

                    DigitalOcean Employee
                    DigitalOcean Employee badge
                    September 21, 2015

                    Hi, please tell me how to do the same with method parammeters

                    - Palak

                      Try DigitalOcean for free

                      Click below to sign up and get $200 of credit to try our products over 60 days!

                      Sign up

                      Join the Tech Talk
                      Success! Thank you! Please check your email for further details.

                      Please complete your information!

                      Featured on Community

                      Get our biweekly newsletter

                      Sign up for Infrastructure as a Newsletter.

                      Hollie's Hub for Good

                      Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

                      Become a contributor

                      Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

                      Welcome to the developer cloud

                      DigitalOcean makes it simple to launch in the cloud and scale up as you grow — whether you're running one virtual machine or ten thousand.

                      Learn more
                      DigitalOcean Cloud Control Panel