코드 참조를 위한 Github 링크
소개
최신 웹 애플리케이션에서는 보안 사용자 인증이 매우 중요합니다. 전통적으로 세션 기반 인증이 널리 사용되었지만 애플리케이션이 더욱 분산되고 확장 가능해짐에 따라 토큰 기반 인증은 여러 가지 이점을 제공합니다.
토큰 기반 인증을 사용하면 애플리케이션을 상태 비저장할 수 있습니다. 즉, 서버가 세션 데이터를 저장할 필요가 없으므로 확장 가능한 RESTful API에 적합합니다.
이 튜토리얼에서는 JDBC 템플릿과 함께 Spring Security를 사용하여 Spring Boot 애플리케이션에서 JWT(JSON 웹 토큰) 인증을 구현하는 과정을 안내합니다.
JWT(JSON Web Token)는 두 당사자 간에 전송된 소유권 주장을 표현하는 URL에 안전한 간결한 방법입니다. 각 요청이 서명된 토큰을 사용하여 인증되는 무상태 인증에 일반적으로 사용됩니다.
JWT와 토큰 기반 인증이 필요한 이유
상태 비저장 인증
JWT 토큰은 자체 포함되어 토큰 페이로드 내에서 사용자의 인증 정보를 직접 전달하므로 서버 메모리 사용량이 줄어들고 확장성이 향상됩니다.
교차 플랫폼 지원
토큰은 클라이언트에 안전하게 저장될 수 있으므로(예: 로컬 저장소 또는 쿠키) 모바일 및 웹 애플리케이션에서 사용하기 쉽습니다.
보안
각 토큰은 디지털 서명되어 무결성을 보장하고 서버가 모든 요청에 대해 데이터베이스에 쿼리하지 않고도 토큰을 확인할 수 있도록 합니다.
무엇을 배울 것인가
이 튜토리얼에서는 다음 방법을 배웁니다.
- Spring Security를 사용하여 Spring Boot 애플리케이션을 설정합니다.
- JDBC 템플릿을 사용하여 JWT 토큰 기반 인증을 구현하여 사용자를 관리하고 새로 고침 토큰을 안전하게 저장하세요.
- 로그인, 액세스 토큰 생성, 새로 고침 토큰 처리를 위한 엔드포인트를 설정하세요.
이 튜토리얼이 끝나면 Spring Boot와 JWT를 활용하여 애플리케이션에 원활하고 확장 가능한 액세스 제어를 제공하는 안전한 상태 비저장 인증 시스템을 갖게 됩니다.
API 흐름:
기술 요구 사항:
- 자바 17/11/8
- Spring Boot 3/2(Spring Security, Spring Web 포함)
- jjwt-api 0.11.5
- PostgreSQL/MySQL
- 메이븐
1. Spring Boot 프로젝트 설정
Spring 웹 도구나 개발 도구(STS, Intellij 또는 모든 IDE)를 사용하여 Spring Boot 프로젝트를 생성하세요.
pom.xml을 열고 Spring Security, JWT 및 JDBC 템플릿에 대한 종속성을 추가합니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
2. 데이터베이스, 앱 속성 구성
src/main/resources 폴더에서 application.properties를 열고 아래 구성을 추가합니다. 이 튜토리얼에서는 postgres 데이터베이스를 사용할 것입니다.
spring.application.name= authmanager
server.port= 1001
servlet.context-path= /authmanager
database.username= postgres
database.password= admin@123
database.driverClassName= org.postgresql.Driver
database.jdbcUrl= jdbc:postgresql://localhost:5432/postgres
database.maxActive= 5
database.minIdle= 5
database.poolName= Authmanager Postgres Datasource
app.jwtSecret= ###############ib-Spring###############
app.jwtExpirationMs= 3600000
app.jwtRefreshExpirationMs= 86400000
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
3. 데이터베이스 테이블 설정
사용자 정보, 역할, 사용자-역할 매핑 및 새로 고침 토큰에 대한 간단한 테이블 구조 정의:
CREATE SCHEMA IB;
-------------------------------------------------------------------------
create sequence users_uniqueid_seq START 1;
create table ib.users(
uniqueid bigint not null default nextval('users_uniqueid_seq') PRIMARY KEY,
email varchar(75),
password varchar(200),
username varchar(20)
);
insert into ib.users(email,password,username) values ('admin@ib.com','a$VcdzH8Q.o4KEo6df.XesdOmXdXQwT5ugNQvu1Pl0390rmfOeA1bhS','admin');
#(password = 12345678)
-------------------------------------------------------------------------
create sequence roles_id_seq START 1;
create table ib.roles(
id int not null default nextval('roles_id_seq') PRIMARY KEY,
name varchar(20)
);
INSERT INTO ib.roles(name) VALUES('ROLE_USER');
INSERT INTO ib.roles(name) VALUES('ROLE_MODERATOR');
INSERT INTO ib.roles(name) VALUES('ROLE_ADMIN');
-------------------------------------------------------------------------
create table ib.user_roles(
user_uniqueid bigint not null,
role_id int not null,
primary key(user_uniqueid,role_id)
);
insert into ib.user_roles (user_uniqueid,role_id) values (1,3);
-------------------------------------------------------------------------
create sequence refresh_tokens_id_seq START 1;
create table ib.refresh_tokens(
id bigint not null default nextval('refresh_tokens_id_seq') PRIMARY KEY,
uniqueid bigint,
token varchar(500) not null,
expiryDate TIMESTAMP WITH TIME ZONE not null
);
-------------------------------------------------------------------------
로그인 후 복사
로그인 후 복사
로그인 후 복사
4. 모델 생성
다음 모델을 정의해 보겠습니다.
models 패키지에서 아래 4개의 파일을 생성하세요:
모델/ERole.java
package com.security.authmanager.model;
public enum ERole {
ROLE_USER,
ROLE_MODERATOR,
ROLE_ADMIN
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
모델/Role.java
package com.security.authmanager.model;
public class Role {
private Integer id;
private ERole name;
public Role() {
}
public Role(ERole name) {
this.name = name;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
모델/User.java
package com.security.authmanager.model;
import java.util.HashSet;
import java.util.Set;
public class User {
private Long id;
private String username;
private String email;
private String password;
private Set<Role> roles = new HashSet<>();
public User() {
}
public User(String username, String email, String password) {
this.username = username;
this.email = email;
this.password = password;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
모델/RefreshToken.java
package com.security.authmanager.model;
import java.util.HashSet;
import java.util.Set;
public class User {
private Long id;
private String username;
private String email;
private String password;
private Set<Role> roles = new HashSet<>();
public User() {
}
public User(String username, String email, String password) {
this.username = username;
this.email = email;
this.password = password;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
5. CustomUserDetailsRepository 클래스 구현
CustomUserDetailsRepository 클래스는 사용자 및 역할 엔터티와 관련된 사용자 정의 데이터베이스 작업을 처리하는 Spring @Repository입니다. JdbcTemplate을 사용하여 사용자 가져오기, 사용자 이름 또는 이메일로 사용자 존재 여부 확인, 새 사용자 생성, 역할 가져오기와 같은 작업에 대한 SQL 쿼리를 실행합니다.
package com.security.authmanager.repository;
import com.security.authmanager.common.QueryConstants;
import com.security.authmanager.model.ERole;
import com.security.authmanager.model.Role;
import com.security.authmanager.model.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
@Repository
public class CustomUserDetailsRepository {
private static final Logger logger = LoggerFactory.getLogger(CustomUserDetailsRepository.class);
@Autowired
private JdbcTemplate jdbcTemplate;
public User fetchUserByUserName(String userName){
try{
return jdbcTemplate.query((conn) ->{
final PreparedStatement ps = conn.prepareStatement(QueryConstants.FETCH_USER);
ps.setString(1, userName.toUpperCase());
return ps;
},rs->{
User user = null;
Set<Role> roles = new HashSet<>();
while (rs.next()) {
if (user == null) {
user = new User();
user.setEmail(rs.getString("email"));
user.setId(rs.getLong("uniqueid"));
user.setPassword(rs.getString("password"));
user.setUsername(rs.getString("username"));
}
Role role = new Role();
role.setId(rs.getInt("id"));
role.setName(ERole.valueOf(rs.getString("name")));
roles.add(role);
}
if (user != null) {
user.setRoles(roles);
}
return user;
});
}catch(Exception e){
logger.error("Exception in fetchUserByUserName()",e);
throw new RuntimeException(e);
}
}
public boolean existsByUsername(String userName) {
try{
return jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.CHECK_USER_BY_USERNAME);
ps.setString(1, userName.toUpperCase());
return ps;
}, (rs,rownum) -> rs.getInt("count")).get(0)>0;
}catch(Exception e){
logger.error("Exception in existsByUsername()",e);
throw new RuntimeException(e);
}
}
public boolean existsByEmail(String email) {
try{
return jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.CHECK_USER_BY_EMAIL);
ps.setString(1, email.toUpperCase());
return ps;
}, (rs,rownum) -> rs.getInt("count")).get(0)>0;
}catch(Exception e){
logger.error("Exception in existsByEmail()",e);
throw new RuntimeException(e);
}
}
public Role findRoleByName(ERole eRole) {
try{
return jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.FETCH_ROLE_BY_NAME);
ps.setString(1, String.valueOf(eRole));
return ps;
}, rs -> {
Role role=null;
while(rs.next()){
role = new Role();
role.setName(ERole.valueOf(rs.getString("name")));
role.setId(rs.getInt("id"));
}
return role;
});
}catch(Exception e){
logger.error("Exception in findRoleByName()",e);
throw new RuntimeException(e);
}
}
public void createUser(User user) {
try(Connection conn = Objects.requireNonNull(jdbcTemplate.getDataSource()).getConnection()){
try (PreparedStatement userStatement = conn.prepareStatement(QueryConstants.INSERT_TO_USERS,Statement.RETURN_GENERATED_KEYS)) {
userStatement.setString(1, user.getEmail().toUpperCase());
userStatement.setString(2, user.getPassword());
userStatement.setString(3, user.getUsername().toUpperCase());
userStatement.executeUpdate();
// Retrieve generated userId
try (ResultSet generatedKeys = userStatement.getGeneratedKeys()) {
if (generatedKeys.next()) {
Long userId = generatedKeys.getLong(1); // Assuming userId is of type VARCHAR
logger.info("gen userid {}",userId.toString());
user.setId(userId);
}
}
}
if (user.getRoles() != null && !user.getRoles().isEmpty()) {
try (PreparedStatement userRoleStatement = conn.prepareStatement(QueryConstants.INSERT_TO_USER_ROLES)) {
for (Role role : user.getRoles()) {
userRoleStatement.setLong(1, user.getId());
userRoleStatement.setLong(2, role.getId());
userRoleStatement.executeUpdate();
}
}
}
}catch(Exception e){
logger.error("Exception in existsByEmail()",e);
throw new RuntimeException(e);
}
}
}
로그인 후 복사
로그인 후 복사
이 저장소는 데이터베이스의 사용자 및 역할 데이터를 관리하기 위해 사용자 정의 SQL 기반 CRUD 작업을 수행합니다.
주요 기능:
- 사용자 이름으로 사용자를 가져오고 관련 역할을 검색합니다.
- 사용자 이름이나 이메일로 사용자가 존재하는지 확인하세요.
- 새 사용자와 해당 역할을 데이터베이스에 삽입하세요.
- 역할 이름을 기준으로 역할 세부정보를 검색합니다.
6. RefreshTokenRepository 클래스 구현
RefreshTokenRepository 클래스는 RefreshToken 엔터티와 관련된 데이터베이스 작업을 처리하는 Spring @Repository입니다. 원시 SQL 쿼리를 통해 데이터베이스와 상호 작용하고 새로 고침 토큰을 저장, 삭제 및 검색하기 위한 논리를 캡슐화하기 위해 Spring의 JdbcTemplate을 사용합니다.
package com.security.authmanager.repository;
import com.security.authmanager.common.QueryConstants;
import com.security.authmanager.model.ERole;
import com.security.authmanager.model.RefreshToken;
import com.security.authmanager.model.Role;
import com.security.authmanager.model.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.sql.PreparedStatement;
import java.sql.Timestamp;
import java.util.Optional;
@Repository
public class RefreshTokenRepository {
private static final Logger logger = LoggerFactory.getLogger(RefreshTokenRepository.class);
@Autowired
private JdbcTemplate jdbcTemplate;
public void deleteRefreshToken(RefreshToken refreshToken) {
try{
jdbcTemplate.update(QueryConstants.DELETE_REFRESH_TOKEN,(final PreparedStatement ps) ->{
ps.setString(1,refreshToken.getToken());
});
}catch (Exception e){
logger.error("Exception in deleteRefreshToken()",e);
throw new RuntimeException(e);
}
}
public int deleteRefreshTokenByUser(User user) {
return 0;
}
public RefreshToken saveRefreshToken(RefreshToken refreshToken) {
try{
jdbcTemplate.update(QueryConstants.SAVE_REFRESH_TOKEN,(final PreparedStatement ps) ->{
ps.setLong(1,refreshToken.getUser().getId());
ps.setString(2,refreshToken.getToken());
ps.setTimestamp(3, Timestamp.from(refreshToken.getExpiryDate()));
});
}catch (Exception e){
logger.error("Exception in saveRefreshToken()",e);
throw new RuntimeException(e);
}
return refreshToken;
}
public Optional<RefreshToken> findByToken(String token) {
RefreshToken refreshToken = new RefreshToken();
try{
return Optional.ofNullable(jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.FIND_BY_TOKEN);
ps.setString(1, token);
return ps;
}, rs -> {
User user = new User();
while (rs.next()) {
refreshToken.setId(rs.getLong("id"));
refreshToken.setToken(rs.getString("token"));
refreshToken.setExpiryDate(rs.getTimestamp("expiryDate").toInstant());
user.setId(rs.getLong("uniqueid"));
user.setEmail(rs.getString("email"));
user.setUsername(rs.getString("username"));
refreshToken.setUser(user);
}
return refreshToken;
}));
}catch(Exception e){
logger.error("Exception in findByToken()",e);
throw new RuntimeException(e);
}
}
}
로그인 후 복사
로그인 후 복사
이 저장소는 RefreshToken 엔터티에 대한 CRUD 작업을 위해 데이터베이스와 직접 상호 작용합니다.
주요 기능:
- 새로고침 토큰을 저장하세요.
- 토큰 값으로 갱신 토큰을 검색합니다.
- 토큰 또는 사용자별로 새로 고침 토큰을 삭제하세요.
7. 스프링 보안 구성
WebSecurityConfig는 JWT 기반 토큰 인증을 사용하도록 Spring Security를 구성합니다.
AuthTokenFilter(JWT 토큰 처리용), DaoAuthenticationProvider(사용자 세부 정보 검색 및 비밀번호 검증용), BCryptPasswordEncoder(해싱 및 비밀번호 비교용)와 같은 인증에 필요한 다양한 구성 요소에 대한 Bean을 정의합니다.
SecurityFilterChain은 들어오는 HTTP 요청의 보안 방법을 구성합니다.
- 특정 공개 경로(/auth/**, /test/**)에 대한 액세스를 허용합니다.
- 인증이 필요한 다른 모든 경로를 보호합니다.
- 세션 관리를 비활성화합니다(시스템을 무상태로 만들기).
-
에 대한 JWT 토큰을 가로채서 처리하도록 필터를 구성합니다.
사용자 인증.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
8. UserDetailsImpl 구현
이 클래스는 현재 인증된 사용자를 나타내기 위해 Spring Security에서 주로 사용됩니다.
사용자가 로그인을 시도하는 경우:
- Spring Security는 UserDetailsService.loadUserByUsername()을 호출하여 로드합니다.
데이터베이스의 사용자입니다.
- 사용자 세부정보로 UserDetailsImpl 인스턴스를 생성합니다.
(역할 포함).
- 이 UserDetailsImpl 객체는 Spring Security에서 다음을 수행하는 데 사용됩니다.
사용자를 인증하고 전체 권한을 확인합니다.
세션.
UserDetailsImpl은 사용자 엔터티와 인증 및 권한 부여를 위한 Spring Security의 내부 메커니즘 사이의 브리지입니다.
spring.application.name= authmanager
server.port= 1001
servlet.context-path= /authmanager
database.username= postgres
database.password= admin@123
database.driverClassName= org.postgresql.Driver
database.jdbcUrl= jdbc:postgresql://localhost:5432/postgres
database.maxActive= 5
database.minIdle= 5
database.poolName= Authmanager Postgres Datasource
app.jwtSecret= ###############ib-Spring###############
app.jwtExpirationMs= 3600000
app.jwtRefreshExpirationMs= 86400000
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
다음은 쿼리입니다: (QueryConstants.java)
CREATE SCHEMA IB;
-------------------------------------------------------------------------
create sequence users_uniqueid_seq START 1;
create table ib.users(
uniqueid bigint not null default nextval('users_uniqueid_seq') PRIMARY KEY,
email varchar(75),
password varchar(200),
username varchar(20)
);
insert into ib.users(email,password,username) values ('admin@ib.com','a$VcdzH8Q.o4KEo6df.XesdOmXdXQwT5ugNQvu1Pl0390rmfOeA1bhS','admin');
#(password = 12345678)
-------------------------------------------------------------------------
create sequence roles_id_seq START 1;
create table ib.roles(
id int not null default nextval('roles_id_seq') PRIMARY KEY,
name varchar(20)
);
INSERT INTO ib.roles(name) VALUES('ROLE_USER');
INSERT INTO ib.roles(name) VALUES('ROLE_MODERATOR');
INSERT INTO ib.roles(name) VALUES('ROLE_ADMIN');
-------------------------------------------------------------------------
create table ib.user_roles(
user_uniqueid bigint not null,
role_id int not null,
primary key(user_uniqueid,role_id)
);
insert into ib.user_roles (user_uniqueid,role_id) values (1,3);
-------------------------------------------------------------------------
create sequence refresh_tokens_id_seq START 1;
create table ib.refresh_tokens(
id bigint not null default nextval('refresh_tokens_id_seq') PRIMARY KEY,
uniqueid bigint,
token varchar(500) not null,
expiryDate TIMESTAMP WITH TIME ZONE not null
);
-------------------------------------------------------------------------
로그인 후 복사
로그인 후 복사
로그인 후 복사
9. UserDetailsServiceImpl 구현
UserDetailsServiceImpl 클래스는 애플리케이션 데이터베이스와 Spring Security의 인증 프로세스 사이의 브리지 역할을 합니다. CustomUserDetailsRepository를 사용하여 데이터베이스에서 사용자 세부 정보를 가져오고, User 객체를 UserDetailsImpl(Spring Security에 적합한 형식)으로 변환하고, 사용자를 찾을 수 없는 경우 예외를 발생시켜 처리합니다. 이 서비스를 통해 Spring Security는 사용자를 인증하고 사용자의 역할 및 권한에 따라 권한 부여를 관리할 수 있습니다.
package com.security.authmanager.model;
public enum ERole {
ROLE_USER,
ROLE_MODERATOR,
ROLE_ADMIN
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
10. 요청 필터링
AuthTokenFilter 클래스는 Spring의 OncePerRequestFilter를 확장하여 요청 체인에서 모든 HTTP 요청을 한 번 처리하는 필터로 만듭니다. 주요 역할은 요청에서 JWT(JSON 웹 토큰)를 추출 및 검증하고 토큰이 유효한 경우 Spring Security의 SecurityContext에서 사용자 인증을 설정하는 것입니다.
package com.security.authmanager.model;
public class Role {
private Integer id;
private ERole name;
public Role() {
}
public Role(ERole name) {
this.name = name;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
요청이 이루어질 때마다:
- 필터는 요청에 유효한 JWT가 포함되어 있는지 확인합니다.
- 유효한 경우 SecurityContext에서 UsernamePasswordAuthenticationToken을 설정하여 사용자를 인증합니다.
- JWT가 유효하지 않거나 누락된 경우 인증이 설정되지 않으며 인증되지 않은 요청으로 요청이 진행됩니다.
이 필터를 사용하면 사용자가 로그인 후 후속 요청에서 자격 증명(예: 사용자 이름/비밀번호)을 제공할 필요 없이 유효한 JWT 토큰을 전달하는 모든 요청이 자동으로 인증됩니다.
11. RefreshTokenService 구현
RefreshTokenService 클래스는 토큰 기반 인증 시스템에서 새로 고침 토큰 관리와 관련된 서비스를 제공합니다. 새로 고침 토큰은 초기 JWT가 만료된 후 사용자에게 재인증을 요구하지 않고 새 JWT 토큰을 얻는 데 사용됩니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
RefreshTokenService는 새로 고침 토큰의 생성, 검증 및 삭제를 처리합니다. 데이터베이스에서 토큰과 사용자를 저장하고 가져오기 위해 저장소를 사용합니다.
이 서비스는 JWT가 만료된 후 자격 증명을 다시 제공하지 않고도 사용자의 로그인을 유지하기 위해 새로 고침 토큰을 사용하는 인증 시스템의 필수 부분입니다.
12. JWT 유틸리티 구현
JwtUtils 클래스는 Spring Boot 애플리케이션에서 인증 목적으로 JWT(JSON 웹 토큰)의 생성, 구문 분석 및 유효성 검사를 처리하는 유틸리티 클래스입니다. JWT 작업을 위해 jjwt 라이브러리를 사용합니다.
spring.application.name= authmanager
server.port= 1001
servlet.context-path= /authmanager
database.username= postgres
database.password= admin@123
database.driverClassName= org.postgresql.Driver
database.jdbcUrl= jdbc:postgresql://localhost:5432/postgres
database.maxActive= 5
database.minIdle= 5
database.poolName= Authmanager Postgres Datasource
app.jwtSecret= ###############ib-Spring###############
app.jwtExpirationMs= 3600000
app.jwtRefreshExpirationMs= 86400000
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
JwtUtils 클래스는 JWT 토큰 생성, 구문 분석 및 유효성 검사를 담당합니다. 비밀 키(HMAC-SHA256)를 사용하여 토큰에 안전하게 서명하고 올바른 비밀 키를 소유한 당사자만 토큰을 읽거나 확인할 수 있도록 보장합니다.
또한 클래스는 토큰에서 사용자 이름을 추출하고 사용자에게 액세스 권한을 부여하기 전에 토큰이 유효한지 확인합니다. 이 유틸리티는 애플리케이션에서 안전한 토큰 기반 인증을 유지하는 데 필수적입니다.
13. 인증 예외 처리
AuthEntryPointJwt 클래스는 Spring Security의 AuthenticationEntryPoint 인터페이스를 구현합니다. 일반적으로 사용자가 유효한 인증 없이(예: JWT가 없거나 유효하지 않은 JWT) 보호된 리소스에 액세스하려고 할 때 무단 요청이 있을 때 발생하는 상황을 처리합니다.
CREATE SCHEMA IB;
-------------------------------------------------------------------------
create sequence users_uniqueid_seq START 1;
create table ib.users(
uniqueid bigint not null default nextval('users_uniqueid_seq') PRIMARY KEY,
email varchar(75),
password varchar(200),
username varchar(20)
);
insert into ib.users(email,password,username) values ('admin@ib.com','a$VcdzH8Q.o4KEo6df.XesdOmXdXQwT5ugNQvu1Pl0390rmfOeA1bhS','admin');
#(password = 12345678)
-------------------------------------------------------------------------
create sequence roles_id_seq START 1;
create table ib.roles(
id int not null default nextval('roles_id_seq') PRIMARY KEY,
name varchar(20)
);
INSERT INTO ib.roles(name) VALUES('ROLE_USER');
INSERT INTO ib.roles(name) VALUES('ROLE_MODERATOR');
INSERT INTO ib.roles(name) VALUES('ROLE_ADMIN');
-------------------------------------------------------------------------
create table ib.user_roles(
user_uniqueid bigint not null,
role_id int not null,
primary key(user_uniqueid,role_id)
);
insert into ib.user_roles (user_uniqueid,role_id) values (1,3);
-------------------------------------------------------------------------
create sequence refresh_tokens_id_seq START 1;
create table ib.refresh_tokens(
id bigint not null default nextval('refresh_tokens_id_seq') PRIMARY KEY,
uniqueid bigint,
token varchar(500) not null,
expiryDate TIMESTAMP WITH TIME ZONE not null
);
-------------------------------------------------------------------------
로그인 후 복사
로그인 후 복사
로그인 후 복사
AuthEntryPointJwt 클래스는 무단 액세스 시도를 가로채고 401 오류 코드, 오류 메시지 및 요청에 대한 세부정보가 포함된 구조화된 JSON 응답을 반환하는 사용자 정의 진입점입니다.
인증 실패 시 오류를 기록하고 클라이언트에게 명확하고 사용자 친화적인 응답을 제공합니다.
14. 컨트롤러에 대한 페이로드 클래스 생성
다음은 RestAPI의 페이로드입니다.
1. 요청:
- LoginRequest.java :
package com.security.authmanager.model;
public enum ERole {
ROLE_USER,
ROLE_MODERATOR,
ROLE_ADMIN
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
- SignupRequest.java :
package com.security.authmanager.model;
public class Role {
private Integer id;
private ERole name;
public Role() {
}
public Role(ERole name) {
this.name = name;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
- TokenRefreshRequest.java :
package com.security.authmanager.model;
import java.util.HashSet;
import java.util.Set;
public class User {
private Long id;
private String username;
private String email;
private String password;
private Set<Role> roles = new HashSet<>();
public User() {
}
public User(String username, String email, String password) {
this.username = username;
this.email = email;
this.password = password;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
2. 응답:
- JwtResponse.java
package com.security.authmanager.model;
import java.util.HashSet;
import java.util.Set;
public class User {
private Long id;
private String username;
private String email;
private String password;
private Set<Role> roles = new HashSet<>();
public User() {
}
public User(String username, String email, String password) {
this.username = username;
this.email = email;
this.password = password;
}
//generate getters and setters
}
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
- MessageResponse.java
package com.security.authmanager.repository;
import com.security.authmanager.common.QueryConstants;
import com.security.authmanager.model.ERole;
import com.security.authmanager.model.Role;
import com.security.authmanager.model.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
@Repository
public class CustomUserDetailsRepository {
private static final Logger logger = LoggerFactory.getLogger(CustomUserDetailsRepository.class);
@Autowired
private JdbcTemplate jdbcTemplate;
public User fetchUserByUserName(String userName){
try{
return jdbcTemplate.query((conn) ->{
final PreparedStatement ps = conn.prepareStatement(QueryConstants.FETCH_USER);
ps.setString(1, userName.toUpperCase());
return ps;
},rs->{
User user = null;
Set<Role> roles = new HashSet<>();
while (rs.next()) {
if (user == null) {
user = new User();
user.setEmail(rs.getString("email"));
user.setId(rs.getLong("uniqueid"));
user.setPassword(rs.getString("password"));
user.setUsername(rs.getString("username"));
}
Role role = new Role();
role.setId(rs.getInt("id"));
role.setName(ERole.valueOf(rs.getString("name")));
roles.add(role);
}
if (user != null) {
user.setRoles(roles);
}
return user;
});
}catch(Exception e){
logger.error("Exception in fetchUserByUserName()",e);
throw new RuntimeException(e);
}
}
public boolean existsByUsername(String userName) {
try{
return jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.CHECK_USER_BY_USERNAME);
ps.setString(1, userName.toUpperCase());
return ps;
}, (rs,rownum) -> rs.getInt("count")).get(0)>0;
}catch(Exception e){
logger.error("Exception in existsByUsername()",e);
throw new RuntimeException(e);
}
}
public boolean existsByEmail(String email) {
try{
return jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.CHECK_USER_BY_EMAIL);
ps.setString(1, email.toUpperCase());
return ps;
}, (rs,rownum) -> rs.getInt("count")).get(0)>0;
}catch(Exception e){
logger.error("Exception in existsByEmail()",e);
throw new RuntimeException(e);
}
}
public Role findRoleByName(ERole eRole) {
try{
return jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.FETCH_ROLE_BY_NAME);
ps.setString(1, String.valueOf(eRole));
return ps;
}, rs -> {
Role role=null;
while(rs.next()){
role = new Role();
role.setName(ERole.valueOf(rs.getString("name")));
role.setId(rs.getInt("id"));
}
return role;
});
}catch(Exception e){
logger.error("Exception in findRoleByName()",e);
throw new RuntimeException(e);
}
}
public void createUser(User user) {
try(Connection conn = Objects.requireNonNull(jdbcTemplate.getDataSource()).getConnection()){
try (PreparedStatement userStatement = conn.prepareStatement(QueryConstants.INSERT_TO_USERS,Statement.RETURN_GENERATED_KEYS)) {
userStatement.setString(1, user.getEmail().toUpperCase());
userStatement.setString(2, user.getPassword());
userStatement.setString(3, user.getUsername().toUpperCase());
userStatement.executeUpdate();
// Retrieve generated userId
try (ResultSet generatedKeys = userStatement.getGeneratedKeys()) {
if (generatedKeys.next()) {
Long userId = generatedKeys.getLong(1); // Assuming userId is of type VARCHAR
logger.info("gen userid {}",userId.toString());
user.setId(userId);
}
}
}
if (user.getRoles() != null && !user.getRoles().isEmpty()) {
try (PreparedStatement userRoleStatement = conn.prepareStatement(QueryConstants.INSERT_TO_USER_ROLES)) {
for (Role role : user.getRoles()) {
userRoleStatement.setLong(1, user.getId());
userRoleStatement.setLong(2, role.getId());
userRoleStatement.executeUpdate();
}
}
}
}catch(Exception e){
logger.error("Exception in existsByEmail()",e);
throw new RuntimeException(e);
}
}
}
로그인 후 복사
로그인 후 복사
- TokenRefreshResponse.java
package com.security.authmanager.repository;
import com.security.authmanager.common.QueryConstants;
import com.security.authmanager.model.ERole;
import com.security.authmanager.model.RefreshToken;
import com.security.authmanager.model.Role;
import com.security.authmanager.model.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.sql.PreparedStatement;
import java.sql.Timestamp;
import java.util.Optional;
@Repository
public class RefreshTokenRepository {
private static final Logger logger = LoggerFactory.getLogger(RefreshTokenRepository.class);
@Autowired
private JdbcTemplate jdbcTemplate;
public void deleteRefreshToken(RefreshToken refreshToken) {
try{
jdbcTemplate.update(QueryConstants.DELETE_REFRESH_TOKEN,(final PreparedStatement ps) ->{
ps.setString(1,refreshToken.getToken());
});
}catch (Exception e){
logger.error("Exception in deleteRefreshToken()",e);
throw new RuntimeException(e);
}
}
public int deleteRefreshTokenByUser(User user) {
return 0;
}
public RefreshToken saveRefreshToken(RefreshToken refreshToken) {
try{
jdbcTemplate.update(QueryConstants.SAVE_REFRESH_TOKEN,(final PreparedStatement ps) ->{
ps.setLong(1,refreshToken.getUser().getId());
ps.setString(2,refreshToken.getToken());
ps.setTimestamp(3, Timestamp.from(refreshToken.getExpiryDate()));
});
}catch (Exception e){
logger.error("Exception in saveRefreshToken()",e);
throw new RuntimeException(e);
}
return refreshToken;
}
public Optional<RefreshToken> findByToken(String token) {
RefreshToken refreshToken = new RefreshToken();
try{
return Optional.ofNullable(jdbcTemplate.query((conn) -> {
final PreparedStatement ps = conn.prepareStatement(QueryConstants.FIND_BY_TOKEN);
ps.setString(1, token);
return ps;
}, rs -> {
User user = new User();
while (rs.next()) {
refreshToken.setId(rs.getLong("id"));
refreshToken.setToken(rs.getString("token"));
refreshToken.setExpiryDate(rs.getTimestamp("expiryDate").toInstant());
user.setId(rs.getLong("uniqueid"));
user.setEmail(rs.getString("email"));
user.setUsername(rs.getString("username"));
refreshToken.setUser(user);
}
return refreshToken;
}));
}catch(Exception e){
logger.error("Exception in findByToken()",e);
throw new RuntimeException(e);
}
}
}
로그인 후 복사
로그인 후 복사
15. Rest API 컨트롤러 클래스 생성
- AuthController.java
AuthController 클래스는 애플리케이션에서 인증 관련 엔드포인트를 처리하는 Spring @RestController입니다. 사용자 로그인, 등록 및 토큰 새로 고침 작업을 위한 엔드포인트를 제공합니다.
주요 기능:
- JWT를 통한 사용자 로그인 및 새로고침 토큰 생성.
- 유효한 새로 고침 토큰을 사용하여 토큰을 새로 고칩니다.
- 검증 및 역할 할당을 통한 사용자 등록.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
- TestController.java
TestController 클래스는 사용자 역할에 따라 액세스 제어를 테스트하기 위한 여러 엔드포인트를 제공하는 Spring @RestController입니다. Spring Security의 역할 기반 인증을 사용하여 애플리케이션의 특정 부분에 대한 액세스를 제한하는 방법을 보여줍니다.
주요 기능:
- 누구나 접속할 수 있는 공개 접속 엔드포인트.
- 사용자 역할(USER, MODERATOR, ADMIN)에 따라 액세스를 제한하는 역할별 엔드포인트입니다.
spring.application.name= authmanager
server.port= 1001
servlet.context-path= /authmanager
database.username= postgres
database.password= admin@123
database.driverClassName= org.postgresql.Driver
database.jdbcUrl= jdbc:postgresql://localhost:5432/postgres
database.maxActive= 5
database.minIdle= 5
database.poolName= Authmanager Postgres Datasource
app.jwtSecret= ###############ib-Spring###############
app.jwtExpirationMs= 3600000
app.jwtRefreshExpirationMs= 86400000
로그인 후 복사
로그인 후 복사
로그인 후 복사
로그인 후 복사
16. 테스트 API
1. 모드 및 사용자로 등록하세요. (로그인)
2. 액세스 토큰을 받으려면 로그인하세요.
3. 새로고침 토큰 API를 받으세요.
4. 액세스 토큰을 전달하여 사용자 액세스를 테스트합니다.
5. 액세스 토큰을 전달하여 모드 액세스를 테스트합니다.
6. 동일한 액세스 토큰을 전달하여 관리자 액세스를 테스트합니다.
이 사용자는 관리자 액세스 권한이 없으므로 승인되지 않았습니다(사용자는 모드 및 사용자 역할만 가짐)
즐거운 배움! 또 만나요.?
위 내용은 Spring Security, JWT 및 JDBC 템플릿을 사용하여 Spring Boot에서 토큰 기반 인증 구현의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
