SH's 개발일기

[SpringBoot] Security - 회원가입 DB 인증

shb — Mon, 16 May 2022 16:37:08 +0900

회원 가입하기
회원가입 → DB저장 → 인증
스프링 시큐리티에선
1. 하나의 계정에 복수개의 권한 부여 가능. 즉! 계정:권한 => 1:N 관계
2. DB 저장시 password 는 반드시 ‘암호화’ 해서 저장되어야 한다
a. 암호화는 스프링 시큐리티의 PasswordEncoder 사용
3. 인증을 위해 DB 조회시 필요한 ‘동작’들이 제공되어야 한다.

* DB 테이블 작성
[회원계정] 1:n [권한]
ERD 폴더와 sql 생성

* UserDTO 생성

* DummyData 만들기

* 로그인 폼에 회원가입 폼 링크추가
loginForm.jsp

* /join 핸들러 추가
IndexController.java

    @GetMapping("/join")
    public String join() {
        return "joinForm";
    }

회원가입 폼 작성
{view_root}/joinForm.jsp 생성

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<head>
<meta charset="UTF-8">
<title>회원가입 페이지</title>
</head>
<body>
<h1>회원가입 페이지</h1>
<hr>
<form action="/joinOk" method="POST">
    <input type="text" name="id" placeholder="아이디 입력"/><br>
    <input type="password" name="pw" placeholder="패스워드 입력"/><br>
    <input type="email" name="email" placeholder="이메일 입력"/><br>
    <input type="submit" value="회원가입">
</form>
</body>
</html>

* /joinOk 핸들러 추가
IndexController.java

    @PostMapping("/joinOk")
    public String joinOk(UserDTO user) {
        System.out.println("/joinOk: " + user);

        // password 는 암호화 하여 저장
        String rawPassword = user.getPw();
        String encPassword = passwordEncoder.encode(rawPassword);
        user.setPw(encPassword);
        
        userService.addMember(user);
        
        return "redirect:/login";
    }

* UserDAO.java 작성
{base-pacakge}/domain
인터페이스 작성

package com.lec.spring.domain;

import java.util.List;

public interface UserDAO {
    // 사용자(user) 추가
	int addUser(UserDTO user);
	  
    // 특정 id(username)의 사용자 에 권한(auth) 추가
	int addAuth(String id, String auth);
   
    // 사용자(user) 삭제
	int deleteUser(UserDTO user);
   
    // 특정 id(username)의 사용자의 특정 권한(auth) 삭제
	int deleteAuth(String id, String auth);
   
    // 특정 id(username)의 사용자의 권한(들) 전부 삭제
	int deleteAuths(String id);
   
    // 특정 id(username)의 사용자 조회
	UserDTO findById(String id);
   
    // 특정 id(username)의 사용자의 권한(들) 뽑기
	List<String> selectAuthoritiesById(String id);
	
}

* UserDAO.xml
MyBatis 매퍼 파일
{base-pacakge}/domain

<?xml version="1.0" encoding="UTF-8"?>
http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lec.spring.domain.UserDAO">

	<insert id="addUser" parameterType="com.lec.spring.domain.UserDTO"
		flushCache="true">
		INSERT INTO test_member2(mb_id, mb_pw, mb_email)
		VALUES(#{id}, #{pw}, #{email})
	</insert>
	
	<insert id="addAuth" flushCache="true">
		INSERT INTO test_authority2
		VALUES(#{param1}, #{param2})
	</insert>
	
	<delete id="deleteUser" parameterType="com.lec.spring.domain.UserDTO"
		flushCache="true">
		DELETE FROM test_member2
		WHERE mb_id = #{id}
	</delete>
	
	<delete id="deleteAuth" flushCache="true">
		DELETE FROM test_authority2
		WHERE mb_id = #{param1} AND mb_auth = #{param2}
	</delete>
	
	<delete id="deleteAuths" flushCache="true">
		DELETE FROM test_authority2
		WHERE md_id = #{param1}
	</delete>
	
	<select id="findById" resultType="com.lec.spring.domain.UserDTO">
	   SELECT
            mb_uid uid,
            mb_id id,
            mb_pw pw,
            mb_email email,
            mb_enabled enabled,
            mb_regdate regdate
        FROM test_member2
        WHERE mb_id = #{id} 
	</select>
	
	<select id="selectAuthoritiesById" resultType="String">
		SELECT mb_auth
		FROM test_authority2
		WHERE mb_id = #{id}		
	</select>
	
</mapper>

* UserDAOImpl.java 작성
{base-pacakge}/domain

package com.lec.spring.domain;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class UserDAOImpl implements UserDAO {

	private UserDAO mapper;
	
	@Autowired
	public UserDAOImpl(SqlSession sqlSession) {
		mapper = sqlSession.getMapper(UserDAO.class);
	}
	
	
	@Override
	public int addUser(UserDTO user) {
		return mapper.addUser(user);
	}

	@Override
	public int addAuth(String id, String auth) {
		return mapper.addAuth(id, auth);
	}

	@Override
	public int deleteUser(UserDTO user) {
		return mapper.deleteUser(user);
	}

	@Override
	public int deleteAuth(String id, String auth) {
		return mapper.deleteAuth(id, auth);
	}

	@Override
	public int deleteAuths(String id) {
		return mapper.deleteAuths(id);
	}

	@Override
	public UserDTO findById(String id) {
		return mapper.findById(id);
	}

	@Override
	public List<String> selectAuthoritiesById(String id) {
		return mapper.selectAuthoritiesById(id);
	}

}

* UserService.java 작성
{base-pacakge}/service

package com.lec.spring.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.lec.spring.domain.UserDAO;
import com.lec.spring.domain.UserDTO;

@Service
public class UserService {

	@Autowired
	UserDAO dao;
	
    // 회원가입
    // ROLE_MEMBER 권한 부여
	@Transactional
	public int addMember(UserDTO user) {
		int cnt = dao.addUser(user);
		dao.addAuth(user.getId(), "ROLE_MEMBER");
		return cnt;
	}

    // 회원삭제
	@Transactional
	public int deleteMember(UserDTO user) {
		dao.deleteAuths(user.getId());   // 권한(들) 먼저 삭제  (차라리 DDL 에 ON DELETE CASCADE 하자..)
		int cnt = dao.deleteUser(user);
		return cnt;
	}

    // 특정 id(username) 의 정보 가져오기
	public UserDTO findById(String id) {
		return dao.findById(id);
	}

    // 특정 id 의 권한(들) 정보 가져오기
	public List<String> selectAuthoritiesById(String id){
		return dao.selectAuthoritiesById(id);
	}
	
}

* PasswordEncoder
스프링 시큐리티는 기본적으로 PasswordEncoder 객체를 통해 ‘password’ 는 반.드.시 암호화 하여 다루도록 되어 있다.

public class SecurityConfig extends WebSecurityConfigurerAdapter{
	
    // PasswordEncoder 를 bean 으로 IoC 에 등록
    // IoC 에 등록된다, IoC 내에선 어디서든 가져다가 사용할수 있다.
	@Bean
	public PasswordEncoder encoder() {
		return new BCryptPasswordEncoder();
	}

* IndexController 수정

@Controller
public class IndexController {
	
	@Autowired
	UserService userService;
	
	@Autowired
	private PasswordEncoder passwordEncoder;

* 로그인 진행, DB를 통한 인증

UserDetails 작성
{bast-package}/config/PrincipalDetails.java

package com.lec.spring.config;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import com.lec.spring.domain.UserDTO;
import com.lec.spring.service.UserService;

//시큐리티가 /loginOk 주소요청이 오면 낚아채서 로그인을 진행시킨다.
//로그인 진행이 완료되면 '시큐리티 session' 에 넣어주게 된다. 
//우리가 익히 알고 있는 같은 session 공간이긴 한데..
//시큐리티가 자신이 사용하기 위한 공간을 가집니다. 
//=> Security ContextHolder 라는 키값에다가 session 정보를 저장합니다.
//여기에 들어갈수 있는 객체는 Authentication 객체이어야 한다.
//Authentication 안에 User 정보가 있어야 됨. 
//User 정보 객체는 ==> UserDetails 타입 객체이어야 한다.

//따라서 로그인한 User 정보를 꺼내려면
//Security Session 에서 
// => Authentication 객체를 꺼내고, 그 안에서
//      => UserDetails 정보를 꺼내면 된다.
public class PrincipalDetails implements UserDetails {

	private UserService userService;
	
	public void setUserService(UserService userService) {
		this.userService = userService;
	}
	
	private UserDTO user;
	public UserDTO getUser() {
		return user;
	}
	
	
	public PrincipalDetails(UserDTO user) {
		System.out.println("PrincipalDetails(user) 생성: " + user);
		this.user = user;
	}
	

    // 해당 User 의 '권한(들)'을 리턴
    // 현재 로그인한 사용자의 권한정보가 필요할때마다 호출된다. 혹은 필요할때마다 직접 호출해 사용할수도 있다
	@Override
	public Collection<? extends GrantedAuthority> getAuthorities() {
		System.out.println("getAuthorities() 호출");
		Collection<GrantedAuthority> collect = new ArrayList<>();
		
		List<String> list = userService.selectAuthoritiesById(user.getId());  // DB 에서 권한들 읽어옴.
		
		for(String auth : list) {
			collect.add(new GrantedAuthority() {
				
				@Override
				public String getAuthority() {					
					return auth;
				}
				
				@Override
				public String toString() {				
					return auth;
				}
			});
		}
	
		
		return collect;
	}

	// 로그인 한 사용자의 password 는?
	@Override
	public String getPassword() {		
		return user.getPw();
	}

	// 로그인 한 사용자의 username 은?
	@Override
	public String getUsername() {
		return user.getId();
	}

	// 계정이 만료된건 아닌지?
	@Override
	public boolean isAccountNonExpired() {
		return true;
	}

	// 계정이 잠긴건 아니지?
	@Override
	public boolean isAccountNonLocked() {
		return true;
	}

	// 계정 credential 이 만료된건 아니지?
	@Override
	public boolean isCredentialsNonExpired() {
		return true;
	}

	// 활성화 되었니?
	@Override
	public boolean isEnabled() {
		if("1".equals(user.getEnabled())) return true;
		return false;
	}

}

* UserDetailsService 생성
{base-package}/config/PrincipalDetailsService.java

package com.lec.spring.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import com.lec.spring.domain.UserDTO;
import com.lec.spring.service.UserService;

//UserDetailsService
//컨테이너에 등록한다.
//시큐리티 설정에서 loginProcessingUrl(url) 로 걸어 놓았기 때문에
//로그인시 위 url 로 요청이 오면 자동으로 UserDetailsService 타입으로 IoC 되어 있는
//loadUserByUsername() 가 실행되고
//인증성공하면 결과를 UserDetails 로 리턴
@Service
public class PrincipalDetailsService implements UserDetailsService {

	@Autowired
	private UserService userService;
	
	
    // UserDetails 를 리턴한다,  --> 누구한테 리턴하나?
    // 시큐리티 session ( <= Authentication( <= 리턴된 UserDetails ) )a
	@Override
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		System.out.println("loadUserByUsername(" + username + ")");
		
		UserDTO user = userService.findById(username);  // DB 조회 
		
		// 해당 username 의 user 가 DB 에 있었다면
		// UserDetails 을 생성하여 리턴
		if(user != null) {
			PrincipalDetails details = new PrincipalDetails(user);
			details.setUserService(userService);
			return details;
		}
		
        // 해당 username 의 user 가 없다면!
        // UsernameNotFoundException을 throw 해주도록 한다
		throw new UsernameNotFoundException(username);
	}

}

sesstion attribute 에 SPRING_SECURITY_CONTEXT 라는 이름으로 현재 로그인 정보가 담겨 있다.
그리고 그 정보는 Authentication 객체다.

[SpringBoot] Security

shb — Mon, 16 May 2022 14:54:14 +0900

Authentication (인증) / Authorization (인가)
인증(Authentication) : 자신을 증명
- 내가 (스스로) 자신을 증명할 만한 자료를 제시 하는 것.
- 시스템 접근 시, 등록된 사용자인지 여부를 확인하는 것
- 로그인

인가(Authorization) : 권한 부여
- 접근 후, 인증된 사용자에게 권한을 부여하는 것
- 남에 의해서 ‘자격’ 이 부여된것.
- 권한에따라 사용 가능한 기능이 제한됨
- 사용자 등급(ex: 일반/VIP/관리자)

서버로 들어오는 request를 낚아챌 수단이 필요하다.
‘request’ 를 처리하기 전에 보안체크부터 해야 한다. 검문소 역할을 해야 하는데
스프링 시큐리티는 서블릿 프로그래밍의 filter 객체를 사용하여 이를 구현한다.

filter
서블릿 2.3 부터 도입
'HTTP 요청과 응답을 변경할 수 있는 재사용가능한 코드'이다.

필터는 ‘객체의 형태’로 존재하며 클라이언트로부터 오는 요청(request)과 최종 자원(서블릿/JSP/기타 문서) 사이에 위치하여 클라이언트의 요청 정보를 알맞게 변경할 수 있으며, 또한 필터는 최종 자원과 클라이언트로 가는 응답(response) 사이에 위치하여 최종 자원의 요청 결과를 알맞게 변경할 수 있다.

Security Filter Chain
스프링 시큐리티도 서블릿 필터를 사용한다.
Security와 관련한 서블릿 필터도 실제로는 연결된 여러 필터들로 구성 되어 있다. 이러한 모습때문에 Chain(체인)이라 표현한다.

* IndexController 작성

package com.lec.spring.controller;

import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.lec.spring.domain.UserDTO;
import com.lec.spring.service.UserService;

@Controller
public class IndexController {
	
	@Autowired
	UserService userService;
	
	@Autowired
	private PasswordEncoder passwordEncoder;
	

	@RequestMapping({"", "/"})
	@ResponseBody
	public String sayHello() {
		return "<h2>/ : Hello</h2>";
	}
	
	// Spring Security(이하 '시큐리티') 가 적용되면
	// /login 등의 url 로의 request 를  시큐리티가 모두 낚아 챕니다.
	// ※ 나중에 SecurityConfig 가 설정되면 낚아 채지 않게 된다.
	@GetMapping("/login")
//	@ResponseBody
	public String login() {
	    System.out.println("GET: /login");
//	    return "<h2> /login : login 페이지</h2>";
	    return "loginForm";
	}
	
	@PostMapping("/login")
	public String loginFail() {
		System.out.println("POST: /login");
		return "loginForm";
	}
	

	//  현재 로그인한 정보 Authentication 보기
	@RequestMapping("/auth")
	@ResponseBody
	public Authentication auth(HttpSession session) {
		return SecurityContextHolder.getContext().getAuthentication();
		//시큐리티가 /loginOk 주소요청이 오면 낚아채서 로그인을 진행시킨다.
		//로그인 진행이 완료되면 '시큐리티 session' 에 넣어주게 된다. 
		//우리가 익히 알고 있는 같은 session 공간이긴 한데..
		//시큐리티가 자신이 사용하기 위한 공간을 가집니다. 
		//=> Security ContextHolder 라는 키값에다가 session 정보를 저장합니다.
		//여기에 들어갈수 있는 객체는 Authentication 객체이어야 한다.
		//Authentication 안에 User 정보가 있어야 됨. 
		//User 정보 객체는 ==> UserDetails 타입 객체이어야 한다.

	}
	
    @GetMapping("/join")
    public String join() {
        return "joinForm";
    }
	
    @PostMapping("/joinOk")
    public String joinOk(UserDTO user) {
        System.out.println("/joinOk: " + user);

        // password 는 암호화 하여 저장
        String rawPassword = user.getPw();
        String encPassword = passwordEncoder.encode(rawPassword);
        user.setPw(encPassword);
        
        userService.addMember(user);
        
        return "redirect:/login";
    }
    
    @RequestMapping("/accessError")
    public void accessError() {}

	
}

* SampleController.java 작성

package com.lec.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/sample/*")
public class SampleController {
	
	@GetMapping("/all/**")
	@ResponseBody
	public String doAll() {
		return "<h1>/all/** : 누구나 접근 가능</h1>";
	}
	
    @GetMapping("/user/**")
    @ResponseBody
    public String doUser() {
        return "<h1>/user/** : 로그인한 사람이면 접근 가능</h1>";
    }

    @GetMapping("/member/**")
    @ResponseBody
    public String doManager() {
        return "<h1>/member/** : 로그인한 사람중 'ROLE_MEMBER' 나 'ROLE_ADMIN' 권한만 접근 가능</h1>";
    }

    @GetMapping("/admin/**")
    @ResponseBody
    public String doAdmin() {
        return "<h1>/admin/** : 로그인 한 사람중 'ROLE_ADMIN' 권한가진 사람만 접근 가능</h1>";
    }

	
} // end controller

* Spring Security Starter 추가

일단 Spring Security (이하 ‘시큐리티’)가 적용되면, Security Filter Chain 이 가동된다.
(기본적으로) 모~ 든 페이지가 ‘인증’ 이 필요한 페이지로 동작(redirect)하게 됩니다.
즉, 어떠한 url 로의 request 접근도 ‘시큐리티’ 가 낚아챕니다. (intercept)

* SecurityConfig 생성
{base-package}/config/
SecurityConfig.java 생성
스프링 시큐리티에 대한 설정들이 이 안에서 메소드 체이닝으로 설정된다.

// 스프링 시큐리티 설정
@Configuration
@EnableWebSecurity  // Web Security 를 활성화 해준다.
					// 아래 스프링 시큐리티 필터가 스프링 필터 체인에 등록이 된다.
			// ↓ 등록될 필터 객체
public class SecurityConfig extends WebSecurityConfigurerAdapter{
	
    // PasswordEncoder 를 bean 으로 IoC 에 등록
    // IoC 에 등록된다, IoC 내에선 어디서든 가져다가 사용할수 있다.
	@Bean
	public PasswordEncoder encoder() {
		return new BCryptPasswordEncoder();
	}
	
	
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.csrf().disable();    // CSRF 비활성화  (Cross Site Request Forgery)

‘권한’ 기능을 부여해서
/sample/user/** 는 ← 로그인한 사람만
/sample/member/** 는 ← 회원만
/sample/admin/** 은 ← 관리자만
접근할수 있게 설정

* 접근 권한 세팅 진행
스프링 시큐리티에서 사용하는 권한명은 ‘ROLE_’ 로 시작하는 접두어를 갖고 동작하도록 기본 설정되어 있습니다.

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.csrf().disable();    // CSRF 비활성화  (Cross Site Request Forgery)
		
		http  // HttpSecurity 객체
			
			/**********************************************
			 * ① request URL 에 대한 접근 권한 세팅
		     * ExpressionInterceptUrlRegistry 객체 리턴.  이하 이 객체의 메소드체이닝
		     **********************************************/
			.authorizeRequests()
		
			// URL 과 접근권한 세팅(들)
	        // ↓ /sample/user/** 주소로 들어오는 요청은 '인증'만 필요.
			.antMatchers("/sample/user/**").authenticated()
	        // ↓ /sample/member/** 주소로 들어오는 요청은 '인증' 뿐 아니라 ROLE_MEMBER 나 ROLE_ADMIN 권한을 갖고 있어야 한다 ('인가')
	        .antMatchers("/sample/member/**").access("hasRole('ROLE_MEMBER') or hasRole('ROLE_ADMIN')")	                
	        // ↓ /sample/admin/**  주소로 들어오는 요청은 '인증' 뿐 아니라 ROLE_ADMIN 권한을 갖고 있어야 한다 ('인가')
			.antMatchers("/sample/admin/**").access("hasRole('ROLE_ADMIN')")
			// ↓ 그 밖의 다른 요청은 모두 permit! (위 주소들만 아니면 누구나 접근 가능!)
			.anyRequest().permitAll()

로그인 설정, 커스텀 로그인 페이지

.formLogin()
SecurityConfig.java

			.and()   // 다시, HttpSecurity 리턴,  다른 세팅 전환시 호출
			
			/******************************************** 
			 * ② 폼 로그인 설정
			 * FormLoginConfigurer<HttpSecurity> 리턴.  이하 이 객체의 메소드체이닝
			 ********************************************/
			.formLogin()  // form 기반 인증 페이지 활성화.  만약 .loginPage(url) 가 세팅되어 있지 않으면 '디폴트 로그인' form 페이지가 활성화 된다

.loginPage(url) 로그인 form

			.loginPage("/login")  // 로그인 필요한 상황 발생시 매개변수의 url (로그인 폼) 로 redirect 발생

여기까지 동작확인
접근권한 오류시 /login으로 이동하게 되고 아까와 달리 달리 우리가 제공한 로그인 페이지가 보인다.
이제 view 로 form을 보여주기.

* 로그인시 입력한 username, password 처리하기

SecurityConfig.java

			// 로그인 처리
			.loginProcessingUrl("/loginOk")  // "/loginOk" url 로 POST request 가 들어오면 시큐리티가 낚아채서 처리, 대신 로그인을 진행해준다.
										// 이와 같이 하면 Controller 에서 /longinOk 를 만들지 않아도 된다!
			.defaultSuccessUrl("/")   // '직접 /login' → /loginOk 에서 성공하면 "/" 로 이동시키기
		      			// 만약 다른 특정페이지에 진입하려다 로그인 하여 성공하면 해당 페이지로 이동 (너무 편리!)

IndexController.java

	@GetMapping("/login")
//	@ResponseBody
	public String login() {
	    System.out.println("GET: /login");
//	    return "<h2> /login : login 페이지</h2>";
	    return "loginForm";
	}

loginForm.jsp 작성
{view_root}/loginForm.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>로그인 페이지</title>
<style>
.error {color: red}
</style>
</head>
<body>
<h1>로그인 페이지</h1>
<hr>
<!-- loginProcessingUrl() 로 세팅한 url, 반드시 POST! -->
<form action="/loginOk" method="POST">  <!-- 시큐리티로 /loginOk 을 낚아챈다.  무조건 POST -->
    <!-- ↓ 아이디/패스워드 의 name 은 'username' 과 'password' 로 하자 (시큐리티의 디폴트) -->
    <input type="text" name="username" placeholder="아이디 입력" value="${username }"/><br>
    <input type="password" name="password" placeholder="패스워드 입력"/><br>
    <br>
    <span class="error">${errorMessage }</span><br>
    <input type="submit" value="로그인"/>
</form>
<a href="/join">회원가입을 아직도 안하셨나요?</a>
</body>
</html>

동작확인
/login (혹은 다른 인증이 필요한 url 로 접근시)
우리가 만든 커스텀 로그인 페이지가 뜬다.

username, password 입력하면 로그인 동작 수행

디폴트 username, password 변경하기
매번 서버가동할때 뜨는 디폴트 패스워드 복붙하기 싫다면
application.properties에서 설정

권한 맛보기
현재의 디폴트 계정으로 로그인 하면 /sample/user/** 만 가능하고
/sample/member/** , /sample/admin/** 는 안된다.

application.properties
# 디폴트 권한 설정, 앞의 ROLE_ 은 빼고 지정
spring.security.user.roles=MEMBER

서버 재시작 하면 일단 /logout 한뒤 다시 로그인
그리고 /sample/member/** 페이지로 들어가보면 -> 접근됨
반면 /sample/admin/** 페이지로 들어가보면 -> 접근 불가

# 디폴트 권한 설정, 앞의 ROLE_ 은 빼고 지정
spring.security.user.roles=ADMIN

-> ROLE_ADMIN 권한 지정

서버 재시작 하면 일단 /logout 한뒤 다시 로그인
그리고 /sample/member/** 페이지로 들어가보면 -> 접근됨
반면 /sample/admin/** 페이지로 들어가보면 -> 접근됨

# 디폴트 권한 설정, 앞의 ROLE_ 은 빼고 지정
spring.security.user.roles=ADMIN,MEMBER

-> ROLE_MEMBER 와 ROLE_ADMIN 권한 지정

하나의 계정에 복수개 권한 지정 가능

/sample/member/** 페이지로 들어가보면 -> 접근됨
반면 /sample/admin/** 페이지로 들어가보면 -> 접근됨

현재 로그인 한 정보는?
현재 인증(로그인) 한 정보는 Authentication 객체로 받아올수 있다.
IndexController.java

	//  현재 로그인한 정보 Authentication 보기
	@RequestMapping("/auth")
	@ResponseBody
	public Authentication auth(HttpSession session) {
		return SecurityContextHolder.getContext().getAuthentication();
		//시큐리티가 /loginOk 주소요청이 오면 낚아채서 로그인을 진행시킨다.
		//로그인 진행이 완료되면 '시큐리티 session' 에 넣어주게 된다. 
		//우리가 익히 알고 있는 같은 session 공간이긴 한데..
		//시큐리티가 자신이 사용하기 위한 공간을 가집니다. 
		//=> Security ContextHolder 라는 키값에다가 session 정보를 저장합니다.
		//여기에 들어갈수 있는 객체는 Authentication 객체이어야 한다.
		//Authentication 안에 User 정보가 있어야 됨. 
		//User 정보 객체는 ==> UserDetails 타입 객체이어야 한다.

	}

sesstion attribute에 SPRING_SECURITY_CONTEXT 라는 이름으로 현재 로그인 정보가 담겨 있다
그리고 그 정보는 Authentication 객체다.

[SpringBoot] MyBatis

shb — Fri, 13 May 2022 16:53:42 +0900

XML과 애너테이션(annotation)을 사용하여 ‘저장 프로시저’나 ‘SQL 문’으로 ‘객체’들을 연결(매핑)시킨다.
(SQL Mapper 라고도 한다)

** 과거 아파치재단 에서 iBATIS로 개발했으나, 그 개발진들이 ‘구글코드’로 옮기면서 MyBatis로 이름을 바꾸어 계속 업데이트중. (iBATIS 는 중단됨)

더 많이 코드를 줄일수 있고, 자바 코드가 아닌 ‘XML매퍼파일’ 을 통해서 DB에 접근 가능. 매우 간단
XML매퍼파일에 쿼리(SQL) 만 설정해두어도 알아서 동작
(기존의 Connection 만들던 방식, JdbcTemplate 을 사용하던 방식 다 필요 없어짐)

Mybatis 프레임워크

자바코드(** DAO) <-> XML 매퍼파일, SQL 세팅 -> DB

DAO는 인터페이스로만 주어지고, MyBatis가 DAO를 구현해준다.

<mappper>는 어느 DAO에 매핑될지 지정
<mapper>는 여러 <SQL세팅>으로 구성. 각 <SQL세팅>은 DAO의 어느 메소드에 매핑될지 지정

MyBatis의 Mapper : JAVA 객체와 SQL 연동
MyBatis에서 Mapper 역할을 하는 매핑파일(XML)은 ‘데이터’ 조작을 하는 객체와 쿼리(SQL)를 연결(mapping)한다.

‘데이터’ 조작을 하는 객체는 일반적으로 DAO객체가 그 역할을 하고 있다.

MyBatis : 한글 페이지
마이바티스 한글 : http://www.mybatis.org/mybatis-3/ko/
마이바티스 스프링 설정 : http://www.mybatis.org/spring/ko/sample.html
마이바티스 매퍼XML 설정 : http://www.mybatis.org/mybatis-3/ko/sqlmap-xml.html
마이바티스 매퍼설정: http://www.mybatis.org/mybatis-3/ko/configuration.html
그 밖에도 다양한 예제, 레퍼런스들 있음

MVC 기본 구조 작성

기존의 view (jsp) 파일들 가져오기, 기존 EL, JSTL 사용 버젼 가져오기
*.do 로 되어 있는 url 들 변경하기

* domain : DTO 작성
기존의 DTO 가져오기

WriteDTO.java

package com.lec.spring.domain;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

//DTO : Data Transfer Object
//DAO 등과 연동하여 데이터를 실어 나르는 객체
//필요한 객체(entity) 만큼 작성
public class WriteDTO {
	private int uid;    //  wr_uid
	private String subject;  // wr_subject
	private String content;  // wr_content
	private String name;     // wr_name
	private int viewCnt;  // wr_viewcnt
	private LocalDateTime regDate;  // wr_regdate
	
	// 웹개발시...
	// 가능한, 다음 3가지는 이름을 일치시켜주는게 좋습니다.
	// 클래스 필드명 = DB 필드명 = form의 name명

	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getSubject() {
		return subject;
	}
	public void setSubject(String subject) {
		this.subject = subject;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getViewCnt() {
		return viewCnt;
	}
	public void setViewCnt(int viewCnt) {
		this.viewCnt = viewCnt;
	}
	public LocalDateTime getRegDate() {
		return regDate;
	}
	// LocalDateTime 을 String 으로 리턴하는 getter
	public String getRegDateTime() {
		if(this.regDate == null) return "";
		return this.regDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"));
	}
	public void setRegDate(LocalDateTime regDate) {
		this.regDate = regDate;
	}

	// 개발할때 class 의 toString() 을 오버라이딩 해주면
	// 웹에 표현하거나, 디버깅이나 테스팅 하기 좋다.
	@Override
	public String toString() {
		return String.format("WriteDTO] %d: %s : %s : %s : %d : %s", 
				uid, subject, content, name, viewCnt, regDate);
	}
	
	
	
	
} // end DTO

* domain : DAO 작성
DAO는 interface로 작성
동작하는 ‘추상메소드’들 작성 ← 후에 MyBatis가 SQL 매핑하여 생성해주게 된다.

WriteDAO.java

package com.lec.spring.domain;
import java.util.List;

// MyBatis가 매핑할 인터페이스
public interface WriteDAO {
	
	// 새글 작성 <-- DTO
	public abstract int insert(WriteDTO dto);
	
	// 전체 SELECT
	public abstract List<WriteDTO> select();
		
	// 특정 uid 의 글 하나 SELECT --> List<DTO> 로 리턴
	public abstract List<WriteDTO> selectByUid(int uid);
	
	// 특정 uid 의 글 수정 <- DTO
	public abstract int update(WriteDTO dto);
	
	// 특정 uid 글 삭제하기
	public abstract int deleteByUid(int uid);
	
	// 특정 uid 글 조회수 증가
	public abstract int incViewCnt(int uid);
	
} // end DAO

* Controller 작성

BoardController.java

package com.lec.spring.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import com.lec.spring.domain.WriteDTO;
import com.lec.spring.service.BoardService;

@Controller
@RequestMapping("/board")
public class BoardController {

	private BoardService boardService;

	@Autowired
	public void setBoardService(BoardService boardService) {
		this.boardService = boardService;
	}


	public BoardController() {
		System.out.println("BoardController() 생성");
	}
	
	
	@RequestMapping("/list")
	public void list(Model model) {
		model.addAttribute("list", boardService.list());
	}
	
	@GetMapping("/write")
	public void write(Model model) {}
	
	@PostMapping("/writeOk")
	public void writeOk(WriteDTO dto, Model model) {
		model.addAttribute("result", boardService.write(dto));
		model.addAttribute("dto", dto);  // auto-generated key 
	}

	@GetMapping("/view")
	public void view(int uid, Model model) {
		model.addAttribute("list", boardService.viewByUid(uid));
	}
	
	@GetMapping("/update")
	public void update(int uid, Model model) {
		model.addAttribute("list", boardService.selectByUid(uid));
	}
	
	@PostMapping("/updateOk")
	public void updateOk(WriteDTO dto, Model model) {
		model.addAttribute("result", boardService.update(dto));
		model.addAttribute("dto", dto);
	}
	
	@RequestMapping("/deleteOk")
	public void deleteOk(int uid, Model model) {
		model.addAttribute("result", boardService.deleteByUid(uid));
	}
	
}

* Service 생성

BoardService.java

package com.lec.spring.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.lec.spring.domain.WriteDAO;
import com.lec.spring.domain.WriteDTO;

//Service 단.
//JSP MVC model2 의 Command 역할 비슷
//  Controller -> Commmand -> DAO

//- Transaction 담당
//Spring
//@Controller -> @Service -> DAO -> JdbcTemplate
@Service
public class BoardService {

	WriteDAO dao;
	
	@Autowired
	public void setDao(WriteDAO dao) {
		this.dao = dao;
	}
	
	public BoardService() {
		System.out.println("BoardServcie() 생성");		
	}

	public List<WriteDTO> list() {
		
		return dao.select();
	}

	@Transactional
	public List<WriteDTO> viewByUid(int uid) {
		// 트랜잭션 처리!
		// 1. 조회수 증가
		// 2. 글 하나 읽어오기
		dao.incViewCnt(uid);
		return dao.selectByUid(uid);
	}

	public int write(WriteDTO dto) {
		return dao.insert(dto);
	}

	public List<WriteDTO> selectByUid(int uid) {
		return dao.selectByUid(uid);
	}

	public int update(WriteDTO dto) {
		return dao.update(dto);
	}

	public int deleteByUid(int uid) {
		return dao.deleteByUid(uid);
	}
}

* DAO 구현체 작성
DAOImpl / 반복되는 MySQL Mapper를 주입받는 구현체

WriteDAOImple.java

package com.lec.spring.domain;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class WriteDAOImpl implements WriteDAO {

	private WriteDAO mapper;
	
	@Autowired
	public WriteDAOImpl(SqlSession sqlSession) {
		System.out.println("WriteDAOImpl() 생성");
		// MyBatis 가 생성한 WriteDAO 의 mapper (구현체)를 받아온다.
		mapper = sqlSession.getMapper(WriteDAO.class);   
	}
	
	
	@Override
	public int insert(WriteDTO dto) {
		return mapper.insert(dto);
	}

	@Override
	public List<WriteDTO> select() {
		return mapper.select();
	}

	@Override
	public List<WriteDTO> selectByUid(int uid) {
		return mapper.selectByUid(uid);
	}

	@Override
	public int update(WriteDTO dto) {
		return mapper.update(dto);
	}

	@Override
	public int deleteByUid(int uid) {
		return mapper.deleteByUid(uid);
	}

	@Override
	public int incViewCnt(int uid) {
		return mapper.incViewCnt(uid);
	}

}

WriteDAO.xml

MyBatis의 Mapper : JAVA 객체와 SQL 연동
MyBatis에서 Mapper 역할을 하는 매핑파일(XML)은 ‘데이터’ 조작을 하는 객체와 쿼리(SQL)를 연결(mapping)한다.

<?xml version="1.0" encoding="UTF-8"?>
http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lec.spring.domain.WriteDAO">

	<select id="select" resultType="com.lec.spring.domain.WriteDTO">
		SELECT 
			wr_uid "uid", 
			wr_subject subject, 
			wr_content content, 
			wr_name name, 
			wr_viewcnt viewcnt, 
			wr_regdate regDate 
		FROM 
			test_write 
		ORDER BY 
			wr_uid DESC	
	</select>

	<select id="selectByUid" resultType="com.lec.spring.domain.WriteDTO">
		SELECT 
			wr_uid "uid", 
			wr_subject subject, 
			wr_content content, 
			wr_name name, 
			wr_viewcnt viewcnt, 
			wr_regdate regDate 
		FROM 
			test_write
		WHERE wr_uid = #{uid} 
	</select>

	<update id="incViewCnt" flushCache="true">
		UPDATE test_write
		SET wr_viewcnt = wr_viewcnt + 1
		WHERE wr_uid = #{param1}
	</update>
	
	<insert id="insert" flushCache="true"
		parameterType="com.lec.spring.domain.WriteDTO"
		useGeneratedKeys="true"
		keyColumn="wr_uid" keyProperty="uid">
		INSERT INTO test_write
			(wr_subject, wr_content, wr_name)
		VALUES
			(#{subject}, #{content}, #{name})	
	</insert>
	
	<update id="update" flushCache="true"
		parameterType="com.lec.spring.domain.WriteDTO">
		UPDATE test_write
		SET wr_subject = #{subject}, wr_content = #{content}
		WHERE wr_uid = #{uid}
	</update>
	
	<delete id="deleteByUid" flushCache="true">
		DELETE FROM test_write WHERE wr_uid = #{uid}
	</delete>
	
	
	
</mapper>

* Controller 의 handler 및 view 파일 준비
각 url 별로 일단 매개변수 없이 view 만 보이기
동작 확인

[Spring Boot] Validation

shb — Thu, 12 May 2022 18:18:45 +0900

폼 데이터 검증 (Parameter Validation)
신뢰성 있는 웹 어플리케이션 작성을 위해 폼데이터 검증 필수
기본적으로 폼데이터는 2단계 걸쳐 검증해주어야 한다.
1단계: ‘클라이언트’ 에서 submit 하기 전에 검증 : (JavaScript) 사용
2단계: ‘서버’ 에서도 검증 : Spring, JSP 등 사용...

WriteDTO 클래스 가져오기
직전 단원에서 작성한 DTO 클래스와 패키지를 복사해옵시다.
생성자, getter, setter 의 출력코드 살려둡니다.

일단 기본적인 form 동작 작성

컨트롤러 생성

package com.lec.spring.controller;

import java.util.List;

import javax.validation.Valid;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.Errors;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import com.lec.spring.domain.BoardValidator;
import com.lec.spring.domain.WriteDTO;

@Controller
@RequestMapping("/board")
public class BoardController {
	
	@RequestMapping("write")
	public void write() {}
	
	
	// BindingResult : spring validator 가 유효성 검사를 한 결과가 담긴 객체
	@RequestMapping("writeOk")
	public String writeOk(@ModelAttribute("w") @Valid WriteDTO dto,
			BindingResult result,	
			Model model,  // Model 이 BindingResult 보다 앞에 있으면 에러..
			RedirectAttributes redirectAttrs   // redirect: 시 넘겨줄 값들
			) {
		System.out.println("writeOk : " + dto.getUid() + ":" + dto.getName());	
		String page = "board/writeOk";
		
//		System.out.println("validate전 "); showErrors(result);
		
		// validator 객체 생성
//		BoardValidator validator = new BoardValidator();
//		validator.validate(dto, result);
		
		System.out.println("validate후 "); showErrors(result);
		if(result.hasErrors()) {   // 에러가 있었으면
			redirectAttrs.addFlashAttribute("w", dto);  // 원래 입력한 값 돌려주기.
			if(result.getFieldError("uid") != null) {
				redirectAttrs.addFlashAttribute("errUid", "uid 값은 0보다 큰 정수이어야 합니다");
			}
			if(result.getFieldError("name") != null) {
				redirectAttrs.addFlashAttribute("errName", "name 은 필수 입니다");
			}
			if(result.getFieldError("subject") != null) {
				redirectAttrs.addFlashAttribute("errSubject", "subject 는 필수 입니다");
			}
			page = "redirect:/board/write";   // 리턴값(String)  에 redirect:url <- 해당 url 로 redirect 한다
		}
		
		
		return page;
	}
	
	// binding 에러 출력 도우미 메소드
	public void showErrors(Errors errors) {
		if(errors.hasErrors()) {
			System.out.println("에러개수: " + errors.getErrorCount());
			System.out.println("\t[field]\t|[code] ");
			List<FieldError> errList = errors.getFieldErrors();
			for(FieldError err : errList) {
				System.out.println("\t" + err.getField() + "\t|" + err.getCode());
			}
		} else {
			System.out.println("에러 없슴");
		}
	}
	
	// 이 컨트롤러의 클래스의 handler 에서 폼데이터를 바인딩할때 검증하는 객체 지정
	@InitBinder
	public void initBinder(WebDataBinder binder) {
		binder.setValidator(new BoardValidator());
	}
	
	
	
}

* 간단한 작성 폼 작성 : write.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<title>글 작성</title>
<style>
span { color: red;}
</style>
</head>
<body>
<form action="writeOk">
uid(<span>숫자</span>): 
	<input type="text" name="uid" value="${w.uid }"><span>${errUid }</span><br>
작성자(<span>*</span>): 
	<input type="text" name="name" value="${w.name }"><span>${errName }</span><br>
제목(<span>*</span>):
	<input type="text" name="subject" value="${w.subject }"><span>${errSubject }</span><br>
<input type="submit" value="등록"><br>
</form>
</body>
</html>

* writeOk.jsp 작성

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
uid: ${w.uid}<br>
작성자: ${w.name}<br>
제목: ${w.subject }<br>
<button onclick="history.back()">돌아가기</button>

동작 확인하기 - uid (숫자, int) 가 비어 있으면?

폼 데이터를 검증하려면 어디에?
커맨드 객체를 사용하는 상황에서 폼 검증은 어디서 해야 하나?
이미 스프링(Dispatcher Servlet)이 사전 처리 하는 단계에서 발생하는데?
스프링 MVC 에서 폼 데이터 검증 코드를 집어 넣으려면 어떻게?

스프링에서 폼 데이터 검증 validator

예제의 시나리오
아래와 같이 폼 데이터 에 대한 규칙이 있을때, 서버로 넘어온 폼데이터를 스프링에서 다루어 보도록 합니다

uid 값은 반드시 숫자 입력 : 비어 있으면 안됨.
name 은 반드시 입력 : 비어 있으면 안됨.

handler에 BindingResult 매개변수
마치 handler의 Model 매개변수와 마찬가지로 DispatcherServlet 에서 제공(자동주입) 해주는 객체
validator가 유효성 검사를 한 결과가 담긴 객체

BindingResult result

	// BindingResult : spring validator 가 유효성 검사를 한 결과가 담긴 객체
	@RequestMapping("writeOk")
	public String writeOk(@ModelAttribute("w") @Valid WriteDTO dto,
			BindingResult result,	
			Model model,  // Model 이 BindingResult 보다 앞에 있으면 에러..
			RedirectAttributes redirectAttrs   // redirect: 시 넘겨줄 값들
			) {
		System.out.println("writeOk : " + dto.getUid() + ":" + dto.getName());	
		String page = "board/writeOk";

이 상태에서 결과 확인
일단 400 에러 발생 안함 uid 값이 0
콘솔을 확인했을때 setUid( 0 )이 아예 호출되지 않았음

* 폼 데이터 오류 개수 확인

	// BindingResult : spring validator 가 유효성 검사를 한 결과가 담긴 객체
	@RequestMapping("writeOk")
	public String writeOk(@ModelAttribute("w") @Valid WriteDTO dto,
			BindingResult result,	
			Model model,  // Model 이 BindingResult 보다 앞에 있으면 에러..
			RedirectAttributes redirectAttrs   // redirect: 시 넘겨줄 값들
			) {
		System.out.println("writeOk : " + dto.getUid() + ":" + dto.getName());	
		String page = "board/writeOk";

결과 확인
정상적인 submit 인 경우 → 에러 개수 : 0
uid 가 없거나 숫자가 아니면 → 에러 개수 : 1

Data Binding
데이터 바인딩이란 프로퍼티 값을 타겟 객체에 설정해주는 것을 의미한다.
ex) 사용자의 문자열 입력값을 어플리케이션 도메인 객체의 프로퍼티값으로 동적으로 할당해주는 것과 같은 일을 데이터 바인딩이라고 한다.

error 출력 도우미 메소드 추가
Errors 에 담겨있는 에러 들을 다 출력해보기

	// binding 에러 출력 도우미 메소드
	public void showErrors(Errors errors) {
		if(errors.hasErrors()) {
			System.out.println("에러개수: " + errors.getErrorCount());
			System.out.println("\t[field]\t|[code] ");
			List<FieldError> errList = errors.getFieldErrors();
			for(FieldError err : errList) {
				System.out.println("\t" + err.getField() + "\t|" + err.getCode());
			}
		} else {
			System.out.println("에러 없슴");
		}
	}

* Validator 클래스 작성
패키지 : com.lec.spring
클래스 : BoardValidator
인터페이스 : implements Validator

Validator의 메소드 supports, validate

support() 작성

ublic class BoardValidator implements Validator {

	// 이 Validator 가 제공된 Class 의 인스턴스(clazz) 를 유효성 검사 할수 있나.
	@Override
	public boolean supports(Class<?> clazz) {
		System.out.println("supports(" + clazz.getName() + ")");
		// ↓ 검증할 객체의 클래스 타입인지 확인. 즉, WriteDTO <= clazz 가능 여부
		return WriteDTO.class.isAssignableFrom(clazz);
	}

validate() 작성

	// 주어진 객체(target) 에 유효성 검사를 수행하고
	// 유효성 검사에 오류가 있는 경우 주어진 객에체 이 오류들을 error 에 등록한다.
	@Override
	public void validate(Object target, Errors errors) {
		System.out.println("validate()");
		WriteDTO dto = (WriteDTO)target;
		
		Integer uid = dto.getUid();
		if(uid == null) {  // binding 실패하면 null 로 남아있을 것이다.
			System.out.println("uid 오류");
			// 에러등록 rejectValue(field, errorCode);
			errors.rejectValue("uid", "invalidUid");
		}
		
		String name = dto.getName();
		if(name == null || name.trim().isEmpty()) {
			System.out.println("name 오류: 반드시 한글자라도 입력해야 합니다");
			errors.rejectValue("name", "emptyName");
		}
		
		// ValidationUtils 사용
		// 단순히 빈 폼 데이터를 처리할때는 아래 와 같이 사용 가능
		// 두번째 매개변수 "subject" 은 반드시 target 클래스의 필드명 이어야 함
		// 게다가 Errors 에 등록될때도 동일한 field 명으로 등록된다. 
		ValidationUtils.rejectIfEmptyOrWhitespace(errors, "subject", "emptySubject");
	}

}

writeOk.do에 validator 객체 생성

		// validator 객체 생성
//		BoardValidator validator = new BoardValidator();
//		validator.validate(dto, result);

System.out.println("validate후 "); showErrors(result)

-> Binding 후 사용자가 validate() 를 호출하여 확인된 에러 추가

primitive 사용에 대한 고찰

binding 에러인데? uid 값이 0 ?
binding 실패하면... 초기값으로 남아있기 때문에
이러한 이유로.. primitive type 보단 wrapper 타입으로 설정한다.

ValidationUtils 사용
ValidationUtils 클래스
직전의 예제에서 데이터 검증을 위해서 Validator 인터페이스의 validate() 메소드를 사용하였습니다.
ValidationUtils 클래스는 validate()메소드를 좀더 편리하게 사용 할 수 있도록 고안된 클래스 입니다.

write.jsp, writeOk.jsp 수정

validate()에 추가

@Valid 와 @InitBinder 사용하기

validate() 를 스프링에서 호출하도록 설정
이전까지는 Validator 인터페이스를 구현한 클래스를 만들고,
validate()메소드를 직접 호출하여 사용 하였습니다.

이번에는 직접 호출하지 않고, 스프링 프레임워크에서 호출하는 방법에 대해서 살펴 봅니다.

spring-boot-starter-validation 를 설정하면
@Valid 와 @InitBinder 를 사용하기 위한 hibernate-validator 가 이미 들어와있다.

컨트롤러에 @InitBinder 추가
BoardController.java 에 추가

	// 이 컨트롤러의 클래스의 handler 에서 폼데이터를 바인딩할때 검증하는 객체 지정
	@InitBinder
	public void initBinder(WebDataBinder binder) {
		binder.setValidator(new BoardValidator());
	}

writeOk() 수정

	// BindingResult : spring validator 가 유효성 검사를 한 결과가 담긴 객체
	@RequestMapping("writeOk")
	public String writeOk(@ModelAttribute("w") @Valid WriteDTO dto,
			BindingResult result,	
			Model model,  // Model 이 BindingResult 보다 앞에 있으면 에러..
			RedirectAttributes redirectAttrs   // redirect: 시 넘겨줄 값들
			) {
		System.out.println("writeOk : " + dto.getUid() + ":" + dto.getName());	
		String page = "board/writeOk";
		
//		System.out.println("validate전 "); showErrors(result);
		
		// validator 객체 생성
//		BoardValidator validator = new BoardValidator();
//		validator.validate(dto, result);
		
		System.out.println("validate후 "); showErrors(result);
		if(result.hasErrors()) {   // 에러가 있었으면
			redirectAttrs.addFlashAttribute("w", dto);  // 원래 입력한 값 돌려주기.
			if(result.getFieldError("uid") != null) {
				redirectAttrs.addFlashAttribute("errUid", "uid 값은 0보다 큰 정수이어야 합니다");
			}
			if(result.getFieldError("name") != null) {
				redirectAttrs.addFlashAttribute("errName", "name 은 필수 입니다");
			}
			if(result.getFieldError("subject") != null) {
				redirectAttrs.addFlashAttribute("errSubject", "subject 는 필수 입니다");
			}
			page = "redirect:/board/write";   // 리턴값(String)  에 redirect:url <- 해당 url 로 redirect 한다
		}
		
		
		return page;
	}

결과 확인
supports() 가 호출됨을 알수 있다.
주어진 WriteDTO 객체가 BoardValidator 로 검증할수 있는지 여부를 먼저 supports() 로 체크하고 나서 validate() 를 수행하고 있는 것이다.

중요 : BindingResult 매개변수 순서

[스프링:에러] java.lang.IllegalStateException: Errors/BindingResult argument declared without preceding model attribute. Check your handler method signature!

Validate를 하는 메소드 내에서 BindingResult의 순서와 관련된 에러. BindingResult가 HttpServletRequest, HttpServletResponse, ModelMap보다 먼저 선언되어야 에러가 나지 않습니다.

에러시 원래 url 로 돌아가기. redirect: 사용

write.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<title>글 작성</title>
<style>
span { color: red;}
</style>
</head>
<body>
<form action="writeOk">
uid(<span>숫자</span>): 
	<input type="text" name="uid" value="${w.uid }"><span>${errUid }</span><br>
작성자(<span>*</span>): 
	<input type="text" name="name" value="${w.name }"><span>${errName }</span><br>
제목(<span>*</span>):
	<input type="text" name="subject" value="${w.subject }"><span>${errSubject }</span><br>
<input type="submit" value="등록"><br>
</form>
</body>
</html>

${errUid}

${errName}

[SpringBoot] Request Parameter

shb — Thu, 12 May 2022 18:03:38 +0900

request parameter를 받는 다양한 방법

스프링에서 제공하는 다양한 방법들에 대해 배웁니다.
1. request parameter 처리
2. GET 방식 / POST 방식 처리
3. @RequestParam
4. 커맨드 객체
5. @ModelAttribute
6. @PathVariable
7. redirect: forward:

프로젝트 생성
Bt011_RequestParam
Starter : SpringWeb, DevTools, Lombok

* HomeController 작성

package com.lec.spring;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.lec.spring.domain.WriteDTO;

@Controller
public class HomeController {

	@RequestMapping(value="/member/delete")  // @RequestMapping: GET, POST, PUT, PATCH, DELETE,.. 어떠한 방식의 request 이든 관계없이 동작
//	public void delMember(HttpServletRequest request, Model model) {
	public void delMember(Model model, HttpServletRequest request) {  // ★ 핸들어의 매개변수 순서 관계 없다!
		String id = request.getParameter("id");
		model.addAttribute("mbId", id);
	}
	
	//@RequestMapping(value="/member/regOk", method= RequestMethod.POST)  // POST 방식 request 일때만 처리
	@PostMapping("/member/regOk")
	public void registPost() {
		System.out.println("/member/regOk : POST");
	}
	
//	@RequestMapping(value="/member/regOk", method= RequestMethod.GET)
	@GetMapping("/member/regOk")
	public void registGet() {
		System.out.println("/member/regOk : GET");
	}
	
	// GET, POST 두가지 방식만 매핑하려면?
	@RequestMapping(value="/member/regOk2", method= {RequestMethod.GET, RequestMethod.POST})
	public String regOkMember2(HttpServletRequest request) {
		System.out.println("/membre/regOk2 : " + request.getMethod());
		return "member/regOk";
	}
	
	@RequestMapping("/member/regist")
	public void registMember() {}
	
	
	@RequestMapping("/member/find")
//	public void findMember(String id, String name, Model model) {
//	public void findMember(Model model, String id, String name) {  // 매개변수 순서에 영향 받지 않는다.
//	public void findMember(double id, String name, Model model) {  // 숫자타입이면, 해당타입으로 변환하여 binding
	
//	public void findMember(Double id, String name, Model model) { //  Wrapper 타입을 사용하면 id parameter 가 없는 경우에도 에러 없이 동작		
//		System.out.println("member/find: id=" + id + ", name=" + name);
//		
//		model.addAttribute("id", id);
//		model.addAttribute("name", name);
//	}
	
	// 동일한 name 의 request parameter 복수개
//	public void findMember(Integer[] id, String [] name, Model model) {
//		model.addAttribute("id", Arrays.toString(id));
//		model.addAttribute("name", Arrays.toString(name));
//	}
	
	// 만약 request parameter 의 name 과 매개변수가 같을수 없는 상황이면 
	// @RequestParam 애노테이션 사용
//	public void findMember(Model model,
//			@RequestParam("id") String userid, // "id" 란 name 의 parameter 값을 userid 매개변수에 binding 해준다
//			@RequestParam("name") String username 
//			) {
//		model.addAttribute("id", userid);
//		model.addAttribute("name", username);
//	}
	
	// 위의 경우 id 값이 없거나 변환 불가능하면 에러 발생한다.
	// @RequestParam(value="test", required=false, defaultValue="0") 을 이용하면 가능하긴 하다.		
	// 또한, @RequestParam 과 Map<name, value> 을 사용하면 된다. 	
	
	public void findMember(Model model,
			@RequestParam Map<String, String> map
			) {
		
		model.addAttribute("id", map.get("id"));
		model.addAttribute("name", map.get("name"));
	}
	
	// ---------------------------------------------------
	// 커맨드 객체 (Command object) 사용
	
	// 게시글 등록 form
	@RequestMapping("/board/write")
	public void writeBoard() {}
	
	
	@PostMapping("/board/writeOk")
//	public void writeOkBoard(Model model,
//			String name,
//			String subject,
//			String content
//			) {
//		
//		WriteDTO dto = WriteDTO.builder()
//				.name(name)
//				.subject(subject)
//				.content(content)
//				.build();
//		
//		model.addAttribute("dto", dto);
//		
//	}
	// 커맨드 객체 사용방식
	// 코드 작업량이 매우 줄어든다. (성능도 더 좋다)
//	public void writeOkBoard(WriteDTO dto) {
	
//  @ModelAttribute : 커맨드 객체의 model attribute 이름을 변경할수 있다.
	public void writeOkBoard(@ModelAttribute("DTO") WriteDTO dto) {
		System.out.println(dto);
	}
	
	//-------------------------------------------------
	// @PathVariable
//	@RequestMapping("/board/writePath/{name}/{subject}/{content}")
//	public String writePathBoard(Model model,
//			@PathVariable String name,
//			@PathVariable String subject,
//			@PathVariable String content
//			) {
	@RequestMapping("/board/writePath/{k1}/{k2}/{k3}")
	public String writePathBoard(Model model,
			@PathVariable(name="k1") String name,
			@PathVariable(name="k2") String subject,
			@PathVariable(name="k3") String content
			) {
		model.addAttribute("name", name);
		model.addAttribute("subject", subject);
		model.addAttribute("content", content);
		return "board/writepath";
	}
	
	
}

* parameter : HttpServletRequest 매개변수

String id = request.getParameter("id");
-> request 안의 parameter 값을 뽑아서 Model에 담아 봅니다.

@RequestMapping(value="/member/delete")  // @RequestMapping: GET, POST, PUT, PATCH, DELETE,.. 어떠한 방식의 request 이든 관계없이 동작
//	public void delMember(HttpServletRequest request, Model model) {
	public void delMember(Model model, HttpServletRequest request) {  // ★ 핸들어의 매개변수 순서 관계 없다!
		String id = request.getParameter("id");
		model.addAttribute("mbId", id);
	}

핸들러 메소드에 HttpServletRequest 매개변수 받을 수 있다.
이 안에는 parameter 라든지 여러가지 request 관련 정보들이 있다.
JSP/Servlet 에서 배웠던 바로 그 객체이기 때문에 관련 메소드 그대로 사용 가능합니다.

* member/delete.jsp 파일 작성

당연히 forwarding 된 JSP니까 request 객체 그대로도 parameter사용 가능

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
${mbId}<br>
<%= request.getParameter("id") %><br>

* 결과 확인
/member/delete?id=55

POST, PUT, DELETE .. 방식 request 받기
기본적으로 @RequestMapping 은 GET 방식에 동작함.
만약 POST 나 PUT, DELETE 같은 다른 방식으로 동작하게 하려면?

POST 방식 request 받기

//@RequestMapping(value="/member/regOk", method= RequestMethod.POST)  // POST 방식 request 일때만 처리
	@PostMapping("/member/regOk")
	public void registPost() {
		System.out.println("/member/regOk : POST");
	}

member/regOk.jsp 생성, 작성

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%= request.getParameter("name") %><br>

우선 resist.jsp와 핸들러 작성
다양한 방식의 method 로 request 하기 위한 폼을 만들어 보자

컨트롤러 작성

@RequestMapping("/member/regist")
	public void registMember() {}

member/regist.jsp 작성

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%-- action 의 url 과 method 주목 ! --%>
<form action="regOk" method="GET">
	<input type="text" name="name" value="GET"/>
	<input type="submit" value="GET요청"/>
</form>
<hr>
<form action="regOk" method="POST">
	<input type="text" name="name" value="POST"/>
	<input type="submit" value="POST요청"/>
</form>

@RequestMapping(value="/member/regOk", method= RequestMethod.POST)
@RequestMapping(value="/member/regOk", method= RequestMethod.GET)

- > 동일 request url & 다른 request method를 다른 handler로 처리 하기
동일한 request url 이지만 request method가 다르면 , 다른 메소드로 request mapping 가능.

@GetMapping, @PostMapping ... - Spring 4.3부터 등장
다음은 동일하게 동작한다.

	//@RequestMapping(value="/member/regOk", method= RequestMethod.POST)  // POST 방식 request 일때만 처리
	@PostMapping("/member/regOk")
	public void registPost() {
		System.out.println("/member/regOk : POST");
	}
	
//	@RequestMapping(value="/member/regOk", method= RequestMethod.GET)
	@GetMapping("/member/regOk")
	public void registGet() {
		System.out.println("/member/regOk : GET");
	}

* post 와 get 둘다 받으려면?
GET / POST 둘다 받는 request /member/regOk2 설정

@RequestMapping(value="/member/regOk2", method= {RequestMethod.GET, RequestMethod.POST})
	public String regOkMember2(HttpServletRequest request) {
		System.out.println("/membre/regOk2 : " + request.getMethod());
		return "member/regOk";
	}

register.jsp 파일에도 추가

* Put, Delete 방식 request.
기본적으로 <form> 의 method 는 get, post 방식만 지원.
서버 내부의 JSP 요청도 get, post, head 만 지원. → 405 에러 발생
Postman 등의 툴을 활용하여 request 해보자.

URL 매핑은 정상적으로 이루어진다 JSP 요청(forwarding)이 안될 뿐

매개변수로 request parameter 받기
handler에 request parameter 의 name 값과 ‘같은 이름(name)의 매개변수’ 있으면
바로 그 매개변수가 request parameter 값을 받아온다
(내부적으로 스프링이 알아서 주입하는 셈이다)

@RequestMapping("/member/find")
public void findMember(String id, String name, Model model) {
public void findMember(Model model, String id, String name) {  // 매개변수 순서에 영향 받지 않는다.
public void findMember(double id, String name, Model model) {  // 숫자타입이면, 해당타입으로 변환하여 binding

public void findMember(Double id, String name, Model model) { //  Wrapper 타입을 사용하면 id parameter 가 없는 경우에도 에러 없이 동작
System.out.println("member/find: id=" + id + ", name=" + name);

model.addAttribute("id", id);
model.addAttribute("name", name);
}

* 데이터 바인딩 (Data Binding)
"프로퍼티 값을 타겟 객체에 설정해주는 것"
사용자가 입력한 값을 애플리케이션 도메인 객체에 동적으로 할당하는 기능다. Spring에서는 사용자가 입력한 값은 '문자열'이고 도메인 객체에 맞는 자료형으로 변경 필요하기 때문에 추상화되어 있다.

id="aaa" name= "bbb" -> Request -> Dispatcher Servlet -> Binding -> String id String name

Controller

숫자타입으로 request parameter 받기
스프링은 request parameter 를 받아올때, handler 의 매개변수 타입으로 형변환, parsing 가능하면 변환해준다.

가급적 Wrapper 타입으로 parameter 받자
parameter 가 없는 경우에도 에러없이 동작하니까. (null 값으로 동작)

* 동일한 name의 request parameter 복수개
‘배열’로 받으면 된다.

동일한 name의 request parameter 복수개
public void findMember(Integer[] id, String [] name, Model model) {
model.addAttribute("id", Arrays.toString(id));
model.addAttribute("name", Arrays.toString(name));
}

@RequestParam
상황에 따라서는 handler 메소드의 ‘매개변수 이름’ 을 request parameter 와 일치시켜주기 어려울 때도 있다.
그런경우에는 @RequestParam을 사용하여, request parameter와 다른 이름의 매개변수로 받을 수 있다.

@RequestParam 애노테이션 사용
public void findMember(Model model,
@RequestParam("id") String userid, // "id" 란 name 의 parameter 값을 userid 매개변수에 binding 해준다
@RequestParam("name") String username
) {
model.addAttribute("id", userid);
model.addAttribute("name", username);
}

@RequestParam + Map<name, value>
위의 경우 id 값이 없거나 변환 불가능하면 에러 발생한다.
@RequestParam(value="text", required=false, defaultValue="0") 을 이용하면 없어도 동작 가능하긴 하다.
또한, @RequestParam 과 Map<name, value> 을 사용하면 된다.

	public void findMember(Model model,
			@RequestParam Map<String, String> map
			) {
		
		model.addAttribute("id", map.get("id"));
		model.addAttribute("name", map.get("name"));
	}

그러나 ‘다량의 parameter’ 를 받기에 Map<> 도 가능하긴 하나 개발한 사람 외에는 유지보수 어렵다.
그래서 다음의 ‘커맨더’ 를 사용한 방식을 많이 사용한다.

* ‘커맨드 객체’를 사용한 parameter 전달
HttpServletRequest 를 받든지..  @RequestParam 을 사용하든지…
request parameter 자체가 많아지면,  잔코딩이 많아지고, 유지보수에 어려움이 발생한다.
스프링에서는 ‘커맨드 객체( Command Object )’를 통해, 여러 request parameter 들을 ‘한번에’ 받아올수 있다!!
커맨드 객체란?  : form 으로 부터 넘어오는 parameter들을 담는 ‘빈(bean)’ 객체

컨트롤러

	// 커맨드 객체 (Command object) 사용
	
	// 게시글 등록 form
	@RequestMapping("/board/write")
	public void writeBoard() {}
	
	
	@PostMapping("/board/writeOk")
//	public void writeOkBoard(Model model,
//			String name,
//			String subject,
//			String content
//			) {
//		
//		WriteDTO dto = WriteDTO.builder()
//				.name(name)
//				.subject(subject)
//				.content(content)
//				.build();
//		
//		model.addAttribute("dto", dto);
//		
//	}

writeOk.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%--
${dto}
<hr>
작성자: ${dto.name }<br>
글제목: ${dto.subject}<br>
내용: ${dto.content}<br> 
 --%>
<%-- 
작성자: ${writeDTO.name}<br>
글제목: ${writeDTO.subject}<br>
내용: ${writeDTO.content}<br> 
uid: ${writeDTO.uid }<br>
조회수: ${writeDTO.viewCnt }<br>
등록일: ${writeDTO.regDate }<br>
 --%>
 
작성자: ${DTO.name}<br>
글제목: ${DTO.subject}<br>
내용: ${DTO.content}<br> 
uid: ${DTO.uid }<br>
조회수: ${DTO.viewCnt }<br>
등록일: ${DTO.regDate }<br>

<button onclick="history.back()">이전으로</button>

커맨드 객체 사용

커맨드 객체(Command Object) handler 메소드 매개변수로 명시하면
스프링 내부에서 빈(bean) 객체가 생성되고 request parameter 들을 담습니다.

스프링 내부에서 WriteDTO 타입의 빈(bean) 객체가 생성되어, request parameter에 대해 적절한 setter 가 호출되어 세팅됨.
그리고 Model 에 addAttribute() 되어 더해짐.

writeOk.jsp

EL 에 사용된 객체의 이름은 handler 매개변수 이름(dto) 가 아니라, 커맨드객체 ‘타입’ 입니다.
WriteDTO 타입의 bean 객체가 스프링 내부에 writeDTO 라는 id 로 생성된겁니다.

용어 문제
‘JSP MVC 모델2’ 의 경우 컨트롤러에서 수행하는 것을 Command 객체라 불렀습니다.
(스프링에서는 (나중에 언급되겠지만) 그와 같은 역할을 하는 객체를 Service 라고 도 합니다. 그러나 혼용되는게 문제)
한편, ‘스프링’에서 ‘커맨드 객체’라 함은 지금 배우고 있는 parameter 받기 위한 bean 객체 입니다
동일한 용어로 사용되는 것들이 있으니, 혼선일으키지 않도록, 문맥을 잘 살핍시다.

관찰: 커맨드 객체에 넘어오지 않은 필드값은 ?

@ModelAttribute
기본적으로 커맨드 객체는 객체의 타입명이 model의 ‘attribute’가 됩니다.

커맨드 객체의 model 의 ‘attribute’ 이름을 바꾸어 주기 위해선 @ModelAttribute를 사용합니다.

이제 Model 에는 “DTO” 라는 id 로 등록되어, EL 에서 사용 가능.

BindException
binding : parameter 들이 java 객체(command 객체 )에 담는 동작. 이 와중에 담길수 없는 (변환할수 없는) 상황이 발생하면 에러 발생

@PathVariable
request parameter를 GET 방식의 query string 이 아닌 ‘URL 경로’ 에 담아서 전달할수도 있다!

@RequestMapping("/board/writePath/{k1}/{k2}/{k3}")
	public String writePathBoard(Model model,
			@PathVariable(name="k1") String name,
			@PathVariable(name="k2") String subject,
			@PathVariable(name="k3") String content
			) {
		model.addAttribute("name", name);
		model.addAttribute("subject", subject);
		model.addAttribute("content", content);
		return "board/writepath";
	}

리다이렉트 redirect:
handler 메소드의 뷰 리턴값 (문자열) 에 redirect: 를 사용하면 해당 URL 로 redirect 된다.
RedirectAttributes
리다이렉트로 parameter 넘기기
스프링에서 제공하는 RedirectAttributes 객체를 사용해서 리다이텍트 되는 URL 로 parameter 를 넘겨줄수 있습니다.

* redirect, forward 방법 총정리

	redirect	forward
Servlet	response.sendRedirect(URL)	RequestDispatcher dispatcher = request.getRequestDispatcher(URL); dispatcher.forward(request, response);
JSP	response.sendRedirect(URL)	<jsp:forward page="URL"> pageContext.forward(URL)
Javascript	location.href=URL	클라이언트에선 forward란게 있을 수 없다.
Spring	handler 메소드에서 return "redirect:URL"	handler 메소드에서 return "forward:URL"

[SpringBoot] RequestMapping

shb — Thu, 12 May 2022 15:59:46 +0900

@Controller ~ @RequestMapping
RequestMapping

웹 어플리케이션은 원하는 형태의 request URL을 받아서

그 URL을 처리하는 동작(handler)를 찾아서 (mapping) 수행하고
원하는 ‘뷰’ 로 response 해주기

용어: 메소드? 핸들러? 컨트롤러?
@Controller 클래스 안의 @RequestMapping 등으로 지정된 메소드를 핸들러(Handler) 라고도 함.
그러나, 보통 혼용되어 이야기 됨.
컨트롤러 이야기 할때 메소드, 핸들러, 컨트롤러… ← 대체로 같은것을 지칭하는 것

* 기본적인 Controller 클래스 제작 흐름
@Controller를 이용한 클래스 생성
↓
요청 경로 지정
@RequestMapping, @GetMapping …. - 다양한 방법의 '경로지정'
↓
요청 처리 메소드 (handler) 구현 - 다양한 방법의 매개변수 지정
↓
“뷰 이름” 혹은 ModelAndView 리턴

URL mapping ↔  메소드 이름 ↔ 뷰이름
HomeController.java에  핸들러 메소드 작성
URL mapping , handler(메소드) 이름, 뷰 이름 리턴값  ← 굳이 같을 필요는 없다.

BoardController.java

package com.lec.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/board")
public class BoardController {
	
		
	@RequestMapping("/list")   // request -->  /board/list
	public String listBoard() {
		return "board/list_board";
	}
	
	@RequestMapping("/write")
	public String writeBoard() {
		return "board/write_board";
	}

	
	@RequestMapping("/view")  // request --> /board/view
	public String viewBoard() {
		return "board/view_board";
	}
	
	@RequestMapping("/update")
	public String updateBoard() {
		return "board/update_board";
	}
	
	@RequestMapping("/delete")
	public String deleteBoard() {
		return "board/delete_board";
	}
	
} // end Controller

MemberController.java

package com.lec.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping(value = "/member")    // -> /member 로 시작하는 request 를 처리
public class MemberController {

	
	@RequestMapping(value = "/save")  //  URL ->  /member + /save
	public String saveMember() {      //         =>  /member/save
		return "member/save";
	}
	
	@RequestMapping(value = "/load")
	public String loadMember() {
		return "member/load";        //         => /member/load
	}
	
	// 서버 가동중 에러 발생!
	// mapping url 중복.
//	@RequestMapping(value = "/search")
//	public String searchMember() {
//		return "member/search";      //        => /member/search          
//	}
	
	
	// 핸들러 리턴값이 void 이면
	// mapping 되는 url문자열에 해당하는 .jsp 파일로 forwarding 된다
	// (일반적으로 많이 사용)
	@RequestMapping("/remove")
	public void removeMember() {     //  URL =>  /member/remove
		                             //  JSP =>  /member/remove.jsp
	}
	
	
}

‘뷰’ 에 데이터 전달 : Model 매개변수
Model은 매개변수로 넘겨진다. ‘스프링 쪽’에서 넘겨주는 것이다.

핸들러 메소드는 Model 에 담기만 하면, 스프링이 DispatcherServlet에 넘겨준다.

향후 트랜잭션들을 수행한 결과를 model 에 담아서 뷰에 넘길수 있다.

‘뷰’ + ‘Model’ : ModelAndView 리턴
ModelAndView 에는 데이터들도 담고 ‘뷰’ 도 지정하고 그리고 리턴되면 OK

확장자 패턴 가능 *
@RequestMapping(value = "/member/*.do")
public String doMember() {
return "member/domember";
}

* 핸들러 메소드 동작은
1. @RequestMapping 으로 매핑된 request가 들어오면
2. 필요한 동작들(ex: 트랜잭션) 수행, DAO 혹은 @Service 등의 객체 사용
3. 결과는 Model에 담고, 뷰(View) 지정 ⇒ 합해서 ModelAndView 로 담아 리턴 가능

컨트롤러 클래스에 @RequestMapping !
일반적으로 request URL 체계도, 다루는 아이템별로 다루게 되는데…
가령
회원관리 URL 형태는 /member/○○○
상품관리 URL 형태는 /goods/○○○

이런식으로 request URL 이 기획되어 관리될 것이다.
그런데, 과연 이 모든 handler 가 하나의 @Controller 클래스에 있으면 체계적인 관리가 힘들다.

컨트롤러 클래스 작성
패키지 : {base-package}.controller
클래스명 : MemberController

@Controller 클래스 추가하면, 반드시 서버 재시작
DevTool 사용시는 굳이 할필요 없음

만약 @RequestMapping 중복되면?
애시당초 서버 가동 중에 Exception 발생한다
/member/search로 request 해보자

[SpringBoot] MVC

shb — Thu, 12 May 2022 15:08:06 +0900

스프링부트는 웹루트가 (마치) 3개인 것처럼 동작한다.
/static
/templates
/webapp

static : 정적 웹소스 , JS, css, html, 이미지 ...
템플릿 : Thymeleaf, Mustache ...
applicaiotn.properties : 스프링부트 설정파일
webapp(웹루트) : JSP들...
pom.xml : 메이븐 설정파일

src/main/resources 의 static 폴더
이미지, JS, css, html  ← 이런 파일들을 위한 홈 디렉토리
static (정적) 이다 함은 서버입장에서 별도의 프로세스 없이 그대로 response만 하는 파일들

스프링 부트에선 홈 디렉토리가 3개라 보시면 됨
src/main/resource/static   ← 정적인 파일들
src/main/resource/templates   ← 템플릿 파일들
src/main/webapp  ← 동적인 파일들 (jsp ..)

Jasper 라이브러리 추가하기 : 방법1
Mavern Reporitories view 에서
‘index build ’ 가 되어 있다면 다음과 같이 가능..

pom.xml 을 수정하면 꼭 Maven update 하자

* ViewResolver 설정
application.properties에서 설정
※단순 텍스트 파일이지만, 스프링에선 자동완성도 기능 지원한다.

handler의 리턴값 “home” -> prefix + “home” + suffix

뷰 (view) 완성 /WEB-INF/views/home.jsp <- /WEB-INF/views/ + home + .jsp

* spring-webmvc 라이브러리의 DispatcherServlet

MVC 모델에서 Controller 역할.
일단 모든 request 를 받아서 Java POJO Controller 에 매핑시키고
결과(model, view) 를 받아서 View 에 전달
Controller 의 앞에 있는 Controller 라 하여 이를 FrontController 라 한다.
View 에 전달할때, 다양한 View 에 전달할수 있도록 ViewResolver 개념을 둔다.

resource view resolver

HomeController.java

package com.lec.spring;

import java.time.LocalDateTime;
import java.util.Random;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
// Spring MVC 에서 'C' Controller 역할을 하는 클래스로 컨테이너에 생성
public class HomeController {
	
	public HomeController() {
		System.out.println("HomeController() 생성");
	}
	
	// Controller 안에는 request를 처리(handle) 하는 메소드들을 정의한다
	// 이러한 메소드들을 'handler' 라 한다.
	// handler 는 
	//  - '어떠한 request' 를 받아서, 
	//  - '어떠한 처리 (business logic)' 를 하고
	//  - '어떠한 response' 를 할지를 정의
	
	@RequestMapping("/")   //  "/" 라는 url 로 request 라 오면 아래 메소드가 처리(handle) 한다
	public String now(Model model) {  // Model : 데이터를 실어나르는 객체, View 까지 전달된다 
		
		System.out.println("/ : now() 호출 ");
		
		LocalDateTime t = LocalDateTime.now();
		model.addAttribute("serverTime", t.toString());  // Model 에 데이터 담기 (name-value)
		
		
		
		return "home";    // 리턴되는 "문자열" 은 -> View Resolver 로 전달
		
		//prefix = /WEB-INF/views/
		//suffix=.jsp
		
		// "/WEB-INF/views/" + "home" + ".jsp"  => /WEB-INF/views/home.jsp  로 포워딩
	}
	
	@RequestMapping("/aaa")
	public String home(Model model) {
		
		int a = new Random().nextInt(10);
		int b = new Random().nextInt(5);
		model.addAttribute("first", a);
		model.addAttribute("second", b);
		
		return "aaa/my";
		
		// "/WEB-INF/views/" + "aaa/my" + ".jsp"  => /WEB-INF/views/aaa/my.jsp  로 포워딩
	}
	
	
	@RequestMapping("/aaa/bbb")
	public String aaabbb(Model model) {   // 핸들러 '이름' 은 별로 중요하지 않다.
		int a = new Random().nextInt(10);
		int b = new Random().nextInt(5);
		model.addAttribute("first", a);
		model.addAttribute("second", b);
		
		return "aaa/bbb/title";  // => /WEB-INF/views/aaa/bbb/title.jsp
	}
	
	
	

} // end controller

my.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<title>my.jsp</title>
</head>
<body>
<h2>my.jsp - /aaa</h2>
${first } - ${second }<br>
<img src="cat.png"/><br>
</body>
</html>

[SpringBoot] Dependency Injection 의존주입

shb — Thu, 12 May 2022 13:37:28 +0900

스프링 빈 (bean)
스프링은 경량 컨테이너로서 객체 생성, 소멸과 같은 Life Cycle을 관리하며 스프링 컨테이너로부터 필요한 객체를 얻을 수 있다.
스프링 컨테이너에 의해서 자바 객체가 만들어지게 되면 이 객체를 스프링은 스프링 빈(Bean)이라고 부른다.

스프링부트에서 bean 생성 & 사용
스프링부트의 경우
@Component, @Service, @Controller, @Repository, @Bean, @Configuration 등으로 필요한 빈들을 등록하고 필요한 곳에서 @Autowired를 통해 주입받아 사용하는 것이 일반적이다.

Dependency Injection (의존 주입)
필요한 객체는 누가 만드나?
방법1] 직접 new 생성
방법2] 외부에서 만들어서 주입

설계 변경이 발생하면?
msg 변수에 담을 객체가 변경되어야 한다면?
즉, Main 이 ‘의존’하는 MessageBean 객체가 변경되어야 한다면?

기존 방식
만약 msg 를 수정하게 될 일이 있다면..
DI1Main 을 손 안대도 가능한가?
돌아가게 하려면 DI1Main 을 다시 컴파일 해야 한다. (즉 손을 대야 한다)

1. 필요한 객체를 직접 만드는 경우
SW 설계에 있어 다음과 같이 2개의 구성요소가 있고 Main 은 MessageBean 이 필요하다 (즉 의존한다)
그래서, MessageBean 쪽 설계에 변화가 생긴다면, Main도 수정/ 재컴파일 해야 한다?

만약 수백, 수천개의 구성요소 (그것도 제작사가 한군데가 아닌 여러 업체가 협업을 통해 만들어진)로 구성되어

서로 의존하는 구성의 SW 라면 어떻게 유지 보수 할 것인가?

2. 필요한 객체를 ‘외부’ 에서 생성 ‘주입’
그래서 SW 공학적으로 필요한 객체를 ‘외부’에서 생성해서 주입하는 방식이 유지 보수 측면에서 이로운 점이 많다.
스프링 프레임 워크에서 제공하는 ‘의존주입 (Dependency Injection)’ 기능을 통해 이를 배워보도록 하자.

비록 Main 이 MessageBean 객체를 필요(의존) 하지만, 외부에서 주입되는 MessageBean 객체가 변경되었다고 해서 Main 을 수정하거나 재컴파일 할 필요는 없다!

연습 2-1 :  빈 객체 생성 연습
컨테이너에서 객체를 생성한뒤 이를 의존주입받아 동작하는 코드 만들기

패키지 :  base-package.ex2_1
인터페이스 : OperatorBean
클래스 :  DIApp  main() 포함

다음 요구사항을 만족하는 프로그램을 작성
- 클래스 구조도가 오른쪽과 같이 구성되도록 작성하기
- 클래스
- DIApp ( main() )
- OperatorBean( interface )
- PlusOp, MinusOp (OperatorBean 구현체)
- Config.java (@Configuration)

main() 에서의 operator 와 각 operand1, operand2 값 지정은 Config.java 을 통해 외부 주입 될수 있도록 설정

MessageBean.java

package com.lec.spring.beans;

public interface MessageBean {
	public abstract void sayHello();
}

Score.java

package com.lec.spring.beans;

import lombok.Data;

@Data
public class Score {
	int kor;
	int eng;
	int math;
	String comment;
	
	public Score() {
		System.out.println("Score() 생성");
	}
	
	public Score(int kor, int eng, int math, String comment) {
		super();
		System.out.printf("Score(%d, %d, %d, %s) 생성\n", kor, eng, math, comment);
		this.kor = kor;
		this.eng = eng;
		this.math = math;
		this.comment = comment;
	}
}

Student.java

package com.lec.spring.beans;

import lombok.Data;

@Data
public class Student {
	String name;
	int age;
	Score score;
	
	public Student() {
		super();
		System.out.println("Student() 생성");
	}
	
	public Student(String name, int age, Score score) {
		super();
		System.out.printf("Student(%s, %d, %s) 생성\n", name, age, score.toString());
		this.name = name;
		this.age = age;
		this.score = score;
	}
}

MessageEng.java

package com.lec.spring.di01;

import com.lec.spring.beans.MessageBean;

public class MessageEng implements MessageBean {
	
	String msgEng = "Good Morning";
	
	// 생성자 : 언제 생성되는지 예의주시
	public MessageEng() {
		System.out.println("MessageEng() 생성");
	}	

	@Override
	public void sayHello() {
		System.out.println(msgEng);

	}

} // end MessageBean

MessgaeKor.java

package com.lec.spring.di01;

import com.lec.spring.beans.MessageBean;

public class MessageKor implements MessageBean {

	String msgKor = "안녕하세요";
	
	// 생성자 : 언제 생성되는지 주목
	public MessageKor() {
		System.out.println("MessageKor() 생성");
	}
	
	@Override
	public void sayHello() {
		System.out.println(msgKor);
	}

}

DiMain01.java

package com.lec.spring.di01;

import com.lec.spring.beans.MessageBean;

/*
	Dependency Injection (DI, 의존주입)
	필요한 객체는 누가 만들어 사용하나?
	
	방법1 : 직접 생성하여 사용
	
	문제점 : MessageBean 객체의 설계가 바뀐다면????
	
	결국 --> 사용하는 쪽에서의 코드수정 발생 -> 재컴파일
*/
public class DiMain01 {

	public MessageBean msg;
	
	public void setMsg(MessageBean msg) {
		this.msg = msg;
	}
	
	public static void main(String[] args) {
		System.out.println("Main 시작");

		DiMain01 app = new DiMain01();
		app.test();
		
		System.out.println("Main 종료");
	}

	private void test() {
		// 필요한 MessageBean 객체를
//		msg = new MessageKor();   // 직접 만들어(new) 사용
//		msg.sayHello();		
		
		// 필요한 MessageBean 객체의 설계 변경이 발생되면
		msg = new MessageEng();   // 직접 만들어(new) 사용
		msg.sayHello();
		
		// 결국 --> 사용하는 쪽에서의 코드수정 발생 -> 재컴파일
		
	}

}

용어
스프링 프레임워크에서 작업하면서 “컨테이너(Container)”, “스프링 컨테이너”, “,IoC 컨테이너”,

“Application Context 객체” “빈(bean) 컨테이너” .모두 (거의) 같은 말.
IOC : Inversion Of Control 의 약자

결국 스프링이란?
부품을 생성하고 조립하는 라이브러리 집합체 라고도 할 수 있음.

* 스프링 빈 (bean)
스프링은 경량 컨테이너로서 객체 생성, 소멸과 같은 Life Cycle을 관리하며 스프링 컨테이너로부터 필요한 객체를 얻을 수 있다.
스프링 컨테이너에 의해서 자바 객체가 만들어지게 되면 이 객체를 스프링은 스프링 빈(Bean)이라고 부른다.

* 스프링부트에서 bean 생성 & 사용
스프링부트의 경우
@Component, @Service, @Controller, @Repository, @Bean, @Configuration 등으로 필요한 빈들을 등록하고 필요한 곳에서 @Autowired를 통해 주입받아 사용하는 것이 일반적이다.

* 의존 자동 주입 : @Autowired 사용하기

‘컨테이너 안’에 이미 생성된 빈(bean)객체, 그리고 이를 의존하는 다른 빈 객체들로 하여금
자동적으로 참조 하여 주입될수 있게 하는 것이 Autowired(자동주입)를 구현하기 위해서는 아래와 같이 한다.
1. ‘자동주입 대상’에 @Autowired 애노테이션 사용
- 자동주입 대상 : 생성자, 멤버변수, setter메소드

★ Autowired(자동주입)는 세군데 발생
- 생성자 (Constructor injection)
- 멤버변수 (field injection)
- setter (setter injection)

@Autowired 검색순위

타입(다형성 적용) → 이름 → @Qualifier → @Primary
검색 실패시 예외 처리 또는 null 처리
@Autowired(required=false) : 빈이 존재하지 않으면 null 주입하여 처리

package com.lec.spring.di05;

import com.lec.spring.beans.MessageBean;

public class MessageEng implements MessageBean {
	
	String msgEng = "Good Morning";
	
	// 생성자 : 언제 생성되는지 예의주시
	public MessageEng() {
		System.out.println("MessageEng() 생성");
	}	

	@Override
	public void sayHello() {
		System.out.println(msgEng);

	}

} // end MessageBean

package com.lec.spring.di05;

import com.lec.spring.beans.MessageBean;

public class MessageKor implements MessageBean {

	String msgKor = "안녕하세요";
	
	// 생성자 : 언제 생성되는지 주목
	public MessageKor() {
		System.out.println("MessageKor() 생성");
	}
	
	@Override
	public void sayHello() {
		System.out.println(msgKor);
	}

}

package com.lec.spring.di05;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.lec.spring.beans.MessageBean;
import com.lec.spring.beans.Score;
import com.lec.spring.beans.Student;

@Configuration
public class Config05 {

	public Config05() {
		System.out.println("Config05() 생성");
	}
	
	@Bean
	public Score scoreA() {
		return new Score(77, 55, 89, "괜찮아요");
	}
	
	@Bean(name = "Park")
	public Student stu1() {
		return new Student("박주찬", 19, scoreA());
	}
	
	@Bean(name = "Hong")
	public Student stu2() {
		return new Student("홍길동", 25, scoreA());
	}
	
	@Bean(name="eng")
	public MessageBean msg1() {
		return new MessageEng();
	}

	@Bean
	@Primary  // 동일한 타입의 빈이 여러개 있을때 autowired 되는 우선순위
	public MessageBean msg2() {
		return new MessageKor();
	}
}

package com.lec.spring.di05;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.lec.spring.beans.MessageBean;
import com.lec.spring.beans.Student;

/*
 * Autowired (자동주입) 는 세군데 발생
 * - 생성자  (constructor injection)
 * - 멤버변수 (field injection)
 * - setter (setter injection)
 */

@SpringBootApplication
public class DIMain05 implements CommandLineRunner {

	Student stu1;
	Student stu2;
	
	@Autowired  // construcgtor injection
	// Sprig 4.3 <= 부터는 
	// 생성자가 '하나만' 있는 경우 생성자 @Autowired 생략가능
	
	// 기본적으로 자동주입(autowired) 는
	// 1. 같은 타입의  bean 이 주입
	// 2. 같은 타입이 여러개 이면, name 이 같거나 (혹은 유사) 한것이 주입
	// 3. @Qualifier, @Primary 등으로 특정 이름의 bean 주입
	public DIMain05(@Qualifier("Park") Student stu1, @Qualifier("Hong") Student stu2) {   // 동일 타입의 Student bean 이 복수개 있는데도 동작한다?!!
								
		System.out.println("DIMain05(Student, Student) 생성");
		this.stu1 = stu1;
		this.stu2 = stu2;
	}
	
	@Autowired   // filed injection
	MessageBean msg1;  // 동일한 이름의 bean 자동주입
	
	MessageBean msg2;
	
	@Autowired   // setter injection
	public void setMsg2(MessageBean msg) {
		this.msg2 = msg;
	}
	
	
	MessageBean msg3;
	@Autowired   // setter injection
	@Qualifier("eng")
	public void setMsg3(MessageBean msg) {
		this.msg3 = msg;
	}
	
	
	public static void main(String[] args) {
		System.out.println("Main 시작");
		SpringApplication.run(DIMain05.class, args);
		System.out.println("Main 종료");		

	}


	@Override
	public void run(String... args) throws Exception {
		System.out.println("- run() ----------------------------");
		
		System.out.println(stu1);
		System.out.println(stu2);
		
		msg1.sayHello();
		msg2.sayHello();
		msg3.sayHello();
		
		System.out.println("-----------------------------");		
	}

}

[Spring] Spring이란

shb — Wed, 11 May 2022 15:11:16 +0900

* 스프링의 핵심
- 스프링은 자바 언어 기반의 프레임워크
- 자바 언어의 가장 큰 특징 - 객체 지향 언어
- 스프링은 객체 지향 언어가 가진 강력한 특징을 살려내는 프레임워크
- 스프링은 좋은 객체 지향 애플리케이션을 개발할 수 있도록 도와주는 프레임워크

* 스프링 프레임워크 특징
1. 경량 컨테이너
a. 자바 객체를 담고 있는 컨테이너
2. DI (Dependency Injection: 의존주입) 지원
a. 설정파일로 객체 의존 관계 설정 및 생성.
3. AOP (Aspect Orientec Programming) 지원
a. 트랜잭션, 로깅, 보안 등 공통기능을 핵심기능에서 분리하여 적용 가능
4. IoC (Inversion Of Control) 제어반전 지원
5. POJO (Plain Old Java Object) 지원
a. 컨테이너 안의 객체는 특별한 상속이 필요없는 평범한 자바 객체
6. 트랜잭션 처리를 위한 일관된 방법 지원 (영속성)
a. 설정파일을 통한 일관된 트랜잭션 처리
7. 다양한 API 지원
a. 엔터프라이즈 어플리케이션 개발에 필요한 다양한 API 지원
(스케쥴링, 메일..)

모든 Spring project 의 핵심 기반은 ‘Spring Framework’ 다
- 핵심기술 : 스프링 DI 컨테이너, AOP, 이벤트, 기타
- 웹기술 : 스프링 MVC, 스프링 WebFlux
- 데이터접근기술 : 트랜잭션, JDBC, ORM 지원, XML지원
- 기술통합: 캐시, 이메일, 원격접근, 스케쥴링
- 테스트: 스프링 기반 테스트 지원
- 언어: 코틀린, 그루비
- 최근에는 Spring Boot 를 통해 Spring Framework 기술들을 편리하게 사용

* Spring이란 단어
- 애매하고, 너무 범위가 넓다. 문맥에 따라 다르게 사용
- 스프링 DI 컨테이너 기술
- 스프링 프레임워크
- 스프링 프레임워크 + 스프링 부트 + 스프링xxx 등을 모두 포함하는 생태계

* 프레임워크 (FrameWork)?
어플리케이션 프레임워크 는 프로그래밍 개발환경에서 기본적인 구조 (골조?) 를 제공하는 개발환경이다. 이를 통해, 어플리케이션 의 개발및 유지 보수의 생산성을 향상 시키는데 목적이 있다.
기본구조 라 함은 프레임워크 안에는 수많은 클래스, 함수, 개발툴 등의 집합체이고, 이들을 구동하는 다양한 구성요소들로 복잡하게 만들어져 있다.
‘인터페이스’ 등의 제공을 통해 개발자가 이를 기반으로 개발함.
결국 이미 제공된는 ‘틀’과 ‘클래스, 함수규칙’ 들의 동작을 이해해야 하고, 이를 사용하는 것인데.. 그러다 보니, 처음에 학습하고 숙달되는데 어려움이 있다.

* 프레임워크 vs 라이브러리
프레임워크는 단지 미리 만들어 둔 반제품이나, 확장해서 사용할 수 있도록 준비된 추상 라이브러리의 집합이 아니다.
프레임워크가 어떤 것인지 이해하려면 라이브러리와 프레임워크가 어떻게 다른지 알아야 한다.
라이브러리를 사용하는 애플리케이션 코드는 애플리케이션 흐름을 직접 제어한다.
단지 동작하는 중에 필요한 기능이 있을 때 능동적으로 라이브러리를 사용할 뿐이다.
반면에 프레임워크는 거꾸로 애플리케이션 코드가 프레임워크에 의해 사용된다.
프레임워크에는 분명한 제어의 역전(IOC) 개념이 적용되어 있어야 합니다.
애플리케이션 코드는 프레임워크가 짜놓은 틀에서 수동적으로 동작해야 합니다.

* Maven 이란?
- http://maven.apache.org/
- 자바용 프로젝트 빌드 관리 도구임 .
- 아파치 라이선스로 배포되는 오픈 소스 소프트웨어
- Project object model (POM) 개념에 기반을 두고 있음 .
- Maven can manage a project's build, reporting and documentation from a central piece of information
- History
2004 년 07 월 13 일 , Apache Maven 발표
2018 년 10 월 24 현재 version 3.6.x

[JSP] Comment

shb — Wed, 13 Apr 2022 18:29:18 +0900

* 게시판 댓글 기능 (JSON + AJAX 사용)
JSON resopnse + AJAX 를 사용한 댓글

* 구현할 댓글 기능
- 댓글 목록
- 댓글 작성
- 댓글 삭제 : 삭제는 한번 confirm 하고 진행

* ERD, DDL 작성

* 라이브러리 준비

* select 쿼리문 준비
# 특정글 의 (댓글 + 사용자) 정보

필요한 쿼리문 작성
D.java

	// ★ 댓글
	// 댓글과 작성자 SELECT
	public static final String SQL_COMMENT_SELECT = 
			"SELECT c.uid \"uid\", c.content \"content\", c.regdate \"regdate\",\r\n"
			+ "	u.uid \"user_uid\", u.username \"user_username\", u.password \"user_password\", u.name \"user_name\", u.authorities \"user_authorities\", u.regdate \"user_regdate\"\r\n"
			+ "FROM t2_comment c, t2_user u\r\n"
			+ "WHERE c.user_uid = u.uid "
			;
	
	// '특정 글'의 댓글과 작성자 정보 SELECT
	public static final String SQL_COMMENTS_BY_WRITE =
			SQL_COMMENT_SELECT
			+ "AND c.write_uid = ?\r\n"
			+ "ORDER BY c.uid DESC"
			;
	
	// 특정글에 댓글 추가
	public static final String SQL_COMMENT_INSERT = 
			"INSERT INTO t2_comment(user_uid, write_uid, content) VALUES"
			+ "(?, ?, ?)";	
	
	// 특정 댓글 삭제
	public static final String SQL_COMMENT_DELETE_BY_UID = 
			"DELETE FROM t2_comment WHERE uid = ?";

* CommentDTO 생성

package domain;

import java.time.LocalDateTime;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class CommentDTO {
	private int uid;   // uid
	private String content;
	// java.time.* 객체 변환을 위한 annotation
	@JsonDeserialize(using = LocalDateTimeDeserializer.class)
	@JsonSerialize(using = LocalDateTimeSerializer.class)
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Seoul")
	@JsonProperty("regdate")
	private LocalDateTime regDate;
	private UserDTO user;    // user_uid (FK) 작성자
	@JsonIgnore
	private WriteDTO write;  // write_uid (FK) 글
}

* CommentDAO 생성

package domain;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

import common.D;

public class CommentDAO {
	Connection conn;
	PreparedStatement pstmt;
	Statement stmt;
	ResultSet rs;
	
	// DAO 객체가 생성될때 Connection 도 생성된다
	public CommentDAO(){
		try {
			Class.forName(D.DRIVER);
			conn = DriverManager.getConnection(D.URL, D.USERID, D.USERPW);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} // end try
	}// 생성자
	
	// DB 자원 반납 메소드, 만들어놓으면 편함..
	public void close() throws SQLException{
		if(rs != null) rs.close();
		if(pstmt != null) pstmt.close();
		if(stmt != null) stmt.close();
		if(conn != null) conn.close();
	} // end close();
	
	// 댓글목록읽기
	// ResultSet --> List<DTO> 로 리턴
	public List<CommentDTO> buildList(ResultSet rs) throws SQLException{
		List<CommentDTO> list = new ArrayList<>();
		
		while(rs.next()) {
			int uid = rs.getInt("uid");
			String content = rs.getString("content");
			if(content == null) content = "";
			LocalDateTime regDate = rs.getObject("regdate", LocalDateTime.class); 			
			
			// user_id 의 User 정보 가져오기
			UserDTO user = UserDTO.builder()
					.uid(rs.getInt("user_uid"))
					.username(rs.getString("user_username"))
					.password(rs.getString("user_password"))
					.name(rs.getString("user_name"))
					.authorities(rs.getString("user_authorities"))
					.regdate(rs.getObject("user_regdate", LocalDateTime.class))
					.build()
					;
			
			CommentDTO dto = CommentDTO.builder()
					.uid(uid)
					.content(content)
					.regDate(regDate)
					.user(user)
					.build()
					;
			
			list.add(dto);
			
		} // end while
		
		return list;
	}
	
	
	// 특정글의 댓글들 SELECT
	public List<CommentDTO> selectByWrite(int write_uid) throws SQLException {
		List<CommentDTO> list = null;
		try{
			pstmt = conn.prepareStatement(D.SQL_COMMENTS_BY_WRITE);
			pstmt.setInt(1, write_uid);
			rs = pstmt.executeQuery();
			list = buildList(rs);
		}finally{
			close();
		} // end try
		return list;		
	} // end selectByWrite()
	
	
	// 댓글 작성 <-- DTO
	public int insert(CommentDTO dto) throws SQLException {
		int cnt = 0;
		
		String content = dto.getContent();
		UserDTO user = dto.getUser();  // 댓글 작성자 (로그인 한 사용자)
		WriteDTO write = dto.getWrite();  // 댓글이 달린 글 
		
		
		int uid;  // auto-generated keys 값
		// auto-generated 컬럼
		String [] generatedCols = {"uid"};  

		try{	
			pstmt = conn.prepareStatement(D.SQL_COMMENT_INSERT, generatedCols);
			pstmt.setInt(1, user.getUid());
			pstmt.setInt(2, write.getUid());
			pstmt.setString(3, content);
			cnt = pstmt.executeUpdate();
			
			if(cnt > 0){
				// auto-generated keys 값 뽑아오기
				rs = pstmt.getGeneratedKeys();
				if(rs.next()) {
					uid = rs.getInt(1);
					dto.setUid(uid);  // DTO 에 set
				}
			}
			
		}finally{
			close();
		} // end try
		
		
		return cnt;
	} // end insert()
	
	
	// 특정 댓글 삭제하기 <-- uid
	public int deleteByUid(int uid) throws SQLException {
		int cnt = 0;
		
		try{
			pstmt=conn.prepareStatement(D.SQL_COMMENT_DELETE_BY_UID);
			pstmt.setInt(1, uid);
			cnt = pstmt.executeUpdate();
		}finally{
			close();
		} // end try
		
		return cnt;
	} // end deleteByUid()
	
	
	
} // end DAO

* command.comment
CmdListCommand.java
CmdWriteCommand.java
CmdDeleteCommand.java

* CommentController 생성
이번에는 페이지를 response 하는게 아니다. (viewPage 가 필요없다)
걍 각 Command 를 execute() 만 해주면 된다.

package controller;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import command.Command;
import command.comment.CmtDeleteCommand;
import command.comment.CmtListCommand;
import command.comment.CmtWriteCommand;

@WebServlet("/comment/*")
public class CommentController extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    public CommentController() {
        super();
    }

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doAction(request, response);
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("UTF-8");
		doAction(request, response);
	}

	protected void doAction(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("CommentController.actionDo() 호출");
		
		String method = request.getMethod();
				
		// URL로부터 URI, ContextPath, Command 분리
		String uri = request.getRequestURI();
		String conPath = request.getContextPath() + "/comment";
		String com = uri.substring(conPath.length());
		
		// 테스트 출력
		System.out.println("uri: " + uri);  
		System.out.println("conPath: " + conPath);  
		System.out.println("com: " + com);

		Command command = null;   // 어떠한 로직을 수행할지

		switch(com) {
		case "/list":
			new CmtListCommand().execute(request, response);
			break;
		case "/write":
			if(method.equals("POST")) {
				new CmtWriteCommand().execute(request, response);
			}
			break;
		case "/delete":
			if(method.equals("POST")) {
				new CmtDeleteCommand().execute(request, response);
			}
			break;
		} // end switch
	
	
	} // end doAction()
	
	

} // end Controller

* Response 할 객체 준비 (공통)
일단 QryResult.java 객체
'공통적'으로 response 할 내용들을 필드로 담아서 정의
(@Data, @NoArgsConstructor 두개만)

package domain;

import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
public class QryResult {
	int count;  // 결괏값 
	String status;  // 결과 메세지
}

* Response 할 객체 준비 ( 댓글 List Response)

package domain;

import java.util.List;

import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
public class QryCommentList extends QryResult {
	List<CommentDTO> list;
}

댓글 목록
특정글의 댓글 목록 가져와서 response 하기
CmtListCommand.java 작성

package command.comment;

import java.io.IOException;
import java.sql.SQLException;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

import command.Command;
import domain.CommentDAO;
import domain.CommentDTO;
import domain.QryCommentList;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

public class CmtListCommand implements Command {

	@Override
	public void execute(HttpServletRequest request, HttpServletResponse response) throws IOException {
		
//		AjaxWriteResult obj = AjaxWriteResult.builder()
//				.num(177)
//				.name("홍길동")
//				.arr(new int[] {10, 20, 30})
//				.cities(Arrays.asList("서울", "인천", "부산"))
//				.item2(new AjaxItem(10, "사과"))
//				.build()				
//				;
		
		int uid = Integer.parseInt(request.getParameter("uid"));
		
		QryCommentList obj = new QryCommentList();
		ObjectMapper mapper = new ObjectMapper();   // JSON 매핑할 Mapper 객체
		
		
		try {
			List<CommentDTO> list = new CommentDAO().selectByWrite(uid);
			obj.setCount(list.size());
			obj.setStatus("OK");
			obj.setList(list);
		} catch (SQLException e) {
			e.printStackTrace();
			obj.setStatus("댓글목록 ERROR: " + e.getMessage());
		}
		
		String output = mapper.writeValueAsString(obj);  // JSON String <- Java Object
		System.out.println("output : " + output);
		response.setContentType("application/json; charset=utf-8");  // MIME 설정
		response.getWriter().write(output);

	}

}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
class AjaxWriteResult {
	private int num;   // -> number 로
	
	@JsonProperty("Name")  // JSON 으로 출력되는 이름지정
	private String name; // -> string
	private int[] arr;  // ->  array 로
	@JsonIgnore   // JSON 변환에서 제외
	private List<String> cities; // -> array 로 변환
	
	public int getAge() {
		return 43;
	}
	
	// -> object 로 변환
	AjaxItem item1;
	AjaxItem item2;
	
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
class AjaxItem {
	private int stock;
	private String product;
}

java.time.* 처리해주기
여기서 CommentDTO List 를 넣으면 response 할때 에러 난다.
1. Java8 의 Date/Time 객체를 위한 Jackson 의 추가 모듈 설치 +
2. java.time.* 에 대한 annotation 설정이 필요.하다
일단 server stop 하고 라이브러리 설치

* Jackson + java.time.* annotaion 설정하기

* 불필요한 필드에 @JsonIgnore 처리하기

* 일단 하단에 댓글 html 기본양식 붙이기
board/comment.jsp 생성, 댓글 기본 양식
그리고 board/view.jsp 에 include 시키기 그리고 결과 확인

* ROLE_MEMBER 가진 사용자만 댓글 작성 가능케 하기
comment.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>   
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %> 

<script src="https://kit.fontawesome.com/51772bd9bd.js" crossorigin="anonymous"></script>
    
<div class="container my-3 border rounded">
    <div class="mb-3 mt-3">
        <label>댓글: <span id="cmt_cnt"></span> 개</label>
        
        <%-- ROLE_MEMBER 권한 가진 사용자만 댓글 작성 가능 --%>
        <c:if test="${fn:contains(sessionScope.PRINCIPAL.authorities, 'ROLE_MEMBER') }">
        <div class="input-group my-2">
            <input type="text" class="form-control" id="input_comment">
            <button type="button" class="btn btn-outline-primary" id="btn_comment">작성</button>
        </div>
        </c:if>

        <table class="table table-hover mt-3" id="cmt_table">
            <thead>
              <tr>
                <th style="width: 16.66%">작성자</th>
                <th>내용</th>
                <th style="width: 16.66%">작성일</th>
              </tr>
            </thead>
            <tbody id="cmt_list">

            </tbody>
        </table>
    </div>
</div>

* 확인 후에는 일부 내용 삭제하기
댓글개수, <tbody> 안의 내용

* js/view.js 파일 생성
* board/view.jsp 에는
jQuery 와 함께 js 파일 포함
contextPath 와 현재 로그인한 user 의 uid 정보가 js 에 넘겨져야 하므로 jsp 파링레 설정
view.js 을 include

* view.js 작성
ajax() request - response 하기
댓글 목록 렌더링 해주기
작성자 본인인 경우에만 삭제 버튼 보여주기
댓글 작성 input 은 ROLE_MEMBER 권한을 가진이에게만 보여주기

* 댓글 작성
다음의 항목들이 서버로 전달되어야 한다
1. 어느글에 대한 댓글인지?
2. 어느 사용자가 작성한 댓글인지?
3. 댓글 내용은 무엇인지?
서버에서 INSERT 트랜잭션후 다시 댓글 list 를 불러와서 update 를 해야 한다.

* 댓글 작성 버튼 누를시 동작
view.js 의 document.ready() 에 등록
1. 입력한 값 검증
2. 전달할 parameter 준비
3. ajax request - response
4. response 후 댓글 목록 업데이트

* CmtWriteCommand 작성
CmtWriteCommand.java 작성

package command.comment;

import java.io.IOException;
import java.sql.SQLException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.fasterxml.jackson.databind.ObjectMapper;

import command.Command;
import domain.CommentDAO;
import domain.CommentDTO;
import domain.QryResult;
import domain.UserDTO;
import domain.WriteDTO;

public class CmtWriteCommand implements Command {

	@Override
	public void execute(HttpServletRequest request, HttpServletResponse response) throws IOException {
		int writeUid = Integer.parseInt(request.getParameter("write_uid"));  // 어느글에 대한 댓글?
		int userUid = Integer.parseInt(request.getParameter("user_uid"));  // 누가 쓰는 댓글?
		String content = request.getParameter("content");
		
		WriteDTO write = new WriteDTO();
		write.setUid(writeUid);
		UserDTO user = new UserDTO();
		user.setUid(userUid);

		CommentDTO dto = CommentDTO.builder()
				.write(write)
				.user(user)
				.content(content)
				.build();
		
		QryResult obj = new QryResult();  // response 할 Java 객체
		ObjectMapper mapper = new ObjectMapper();  // JSON 으로 매핑할 Mapper 객체
		
		try {
			int cnt = new CommentDAO().insert(dto);
			obj.setCount(cnt);
			obj.setStatus("OK");
		} catch (SQLException e) {
			e.printStackTrace();
			obj.setStatus("댓글 작성 ERROR: " + e.getMessage());
		}
		
		String output = mapper.writeValueAsString(obj);  // JSON 문자열 변환
		response.setContentType("application/json; charset=utf-8"); // MIME 설정
		response.getWriter().write(output);  // 전송
		
	}

}

* 댓글 삭제

1. 몇번(uid) 댓글이 삭제되는 것인가?
2. 삭제하기 전에 한번 confirm 시키기
3. 댓글 삭제 버튼
명심! : 댓글목록을 불러온 후에, 삭제 버튼에 대한 이벤트 리스터를 동작시켜야 한다.

view.js 에 addDelete() 함수

* CmtDeleteCommand 작성

package command.comment;

import java.io.IOException;
import java.sql.SQLException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.fasterxml.jackson.databind.ObjectMapper;

import command.Command;
import domain.CommentDAO;
import domain.QryResult;

public class CmtDeleteCommand implements Command {

	@Override
	public void execute(HttpServletRequest request, HttpServletResponse response) throws IOException {
		int uid = Integer.parseInt(request.getParameter("uid"));
		
		QryResult obj = new QryResult();
		ObjectMapper mapper = new ObjectMapper();
		
		try {
			int cnt = new CommentDAO().deleteByUid(uid);
			obj.setCount(cnt);
			obj.setStatus("OK");
		} catch (SQLException e) {
			e.printStackTrace();
			obj.setStatus("댓글 삭제 ERROR: " + e.getMessage());
		}
		
		String output = mapper.writeValueAsString(obj);  // JSON 문자열 변환
		response.setContentType("application/json; charset=utf-8"); // MIME 설정
		response.getWriter().write(output);  // 전송

	}

}