Feature join

build.gradle

@@ -17,6 +17,10 @@ configurations {
     compileOnly {
         extendsFrom annotationProcessor
     }
+    configureEach {
+        exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
+    }
+
 }
 
 repositories {
@@ -26,10 +30,36 @@ repositories {
 
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+
+    // log4j2 적용
+    implementation 'org.springframework.boot:spring-boot-starter-log4j2'
+    // p6spy 설정
+    implementation 'p6spy:p6spy:3.9.1'
+    implementation 'com.github.gavlyukovskiy:p6spy-spring-boot-starter:1.9.0'
+
+
+    implementation 'org.mindrot:jbcrypt:0.4'
+
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
+    testCompileOnly 'org.projectlombok:lombok' // 테스트 의존성 추가
+    testAnnotationProcessor 'org.projectlombok:lombok' // 테스트 의존성 추가
+
+    runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'
+
+    developmentOnly 'org.springframework.boot:spring-boot-devtools'
+
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+
+    // TestContainers Core
+    testImplementation 'org.testcontainers:testcontainers:1.20.3'
+    // TestContainers MariaDB 모듈
+    testImplementation 'org.testcontainers:mariadb:1.19.0'
+    // TestContainers Spring Extension
+    testImplementation 'org.testcontainers:junit-jupiter:1.19.0'
 }
 
 tasks.named('test') {

src/main/java/spring/academyPlatform/AcademyPlatformApplication.java

@@ -0,0 +1,15 @@
+package spring.academyPlatform;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+
+@EnableJpaAuditing
+@SpringBootApplication
+public class AcademyPlatformApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(AcademyPlatformApplication.class, args);
+	}
+
+}

src/main/java/spring/academyPlatform/global/config/P6SpyConfig.java

@@ -0,0 +1,19 @@
+package spring.academyPlatform.global.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+
+@Profile({"default", "test"})
+@Configuration
+public class P6SpyConfig {
+	@Bean
+	public P6SpyEventListener p6SpyCustomEventListener() {
+		return new P6SpyEventListener();
+	}
+
+	@Bean
+	public P6SpyFormatter p6SpyCustomFormatter() {
+		return new P6SpyFormatter();
+	}
+}

src/main/java/spring/academyPlatform/global/config/P6SpyEventListener.java

@@ -0,0 +1,15 @@
+package spring.academyPlatform.global.config;
+
+import java.sql.SQLException;
+
+import com.p6spy.engine.common.ConnectionInformation;
+import com.p6spy.engine.event.JdbcEventListener;
+import com.p6spy.engine.spy.P6SpyOptions;
+
+public class P6SpyEventListener extends JdbcEventListener {
+	@Override
+	public void onAfterGetConnection(ConnectionInformation connectionInformation, SQLException e) {
+		P6SpyOptions.getActiveInstance().setLogMessageFormat(P6SpyFormatter.class.getName());
+	}
+
+}

src/main/java/spring/academyPlatform/global/config/P6SpyFormatter.java

@@ -0,0 +1,78 @@
+package spring.academyPlatform.global.config;
+
+import java.util.Locale;
+
+import org.hibernate.engine.jdbc.internal.FormatStyle;
+
+import com.p6spy.engine.logging.Category;
+import com.p6spy.engine.spy.appender.MessageFormattingStrategy;
+
+public class P6SpyFormatter implements MessageFormattingStrategy {
+	private static final String NEW_LINE = "\n";
+	private static final String TAP = "\t";
+	private static final String CREATE = "create";
+	private static final String ALTER = "alter";
+	private static final String DROP = "drop";
+	private static final String COMMENT = "comment";
+
+	@Override
+	public String formatMessage(int connectionId, String now, long elapsed, String category, String prepared,
+		String sql, String url) {
+		if (sql.trim().isEmpty()) {
+			return formatByCommand(category);
+		}
+		return formatBySql(sql, category) + getAdditionalMessages(elapsed);
+	}
+
+	private static String formatByCommand(String category) {
+		return NEW_LINE
+			+ "Execute Command : "
+			+ NEW_LINE
+			+ NEW_LINE
+			+ TAP
+			+ category
+			+ NEW_LINE
+			+ NEW_LINE
+			+ "----------------------------------------------------------------------------------------------------";
+	}
+
+	private String formatBySql(String sql, String category) {
+		if (isStatementDDL(sql, category)) {
+			return NEW_LINE
+				+ "Execute DDL : "
+				+ NEW_LINE
+				+ FormatStyle.DDL
+				.getFormatter()
+				.format(sql);
+		}
+		return NEW_LINE
+			+ "Execute DML : "
+			+ NEW_LINE
+			+ FormatStyle.BASIC
+			.getFormatter()
+			.format(sql);
+	}
+
+	private String getAdditionalMessages(long elapsed) {
+		return NEW_LINE
+			+ NEW_LINE
+			+ String.format("Execution Time: %s ms", elapsed)
+			+ NEW_LINE
+			+ "----------------------------------------------------------------------------------------------------";
+	}
+
+	private boolean isStatementDDL(String sql, String category) {
+		return isStatement(category) && isDDL(sql.trim().toLowerCase(Locale.ROOT));
+	}
+
+	private boolean isStatement(String category) {
+		return Category.STATEMENT.getName().equals(category);
+	}
+
+	private boolean isDDL(String lowerSql) {
+		return lowerSql.startsWith(CREATE)
+			|| lowerSql.startsWith(ALTER)
+			|| lowerSql.startsWith(DROP)
+			|| lowerSql.startsWith(COMMENT);
+	}
+}

src/main/java/spring/academyPlatform/global/model/YnCode.java

@@ -0,0 +1,5 @@
+package spring.academyPlatform.global.model;
+
+public enum YnCode {
+	Y, N;
+}

src/main/java/spring/academyPlatform/global/util/BcryptPasswordEncryptor.java

@@ -0,0 +1,22 @@
+package spring.academyPlatform.global.util;
+
+import org.mindrot.jbcrypt.BCrypt;
+import org.springframework.stereotype.Component;
+
+@Component
+public class BcryptPasswordEncryptor {
+
+	static int cost = 8;  // 반복 횟수 (보통 10~12 권장)
+
+	// Bcrypt를 사용해 비밀번호를 해싱하는 메서드
+	public static String hashPassword(String password) {
+
+		return BCrypt.hashpw(password, BCrypt.gensalt(cost));
+	}
+
+	// 해싱된 비밀번호와 사용자가 입력한 비밀번호를 검증하는 메서드
+	public static boolean checkPassword(String password, String hashedPassword) {
+		return BCrypt.checkpw(password, hashedPassword);
+	}
+
+}

src/main/java/spring/academyPlatform/user/api/UserController.java

@@ -0,0 +1,36 @@
+package spring.academyPlatform.user.api;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+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 jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import spring.academyPlatform.user.application.UserService;
+import spring.academyPlatform.user.dto.UserCreateRequest;
+import spring.academyPlatform.user.dto.UserCreateResponse;
+
+@RestController
+@RequestMapping("api/v1/user")
+@RequiredArgsConstructor
+@Slf4j
+public class UserController {
+
+	private final UserService userService;
+
+	@PostMapping("/user")
+	public ResponseEntity<UserCreateResponse> getUser(@Valid @RequestBody UserCreateRequest dto) {
+		try {
+			UserCreateResponse result = userService.createUser(dto);
+			return ResponseEntity.status(HttpStatus.OK).body(result);
+		} catch (Exception e) {
+			log.error(e.getMessage(), e);
+			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+		}
+	}
+
+}

src/main/java/spring/academyPlatform/user/application/UserService.java

@@ -0,0 +1,44 @@
+package spring.academyPlatform.user.application;
+
+import java.util.Arrays;
+
+import org.springframework.stereotype.Service;
+
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import spring.academyPlatform.global.util.BcryptPasswordEncryptor;
+import spring.academyPlatform.user.dao.UserRepository;
+import spring.academyPlatform.user.domain.User;
+import spring.academyPlatform.user.dto.UserCreateRequest;
+import spring.academyPlatform.user.dto.UserCreateResponse;
+import spring.academyPlatform.user.mapper.UserMapper;
+import spring.academyPlatform.user.model.UserTypeCode;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class UserService {
+
+	private final UserRepository userRepository;
+
+	@Transactional
+	public UserCreateResponse createUser(UserCreateRequest dto) {
+
+		UserTypeCode userTypeCode = convertToEnum(dto.getUserType());
+		String encodedPassword = BcryptPasswordEncryptor.hashPassword(dto.getUserPassword());
+		User user = UserMapper.fromDto(dto, encodedPassword, userTypeCode);
+		log.info("User created: {}", user.toString());
+		User savedUser = userRepository.save(user);
+
+		return UserMapper.fromEntity(savedUser);
+	}
+
+	public UserTypeCode convertToEnum(String userType) {
+		return Arrays.stream(UserTypeCode.values())
+			.filter(e -> e.name().equalsIgnoreCase(userType))
+			.findFirst()
+			.orElseThrow(() -> new IllegalArgumentException("잘못된 유저 타입입니다 : " + userType));
+	}
+
+}

src/main/java/spring/academyPlatform/user/dao/UserRepository.java

@@ -0,0 +1,11 @@
+package spring.academyPlatform.user.dao;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import spring.academyPlatform.user.domain.User;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+
+}

src/main/java/spring/academyPlatform/user/domain/User.java

@@ -0,0 +1,80 @@
+package spring.academyPlatform.user.domain;
+
+import java.time.LocalDateTime;
+
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EntityListeners;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import spring.academyPlatform.global.model.YnCode;
+import spring.academyPlatform.user.model.UserTypeCode;
+
+@Entity
+@Table(name = "user")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@ToString
+@EntityListeners(AuditingEntityListener.class)
+public class User {
+
+	@Id
+	@Column(name = "user_id")
+	private String userId;
+
+	@Column(name = "user_password")
+	private String userPassword;
+
+	@Column(name = "user_name")
+	private String userName;
+
+	@Enumerated(EnumType.STRING)
+	@Column(name = "user_type")
+	private UserTypeCode userType;
+
+	@Column(name = "created_at")
+	@CreatedDate
+	@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Seoul")
+	private LocalDateTime createdAt;
+
+	@Column(name = "modified_at")
+	@LastModifiedDate
+	@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Seoul")
+	private LocalDateTime modifiedAt;
+
+	@Column(name = "created_by")
+	private String createdBy;
+
+	@Column(name = "modified_by")
+	private String modifiedBy;
+
+	@Enumerated(EnumType.STRING)
+	@Column(name = "deleted_yn")
+	private YnCode deletedYn = YnCode.N;
+
+	@Builder
+	public User(String userId, String userPassword, String userName, UserTypeCode userType,
+		String createdBy, String modifiedBy, YnCode deletedYn) {
+		this.userId = userId;
+		this.userPassword = userPassword;
+		this.userName = userName;
+		this.userType = userType;
+		this.createdBy = createdBy;
+		this.modifiedBy = modifiedBy;
+		this.deletedYn = (deletedYn == null) ? YnCode.N : deletedYn;
+	}
+
+}