WOO L' Techlog

public class PostReadService {
	public Page<Post> getPosts(Long memberId, PageRequest pageRequest) {
    
    }
}

public class PostRepository {

    private static final RowMapper<Post> POST_ROW_MAPPER = (rs, rowNum) -> Post.builder()
            .id(rs.getLong("id"))
            .memberId(rs.getLong("memberId"))
            .content(rs.getString("contents"))
            .createdDate(rs.getDate("createdDate").toLocalDate())
            .createdAt(rs.getDate("createdAt").toLocalDate())
            .build();

	public Page<Post> findAllByMemberId(Long memberId, Pageable pageable) {
        /*
        memberId로 게시글을 조회하는 쿼리를 작성해주세요.
        */
        var sql = """
                SELECT *
                FROM post
                WHERE memberId = :memberId
                LIMIT :size OFFSET :offset;
                """;
        var params = new MapSqlParameterSource()
                .addValue("memberId", memberId)
                .addValue("size", pageable.getPageSize())
                .addValue("offset", pageable.getOffset());
        var posts = jdbcTemplate.query(sql, params, POST_ROW_MAPPER);
        return new PageImpl(posts, pageable, getCount(memberId));
    }

    private Long getCount(Long memberId) {
        var sql = """
                SELECT count(*)
                FROM post
                WHERE memberId = :memberId;
                """;
        var params = new MapSqlParameterSource()
                .addValue("memberId", memberId);
        return jdbcTemplate.queryForObject(sql, params, Long.class);
    }

public PageImpl(List<T> content, Pageable pageable, long total)

    @GetMapping("/members/{memberId}")
    public Page<Post> getPost(
            @PathVariable Long memberId, 
            @RequestParam Integer page, 
            @RequestParam Integer size) {
        
        return postReadService.getPosts(memberId, PageRequest.of(page, size));
    }

public class PageHelper {
    public static String orderBy(Sort sort) {
        if (sort.isEmpty()) {
            return "id Desc";
        }
        List<Sort.Order> orders = sort.toList();
        var orderBys = orders.stream()
                .map(order -> order.getProperty() + " " + order.getDirection())
                .toList();
        return String.join(", ", orderBys);
    }

public class PostFixtureFactory {

    public static EasyRandom get(Long memberId, LocalDate firstDate, LocalDate lastDate) {
        var idPrecicate = named("id")
                .and(ofType(Long.class))
                .and(inClass(Post.class));

        var memberIdPrecicate = named("memberId")
                .and(ofType(Long.class))
                .and(inClass(Post.class));

        var param = new EasyRandomParameters()
                .excludeField(idPrecicate)
                .dateRange(firstDate, lastDate)
                .randomize(memberIdPrecicate, () -> memberId);
        return new EasyRandom(param);

    }
}

public void bulkInsert(List<Post> posts) {
    /*
    [일괄 저장]을 구현해주세요.
    */
    var sql = """
            INSERT INTO post (memberId, contents, createdDate, createdAt)
            VALUES (:memberId, :contents, :createdDate, :createdAt);
            """;
    SqlParameterSource[] params = posts
            .stream()
            .map(BeanPropertySqlParameterSource::new)
            .toArray(SqlParameterSource[]::new);
    jdbcTemplate.batchUpdate(sql, params);
}

@SpringBootTest
public class PostBulkInsertTest {

    @Autowired
    private PostRepository postRepository;

    @Test
    public void bulkInsert() {
        var easyRandom = PostFixtureFactory.get(
                1L,
                LocalDate.of(2022, 1, 1),
                LocalDate.of(2022, 2, 1));
        var post = IntStream.range(0, 10000)
                .parallel()
                .mapToObj(i -> easyRandom.nextObject(Post.class))
                .toList();
        postRepository.bulkInsert(post);
    }
}

create index POST__index_member_id
    on POST (memberId);

create index POST__index_created_date
    on POST (createdDate);

create index POST__index_member_id_created_date
    on POST (memberId, createdDate);

private final Long id;
private final Long memberId;
private final String content;
private final LocalDate createdDate;
private final LocalDate createdAt;

@Repository
@RequiredArgsConstructor
public class PostRepository {

    private final NamedParameterJdbcTemplate jdbcTemplate;
    private static final String TABLE_NAME = "Post";
    public Post save(Post post) {
        if (post.getId() == null) {
            return insert(post);
        } else {
            throw new UnsupportedOperationException();
        }
    }
    private Post insert(Post post) {
        SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate.getJdbcTemplate())
                .withTableName(TABLE_NAME)
                .usingGeneratedKeyColumns("id");

        SqlParameterSource params = new BeanPropertySqlParameterSource(post);
        var id = jdbcInsert.executeAndReturnKey(params).longValue();

        return Post.builder()
                .id(id)
                .memberId(post.getMemberId())
                .content(post.getContent())
                .createdDate(post.getCreatedDate())
                .createdAt(post.getCreatedAt())
                .build();
    }
}

    public Long createPost(PostCommand command) {
        var post = Post
                .builder()
                .memberId(command.memberId())
                .content(command.content())
                .build();
        return postRepository.save(post).getId();
    }
}

public static RowMapper<DailyPost> DAILY_POST_ROW_MAPPER = (rs, rowNum) -> new DailyPost(
        rs.getLong("memberId"),
        rs.getDate("createdDate").toLocalDate(),
        rs.getLong("post_count")
);

public List<DailyPost> getCount(DailyPostCommand command) {
    /*
    [일자, 회원, 게시글수]를 조회하는 쿼리를 작성해주세요.
    */
    var sql = """
            SELECT createdDate, memberId, count(*) as post_count
            FROM post
            WHERE memberId = :memberId AND createdDate BETWEEN :firstDate AND :lastDate
            GROUP BY createdDate, memberId;
            """;
    SqlParameterSource params = new BeanPropertySqlParameterSource(command);
    return jdbcTemplate.query(sql, params, DAILY_POST_ROW_MAPPER);
}

@Service
@RequiredArgsConstructor
public class FollowMemberUsecase {
    private final MemberReadService memberReadService;
    private final FollowWriteService followWriteService;

    public void excute(Long fromId, Long toId) {

        var fromMember = memberReadService.getMember(fromId);
        var toMember = memberReadService.getMember(toId);

        followWriteService.createFollow(fromMember, toMember);
    }
}

@Service
@RequiredArgsConstructor
public class FollowWriteService {
    private final FollowRepository followRepository;

    public Follow createFollow(MemberDto fromMember, MemberDto toMember) {
        Assert.isTrue(!fromMember.id().equals(toMember.id()), "자기 자신을 팔로우 할 수 없습니다.");

        var follow = Follow.builder()
                .fromMemberId(fromMember.id())
                .toMemberId(toMember.id())
                .build();
        return followRepository.save(follow);
    }
}

@RequiredArgsConstructor
@RestController
@RequestMapping("/follows")
public class FollowController {
    private final FollowMemberUsecase followMemberUsecase;

    @PostMapping("/{fromId}/{toId}")
    public void createFollow(@PathVariable Long fromId, @PathVariable Long toId) {
        followMemberUsecase.excute(fromId, toId);
    }
}

private static final RowMapper<Follow> rowMapper = (rs, rowNum) -> Follow.builder()
        .id(rs.getLong("id"))
        .fromMemberId(rs.getLong("fromMemberId"))
        .toMemberId(rs.getLong("toMemberId"))
        .createdAt(rs.getObject("createdAt", LocalDate.class))
        .build();

public List<Follow> findAllByFromMemberId(Long fromMemberId) {
    var sql = "select * from " + Table + " where fromMemberId = :fromMemberId";
    var params = new MapSqlParameterSource().addValue("fromMemberId", fromMemberId);
    return jdbcTemplate.query(sql, params, rowMapper);
}

@Service
@RequiredArgsConstructor
public class FollowReadService {
    private final FollowRepository followRepository;

    public List<Follow> getFollowing(Long memberId) {
        return followRepository.findAllByFromMemberId(memberId);
    }
    public List<Follow> getFollower(Long memberId) {
        return followRepository.findAllByToMemberId(memberId);
    }

}

    public List<MemberDto> excute(Long memberId) {
        /* 
        memberId -> following을 조회
        */
        var followings = followReadService.getFollowing(memberId);
        var followingMemberIds = followings.stream()
                .map(Follow::getToMemberId)
                .toList();
        return memberReadService.getMembers(followingMemberIds);
    }

    @GetMapping("/members/{fromId}")
    public List<MemberDto> getFollowing(@PathVariable Long fromId) {
        return getFollowingUsecase.excute(fromId);
    }
}

public List<Member> findAllByIdIn(List<Long> ids) {
    if (ids.isEmpty()) {
        return List.of();
    }

public void changeNickname(String other) {
    validateNickname(other);
    nickname = other;
}

public void changeNickname(Long id, String nickname) {
    var member = memberRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("해당하는 회원이 없습니다."));
    member.changeNickname(nickname);
    memberRepository.save(member);
}

private Member update(Member member) {
    var sql = "update " + TABLE_NAME + " set nickname = :nickname where id = :id";
    SqlParameterSource params = new BeanPropertySqlParameterSource(member);
    namedParameterJdbc.update(sql, params);
    return member;
}

    @PostMapping("/members/{id}/nickname")
    public MemberDto changeNickname(@PathVariable Long id, @RequestBody String nickname) {
        memberWriteService.changeNickname(id, nickname);
        return memberReadService.getMember(id);
    }
}

create table Member
(
    id int auto_increment,
    email varchar(20) not null,
    nickname varchar(20) not null,
    birthdate date not null,
    createdAt datetime not null,
    constraint member_id_uindex
        primary key (id)
);


create table MemberNicknameHistory
(
    id int auto_increment,
    memberId int not null,
    nickname varchar(20) not null,
    createdAt datetime not null,
    constraint memberNicknameHistory_id_uindex
        primary key (id)
);

@Getter
public class MemberNickNameHistory {
    private final Long id;
    private final Long memberId;
    private final String nickname;

    private final LocalDate createdAt;

    @Builder
    public MemberNickNameHistory(Long id, Long memberId, String nickname, LocalDate createdAt) {
        this.id = id;
        this.memberId = Objects.requireNonNull(memberId);
        this.nickname = Objects.requireNonNull(nickname);
        this.createdAt = createdAt == null ? LocalDate.now() : createdAt; // 로그를 위해 생성시간 추가
    }

public record NickNameHistoryDto (
        Long id,
        Long memberId,
        String nickname,
        LocalDate createdAt
){
}

@Repository
@RequiredArgsConstructor
public class MemberNickNameHistoryRepository {

    private final NamedParameterJdbcTemplate namedParameterJdbc;

    private static final String TABLE_NAME = "MemberNickNameHistory";
    public static final RowMapper<MemberNickNameHistory> rowMapper = (rs, rowNum) -> MemberNickNameHistory
            .builder()
            .id(rs.getLong("id"))
            .memberId(rs.getLong("memberId"))
            .nickname(rs.getString("nickname"))
            .createdAt(rs.getObject("createdAt", LocalDate.class))
            .build();

    public List<MemberNickNameHistory> findAllByMemberId(Long memberId) {
        /*
        select * from Member where memberId = :memberId;
         */
        var sql = "select * from " + TABLE_NAME + " where memberId = :memberId";
        var params = new MapSqlParameterSource()
                .addValue("memberId", memberId);

        return namedParameterJdbc.query(sql, params, rowMapper);
    }

    public MemberNickNameHistory save(MemberNickNameHistory memberNickNameHistory) {
        if (memberNickNameHistory.getId() == null) {
            return insert(memberNickNameHistory);
        }
        throw new IllegalArgumentException("MemberNickNameHistory는 수정할 수 없습니다.");
    }

    private MemberNickNameHistory insert(MemberNickNameHistory memberNickNameHistory) {
        SimpleJdbcInsert simpleJdbcInsert = new SimpleJdbcInsert(namedParameterJdbc.getJdbcTemplate())
                .withTableName(TABLE_NAME)
                .usingGeneratedKeyColumns("id");
        SqlParameterSource params = new BeanPropertySqlParameterSource(memberNickNameHistory);

        var id = simpleJdbcInsert.executeAndReturnKey(params).longValue();

        return MemberNickNameHistory.builder()
                .id(id)
                .memberId(memberNickNameHistory.getMemberId())
                .nickname(memberNickNameHistory.getNickname())
                .createdAt(memberNickNameHistory.getCreatedAt())
                .build();
    }
}

public Optional<Member> findById(Long id) {
    /*
    select * from Member where id = :id;
     */
    var sql = "select * from " + TABLE_NAME + " where id = :id";
    var params = new MapSqlParameterSource()
            .addValue("id", id);
    RowMapper<Member> rowMapper = (rs, rowNum) -> Member.builder()
            .id(rs.getLong("id"))
            .nickname(rs.getString("nickname"))
            .email(rs.getString("email"))
            .birthdate(rs.getDate("birthdate").toLocalDate())
            .createdAt(rs.getDate("createdAt").toLocalDate())
            .build();
    var Member = namedParameterJdbc.queryForObject(sql, params, rowMapper);
    return Optional.ofNullable(Member);

@Service
@RequiredArgsConstructor
public class MemberReadService {

    private final MemberRepository memberRepository;

    public Member getMember(Long id) {
        return memberRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("해당하는 회원이 없습니다."));
    }

}

@GetMapping("/members/{id}")
public Member getMember(Long id) {
    return memberReadService.getMember(id);
}

// 파라미터를 RegisterMemberCommand로 받는다.
//val member = Member of(registerMemberCommand)
//memberRepository.save(member)

public record RegisterMemberCommand(
        String email,
        String nickname,
        LocalDate birthdate ) {
}

@Getter
public class Member {

    private final Long id;
    private final String nickname;
    private final String email;
    private final LocalDate birthdate;
    private final LocalDate createdAt; // 로그를 위해 생성시간 추가

    //nickname.length() <= 10
    private static final Long MAX_NICKNAME_LENGTH = 10L;
    @Builder
    public Member(Long id, String nickname, String email, LocalDate birthdate, LocalDate createdAt) {
        this.id = id;
        this.nickname = Objects.requireNonNull(nickname);
        this.email =  Objects.requireNonNull(email);
        this.birthdate = birthdate;
        this.createdAt = createdAt == null ? LocalDate.now() : createdAt;

        if (nickname.length() > MAX_NICKNAME_LENGTH) {
            throw new IllegalArgumentException("nickname length must be less than " + MAX_NICKNAME_LENGTH);
        }

    @Builder
    public Member(Long id, String nickname, String email, LocalDate birthdate, LocalDate createdAt) {
        this.id = id;
        this.email =  Objects.requireNonNull(email);
        this.birthdate = birthdate;

        validateNickname(nickname);
        this.nickname = nickname;
        this.createdAt = createdAt == null ? LocalDate.now() : createdAt;
//
//        if (nickname.length() > MAX_NICKNAME_LENGTH) {
//            throw new IllegalArgumentException("nickname length must be less than " + MAX_NICKNAME_LENGTH);
//        }

    }
    void validateNickname(String nickname) {
        if (nickname == null || nickname.length() > MAX_NICKNAME_LENGTH) {
            throw new IllegalArgumentException("Invalid nickname");
        }
    }

@Service
@RequiredArgsConstructor
public class MemberWriteService {

    private final MemberRepository memberRepository;
	// member 객체 생성한다.
    public void createMember(RegisterMemberCommand command) {

        var member = Member.builder()
                .nickname(command.nickname())
                .email(command.email())
                .birthdate(command.birthdate())
                .build();
		// member 객체를 Repository에 저장한다.
        memberRepository.save(member);
    }

private Member insert(Member member) {
    SimpleJdbcInsert simpleJdbcInsert = new SimpleJdbcInsert(namedParameterJdbc.getJdbcTemplate())
            .withTableName("Member")
            .usingGeneratedKeyColumns("id");
    SqlParameterSource params = new BeanPropertySqlParameterSource(member);
    
    var id = simpleJdbcInsert.executeAndReturnKey(params).longValue();
    return Member.builder()
            .id(id)
            .nickname(member.getNickname())
            .email(member.getEmail())
            .birthdate(member.getBirthdate())
            .createdAt(member.getCreatedAt())
            .build();
}