Users Microservice (2)

신규 회원 등록

---

사용자 서비스 첫 번째 기능인 신규 회원 등록이다.

UserController

---

사용자가 회원가입 요청 시 RequstBody Json 형태로 값을 보낼 것이다.

@PostMapping("/users")
    public ResponseEntity<?> createUser(@RequestBody RequestUser requestUser){

        ModelMapper mapper = new ModelMapper();
        mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
        UserDto userDto = mapper.map(requestUser, UserDto.class);
        userService.createUser(userDto);

        ResponseUser responseUser = mapper.map(userDto, ResponseUser.class);

        return ResponseEntity.status(HttpStatus.CREATED).body(responseUser);
    }

사용자가 /users로 body값에 회원가입 정보와 함께 요청을 한다.

@RequestBody 어노테이션을 사용하여 vo에 값을 넣어준다.

ModelMapper를 사용하여 vo인 requestUser를 계층 간 이동에 사용하는 UserDto에 매핑시켜준다.

그 후 UserService.createUser에 값을 넣어 회원가입을 한다.

값이 잘 들어갔는지 확인을 위해 응답 ResponseUser에 값을 매핑시키고 HttpStatus.CREATED와 함께 응답한다.

RequestUser

---

package com.example.userservice.vo;

import lombok.Data;

import javax.validation.constraints.Email;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

@Data
public class RequestUser {

    @NotNull(message = "이메일을 입력해주세요.")
    @Size(min = 2, message = "이메일 최소 2자입니다.")
    @Email
    private String email;

    @NotNull(message = "이름을 입력해주세요.")
    @Size(min = 2, message = "이름은 최소 2자입니다.")
    private String name;

    @NotNull(message = "비밀번호를 입력해주세요.")
    @Size(min = 8, message = "비밀번호는 최소 8자입니다..")
    private String password;
}

UserDto

---

package com.example.userservice.dto;

import lombok.Data;

import java.util.Date;

@Data
public class UserDto {

    private String email;
    private String name;
    private String password;
    private String userId;
    private Date createdAt;

    private String encryptedPwd;
}

UserService

---

package com.example.userservice.service;

import com.example.userservice.dto.UserDto;
import com.example.userservice.model.Users;
import com.example.userservice.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.UUID;

@Service
@Slf4j
@RequiredArgsConstructor
public class UserServiceImpl implements UserService{

    private final UserRepository userRepository;
    private final BCryptPasswordEncoder passwordEncoder;

    @Override
    public UserDto createUser(UserDto userDto) {
        userDto.setUserId(UUID.randomUUID().toString());
        ModelMapper mapper = new ModelMapper();
        mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
        Users users = mapper.map(userDto, Users.class);
        users.setEncryptedPwd(passwordEncoder.encode(userDto.getPassword()));
        userRepository.save(users);

        UserDto responseUserDto = mapper.map(users, UserDto.class);

        return responseUserDto;
    }
}

의존 주입을 통해 UserRepository, PasswordEncoder를 롬복을 통해 생성자 주입한다.

위에서 매핑이 안된 유저아이디는 랜덤으로 정하고, 이것도 매핑을 통해 Users로 매핑한다. PasswordEncoder를 통해 패스워드를 암호화한 뒤 넣어주고 저장한다.

저장된 값을 Dto에 매핑시켜 반환한다.

Users

---

package com.example.userservice.model;

import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.*;

@Entity
@Getter
@Setter
@ToString
@Table(name = "users")
public class Users {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(nullable = false, length = 50, unique = true)
    private String email;

    @Column(nullable = false, length = 50)
    private String name;

    @Column(nullable = false, unique = true)
    private String userId;

    @Column(nullable = false, unique = true)
    private String encryptedPwd;

    public void setEncryptedPwd(String encryptedPwd) {
        this.encryptedPwd = encryptedPwd;
    }
}

Spring Security

---

package com.example.userservice.security;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class WebSecurity {

    @Bean
    protected SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        http
                .csrf().disable()
                .headers().frameOptions().disable()
                .and()
                .authorizeRequests().antMatchers("/users/**").permitAll();

        return http.build();
    }

    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
}

스프링 시큐리티를 사용하여 인증처리를 한다.
csrf를 disable하고, h2-console을 사용하기 위해 headers.frameoption도 disable한다.
회원가입, 로그인 할때는 인증이 필요없으므로 이 부분은 해제한다.

패스워드 인코드를 빈으로 등록해 사용한다.