Authentication ด้วย Spring Security & JWT

***************************
APPLICATION FAILED TO START
***************************

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class


Action:

Consider the following:
        If you want an embedded database (H2, HSQL or Derby), please put it on the classpath.
        If you have database settings to be loaded from a particular profile you may need to activate it (no profiles are currently active).

export JAVA_HOME="/Library/Java/JavaVirtualMachines/jdk-18.0.2.1.jdk/Contents/Home/"

export M2_HOME="/Users/xxxxxx/space/tools/apache-maven-3.8.2"
export PATH="$PATH:$M2_HOME/bin"

Apache Maven 3.8.2 (ea98e05a04480131370aa0c110b8c54cf726c06f)
Maven home: /Users/janescience/space/tools/apache-maven-3.8.2
Java version: 18.0.2.1, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk-18.0.2.1.jdk/Contents/Home
Default locale: en_TH, platform encoding: UTF-8
OS name: "mac os x", version: "13.2", arch: "aarch64", family: "mac"

server.servlet.context-path=/api
server.port=8008

spring.datasource.url= jdbc:postgresql://localhost:5432/postgres
spring.datasource.username= postgres
spring.datasource.password= p@stgres

spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation= true
spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.PostgreSQLDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto= update

 entity
  └── app
  │   ├── User
  │   └── MemberType
  │   └── Role
  └── enums
  │   └── ERole
  │   └── EMemberType
  └── base
      └── BaseEntity
      └── EntityListener

package com.demo.auth.entity.base;

import com.demo.auth.security.services.UserDetailsImpl;
import com.demo.auth.util.AppUtil;
import com.demo.auth.util.DateUtil;
import lombok.SneakyThrows;

import org.apache.commons.beanutils.BeanUtils;
import org.springframework.security.authentication.AnonymousAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;

import jakarta.persistence.*;

import java.lang.reflect.Field;

@Component
public class EntityListener {

    @PrePersist
    public void prePersistFunction(Object object) {
        this.assignValueToCommonFields(object, "CREATE");
    }

    @PreUpdate
    public void preUpdateFunction(Object object) {
        this.assignValueToCommonFields(object,"UPDATE");
    }

    @SneakyThrows
    private void assignValueToCommonFields(Object arg, String status) {

        String user = null;
        Authentication authen = SecurityContextHolder.getContext().getAuthentication();
        if (AppUtil.isNotNull(authen) && authen.getPrincipal() != "anonymousUser") {
            UserDetails userDetails = (UserDetails) authen.getPrincipal();
            if (AppUtil.isNotNull(userDetails) && AppUtil.isNotNull(userDetails.getUsername())) {
                user = userDetails.getUsername();
            }
        }

        if (status.equals("CREATE")) {
            BeanUtils.setProperty(arg, "createdBy", user != null ? user : "SYSTEM");
            BeanUtils.setProperty(arg, "createdDate", DateUtil.getCurrentDate());
        }else{
            BeanUtils.setProperty(arg, "updatedBy", user != null ? user : "SYSTEM");
            BeanUtils.setProperty(arg, "updatedDate", DateUtil.getCurrentDate());
        }

        Class<?> cls = arg.getClass();
        for (Field field : cls.getDeclaredFields()) {
            
            Field strField = ReflectionUtils.findField(cls, field.getName());
            if (strField.getType().equals(String.class)) {

                strField.setAccessible(true);
                Object value = ReflectionUtils.getField(strField, arg);

                if (AppUtil.isNotNull(value) && AppUtil.isEmpty(value.toString())) {
                    ReflectionUtils.makeAccessible(strField); //set null when emptyString
                    ReflectionUtils.setField(strField, arg, null);
                }
            }
        }
    }
}

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

package com.demo.auth.entity.base;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;

import jakarta.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Data
@MappedSuperclass
@EntityListeners(EntityListener.class)
@JsonIgnoreProperties({"hibernateLazyInitializer","handler"})
public abstract class BaseEntity implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @JsonIgnore
    private Long id;

    @Version
    @Column(name = "version")
    @JsonIgnore
    private Integer version;

    private String createdBy;

    private String updatedBy;


    @Temporal(TemporalType.TIMESTAMP)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createdDate;

    @Temporal(TemporalType.TIMESTAMP)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date updatedDate;
}

package com.demo.auth.entity.enums;

public enum ERole {
    ROLE_USER,
    ROLE_MODERATOR,
    ROLE_ADMIN
}

package com.demo.auth.entity.enums;

public enum EMemberType {
    PLATINUM,
    GOLD,
    SILVER
}

package com.demo.auth.entity.app;

import com.demo.auth.entity.base.BaseEntity;
import com.demo.auth.entity.enums.ERole;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.Table;
import lombok.Data;

@Entity
@Table(name = "roles")
@Data
public class Role extends BaseEntity{

  @Enumerated(EnumType.STRING)
	@Column(length = 20)
	private ERole name;
    
}

package com.demo.auth.entity.app;

import com.demo.auth.entity.base.BaseEntity;
import com.demo.auth.entity.enums.EMemberType;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import lombok.Data;

@Entity
@Data
public class MemberType extends BaseEntity{

    @Enumerated(EnumType.STRING)
	@Column(length = 20)
	private EMemberType name;
}

package com.demo.auth.entity.app;

import jakarta.persistence.*;
import jakarta.annotation.*;

import com.demo.auth.entity.base.BaseEntity;
import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
@Table(	name = "users")
@Data
public class User extends BaseEntity{

	@Nonnull
	@Column(unique = true)
	private String username;

	@Nonnull
	@JsonIgnore
	private String password;

	@Column(length = 1000)
	private String address;

	@Nonnull
	@Column(unique = true,length = 10)
	private String phoneNumber;

	@Nonnull
	@Column(unique = true,length = 12)
	private String refCode;

	@Nonnull
	private Double salary;

	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "memberType")
	private MemberType memberType;

  @ManyToMany(fetch = FetchType.LAZY)
	@JoinTable(	name = "user_roles", 
				joinColumns = @JoinColumn(name = "user_id"), 
				inverseJoinColumns = @JoinColumn(name = "role_id"))
	private Set<Role> roles = new HashSet<>();
}

util
  └── AppUtil
  └── DateUtil

package com.demo.auth.util;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

public class AppUtil {

    public static Object getDefaultValueIfNull(final Object value, final Object defaultValue) {
        Object result = defaultValue;
        if (value != null) {
            result = value;
        }
        return (result);
    }

    public static boolean isEmpty(final BigDecimal d) {
        final boolean b = AppUtil.isNull(d);
        return (b);
    }

    public static boolean isEmpty(final Byte byt) {
        final boolean b = AppUtil.isNull(byt);
        return (b);
    }

    public static boolean isEmpty(final Character c) {
        final boolean b = AppUtil.isNull(c);
        return (b);
    }

    public static boolean isEmpty(final Double d) {
        final boolean b = AppUtil.isNull(d);
        return (b);
    }

    public static boolean isEmpty(final Float f) {
        final boolean b = AppUtil.isNull(f);
        return (b);
    }

    public static boolean isEmpty(final Integer integer) {
        final boolean b = AppUtil.isNull(integer);
        return (b);
    }

    public static boolean isEmpty(final List<?> ls) {
        boolean b = true;
        if ((ls != null) && !ls.isEmpty()) {
            b = false;
        }
        return (b);
    }

    public static boolean isEmpty(final Long l) {
        final boolean b = AppUtil.isNull(l);
        return (b);
    }

    public static boolean isEmpty(final Map<?, ?> map) {
        boolean b = true;
        if ((map != null) && !map.isEmpty()) {
            b = false;
        }
        return (b);
    }

    public static boolean isEmpty(final Number num) {
        final boolean b = AppUtil.isNull(num);
        return (b);

    }

    public static boolean isEmpty(final Short s) {
        final boolean b = AppUtil.isNull(s);
        return (b);
    }

    public static boolean isEmpty(final String st) {
        boolean b = true;
        if ((st != null) && (st.trim().length() > 0)) {
            b = false;
        }
        return (b);
    }

    public static boolean isEmpty(final StringBuilder st) {
        boolean b = true;
        if ((st != null) && (st.toString().trim().length() > 0)) {
            b = false;
        }
        return (b);
    }

    public static boolean isEmpty(final String[] st) {
        boolean b = true;
        if ((st != null) && (st.length > 0)) {
            b = false;
        }
        return (b);
    }

    public static boolean isNotEmpty(final BigDecimal d) {
        final boolean b = AppUtil.isNotNull(d);
        return (b);
    }

    public static boolean isNotEmpty(final Byte byt) {
        final boolean b = AppUtil.isNotNull(byt);
        return (b);
    }

    public static boolean isNotEmpty(final Character c) {
        final boolean b = AppUtil.isNotNull(c);
        return (b);

    }

    public static boolean isNotEmpty(final Double d) {
        final boolean b = AppUtil.isNotNull(d);
        return (b);

    }

    public static boolean isNotEmpty(final Float f) {
        final boolean b = AppUtil.isNotNull(f);
        return (b);

    }

    public static boolean isNotEmpty(final Integer integer) {
        final boolean b = AppUtil.isNotNull(integer);
        return (b);

    }

    public static boolean isNotEmpty(final List<?> ls) {
        boolean b = false;
        if ((ls != null) && !ls.isEmpty()) {
            b = true;
        }
        return (b);

    }

    public static boolean isNotEmpty(final Long l) {
        final boolean b = AppUtil.isNotNull(l);
        return (b);

    }

    public static boolean isNotEmpty(final Map<?, ?> map) {
        boolean b = false;
        if ((map != null) && !map.isEmpty()) {
            b = true;
        }
        return (b);
    }

    public static boolean isNotEmpty(final Number num) {
        final boolean b = AppUtil.isNotNull(num);
        return (b);

    }

    public static boolean isNotEmpty(final Object obj) {
        boolean b = false;
        if (obj != null) {
            b = true;
        }
        return (b);
    }

    public static boolean isNotEmpty(final Short s) {
        final boolean b = AppUtil.isNotNull(s);
        return (b);
    }

    public static boolean isNotEmpty(final String st) {
        boolean b = true;
        if ((st == null) || (st.trim().length() == 0)) {
            b = false;
        }
        return (b);
    }

    public static boolean isNotEmpty(final String[] st) {
        boolean b = true;
        if ((st == null) || (st.length == 0)) {
            b = false;
        }
        return (b);
    }

    public static boolean isNotNull(final Object obj) {
        boolean b = false;
        if (obj != null) {
            b = true;
        }
        return (b);
    }

    public static boolean isNull(final Object obj) {
        boolean b = true;
        if (obj != null) {
            b = false;
        }
        return (b);
    }

    public static String toString(Object obj) {
        String r = "";
        if(AppUtil.isNotNull(obj)) {
            r = obj.toString();
        }
        return r;
    }
}

package com.demo.auth.util;

import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Date;

import lombok.extern.log4j.Log4j2;

import org.springframework.stereotype.Component;

@Log4j2
@Component
public class DateUtil {
    public static Timestamp getCurrentDate() {
        Timestamp today = null;
        try {
            Date nowDate = Calendar.getInstance().getTime();
            today = new Timestamp(nowDate.getTime());
        } catch (Exception e) {
            log.error("error msg : {} ", e);
            throw new RuntimeException(e);
        }
        return today;
    }
}

package com.demo.auth.repository;

import java.util.List;
import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.demo.auth.entity.app.Role;
import com.demo.auth.entity.app.User;

@Repository
public interface UserRepository extends JpaRepository<User,Long>{
    Optional<User> findByUsername(String username);

    List<User> findByRoles(Role role);

    Boolean existsByUsername(String username);

    Boolean existsByPhoneNumber(String phoneNumber);
    
    Boolean existsByRefCode(String refCode);
}

package com.demo.auth.repository;

import org.springframework.stereotype.Repository;

import com.demo.auth.entity.app.Role;
import com.demo.auth.entity.enums.ERole;

import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;

@Repository
public interface RoleRepository extends JpaRepository<Role,Long>{
    Optional<Role> findByName(ERole name);
}

package com.demo.auth.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.demo.auth.entity.app.MemberType;
import com.demo.auth.entity.enums.EMemberType;

@Repository
public interface MemberTypeRepository extends JpaRepository<MemberType,Long>{
    MemberType findByName(EMemberType name);
}

// Native
@Query(value = "SELECT * FROM USERS where username = :username",nativeQuery = true)
User findByUsername(String username);

// JPQL
@Query(SELECT u FROM User u WHERE u.username = :username)
User findByUsername(String username);

security
  └── services
      └── UserDetailsImpl
      └── UserDetailsServiceImpl

package com.demo.auth.security.services;

import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import com.demo.auth.entity.app.MemberType;
import com.demo.auth.entity.app.User;
import com.fasterxml.jackson.annotation.JsonIgnore;

import lombok.Data;

@Data
public class UserDetailsImpl implements UserDetails {

    private static final long serialVersionUID = 1L;

    private Long id;

    private String username;

    @JsonIgnore
    private String password;

    private String address;

    private String phoneNumber;

    private String refCode;

    private Double salary;

    private MemberType memberType;

    public Collection<? extends GrantedAuthority> authorities;

    public UserDetailsImpl(
        Long id, 
        String username, 
        String address, 
        String phoneNumber,
        String refCode,
        Double salary,
        MemberType memberType,
        String password,
			Collection<? extends GrantedAuthority> authorities) {
      this.id = id;
      this.username = username;
      this.address = address;
      this.phoneNumber = phoneNumber;
      this.refCode = refCode;
      this.salary = salary;
      this.memberType = memberType;
      this.password = password;
      this.authorities = authorities;
    }

    public static UserDetailsImpl build(User user) {
		List<GrantedAuthority> authorities = user.getRoles().stream()
				.map(role -> new SimpleGrantedAuthority(role.getName().name()))
				.collect(Collectors.toList());

		return new UserDetailsImpl(
				user.getId(), 
				user.getUsername(), 
				user.getAddress(),
				user.getPhoneNumber(),
				user.getRefCode(),
				user.getSalary(),
				user.getMemberType(),
				user.getPassword(), 
				authorities);
	  }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    @Override
    public boolean equals(Object o) {
      if (this == o)
        return true;
      if (o == null || getClass() != o.getClass())
        return false;
      UserDetailsImpl user = (UserDetailsImpl) o;
      return Objects.equals(id, user.id);
    }
}

package com.demo.auth.security.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import com.demo.auth.entity.app.User;
import com.demo.auth.repository.UserRepository;

import jakarta.transaction.Transactional;

@Service
public class UserDetailsServiceImpl implements UserDetailsService{

    @Autowired
    UserRepository userRepository;

    @Override
    @Transactional
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
        .orElseThrow(() -> new UsernameNotFoundException("User Not Found with username : " + username));

        return UserDetailsImpl.build(user);
    }
}

└── security
|   └── jwt
|       └── AuthEntryPointJwt
|       └── AuthTokenFilter
└── util
    └── JwtUtil

    <!-- JWT -->
	<dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

package com.demo.auth.util;

import java.util.Date;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Component;

import com.demo.auth.security.services.UserDetailsImpl;

import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.SignatureException;
import io.jsonwebtoken.UnsupportedJwtException;
import lombok.extern.log4j.Log4j2;

@Log4j2
@Component
public class JwtUtil {
    
    @Value("${jwtSecret}")
    private String jwtSecret;

    @Value("${jwtExpirationMs}")
	  private int jwtExpirationMs;

    public String generateJwtToken(Authentication authentication) {

      UserDetailsImpl userPrincipal = (UserDetailsImpl) authentication.getPrincipal();

      return Jwts.builder()
          .setSubject((userPrincipal.getUsername()))
          .setIssuedAt(new Date())
          .setExpiration(new Date((new Date()).getTime() + jwtExpirationMs))
          .signWith(SignatureAlgorithm.HS512, jwtSecret)
          .compact();
	  }

    public String getUserNameFromJwtToken(String token) {
      return Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(token).getBody().getSubject();
    }

    public boolean validateJwtToken(String authToken) {
      try {
        Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
        return true;
      } catch (SignatureException e) {
        log.error("Invalid JWT signature: {}", e.getMessage());
      } catch (MalformedJwtException e) {
        log.error("Invalid JWT token: {}", e.getMessage());
      } catch (ExpiredJwtException e) {
        log.error("JWT token is expired: {}", e.getMessage());
      } catch (UnsupportedJwtException e) {
        log.error("JWT token is unsupported: {}", e.getMessage());
      } catch (IllegalArgumentException e) {
        log.error("JWT claims string is empty: {}", e.getMessage());
      }

      return false;
    }
}

# JWT Config
jwtSecret=auth-spring-jwt-docker-secret-key
# 24 hours.
jwtExpirationMs=86400000

package com.demo.auth.security.jwt;

import java.io.IOException;

import org.springframework.beans.factory.annotation.Autowired;
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.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import com.demo.auth.security.services.UserDetailsServiceImpl;
import com.demo.auth.util.JwtUtil;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.log4j.Log4j2;

@Log4j2
public class AuthTokenFilter extends OncePerRequestFilter{

    @Autowired
	private JwtUtil jwtUtil;

    @Autowired
	private UserDetailsServiceImpl userDetailsService;

    @Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
		try {
			String jwt = parseJwt(request);
			if (jwt != null && jwtUtil.validateJwtToken(jwt)) {
				String username = jwtUtil.getUserNameFromJwtToken(jwt);

				UserDetails userDetails = userDetailsService.loadUserByUsername(username);
				UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
						userDetails, null, userDetails.getAuthorities());
				authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

				SecurityContextHolder.getContext().setAuthentication(authentication);
			}
		} catch (Exception e) {
			log.error("Cannot set user authentication: {}", e);
		}

		filterChain.doFilter(request, response);
	}

    private String parseJwt(HttpServletRequest request) {
      String headerAuth = request.getHeader("Authorization");

      if (StringUtils.hasText(headerAuth) && headerAuth.startsWith("Bearer ")) {
        return headerAuth.substring(7, headerAuth.length());
      }

      return null;
    }
    
}

package com.demo.auth.security.jwt;

import java.io.IOException;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.log4j.Log4j2;

@Log4j2
@Component
public class AuthEntryPointJwt implements AuthenticationEntryPoint{

    @Override
	public void commence(HttpServletRequest request, HttpServletResponse response,
		AuthenticationException authException) throws IOException, ServletException {
		log.error("Unauthorized error: {}", authException.getMessage());
		response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Error: Unauthorized");
	}
}

package com.demo.auth.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;

import com.demo.auth.security.jwt.AuthEntryPointJwt;
import com.demo.auth.security.jwt.AuthTokenFilter;
import com.demo.auth.security.services.UserDetailsServiceImpl;

@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig  {
    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Autowired
	private AuthEntryPointJwt unauthorizedHandler;

    @Bean
    public AuthTokenFilter authenticationJwtTokenFilter(){
        return new AuthTokenFilter();
    }

    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder());
    
        return authProvider;
    }

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

	@Bean
	public PasswordEncoder passwordEncoder() {
		return new BCryptPasswordEncoder();
	}

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()
            .authorizeHttpRequests()
            .requestMatchers("/auth/**").permitAll()
            .requestMatchers("/user/**").authenticated()
            .anyRequest().authenticated()
            .and()
            .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                                         
        http.authenticationProvider(authenticationProvider());
        http.addFilterBefore(authenticationJwtTokenFilter, UsernamePasswordAuthenticationFilter.class);
                
        return http.build();
    }
}

 └── payload
       └── request
       │    └── SigninRequest
       │    └── SignupRequest
       └── response
            └── JwtResponse
            └── MessageResponse

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

package com.demo.auth.payload.request;

import jakarta.validation.constraints.NotBlank;
import lombok.Data;

@Data
public class SigninRequest {
    @NotBlank
    private String username;
    @NotBlank
    private String password;
}

package com.demo.auth.payload.request;

import lombok.Data;
import java.util.Set;

import jakarta.validation.constraints.*;

@Data
public class SignupRequest {
    
    @NotBlank
    @Size(min = 3,max = 20)
    private String username;

    @NotBlank
    @Size(min = 6, max = 40)
    private String password;

    @Pattern(regexp="[0-9]{10}")
    private String phoneNumber;

    @Size(max = 1000)
    private String address;

    @NotNull
    private Double salary;    

    private Set<String> role;
}

package com.demo.auth.payload.response;

import java.util.List;

import com.demo.auth.entity.app.MemberType;

import lombok.Data;

@Data
public class JwtResponse {
    private String token;
    private String type = "Bearer";
    private Long id;
    private String username;
    private String phoneNumber;
    private Double salary;
    private String address;
    private String refCode;
    private MemberType memberType;
    private List<String> roles;

    public JwtResponse(
        String accessToken, 
        Long id, 
        String username, 
        String phoneNumber, 
        Double salary, 
        String address, 
        String refCode, 
        MemberType memberType, 
        List<String> roles) 
    {
        this.token = accessToken;
        this.id = id;
        this.username = username;
        this.phoneNumber = phoneNumber;
        this.salary = salary;
        this.address = address;
        this.refCode = refCode;
        this.memberType = memberType;
        this.roles = roles;
    }
}

package com.demo.auth.payload.response;

import lombok.Data;

@Data
public class MessageResponse {

    private String message;
    private String code;
    private Object data;
    private String status;

    public MessageResponse(String message,String code,String status,Object data) {
        this.message = message;
        this.data = data;
        this.code = code;
        this.status = status;
    }
}

 └── controllers
      └── AuthController
      └── UserController

package com.demo.auth.controllers;

import java.text.SimpleDateFormat;
import java.util.*;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.demo.auth.entity.app.Role;
import com.demo.auth.entity.app.User;
import com.demo.auth.entity.enums.EMemberType;
import com.demo.auth.entity.enums.ERole;
import com.demo.auth.payload.request.*;
import com.demo.auth.payload.response.*;
import com.demo.auth.repository.*;
import com.demo.auth.security.services.UserDetailsImpl;
import com.demo.auth.util.DateUtil;
import com.demo.auth.util.JwtUtil;

import jakarta.validation.Valid;

@CrossOrigin(origins = "*", maxAge = 3600)
@RestController
@RequestMapping("/auth")
public class AuthController {

	private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyyMMdd", Locale.US);
	
    @Autowired
	AuthenticationManager authenticationManager;

	@Autowired
	UserRepository userRepository;

	@Autowired
	RoleRepository roleRepository;

	@Autowired
	MemberTypeRepository memberTypeRepository;

	@Autowired
	PasswordEncoder encoder;

	@Autowired
	JwtUtil jwtUtil;

	@PostMapping("/signin")
	public ResponseEntity<?> authenticateUser(@Valid @RequestBody SigninRequest req) {

		Authentication authentication = authenticationManager.authenticate(
				new UsernamePasswordAuthenticationToken(req.getUsername(), req.getPassword()));

		SecurityContextHolder.getContext().setAuthentication(authentication);
		String jwt = jwtUtil.generateJwtToken(authentication);
		
		UserDetailsImpl userDetails = (UserDetailsImpl) authentication.getPrincipal();		
		List<String> roles = userDetails.getAuthorities().stream()
				.map(item -> item.getAuthority())
				.collect(Collectors.toList());

		return ResponseEntity.ok(new JwtResponse(jwt, 
												 userDetails.getId(), 
												 userDetails.getUsername(), 
												 userDetails.getPhoneNumber(), 
												 userDetails.getSalary(), 
												 userDetails.getAddress(), 
												 userDetails.getRefCode(), 
												 userDetails.getMemberType(), 
												 roles));
	}

	@PostMapping("/signup")
	public ResponseEntity<?> registerUser(@Valid @RequestBody SignupRequest req){
		if (userRepository.existsByUsername(req.getUsername())) {
			return ResponseEntity
					.badRequest()
					.body(new MessageResponse("Username is already taken!","400","error",null));
		}

		if (userRepository.existsByPhoneNumber(req.getPhoneNumber())) {
			return ResponseEntity
					.badRequest()
					.body(new MessageResponse("PhoneNumber is already in use!","400","error",null));
		}

		String refCode = DATE_FORMAT.format(DateUtil.getCurrentDate()) + req.getPhoneNumber().substring(req.getPhoneNumber().length() - 4);

		if (userRepository.existsByRefCode(refCode)) {
			return ResponseEntity
					.badRequest()
					.body(new MessageResponse("RefCode (YYYYMMDD)(4 last digit phone number) is already in use!","400","error",null));
		}

		User user = new User();
		user.setUsername(req.getUsername());
		user.setPassword(encoder.encode(req.getPassword()));
		user.setPhoneNumber(req.getPhoneNumber());
		user.setAddress(req.getAddress());
		user.setRefCode(refCode);
		user.setSalary(req.getSalary());

        if (user.getSalary() >= 80000) {
            user.setMemberType(memberTypeRepository.findByName(EMemberType.PLATINUM));
        } else if (user.getSalary() >= 40000) {
			user.setMemberType(memberTypeRepository.findByName(EMemberType.GOLD));
        } else{
			user.setMemberType(memberTypeRepository.findByName(EMemberType.SILVER));
        }

		Set<String> strRoles = req.getRole();
		Set<Role> roles = new HashSet<br>();

		if (strRoles == null) {
			Role userRole = roleRepository.findByName(ERole.ROLE_USER)
					.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
			roles.add(userRole);
		} else {
			strRoles.forEach(role -> {
				switch (role) {
				case "admin":
					Role adminRole = roleRepository.findByName(ERole.ROLE_ADMIN)
							.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
					roles.add(adminRole);

					break;
				case "mod":
					Role modRole = roleRepository.findByName(ERole.ROLE_MODERATOR)
							.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
					roles.add(modRole);

					break;
				default:
					Role userRole = roleRepository.findByName(ERole.ROLE_USER)
							.orElseThrow(() -> new RuntimeException("Error: Role is not found."));
					roles.add(userRole);
				}
			});
		}

		user.setRoles(roles);
		userRepository.save(user);

		return ResponseEntity.ok(new MessageResponse("User registered successfully.","200","success",user));

	}
}

package com.demo.auth.controllers;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.demo.auth.security.services.UserDetailsServiceImpl;
import com.demo.auth.repository.RoleRepository;
import com.demo.auth.repository.UserRepository;
import com.demo.auth.entity.app.User;
import com.demo.auth.entity.app.Role;
import com.demo.auth.entity.enums.ERole;
import com.demo.auth.payload.response.MessageResponse;



@CrossOrigin(origins = "*", maxAge = 3600)
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    UserRepository userRepository;

	@Autowired
	RoleRepository roleRepository;

	@Autowired
	UserDetailsServiceImpl userDetailsService;

    @GetMapping("/all")
    @PreAuthorize("hasRole('ADMIN')")
	public ResponseEntity<?> allAccess() {
        List<User> users = userRepository.findAll();
		return ResponseEntity.ok(new MessageResponse("Get all users", "200", "success", users));
	}
	
	@GetMapping
	@PreAuthorize("hasRole('USER') or hasRole('MODERATOR') or hasRole('ADMIN')")
	public ResponseEntity<?> userAccess() {
		UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
		UserDetails user = userDetailsService.loadUserByUsername(userDetails.getUsername());
		return ResponseEntity.ok(new MessageResponse("Get data user", "200", "success", user));
	}

	@GetMapping("/mod")
	@PreAuthorize("hasRole('MODERATOR')")
	public ResponseEntity<?> moderatorAccess() {
		Role role = roleRepository.findByName(ERole.ROLE_MODERATOR).get();
		List<User> users = userRepository.findByRoles(role);
		return ResponseEntity.ok(new MessageResponse("Get moderator users", "200", "success", users));
	}
}

 └── resources
        └── sql
            └── member_type.sql
            └── rolse.sql

#SQL Script
spring.sql.init.encoding=utf-8
spring.sql.init.continue-on-error=true
spring.sql.init.data-locations=classpath*:/sql/*.sql
spring.sql.init.mode=always

INSERT INTO member_type(id, created_by, created_date, updated_by, updated_date, "version","name")
VALUES(1, 'SYSTEM', current_timestamp, null, null, 0,'PLATINUM');

INSERT INTO member_type(id, created_by, created_date, updated_by, updated_date, "version","name")
VALUES(2, 'SYSTEM', current_timestamp, null, null, 0,'GOLD');

INSERT INTO member_type(id, created_by, created_date, updated_by, updated_date, "version","name")
VALUES(3, 'SYSTEM', current_timestamp, null, null, 0,'SILVER');

INSERT INTO roles(id, created_by, created_date, updated_by, updated_date, "version","name")
VALUES(1, 'SYSTEM', current_timestamp, null, null, 0,'ROLE_USER');

INSERT INTO roles(id, created_by, created_date, updated_by, updated_date, "version","name")
VALUES(2, 'SYSTEM', current_timestamp, null, null, 0,'ROLE_MODERATOR');

INSERT INTO roles(id, created_by, created_date, updated_by, updated_date, "version","name")
VALUES(3, 'SYSTEM', current_timestamp, null, null, 0,'ROLE_ADMIN');

<!-- Swagger UI-->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.0.2</version>
</dependency>

package com.demo.auth.config;

import org.springdoc.core.models.GroupedOpenApi;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.ExternalDocumentation;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;

import io.swagger.v3.oas.models.security.SecurityRequirement;
import io.swagger.v3.oas.models.security.SecurityScheme;

@Configuration
public class SwaggerConfiguration {

    final String securitySchemeName = "bearerAuth";

    @Bean
    public OpenAPI openApi() {
        return new OpenAPI()
            .info(
                new Info()
                    .title("Authentication Service")
                    .description("Spring Security with JWT")
                    .version("1.0.0"))
            .externalDocs(
                new ExternalDocumentation()
                    .description("Blog - janescience.com")
                    .url("https://janescience.com/blog/auth-springsecurity-jwt"))
            // With Authentication by JWT
            .addSecurityItem(new SecurityRequirement()
                    .addList(securitySchemeName))
            .components(new Components()
                .addSecuritySchemes(securitySchemeName, new SecurityScheme()
                    .name(securitySchemeName)
                    .type(SecurityScheme.Type.HTTP)
                    .scheme("bearer")
                    .bearerFormat("JWT")));
    }

    @Bean
    public GroupedOpenApi authApi() {
        return GroupedOpenApi.builder()
            .group("Authentication API")
            .pathsToMatch("/auth/**")
            .build();
    }

    @Bean
    public GroupedOpenApi userApi() {
        return GroupedOpenApi.builder()
            .group("User API")
            .pathsToMatch("/user/**")
            .build();
    }
}