[Pre Project] 기본 설계

 

build.gradle

plugins {
   id 'org.springframework.boot' version '2.7.3'
   id 'io.spring.dependency-management' version '1.0.13.RELEASE'
   id "org.asciidoctor.jvm.convert" version "3.3.2"
   id 'java'
}

group = 'com.codestates'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

// snippet 경로 (Rest docs parts)
ext {
   set('snippetsDir', file("build/generated-snippets"))
}

configurations {
   asciidoctorExtensions
}

repositories {
   mavenCentral()
}

dependencies {

   // Rest Docs 추가
   testImplementation 'org.springframework.restdocs:spring-restdocs-mockmvc'
   asciidoctorExtensions 'org.springframework.restdocs:spring-restdocs-asciidoctor'

   // JPA 추가
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

   // starter-web 추가
   implementation 'org.springframework.boot:spring-boot-starter-web'

   // lombok 추가
   compileOnly 'org.projectlombok:lombok'
   annotationProcessor 'org.projectlombok:lombok'

   // 개발용 h2 로컬 저장소 추가
   runtimeOnly 'com.h2database:h2'

   // 실제 배포용 저장소 추가
   runtimeOnly 'mysql:mysql-connector-java'

   // test 추가
   testImplementation 'org.springframework.boot:spring-boot-starter-test'

   //Mapstruct 추가
   implementation 'org.mapstruct:mapstruct:1.5.2.Final'
   annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.2.Final'

   // gson 추가
   implementation 'com.google.code.gson:gson'

   // 유효성 검사 추가
   implementation 'org.springframework.boot:spring-boot-starter-validation'
}

tasks.named('test') {
   outputs.dir snippetsDir
   useJUnitPlatform()
}

tasks.named('asciidoctor') {
   configurations "asciidoctorExtensions"
   inputs.dir snippetsDir
   dependsOn test
}


task copyDocument(type: Copy) {
   dependsOn asciidoctor
   println "asciidoctor output: ${asciidoctor.outputDir}"
   from file("${asciidoctor.outputDir}")
   into file("src/main/resources/static/docs")
}

build {
   dependsOn copyDocument
}

bootJar {
   dependsOn copyDocument
   from ("${asciidoctor.outputDir}") {
      into 'src/main/resources/static/docs'
   }
}

 

application.yml

spring:
  h2:
    console:
      enabled: true
      path: /h2
  datasource:
    url: jdbc:h2:mem:test
  jpa:
    hibernate:
      ddl-auto: create  # (1) ??? ?? ??
    show-sql: true      # (2) SQL ?? ??
    properties:
      hibernate:
        format_sql: true  # (3) SQL pretty print
  sql:
    init:
      data-locations: classpath*:db/h2/data.sql
logging:
  level:
    org:
      springframework:
        orm:
          jpa: DEBUG
server:
  servlet:
    encoding:
      force-response: true

 

Membercontroller

package com.codestates.pre012.member.controller;

import com.codestates.pre012.dto.SingleResponseDto;
import com.codestates.pre012.member.dto.MemberDto;
import com.codestates.pre012.member.entity.Member;
import com.codestates.pre012.member.mapper.MemberMapper;
import com.codestates.pre012.member.service.MemberService;
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;

@RestController
@RequestMapping("/v1/member")
public class MemberController {

    private final MemberService memberService;
    private final MemberMapper mapper;

    public MemberController(MemberService memberService, MemberMapper mapper) {
        this.memberService = memberService;
        this.mapper = mapper;
    }

    /**
     * 회원 관리 ( 회원 가입, 로그인 )
     */
    @PostMapping("/create")
    public ResponseEntity createMember(@RequestBody MemberDto.Post postMember) {

        Member member = mapper.memberPostDtoToMember(postMember);
        Member response = memberService.saveMember(member);

        return new ResponseEntity<>(new SingleResponseDto<>
                (mapper.memberToMemberResponseDto(response)) ,HttpStatus.CREATED);
    }


    @PostMapping("/login")
    public ResponseEntity login(@RequestBody MemberDto.Login loginMember) {


        Member member = mapper.memberLoginDtoToMember(loginMember);
        Member response = memberService.login(member);

        return new ResponseEntity<>(new SingleResponseDto<>
                (mapper.memberToMemberResponseDto(response)),HttpStatus.OK);
    }


}

 

MemberService

package com.codestates.pre012.member.service;

import com.codestates.pre012.member.entity.Member;
import com.codestates.pre012.member.repository.MemberRepository;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class MemberService {

    private final MemberRepository memberRepository;

    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }
    //member 회원가입
    public Member saveMember(Member member) {

        verifiedMemberEmail(member.getEmail());

        return memberRepository.save(member);


    }
    public Member login(Member member) {

        Member member1 = loginVerifiedEmail(member.getEmail());

        if(member1.getPassword().equals(member.getPassword())) {
            member.setMemberId(member1.getMemberId());
            return member;
        }
        else {
            throw new RuntimeException("wrong password!!");
        }
    }

    public Member findMember (long memberId) {
        return null;
    }

    public Page<Member> findMembers(int page, int size) {
        return null;
    }

    public void deleteMember(long memberId) {
    }



    //이메일 존재시 예외처리
    public void verifiedMemberEmail(String email) {
        Optional<Member> verifyMember = memberRepository.findByEmail(email);
        if(verifyMember.isPresent()) throw new RuntimeException("member Already Exist");
    }

    public Member loginVerifiedEmail(String email) {
        Optional<Member> loginMember = memberRepository.findByEmail(email);
        Member member = loginMember.orElseThrow(() -> new RuntimeException("email not exist"));

        return member;
    }
}

 

MemberRepository

package com.codestates.pre012.member.repository;

import com.codestates.pre012.member.entity.Member;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface MemberRepository extends JpaRepository<Member, Long> {

    Optional<Member> findByEmail(String email);
}

 

MemberDto

package com.codestates.pre012.member.dto;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

public class MemberDto {


    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Login {

        private String email;
        private String password;
    }


    @Getter
    @AllArgsConstructor
    public static class Patch {

        private long memberId;
        private String password;
    }


    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Post {

        private String email;

        private String password;
    }

    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    public static class Response {

        private long memberId;

        private String email;

    }
}

 

MemberEntity

package com.codestates.pre012.member.entity;

import com.codestates.pre012.baseEntity.BaseEntity;
import com.codestates.pre012.posts.entity.Posts;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.util.List;

@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Member extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long memberId;

    @Column(name = "email", nullable = false, unique = true)
    private String email;

    @Column(name = "password", nullable = false)
    private String password;

    @OneToMany(mappedBy = "member")
    private List<Posts> posts;


}

 

MemberMapper

package com.codestates.pre012.member.mapper;

import com.codestates.pre012.member.dto.MemberDto;
import com.codestates.pre012.member.entity.Member;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;

@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MemberMapper {

    Member memberPostDtoToMember(MemberDto.Post requestBody);
    Member memberLoginDtoToMember(MemberDto.Login requestBody);
    MemberDto.Response memberToMemberResponseDto(Member member);

}