Forem: NISHANT RATHORE

Implementing JWT Authentication in Spring Boot

NISHANT RATHORE — Mon, 28 Apr 2025 15:01:45 +0000

What is JWT?

JSON Web Token (JWT) is a compact, URL-safe token format used for securely transmitting information between parties as a JSON object. JWTs are commonly used for authentication and authorization in web applications, allowing users to securely access protected resources. The token consists of three parts:

Header: Contains the token type and signing algorithm.
Payload: Holds user claims and metadata.
Signature: Ensures token integrity and authenticity.

JWTs are stateless, meaning the server does not need to store session information. Instead, the token itself contains the required data, making it a scalable and efficient authentication mechanism.

Implementation of JWT in Spring Boot

1. Add Dependencies

Include the required dependencies in pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. Add JWT Util

Create a utility class to generate and validate JWT tokens.

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.stereotype.Component;
import java.security.Key;
import java.util.Date;

@Component
public class JwtUtil {
    private final String SECRET_KEY = "your-secret-key-your-secret-key-your-secret-key";
    private final long EXPIRATION_TIME = 1000 * 60 * 60; // 1 hour

    private Key getSigningKey() {
        return Keys.hmacShaKeyFor(SECRET_KEY.getBytes());
    }

    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .signWith(getSigningKey(), SignatureAlgorithm.HS256)
                .compact();
    }

    public String extractUsername(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(getSigningKey())
                .build()
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(getSigningKey())
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (JwtException e) {
            return false;
        }
    }
}

3. Add JWT Filter

The filter extracts the JWT token from the request and validates it.

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;

@Component
public class JwtFilter extends OncePerRequestFilter {

    private final JwtUtil jwtUtil;
    private final ApplicationContext applicationContext;

    @Autowired
    public JwtFilter(JwtUtil jwtUtil, ApplicationContext applicationContext) {
        this.jwtUtil = jwtUtil;
        this.applicationContext = applicationContext;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");
        String token = null;
        String username = null;

        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            token = authHeader.substring(7);
            username = jwtUtil.extractUsername(token);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = applicationContext.getBean(CustomUserDetailsService.class).loadUserByUsername(username);
            if (jwtUtil.validateToken(token)) {
                UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }

        filterChain.doFilter(request, response);
    }
}

4. Add Security Configuration

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
public class SecurityConfig {

    private final JwtFilter jwtFilter;

    public SecurityConfig(JwtFilter jwtFilter) {
        this.jwtFilter = jwtFilter;
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests()
            .requestMatchers("/auth/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }
}

5. Add Interceptor

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class JwtInterceptor implements HandlerInterceptor {
    private final JwtUtil jwtUtil;

    public JwtInterceptor(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String authHeader = request.getHeader("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            if (jwtUtil.validateToken(token)) {
                return true;
            }
        }
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        return false;
    }
}

6. Register Interceptors

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    private final JwtInterceptor jwtInterceptor;

    @Autowired
    public InterceptorConfig(JwtInterceptor jwtInterceptor) {
        this.jwtInterceptor = jwtInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor).excludePathPatterns("/auth/login");
    }
}

7. Create Controller

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

@RestController
@RequestMapping("/auth")
public class AuthController {

    private final UserService userService;
    private final JwtUtil jwtUtil;

    public AuthController(UserService userService, JwtUtil jwtUtil) {
        this.userService = userService;
        this.jwtUtil = jwtUtil;
    }

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody Map<String, String> credentials) {
        String username = credentials.get("username");
        String password = credentials.get("password");

        if (userService.authenticate(username, password)) {
            String token = jwtUtil.generateToken(username);
            return ResponseEntity.ok(Map.of("Bearer", token));
        } else {
            return ResponseEntity.status(401).body("Invalid Credentials");
        }
    }
}

8. Create Service

import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;

@Service
public class UserService {
    private final Map<String, String> users = new HashMap<>();

    public UserService() {
        users.put("admin", "password");
    }

    public boolean authenticate(String username, String password) {
        return users.containsKey(username) && users.get(username).equals(password);
    }
}

9. Testing

Send a POST request to /auth/login with a valid username and password.
If successful, it returns a JWT token.
Use this token in the Authorization header (Bearer <token>) when making requests to secured endpoints.

Now your Spring Boot app supports JWT authentication with proper security configurations! 🚀

Conclusion

JWT authentication provides a scalable, stateless security solution for your Spring Boot applications. By implementing JWT filters and interceptors, you can efficiently manage user authentication and authorization while ensuring a secure API.

You can now integrate JWT authentication into your microservices or enhance it with refresh tokens and role-based access control (RBAC) for even better security!

How to Integrate JWT in Spring Boot

NISHANT RATHORE — Mon, 28 Apr 2025 15:01:12 +0000

Introduction

JWT (JSON Web Token) is a popular method for securing APIs...

Step 1: Setup Spring Boot Project...

Add Demo Blog using hashnodeApis

NISHANT RATHORE — Mon, 28 Apr 2025 15:00:40 +0000

Introduction

JWT (JSON Web Token) is a secure way to authenticate users...

The Future of AI: How Artificial Intelligence is Transforming Our World

NISHANT RATHORE — Mon, 28 Apr 2025 15:00:08 +0000

Introduction

Artificial Intelligence (AI) is rapidly evolving, shaping industries and revolutionizing the way we live and work. From self-driving cars to intelligent chatbots, AI is making an undeniable impact.

The Rise of AI

Over the past decade, AI advancements have surged, with machine learning, deep learning, and natural language processing driving innovation. Companies like OpenAI, Google, and Tesla are pushing the boundaries of what AI can achieve.

AI in Healthcare

AI is transforming healthcare by improving diagnostics, predicting diseases, and personalizing treatments. Algorithms can analyze medical images with high accuracy, assisting doctors in making better decisions.

Everyday AI

From voice assistants like Siri and Alexa to recommendation engines on Netflix and Spotify, AI is embedded in our daily lives, making interactions more seamless and efficient.

Conclusion

AI is not just the future—it is the present. As technology advances, ethical considerations, data privacy, and responsible AI development will become increasingly crucial. The potential for AI to enhance human lives is limitless, but it must be implemented wisely.

🚀 Stay tuned for more insights on AI and emerging technologies!

5 Productivity Hacks to Supercharge Your Workflow

NISHANT RATHORE — Mon, 28 Apr 2025 14:59:35 +0000

Introduction

In today's fast-paced world, staying productive can be a challenge. Between emails, meetings, and distractions, it’s easy to lose focus. Here are five powerful productivity hacks to help you stay on track and accomplish more.

1. The Pomodoro Technique

Break your work into 25-minute focused sessions, followed by a 5-minute break. This technique helps maintain concentration and prevents burnout.

2. Prioritize with the Eisenhower Matrix

Classify tasks into four categories:

Urgent & Important – Do these immediately.
Important but Not Urgent – Schedule these for later.
Urgent but Not Important – Delegate these tasks.
Neither Urgent nor Important – Eliminate or minimize these.

3. Use the 2-Minute Rule

If a task takes less than two minutes, do it immediately instead of adding it to your to-do list. This helps clear small tasks quickly.

4. Leverage Automation

Use tools like Zapier, Notion, or Trello to automate repetitive tasks. This saves time and reduces mental clutter.

5. Block Distractions

Turn off notifications, set specific work hours, and use website blockers to stay focused on deep work.

Conclusion

Productivity isn’t about working harder—it’s about working smarter. Implement these hacks into your daily routine, and watch your efficiency soar!

⚡ What’s your favorite productivity hack? Share your thoughts in the comments!

The Beginner’s Guide to Learning JavaScript

NISHANT RATHORE — Mon, 28 Apr 2025 14:59:03 +0000

Introduction

JavaScript is one of the most popular programming languages in the world. It powers websites, web applications, and even backend systems. If you're new to coding, JavaScript is a great language to start with!

1. Why Learn JavaScript?

It's beginner-friendly.
It runs in the browser—no setup required!
It’s widely used in web development, making it a valuable skill.

2. Getting Started

To write JavaScript, all you need is a browser and a text editor. You can start by opening your browser’s developer console (press F12 in Chrome) and typing:


js
console.log("Hello, JavaScript!");