Xây dựng Json Web Token trong Spring Boot

@Data
@Entity
@Table(name = "users")
@NoArgsConstructor
@AllArgsConstructor
public class Users implements UserDetails {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	int userid;
	String full_name;
	String user_name;
	String gender;
	String user_password;
	String phone;
	String email;
	String profile_picture;
	boolean account_status;
	Boolean processed_by;
	@Temporal(TemporalType.DATE)
	Date user_birtday = new Date();
	@Temporal(TemporalType.DATE)
	Date user_dayjoin = new Date();
	String gg_id;

	@JsonIgnore
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "users")
	List<Booking> booking;


	@ManyToMany(fetch = FetchType.LAZY, targetEntity = Roles.class)
	@JoinTable(name = "user_role", joinColumns = @JoinColumn(name = "userid", referencedColumnName = "userid"), inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "role_id"))

	Set<Roles> roles = new HashSet<>();

	public String[] getAuth() {
		List<String> roles = new ArrayList<>();
		for (Roles role : this.roles) {
			roles.add(role.getName().substring(5));
		}
		return roles.toArray(new String[0]);
	}

	@Override
	public Collection<? extends GrantedAuthority> getAuthorities() {
        List<SimpleGrantedAuthority> authorities = new ArrayList<>();
        for (Roles role : roles) {
            authorities.add(new SimpleGrantedAuthority(role.getName()));
            
            System.out.println("ROLE: " + role.getName());
        }
        return authorities;
	}

	public boolean isUser() {
		return Arrays.asList(this.getAuth()).contains("USER");
	}

	public boolean isAdmin() {
		return Arrays.asList(this.getAuth()).contains("ADMIN");
	}
}

@Data
@Entity
@Table(name = "roles")
@NoArgsConstructor
@AllArgsConstructor
public class Roles implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	Integer role_id;

	String name;
	String role_des;

	@ManyToMany( mappedBy = "roles",targetEntity = Users.class)
	List<Users>user;
}

package com.davisys.dao;

import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import com.davisys.entity.Users;

public interface UserDAO extends JpaRepository<Users, Integer> {

	@Query(value = "SELECT * FROM users WHERE email=:email OR phone=:email", nativeQuery = true)
	public Users findEmaiAndPhonelUser(String email);
	
	@Query(value = "SELECT * FROM users WHERE email=:email ", nativeQuery = true)
	public Users findEmailUser(String email);

	@Query(value = "SELECT * FROM users WHERE email=:email OR phone=:phone", nativeQuery = true)
	public Users findPhoneAndEmailUser(String email, String phone);
}

package com.davisys.dao;

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

import com.davisys.entity.Roles;

public interface RoleDAO extends JpaRepository<Roles, Integer>{

}

@Repository
public class RoleCustomRepo {
	@PersistenceContext
	private EntityManager entityManager;

	public List<Roles> getRole(Users user) {
		StringBuilder sql = new StringBuilder()
				.append("SELECT r.name, r.role_des as name FROM users u INNER JOIN user_role ur ON u.userid = ur.userid \r\n"
						+ "INNER JOIN roles r ON r.role_id =ur.role_id ");
		sql.append("WHERE 1=1 ");
		if (user.getEmail() != null) {
			sql.append(" and email=:email");
		}
		NativeQuery<Roles> query = ((Session) entityManager.getDelegate()).createNativeQuery(sql.toString());
		if (user.getEmail() != null) {
			query.setParameter("email", user.getEmail());
		}
		query.addScalar("name", StandardBasicTypes.STRING);
		query.setResultTransformer(Transformers.aliasToBean(Roles.class));
		return query.list();
	}
}

@Repository
public interface UsersReponsitory extends JpaRepository<Users, Long>{
	Optional<Users>findByEmail(String email);
}

package com.davisys.auth;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class AuthenticationRequest {
	String email;
	String password;
}

package com.davisys.auth;

import java.util.ArrayList;
import java.util.Collection;

import org.springframework.security.core.authority.SimpleGrantedAuthority;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class AuthenticationResponse {
	String name;
	Collection<SimpleGrantedAuthority> roles = new ArrayList<>();
	String token;
	String refreshToken;
}

@Configuration
public class JwtService {
	@Value("${jwt.secret}")
    private String secret;
	
    public static final long    JWT_TOKEN_VALIDITY  = 5 * 60 * 60 * 1000; 
	
	// phương thức khởi tạo access token
	public String generateToken(Users user, Collection<SimpleGrantedAuthority> authorities) {
		Algorithm algorithm = Algorithm.HMAC256(secret.getBytes());
		
		return JWT.create()
				.withSubject(user.getEmail())
				.withExpiresAt(new Date(System.currentTimeMillis()+ JWT_TOKEN_VALIDITY))
				.withClaim("roles", authorities.stream().map(GrantedAuthority:: getAuthority).collect(Collectors.toList()))
				.sign(algorithm);
	}
	
	// phương thức khởi tạo refresh token
	public String generateRefreshToken(Users user, Collection<SimpleGrantedAuthority> authorities) {
		Algorithm algorithm = Algorithm.HMAC256(secret.getBytes());
		
		return JWT.create()
				.withSubject(user.getEmail())
				.withExpiresAt(new Date(System.currentTimeMillis()+JWT_TOKEN_VALIDITY))
				.sign(algorithm);
	}
}

@Service
@RequiredArgsConstructor
@Configuration
@EnableWebSecurity
public class AuthenticationService {
	private final UsersReponsitory usersReponsitory;

	@Autowired
	private final AuthenticationManager authenticationManager;
	private final RoleCustomRepo roleCustomRepo;
	private final JwtService jwtService;
	@Autowired
	private PasswordEncoder passwordEncoder;

	public AuthenticationResponse loginAuth(AuthenticationRequest authenticationRequest) {
		try {
			// tìm kiếm user với email nhận từ Request
			Users user = usersReponsitory.findByEmail(authenticationRequest.getEmail()).orElseThrow();
			if(!user.isAccount_status()) return null;

			// Nếu tồn tại và không bị khóa thì tạo ra token
			UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
				authenticationRequest.getEmail(), authenticationRequest.getPassword()
			);

			// lấy ra các quyền của User và truyền vào token
			Collection<SimpleGrantedAuthority> authorities = new ArrayList<>();
			Set<Roles> set = new HashSet<>();
			role.stream().forEach(c -> set.add(new Roles(c.getName())));
			user.setRoles(set);
			set.stream().forEach(i -> authorities.add(new SimpleGrantedAuthority(i.getName())));
			authenticationManager.authenticate(token);

			var jwtToken = jwtService.generateToken(user, authorities);
			var jwtRefreshToken = jwtService.generateRefreshToken(user, authorities);

			// Trả về thông tin cần thiết
			return AuthenticationResponse.builder().token(jwtToken).refreshToken(jwtRefreshToken)
					.name(user.getFull_name()).roles(authorities).build();
		} catch (Exception e) {
			System.out.println(e);
		}
		return null;
	}
}

@PostMapping("/oauth/login")
public ResponseEntity<AuthenticationResponse> authLog(@RequestBody AuthenticationRequest authenticationRequest) {
	return ResponseEntity.ok(authenticationService.authenticationResponse(authenticationRequest));
}