DEV Community: Sri

Connecting to Redis cache and working with it

Sri — Mon, 01 Jun 2026 02:07:24 +0000

Start Redis Server Make sure Redis is running on the default port 6379. Test it: redis-cli ping Expected: PONG ________________________________________
Add Dependency For Maven: org.springframework.boot spring-boot-starter-data-redis ________________________________________
Configure Redis application.properties spring.data.redis.host=localhost spring.data.redis.port=6379 ________________________________________
Define a RedisTemplate Bean (Optional)
@Configuration
public class RedisConfig {

@bean
public RedisTemplate redisTemplate(
RedisConnectionFactory connectionFactory) {
```
RedisTemplate<String, Object> template =
        new RedisTemplate<>();

template.setConnectionFactory(connectionFactory);
return template;
```
}
}
Use RedisTemplate
Store Data
@Service
public class RedisService {

@Autowired
private RedisTemplate redisTemplate;

public void save(String key, String value) {
redisTemplate.opsForValue().set(key, value);
}
}
Read Data
public String get(String key) {
return (String) redisTemplate.opsForValue().get(key);
}
Delete Data
public void delete(String key) {
redisTemplate.delete(key);
}
Controller Example
@RestController
@RequestMapping("/redis")
public class RedisController {

@Autowired
private RedisService redisService;

@PostMapping("/{key}/{value}")
public String save(
@PathVariable String key,
@PathVariable String value) {
```
redisService.save(key, value);
return "Saved";
```
}

@GetMapping("/{key}")
public String get(@PathVariable String key) {
return redisService.get(key);
}

@DeleteMapping("/{key}")
public String delete(@PathVariable String key) {
redisService.delete(key);
return "Deleted";
}
}
Caching with Redis
Enable caching:
@SpringBootApplication
@EnableCaching
public class Application {
}
Use cache annotations:
@Cacheable("users")
public User getUser(Long id) {
return userRepository.findById(id).orElse(null);
}
@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) {
userRepository.deleteById(id);
}

execute Get URL in postman:
http://localhost:8080/book/getAllBookDetails
output:

{
    "id1": 6,
    "author": {
        "authorId": 1,
        "authorName": null,
        "contactNumber": null,
        "state": null
    },
    "name": "PHYTHON"
}

]
REDIS in command prompt:
127.0.0.1:6379> keys *
1) "Books::6"
127.0.0.1:6379>

Step 2:
initialising delete method with
@CacheEvict(value = "Books", key = "#bookIDFromRequest")
@DeleteMapping("/DeleteBookDetails/{bookIDFromRequest}")
public ResponseEntity DeleteBookDetails(@PathVariable int bookIDFromRequest) {
log.info("entering DeleteBookDetails");
String upDateBookStatus= bookService.DeleteBookDetailsService(bookIDFromRequest);
log.info("upDateBookStatus "+upDateBookStatus);
ErrorTemplate error = new ErrorTemplate();
if(upDateBookStatus.equalsIgnoreCase("DeleteBook Failed")){
error.setStatusCode(200);
error.setMessage("book id not found");
return ResponseEntity.status(400).body("Book id not found");
}

Common Startup Error
If you see:
Unable to connect to Redis
Connection refused: localhost:
Points to remember

Entity class must implements Serializale interface so as to allow @cachale to serialise the response oject.

Redis Installation on windows

Sri — Mon, 01 Jun 2026 01:52:45 +0000

Start server:

Option 1: Run Command Prompt as Administrator
Close the current Command Prompt.
Open the Start menu.
Search for cmd.
Right-click Command Prompt → Run as administrator.
Run

sc start redis
>redis-cli.exe ping expected output: PONG
redis-cli
server with port no will be prompt in keys *

Shutdown server:

Redis-cli
shutdown

delete keys
1.type cmd Keys *

"Hello"
"Sample"
"Books::6"
del Books::6
output
(integer 1)
delete multiple keys

del Hello Sample
(integer) 2

Delete All Keys in Current Database
FLUSHDB

⚠️ This removes all keys from the currently selected Redis database.

Delete All Keys in All Databases
FLUSHALL

⚠️ This removes everything from Red

Rest Template - API for developers- Spring Boot

Sri — Fri, 29 May 2026 12:38:53 +0000

RestTemplate is a synchronous Spring Framework client used to consume RESTful web services by simplifying HTTP communication.
Synchronous Communication: It blocks the execution thread until a response is received.HTTP Methods: It provides built-in methods for standard operations like GET, POST, PUT, and DELETE.Automatic Mapping: It can automatically convert JSON or XML responses into Java domain objects using message converters.Status: While widely used, it is in maintenance mode. For new projects, Spring recommends using the modern RestClient or the reactive.

Its an automate work.

getForObject() Performs a GET request and returns the response body directly as an object.
getForEntity() Performs a GET request and returns a ResponseEntity (includes status and headers).
postForObject() Sends data via POST and returns the mapped response body.
exchange() A general-purpose method for all HTTP verbs, offering full control over headers and request entities.

getForObject-
Controller Snippet
Response is received in Object format.
@RestController
@RequestMapping("/api")
public class ApiController {

@Autowired
private ApiService apiService;

@GetMapping("/getUsers")
public String users() {
    return apiService.getUsers();
}

Service snippet:
@Service
public class ApiService {

@Autowired
private RestTemplate restTemplate;
@Autowired
UserApiRepo userApiRepo;
public String getUsers() {

    String url = "https://jsonplaceholder.typicode.com/users";

    String response = restTemplate.getForObject(url, String.class);

    return response;
}

Response:

"id": 1,
"name": "Leanne Graham",
"username": "Bret",
"email": "Sincere@april.biz",
"address": {
  "street": "Kulas Light",
  "suite": "Apt. 556",
  "city": "Gwenborough",
  "zipcode": "92998-3874",
  "geo": {
    "lat": "-37.3159",
    "lng": "81.1496"
  }
},
"phone": "1-770-736-8031 x56442",
"website": "hildegard.org",
"company": {
  "name": "Romaguera-Crona",
  "catchPhrase": "Multi-layered client-server neural-net",
  "bs": "harness real-time e-markets"
}

getForEntity()
Response is received in ResponseEntity Format. It has Response Header,Response body an response.
@GetMapping("/callGetEntityApi/{id}")
public String callApi(@PathVariable String id) {

    RestTemplate restTemplate = new RestTemplate();

    String url = "https://jsonplaceholder.typicode.com/posts/"+id;

    ResponseEntity<String> response =
            restTemplate.getForEntity(url, String.class);
   System.out.println("response.getStatusCode() " +response.getStatusCode() +"response.getHeaders() " +response.getHeaders());
    return response.getBody();
}

Output:
http://localhost:8080/api/callGetEntityApi/1
{
"userId": 1,
"id": 1,
"title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
"body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
}

LogS:
2026-05-29T18:09:20.680+05:30 DEBUG 216 --- [LearningDemo] [nio-8080-exec-3] o.s.web.client.RestTemplate : Response 200 OK
2026-05-29T18:09:20.682+05:30 DEBUG 216 --- [LearningDemo] [nio-8080-exec-3] o.s.web.client.RestTemplate : Reading to [java.lang.String] as "application/json;charset=utf-8"
2026-05-29T18:09:20.688+05:30 DEBUG 216 --- [LearningDemo] [nio-8080-exec-3]** m.m.a.RequestResponseBodyMethodProcessor : Using 'text/plain', given [/] and supported [text/plain, /, application/json, application/+json]*
2026-05-29T18:09:20.690+05:30 DEBUG 216 --- [LearningDemo] [nio-8080-exec-3] m.m.a.RequestResponseBodyMethodProcessor : Writing ["[ { "id": 1, "name": "Leanne Graham", "username": "Bret", "email": "Sincere@april. (truncated)..."]
2026

** PostForOject-**
Service:
public String createPost(JSOnRequest jsOnRequest) {

    String url = "https://jsonplaceholder.typicode.com/posts";

    Map<String, Object> body = new HashMap<>();

    body.put("title",jsOnRequest.getTitle() );
    body.put("body", jsOnRequest.getBody());
    body.put("userId", jsOnRequest.getUserId());

    String response = restTemplate.postForObject(
            url,
            body,
            String.class
    );

    return response;
}
**Controller**
 @PostMapping("/postUsers")
public String postUsers(JSOnRequest request) {
    return apiService.createPost(request);
}

** Output**

"title": "Java3",
"body": "Dell-Dark",
"userId": "4",
"id": 101

headforheaders
Service
public MediaType getheadforheaders(){
String url = "https://jsonplaceholder.typicode.com/users";
HttpHeaders response = restTemplate.headForHeaders(url);
log.info(response.toString());
@Nullable MediaType responseList = response.getContentType();
return responseList;
}

Controller
@GetMapping("/getheadforheaders")
public MediaType headforheaders() {
return apiService.getheadforheaders();
}
Output
{
"charset": "UTF-8",
"concrete": true,
"parameters": {
"charset": "utf-8"
},
"qualityValue": 1.0,
"subtype": "json",
"subtypeSuffix": null,
"type": "application",
"wildcardSubtype": false,
"wildcardType": false
}
delete
Service
public String getdeleteUser(Integer bookid){
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/book/DeleteBookDetails/{bookId}";
restTemplate.delete(url,bookid);
return "Success";
}
Controller:
@GetMapping("/deleteUser/{id}")
public String deleteUser(@PathVariable Integer id) {
return apiService.getdeleteUser(id);
}
http://localhost:8080/api/deleteUser/3
output :: success

PostForEntity
@PostMapping("/send")
public String sendRequest(@RequestBody Laptop laptop) {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/Laptop/saveLaptop";
log.info("laptop.getModelName() "+laptop.getModelName()+"laptop.getLaptopModelId() " +laptop.getLaptopModelId()
+"laptop.getPrice() " +laptop.getPrice());
ResponseEntity response =restTemplate.postForEntity(
url,
laptop,
String.class);
log.info(response.getStatusCode().toString());
return response.getBody();
}
RestTemplate.exchange() is the most flexible method in RestTemplate. It allows you to specify:

HTTP method (GET, POST, PUT, DELETE, etc.)
Request headers
Request body
Response type Method Signature: ResponseEntity exchange( String url, HttpMethod method, HttpEntity<?> requestEntity, Class responseType )

Example
@RequestMapping("/getExchange")
public ResponseEntity getExchange(HttpServletRequest request){
RestTemplate restTemplate = new RestTemplate(); // Initiate restTemplate
//Get BearerAuth from Heaer
String token=getBearertokenFromRequest(request);
log.info("token "+token);
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
//Perform Exchange Activity
HttpEntity entity = new HttpEntity<>(headers);
String URL="http://localhost:8080/book/getBookDetailsForID/6";
ResponseEntity response =
restTemplate.exchange(
URL,
HttpMethod.GET,
entity,
String.class
);

System.out.println(response.getBody());
return response;

}
public String getBearertokenFromRequest(HttpServletRequest request){
System.out.println("insie token");
String authHeader=request.getHeader("Authorization");
log.info("authHeader "+authHeader);
if(authHeader.startsWith("Bearer ")) {
return authHeader.substring(7);
}
return "Invalid Token";
}

}

Spring Security

Sri — Tue, 19 May 2026 13:01:09 +0000

Spring security provides authentication an authorisation.
Spring Security is a security framework for Java and Spring Boot applications.

It provides:

Authentication → verifying user identity
Authorization → controlling access
Session management
Password encryption
CSRF protection
JWT/OAuth2 support
Spring security will be enabled after adding below XML defintions in POM.xml.

org.springframework.boot
spring-boot-starter-security

org.springframework.boot
spring-boot-starter-security-test
test

Spring security filters almost all pages except the pages which is marked to permit and gives login page.

Type 1:
Passwor will be automatically generate in devleoper tool console and user will be user.
This password will be changedd on each application bootup.
Flow :

http://localhost:8080/First/add/6/8
when the user clicks this link, instead of displaying output a login page will be shown, this is prewritten and plugged in using xml definition. the actual output of addition will be displayed after authentication.
Type:2
Adding our own username and password in application properties.
spring.security.user.name=admin
spring.security.user.password=generate
Now application will not generate password but a login page will be shown on clicking the addition endpoint.
User has to enter correct username and password mentioned in application.properties. After authenticating him, he will be redirected to the output page,else error with status code 403 will be displayed
Type3:
Adding multiple users.
we cannot add all users in property file. Though property file will not accept adding duplicate properties, in real time we will be having huge data and adding in property or convincing it to accept is not an idea.

So we can achieve this multiple user concept in spring security using UserDetailsManager Interface. Its implementation class is InMemoryUserDetailsManager.
This accepts a list with userDetails objects.
UserDetails is a static method with methods to add username,password,roles etc.

Here is the code snippet:
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@bean
public UserDetailsManager createUserDetailsManager(){

UserDetails user1= User.withUsername("Sri").password("{noop}generate").roles("admin").build();
UserDetails user2=User.withUsername("Desigan").password("{noop}generate").roles("user").build();
// Add users to the UserDetailsManager
List l = Arrays.asList(user1, user2);
UserDetailsManager userDetailsManager = new InMemoryUserDetailsManager(l);
return userDetailsManager;
}

Authorisation:
It works based on user privilages.
User with admin access can see all pages.
User with read access can view pages but he cannot make any changes.
we can set these privilages in security config class.

@bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

    http
       // Disable CSRF (useful for REST APIs)
            .csrf(csrf -> csrf.disable())

       // Authorization rules
 .authorizeHttpRequests(auth -> auth
 .requestMatchers("/calc/add/**").permitAll()   // No auth required
 .requestMatchers("/calc/sub/**").hasRole("USER")
 .requestMatchers("/calc/mul/**").hasRole("ADMIN")
 .requestMatchers("/calc/div/**").hasRole("ADMIN")
 .anyRequest().authenticated()
            )
 .formLogin(Customizer.withDefaults());

    return http.build();
}

In above snippet ".permitAll()" allows the user to view endpoint without any authentication.
For all the requestMatchers("/div/").hasRole("user") -> user with User role will be able to view this page.
**Option 2: JDBCUserDetialsManager.
It is nothing but communicating with database to perform login.
It has four steps, 1. collect data from UI 2. Request Database for UserDetails using loadByUserName(username) method from UserDetailService interface.

compare data from UI with data from DB
Provide success or failure login based on the results from above step. To achieve this we need load data into DB first, This is what we call as "SIGNUP". Im going to write an endpoint and send a request from POSTMan and load data into Database. This request again pass through Spring security firewall check. To allow our request to endpoint we can request spring security to permit our endpoint URL by adding below line.

public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

http.csrf(csrf -> csrf.disable())

            .authorizeHttpRequests(auth -> auth
             .requestMatchers("/", "/error").permitAll()
             .requestMatchers("/First/signUp/**").permitAll()
             .anyRequest().authenticated())
            .formLogin(Customizer.withDefaults());
           // .httpBasic(Customizer.withDefaults());

    return http.build();
}

Controller:
@RequestMapping("/signUp")
////@ResponseBody
public ResponseEntity processUserSignUp(@RequestBody User user ){
log.info("inside LearningFrontController.getmultiplyService");
response=calculatorService.processUserSignUp(user);
log.info(response);
if(response.equalsIgnoreCase("success")){
return ResponseEntity.status(200).body(response);
}
log.info("exiting LearningFrontController.getmultiplyService");
return ResponseEntity.status(400).body("Signup failed");
}
Service:
public String processUserSignUp(User user){
String response="failed";
UserDetailsEntity userDetailsEntity = new UserDetailsEntity();
userDetailsEntity.setUserName(user.getUserName());
String maskedPassword=passwordEncoder.encode(user.getPassword());
userDetailsEntity.setMaskedPassword(maskedPassword);
userDetailsEntity.setUserRole(user.getRoles());
UserDetailsEntity userDetailsEntity1= customUserDetailsRepo.save(userDetailsEntity);
if(userDetailsEntity1!=null) {
return "success";
}
return response;
}
JSON:

{
"userName":"Sri",
"Password":"generate",
"roles":"User"
}
What we have in table?
UserNo PAssword userName Role
202 $2a$10$PtbhgrteGOLk0azcyGK1x SriKamini USER
203 $2a$10$WcefaBSrdqTIqLLOAh3XNep Sri USER
Authenticate and Generate Token if authencation passes
Step 1. *implement UserDetailsService Interface *

public class CustomUserDetailService implements UserDetailsService {
@Autowired
CustomUserDetailsRepo customUserDetailsRepo;

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    Optional<UserDetailsEntity> userDetailsEntityList = customUserDetailsRepo.findByUserName(username);

    if (userDetailsEntityList == null)
        return null;
    else {
        UserDetailsEntity userDetailsEntity = userDetailsEntityList.get();
        //convert userDetailsEntity to UserDetails
        UserDetails userDetails = User.withUsername(userDetailsEntity.getUserName())
                .password(userDetailsEntity.getMaskedPassword())
                .roles(userDetailsEntity.getUserRole()).build();
        return userDetails;

    }
}

}
Step2 IncluDe DAOAuthenticationProviDer in security Config
Getting UserDetailsService in Below Snippet
@bean
public UserDetailsService userDetailsService(){
return new CustomUserDetailService();
}
//Passing this generate CustomUserDetailService to DaoAuthenticationProvider
@bean
DaoAuthenticationProvider daoAuthenticationProvider(){
DaoAuthenticationProvider daoAuthenticationProvider
=new DaoAuthenticationProvider(userDetailsService());
daoAuthenticationProvider.setPasswordEncoder(passwordEncoder());
return daoAuthenticationProvider;
}

//Creating an instance AuthenticationManager
@bean
public AuthenticationManager authenticationManager(
AuthenticationConfiguration config)
throws Exception {

    return config.getAuthenticationManager();
}

Step3
Perform login from POSTMAN,
This mentioneD Snippet will authenticate username & passwor coming in RequestBody.
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody User request) {
log.info("inside login");
log.info("request.getUserName(), "+request.getUserName() + request.getPassword() + request.getPassword());
Authentication authentication = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(
request.getUserName(),
request.getPassword()
)
);
String token = "";
log.info("authentication.isauthenticated"+authentication.isAuthenticated());
if(authentication.isAuthenticated()) {
UserDetails userDetails = (UserDetails) authentication.getPrincipal();
token = jwtUtils.generateToken(String.valueOf(userDetails));
}
return ResponseEntity.ok(token);
}
PostMan JSON
{
"userName": "SriKamini",
"Password": "generate"
}
output:
eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJvcmcuc3ByaW5nZnJhbWV3b3JrLnNlY3VyaXR5LmNvcmUudXNlcmRldGFpbHMuVXNlciBbVXNlcm5hbWU9U3JpS2FtaW5pLCBQYXNzd29yZD1bUFJPVEVDVEVEXSwgRW5hYmxlZD10cnVlLCBBY2NvdW50Tm9uRXhwaXJlZD10cnVlLCBDcmVkZW50aWFsc05vbkV4cGlyZWQ9dHJ1ZSwgQWNjb3VudE5vbkxvY2tlZD10cnVlLCBHcmFudGVkIEF1dGhvcml0aWVzPVtST0xFX1VTRVJdXSIsImlhdCI6MTc3OTQ2ODEzNSwiZXhwIjoxNzc5NDY4NzM1fQ.EcUWMgOumkHi3Qo7Ggq7ju8FXqvrNob6_YSOm7WmbYs
Login 2 Authorise the username & password coming in authorise tab in POSTMan. i.e credentials coming in authorise tab

Login :

Rest Login using UserName an password in Request body
Rest Login using UserName an password in Autorisation tab an request body can be anything & an it can be empty
Rest Login using bearer token.
Custom Login - Overrides default spring security login and it takes userdefined custom login. a.After custom Login redirect to home page b. After custom login redirect to the same endpoint which called custom login.

_ Rest Login using UserName an password in Request body_
** Rest Login using UserName an password in Autorisation tab an request body can be anything & an it can be empty**
Security config takes " .httpBasic(Customizer.withDefaults())"

SecurityConfig.class:
@bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
.authorizeHttpRequests(auth -> auth
.requestMatchers("/", "/error").permitAll()
.anyRequest().authenticated())
.httpBasic(Customizer.withDefaults())
.addFilterBefore(
jwtAuthFilter,
UsernamePasswordAuthenticationFilter.class);
return http.build();
}
AuthController.java
@RestController
@RequestMapping("/api/1.0/security")

public class AuthController {
private static final Logger log= LoggerFactory.getLogger(AuthController.class);
@Autowired
private AuthenticationManager authenticationManager;
@PostMapping("/perform_login")
public ResponseEntity<?> login(@RequestBody User request) {
log.info("inside login");
log.info("request.getUserName(), "+request.getUserName() + request.getPassword() + request.getPassword());
Authentication authentication = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(
request.getUserName(),
request.getPassword()
)
);
String token = "";
log.info("authentication.isauthenticated"+authentication.isAuthenticated());
if(authentication.isAuthenticated()) {
UserDetails userDetails = (UserDetails) authentication.getPrincipal();
token = jwtUtils.generateToken(userDetails.getUsername());

    }
    return ResponseEntity.ok(token);
}

JWTUTil.java
public String generateToken(String username) {
return Jwts.builder()
.setSubject(username) // payload
.setIssuedAt(new Date())
.setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 10)) // 10 mins
.signWith(key)
.compact();

2.** Rest Login using UserName an password in Autorisation tab an request body can be anything & an it can be empty**
If you enter username and password in authorisation tab,
.httpBasic(Customizer.withDefaults()) will accept the input and handle the request.
3.Rest Login using bearer token.
JWT comes in picture to accept and validate this token.
below snippet is the controller code to accept the token and validate it.
if jwt is enale in security config, JWT Auth filter handles this request an validates even Before it reaches controller

@GetMapping("/token")
public String token(HttpServletRequest request){
System.out.println("insie token");
String authHeader=request.getHeader("Authorization");
log.info("authHeader "+authHeader);
if(authHeader.startsWith("Bearer ")) {
return authHeader.substring(7);
}

        return "Invalid Token";
    }

doFilterInternal() in JWTAuthFilter accepts all requests using "OncePerRequestFilter". If 1000 requests comes in then all these 1000 request must pass through this filter "OncePerRequestFilter "
@Component
public class JwtAuthFilter extends OncePerRequestFilter {
@override
protected void doFilterInternal(
HttpServletRequest request,
HttpServletResponse response,
FilterChain filterChain)
throws ServletException, IOException {
log.info("insife doFilterInternal");
String authHeader = request.getHeader("Authorization");
String token = null;
String username = null;
log.info("authHeader " + authHeader);
try{
try {
if (authHeader != null && authHeader.startsWith("Bearer ")) {
token = authHeader.substring(7);
log.info("token " + token);
log.info(jwtUtils.toString());
username = jwtUtils.getUserName(token);
log.info("username " + username);
}} catch(Exception ex){
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
return;
}

    if (username != null &&
            SecurityContextHolder.getContext().getAuthentication() == null) {

        UserDetails userDetails =
                userDetailService.loadUserByUsername(username);
        log.info("value of valiate token " + jwtUtils.validateToken(token, userDetails));
        log.info("authorities "+userDetails.getAuthorities());
        if (jwtUtils.validateToken(token, userDetails)) {

            UsernamePasswordAuthenticationToken authentication =
                    new UsernamePasswordAuthenticationToken(
                            userDetails,
                            null,
                            userDetails.getAuthorities()
                    );

            log.info("Credentials "+authentication.getCredentials());
            log.info("authorities " + userDetails.getAuthorities());
           // authentication.setDetails(userDetails);
            authentication.setDetails(
                    new WebAuthenticationDetailsSource()
                            .buildDetails(request)
            );

            SecurityContextHolder.getContext()
                    .setAuthentication(authentication);
        }
    }
    filterChain.doFilter(request, response);
}
catch(
Exception e) {
    e.printStackTrace();
}

}

Custom Login - Overrides default spring security login and it takes userdefined custom login.

database connection object is achieved using
declare this code in security connection class.
@bean
public UserDetailsService userDetailsService(){
return new CustomUserDetailService();
}
@bean
DaoAuthenticationProvider daoAuthenticationProvider(){
DaoAuthenticationProvider daoAuthenticationProvider=new DaoAuthenticationProvider(userDetailsService());
daoAuthenticationProvider.setPasswordEncoder(passwordEncoder());
return daoAuthenticationProvider;
}
@bean
public AuthenticationManager authenticationManager(
AuthenticationConfiguration config)
throws Exception {

    return config.getAuthenticationManager();
}

private final JwtAuthFilter jwtAuthFilter;

public SecurityConfig(JwtAuthFilter jwtAuthFilter) {
    this.jwtAuthFilter = jwtAuthFilter;
}

security config also takes Below code
.formLogin(form -> form
.loginPage("/api/1.0/security/login")
.loginProcessingUrl("/api/1.0/security/perform_login")
.defaultSuccessUrl("/First/index", true)
.failureUrl("/loginPage?error=true")
.permitAll())
when defaultSuccessUrl is enaBled.after successful login, home page will be redirected.
if we want to redirect to the enpoint which called the login service,
step 1: http://localhost:8080/First/add/6/8
Spring security custom login page will be displayed.
after entering the credentials,".loginProcessingUrl("/api/1.0/security/perform_login")" will Be processed. JWTAuthFilter will happen and endpoint AuthController an its ,method with request mapping "perform_login" will de called. username authentication will happen here.
Post Login,http://localhost:8080/First/add/6/8, Controller "First"with requestmapping"6 and 8 will be processed and output is displayed.

Can we send RequestParams in POSTMAN?

yes under the Body tab we have form_data tab.
It takes key and value. we can send out requestparams in key as param name and value as its value to be processed.

Spring Annotations Part2

Sri — Thu, 16 Apr 2026 18:37:49 +0000

@Restcontrolleradvice **
A convenience annotation that combines @ControllerAdvice and @ResponseBody. It is designed for RESTful APIs where the return value of an exception handler is automatically serialized into the response body (typically as JSON or XML) instead of being resolved as a view.
**@ExceptionHandler
We can use @ExceptionHandler to annotate methods that Spring automatically invokes when the given exception occurs. We can specify the exception either with the annotation or by declaring it as a method parameter, which allows us to read out details from the exception object to handle it correctly. The method itself is handled as a Controller method.
EX:
@RestControllerAdvice
public class ExceptionController {
@ExceptionHandler(NullPointerException.class)
public String hanleNullPointerException(NullPointerException ex){
return "Error: "+ex.getMessage();
}

@ExceptionHandler(MethodArgumentNotValidException.class)
public String hanleIllegalArgumentException(MethodArgumentNotValidException ex){
    return "Error: "+ex.getMessage();
}

}
@valid:
It informs controller about the presence of @ExceptionHandler.
When an exception occurs,Spring container redirects the flow to corresponding Exception handler method
@PostMapping("/SaveBookDetails")
public String SaveBookDetails(@RequestBody @valid BookDetails bookDetails) {
log.info("entering ProcessBookDetailsController");
String ValueFromService=bookService.SaveBookDetails(bookDetails);
log.info("leaving ProcessBookDetailsController");
return ValueFromService;
}

To Enable validations in coding we have Spring Boot validation dependency.
For Spring Boot applications, the standard dependency for enabling Bean Validation is spring-boot-starter-validation. This starter provides the Jakarta Bean Validation API and Hibernate Validator as the default implementation.
Enabling Validation: Once the dependency is added, you must use annotations such as @valid or @Validated on your controller method parameters (e.g., @RequestBody) to trigger the validation process.
Standard Annotations: The dependency supports standard JSR-380 annotations including @NotNull, @notblank, @Size, @min, @max, and @Email.
Historical Note: Starting with Spring Boot 2.3, the validation starter is no longer included by default in spring-boot-starter-web or spring-boot-starter-webflux. You must add it explicitly to your project.
Error Handling: When validation fails, Spring Boot typically throws a MethodArgumentNotValidException, which can be captured using a Global Exception Handler with @ControllerAdvice.

pom.xml
Dependency Configurations

org.springframework.boot
spring-boot-starter-validation

org.springframework.boot
spring-boot-starter-validation-test
test

Code:
package LiBrary;

import jakarta.validation.constraints.*;

public class BookDetails {
@NotEmpty

String bookName;

@NotNull
@Positive
@Min(0)
@Max(50)
int bookId;
double price;

@NotBlank
@NotEmpty
String authorName;
String Genre;
@Email
String email;

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}

public double getPrice() {
    return price;
}

public void setPrice(double price) {
    this.price = price;
}

public String getBookName() {
    return bookName;
}

public void setBookName(String bookName) {
    this.bookName = bookName;
}

public int getBookId() {
    return bookId;
}

public void setBookId(int bookId) {
    this.bookId = bookId;
}

public String getGenre() {
    return Genre;
}

public void setGenre(String genre) {
    Genre = genre;
}

public String getAuthorName() {
    return authorName;
}

public void setAuthorName(String authorName) {
    this.authorName = authorName;
}

}
Setting default error message for valid annotations:
@NotEmpty(message="bookname cannot be blank")
String bookName;

@NotNull(message="Book id cannot be null")
@Positive(message="Book Id must be +ve")
@Min(0)
@Max(50)
int bookId;
double price;

@NotBlank(message="author name cannot be blank")
@NotEmpty(message="author name cannot be empty")
String authorName;
String Genre;
@Email(message="Not a valid email address")
String email;

error message:
arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [bookDetails.bookId,bookId]; arguments []; default message [bookId]]; default message [Book Id must be +ve]] [Field error in object 'bookDetails' on field 'authorName': rejected value [ ]; codes [NotBlank.bookDetails.authorName,NotBlank.authorName,NotBlank.java.lang.String,NotBlank]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable:

ResponseEntity:
ResponseEntity is a class in the Spring Framework used to represent the entire HTTP response. Unlike simply returning an object, it allows developers to fully configure the status code, headers, and response body sent back to the client.
It can be any objectlike List, Map or user define class

1.public class ResponseEntity extends HttpEntity

Extension of HttpEntity that adds an HttpStatusCode status code. Used in RestTemplate as well as in @Controller methods. 3.In RestTemplate, this class is returned by getForEntity() and exchange(): Snippet 1: ResponseEntity entity = template.getForEntity("https://example.com", String.class); String body = entity.getBody(); MediaType contentType = entity.getHeaders().getContentType(); HttpStatus statusCode = entity.getStatusCode(); Snippet 2 public ResponseEntity hanleIllegalArgumentException(MethodArgumentNotValidException ex){ Map errors=new HashMap(); //Code Snippet 1 - displays only key error message ex.getBindingResult().getFieldErrors().forEach(Error->{ errors.put(Error.getField(),Error.getDefaultMessage()); }); return new ResponseEntity("validation error "+errors , HttpStatusCode.valueOf(400)); //Code Snippet 2 - displays all error with vast data // return new ResponseEntity("validation error "+ex.getMessage() , HttpStatusCode.valueOf(400)); } output: validation error {authorName=author name cannot be blank, bookName=bookname cannot be blank, email=Not a valid email address, bookId=must be less than or equal to 50}

In above snippet we returned a map. we can also return a class
References:

SpringBoot Basic Annotations and Logging

Sri — Thu, 09 Apr 2026 12:49:38 +0000

Today we learned to create a spring project in Spring initializer.
Here we learnt metadata is data about data, some of metadata in maven is artifact,groupid and version.
we also learned about maven project structure and adding spring web dependency. Spring web gives tomcat automatically, whereas in eclipse we as a programmer explicitly add apache tomcat server and bring it up. spring web helps to withhold tomcat server and container takes care of bringing the server up. it helps developer to concentrate on business log instead of working in bringing the server up. Its a great feature of spring boot.

Exploring logs:
application.properties

server.port = 8080 //port in which localhost will be accessed
logging.level.root=INFO //logger prints all abstract information into the console.
logging.level.root=DEBUG // It prints all debug informations.errors.and INFO into the console.
logging.level.root=TRACE// It prints fine-grained logic flow. 5.logging.level.com.spring.LearningDemo = DEBUG //If we want to print only our package logs, we can do it. 6.If we want to have a external logging file in local disk we use below code in application.properties. logging.file.name = myapp.log logging.file.path="/E:Spring projects/LearningDemo"
In production we use logging.level.root=INFO to avoid unneccesary loggings. we use DEBUG only when we want identify a bug.

context pat is the base URL of app. here http://localhost:8080/index.

Annotations:
@Controller
Container idetifies the mentioned class as container using this annotation.

@Controller
public class LearningFrontController {

public String getResponseFromLearningFrontController(){
return "Welcome to SpringBootFrontController";
}
}
In core Java programmer has to initialise an object to call any method from one class to another. whereas in spring and spring boot container takes of creating instances, programmer can concentrate on the business logic.
A project can have any no of controllers, we can differentiate them using requestmapping annotaion.
@Controller
@RequestMapping("First")
public class LearningFrontController {
private static final Logger log= LoggerFactory.getLogger(LearningFrontController.class);

public String getResponseFromLearningFrontController(){
log.info("LearningFrontController started");
log.debug("Debug:LearningFrontController started");
log.debug("Debug:LearningFrontController completed");
return "Welcome to SpringBootFrontController";
}

}

similarly a single container can have any no of methods so we exlplicitly differentiate the method using @RequestMapping("/add")

@RequestMapping("/add/{a}/{b}")
@ResponseBody
public String getAddResponseFromLearningFrontController(@PathVariable int a,@PathVariable int b){
log.info("LearningFrontController started");
log.debug("Debug:LearningFrontController started");
int c=a+b;
log.debug("Debug:LearningFrontController completed");
log.debug("Debug:LearningFrontController completed");
return "Addition is "+c;
}
This method usually returns the view name and view resolver returns it to the client but when we want to return a value and inform the container to print the returned value as content of the page, we use "@ResponseBody"
@RequestMapping("/Login/{username}/{password}")
//@ResponseBody
public String Login(@PathVariable String username,@PathVariable String password)
{
log.debug("Debug:welcomeUser started");
String name1 =username;
log.debug("Debug:welcomeUser completed");
return "welcome "+username;

@RestController
Combination of both Responsebody and controller.
when all methods in the container uses response body, then we can mention one annotation at the top of the controller.
@RestController
@RequestMapping("/second")
public class LearningFrontREquestController {
private static final Logger log= LoggerFactory.getLogger(com.learning.LearningDemo.LearningFrontController.class);

    public String getResponseFromLearningFrontController(){
        log.info("LearningFrontController started");
        log.debug("Debug:LearningFrontRequstController started");
        log.debug("Debug:LearningFrontrequstController completed");
        return "Welcome to SpringBootFrontController";
    }

Difference between Pathvariable and RequestPAram
@PathVariable
1.user is sending input to the method in URL.

Service will fetch this input from the url and handles in method when @Pathvariable is mentioned.
URL format is http:/localhost::8080/firstControllerNameMappe/CallingMethoMap/{input1}/{input2}
Its param are unique value like userid
It can take only 20 arguments & It cannot take null values. if values are not sent in URL,it will throw 404 error.

6.Using java.util.Optional: You can wrap the parameter in an Optional type (e.g., Optional id). If the path variable is missing from the URI, the value will be Optional.empty() rather than null.
7.Handling with a Map: You can use a Map to capture all path variables. If a specific key is missing, its value in the map will be null.
8.Using pathVariableOrNull (WebFlux): For applications using Spring WebFlux, the ServerRequest interface provides a pathVariableOrNull() helper method to handle missing variables gracefully.

_@RequestParam
_1. Service will receive inputs from URL & URL is in below format
http://localhost:8080/firstControllerNameMappe/CallingMethoMap?input1=6&input2=9

Request can have any no of arguments & it wont represent unique id
it usually fetches a lengthy data ex:getting all the students name starting in K. It obviusly returns n no of data
It wont take empty arguments

@RequestBody
when the input is in JSON format. we use RequestBody.
JAckson library helps to convet JSON to object inside spring boot application and it also converts the object to JSON and send it back to POSTMAN.

@RequestMapping("/divide")
//@ResponseBody
public Student getDivideService(@RequestBody Student student){
log.info("inside LearningFrontController.getSubtractService");
int a=student.getFirstValue();
int b=student.getSecondValue();
log.info("a "+a +"b "+b);
if((a!=0)&&(b!=0)) {
double divided = learningDemoService.divitionService(a, b);
student.setDivided(divided);
}
student.setName(student.getName().toUpperCase().trim());
log.info(response);
log.info("exiting LearningFrontController.getSubtractService");
return student;
}
}

Object creation:
In java:
To have interaction between classes we will create object using new keyword.
Student object=new Student();

In Spring framework.
we will declare in XML

In spring boot we have two annotations

Component
Bean Component:
It is declared in class level. If @Comparable is mentioned on top of class, An object will be create on compile time.
Auto-detected via classpath scanning.
Limited; uses Spring's default instantiation.
Has specialized forms: @Service, @Repository, @Controller,@Configuration.
@Component is an interface

Bean:

It is declared in Method Level. It is declared in class which has @Configuration annotation on top of it.
All classe with @Configuration annotation is loaded and all the methods,construtors are loaded and all objects mentioned in the constructors are created.
It can be done in three ways setter injection, field injection, constructor injection. Field injection is not advisable.
programmer can have full control over the class.
we can create object for third party classes using Bean even library files. Snippet 1 @bean(initMethod = "init", destroyMethod = "cleanup") public MyService myService() { return new MyService(); } Ex import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;

@Configuration
public class Config {
private static final Logger log= LoggerFactory.getLogger(Config.class);
@bean
Student getStudent(){
log.info("inside student Bean creation config ");
return new Student();
}

}

How it works internally
Application starts:
SpringApplication.run(MyApp.class, args);
Spring Boot:

Scans classes (@ComponentScan)
Reads config (@Configuration)
Applies auto-config (@EnableAutoConfiguration)
Beans are created and stored in:
👉 ApplicationContext (Spring Container

@PostConstruct:
we use postconstruct when we want to add values to an object immediately after initialisation.
When it runs
After the bean is created and dependencies are injected
✅ Purpose
Initialization logic
Setting default values
Opening resources
@PostConstruct
public void init(){
log.info("init method called");
studentFromBeanConfig.setName("Karthi");
studentFromBeanConfig.setLoginStatus(true);
}

@PreDestroy
It is used to delete values before destroying the same object.
@PreDestroy
public void preDestroy(){
System.out.println("Values are destroyed");
}
Lifecycle of Bean :
Bean Created → @PostConstruct → Bean in Use → @PreDestroy → Bean Destroyed

Important Points for PreDestroy
_Method must be:
_

public
void
No arguments
Works only for singleton beans by default
Triggered when: Application stops Context is closed.

@primary & @Qualifier
In Spring and Spring Boot, both @primary and @Qualifier are used to resolve autowiring ambiguity when multiple beans of the same type exist in the application context.
Primary Annotation:

The @primary annotation in Spring is used to designate a primary bean among multiple beans of the same type. When a primary bean is defined using @primary, it is preferred for injection when no specific bean name or qualifier is provided.
this is a class level annotation
Qualifier Annotation:
On the other hand, the @Qualifier annotation is used to specify the exact bean to be injected when multiple beans of the same type are present. It works in conjunction with bean names or custom qualifiers to resolve ambiguity and specify the desired bean for injection.
Example:
@RestController
@RequestMapping("student")
public class StudentPrimaryAndQualiferService {
@Autowired
@Qualifier("JavaCoursestuent")
StudentInterface studentInterface;

@RequestMapping("/getStudentInferface")
public String getStudentInterface(){
return "Name: "+studentInterface.getName()+ "Roll No :" +studentInterface.getRollNo();
}
}

package LearningBeanConfig;

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
@primary
public class SchoolStudent implements StudentInterface{
@override
public String getName() {
return "SchoolStudent";
}

@Override
public String getRollNo() {
    return "DAV-11";
}

}

package LearningBeanConfig;

import com.Learning.LearningDemo.LearningDemoApplication;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component(value="JavaCoursestuent")
public class JavaCourseStu implements StudentInterface {
private static final Logger log = LoggerFactory.getLogger(JavaCourseStu.class);

@Override
public String getName() {
    log.info("JavaCoursestuent.getNAme starts");
    return "Java Course StudentInterface ";
}

@Override
public String getRollNo() {
    log.info("JavaCoursestuent.getRollNo starts");
    return "RollNo1";
}

}