@techwithvishalraj
Java
SpringBoot Annotation
Annotation on Main Class @techwithvishalraj
import
Indicate the main configuration class of a Spring Boot
@SpringBoot org.springframework
application. It combines (@Configuration +
Application .boot.autoconfigure
@EnableAutoConfiguration + @ComponentScan)
.SpringBootApplication;
import
It is a class-level annotation. The class annotated
org.springframework
@Configuration with @Configuration used by Spring Containers as a
.context.annotation
source of bean definitions.
.Configuration;
import
@EnableAuto org.springframework It auto-configures the bean that is present in the
Configuration .boot.autoconfigure classpath and configures it to run the methods.
.EnableAutoConfiguration;
It is used when we want to scan a package for beans.
import
It is used with the annotation @Configuration. We can
@Component org.springframework
also specify the base packages to scan for Spring
Scan .context.annotation
Components.
.ComponentScan;
@ComponentScan(basePackages = "com.java")
Annotation on Bean
import It is a method-level annotation. It is an alternative of
@Bean org.springframework XML <bean> tag. It tells the method to produce a bean
.context.annotation.Bean; to be managed by Spring Container.
Annotation on Controller Class @techwithvishalraj
import It is a specific type of Spring MVC controller that is
@RestContro
org.springframework.web.bind used to build RESTful web services
ller
.annotation.RestController; it combines (@Controller + @ResponseBody)
import
Validation is commonly used to check user input,
@Validated org.springframework.validation.
validate data from external sources
annotation.Validated;
@Request It is used to map the web requests. It has many
import
Mapping( optional elements like consumes, header, method,
org.springframework.web.bind
value= name, params, path, produces, and value. We use it
.annotation.RequestMapping;
"/uriPath") with the class as well as the method.
Annotation on Object
It is used to autowire spring bean on setter methods,
import
instance variable, and constructor. When we use
@Autowired org.springframework.beans
@Autowired annotation, the spring container auto-
.factory.annotation.Autowired;
wires the bean by matching data-type.
@techwithvishalraj
CRUD Operation Annotation
It maps the HTTP POST requests on the specific
import
handler method. It is used to create a web service
@PostMapping org.springframework.
endpoint that creates resource.
(value= "/uripath”) web.bind.annotation.
It is used instead of using:
GetMapping;
@RequestMapping(method = RequestMethod.POST)
It maps the HTTP GET requests on the specific
import
handler method. It is used to create a web service
@GetMapping org.springframework.
endpoint that fetches resource.
(value="/uriPath”) web.bind.annotation.
It is used instead of using:
GetMapping;
@RequestMapping(method = RequestMethod.GET)
It maps the HTTP PUT requests on the specific
import
handler method. It is used to create a web service
@PutMapping org.springframework.
endpoint that creates or updates resource.
(value="/uripath”) web.bind.annotation.
It is used instead of using:
PutMapping;
@RequestMapping(method = RequestMethod.PUT)
It maps the HTTP DELETE requests on the specific
import handler method. It is used to create a web service
@DeleteMapping org.springframework. endpoint that deletes a resource.
(value="/uripath”) web.bind.annotation. It is used instead of using:
DeleteMapping; @RequestMapping(method =
RequestMethod.DELETE)
Annotation on REST request @techwithvishalraj
import
It is used to bind HTTP request with an
@RequestBody org.springframework.web
object in a method parameter.
.bind.annotation.RequestBody;
@PathVariable import
used to extract values from the URI path
("email") org.springframework.web.bind.
and use them as method parameters
annotation.PathVariable;
import Annotation which indicates that a method
@RequestParam
org.springframework.web.bind parameter should be bound to a
(”email”)
.annotation.RequestParam; webrequest parameter.
@Pattern(regexp = "[a- import These annotations are used to validate
z]", message = "abc”) javax.validation incoming data before processing it in your
@NotNull, @Min, @Max .constraints.*; application.
If you have a REST endpoint then use
import jakarta.validation.Valid;
@Valid @Valid with a DTO class as a method
parameter.
Annotation on DTO
@NotNull, @Email
@Size(min = 2, max = 50) import
apply validation constraints to fields.
@Pattern(regexp = "[a-z]", javax.validation.constraints.*;
message = "abc”)
Annotation on Entity/Model @techwithvishalraj
@GeneratedValue Configures how the primary key is generated.
import
(strategy = Common strategies are GenerationType.IDENTITY,
javax.persistence
GenerationType GenerationType.SEQUENCE, and
.GenerationType;
.IDENTITY) GenerationType.AUTO.
import Marks a class as a JPA entity, representing a table
@Entity
javax.persistence.Entity; in the database.
Specifies the name of the database table to which
import the entity is mapped. You can also configure other
@Table
javax.persistence.Table; table properties like indexes and unique
constraints using this annotation.
import
@Id Specifies the primary key of the entity.
javax.persistence.Id;
Specifies the mapping of a field to a database
@Column(name= import
column, allowing you to configure properties like
"abc") javax.persistence.Column;
column name, length, and nullable constraints.
@OneToMany
import javax.persistence.*; Define relationships between entities.
@OneToOne
@JoinColumn import javax.persistence
to be used foreign/reference key
(name="abc") .JoinColumn;
import Marks a field as not persistent, meaning it won't be
@Transient
javax.persistence.Transien; mapped to a database column.
Stereotype Annotation @techwithvishalraj
This annotation is a generic stereotype for any
import
Spring-managed component. It tells Spring to
@Component org.springframework
scan the classpath for classes annotated with
.stereotype.Component;
@Component and create beans from them.
import This annotation is used to mark a class as a
@Controller org.springframework Spring MVC controller. It is typically used in
.stereotype.Controller; web applications to handle HTTP requests.
@Service(value= import org.springframework It is used at class level. It tells the Spring that
"xyzXyz") .stereotype.Service; class contains the business logic.
It is a class-level annotation. The repository is
import
a DAOs (Data Access Object) that access the
@Repository org.springframework
database directly. The repository does all the
.stereotype.Repository;
operations related to the database.
Transactional Annotation
If an exception is thrown within the method,
import
the transaction can be rolled back, ensuring
@Transactional org.springframework.transacti
data consistency.
on.annotation.Transactional;
You can annotate a specific method or class.
Exception Annotation @techwithvishalraj
This annotation is used to define a global
import exception handler that can be applied to multiple
org.springframework controllers. You can create a class annotated
@RestControllerAdvice
.web.bind.annotation with @RestControllerAdvice and define methods
.RestControllerAdvice; within it annotated with @ExceptionHandler to
handle specific exceptions.
@ExceptionHandler You can use the @ExceptionHandler annotation
import
(Exception.class) on methods within your controller classes to
org.springframework.we
handle specific exceptions for that controller.
b.bind.annotation
@ExceptionHandler(Inf This allows you to define exception handling logic
.ExceptionHandler;
yInternException.class) on a per-controller basis.
MethodArgumentNotValidException exception is
typically thrown when validating the request
import parameters, request body, or method arguments
org.springframework.we of a controller endpoint using annotation-based
@ExceptionHandler({
b.bind.MethodArgument validation (e.g., @Valid and validation
MethodArgumentNot
NotValidException; annotations like @NotNull, @Size, etc.).
ValidException.class,
ConstraintViolationException exception is more
ConstraintViolation
import closely associated with Bean Validation and is
Exception.class})
javax.validation.Constrai thrown when there are validation constraints
ntViolationException; violated on JavaBeans. These constraints are
typically defined using annotations like
@NotNull, @Size, @Email, etc.
import This annotation can be used to specify the HTTP
@ResponseStatus(Http org.springframework status code to return when a specific exception
Status.NOT_FOUND) .web.bind.annotation occurs. You can use it in combination with
.ResponseStatus; @ExceptionHandler.
Aspects Annotation @techwithvishalraj
Aspects in Spring Boot are commonly used for tasks like
import logging, security, transaction management, and performance
@Aspect org.aspectj.lang monitoring. They allow you to keep these cross-cutting
.annotation.Aspect; concerns separate from your core business logic, making your
codebase more modular and maintainable.
@AfterThrowing You define pointcut expressions using annotations like
import
@Before, @Before, @After, @Around, etc. These expressions determine
org.aspectj.lang
@After, where in your codebase the advice methods should be
.annotation.*;
@Around applied.
Test Annotation
@SpringBootTest It loads the entire Spring application context,
import
@SpringBootTest( making it suitable for integration tests. You can use
org.springframework.boot
webEnvironment = it with the webEnvironment attribute to specify the
.test.context
WebEnvironment. type of web environment( WebEnvironment.MOCK
.SpringBootTest;
MOCK) for a mock servlet environment).
It's often used to replace real dependencies with
@Mock import org.mockito.Mock;
mock objects to isolate the class under test.
import it is about the automatic injection of those mock
@InjectMocks
org.mockito.InjectMocks; objects into the class or object you are testing.
import This is a standard JUnit annotation used to mark a
@Test
org.junit.jupiter.api.Test; method as a test method.
Thank
you!
EXPLORE MORE
@techwithvishalraj
