refactor: Station을 도메인과 엔티티로 분리

src/main/java/subway/application/StationService.java

@@ -1,14 +1,16 @@
 package subway.application;
 
-import java.util.List;
-import java.util.stream.Collectors;
 import org.springframework.stereotype.Service;
 import subway.dao.StationDao;
+import subway.dao.entity.StationEntity;
 import subway.domain.Station;
 import subway.dto.request.StationRequest;
 import subway.dto.response.StationResponse;
 import subway.exception.NotFoundException;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 @Service
 public class StationService {
 
@@ -20,33 +22,39 @@ public StationService(StationDao stationDao) {
 
  public StationResponse saveStation(StationRequest stationRequest) {
  checkDuplicatedStationName(stationRequest);
- Station station = stationDao.insert(new Station(stationRequest.getName()));
- return StationResponse.of(station);
+ StationEntity station = stationDao.insert(new StationEntity(stationRequest.getName()));
+ return StationResponse.of(Station.from(station));
  }
 
  public StationResponse findStationResponseById(Long id) {
- Station station = stationDao.findById(id).orElseThrow(() -> new NotFoundException("해당 역이 존재하지 않습니다."));
- return StationResponse.of(station);
+ StationEntity station = stationDao.findById(id)
+ .orElseThrow(() -> new NotFoundException("해당 역이 존재하지 않습니다."));
+ return StationResponse.of(Station.from(station));
  }
 
  public List<StationResponse> findAllStationResponses() {
- List<Station> stations = stationDao.findAll();
+ List<StationEntity> stationEntities = stationDao.findAll();
+
+ List<Station> stations = stationEntities.stream()
+ .map(Station::from)
+ .collect(Collectors.toList());
 
  return stations.stream()
- .map(StationResponse::of)
- .collect(Collectors.toList());
+  .map(StationResponse::of)
+  .collect(Collectors.toList());
  }
 
  public void updateStation(Long id, StationRequest stationRequest) {
- stationDao.update(new Station(id, stationRequest.getName()));
+ stationDao.update(new StationEntity(id, stationRequest.getName()));
  }
 
  public void deleteStationById(Long id) {
  stationDao.deleteById(id);
  }
 
- private void checkDuplicatedStationName(StationRequest stationRequest) {
- if (stationDao.findByName(stationRequest.getName()).isPresent()) {
+ private void checkDuplicatedStationName(StationRequest stationRequest) {
+ if (stationDao.findByName(stationRequest.getName())
+ .isPresent()) {
  throw new IllegalArgumentException("이미 존재하는 역 이름 입니다");
  }
  }

src/main/java/subway/dao/StationDao.java

@@ -1,70 +1,76 @@
 package subway.dao;
 
-import java.util.List;
-import java.util.Optional;
-import javax.sql.DataSource;
 import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
 import org.springframework.jdbc.core.namedparam.SqlParameterSource;
 import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
 import org.springframework.stereotype.Repository;
-import subway.domain.Station;
+import subway.dao.entity.StationEntity;
+
+import javax.sql.DataSource;
+import java.util.List;
+import java.util.Optional;
 
 @Repository
 public class StationDao {
- private final JdbcTemplate jdbcTemplate;
+ private final NamedParameterJdbcTemplate jdbcTemplate;
  private final SimpleJdbcInsert insertAction;
 
- private RowMapper<Station> rowMapper = (rs, rowNum) ->
- new Station(
+ private RowMapper<StationEntity> rowMapper = (rs, rowNum) ->
+ new StationEntity(
  rs.getLong("id"),
  rs.getString("name")
  );
 
 
- public StationDao(JdbcTemplate jdbcTemplate, DataSource dataSource) {
+ public StationDao(NamedParameterJdbcTemplate jdbcTemplate, DataSource dataSource) {
  this.jdbcTemplate = jdbcTemplate;
  this.insertAction = new SimpleJdbcInsert(dataSource)
  .withTableName("station")
  .usingGeneratedKeyColumns("id");
  }
 
- public Station insert(Station station) {
+ public StationEntity insert(StationEntity station) {
  SqlParameterSource params = new BeanPropertySqlParameterSource(station);
  Long id = insertAction.executeAndReturnKey(params).longValue();
- return new Station(id, station.getName());
+ return new StationEntity(id, station.getName());
  }
 
- public List<Station> findAll() {
- String sql = "select * from STATION";
+ public List<StationEntity> findAll() {
+ String sql = "SELECT * FROM station";
  return jdbcTemplate.query(sql, rowMapper);
  }
 
- public Optional<Station> findById(Long id) {
- String sql = "select * from STATION where id = ?";
+ public Optional<StationEntity> findById(Long id) {
+ String sql = "SELECT * from station WHERE id = :id";
+ SqlParameterSource source = new MapSqlParameterSource("id", id);
  try {
- return Optional.of(jdbcTemplate.queryForObject(sql, rowMapper, id));
+ return Optional.of(jdbcTemplate.queryForObject(sql, source, rowMapper));
  } catch (DataAccessException exception) {
  return Optional.empty();
  }
  }
 
- public void update(Station newStation) {
- String sql = "update STATION set name = ? where id = ?";
- jdbcTemplate.update(sql, new Object[]{newStation.getName(), newStation.getId()});
+ public void update(StationEntity newStation) {
+ String sql = "UPDATE station SET name = :name WHERE id = :id";
+ SqlParameterSource source = new BeanPropertySqlParameterSource(newStation);
+ jdbcTemplate.update(sql, source);
  }
 
  public void deleteById(Long id) {
- String sql = "delete from STATION where id = ?";
- jdbcTemplate.update(sql, id);
+ String sql = "DELETE FROM station WHERE id = :id";
+ SqlParameterSource source = new MapSqlParameterSource("id", id);
+ jdbcTemplate.update(sql, source);
  }
 
- public Optional<Station> findByName(String name) {
- String sql = "select * from STATION where name = ?";
+ public Optional<StationEntity> findByName(String name) {
+ String sql = "SELECT * FROM station WHERE name = :name";
+ SqlParameterSource source = new MapSqlParameterSource("name", name);
  try {
- return Optional.of(jdbcTemplate.queryForObject(sql, rowMapper, name));
+ return Optional.of(jdbcTemplate.queryForObject(sql, source, rowMapper));
  } catch (DataAccessException exception) {
  return Optional.empty();
  }

src/main/java/subway/dao/entity/StationEntity.java

@@ -7,6 +7,10 @@ public class StationEntity {
  private Long id;
  private String name;
 
+ public StationEntity(String name) {
+ this.name = name;
+ }
+
  public StationEntity(Long id, String name) {
  this.id = id;
  this.name = name;

src/main/java/subway/domain/Section.java

@@ -18,8 +18,8 @@ private Section(Station upStation, Station downStation, Integer distance) {
 
  public static Section from(SectionStationMapper sectionStationMapper) {
  return new Section(
- new Station(sectionStationMapper.getUpStationId(), sectionStationMapper.getUpStationName()),
- new Station(sectionStationMapper.getDownStationId(), sectionStationMapper.getDownStationName()),
+ Station.of(sectionStationMapper.getUpStationId(), sectionStationMapper.getUpStationName()),
+ Station.of(sectionStationMapper.getDownStationId(), sectionStationMapper.getDownStationName()),
  sectionStationMapper.getDistance()
  );
  }

src/main/java/subway/domain/Station.java

@@ -1,21 +1,24 @@
 package subway.domain;
 
+import subway.dao.entity.StationEntity;
+
 import java.util.Objects;
 
 public class Station {
- private Long id;
- private String name;
-
- public Station() {
- }
+ private final Long id;
+ private final String name;
 
- public Station(Long id, String name) {
+ private Station(Long id, String name) {
  this.id = id;
  this.name = name;
  }
 
- public Station(String name) {
- this.name = name;
+ public static Station from(StationEntity stationEntity) {
+ return new Station(stationEntity.getId(), stationEntity.getName());
+ }
+
+ public static Station of(Long id, String name) {
+ return new Station(id, name);
  }
 
  public Long getId() {