사용자관리 프로젝트

Spring Framework 사용자관리 프로젝트

학습 목표

• 사용자 관리 프로젝트 아키텍쳐에 대한 이해
• 사용자 관리 프로젝트 클래스 설계에 대한 이해
• 사용자 관리 프로젝트 클래스 Code에 대한 이해

1.사용자 관리 프로젝트 아키텍쳐에 대한 이해

1-1 아키텍쳐 개요

- 대부분의 중.대규모 웹 애플리케이션은 효율적인 개발 및 유지보수를 위하여 계층화(Layering) 하여 개발하는 것이 일반적이다.

- 사용자관리 프로젝트 아키텍쳐에서 기본적으로 가지는 계층은 프리젠테이션 계층(Presentation Layer), 

서비스 계층(Service Layer), 데이터액세스 계층(Data Access Layer) 3계층과 모든 계층에서 사용되는

도메인 모델 클래스로 구성되어 있다.

- 각각의 계층은 계층마다 독립적으로 분리하여 구현하는 것이 가능해야 하며, 각 계층에서 담당해야 할 기능들이 있다.

아키텍쳐 개요

- 위의 세 가지 계층은 독립적으로 분리할 수 있도록 구현해야 하며, 일반적으로 각 계층사이에서는 인터페이스(Interface)를 이용하여 통신하는 것이 일반적이다.

1-2 프리젠테이션 계층

- 브라우저상의 웹클라이언트의 요청 및 응답을 처리

- 상위계층(서비스게층, 데이터 액세스계층)에서 발생하는 Exception에 대한 처리

- 최종 UI에서 표현해야 할 도메인 모델을 사용

- 최종 UI에서 입력한 데이터에 대한 유효성 검증(Validation) 기능을 제공

- 비즈니스 로직과 최종 UI를 분리하기 위한 컨트롤러 기능을 제공

- @Controller 어노테이션을 사용하여 작성된 Controller 클래스가 이 계층에 속함.

1-3 서비스 계층

- 애플리케이션 비즈니스 로직 처리와 비즈니스와 관련된 도메인 모델의 적합성 검증

- 트랜잭션(Transaction) 처리

- 프리젠테이션 계층과 데이터 액세스 계층 사이를 연결하는 역할로서 두 계층이 직접적으로 통신하지 않게 하여 애플리케이션의 유연성을 증가

- 다른 계층들과 통신하기 위한 인터페이스를 제공

- Service 인터페이스와 @Service 어노테이션을 사용하여 작성된 Service 구현 클래스가 이 계층에 속함.

1-4 데이터 액세스 계층

- 영구 저장소(관계형 데이터베이스)의 데이터를 조작하는 데이터 액세스 로직을 객체화

- 영구 저장소의 데이터를 조회, 등록, 수정, 삭제 함

- ORM(Object Relational Mapping) 프레임워크(MyBatis,Hibernate)를 주로 사용하는 계층

- DAO 인터페이스와 @Repository 어노테이션을 사용하여 작성된 DAO 구현 클래스가 이 계층에 속함

1-5 도메인 모델 클래스

- 관계형 데이터 베이스의 엔티티와 비슷한 개념을 가지는 것으로 실제 VO(Value Object) 혹은

DTO(Data Transfer Object) 객체에 해당

- 도메인 모델 클래스는 3개의 계층 전체에 걸쳐 사용

- private으로 선언된 멤버변수가 있고, 그 변수에 대한 getter와 setter 메서드를 가진 클래스를 말함

1-6 테이블 설계 (MySQL 8.0.12 version)

create table users(
userid varchar(30) not null primary key,
name varchar(50) not null,
gender varchar(10),
city varchar(100)
)default charset=utf8;

2.사용자 관리 프로젝트 클래스 설계에 대한 이해

2-1 클래스 다이어그램

클래스 다이어그램

- 데이터 액세스 계층 : UserDao , UserDaoImplJDBC

- 서비스 계층 : UserService , UserServiceImpl

- 프리젠테이션 계층 : UserController

- 도메인 클래스 : UserVO

2-2 클래스의 역할

- 프리젠테이션계층

- UserController

- UI 계층과 서비스 계층을 연결하는 역할을 하는 클래스

- JSP에서 UserController를 통해서 서비스 계층의 UserService를 사용하게 된다.

- 서비스 계층의 UserService 인터페이스를 구현하나 객체를 IoC 컨테이너가 주입해준다.

- 서비스 계층

- UserService 인터페이스

- 서비스 계층에 속한 상위 인터페이스

- UserServiceImpl 클래스

- UserService 인터페이스를 구현한 클래스

- 복잡한 업무 로직이 있을 경우에는 이 클래스에서 업무 로직을 구현하면 된다.

- 데이터 액세스 계층의 UserDao 인터페이스를 구현한 객체를 IoC 컨테이너가 주입해준다.

- 데이터 액세스 계층

- UserDao 인터페이스

- 데이터 액세스 계층에 속한 상위 인터페이스

- UserDaoImplJDBC 클래스

- UserDao 인터페이스를 구현한 클래스로 이 클래스에서는 데이터 액세스 로직을 구현하면 된다.

- SpringJDBC를 사용하는 경우에는 DataSource를 IoC 컨테이너가 주입해준다.

- Mybatis를 사용하는 경우에는 SqlSession을 IoC 컨테이너가 주입해준다.

3.사용자 관리 프로젝트 클래스 Code에 대한 이해

3-1 UserVO.java

New -> pakage 검색 -> myspring.user.vo 패키지 생성

New -> pakage 검색

myspring.user.vo 생성

 myspring.user.vo 하위 -> New -> class -> UserVO 생성

package myspring.user.vo;
 
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
 
public class UserVO {
    
    private String userid;
    private String name;
    private String gender;
    private String city;
    
    public UserVO() {
        super();
    }
    
    public UserVO(String userid, String name, String gender, String city) {
        super();
        this.userid = userid;
        this.name = name;
        this.gender = gender;
        this.city = city;
    }
 
    public String getUserid() {
        return userid;
    }
    public void setUserid(String userid) {
        this.userid = userid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    
     @Override
     public String toString() {
         return ToStringBuilder.reflectionToString(this, ToStringStyle.JSON_STYLE);
     }
}

3-2 UserService.java

New -> pakage 검색 -> myspring.user.service 패키지 생성

myspring.user.service 하위 -> New -> interface -> UserService 생성

package myspring.user.service;
 
import java.util.List;
import myspring.user.vo.UserVO;
 
public interface UserService {
    int insertUser(UserVO user);
    List<UserVO> getUserList();
    int deleteUser(String id);
    UserVO getUser(String id);
    int updateUser(UserVO user);
}

3-3 UserServiceImpl.java

myspring.user.service 하위 -> New -> class -> UserService 생성

package myspring.user.service;
 
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import myspring.user.dao.UserDao;
import myspring.user.vo.UserVO;
 
@Service("userService")
@Transactional(rollbackFor = {Exception.class})
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDao dao;
    
    public int insertUser(UserVO user) {
        return dao.insert(user);
    }
 
    public List<UserVO> getUserList() {
        return dao.readAll();
    }
 
    public int deleteUser(String id) {
        return dao.delete(id);
    }
 
    public UserVO getUser(String id) {
        UserVO user = dao.read(id);
        return user;
    }
 
    public int updateUser(UserVO user) {
        return dao.update(user);
    }
 
}
 

3-4 UserDao.java

New -> pakage 검색 -> myspring.user.dao 패키지 생성

myspring.user.dao 하위 -> New -> interface -> UserDao 생성

package myspring.user.dao;
 
import java.util.List;
 
import javax.sql.DataSource;
 
import myspring.user.vo.UserVO;
 
public interface UserDao {
    int insert(UserVO user);
    List<UserVO> readAll();
    int delete(String id);
    int update(UserVO user);
    UserVO read(String id);
}
 

3-5 UserDaoImplJDBC.java

myspring.user.dao 하위 -> New -> class -> UserDaoImplJDBC 생성

package myspring.user.dao;
 
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
 
import myspring.user.vo.UserVO;
 
@Repository("userDao")
public class UserDaoImplJDBC implements UserDao{
 
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
    
    class UserMapper implements RowMapper<UserVO>{
 
        public UserVO mapRow(ResultSet rs, int rowNum) throws SQLException {
            UserVO user = new UserVO();
            user.setUserid(rs.getString("userid"));
            user.setName(rs.getString("name"));
            user.setGender(rs.getString("gender"));
            user.setCity(rs.getString("city"));
            return user;
        }
        
    }
    
    public int insert(UserVO user) {
        int result = 0;
        String sql = "insert into users values(?,?,?,?)";
        result = jdbcTemplate.update(sql,user.getUserid(),user.getName(),user.getGender(),user.getCity());
        
        System.out.println("등록된 UserId = " + user.getUserid() + " Name = " + user.getName());
        return result;
    }
 
    public List<UserVO> readAll() {
        String sql = "select * from users";
        List<UserVO> userList = jdbcTemplate.query(sql,new UserMapper());
        return userList;
    }
 
    public int delete(String id) {
        int result = 0;
        String sql = "delete from users where userid = ?";
        result = jdbcTemplate.update(sql,id);
        System.out.println("삭제된 UserId = " + id);
        return result;
    }
 
    public int update(UserVO user) {
        int result = 0;
        String sql = "update users set name=?,gender=?,city=? where userid=?";
        result = jdbcTemplate.update(sql,user.getName(),user.getGender(),user.getCity(),user.getUserid());
        System.out.println("수정된 UserId = " + user.getUserid());
        return result;
    }
 
    public UserVO read(String id) {
        String sql = "select * from users where userid=?";
        try {
            UserVO user = jdbcTemplate.queryForObject(sql,new Object[] {id},new UserMapper());
            return user;
        } catch (EmptyResultDataAccessException e) {
            e.printStackTrace();
            return null;
        }
 
    }
 
}
 

완성된 프로젝트 코드를 다운받으실수 있습니다.

https://dog-developers.tistory.com/30