Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();

    if (principal instanceof UserDetails) {
        String username = ((UserDetails) principal).getUsername();
    } else {
        String username = principal.toString();
    }

    @Entity
    @Table(name = "user", schema = "public")
    @Getter
    @Setter
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int id;
        private String username;
        private String password;
        private String email;
        @ManyToOne
        @JoinColumn(name = "role_id", nullable = false)
        private Role role;
    }

    @Entity
    @Table(name = "role", schema = "public")
    @Setter
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    public class Role {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int id;
        private String name;
        @OneToMany(fetch = FetchType.LAZY, mappedBy = "role")
        private Set<User> userList = new HashSet<>();

        public int getId() {
            return id;
        }

        public String getName() {
            return name;
        }

    }

    @Repository("userRepository")
    public interface userRepository extends JpaRepository<User, Integer> {
        Optional<User> findUserByUsername(String Username);
    }

    @Service("userDetailServiceImpl")
    @RequiredArgsConstructor
    public class userDetailServiceImpl implements UserDetailsService {
        private final userRepository userRepository;
        @Override
        public UserDetails loadUserByUsername(String Username) throws UsernameNotFoundException {
            Optional<User> user = userRepository.findUserByUsername(Username);
            if (user == null) {
                System.out.println("User not found!" + Username);
                throw new UsernameNotFoundException("User " + Username + " was not found in the database");
            }
            System.out.println("Found user!" + Username);
            UserDetails userDetails = new org.springframework.security.core.userdetails.User(user.get().getUsername(), user.get().getPassword(), getRole(user));
            System.out.println(userDetails);
            return userDetails;
        }

        public Set<SimpleGrantedAuthority> getRole(Optional<User> user) {
            Role role = user.get().getRole();
            return Collections.singleton(new SimpleGrantedAuthority(role.getName()));
        }
    }

    @Configuration
    @EnableWebSecurity
    @RequiredArgsConstructor
    public class AppConfig extends WebSecurityConfigurerAdapter{

        @Bean
        public NoOpPasswordEncoder passwordEncoder() {
            return (NoOpPasswordEncoder) NoOpPasswordEncoder.getInstance();
        }

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().disable();
            // Được quyền truy cập khi chưa login
            http.authorizeRequests().antMatchers("/login", "/signup", "/").permitAll();

            // Có những quyền Admin, Mod, Member sẽ được truy cập
            http.authorizeRequests().antMatchers("/user/*").hasAnyAuthority("Admin", "Mod", "Member");

            //chỉ có quyền Admin, Mod mới được truy cập
            http.authorizeRequests().antMatchers("/admin").hasAnyAuthority("Admin", "Mod");

            // Khi không đủ quyền truy cập sẽ bị chuyển hướng
            http.authorizeRequests().and().exceptionHandling().accessDeniedPage("/error");

            // Custom login
            http.authorizeRequests().and().formLogin()
                    .loginProcessingUrl("/authentication")
                    .loginPage("/login")
                    .defaultSuccessUrl("/")
                    .failureUrl("/login?error=true")
                    .usernameParameter("username")
                    .passwordParameter("password")
                    .and().logout().logoutUrl("/logout");
        }

    }

@org.springframework.stereotype.Controller
@RequiredArgsConstructor
public class Controller {
    private final userRepository userRepository;

    @GetMapping("/user")
    public String userPage(Model model, Principal principal) {
        User personal = userRepository.findUserByUsername(principal.getName()).get();
        model.addAttribute("personal", personal);
        return "user";
    }

    @GetMapping("/user/{name}")
    public String userPage(@PathVariable("name") String name, Model model) {
        User personal = userRepository.findUserByUsername(name).get();
        model.addAttribute("personal", personal);
        return "user";
    }

    @GetMapping("/login")
    public String loginPage() {
        return "login";
    }

    @GetMapping("/signup")
    public String signUpPage() {
        return "signup";
    }

    @GetMapping("/admin")
    public String adminPage() {
        return "admin";
    }

    @GetMapping("/error")
    public String errorPage() {
        return "error";
    }

}

    public class JwtRequest {
        private String username;
        private String password;

        public JwtRequest() {
        }

        public JwtRequest(String username, String password) {
            this.username = username;
            this.password = password;
        }
    }

    //getter / setter

    @Component
    public class jwtUtils implements Serializable {
        private final String jwtSecret = "thanhtpham";
        private final long jwtExp = 5 * 1000 * 3600;

        public String getUsernameFromToken(String token) {
            return getClaimFromToken(token, Claims::getSubject);
        }

        public Date getExpirationDateFromToken(String token) {
            return getClaimFromToken(token, Claims::getExpiration);
        }

        public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
            final Claims claims = Jwts.parser()
                    .setSigningKey(jwtSecret)
                    .parseClaimsJws(token)
                    .getBody();
            return claimsResolver.apply(claims);
        }


        private Boolean isTokenExpired(String token) {
            final Date expiration = getExpirationDateFromToken(token);
            return expiration.before(new Date());
        }

        public String generateToken(UserDetails userDetails) {
            return Jwts.builder()
                    .setSubject(userDetails.getUsername())
                    .setIssuedAt(new Date(System.currentTimeMillis()))
                    .setExpiration(new Date(System.currentTimeMillis() + jwtExp))
                    .signWith(SignatureAlgorithm.HS512, jwtSecret)
                    .compact();
        }
    
        public Boolean validateToken(String token, UserDetails userDetails) {
            final String username = getUsernameFromToken(token);
            return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
        }
    }

    @Component
    @RequiredArgsConstructor
    public class AuthTokenFilter extends OncePerRequestFilter {
        private final jwtUtils jwtUtils;
        private final userDetailServiceImpl userDetailServiceImpl;

        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
                throws ServletException, IOException {
            final String requestTokenHeader = request.getHeader("Authorization");
            String username = null;
            String jwtToken = null;
            if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
                jwtToken = requestTokenHeader.substring(7);
                try {
                    username = jwtUtils.getUsernameFromToken(jwtToken);
                } catch (IllegalArgumentException e) {
                    System.out.println("Unable to get JWT Token");
                } catch (ExpiredJwtException e) {
                    System.out.println("JWT Token has expired");
                }
            }

            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = this.userDetailServiceImpl.loadUserByUsername(username);
                if (jwtUtils.validateToken(jwtToken, userDetails)) {
                    UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                            userDetails, null, userDetails.getAuthorities());
                    SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
                }
            }
            chain.doFilter(request, response);
        }
    }

    private final AuthTokenFilter authTokenFilter;

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    http.authorizeRequests().antMatchers("/login", "/signup", "/", "/api/login").permitAll();

    http.authorizeRequests().antMatchers(HttpMethod.GET, "/api/get/**").authenticated();

    http.addFilterBefore(authTokenFilter, UsernamePasswordAuthenticationFilter.class);

@RestController
@RequiredArgsConstructor
@RequestMapping(value = "/api")
public class RestAPI {
    private final userRepository userRepository;
    private final userDetailServiceImpl userDetailServiceImpl;
    private final jwtUtils jwtUtils;
    private final AuthenticationManager authenticationManager;


    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody JwtRequest authenticationRequest) throws Exception {

        authenticate(authenticationRequest.getUsername(), authenticationRequest.getPassword());

        System.out.println("ok");

        final UserDetails userDetails = userDetailServiceImpl
                .loadUserByUsername(authenticationRequest.getUsername());

        final String token = jwtUtils.generateToken(userDetails);

        return ResponseEntity.ok(token);
    }

    private void authenticate(String username, String password) throws Exception {
        try {
            authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
            System.out.println(new UsernamePasswordAuthenticationToken(username, password));

        } catch (DisabledException e) {
            throw new Exception("USER_DISABLED", e);
        } catch (BadCredentialsException e) {
            throw new Exception("INVALID_CREDENTIALS", e);
        }
    }

    @GetMapping(value = "/get")
    public List<User> getAllUser() {
        return userRepository.findAll();
    }

    @GetMapping(value = "/get/{id}")
    public User getUser(@PathVariable int id) {
        return userRepository.findById(id).get();
    }
}