- 사원명을 클릭하면 "empView.do" 로 요청한다, 요청하면서 사원 번호인 empno 를 GET 방식으로 전달함
Controller 클래스 EmpController.java 에서 "empView.do" 요청 부분만
// 사원 상세페이지
@RequestMapping("empView.do")
public String empView(int empno, Model model) {
Emp emp = es.select(empno); // 사원 상세 정보 구하기
model.addAttribute("emp", emp);
return "emp/empView";
}
- 앞에서 넘어온 값인 사원번호를 @RequestParam (생략) 으로 바로 변수 empno 로 값을 받는다
- 자동으로 int 형으로 형변환되어 저장됨
- 1명에 대한 상세정보를 DB에서 구해와서 View 에 뿌려야 하므로 Model 객체를 매개변수에 선언해서 받음
<돌아온 후>
- 사원의 상세정보는 select() 가 리턴되면서 Emp DTO 객체에 저장되어 돌아온다, 그걸 Emp DTO 객체 emp 에 저장함
- 그 객체 emp 를 Model 객체에 저장하고 /WEB-INF/views/emp/empView.jsp 파일로 이동
- View 페이지로 이동할때 prefix, suffix 를 빼고 작성하고, 하위의 패키지는 적어줘야하므로 "emp/empView" 로 작성
Service 클래스 EmpServiceImpl.java 에서 select() 메소드 부분만
public Emp select(int empno) {
return ed.select(empno);
}
- DB 연동을 해야하므로 Service 로 넘어왔다
DAO 클래스 EmpDaoImpl.java 에서 select() 메소드 부분만
public Emp select(int empno) {
return sst.selectOne("empns.select", empno);
}
- root-context.xml 에서 SqlSession bean 객체를 생성했고, 그걸 DAO 클래스에 주입했으므로 selectOne() 사용 가능
- 전달된 사원번호 empno 를 selectOne() 을 호추랗며 그대로 전달함
- 사원 1명에 대한 상세정보를 구해야하므로 selectOne() 을 사용
Mapper 파일 Emp.xml 에서 id 가 "select" 인 태그 부분만
<select id="select" parameterType="int" resultType="emp">
select * from emp where empno=#{empno}
</select>
- 전달받은 사원 번호로 해당 사원의 상세정보(모든 정보) 를 검색함
- 전달받은 값은 사원번호이므로 전달받은 자료형 parameterType 은 "int"
- 돌려주는 자료형 resultType 은 Emp DTO alias 인 "emp"
- 다시 DAO -> Service -> Controller 로 갔다가 View 로 오게 된다
- emp.deptno (해당 사원의 부서) 와 dept.deptno (forEach에 의해 모든 부서의 부서번호가 차례대로 들어감) 가 같으면 selected 함으로서 해당 사원이 가입할때 등록했던 부서는 select-option 에서 선택되어 나타나도록 했다
+ jQuery 로 처리하면 간단하게 처리 가능
- 사원 번호을 readonly 속성으로 비활성화했다, readonly 이므로 값이 넘어간다!
- select-option 에 출력되는 내용은 부서명(부서번호) 형식이지만, 저장하는 값인 value 는 부서 번호가 된다
- 사원 수정폼에 수정할 정보를 입력하고 '수정' 을 누르면 action 인 "empUpdate.do" 로 요청한다
프로젝트 myBatis2 : 사원 정보 수정
Controller 클래스 EmpController.java 에서 "empUpdate.do" 요청 부분만
// 사원 정보 수정
@RequestMapping("empUpdate.do")
public String empUpdate(Emp emp, Model model) {
int result = es.update(emp);
model.addAttribute("deptno", emp.getDeptno());
model.addAttribute("result", result);
return "emp/empUpdate";
}
- 사원 수정폼에서 넘어온 값들을 @ModelAttribuate (생략) 을 사용해서 Setter 메소드들로 한번에 Emp DTO 객체인 emp 에 저장한다
- Emp Service 객체 es 를 사용해서 update() 메소드를 호출하고, 호출할때 수정할 정보를 저장한 객체 emp 를 전달
- 수정할 사원을 특정하는 사원 번호는 앞의 사원 수정폼에서 넘어왔으므로 emp 객체 안 emp.empno 에 저장되어있음
<돌아온 후>
- 수정 성공시 result 에는 1이 저장된다
- 수정이 끝난 후 부서 상세 페이지로 돌아가므로, 해당 사원이 소속된 부서의 부서번호가 필요하다, 그래서 emp.getDeptno() 를 "deptno" 네임으로 Model 객체에 저장
- View 페이지에서 수정 성공 / 실패 처리를 하기 위해 update() 에서 돌려받은 값 result 를 Model 객체에 저장
- /WEB-INF/views/emp/empUpdate.jsp 로 이동
Service 클래스 EmpServiceImpl.java 에서 update() 메소드 부분만
public int update(Emp emp) {
return ed.update(emp);
}
DAO 클래스 EmpDaoImpl.java 에서 update() 메소드 부분만
public int update(Emp emp) {
return sst.update("empns.update", emp);
}
- 수정할 정보를 담은 Emp DTO 객체 emp 를 받아서 그대로 전달
- 수정 성공시 자동으로 1을 리턴한다
Mapper 파일 Emp.xml 에서 id 가 "update" 태그 부분만
<update id="update" parameterType="emp">
update emp set ename=#{ename},job=#{job},sal=${sal},
comm=#{comm},deptno=#{deptno} where empno=#{empno}
</update>
- "emp" 는 MyBatis 환경설정 파일 Configuration.xml 에서 설정한 Emp DTO 의 alias 이다
- 객체 emp 가 넘어왔으므로 #{ename} 은 emp.getEname() 과 같은 의미
- 사원번호는 객체 emp 의 emp.empno 에 저장되어 있으므로 #{empno} 로 가져와서 where 절에 넣는다
- '삭제' 를 누르면 "empDelete.do" 료 요청한다, 요청하면서 사원 번호인 empno 를 전달
Controller 클래스 EmpController.java 에서 "empDelete.do" 요청 부분만
// 사원 삭제
@RequestMapping("empDelete.do")
public String empDelete(int empno, Model model) {
Emp emp = es.select(empno); // 사원 상세 정보 구하기
int result = es.delete(empno);
model.addAttribute("result", result);
model.addAttribute("deptno", emp.getDeptno());
return "emp/empDelete";
}
- 앞에서 넘어온 사원번호 empno 를 @RequestParam("empno") (생략) 을 통해 바로 매개변수의 empno 에 저장한다 사원 삭제할때 DB 연동 작업 2가지
1. 사원 상세 정보 구하기
- 사원을 삭제 한 후 그 사원이 속해있었던 부서의 부서 상세 페이지로 이동할 것이다, 그러려면 부서 번호가 필요함
- 부서 상세 페이지로 가기 위해, 삭제될 사원의 상세 정보를 구해서 거기서 부서 번호를 가져올 것 - 사원의 상세 정보를 구하기 위해 select() 메소드를 호출하며, 사원번호를 전달
2. 사원 삭제 하기
- 사원 삭제를 위해 delete() 메소드를 호출하며, 사원번호를 전달
<돌아온 후>
- 삭제된 사원 상세정보를 받은 emp 에서 emp.getDeptno() 로 사원이 소속되어있던 부서번호를 가져와서 Model 객체에 저장하고 empDelete.jsp 로 이동
1. 사원 상세 정보 구하기
- 이전에 여러번 했으므로 설명 생략
2. 사원 삭제하기
Service 클래스 EmpServiceImpl.java 에서 delete() 메소드 부분만
public int delete(int empno) {
return ed.delete(empno);
}
DAO 클래스 EmpDaoImpl.java 에서 delete() 메소드 부분만
public int delete(int empno) {
return sst.delete("empns.delete", empno);
}
Mapper 파일 Emp.xml 에서 id 가 "delete" 인 태그 부분만
<delete id="delete" parameterType="int">
delete from emp where empno=#{empno}
</delete>
- 삭제 성공시 "empList.do" 로 요청하면서 삭제된 사원의 소속 부서인 deptno 를 넘겨주면서 해당 부서 상세 페이지로 이동
- 50번 부서에 등록되어있는 사원 LAY2 를 삭제해보자
STS 에 Data Source Management 추가
- STS 에는 이클립스와 다르게 Data Source Management 가 없으므로 DB 연결 불가능하다
- STS 에 plug-in 기능을 추가해야 Data Source Management 를 사용 가능
- 설치 이후 이제 필요한 SQL문을 STS 내에서 실행할 수 있다
STS 에 Data Source Management 추가하는 방법
- 이러면 STS 에 plug-in 을 설치한다, 원격 저장소에서 로컬 저장소로 다운받음
- 그 후 STS 를 Restart 시키면 plug-in 이 추가되어있다
- 이후 이제 필요한 SQL문을 STS 내에서 실행할 수 있다
게시판 직접 만들어보기
설계도
spring 실습 설계도
프로젝트 명 spring
계정생성 sqlplus system/oracle create user spring identified by spring123;
권한 부여 (connect, resource 롤) grant connect, resource to spring;
테이블명 myboard
create table myboard( no number primary key, writer varchar2(20), passwd varchar2(20), subject varchar2(50), content varchar2(100), readcount number, register date );
시퀀스명 myboard_seq
create sequence myboard_seq;
구조 - base-package 는 myspirng 으로 한다 - prefix 하위에 board 가 있다 환경 설정 파일 작성(세팅) 순서 1) pom.xml 2) web.xml 3) servlet-context.xml 4) configuration.xml 5) board.xml 6) root-context.xml - 4), 5), 6) 은 DB 연동 관련 내용
오라클 계정 생성 및 권한 부여
- 기존 계정들은 복잡하므로 새 오라클 계정을 생성해서 프로젝트를 하자
Spring MVC 프로젝트 생성
- 도메인명 역순으로 지정해야한다
- com.myhome.spring 을 top-level 패키지로 지정
프토젝트 테스트
- 프로젝트 오른 마우스 -> Run As -> Run on Server
- 잘 실행되었음을 확인 가능
커넥션 생성, 테이블 생성하기
- webapp 폴더 하위에 sql 폴더 추가하고, 안에 SQL 파일 myboard.sql 생성
- 다음으로 커넥션을 연결해야함
- 커넥션이 생성되었다!
- Connection profile 도 설정한다
- 다음은 테이블 생성 위해 myboard.sql 작성
-- 게시판
select * from tab;
select * from seq;
select * from myboard;
-- 테이블명 : myboard
create table myboard(
no number primary key,
writer varchar2(20),
passwd varchar2(20),
subject varchar2(50),
content varchar2(100),
readcount number,
register date );
-- 시퀀스명 : myboard_seq
create sequence myboard_seq;
- 테이블과 시퀀스 생성하기
- 테이블 및 시퀀스 생성 확인
환경설정 파일 세팅
+ 환경 설정 파일 작성(세팅) 순서 1) pom.xml 2) web.xml 3) servlet-context.xml 4) configuration.xml 5) board.xml 6) root-context.xml
pom.xml 파일 세팅
- Maven 의 환경설정 파일이다
- 잘 실행되는 내용을 가져와서 복붙하면 된다, 프로젝트 myBatis2 의 pom.xml 을 그대로 가져와서 복붙
- pom.xml 은 프로젝트 바로 하위에 있으므로 프로젝트를 선택하고 붙여넣기 (overwrite)
- 이 폼에서 넘어가는 내용은 writer, passwd, subject, content 이다
- 입력하고 "글작성" 클릭시 "boardwrite.do" 로 넘어간다, Controller -> Service -> DAO (Mapper 파일) 으로 가야한다
- Controller 클래스 BoardController.java 에서 "boardwrite.do" 요청 부분을 처리하자
- 아래 내용을 작성
// 글 작성
@RequestMapping("boardwrite.do")
public String boardwrite(Board board, Model model) {
int result = bs.insert(board);
model.addAttribute("result", result);
return "board/insertresult";
}
- 폼에서 넘어온 값을 DTO 객체로 한번에 받기 위해 @ModelAttribute 사용
- 메소드 명은 요청 이름값과 같게 맞췄다
- 글을 작성(insert) 한 후 성공 / 실패를 View 에서 처리하기위해 어떠한 값들을 가져갈 것이므로 Model 객체 선언해서 받기
- Service 객체 bs 를 사용해서 Service 클래스의 insert() 메소드를 호출, 이때 삽입할 데이터인 객체 board 를 가져감, 리턴자료형은 int 이다
- Service 클래스 BoardService.java 에서 insert() 메소드를 생성해야한다
public int insert(Board board) {
return dao.insert(board);
}
- Controller 에서 이 메소드를 호출해야하므로 public, 리턴자료형은 int, 메소드 명은 insert(), 매개변수 자료형은 Board
- DAO 의 insert() 를 호출
- 이 코드를 복사 후 DAO 클래스 BoardDao.java 로 가서 복붙 하고 수정
- BoardDao.java 에서 insert() 메소드 생성
public int insert(Board board) {
return session.insert("insert", board);
}
- 이 insert() 가 실제 SQL문을 수행하고 성공시 1 을 반환함
- Mapper 파일인 Board.xml 에 id 가 "insert" 인 insert (글 작성) 문을 생성해야함
<!-- 글 작성 -->
<insert id="insert" parameterType="board">
insert into myboard values(myboard_seq.nextval,#{writer},
#{passwd},#{subject},#{content},0,sysdate)
</insert>
- 전달되는 값이 DTO Board 객체 board 이므로 DTO Board 의 alias 인 "board" 를 parameterType 에 설정
- no 컬럼은 sequence 인 myboard_seq 로 세팅
- 앞에서 객체 board 가 넘어왔으므로 #{writer}, #{passwd}, #{subject}, #{content} 로 세팅
- JSTL core 라이브러리 사용하기 위해 core 라이브러리 불러오는 코드 한 줄 추가
- 글 작성 성공하면 목록 페이지로 갈 것이므로 "boardlist.do" 요청하기
- 글 작성 실패시 이전 페이지인 글 작성 폼으로 돌아감
- index 파일을 실행시켜서 글 작성폼에서 글을 작성해보자
+ 글 수정 / 삭제 시 비밀번호가 맞아야 삭제되도록 하기 위해 비밀번호를 입력받는 것임
- "boardlist.do" 요청 처리를 하지 않았으므로 오류가 뜬다
- Controller 클래스 BoardController.java 에서 "boardlist.do" 요청을 처리하는 코드를 작성하자 (미완성, 수정 전)
// 글 목록
@RequestMapping("boardlist.do")
public String boardlist(HttpServletRequest request, Model model) {
int page = 1; // 현재 페이지 번호
int limit = 10; // 한 화면에 출력할 데이터 갯수
if(request.getParameter("page") != null) {
page = Integer.parseInt(request.getParameter("page"));
}
int startRow = (page - 1) * limit + 1;
int endRow = page * limit;
int listcount = bs.getCount(); // 총 데이터 갯수
System.out.println("listcount : " + listcount);
return "board/boardlist";
}
- 기본변수, 파생변수를 설정해서 DB에서 목록을 구해오고, 페이징 처리를 하고, 그걸 View 에 뿌려야함
- request 객체를 매개변수로 부터 받는다, 이렇게 매개변수에 선언하면 자동으로 request 객체를 받아옴
- 결과를 View 페이지에 뿌려야하므로 Model 객체도 매개변수에 선언해서 받아온다
1. 기본변수 page : 현재 페이지를 저장할 변수
2. 기본변수 limit : 한 화면에 출력할 데이터 개수를 저장하는 변수
3. 파생변수 starRow, endRow : page, limit 을 이용해서 구해준다, page, limit 로 생성 가능하므로 굳이 생성하지 않아도 된다
4. 기본변수 listcount : 총 데이터 갯수를 저장, DB 와 연동해서 count(*) 로 가져올 것
<총 데이터 개수 가져오기>
- Service 클래스의 getCount() 를 호출해서 리턴받는다 * 아래에서 Service 에서 getCount() 를 생성함
- 나머지 부분은 아래에서 다시 완성
- Service 클래스 BoardService.java 에서 getCount() 메소드를 생성해야함
public int getCount() {
return dao.getCount();
}
- DAO 클래스 BoardDao.java 에서 getCount() 메소드 생성하기
public int getCount() {
return session.selectOne("count");
}
- 그룹함수는 결과가 1개이므로 selectOne() 메소드 사용, id 가 "count" 인 SQL문 불러오기
- Mapper 파일 Board.xml 에서 id 가 "count" 인 SQL문 생성
<!-- 총 데이터 갯수 -->
<select id="count" resultType="int">
select count(*) from myboard
</select>
- 돌려주는 값이 총 데이터 갯수이므로 resultType 은 "int"
- 총 데이터 갯수를 가져왔는지 확인하기 위해 현재 상태에서 index 파일에서 "boardlist.do" 로 요청해보자
- index 파일 실행 하고 콘솔창 보기
- listcount 값이 찍혀 나왔다, 글을 하나 작성했었으므로 listcount : 1 이 맞다
- 이제 목록을 가져오는 작업을 Controller 부터 처리하자
- Controller 클래스 BoardController.java 에서 "boardlist.do" 요청을 처리하는 코드를 작성하자 (이어서, 완성, 추가되었다)
// 글 목록
@RequestMapping("boardlist.do")
public String boardlist(HttpServletRequest request, Model model) {
int page = 1; // 현재 페이지 번호
int limit = 10; // 한 화면에 출력할 데이터 갯수
if(request.getParameter("page") != null) {
page = Integer.parseInt(request.getParameter("page"));
}
int startRow = (page - 1) * limit + 1;
int endRow = page * limit;
int listcount = bs.getCount(); // 총 데이터 갯수
System.out.println("listcount : " + listcount);
List<Board> boardlist = bs.getBoardList(page); // 게시판 목록
System.out.println("boardlist : " + boardlist);
// 총 페이지
int pageCount = listcount / limit + ((listcount % limit == 0) ? 0 : 1);
int startPage = ((page - 1) / 10) * limit + 1; // 1, 11, 21...
int endPage = startPage + 10 - 1; // 10, 20, 30...
if(endPage > pageCount) endPage = pageCount;
model.addAttribute("page", page);
model.addAttribute("listcount", listcount);
model.addAttribute("boardlist", boardlist); // 리스트
model.addAttribute("pageCount", pageCount);
model.addAttribute("startPage", startPage);
model.addAttribute("endPage", endPage);
return "board/boardlist";
}
<목록 가져오기>
- MyBatis 로 처리하면 DAO -> Mapper 파일로 갈때 단 하나의 값만 전달가능하다
- limit 은 고정되어있고, startRow, endRow 는 나중에 페이지 번호 page 로 계산 가능하므로 페이지번호 page 만 넘기기
+ 또는 map 객체에 키밸류 형태로 저장하는 방법도 있다
- getBoardList() 에서 글들이 저장된 리스트를 반환하도록 할 것 * 아래에서 설명
<돌아온 후>
- getBoardList() 에서 돌아온 후 콘솔창 출력해보면 boadlist 에 내가 썼던 글의 주소가 출력된다
5. 파생변수 pageCount : 총 페이지 수를 구함, listcount 와 limit 사용
6. 파생변수 startPage & endPage : 각(현재) 블럭의 시작 페이지, 끝 페이지, page 와 limit 사용
- 이후 기본변수, 파생변수, 가져온 목록(List) 들을 Model 객체에 저장하고 board/boardlist.jsp 로 이동
- Service 클래스 BoardService.java 에서 목록을 가져오는 메소드 getBoardList() 를 생성하자
public List<Board> getBoardList(int page) {
return dao.getBoardList(page);
}
- DAO 클래스 BoardDao.java 에서 getBoardList() 를 작성하자
public List<Board> getBoardList(int page) {
return session.selectList("list", page);
}
- 여러개의 글(DTO 객체) 을 가져올 것이므로 selectList() 메소드 사용
- 페이지 번호 page 를 전달함, 받는 값은 DTO 객체들이 저장된 리스트이다
- Mapper 파일 Baord.xml 에서 id 가 "list" 인 SQL문 작성
<!-- 글 목록 -->
<!-- > : > , < : < -->
<select id="list" parameterType="int" resultType="board">
<![CDATA[
select * from (select rownum rnum, board.* from (
select * from myboard order by no desc) board )
where rnum >= ((#{page}-1) * 10 + 1) and rnum <= (#{page} * 10)
]]>
</select>
- 페이지 번호가 넘어오므로 parameterType 은 "int" , 돌려주는 값은 DTO 가 저장된 리스트 이므로 resultType 은 "board"(DTO alias)
- limit 은 10으로 고정되어있으므로 10 으로 쓰고, startRow, endRow 는 페이지 번호 page 로 계산 가능해서 사용하기
+ <. > 인식을 못하므로 > , $lt; 사용, 또는 <![CDATA[ ]]> 로 전체 SQL문으로 감싸주면 부등호 기호 <, > 를 인식함
- View 페이지를 보기 전에 페이징 처리를 확인하기 위해 myboard.sql 에서 데이터를 강제로 많이 삽입하자
insert into myboard values(myboard_seq.nextval,'Lay','1234','Practice1',
'Content',0,systdate)
- View 페이지 board/boardlist.jsp 를 생성해서 Contorller 에서 Model 객체에 저장된 값들을 활용해서 목록을 출력하자
- boardlist.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="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>게시판 목록</title>
</head>
<body>
<a href="boardform.do">글작성</a> <br>
글갯수 : ${listcount }
<table border=1 align=center width=700>
<caption>게시판 목록</caption>
<tr>
<th>번호</th>
<th>제목</th>
<th>작성자</th>
<th>날짜</th>
<th>조회수</th>
</tr>
<!-- 화면 출력 번호 -->
<c:set var="num" value="${listcount - (page - 1) * 10}"/>
<c:forEach var="b" items="${boardlist}">
<tr>
<td>${num}
<c:set var="num" value="${num-1}"/>
</td>
<td>
<a href="boardcontent.do?no=${b.no}&page=${page}">${b.subject}</a>
</td>
<td>${b.writer}</td>
<td>
<fmt:formatDate value="${b.register}"
pattern="yyyy-MM-dd HH:mm:ss"/>
</td>
<td>${b.readcount}</td>
</tr>
</c:forEach>
</table>
<br>
<!-- 페이지 처리 -->
<center>
<c:if test="${listcount > 0}">
<!-- 1페이지로 이동 -->
<a href="boardlist.do?page=1" style="text-decoration:none"> << </a>
<!-- 이전 블럭으로 이동 -->
<c:if test="${startpage > 10}">
<a href="boardlist.do?page=${startPage - 10}">[이전]</a>
</c:if>
<!-- 각 블럭에 10개 페이지 출력 -->
<c:forEach var="i" begin="${startPage}" end="${endPage}">
<c:if test="${i == page}"> <!-- 현재 페이지 -->
[${i}]
</c:if>
<c:if test="${i != page}"> <!-- 현재 페이지가 아닌 경우-->
<a href="boardlist.do?page=${i}">[${i}]</a>
</c:if>
</c:forEach>
<!-- 다음 블럭으로 이동 -->
<c:if test="${endPage < pageCount}">
<a href="boardlist.do?page=${startPage + 10}">[다음]</a>
</c:if>
<!-- 마지막 페이지로 이동 -->
<a href="boardlist.do?page=${pageCount}" style="text-decoration:none"> >> </a>
</c:if>
</center>
</body>
</html>
- JSTL core 라이브러리, 국제화 라이브러리를 불러오기
7. 파생변수 num : 화면 출력 번호, 코어 라이브러리 set 태그 사용해서 생성했음, listcount, page 를 사용해서 생성
- forEach 태그 items 안에 목록 리스트인 ${boardlist} 를 써서 하나씩 글을 가져오기
- forEach 루프가 돌아갈때마다 num 을 1씩 감소시키기, 이때 코어 라이브러리 set 태그 사용해서 재정의 하는 방식
- @Autowired 를 통해서 SqlSessionTemplate 객체를 SqlSessionTemplate st 에 주입
- 2개 이상의 데이터를 검색할 것이므로 selectList() 를 호출
- 이 selectList() 메소드는 위에서 SqlSessionTemplate 객체를 구해왔으므로 사용 가능한 것
- 현재는 Mapper 파일이 2개이므로 id 중복을 피하기 위해 namespace 를 사용한다
+ Mapper 파일 중 하나인 Dept.xml 의 namespace 는 "deptns"
- 그래서 selectList("deptns.list") 는 Dept.xml 파일에서 id 가 list 인 태그의 select SQL문을 불러오는 것을 의미
- 돌려받은 값(리스트)을 그대로 리턴
Mapper 파일 Dept.xml 에서 id 가 "list" 인 태그 부분만 + resultMap
<!-- Use type aliases to avoid typing the full classname every time. -->
<resultMap id="deptResult" type="dept">
<result property="deptno" column="deptno" />
<result property="dname" column="dname" />
<result property="loc" column="loc" />
</resultMap>
<select id="list" resultMap="deptResult">
select * from dept order by deptno
</select>
- Dept 테이블의 모든 데이터를 검색
- order by 로 부서번호 기준 오름차순 정렬되어서 돌려준다
- 현재는 Dept DTO 클래스 프로퍼티명과 검색되는 컬럼명인 Dept 테이블의 컬럼명이 일치하므로 resultMap 을 사용하지 않아도 된다, 사용은 하고 있음
+ 엄밀히 말하면 구현클래스가 주입되는 것이지만, 어차피 업캐스팅 하므로 그냥 DeptService 객체, EmpService 객체가 됨
+ 그래서 하나의 인터페이스에 구현클래스를 2개를 만들면 안된다
- 2개의 Service 객체를 주입받음
Controller 클래스 EmpController.java 에서 "empAllList.do" 요청 부분만
// 전체 직원 목록
@RequestMapping("empAllList.do")
public String empAllList(Model model) {
List<Emp> list = es.empAllList();
model.addAttribute("list", list);
return "emp/empAllList";
}
- 위에서 주입받은 EmpService 객체 es 를 사용해서 Service 클래스 메소드인 empAllList() 호출
- 2개 이상의 데이터를 검색하므로 리스트로 값이 돌아올 것이므로 List 로 받음
<돌아올 때>
- 돌아온 List 에는 Emp DAO 객체들이 들어있다
- prefix 로 잡혀있는 경로까지는 생략하고, 그 하위의 경로는 적어야한다
- /WEB-INF/views 는 생략하고, 하위의 emp 폴더는 적어야함, 그래서 "emp/empAllList" 이다
- /WEB-INF/views/emp/empAllList.jsp 파일로 이동
Service 클래스 EmpServiceImpl.java 에서 empAllList() 메소드 부분만 + @Autowired 부분
@Autowired
private EmpDao ed;
public List<Emp> empAllList() {
return ed.empAllList();
}
- 위에서 @Autowired 로 주입받은 EmpDao 객체 ed 를 사용해서 DAO 클래스의 메소드인 empAllList() 호출
DAO 클래스 EmpDaoImpl.java 에서 empAllList() 메소드 부분만+ @Autowired 부분
@Autowired
private SqlSessionTemplate sst;
public List<Emp> empAllList() {
return sst.selectList("empAllList");
}
- 위에서 @Autowired 로 주입받은SqlSEssionTemplate 객체 sst 를 사용해서 지원메소드인 selectList() 사용
- 2개 이상의 데이터를 검색하므로 selectList() 메소드 사용
- 반환되는 List 에 들어가는 것은 Emp DTO 객체만 들어간다는 의미로 제네릭 <Emp> 사용
Mapper 파일 Emp.xml 에서 id 가 "empAllList" 인 태그 부분만 + resultMap
<!-- Use type aliases to avoid typing the full classname every time. -->
<resultMap id="empResult" type="emp">
<result property="empno" column="empno" />
<result property="ename" column="ename" />
<result property="job" column="job" />
<result property="mgr" column="mgr" />
<result property="hiredate" column="hiredate" />
<result property="sal" column="sal" />
<result property="comm" column="comm" />
<result property="deptno" column="deptno" />
<result property="dname" column="dname" />
<result property="loc" column="loc" />
</resultMap>
+ 현재는 모든 10개의 테이블과 검색결과의 컬럼명이 일치하므로 일일히 resultMap 을 사용할 필요 없다, 여기선 resultMap 을 사용했음
- Emp DTO 가 저장된 리스트를 리턴하므로, type 을 "emp" 로 설정함
<select id="empAllList" resultMap="empResult">
select e.*,dname,loc from emp e, dept d
where e.deptno=d.deptno order by empno
</select>
- from 절에서 emp 테이블의 별칭을 e, dept 테이블의 별칭을 d 로 설정
- 등가조인(과거부터 사용하던 방식, 안시 방식 등이 있다) 을 사용하고 있음
- e 의 모든 컬럼과 dname, loc 를 검색
+ 공통 컬럼이 아닌 경우는 dname, loc 처럼 그냥 쓰면 된다
- 등가 조인을 위해 e.deptno 와 d.deptno 가 같은 경우만 가져옴
+ 두 테이블 사이 공통적인 컬럼이 있을때만 가능한게 등가조인
- 사원번호 순서대로 정렬, 사원번호가 빠른(작은) 순대로 나온다
- Emp DTO 는 10개의 정보를 저장하므로 검색결과를 모두 저장할 수 있으므로 resultMap 을 쓰지 않고 resultType 에 "emp" 를 써도 된다
- 객체 dept 가 Model 에 저장되었으므로 View 에서는 ${dept.필드명} 으로 가져온다
- 부서 정보 수정폼에 수정할 정보를 입력하고 "확인" 을 누르면 "deptUpdate.do" 로 요청한다
- 부서코드는 수정할 수 없다, 수정할 수 있는 정보는 부서명과 근무지이다.
+ 현재 부서코드는 입력양식이 아니라 출력만 하고 있으므로 넘어가지 않음, 그래서 hidden 객체 사용
- 부서코드 또한 수정시에 전달해야하므로 hiddden 객체를 통해 "deptUpdate.do" 로 전달
프로젝트 myBatis2 : 부서 정보 수정
- 부서 정보 수정폼 deptUpdateForm.jsp 에 수정할 정보를 입력하고 "확인" 을 누르면 "deptUpdate.do" 로 요청한다
Controller 클래스 DeptController.java 에서 "deptUpdate.do" 요청 부분만
// 부서 정보 수정
@RequestMapping("deptUpdate.do")
public String deptUpdate(Dept dept, Model model) {
int result = ds.update(dept);
model.addAttribute("result", result);
return "deptUpdate";
}
- 앞에서 폼을 통해 넘어온 입력값들을 한번에 @ModelAttribuate (생략) 을 통해 Dept DTO 객체 dept 에 세팅한다
- Service 클래스의 객체 ds 를 사용해서 Service 의 update() 메소드 호출, 호출 시 수정할 정보를 저장한 객체 dept 를 전달
<돌아온 후>
- 수정이 성공적으로 완료되면 update() 에서 1 을 받게 되고, 그걸 result 변수에 저장
- 그 result 변수를 Model 에 저장하고 deptUpdate.jsp 로 이동
Service 클래스 DeptServiceImpl.java 에서 update() 메소드 부분만
public int update(Dept dept) {
return dd.update(dept);
}
DAO 클래스 DeptDaoImpl.java 에서 update() 메소드 부분만
public int update(Dept dept) {
return st.update("deptns.update", dept);
}
- update() 수행 후 DB 에서 수정을 성공하면, update() 는 1 을 자동으로 리턴한다 (수정한 데이터 개수)
- Mapper 파일의 SQL문을 가져오는 것이고, 실제 SQL문의 실행은 여기 DAO의 update() 문이 실행한다
- 그 1 을 다시 Service 로 리턴함
Mapper 파일 Dept.xml 에서 id 가 "update" 인 태그 부분만
<update id="update" parameterType="dept">
update dept set dname=#{dname},loc=#{loc} where deptno=#{deptno}
</update>
- "삭제" 를 누르면 "deptDelete.do" 로 요청한다, 그때 부서 코드인 deptno 를 GET 방식으로 전달한다
삭제시 주의
- Emp 테이블과 Dept 테이블은 참조관계가 있다
- 현재 내가 입력한 50번 부서는 참조하는 Foreign Key 가 없으므로 부서 삭제가 된다
- 10,20,30 번 부서는 참조하는 Foreign Key 가 있으므로 삭제되지 않는다
- 10,20,30 번 부서는 사원 테이블 Emp 에서 참조한다
+ 40번 부서는 원래 참조하는 사원이 없으므로 삭제 된다
- 20 번 부서 삭제 시도시
Controller 클래스 DeptController.java 에서 "deptDelete.do" 요청 부분만
// 부서 삭제
@RequestMapping("deptDelete.do")
public String deptDelete(int deptno, Model model) {
int result = ds.delete(deptno);
model.addAttribute("result", result);
return "deptDelete";
}
- 앞에서 넘어온 네임값과 이름이 같은 변수 deptno 에 앞에서 넘어온 부서코드가 바로 저장됨
- @RequestParam("deptno") 가 int deptno 앞에 생략되어있다
<돌아온 후>
- 삭제가 성공적으로 완료되었다면 delete() 메소드는 1 을 리턴함, 그 값을 result 변수에 저장
- result 변수를 Model 객체에 저장하고 deptDelete.jsp 로 이동
Service 클래스 DeptServiceImpl.java 에서 delete() 메소드 부분만
public int delete(int deptno) {
return dd.delete(deptno);
}
DAO 클래스 DeptDaoImpl.java 에서 delete() 메소드 부분만
public int delete(int deptno) {
return st.delete("deptns.delete", deptno);
}
- delete() 수행 후 DB 에서 수정을 성공하면, delete() 는 1 을 자동으로 리턴한다 삭제한 데이터 개수)
- Mapper 파일의 SQL문을 가져오는 것이고, 실제 SQL문의 실행은 여기 DAO의 delete() 문이 실행한다
- 그 1 을 다시 Service 로 리턴함
Mapper 파일 Dept.xml 에서 id 가 "delete" 인 태그 부분만
<delete id="delete" parameterType="int">
delete from dept where deptno=#{deptno}
</delete>
- 그럼 중복일떄는 "이미 있는 데이터입니다", 중복이 아닐때는 "사용 가능한 사번입니다" 출력
프로젝트 myBatis2 : 사원 등록
- 사원 입력폼 empInsertForm.jsp 에서 입력을 한 후 "확인" 을 누르면 "empInsert.do" 로 요청한다
Controller 클래스 EmpController.java 에서 "empInsert.do" 요청 부분만
// 사원 등록
@RequestMapping("empInsert.do")
// public String empInsert(Emp emp, String hiredate1, Model model) {
public String empInsert(Emp emp, Model model) {
// emp.setHiredate(Date.valueOf(hiredate1)); // String -> Date 형변환
int result = es.insert(emp);
model.addAttribute("result", result);
model.addAttribute("deptno", emp.getDeptno());
return "emp/empInsert";
}
- 이전의 사원 등록폼에서 넘어온 값들을 한번에 @ModelAttribute (생략) 을 통해 DTO Emp 객체 emp 에 세팅
- Service 클래스의 insert() 메소드 호출, 호출하며 사원 등록폼에서 넘어온 값을 저장하는 객체 emp 를 넘겨줌
<돌아온 후>
- insert() 가 호출되어 삽입 성공하면 1 을 반환한다, result 에 그 값을 저장하고 Model 객체에 result 를 저장
- View 인 empInsert.jsp 에서는 삽입 성공시에, 그 사원의 부서 소속 모든 사원을 출력하는 부서 상세페이지로 이동할 것임
- 그러므로 삽입된 사원의 부서번호인 deptno 또한 가져가야한다, Model 객체에 저장
- /WEB-INF/views/emp/empInsert.jsp 로 이동
Service 클래스 EmpServiceImpl.java 에서 insert() 메소드 부분만
public int insert(Emp emp) {
return ed.insert(emp);
}
DAO클래스 EmpDaoImpl.java 에서 insert() 메소드 부분만
public int insert(Emp emp) {
return sst.insert("empns.insert", emp);
}
Mapper 파일 Emp.xml 에서 id 가 "insert" 인 태그 부분만
<insert id="insert" parameterType="emp">
insert into emp values(#{empno},#{ename},#{job},#{mgr},
#{hiredate},#{sal},#{comm},#{deptno})
</insert>
- 객체 emp 를 통해 넘어온 값들을 사용해서 insert 를 해준다
- #{empno} 는 emp.getEmpno() 와 같은 의미
- 입사일(hiredate) 은 캘린더에서 선택한 값이었지만, 객체 emp 에서 입사일은 Date 형으로 저장되어 있다
- 앞에서 넘어온 name 값과 매개변수 변수명이 같으면 @RequestParam 을 생략해도 된다
- 형변환할 필요 없이 @RequestParam 뒤에 쓰는 자료형에 자동 형변환 된다
ex) 여기선 String 형으로 자동형변환되어 저장됨
@ModelAttribute 어노테이션
- 한꺼번에 값을 받아서 @ModelAttribute 뒤에서 선언된 매개변수인 DTO 객체에 저장해준다
- 다만, DTO 객체의 필드명과 입력양식의 name 값들이 일치할때만 가능하다!
- 그땐 @ModelAttribute 생략도 가능하다
@Autowired
- @inject 어노테이션과 같은 역할
- 이걸 필요한 객체이자 프로퍼티 위에 쓰면 자동으로 객체 생성 및 주입까지 완료된다
- 객체 생성 및 주입 시점 : web.xml 에서 servlet-context.xml 을 불러올떄 모두 완료됨
+ servlet-context.xml 안에서 base-package 를 설정함
업로드 기능
- Spring 에선 fileupload 라이브러리를 많이 써서 첨부파일 업로드를 한다
cos 라이브러리 vs fileupload 라이브러리
cos 라이브러리
- 중복 문제를 자동으로 해결해준다
- 업로드 시켜주는 코드가 따로 없다
- 객체를 생성하면 업로드 된다
fileupload 라이브러리
- 중복 문제를 개발자가 해결해야한다
- 업로드 하는 코드가 따로 있다
ViewResolver
- servlet-context.xml 부분
<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
- servlet-context.xml 안에서 View 파일들의 위치를 설정함
- 여기선 /WEB-INF/views/ 폴더로 지정
- View 파일들이 저장될 최상위 디렉토리를 정의
Spring Web Application 예제 2 (이어서)
프로젝트 ch07
파일 설명
- LoginCheck.java : Intercepter Class (구현 클래스)
- UploadController.java : Controller Class
인터셉터 (Interceptor)
- 각 페이지마다 세션이 있는지 확인하고 로그인폼으로 보내는 대신 인터셉터를 사용한다
- 어떤 이름으로 요청이 들어올때만 DispatcherServlet 에서Controller 로 가기 전에 해당 요청을 가로챈다
- 주로 로그인 해야만 쓸 수 있는 기능에 대해 (정보수정, 회원탈퇴, 로그아웃) 매핑을 잡아서 세션이 있는지 확인하기 위해 인터셉터 사용
인터셉터 설정
- servlet-context.xml 부분
1. 인터셉터 클래스로 bean 을 하나 만든다
2. 인터셉터 클래스가 어떤 경우에 동작할지 매핑을 아래에서 수행한다
3. "/upload.do" 로 요청할때 인터셉터를 동작시키고, 위에서 만든 bean 의 id 값과 연결시켜줌
- 주로 로그인 해야만 쓸 수 있는 기능에 대해 (정보수정, 회원탈퇴, 로그아웃) 매핑을 잡아서 세션이 있는지 확인하기 위해 인터셉터 사용
인터셉터 구현 방법
1. abstract class HandlerInterceptorAdapter 클래스를 상속 받아서 구현
- 3개의 메소드 중 필요한 메소드만 오버라이딩
2. interface HandlerInterceptor 인터페이스를 상속 받아서 구현
- 인터페이스를 상속받았을때는 3개의 메소드를 모두 메소드 오버라이딩 해야한다
- 다음으로 3개의 메소드를 오버라이딩해서 원하는 기능을 작성
- boolean preHandle()
- void postHandle()
- void afterCompletion()
- 메소드 오버라이딩 했으므로 이름과 형식을 그대로 따라야함
인터셉터 메소드 호출 시점
- preHandle() 메소드 : Client 가 요청했을때 DispatcherServlet -> Controller 로 가기전에 호출됨
ex) 여기서는 preHandle() 안에, 세션이 있는지 확인하고 없다면 로그인폼으로 보내는 코드를 작성
- postHandle() 메소드 : Controller 에서 돌아가려고 Dispatcher 로 갈때 호출됨
- afterCompletion() 메소드 : 완전히 View 페이지에 간 후에 호출됨
- LoginCheck.java
package com.ch.ch07;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class LoginCheck implements HandlerInterceptor {
// DispatcherServlet의 화면 처리가 완료된 상태에서 처리
public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
}
// 지정된 컨트롤러의 동작 이후에 처리, Spring MVC의 Front Controller인 DispatcherServlet의 화면 처리가 완료된 상태에서 처리
public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
throws Exception {
}
// 지정된 컨트롤러의 동작 이전에 가로채는 역할 (세션이 없으면, 로그인 폼으로 이동 하도록 해준다 )
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object arg2) throws Exception {
HttpSession session = request.getSession();
if (session.getAttribute("id") == null) { // 세션이 없으면
response.sendRedirect("loginForm.do"); // loginform 으로 이동
return false;
}
return true;
}
}
- preHandle() 메소드 안에서 세션 객체를 구한다
- 세션에 id 값이 있는지 확인 후 없다면 비정상 요청으로 판단해 loginForm.do 로 요청, 그 후 return false 하면 메소드를 빠져나감
- 세션값이 있다면 return true 를 통해, 정상적으로 원래 가던 Controller 클래스로 간다
- 로그인 해야만 쓸 수 있는 기능에 대해 (정보수정, 회원탈퇴, 로그아웃) 매핑을 잡아서 세션이 있는지 확인하기 위해 인터셉터 사용
인터셉터 활용
- index.jsp 를 실행하면 "upload.do" 로 요청
- Controller 클래스로 가기 전에 인터셉터가 가로챔
- 세션이 없으므로 loginForm.do 로 요청해서 loginform.jsp 로 이동한다
- 그래서 index.jsp 실행시 로그인 폼으로 가게 되는 것이다
"upload.do" 요청이 들어왔을때 가는 곳
- 같은 이름값 요청이지만 가는 곳이 다르다
- UploadController.java 부분
- 요청이름값이 같더라도 인터셉터 영향 또는 어떤 방식(GET/POST) 으로 요청되었는지에 따라 다른 내용이 실행된다
1) index.jsp 에서 "upload.do" 요청시 인터셉터가 잡아서 upload.jsp 가 아닌 loginform.jsp 로 간다
2) 로그인 성공 후 '업로드' 를 눌러 "upload.do" 요청시, 세션이 있으므로 인터셉터가 잡지못하고 Controller 클래스에 온다, 그 후 위의 @RequestMapping 에 의해 uploadForm() 을 실행하고 upload.jsp 로 가게된다
3) upload.jsp 에서 파일을 선택 후 '확인' 하면 "upload.do" 요청이 되고, 세션이 있으므로 인터셉터가 잡지 못하고 Controller 클래스에 온다, 그 후 아래의 @RequestMapping 에 의해 upload() 를 실행하고 uploadResult.jsp 로 가게 된다
틀린 비밀번호 입력시
1. loginForm.jsp 에서 비밀번호 입력하고 '확인'을 누르면 "login.do" 로 요청된다
2. Controller 에서 Model 객체에 "msg" 값을 저장하고, loginForm.jsp 로 이동한다
+ Controller 클래스에서는 로그인폼에서 온 입력값을 @RequestParam 으로 바로 매개변수에 저장
3. 다시 loginForm.jsp 로 이동했을때는 아래의 if 태그를 만족해서 msg 인 "똑바로 입력해" 를 출력
- 즉 한번 Controller 클래스로 갔다와야 msg 가 있으므로 msg 를 출력한다
- 처음 index.jsp 를 실행해서 loginForm.jsp 로 왔을때는 이 msg 가 없으므로 출력되지 않음
맞는 비밀번호 입력시
1. loginForm.jsp 에서 비밀번호 입력하고 '확인'을 누르면 "login.do" 로 요청된다
2. Controller 에서 id 값을 세션영역 공유설정하고, loginSuccess.jsp 로 간다
- 여기서부터 세션 영역이 시작된다
+ 매개변수에 Session 객체를 적기만 하면 자동으로 Session 객체가 구해진다, Spring 에선 getSession() 을 쓸 필요 없다
- static 으로 블럭을 만들어서 공유함, Model 1, Model 2 에서 했었던 getSession() 메소드 부분에 해당
- MyBatis 의 환경설정 파일 configuration.xml 을 읽어와서 Reader 객체 reader 생성
- reader 객체를 통해 SqlSessionFactory 객체 ssf 를 구함
- ssf.openSession(true) 를 통해 SqlSession 객체 session 을 구해옴
- openSession() 안에 true 가 들어가면 자동으로 커밋이 수행됨
DeptDaoImpl.java 에서 list() 부분만
public List<Dept> list() {
return session.selectList("deptns.list");
}
- 리스트를 구해오기 위해서는 2개이상의 데이터에 대한 상세정보를 구해와야한다, 그래서 selectList() 를 사용
+ selecList() 의 리턴자료형은 List 이다
- deptns 는 Mapper 파일 Dept.xml 안에 설정된 namespace 를 의미, list 는 id 를 의미
- Mapper 파일인 Dept.xml 에서 id 가 list 인 SQL문을 불러오라는 의미
- 이후 Mapper 파일 에서 돌아오면 그 리스트를 그대로 Service 클래스로 리턴한다
Mapper 파일
- Mapper 파일 Dept.xml 로 넘어가보자
- Dept.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="deptns">
<!-- Use type aliases to avoid typing the full classname every time. -->
<resultMap id="deptResult" type="dept">
<result property="deptno" column="deptno" />
<result property="dname" column="dname" />
<result property="loc" column="loc" />
</resultMap>
<select id="list" resultMap="deptResult">
select * from dept order by deptno
</select>
<select id="select" parameterType="int" resultType="dept">
select * from dept where deptno=#{deptno}
</select>
<update id="update" parameterType="dept">
update dept set dname=#{dname},loc=#{loc} where deptno=#{deptno}
</update>
<delete id="delete" parameterType="int">
delete from dept where deptno=#{deptno}
</delete>
</mapper>
- namespace 가 "deptns"
Dept.xml 에서 id 가 "list" 인 태그 부분만 + resultMap
<!-- Use type aliases to avoid typing the full classname every time. -->
<resultMap id="deptResult" type="dept">
<result property="deptno" column="deptno" />
<result property="dname" column="dname" />
<result property="loc" column="loc" />
</resultMap>
<select id="list" resultMap="deptResult">
select * from dept order by deptno
</select>
- resultType 대신 resultMap 을 쓰고 있다
- resultMap 태그의 id 값으로는 아래의 select 태그에서 resultMap 속성에 쓴 "deptResult" 를 써야함
- resultMap 태그의 type 값으로 DTO alias 인 "dept" 가 들어가야함
- 즉 자동으로 DTO 객체에 세팅해서 돌려주는 resultType 대신 resultMap 으로 일일히 매핑하고 있다
- Dept 테이블 컬럼명과 DTO 프로퍼티명이 다를때 resultMap 을 사용해야한다
- 현재 Dept 테이블 컬럼명과 DTO 인 Dept 클래스 프로퍼티 명이 같으므로 resultMap 안써도 된다
+ join 을 해야할 경우 등 resultMap 을 써야만 하는 경우도 있다
- 아래의 select SQL문을 실행하고, 그 검색결과를 매핑을 통해 여러개의 DTO 객체에 세팅 하고, 그 DTO 객체들을 List 에 담고 그 List 를 DAO 로 돌려줌
- 다시 DAO 로 돌아가야하므로 위로 돌아가자
* 돌아올때 설명은 하늘색 하이라이트
- Contorller 까지 돌아간 후 Dispatcher Servlet -> View 로 가게 된다
- Model 객체에 저장된 값이 DTO 객체이므로 ${네임값.필드명} 으로 출력한다, 여기선 ${dept.필드명} 으로 출력
- 입력양식의 value 속성으로 수정폼에 값을 뿌린다
- 수정폼 입력양식에 값을 입력하고 '확인' 을 누르면 action 인 "deptUpdate.do" 로 요청한다
- 부서 코드는 입력양식이 아닌 출력을 하고 있으므로 넘어가지 않는다, 그래서 hidden 으로 전달해야한다
- 이 값을 전달해야만 where 조건절에 deptno 를 넣어서 1개 부서를 수정 가능하다
- "deptUpdate.do" 로 요청하면서 부서 코드인 deptno 를 hidden 객체로 전달한다
프로젝트 myBatis1 : 부서 정보 수정
- 수정폼 deptUpdateForm.jsp 의 입력양식에 값을 입력하고 '확인' 을 누르면 action 인 "deptUpdate.do" 로 요청한다
DeptController.java 에서 "deptUpdate.do" 요청 부분만
// 부서 정보 수정
@RequestMapping("deptUpdate.do")
public String deptUpdate(Dept dept, Model model) {
int result = ds.update(dept);
model.addAttribute("result", result);
return "deptUpdate";
}
- 수정폼 deptUpdateForm.jsp 에서 넘어온 값들을 DTO Dept 객체 dept 에 세팅(저장)해준다
- 즉 @ModelAttribute 어노테이션이 Dept dept 앞에 생략되어 있다
+ 넘어온 name 값과 DTO 프로퍼티명이 같은 이름인 경우에만 가능하다
- 위에서 @Autowired 로 주입한 Service 객체 ds 로 Service 클래스의 update() 메소드를 호출, 호출하며 사용자가 수정폼에 입력한 값들을 전달함
<돌아온 후>
- DB 수정을 성공하면 1 을 리턴할 것, 그 값을 result 변수에 저장한다
- 그 result 변수를 Model 객체에 저장 후, deptUpdate.jsp 로 간다
DeptServiceImpl.java 에서 update() 부분만
public int update(Dept dept) {
return dd.update(dept);
}
- 받은 객체를 그대로 다시 전달
<돌아올때>
- 성공시 받은 1 을 다시 리턴
DeptDaoImpl.java 에서 update() 부분만
public int update(Dept dept) {
return session.update("deptns.update",dept);
}
- 받은 객체를 그대로 다시 전달
<돌아올 때>
- 이 update() 메소드는 DB 수정 성공시 1을 자동으로 리턴함
Mapper 파일 Dept.xml 에서 id 가 "update" 인 태그 부분만
<update id="update" parameterType="dept">
update dept set dname=#{dname},loc=#{loc} where deptno=#{deptno}
</update>
- "deptDelete.do" 요청시 Controller 클래스로 가면서 get 방식으로 부서 코드 deptno 를 가져간다
- 부서코드를 가져가야 delet SQL문 실행시 where 절에 부서 코드를 넣어서 해당 부서를 삭제할 수 있다
DeptController.java 에서 "deltDelete.do" 요청 부분만
// 부서 정보 삭제
@RequestMapping("deptDelete.do")
public String deptDelete(int deptno, Model model) {
int result = ds.delete(deptno);
model.addAttribute("result", result);
return "deptDelete";
}
- 넘어온 부서코드가 저장된 변수명과 같은 이름인 deptno 를 매개변수에 써서 바로 deptno 에 넘어온 부서코드 저장
+ @RequestParam("deptno") 가 int deptno 앞에 생략
- Service 객체 ds 를 통해 Service 클래스의 delete() 메소드를 호출함, 호출하면서 부서코드 deptno 를 전달
<돌아올 때>
- 성공여부를 확인하기 위해 result 변수로 delete() 의 리턴값을 받는다
- 그 result 를 Model 객체에 저장하고 deptDelete.jsp 로 간다
DeptServiceImpl.java 에서 delete() 부분만
public int delete(int deptno) {
return dd.delete(deptno);
}
DeptDaoImpl.java 에서 delete() 부분만
public int delete(int deptno) {
return session.delete("deptns.delete",deptno);
}
- Mapper 파일에서 id 가 "delete" 인 SQL문을 불러온다
- 전달하는 값은 부서 코드인 deptno
Mapper 파일 Dept.xml 에서 id 가 delete 인 태그 부분만
<delete id="delete" parameterType="int">
delete from dept where deptno=#{deptno}
</delete>
- #{deptno} 로 가져옴
문제점
- '삭제' 누르면 오류 발생, 무결성 제약조건때문에 오류가 발생한다
- 즉, 해당 부서(부모)를 참조하는 Foreign Key (자식) 이 있으므로7 삭제가 되지 않는다
문제 해결
- SQL문에서 On Delete Cascade 를 사용해서 부모를 지울때 참조하는 자식까지 같이 지운다
- VehicleImpl 클래스로 bean 객체를 생성하고 프로퍼티 name, rider, out 에 Setter 메소드로 값 초기화 (= Setter DI)
- VehicleImple 객체 vh 의 프로퍼티 name 에 "대박이", rider 에 "비행기", out 에 아래에서 생성한 두번째 객체인 FileOutputter 객체 out 을 주입
- 프로퍼티 out 의 자료형은 Outputer 인터페이스, 주입되는 값은 FileOutputter 객체, 즉 업캐스팅
ex) Outputer out = new FileOutputter() 와 같다
- 위에서 이렇게 out 객체를 프로퍼티 out 에 주입해야만 VehicleImpl 객체 vh 에서 VehicleImpl 클래스의 오버라이딩된 메소드 rider() 를 호출하면서, 그 rider() 메소드 안에서 프로퍼티이자 FileOutputter 로 만든 객체 out 으로 오버라이딩 된 메소드 output() 호출 가능
Ex01.java 에서 VehicleImpl 로 만든 객체 vh 로 메소드 오버라이딩된 rider() 호출VehicleImpl.java 에서 rider() 를 메소드 오버라이딩 하는 코드
- 객체 bs 를 생성하고, 자료형이 BookDao 인 프로퍼티 bd 에 값을 Setter DI 로 할당하는데, 이때 위에서 생성된 BookDaoImpl 객체 bd 를 할당함
- 프로퍼티 자료형은 인터페이스 BookDao , 주입되는 값은 구현클래스 BookDaoImpl, 즉 업캐스팅으로 주입
- BookServiceImpl.java
package sample12.service;
import sample12.dao.BookDao;
import sample12.model.Book;
public class BookSericeImpl implements BookService {
private BookDao bd;
// BookDao bd = new BookDaoImpl()
public void setBd(BookDao bd) {
this.bd = bd;
}
public Book getBook() {
return bd.getBook("대박인생");
}
}
- main() 에서 beans12.xml 을 불러올때 이미 메모리에 BookServiceImpl 객체 생성되고, 프로퍼티 bd 에도 값이 주입되었음, DAO 의 클래스 사용 가능해졌다
- main() 에서 Service 의 getBook() 을 호출했다, 여기서는 DAO 로 가기위해 DAO 객체 bd 로 bd.getBook("대박인생") 호출
- BookDaoImpl.java
package sample12.dao;
import sample12.model.Book;
public class BookDaoImpl implements BookDao {
public Book getBook(String title) { // title="대박인생"
return new Book(title, 20000);
}
}
- Service 클래스에서 이 DAO 의 getBook() 을 호출했다, "대박인생" 이 매개변수로 넘어옴
- 여기서 DTO 객체를 생성하고, DTO 객체 프로퍼티 title 에 "대박인생" , price에 20000 을 저장해서 돌려줌
Book.java (DTO)
package sample12.model;
public class Book {
private String title;
private int price;
public Book(String title, int price) {
this.title = title; // title="대박인생"
this.price = price; // price=20000
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String toString() {
return "책[제목:" + title + ", 가격:" + price + "]";
}
}
+ 값을 리턴할때, 전달할때 DTO 객체 생성
- Object toString() 을 오버라이딩해서 저장된 값들을 한꺼번에 돌려주려한다
- toString() 은 DTO 객체가 리턴될때 자동으로 실행됨, 실행되면 값들을 리턴해줌
- 이제 DAO -> Service 로 돌아가야한다
- BookServiceImpl.java (중복)
package sample12.service;
import sample12.dao.BookDao;
import sample12.model.Book;
public class BookSericeImpl implements BookService {
private BookDao bd;
// BookDao bd = new BookDaoImpl()
public void setBd(BookDao bd) {
this.bd = bd;
}
public Book getBook() {
return bd.getBook("대박인생");
}
}
- 돌려받은 값을 그대로 main() 으로 리턴함
- Ex01.java (중복)
package sample12;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import sample12.model.Book;
import sample12.service.BookService;
public class Ex01 {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("/sample12/beans12.xml");
BookService bs = (BookService) ac.getBean("bs");
Book book = bs.getBook();
System.out.println(book);
}
}
- Service 의 getBook() 으로부터 결과를 바당옴
<toString()> - toString() 은 DTO 객체가 리턴될때 자동으로 실행됨, 그래서 객체 book 을 출력해도 book.toString() 과 같은 결과가 나옴
+ 만약 DTO 객체에 toString() 을 오버라이딩하지 않았으면, System.out.println(book) 할때 주소값이 나옴
- DTO 의 getter 메소드로 개별적인 값을 불러올 수도 있다
어노테이션을 이용한 DI
- 어노테이션 기반으로 처리시 Spring 환경설정 파일에 bean 객체 생성하지 않음
- Sample13 예제를 본격적으로 하기전에 Simple13 을 간략하게 보면서 어노테이션을 이용한 DI 가 뭔지 보자
- beans13.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<!--
1. sample13 패키지 하위 클래스를 스캔한다는 의미를 가진다.
2. @Component, @Controller, @Service, @Repository 어노테이션이
붙어있는 클래스는 @Autowired 어노테이션을 이용해서 필요한 빈 객체를
setter 메소드 없이 주입을 받는다.
-->
<context:component-scan base-package="sample13"/>
</beans>
- bean 을 더이상 만들고 있지 않고 단 한줄만 있다, 이게 어노테이션 기반
- base-package 는 베이스가 되는, 기본이 되는 패키지를 의미함
- 저 한줄은 sample13 패키지 하위의 모든 클래스를 모두 읽어오라는 의미
- 지정된 패키지 sample13 하위의 클래스들에는 클래스명 위에 4가지 어노테이션 중 하나가 붙어있어야함
- @Component, @Controller, @Service, @Repository
어노테이션 4가지
- @Component : 아무 클래스에나 붙일 수 있는 어노테이션
- @Controller : 컨트롤러 클래스 위에 붙이는 어노테이션
- @Service : Service 클래스 위에 붙이는 어노테이션
- @Repository : Repository 클래스 위에 붙이는 어노테이션
- 클래스명 위에 이 4개의 어노테이션 중 한가지만 붙어있어도 된다
- sample13 에서는 모두 @Component 를 붙이지만, 나중엔 클래스에 맞는 어노테이션을 붙인다
ex) Service 클래스 위에 @Service 어노테이션
- 이후 Setter 메소드가 없어도 생성이 필요한 객체 위해 @Autowired 어노테이션을 붙이면 main() 에서 beans13.xml을 읽어올때 필요한 bean 객체가 생성 및 주입됨
필요한 bean 객체를 주입하기 위한 조건
1. base-package 에 적힌 해당 패키지의 모든 클래스를 읽어오는 코드가 있어야함
2. 어노테이션 4개 중 하나 붙어있어야함
3. 만들고자 하는 객체 위에 @Autowired 어노테이션을 붙여야함
ex) Service -> DAO 로 갈때
- Service 에서 DAO 객체를 구해와야하는데, 이때 Setter 메소드 필요없고, bean 객체를 직접 생성하지 않아도 된다
- 자동으로 DAO bean 객체를 생성해줌
- 조건에 맞는지 보자
1) base-package 에 sample13 패키지가 적혀있다
2) Service 클래스 위에 @Component 어노테이션이 붙어있다
3) 필요한 객체인 DAO 객체(Service의 프로퍼티) 위에 @Autowired 어노테이션이 붙어있다
- 조건이 맞으므로 Service 클래스에 Setter 메소드가 없어도 Service 클래스에 DAO 객체가 생성되어서 프로퍼티에 값(객체)이 주입됨, 이때 객체 생성 및 주입 시점은 main() 에서 beans13.xml 을 읽어왔을때이다.
- 즉 아래의 빨간선으로 표시한 내용이 자동으로 실행된다, 실행되는 시점은 main() 에서 beans13.xml 을 읽어왔을때
- sample11.xml 부분
+ 현재는 DAO 에서 DB 연동안하므로 DAO 에서 객체 생성하진 않음, 나중엔 SqlSession 객체를 생성
Spring DI 예제 13 (어노테이션 기반)
- src/main/java/sample13/ 안의 파일들
- 더이상 bean 을 만들지 않고, 어노테이션 기반으로 처리함
Spring DI 예제 13 구조 & 흐름
- Web Application 에서는 갈땐 Controller-> Service -> DAO, 올땐 DAO -> Service -> Controller
- 현재는 Web Application 이 아닌 Application 이므로 Controller 클래스는 없다, 그 역할을 메인메소드가 하고 있는거임
- 갈때 : main() -> Service -> dao , 돌아올땐 반대로 dao -> Service -> main() 으로 돌아오자
- Ex01.java : 메인메소드를 가진 클래스이다, Controller 클래스의 역할을 대신한다
- productDao.java : 인터페이스, 추상메소드 getProduct()
- ProductDaoImpl.java: productDao를 상속하는 구현클래스, 추상메소드 getProduct() 를 오버라이딩
- ProductService.java : 인터페이스, 추상메소드 getProduct()
- ProductServiceImpl.java : ProductService를 상속하는 구현클래스, 추상메소드 getProduct() 를 오버라이딩
- Prodjct.java : DTO 클래스, 값을 저장하고 돌려줄때 사용
어노테이션
- Service 구현 클래스와 DAO 구현 클래스에만 어노테이션이 붙어있다
- Service 구현 클래스, DAO 구현 클래스위에 @Component 어노테이션이 붙어있음
문제
- 흐름은 main() -> Service -> DAO -> Service -> main()
- Service -> DAO 로 갈때는 @Autowired 로 DAO 객체를 구해온다
- 그럼 main() -> Service 로 갈때는 bean 객체가 없는데 어떻게 getbean() 으로 Service 객체를 구해올까?
- Ex01.java
package sample13;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Ex01 {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("/sample13/beans13.xml");
ProductService ps = ac.getBean(ProductService.class);
Product product = ps.getProduct();
System.out.println(product);
}
}
- 먼저 beans13.xml 을 불러온다
- getBean() 안에 bena 이 없고, Service 클래스명을 직접 구해와야한다 (인터페이스명도 되고 구현클래스명도 됨)
- 이러면 Service 객체를 구해와서 ps 로 받고, Service 클래스 안의 메소드 getProduct() 를 호출
- ProductServiceImpl.java
package sample13;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ProductServiceImpl implements ProductService {
@Autowired
private ProductDao pd;
public Product getProduct() {
return pd.getProduct("짜장면");
}
}
- beans13.xml 을 main() 에서 불러올때 이미 DAO 객체 pd 에 주입이 되었다
- 여기 SetterPd() 메소드가 없어도 주입됨!
- 객체 pd 가 주입되어있으므로 pd.getProduct() 로 DAO 클래스의 getProduct("짜장면") 호출
- ProductDaoImpl.java
package sample13;
import org.springframework.stereotype.Component;
@Component
public class ProductDaoImpl implements ProductDao {
public Product getProduct(String name) {//name="짜장면"
return new Product(name, 2500);
}
}
- DTO 객체를 생성하고 매개변수로 넘어온 "짜장면", 2500 을 객체에 저장해서 그 객체를 리턴
- 다시 Service 로 돌아가야한다
- ProductServiceImpl.java (중복)
package sample13;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ProductServiceImpl implements ProductService {
@Autowired
private ProductDao pd;
public Product getProduct() {
return pd.getProduct("짜장면");
}
}
- 받은 DTO 객체를 그대로 main() 으로 돌려줌
- Ex01.java (중복)
package sample13;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Ex01 {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("/sample13/beans13.xml");
ProductService ps = ac.getBean(ProductService.class);
Product product = ps.getProduct();
System.out.println(product);
}
}
- DTO 객체를 돌려받음
- toString() 은 써도 안써도 자동 실행됨
나중에 할 예제의 흐름
- Controller 클래스에서 Service 객체를 생성할때 @Autowired 사용해서 생성
- Controller -> Service로 넘어가는 방법 = Service 객체 생성
Web Application 에서의 어노테이션
- 잠시 Web Application 인 springtest 프로젝트를 보자
어노테이션으로 Controller -> Service 로 가는 방법
- 조건에 맞는지 보자
1) servlet-context.xml 에서 base-package 를 설정하고 있다
- com.myhome.springtest 란 패키지 안의 모든 클래스를 읽어옴, 그 안에는 Controller 클래스인 HomeController.java
- Spring Project 생성시 입력헀던 top-level 패키지이다, 이 패키지 com.myhome.springtest 는 src/main/java 폴더 하위에 생성된다
2) HomeController 클래스 위에 @Controller 어노테이션이 있다
3) Controller 클래스 HomeController 클래스 안에서 Service 객체 생성이 필요한 곳에서 @Autowired 를 붙임
- 1,2,3 조건 3개를 모두 만족하므로 Controller 에서 Service 객체를 생성할때 자동으로 생성해서 Controller 클래스의 프로퍼티에 주입해준다
Spring 환경설정 파일과 어노테이션
- Web Application 에서 Spring 의 환경설정 파일 중 root-context.xml 은 어노테이션 뿐 아니라 기존 처럼 bean 태그로 객체 생성하는 방법도 사용한다
-Web Application 에서Spring 의 환경설정 파일 중servlet-context.xml 은 어노테이션 기반이다, base-package 가 지정되어있음,
Spring DI 예제 14 (어노테이션 기반, Sample13 과 비슷)
- src/main/java/sample14/ 안의 파일들
- 더이상 bean 을 만들지 않고, 어노테이션 기반으로 처리함
Spring DI 예제 14 구조 & 흐름
- Web Application 에서는 갈땐 Controller-> Service -> DAO, 올땐 DAO -> Service -> Controller
- 현재는 Web Application 이 아닌 Application 이므로 Controller 클래스는 없다, 그 역할을 메인메소드가 하고 있는거임
- 갈때 : main() -> Service -> dao , 돌아올땐 반대로 dao -> Service -> main() 으로 돌아오자
- Ex01.java : 메인메소드를 가진 클래스이다, Controller 클래스의 역할을 대신한다
- BookDao.java : 인터페이스, 추상메소드getBook()
- BookDaoImpl.java: BookDao를 상속하는 구현클래스, 추상메소드 getBook() 를 오버라이딩
- BookService.java : 인터페이스, 추상메소드 getBook()
- BookServiceImpl.java : BookService를 상속하는 구현클래스, 추상메소드 getBook() 를 오버라이딩
- Book.java : DTO 클래스, 값을 저장하고 돌려줄때 사용
예제 sample14 / sample15 의 흐름
- 현재는 Controller 클래스가 없으므로 main() 에서 그 역할을 한다
- main() 에서 Service 객체를 생성하는 것이 아니라 그냥 불러왔음
어노테이션
- Service 구현 클래스와 DAO 구현 클래스에만 어노테이션이 붙어있다
- Service 구현 클래스, DAO 구현 클래스위에 @Component 어노테이션이 붙어있음
package sample14;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class Ex01 {
public static void main(String[] args) {
ApplicationContext ac = new GenericXmlApplicationContext("/sample14/beans14.xml");
BookService bs = ac.getBean(BookService.class);
Book book = bs.getBook();
System.out.println(book);
}
}
- 지금은 Controller 클래스가 아니라 main 메소드이므로 어노테이션을 안쓰고 있음
- bean 을 만들지 않았으므로 Service 객체가 없다
- 그래서 getBean(BookService.class) 로 Service 클래스 객체를 구해온다
- BookSeviceImpl.java
package sample14;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bd;
public Book getBook() {
return bd.getBook("바람과 함께 사라지다");
}
}
- Service 클래스 위에 @Component 어노테이션
- DAO 객체를 @Autowired 로 프로퍼티 bd 에 주입
- DAO 객체를 구해왔으므로 DAO 의 getBook() 메소드 호출, 매개변수로 "바람과 함께 사라지다" 를 준다
- BookDaoImpl.java
package sample14;
import org.springframework.stereotype.Component;
@Component
public class BookDaoImpl implements BookDao {
public Book getBook(String title) {
return new Book(title, 25000);
}
}
- 이제 어노테이션 @Componet 대신 Service 클래스 위에 @Service, DAO 클래스 위에 @Repository
Spring DI 예제 15 구조 & 흐름
- Web Application 에서는 갈땐 Controller-> Service -> DAO, 올땐 DAO -> Service -> Controller
- 현재는 Web Application 이 아닌 Application 이므로 Controller 클래스는 없다, 그 역할을 메인메소드가 하고 있는거임
- 갈때 : main() -> Service -> dao , 돌아올땐 반대로 dao -> Service -> main() 으로 돌아오자
- Ex01.java : 메인메소드를 가진 클래스이다, Controller 클래스의 역할을 대신한다
- BookDao.java : 인터페이스, 추상메소드getBook()
-BookDaoImpl.java:BookDao를 상속하는 구현클래스, 추상메소드getBook() 를 오버라이딩
- BookService.java : 인터페이스, 추상메소드 getBook()
- BookServiceImpl.java :BookService를 상속하는 구현클래스, 추상메소드getBook() 를 오버라이딩
- Book.java : DTO 클래스, 값을 저장하고 돌려줄때 사용
어노테이션
- 이제 어노테이션 @Componet 대신 Service 클래스 위에 @Service, DAO 클래스 위에 @Repository
- 인터페이스 위에는 어노테이션 쓰지 않음, 구현 클래스 위에만 어노테이션 쓴다
클래스와 해당 어노테이션 관계
- Controller 클래스 위엔 @Controller
- DAO 클래스 위엔 @Repository
- Service 클래스 위엔 @Service
- @Component 로 해도 동작은 한다
예제 sample14 / sample15 의 흐름
- 현재는 Controller 클래스가 없으므로 main() 에서 그 역할을 한다
+ 나중에 Web Application 할때 할 예제의 흐름 (중복, 중요)
Controller -> Service 로 가는 법
- Controller 클래스에서 Service 객체를 생성할때 @Autowired 사용해서 생성
- Controller -> Service로 넘어가는 방법 = Service 객체 생성, 이때 주입할 프로퍼티 위에 @Autowired 를 써준다
1) servlet-context.xml 에서 top-level 패키지안의 모든 클래스 읽기, 즉 Conroller 클래스를 읽어옴
2) Controller 클래스에서 클래스명 위에 @Controller 붙이기
3) Service 객체를 생성해서 주입할 프로퍼티 위에 @Autowired 를 써준다
- 이 조건을 모두 만족시켜서 Controller 클래스에서 Service 클래스의 객체를 만들 수 있다
- Controlelr 클래스에 Setter 메소드가 없어도 만들고 주입 가능함
+ 지금 예제는 일반 Application 이므로 servlet-context.xml 에서 Controller 패키지를 읽어오는 작업을 하지도 않았고 Controller 패키지가 없으므로 main() 에서 Service 객체를 .class 로 불러와서 main() -> Service 로 이동
- Ex01.java
package sample15;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class Ex01 {
public static void main(String[] args) {
ApplicationContext ac = new GenericXmlApplicationContext("/sample15/beans15.xml");
BookService bs = ac.getBean(BookService.class);
Book book = bs.getBook();
System.out.println(book);
}
}
- beans15.xml 파일을 읽어온다
- beans15.xml 에 bean 태그로 객체를 생성하지 않았으므로 BookService.class (경로설정) 로 Service 클래스의 객체를 생성함
- 생성한 Service 객체로 Service 의 getBook() 메소드 호출
- beans15.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<!--
1. sample15 패키지 하위 클래스를 스캔한다는 의미를 가진다.
2. @Component, @Controller, @Service, @Repository 어노테이션이
붙어있는 클래스는 @Autowired 어노테이션을 이용해서 필요한 빈 객체를
setter 메소드 없이 주입을 받는다.
-->
<context:component-scan base-package="sample15"/>
</beans>
- BookServiceImpl.java
package sample15;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
/*@Component*/
@Service
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bd;
public Book getBook() {
return bd.getBook("바람과 함께 사라지다");
}
}
- Service 클래스 위에는 @Service 를 주로 붙인다
- @Autowired 를 프로퍼티 bd 위에 쓰면 생성된 DAO 객체를 bd 에 주입해줌
- 이때 이 Service 클래스안에 setBd() 인 Setter 메소드가 없어도 자동으로 주입해준다
- 이때 생성 및 주입은 main() 에서 beans15.xml 을 읽어왔을때 이미 했음
+ 조건 1,2,3 을 만족하므로 자동으로 생성, 주입이 가능한 것임 (base-package="sample15", @Service, @Autowired)
- BookDaoImpl.java
package sample15;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/*@Component*/
@Repository
public class BookDaoImpl implements BookDao {
public Book getBook(String title) {//title="바람과 함께 사라지다"
return new Book(title, 25000);
}
}
- DAO 클래스 위에는 @Repository 를 주로 붙인다
- 현재는 DAO 에서는 아무 객체도 생성하고 있지 않지만 나중에 SQL문 실행을 위해서 SqlSession 객체를 @Autowired 로 생성 및 주입해야함
- DTO 인 Book 객체를 만들어서 받은 "바람과 함께 사라지다" 와 25000 을 저장해서 객체를 돌려줌
+ Book.java (DTO) : Object 의 toString() 메소드를 오버라이딩 했다, DTO 리턴시 자동으로 실행됨
- 이제 다시 돌아가야한다
- BookServiceImpl.java : 받은 객체를 그대로 리턴한다
- Ex01.java : Service 클래스로부터 DTO 객체를 받아서 책제목과 가격을 리턴하는 toString() 을 실행
Sample 16 & Sample 17
- 콘솔로 만든 회원관리 프로그램
- 같은 내용이다
- Sample 16 은 bean 객체를 생성해서 만들고
- Sample 17 은 어노테이션 기반으로 만들었다
Spring DI 예제 16 (bean 객체 직접 생성, 회원관리 콘솔 프로그램)
- src/main/java/sample16/ 안의 파일들
- bean 을 직접 생성하여 만든 콘솔 회원관리 프로그램
Spring DI 예제 16 구조 & 흐름
- Web Application 에서는 갈땐 Controller-> Service -> DAO, 올땐 DAO -> Service -> Controller
- 현재는 Web Application 이 아닌 Application 이므로 Controller 클래스는 없다, 그 역할을 메인메소드가 하고 있는거임
- 갈때 : main() -> Service -> dao , 돌아올땐 반대로 dao -> Service -> main() 으로 돌아오자
- Ex01.java : 메인메소드를 가진 클래스이다, Controller 클래스의 역할을 대신한다, 명령어에 따라 회원정보 검색, 등록, 삭제, 수정 가능
- MemberService.java : 인터페이스, 추상메소드들이 많이 있다 ex) delete(), insert(), update(), select(), list()
- MemberServiceImpl.java : MemberService 를 상속, MemberService 의 추상메소드들을 모두 오버라이딩
- MemberDao.java : 인터페이스, 추상메소드들이 많이 있다 ex) delete(), insert(), update(), selectByEmail(), list()
- MemberDaoImpl.java : MemberDao를 상속, MemberDao 의 추상메소드들을 모두 오버라이딩
- Member.java : DTO, 필드 id,pass,email,name,reg_date 와 각각의 getter/setter 메소드, toString() 메소드
- RegisterMember.java : DTO, 필드 pass, confirmpass, name, email 와 각각의 getter/setter 메소드, passCheck() 메소드
- DTO 객체가 2개이다
- RegisterMember.java DTO 클래스는 가입할때만 사용된다
Service 클래스와 DAO 클래스의 메소드 명이 같은 게 많다
- 같게 설정해서 어느 메소드에서 어느 메소드를 호출할지 알기 쉽게 해둔 것이다
ex) Service의 delete() 메소드에서 DAO 의 delete() 메소드를 호출
인터페이스를 사용하는 이유
- 예전에는 통일성있는 클래스를 작성하기 위해 인터페이스를 사용
- 지금은 메소드가 많아서 그걸 관리하기 위해 인터페이스를 사용한다 (어떤 메소드가 있는지 색인처럼 확인 가능)
- 그리고 Service 객체 "ms" 의 프로퍼티 md 에 위에서 만들어진 DAO 객체 "md" 가 주입되었다
Service 클래스의 프로퍼티 md
- 이때 Service 클래스에는 Setter 메소드가 있어야만 함
- Ex01.java
package sample16;
import java.util.Collection;
import java.util.List;
import java.util.Scanner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Ex01 {
static MemberService ms = null;
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("/sample16/beans16.xml");
ms = (MemberService) ac.getBean("ms");
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("명령어를 입력하세요?");
String command = sc.nextLine();
if (command.equals("x")) {
System.out.println("프로그램 종료");
break;
//startsWith() 메소드는 캐릭터 라인이, 지정된 접두사로 시작 여부를 감지하는 데 사용
// public boolean startsWith(String prefix)
} else if (command.startsWith("new")) { // 입력한 문자가 new로 시작하면 true 리턴함
insert(command.split(" "));
continue;
} else if (command.startsWith("select")) {
select(command.split(" "));
continue;
} else if (command.equals("list")) {
list();
continue;
} else if (command.startsWith("delete")) {
delete(command.split(" "));
continue;
} else if (command.startsWith("update")) {
update(command.split(" "));
continue;
}
help();
}
sc.close();
}
public static void insert(String[] str) {
if (str.length != 5) {
help();
return;
}
RegisterMember rm = new RegisterMember();
rm.setEmail(str[1]);
rm.setName(str[2]);
rm.setPass(str[3]);
rm.setConfirmPass(str[4]);
if (!rm.passCheck()) {
System.out.println("똑바로 암호 입력해");
} else {
int result = ms.insert(rm);
if (result > 0)
System.out.println("입력 성공");
}
}
public static void select(String[] str) {
if (str.length != 2) {
help();
return;
}
Member member = ms.select(str[1]);
if (member != null)
System.out.println(member);
else
System.out.println("없는 데이터 입니다");
}
public static void list() {
Collection<Member> list = ms.list();
if (list != null) {
for (Member member : list) {
System.out.println(member);
}
}
}
public static void delete(String[] str) {
if (str.length != 2) {
help();
return;
}
int result = ms.delete(str[1]);
if (result > 0)
System.out.println("삭제 성공");
}
public static void update(String[] str) {
if (str.length != 5) {
help();
return;
}
RegisterMember rm = new RegisterMember();
rm.setPass(str[3]);
rm.setConfirmPass(str[4]);
rm.setEmail(str[1]);
rm.setName(str[2]);
if (!rm.passCheck()) {
System.out.println("똑바로 암호 입력해");
} else {
int result = ms.update(rm);
if (result > 0)
System.out.println("수정 성공");
}
}
public static void help() {
System.out.println("잘못 입력했습니다");
System.out.println("명령어 사용법:");
System.out.println("new 이메일 이름 암호 암호확인");
System.out.println("update 이메일 이름 암호 암호확인");
System.out.println("delete 이메일");
System.out.println("select 이메일");
System.out.println();
}
}
Service 객체 구하기 (Ex01.java 부분)
ms = (MemberService) ac.getBean("ms");
Scanner 객체 구하기(Ex01.java 부분)
Scanner sc = new Scanner(System.in);
- 키보드로 회원정보를 입력받거나 목록을 수정/삭제 하기 위해 Scanner 객체 생성
- While문 안에서 계속해서 입력을 받을 수 있도록 무한 루프가 돈다, x 입력시 빠져나감
While문 안 명령 한 줄 받기(Ex01.java 부분)
String command = sc.nextLine();
입력에 따라 분기(Ex01.java 부분)
if (command.equals("x")) {
System.out.println("프로그램 종료");
break;
//startsWith() 메소드는 캐릭터 라인이, 지정된 접두사로 시작 여부를 감지하는 데 사용
// public boolean startsWith(String prefix)
} else if (command.startsWith("new")) { // 입력한 문자가 new로 시작하면 true 리턴함
insert(command.split(" "));
continue;
} else if (command.startsWith("select")) {
select(command.split(" "));
continue;
} else if (command.equals("list")) {
list();
continue;
} else if (command.startsWith("delete")) {
delete(command.split(" "));
continue;
} else if (command.startsWith("update")) {
update(command.split(" "));
continue;
}
help();
- 이때의 입력은 이렇게 입력해야함 (아래)
public static void help() {
System.out.println("잘못 입력했습니다");
System.out.println("명령어 사용법:");
System.out.println("new 이메일 이름 암호 암호확인");
System.out.println("update 이메일 이름 암호 암호확인");
System.out.println("delete 이메일");
System.out.println("select 이메일");
System.out.println();
}
- 분기 문 중 "new" 로 시작한걸 보자
사용자가 new 를 입력했다면 (Ex01.java 부분)
} else if (command.startsWith("new")) { // 입력한 문자가 new로 시작하면 true 리턴함
insert(command.split(" "));
continue;
- startWith() 는 어떤 특정한 문자로 시작하는지 확인 가능하다
- command 가 "new" 로 시작하면 comand.startWith("new") 는 True 를 반환
- True 면 insert() 메소드가 실행됨, 이 메소드는 Ex01 의 main() 아래에 정의되어있다
- 매개변수로는 command.split(" ") 으로 자른 배열을 주고 있다 (split() 의 리턴값은 String 형 배열이다)
- "new lay99@g.com lay 1999 1999" 를 입력했다면 공백을 기준으로 잘라서 배열에 저장해서 insert() 매개변수 인자로 준다
- 이 배열을 insert() 호출시 전달
- Ex01.java 의 insert() (Ex01.java 부분)
- insert() 는 main() 바깥 아래에 있다
public static void insert(String[] str) {
if (str.length != 5) {
help();
return;
}
RegisterMember rm = new RegisterMember();
rm.setEmail(str[1]);
rm.setName(str[2]);
rm.setPass(str[3]);
rm.setConfirmPass(str[4]);
if (!rm.passCheck()) {
System.out.println("똑바로 암호 입력해");
} else {
int result = ms.insert(rm);
if (result > 0)
System.out.println("입력 성공");
}
}
1. 이때 형식이 맞는지를 먼저 확인한다, str.len 이 5개여야하므로 5개가 아니면 help() 호출 후 insert() 를 나간다
- insert() 를 나가서 main() 으로 돌아가서 continue 문에 의해 다시 while 문에 의해 입력을 받음
2. DTO RegisterMember 객체 rm을 생성해서 그 안에 이메일, 이름, 암호, 암호확인을 객체에 저장
3. RegisterMember 의 passCheck() 메소드로 암호와 암호확인이 일치한지 확인
- 불일치시 "똑바로 암호 입력해", 일치시 main() 에서 받아온 Service 객체 ms (전역변수임) 로 ms.insert() 호출
- ms.insert() 호출시 매개변수로 RegisterMember(DTO) 객체 rm 을 전달
- ms.insert() 에서 리턴된 값이 0 보다 크면 "입력 성공" 출력
- Service 클래스의 메소드를 호출했으므로 Service 로 넘어갔다
- MemberServiceImpl.java
package sample16;
import java.util.Collection;
import java.util.Date;
import java.util.List;
public class MemberServiceImpl implements MemberService {
private MemberDao md;
public void setMd(MemberDao md) {
this.md = md;
}
public int insert(RegisterMember rm) {
int result = 0;
Member member = md.selectByEmail(rm.getEmail()); //email주소로 1명의 정보를 구해옴
if (member == null) { // 동일한 email 주소가 없으면 회원가입함
member = new Member(rm.getPass(), rm.getEmail(), rm.getName(), new Date());
md.insert(member);
result = 1;
} else {
System.out.println("이미 데이터가 있습니다");
}
return result;
}
public Member select(String email) {
return md.selectByEmail(email);
}
public Collection<Member> list() {
return md.list();
}
public int delete(String email) {
int result = 0; // 데이터가 이미 있는지 확인
Member member = md.selectByEmail(email);
if (member != null) {
md.delete(email);
result = 1;
} else {
System.out.println("없는네 우찌 삭제하니");
}
return result;
}
public int update(RegisterMember rm) {
int result = 0; // 데이터가 이미 있는지 확인
Member member = md.selectByEmail(rm.getEmail());
if (member != null) {
member.setPass(rm.getPass()); // 비번과 이름 수정
member.setName(rm.getName());
md.update(member);
result = 1;
} else {
System.out.println("없는네 우찌 고치니 ? 헐");
}
return result;
}
}
- DAO 객체를 주입할 필드 md, Setter 메소드 setMd() 가 있다
- 이 필드 md 에는 이미 DAO 객체가 주입되었다 (main 에서 beans16.xml 을 읽었을때 주입되었음)
insert() 부분만 (MemberServiceImpl.java 부분)
public int insert(RegisterMember rm) {
int result = 0;
Member member = md.selectByEmail(rm.getEmail()); //email주소로 1명의 정보를 구해옴
if (member == null) { // 동일한 email 주소가 없으면 회원가입함
member = new Member(rm.getPass(), rm.getEmail(), rm.getName(), new Date());
md.insert(member);
result = 1;
} else {
System.out.println("이미 데이터가 있습니다");
}
return result;
}
- DAO 객체를 받은 md 로 md.selectByEmail() 로 이메일 주소 중복검사를 한다, 여기서 DAO 로 이동한다
- DAO 의 selectByEmail() 를 호출했으므로 DAO 로 갔다
- MemberDaoImpl.java
package sample16;
import java.util.*;
public class MemberDaoImpl implements MemberDao {
private Map<String, Member> map = new HashMap<String, Member>();
private static int nextId = 0;
public void insert(Member member) {
member.setId(++nextId);
map.put(member.getEmail(), member);
}
public Member selectByEmail(String email) {
return map.get(email);
}
public Collection<Member> list() {
return (Collection<Member>) map.values();
}
public void delete(String email) {
map.remove(email);
}
public void update(Member member) {
map.put(member.getEmail(), member);
}
}
- DB 연동을 안하므로, Map 자료구조에 회원 데이터를 저장할 것임, 여기 DAO 의 Map 객체 map 에 저장할 것
- Map 자료구조에서 키값은 String, 밸류값은 Member(DTO) 가 자료형이다
- 키값이 Email 주소이고, 밸류값은 해당 회원의 정보를 담게 할 것임
- nextId 는 몇명이 등록되어있는지 저장하는 역할, insert() 가 되면 이 값을 증가시켜서 setId() 메소드로 넘어온 DTO 객체 member 에 저장 * 아래까지 모두 보고와야 이해됨
<selectbyemail() 메소드>
- map.get() 으로 넘어온 이메일을 키로, 그 키의 밸류인 DTO 객체를 돌려주고 있다
- 해당 키(매개변수로 넘어온) 에 해당하는 밸류가 있으면 밸류를 리턴, 없으면 null 을 리턴
- Service 로 돌아가자
- Service 의 insert() 부분만
public int insert(RegisterMember rm) {
int result = 0;
Member member = md.selectByEmail(rm.getEmail()); //email주소로 1명의 정보를 구해옴, *
if (member == null) { // 동일한 email 주소가 없으면 회원가입함
member = new Member(rm.getPass(), rm.getEmail(), rm.getName(), new Date());
md.insert(member);
result = 1;
} else {
System.out.println("이미 데이터가 있습니다");
}
return result;
}
<DAO selectByEmail() 에서 돌아온 뒤>
- * 가 돌아온 곳의 줄이다
- selectByEmail() 로 부터 돌아와서 Member 객체 member 로 가져온 객체를 저장한다
- select 문에서 돌려주는 값이 없어야 동일한 Email 이 없는 것임, 그래서 member == null 일때 삽입시켜야함
- 만약 객체를 제대로 가져왔다면 이메일 중복이 아니므로 이 회원을 등록(삽입) 할 것임
- 즉, 중복이 아닐때는 DAO 객체를 받은 md 로 md.insert() 해서 DAO 의 insert() 호출
<회원 등록> - Member DTO 객체 member 에 매개변수로 넘어온 RegisterMember DTO 객체 rm 에서 암호, 이메일, 이름을 꺼내서 세팅
- 그 후 Service 객체 md 로 insert() 호출, 넘겨주는 값은 객체 member 이다
- 그럼 다시 DAO 로 간다
- DAO의 insert() 부분만
public void insert(Member member) {
member.setId(++nextId);
map.put(member.getEmail(), member);
}
- 매개변수로 넘어온 객체 member 에 setId() 로 id(아이디 비번할떄 id 가 아니라 인식을 위한 id) 를 세팅
- 현재는 DB 가 아닌 메모리에 저장한다, 그래서 map 자료구조에 put() 으로 키를 이메일, 밸류를 상세정보를 저장한 member 로 준다
+ map 은 키값 중복 안됨
- DAO 의 insert() 에서 반환은 하지 않음
- 다시 Service로 돌아옴
- Service 클래스 insert() 부분만
public int insert(RegisterMember rm) {
int result = 0;
Member member = md.selectByEmail(rm.getEmail()); //email주소로 1명의 정보를 구해옴
if (member == null) { // 동일한 email 주소가 없으면 회원가입함
member = new Member(rm.getPass(), rm.getEmail(), rm.getName(), new Date());
md.insert(member); // * 돌아온 곳
result = 1;
} else {
System.out.println("이미 데이터가 있습니다");
}
return result;
}
* 돌아온 곳
- DAO의 insert 에서 반환은 하지 않는다, 그냥 삽입만 한 것
- 여기선 DB연동이 아니므로 DAO까지 갔다 온 후 내가 임의로 result 에 1 을 넣고 그 result 를 반환
- 그러면 다시 Ex01.java 로 간다
- Ex01.java 에서 insert() 부분만
public static void insert(String[] str) {
if (str.length != 5) {
help();
return;
}
RegisterMember rm = new RegisterMember();
rm.setEmail(str[1]);
rm.setName(str[2]);
rm.setPass(str[3]);
rm.setConfirmPass(str[4]);
if (!rm.passCheck()) {
System.out.println("똑바로 암호 입력해");
} else {
int result = ms.insert(rm); // * 돌아온 곳
if (result > 0)
System.out.println("입력 성공");
}
}
* 돌아온 곳
- result 에 1이 반환되었으므로 아래의 "입력 성공" 을 출력
- 실제 입력을 해보자
- 이제 검색을 해보자
- 검색할때는 이메일 주소로만 검색 가능
Ex01.java
- main() 에서의 명령에 따른 분기문은 아까와 같은 원리이므로 설명 생략, select() 로 간다
Ex01.java 의 select()
public static void select(String[] str) {
if (str.length != 2) {
help();
return;
}
Member member = ms.select(str[1]);
if (member != null)
System.out.println(member);
else
System.out.println("없는 데이터 입니다");
}
- 형식이 "select 이메일" 이므로 length 가 2인지 확인
- Service 객체 ms 로 ms.select() 하고, 매개변수로는 이메일을 넘김
- Service 클래스 MemberServiceImpl.java 의 select() 부분만
public Member select(String email) {
return md.selectByEmail(email);
}
- DAO 객체 md 로 DAO 의 selectByEmail() 을 호출, 매개변수로는 넘어온 email 을 그대로 넘겨줌
- DAO 클래스 MemberDaoImpl.java의 selectByEmail() 부분만
public Member selectByEmail(String email) {
return map.get(email);
}
- 회원이 저장되어있는 Map 객체 map 에서 get(키) 로 밸류인 Member 객체를 구해옴
- 이제 돌아간다
- Service 클래스 MemberServiceImpl.java 의 select() 부분만
public Member select(String email) {
return md.selectByEmail(email);
}
- 그대로 리턴함, Ex01.java 로 간다
- Ex01.java 의 select() 부분만
public static void select(String[] str) {
if (str.length != 2) {
help();
return;
}
Member member = ms.select(str[1]);
if (member != null)
System.out.println(member);
else
System.out.println("없는 데이터 입니다");
}
- ms.select() 에서 만약 있는 회원이면 객체를 반환해서 member 에 저장, 없으면 null 값이 member 로 들어감
- 그래서 member != null 일땐 member 출력 (Member DTO 클래스에 toString() 이 있으므로 그걸로 회원 정보 모두 출력)
- 검색을 실제로 해보면
- 검색된다
- 이제 목록 출력을 해보자
- 목록 출력시에는 "list" 라고만 입력하면된다
Ex01.java
- main() 에서의 명령에 따른 분기문은 아까와 같은 원리이므로 설명 생략, list() 로 간다
- Ex01.java 의 list() 부분만
public static void list() {
Collection<Member> list = ms.list();
if (list != null) {
for (Member member : list) {
System.out.println(member);
}
}
}
- Service 객체 ms 로 ms.list() 호출하고 Collection<Member>가 자료형인 list 로 반환
+ Collection : 인터페이스, 객체의 모음을 저장, List, Set, Map 이 이 Collection 을 상속함
- Service 클래스 MemberServiceImpl.java 의 list() 부분만
public Collection<Member> list() {
return md.list();
}
- DAO 객체 md 로 md.list() 를 호출하고 있다
- DAO 클래스 MemberDaoImpl.java 의 list() 부분만
public Collection<Member> list() {
return (Collection<Member>) map.values();
}
- 회원 데이터를 저장하는 Map 객체 map 으로 map.values() 로 map 에 저장된 모든 value 값들을 가져와서 리턴함
- map.values() 는 모든 회원 정보, 즉 DTO 객체들의 모음이다
- map.values() 는 리턴자료형이 Collection 이다!
- 그럼 Service 클래스로 다시 돌아가자
- Service 클래스 MemberServiceImpl.java 의 list() 부분만
public Collection<Member> list() {
return md.list();
}
- 그대로 Ex01 로 리턴함
- Ex01.java 의list() 부분만
public static void list() {
Collection<Member> list = ms.list();
if (list != null) {
for (Member member : list) {
System.out.println(member);
}
}
}
- 돌아와서 데이터들을 받아서 for문을 통해서 하나씩 출력하고 있다 (toString() 사용됨)
- update / delete 는 간략히만 설명
update
- update는 기존에 있는 이메일을 써야하고 이름과 비번을 수정 가능하다
<Ex01.java>
- update 는 RegisterMember의 passCheck() 를 먼저 호출해서 암호와 암호확인이 일치하는지 확인 후 일치시 Service 의 update() 호출
<Service>
- Service 의 update() 안에서 DAO의 selectByEmail() 를 호출해서 있는 이메일인지 확인
- 중복이 아닌 이메일이면 DAO의 update() 를 호출해서 수정
<DAO의 update()>
- update 는 키값이 중복되면 마지막의 키값만 사용할 수 있다는 점을 이용
- 즉 정보수정을 원하는 회원의 키값과 똑같은 키값으로 새로운 데이터(수정용 데이터)를 저장
delete
- map 에서 remove() 메소드로 키값 email 로 해당 데이터를 삭제
Spring DI 예제 16 (어노테이션 기반, 회원관리 콘솔 프로그램)
- src/main/java/sample17/ 안의 파일들
- 어노테이션 기반으로 만든 콘솔 회원관리 프로그램
Spring DI 예제 17 구조 & 흐름
- Web Application 에서는 갈땐 Controller-> Service -> DAO, 올땐 DAO -> Service -> Controller
- 현재는 Web Application 이 아닌 Application 이므로 Controller 클래스는 없다, 그 역할을 메인메소드가 하고 있는거임
- 갈때 : main() -> Service -> dao , 돌아올땐 반대로 dao -> Service -> main() 으로 돌아오자
- Ex01.java : 메인메소드를 가진 클래스이다, Controller 클래스의 역할을 대신한다, 명령어에 따라 회원정보 검색, 등록, 삭제, 수정 가능
- MemberService.java : 인터페이스, 추상메소드들이 많이 있다 ex) delete(), insert(), update(), select(), list()
- MemberServiceImpl.java : MemberService 를 상속,MemberService의 추상메소드들을 모두 오버라이딩
- MemberDao.java : 인터페이스, 추상메소드들이 많이 있다 ex) delete(), insert(), update(), selectByEmail(), list()
- MemberDaoImpl.java : MemberDao를 상속, MemberDao 의 추상메소드들을 모두 오버라이딩
- Member.java : DTO, 필드 id,pass,email,name,reg_date 와 각각의 getter/setter 메소드, toString() 메소드
- RegisterMember.java : DTO, 필드 pass, confirmpass, name, email 와 각각의 getter/setter 메소드, passCheck() 메소드
- DTO 객체가 2개이다
- RegisterMember.java DTO 클래스는 가입할때만 사용된다
Service 클래스와 DAO 클래스의 메소드 명이 같은 게 많다
- 같게 설정해서 어느 메소드에서 어느 메소드를 호출할지 알기 쉽게 해둔 것이다
ex) Service의 delete() 메소드에서 DAO 의 delete() 메소드를 호출
인터페이스를 사용하는 이유
- 예전에는 통일성있는 클래스를 작성하기 위해 인터페이스를 사용
- 지금은 메소드가 많아서 그걸 관리하기 위해 인터페이스를 사용한다 (어떤 메소드가 있는지 색인처럼 확인 가능)
package sample17;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service("ms")
public class MemberServiceImpl implements MemberService {
@Autowired
private MemberDao md;
public int insert(RegisterMember rm) {
int result = 0;
Member member = md.selectByEmail(rm.getEmail());
if (member == null) {
member = new Member(rm.getPass(), rm.getEmail(), rm.getName(), new Date());
md.insert(member);
result = 1;
} else {
System.out.println("이미 데이터가 있습니다");
}
return result;
}
public Member select(String email) {
return md.selectByEmail(email);
}
public Collection<Member> list() {
return md.list();
}
public int delete(String email) {
int result = 0; // 데이터가 이미 있는지 확인
Member member = md.selectByEmail(email);
if (member != null) {
md.delete(email);
result = 1;
} else {
System.out.println("없는네 우찌 삭제하니");
}
return result;
}
public int update(RegisterMember rm) {
int result = 0; // 데이터가 이미 있는지 확인
Member member = md.selectByEmail(rm.getEmail());
if (member != null) {
member.setPass(rm.getPass());
member.setName(rm.getName());
md.update(member);
result = 1;
} else {
System.out.println("없는네 우찌 고치니 ? 헐");
}
return result;
}
}
@Service 어노테이션 (MemberServiceImpl.java 부분)
- 조건 3개 중 두번째 조건이다
- @Service 어노테이션 안에서 Service 객체명의 이름을 지정할 수 있다
- sample16 에서는 getBean() 으로 구해왔다
- 여기선 bean 을 직접 만들지 않았으므로 sample15 처럼 getBean(서비스클래스명.class) 로 구해와야한다
- 여기선 @Service 어노테이션 안에 Service 객체명(객체 id값)으로 "ms" 를 지정했으므로 main() 에서 Service 객체를 구해올때 getBean("ms") 로 구해올 수 있다
+ Ex01.java 의 main() 부분
- 만약 @Service("ms") 가 아닌 @Service 만 했다면 ac.getBean(MemberService.class) 로 Service 객체를 구해야한다
- 하지만 Service 클래스 상단에서 @Service("ms") 로 그 객체에 이름을 줬으므로 이름으로 getBean("ms") 불러옴
@Autowired 어노테이션(MemberServiceImpl.java 부분)
- 조건 3개 중 세번째 조건이다
- DAO 객체를 주입받아야하는 프로퍼티 md 위에 @Autowired 를 작성
- 그럼 DAO 객체 생성과 md 로 주입까지 완료된다
- MemberDaoImpl.java
package sample17;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Repository;
@Repository
public class MemberDaoImpl implements MemberDao {
private Map<String, Member> map = new HashMap<String, Member>();
private static int nextId = 0;
public void insert(Member member) {
member.setId(++nextId);
map.put(member.getEmail(), member);
}
public Member selectByEmail(String email) {
return map.get(email);
}
public Collection<Member> list() {
return (Collection<Member>) map.values();
}
public void delete(String email) {
map.remove(email);
}
public void update(Member member) {
map.put(member.getEmail(), member);
}
}
@Reopsitory 어노테이션 (MemberDaoImpl.java 부분)
- 지금은 DAO 클래스에서 아무 객체도 주입받고 있지 않으므로 @Repository 가 없어도 된다
- 나중에 DAO 클래스에서 SqlSession 객체를 생성 해서 DAO의 프로퍼티로 주입할때는 @Repository 를 위에 붙여야한다
스스로 질문 & 스스로 답변
Q. Service 클래스 상단에서 @Service 만으로 썻으면 main() 에서 Service 객체 구해올때 getBean(Service클래스명.class) 로 구해왔었다, 근데 나중에 Web Application 를 해서 Controller -> Service 로 갈떄도 getBean(Service클래스명.class) 를 쓰는가?
A. 아니다, 지금 Application 에서는 main() 에서 Service 객체를 구해와야하므로 getBean() 을 쓰지만 나중에 Controller -> Service 로 갈때는 Controller 클래스에서 @Autowired 로 Service 객체를 바로 프로퍼티에 주입시키므로 그냥 바로 쓰면 된다, getBean() 으로 직접 구해올 필요 없이 이미 Spring 환경설정 파일을 읽어올때 다 생성되고 주입되었음, 주입된 Service객체를 바로 쓰면 됨
- 이렇게 @Autowired 로 Controller 의 프로퍼티 service 에 바로 Service 객체가 주입됨
JSP와 오라클 데이터베이스를 JDBC(Java Database Connectivity) 방식으로 연동하는 코드를 작성하시오. [10점]
데이터베이스 이름 : xe port 번호 : 1521 계정명 : scott 비밀번호 : tiger
// JDBC 방식
Class.forName("oracle.jdbc.driver.OracleDriver");
con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe", "scott", "tiger");
[문항2]
JSP의 내장객체 중 영역에 관련된 객체(request, session)를 이용하여 회원의 id를 각각 공유 설정하고, 공유된 id를 구해오는 코드를 각각 작성하시오. [10점]
사용자 폼 태그에서 method=post 방식으로 넘어온 한글 자료를 JSP에서 받을 때 한글을 깨지지 않게 하는 코드를 작성하시오. [10점]
request.setCharacterEncoding("utf-8");
[문항4]
다음 Java코드와 같은 역할을 하는 내용을 보여주는 JSP 표준액션 코드를 작성 하시오. [10점]
Car sonata = new Car();
<jsp:useBean id="sonata" class="Car"/>
[문항5]
체크박스는 복수 개를 선택할 수 있다. 복수개가 선택된 값을 JSP에서 String 배열로 받으려면 request객체 하위의 어떠한 메서드를 사용해야 하는가? [10점]
답 : request 객체의 getParameterValues() 메소드를 사용하면 된다
[문항6]
자바 서블릿 코드에서 출력 스트림 객체를 만드는 방법은? [10점]
PrintWriter out = response.getWriter();
[문항7]
다음 보기는 JDBC를 활용하여 테이블에 데이터를 입력하는 프로그램이다. 괄호 (1) (2) (3) (4)를 채워서 완성하시오. [10점] Class.forName((1)); Connection con=DriverManager.getConnection((2), "scott","tiger"); PreparedStatement pstmt = con.prepareStatement((3)); pstmt.setInt(1, deptno); pstmt.setString(2, dname); pstmt.setString(3, loc); int result = pstmt.(4); pstmt.close(); con.close();
Class.forName("oracle.jdbc.driver.OracleDriver"); Connection con=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe", "scott","tiger"); PreparedStatement pstmt = con.prepareStatement(sql); pstmt.setInt(1, deptno); pstmt.setString(2, dname); pstmt.setString(3, loc); int result = pstmt.executeUpdate(); pstmt.close(); con.close();
# 실수했다, sql 대신 SQL문이 들어가야함
# insert into 테이블명 values(?,?,?)
[문항8] 다음과 같은 조건에 맞는 게시판 양식을 작성하세요? [10점]
1) 값 전달 방식은 post 방식으로 한다. 2) 값이 전달될 파일명은 board.jsp 로 작성한다. 3) 입력 양식의 name값은 위에서부터 title, name, password, content 순서로 한다. 4) 확인 버튼은 submit으로 작성한다. 5) 게시판 양식 : boardform.html 폼에서 넘어온 값을 받는 파일 : board.jsp 자바빈 클래스 : board – BoardBean.java boardform.txt 파일로 작성해서 제출하세요.
[문항9] 위 8번 문제의 양식에서 넘어온 값을 저장하기 위한 자바빈(DTO) 클래스를 작성하세요? [10점]
1) 입력 양식의 name값은 위에서부터 title, name, password, content 순서로 한다. 2) 자바빈 클래스의 package는 board로 작성한다. 3) 자바빈 클래스는 BoardBean 으로 작성한다. 4) 게시판 양식 : boardform.html 자바빈 클래스 : board – BoardBean.java boardbean.txt 파일로 작성해서 제출하세요.
- board/BoardBean.java
package board;
public class BoardBean {
private String title;
private String name;
private String password;
private String content;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
[문항10] 위 8번 문제의 게시판 폼에서 넘어온 값을 액션태그를 사용하여 자바빈 클래스(DTO)에 저장하고 출력하는 프로그램을 작성하세요. [10점]
1) 한글값이 깨지지 않도록 처리한다. 2) 게시판 폼에서 넘어온 값을 액션태그를 이용해서 자바빈 클래스에 저장하고, 저장된 값을 출력하시오. 3) 게시판 양식 : boardform.html 폼에서 넘어온 값을 받는 파일 : board.jsp 자바빈 클래스 : board – BoardBean.java board.txt 파일로 작성해서 제출하세요.
- MyBatis 연동 전에는 startRow 와 endRow 를 getList() 의 매개변수로 전달했었다, select 문의 where 절에 사용했음
- MyBatis 와 연동시 값이든 주소든 단 하나만 SqlSession 지원 메소드 5개의 매개변수로 전달 가능하다
+ Service 클래스에서 DAO 메소드로는 여러개의 값을 매개변수로 전달 가능하지만, SqlSession 지원 메소드의 매개변수로는 첫번째 매개변수에 id 를 넣고, 두번째 매개변수에 값을 전달할 수 있다, 단 하나의 값만 전달 가능
해결방법
- 해결방법이 여러개 있지만 여기선 이 방법을 사용하고 있다
- startRow 와 endRow 를 전달하는 대신 페이지 번호인 page 를 전달한다
- 이 page 번호에 따라 startRow 와 endRow 가 정해지므로, limit 는 정해진 값이므로 그 자리에 10을 쓰면 된다
- SQL문 상에서 page 번호로 startRow 와 endRow를 계산하기
또다른 해결방법
- 이 부분에서만 여러 파일의 내용을 변경할 것(주석 풀기 등), 이 부분을 나가면 다시 원래대로
- Map 객체 map 을 생성하고 put() 으로 startRow, endRow 를 저장 후 Map 객체 map 을 전달하면 됨
// Map 처리 ----------------------------------
Map map = new HashMap();
map.put("start", startRow);
map.put("end", endRow);
-Map 객체 map 에 key , value 값으로 startRow 와 endRow 를 모두 저장시켰다
ex) 사용자가 2 페이지 선택시 11 과 20 을 Map 객체에 저장하는 것
- key 값으로 value 를 가져와서 사용할 것
- 그리고 Map 객체를 DAO의 getList() 로 전달
boardlist = dao.getList(map);
- MemberDAO.java 에서 getList() 메소드 부분에서 주석을 바꿈
// 데이터 목록
// public List getList(int page) throws Exception {
public List getList(Map map) throws Exception {
List list = new ArrayList();
SqlSession session=getSession();
list = session.selectList("board_list", map);
return list;
}
- map 객체를 selectList() 의 매개변수로 전달한다
- Mapper 파일인 board.xml 로 가자
<!-- Map 전달 -->
<select id="board_list" parameterType="Map" resultType="board">
select * from (select rownum rnum, board.* from (
select * from model22 order by board_re_ref desc,board_re_seq asc) board )
where rnum >= #{start} and rnum <= #{end}
</select>
- parameterType 을 Map 으로 써야한다, HashMap 이어도 괜찮다
- #{start} 와 #{end} 의 "start" 와 "end" 는 map 에 저장한 key 값이다
- #{start} 처럼 key 값을 이용해서 value 값을 구해올 수 있다
+ 세번째 방법
- DTO 클래스 안에 startRow 와 endRow 를 저장할 수 있는 필드를 만들고 그 DTO 객체에 startRow, endRow 를 저장해서 넘겨주는 방법도 있다
- 가져올땐 getter 메소드 사용
어떤 방법을 써야할까?
- 우리가 쓰고 있는 페이지번호 page 를 넘기고 SQL문 상에서 startRow, endRow 를 계산하는 방법은 쓰지 못할 때가 있다
- 검색기능을 수행시에 '작성자명', '제목' 등으로 검색한다, 그 검색어도 SQL상으로 전달되어야함, 넘어가는 값이 많아질땐 페이지번호를 넘기는 방법 쓰지 못하게 됨
- 이땐 DTO 객체를 쓰거나, Map 객체안에 저장해서 전달해야함
- 주로 DTO 객체를 넘기는 경우가 많다, Map 은 DTO보다 처리속도가 느림
- MemberDAO.java 에서 getCount() 메소드 부분만
// 총데이터 갯수 구하기
public int getCount() throws Exception{
int result=0;
SqlSession session=getSession();
result = (Integer)session.selectOne("board_count");
return result;
}
- group 함수로 구하기때문에 검색하는 데이터는 1개이므로 selectOne() 메소드 사용
- session.selectOne() 에서 리턴자료형은 Object 이므로 다운캐스팅이 원칙이다
- board.xml 에서 글 개수를 구해주는 처리하는 SQL문 부분 (id 가 board_count)
// 데이터 목록
public List getList(int page) throws Exception {
// public List getList(Map map) throws Exception {
List list = new ArrayList();
SqlSession session=getSession();
list = session.selectList("board_list", page);
return list;
}
- 메소드 selectList() 에서도 다른 SqlSession 지원 메소드처럼 단 하나의 값만 매개변수로 전달 가능하다
+ 첫번째 매개변수는 id 값, 두번쨰 매개변수에만 값을 전달 가능
- page 번호만 있으면 startRow, endRow를 계산할 수 있으므로 페이지번호 page 만 전달한다
+ Map 객체로 넘어올때는 주석처리 되어있음
- board.xml 에서 목록을 자르고 목록을 가져오는 SQL문 부분 (id 가 board_list)
<!-- 글목록 -->
<!-- page 전달-->
<select id="board_list" parameterType="int" resultType="board">
select * from (select rownum rnum, board.* from (
select * from model22 order by board_re_ref desc,board_re_seq asc) board )
where rnum >= (#{page}-1) * 10 + 1 and rnum <= #{page}*10
</select>
- selectList() 메소드를 실행하고 결과를 List 로 돌려줌, 이때 결과를 DTO 객체들을 저장한 List 로 전달한다고 해도 resultType 에는 DTO 인 member 를 써야한다
- 리스트에 알아서 순차적으로 저장해서 돌려준다
- 전달받은 값은 페이지번호 이므로 parameterType 은 int 로 작성
<SQL문>
- 첫번째 서브쿼리는 rownum 컬럼에 대한 별칭 rnum 을 준다
- 두번째 서브쿼리는 필요한 내용을 검색하고 정렬한다, 댓글게시판이므로 board_re_ref 로 최근글이 위로 가도록 정렬하고, 부모글과 자식글은 board_re_ref 가 동일하므로 한번 더 정렬조건으로 board_re_seq 를 준다
- 두번쨰 서브쿼리에 대해서 board 라는 별칭을 주고 첫번째 서브쿼리에서 board 의 모든 컬럼을 검색하고 있다
- startRow, endRow 를 전달받은 page 번호로 계산한다
- startRow = (#{page} -1) * 10 + 1 이다, 10 은 limit 을 의미
- endRow = #{page} * 10 이다, 10은 limit 을 의미
- xml 파일에서는 < 와 > 를 잘 인식하지 못함, > 대신 특수문자 > 를 사용, < 대신 특수문자 &li; 을 사용
+ <와 > 를 대신하는 다른 방법도 있다, 여기서는 > 과 < 을 사용
- 목록을 성공적으로 가져올때 콘솔창
- 이제 목록을 가져오는 작업은 끝났다, Controller 클래스로 갔다가 Dispatcher 방식으로 qna_board_list.jsp 로 포워딩됨
package service;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import dao.BoardDAO;
import model.BoardBean;
public class BoardReply implements Action {
@Override
public ActionForward execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
// TODO Auto-generated method stub
System.out.println("BoardReply");
request.setCharacterEncoding("utf-8");
int board_num = Integer.parseInt(request.getParameter("board_num"));
int board_re_ref = Integer.parseInt(request.getParameter("board_re_ref"));
int board_re_lev = Integer.parseInt(request.getParameter("board_re_lev"));
int board_re_seq = Integer.parseInt(request.getParameter("board_re_seq"));
String page = request.getParameter("page");
BoardBean board = new BoardBean();
board.setBoard_re_ref(board_re_ref);
board.setBoard_re_seq(board_re_seq);
BoardDAO dao = BoardDAO.getInstance();
dao.updateSeq(board); // board_re_seq값 증가
board.setBoard_re_seq(board_re_seq+1);
board.setBoard_re_lev(board_re_lev+1);
board.setBoard_name(request.getParameter("board_name"));
board.setBoard_pass(request.getParameter("board_pass"));
board.setBoard_subject(request.getParameter("board_subject"));
board.setBoard_content(request.getParameter("board_content"));
dao.boardReply(board); // 댓글 작성 : insert SQL
ActionForward forward = new ActionForward();
forward.setRedirect(false);
forward.setPath("/BoardDetailAction.do?board_num="+board_num+"&page="+page); // 상세페이지로 이동
// forward.setPath("/BoardListAction.do?page="+page); // 목록페이지로 이동
return forward;
}
}
- 댓글 작성 폼에서 한글값이 넘어올 수 있으므로 한글값 인코딩
- hidden 으로 넘어오는 5개의 값을 request.getParameter() 로 받아서 변수에 저장
- 또한 사용자가 직접 댓글 작성폼에 작성한 정보 4가지도 받는다
- updateSeq() 메소드에서 부모글의 board_re_ref, board_re_seq 값이 필요하므로 생성한 DTO 객체 board 에 부모글의 board_re_ref, board_re_seq 를 저장하고 그 객체 board 를 updateSeq() 의 매개변수로 전달
<DAO updateSeq() 메소드로부터 돌아온 뒤>
- 댓글을 작성해야하므로 insert 될 데이터를 DTO 객체 board 에 세팅
- 이때 board_re_seq 값과 board_re_lev 값은 부모보다 1 증가된 값으로 세팅
- 또한 사용자가 직접 입력한 4가지 정보도 세팅하고 DAO의 boardReply() 메소드 호출, 매개변수로는 객체 board 를 넘김
<DAO boardReply() 메소드로부터 돌아온 뒤>
- 댓글을 단 이후 상세페이지로 넘어갈땐, "/BoardDetailAction.do" 로 포워딩 페이지 지정하며 글번호와 페이지번호를 전달
+ BoardDetailAction.java 에서 글번호와 페이지번호를 getParameter() 로 받는 작업을 가장 먼저하므로 두 값이 필요
- 댓글을 단 이후 목록페이지로 넘어갈땐, "/BoardListAction.do" 로 포워딩 페이지 지정하며 페이지 번호를 전달
이 Service 클래스에서 2번의 DAO 메소드를 실행해야함
1) updateSeq() 메소드 : update SQL문
- update 문을 수행하기 위해 부모글의 ref 값과 seq 값을 전달
- 댓글의 ref 는 부모글의 ref 값과 같은값을 넣고, 부모글의 seq 보다 큰 글들의 seq 를 +1 함
2) boardReply() 메소드 : insert SQL문
- 댓글을 DB에 insert 함
- Mapper 파일로 처리해야하므로 두 메소드의 SQL문을 하나의 메소드에서 실행 불가, 메소드를 따로 작성 해야함
- MemberDAO.java 에서 댓글 출력순서를 조절하기 위한 updateSeq() 부분
// 댓글 출력 순서 (board_re_seq값 증가)
public void updateSeq(BoardBean board) {
SqlSession session = getSession();
session.update("board_updateseq", board);
}
- 부모글의 board_re_ref 와 board_re_seq 값을 저장한 객체 board 를 두번째 매개변수로 전달한다
- board.xml 에서 원문 글 작성 처리하는 SQL문 부분 (id 가 board_updateseq)
<!-- 댓글 출력순서 -->
<update id="board_updateseq" parameterType="board">
update model22 set board_re_seq=board_re_seq+1
where board_re_ref = #{board_re_ref} and board_re_seq > #{board_re_seq}
</update>
- 부모글과 board_re_ref 값이 같으면서 , 부모글보다 board_re_seq 값이 큰 글의 board_re_seq 값을 1 증가시켜줘야함
의미
1) 부모가 원문이면 그 원문의 모든 댓글의 seq 값을 1 씩 증가
2) 부모가 댓글이면 그 부모보다 먼저 달린 형제 댓글들과 그 형제 댓글들의 대댓글들의 seq 값을 1씩 증가
package service;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import dao.MemberDAO;
public class Idcheck implements Action{
@Override
public ActionForward execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
// TODO Auto-generated method stub
System.out.println("Idcheck");
request.setCharacterEncoding("utf-8");
PrintWriter out = response.getWriter();
String id = request.getParameter("id");
System.out.println("id:"+ id);
MemberDAO dao = MemberDAO.getInstance();
int result = dao.idcheck(id);
System.out.println("result:"+ result); // 1 : 중복ID, -1 : 사용가능한 ID
out.println(result); // 브라우저에 출력되는 값이 callback함수로 리턴된다.
return null;
}
}
- member.js 에서 ajax 로 전달한 사용자가 입력한 id 값을 속성명 "id" 를 사용해서 request.getParameter("id") 로 받음
- DB와 연동하여 중복 ID 인지 아닌지 확인해야하므로 DAO 객체 생성 후 DAO의 idcheck() 메소드 호출
- idcheck() 메소드 호출 시 매개변수로 사용자가 입력한 id 값을 전달함
- idcheck() 에서 리턴된 값을 result 로 받음, 이때 중복 ID는 1, 사용가능한 ID는 -1 로 전달해주기로 함
- 콜백함수로 리턴되는 값은 브라우저에 출력되는 값이므로 out 객체로 result 값을 출력
+ System.out.println() 은 콘솔에 출력되는 값, out.println() 은 브라우저에 출력되는 값
- MemberDAO.java 에서 idcheck() 메소드 부분만
// ID중복검사
public int idcheck(String id) throws Exception{
int result = 0;
SqlSession session = getSession();
MemberDTO member = session.selectOne("idcheck", id);
if(member != null) { // 중복 ID
result = 1;
}else { // 사용가능한 ID
result = -1;
}
return result;
}
- 매개변수로 사용자가 입력한 id 값을 전달받음
- SqlSession 객체를 변수 session 으로 받아오고 session.selectOne() 메소드를 호출하면서 Mapper 파일에서 id 가 "idcheck" 인 태그의 SQL문 호출
- 그 SQL문을 호출하면서 사용자가 입력한 id 를 넘김
- 사용자가 입력한 id 에 해당하는 검색되는 결과가 1개이므로 selectOne() 메소드로 검색해야함
- selectOne() 을 호출 후 DTO 객체 member 를 반환함, 그 객체가 있으면 DB에 이미 같은 id 인 데이터가 있다는 의미이므로 1 리턴
- 받아온 객체가 null 이면 같은 id 인 데이터가 없다는 의미이므로 사용가능한 id 라는 의미로 -1 리턴
- member.xml 에서 ID중복검사를 처리하는 SQL문 부분 (id 가 idcheck)
<!-- ID중복검사, 회원인증 -->
<select id="idcheck" parameterType="String" resultType="member">
select * from member0609 where id = #{id}
</select>
- 전달되는 값은 id 이므로, 전달되는 값의 자료형인 String 을 parameterType 으로 쓴다
+ parameterType 속성값인 "member"는 MyBatis 환경설정 파일에서 Alias 값으로 지정한 별칭이다
package service;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import dao.MemberDAO;
import model.MemberDTO;
public class Update implements Action{
@Override
public ActionForward execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
// TODO Auto-generated method stub
System.out.println("Update");
response.setContentType("text/html; charset=utf-8");
request.setCharacterEncoding("utf-8");
PrintWriter out = response.getWriter();
MemberDTO member = new MemberDTO();
member.setId(request.getParameter("id"));
member.setPasswd(request.getParameter("passwd"));
member.setName(request.getParameter("name"));
member.setJumin1(request.getParameter("jumin1"));
member.setJumin2(request.getParameter("jumin2"));
member.setMailid(request.getParameter("mailid"));
member.setDomain(request.getParameter("domain"));
member.setTel1(request.getParameter("tel1"));
member.setTel2(request.getParameter("tel2"));
member.setTel3(request.getParameter("tel3"));
member.setPhone1(request.getParameter("phone1"));
member.setPhone2(request.getParameter("phone2"));
member.setPhone3(request.getParameter("phone3"));
member.setPost(request.getParameter("post"));
member.setAddress(request.getParameter("address"));
member.setGender(request.getParameter("gender"));
String h="";
String[] h1 = request.getParameterValues("hobby");
for(String h2 : h1) {
h += h2+"-"; // h = "공부-게임-등산-"
}
member.setHobby(h);
member.setIntro(request.getParameter("intro"));
MemberDAO dao = MemberDAO.getInstance();
MemberDTO old = dao.getMember(member.getId());
// 비번 비교
if(old.getPasswd().equals(member.getPasswd())) { //비번 일치시
int result = dao.update(member);
if(result==1) System.out.println("회원수정 성공");
}else { //비번 불일치시
out.println("<script>");
out.println("alert('비번이 일치하지 않습니다.');");
out.println("history.go(-1);");
out.println("</script>");
out.close();
return null;
}
ActionForward forward = new ActionForward();
forward.setRedirect(false);
forward.setPath("/member/main.jsp");
return forward;
}
}
- 수정폼에서 입력값들이 넘어오므로 한글 인코딩
- id 도 hidden 객체로 넘어왔고, 사용자가 입력한 비번도 넘어왔다
- DTO 객체 member 를 생성해서 setter 메소드로 id 와 사용자가 수정폼에 입력한 값들을 member 에 저장
- DAO 의 메소드를 2번 호출해야함, 비번 확인을 위해 상세정보 가져올때 1번, 수정할때 1번
- DAO 객체 생성 후 DB에 저장된 비번을 가져오기 위해 DAO 의 getMember() 메소드를 호출하면서 수정폼에서 넘겨준 id 를 매개변수로 넘겨준다
<DAO getMember() 에서 돌아온 후>
- old.getPasswd() 는 DB에 저장된 비번, member.getPasswd() 는 사용자가 입력한 비번
- 두 비번이 일치시 수정 하는 메소드인 DAO의 update() 메소드 호출, 수정할 데이터를 저장한 DTO 객체 member 를 넘김
<DAO update() 에서 돌아온 후>
- 수정 성공시 1을 돌려주기로 했으므로, 1을 리턴받으면 "회원수정 성공" 메세지를 콘솔에 출력
- 비번 일치가 되면 수정 후 if-else 문 아래 문장인 ActionForward 객체 foward 생성 후, main.jsp 로 Dispatcher 방식 으로 포워딩 페이지, 방식 지정
- 성공시 Controller 클래스로 가서 main.jsp 로 포워딩하면 아직 세션이 남아있으므로 세션이 있을때의 화면이 뜬다
- 비번이 일치하지 않으면 메세지를 출력한 후 다시 이전페이지인 수정폼으로 돌아간다
- MemberDAO.java 에서 getMember() 메소드 부분만
// 회원 1명 정보 구하기 : 수정폼, 수정, 삭제
public MemberDTO getMember(String id) throws Exception{
SqlSession session = getSession();
MemberDTO member = session.selectOne("idcheck", id);
return member;
}
- 1명에 대한 상세정보를 구하므로 selectOne() 메소드, id 값이 "idcheck" 인 Mapper 파일의 SQL문 호출
- 사용자가 입력한 id 값을 매개변수로 넘겨준다
- 돌려받은 객체 member 를 Service 클래스로 리턴
- member.xml 에서 수정 처리하는 SQL문 부분 (id 가 idcheck)
<!-- ID중복검사, 회원인증 -->
<select id="idcheck" parameterType="String" resultType="member">
select * from member0609 where id = #{id}
</select>
- DTO 객체에 상세정보가 자동으로 저장(매핑) 되어 돌려준다
- MemberDAO.java 에서 update() 메소드 부분만
// 회원정보 수정
public int update(MemberDTO member) throws Exception{
int result = 0;
SqlSession session = getSession();
result = session.update("update", member);
return result;
}
- SqlSession 객체를 변수 session 으로 받아오고 update SQL문을 부를 것이므로 session.update() 메소드를 호출
- Mapper 파일에서 id 가 "update" 인 태그의 SQL문 호출, 호출하며 수정할 데이터를 저장한 객체 member 를 넘김
- session.update() 가 잘 실행되면 1 을 리턴하고, 그걸 result 변수로 받아서 다시 Service 클래스로 돌려줌
- member.xml 에서 수정 처리하는 SQL문 부분 (id 가 update)
<!-- 회원정보 수정 -->
<update id="update" parameterType="member">
update member0609 set name=#{name}, jumin1=#{jumin1}, jumin2=#{jumin2},
mailid=#{mailid}, domain=#{domain}, tel1=#{tel1}, tel2=#{tel2}, tel3=#{tel3},
phone1=#{phone1}, phone2=#{phone2}, phone3=#{phone3}, post=#{post}, address=#{address},
gender=#{gender}, hobby=#{hobby}, intro=#{intro} where id = #{id}
</update>
- DTO 객체 member 가 넘어왔으므로 parameterType 은 전달되는 값의 자료형인 DTO alias 값 member 를 작성
- DTO 객체가 전달될때 DTO 객체 안의 내용을 가져오는 방법 : #{} 안에 DTO 객체의 필드명을 쓴다
ex) #{name} 은 member.getName() 과 같은 의미, #{jumin1} 은 member.getJumin1() 과 같은 의미
- 수정된 데이터 개수를 자동으로 돌려준다, 성공시 1 반환
JSP Model 2 - MyBatis 회원관리 프로그램 : 회원 탈퇴 기능
코드와 흐름 같이 설명
- 탈퇴 폼 + 탈퇴 기능 한번에 설명
- DB 연동이 필요하지 않으므로 main.jsp 에서 '회원탈퇴' 클릭시 Controller 클래스로 가서 바로 View 탈퇴 폼으로 가기
package service;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import dao.MemberDAO;
import model.MemberDTO;
public class Delete implements Action{
@Override
public ActionForward execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
// TODO Auto-generated method stub
System.out.println("Delete");
response.setContentType("text/html; charset=utf-8");
request.setCharacterEncoding("utf-8");
PrintWriter out = response.getWriter();
HttpSession session = request.getSession();
String id = request.getParameter("id");
String passwd = request.getParameter("passwd");
MemberDAO dao = MemberDAO.getInstance();
MemberDTO old = dao.getMember(id);
// 비번 비교
if(old.getPasswd().equals(passwd)) { // 비번 일치시
int result = dao.delete(id);
if(result == 1) System.out.println("회원삭제 성공");
session.invalidate(); // 세션 삭제
}else { // 비번 불일치시
out.println("<script>");
out.println("alert('비번이 일치하지 않습니다.');");
out.println("history.go(-1);");
out.println("</script>");
out.close();
return null;
}
ActionForward forward = new ActionForward();
forward.setRedirect(false);
forward.setPath("/LoginForm.do");
return forward;
}
}
- 회원 삭제(탈퇴) 성공시에 필요한 session 객체, out 객체 생성
- hidden 으로 넘어온 id 값과, 입력양식에서 넘어온 비번 passwd 를 getParameter() 로 받아서 변수 id, passwd 에 저장
- 비번 비교를 위해 DAO의 getMember() 메소드를 호출해서 해당 id 의 회원에 대한 상세정보를 가져온다
- DAO 에서 메소드 호출을 2번 해야한다, 비번을 가져오기 위해 상세정보 가져올때 1번, 회원 삭제할때 1번
<DAO getMember() 에서 돌아온 후>
- old.getPasswd() 는 DB의 비번, passwd 는 사용자가 탈퇴폼에 입력한 비번, 두 비번 일치시 DAO 의 delete() 메소드 호출
- delete() 를 호출하며 id 값을 매개변수로 전달
<DAO update() 에서 돌아온 후>
- 1 을 리턴받으면 성공이라 여기고, "회원삭제 성공" 메세지 출력하고 세션을 삭제한다, SESSION 영역 끝
- 삭제에 성공하면 if-else 문 아래에서 forward 객체를 생성하고 "/LoginForm.do" 로 포워딩 페이지 설정, Dispatcher 방식으로 포워딩 방식 설정
- 삭제에 실패하면 메세지를 출력하고 이전 페이지인 삭제폼으로 이동, return null; 을 추가해서 execute() 를 빠져나가며 아래의 코드를 forward 설정 코드를 실행하지 않도록 함
- 이전 페이지인 삭제폼으로 이동하는데 아래의 forward 설정 코드를 실행하면 오류가 난다. 한번에 두 곳으로 갈 수 없으므로
- MemberDAO.java 에서 getMember() 메소드 부분만
// 회원 1명 정보 구하기 : 수정폼, 수정, 삭제
public MemberDTO getMember(String id) throws Exception{
SqlSession session = getSession();
MemberDTO member = session.selectOne("idcheck", id);
return member;
}
- member.xml 에서 수정 처리하는 SQL문 부분 (id 가 idcheck)
<!-- ID중복검사, 회원인증 -->
<select id="idcheck" parameterType="String" resultType="member">
select * from member0609 where id = #{id}
</select>
- MemberDAO.java 에서 delete() 메소드 부분만
// 회원 탈퇴
public int delete(String id) throws Exception{
int result = 0;
SqlSession session = getSession();
result = session.delete("delete", id);
return result;
}
- delete SQL문을 사용하므로 SqlSession 객체의 메소드 delete() 를 사용해야한다
- Mapper 파일에서 id 가 "delete' 인 SQL문을 호출, 매개변수로는 삭제하고자 하는 회원의 id 값을 넘김
- session.delete() 에서 삭제 성공시 리턴하는 1을 result 변수에 저장 후 다시 Service 클래스로 1 리턴
- member.xml 에서 수정 처리하는 SQL문 부분 (id 가 delete)
<!-- 회원 삭제 -->
<delete id="delete" parameterType="String">
delete from member0609 where id = #{id}
</delete>
- 삭제하고자 하는 회원의 id 값이 넘어오므로 parameterType 은 String 이어야한다
- #{id} : session.delete() 에서 두번째 매개변수로 넘어온 변수 id 의 값을 ${id} 로 가져옴
- 자동으로 삭제된 데이터 개수를 리턴해줌 (성공시 1 리턴)
- main.jsp 에서 '회원탈퇴' 클릭시 콘솔창 (탈퇴 폼)
- 탈퇴 폼에서 맞는 비밀번호를 입력하고 '회원탈퇴' 클릭시
- 탈퇴에 성공하고 로그인 폼으로 포워딩됨
- 탈퇴 폼에서 '회원탈퇴' 클릭해서 회원탈퇴에 성공 했을때 콘솔 창
JSP Model 2 - MyBatis 연동 구조
JSP Model 2 - MyBatis 연동 : 게시판 프로그램
Model 2 과 MyBatis 연동
- 클라우드에서 Model 2 과 MyBatis 가 이미 연동이 완료된 게시판 로그램 mybatisboard 프로젝트 import
- zip 파일을 압축 풀어서 import
- import 하는 프로젝트는 maven 프로젝트이다
- Maven 프로젝트이므로 구조는 다음과 같다
- src/main/java 안에 확장자가 java 인 파일들이 저장되어있다 (Controller, Service, DAO, DTO)
+ Model 2 이므로 src/main/java 안에서도 DTO, DAO, Service, Controller 가 서로 다른 패키지 안에 들어가있음
- src/main/resources 안에 DB 연동에 필요한 MyBatis 환경설정 파일 등이 들어가 있다 (주로 xml 파일들)
- src/main/webapp 안에 View 파일 등이 들어간다
- Maven 프로젝트는 WEB-INF 폴더 안에 lib 폴더가 생성되지 않는다, 대신 pom.xml 에서 라이브러리 추가함
- getSession() 메소드에서는 try 안의 3줄을 통해 SqlSession 객체를 구해준다, 그 객체를 통해 SQL문을 실행하는 메소드들을 사용 가능하다
- Reader 객체를 구할때 MyBatis 환경설정 파일인 mybatis-config,xml 을 불러오고 있다, MyBatis 환경설정 파일에서는 Mapper 파일을 불러옴
- 그렇기 때문에 DAO 에서 Mapper 파일의 id 값을 불러올 수 있다, 즉 Mapper 파일의 SQL문을 불러올 수 있음
- sf.openSession(true) 를 하면 자동 커밋이 된다, 자동 커밋이 되지 않는다면 SQL문을 수행 후 일일히 session.commit() 으로 커밋을 수행해야함
* 커밋을 해야 DB에 실제 삽입, 수정, 삭제 등이 됨
DAO 안에서 id 로 불러와서 SQL문 실행(MemberDao.java 부분)
public int insert(Member member) {
int result = 0;
SqlSession session=null;
try {
session = getSession();
result = session.insert("insert", member);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
- 가장 먼저 getSession() 메소드로 SqlSession 객체를 구한다
- DAO 안의 메소드 안에서 그 SQL문을 실행해야하는데, 이때 SqlSession 에서 지원하는 메소드를 사용한다
- insert() 메소드를 사용해서 id 값인 "insert" 로Mapper 클래스의 insert 문을 불러온다
메소드에서 메소드 첫번째 매개변수에는 id값, 전달될 값이 있다면 두번째 매개변수에 전달될 값을 전달
- 여기서는 전달받은 DTO 객체인 member 를 두번째 매개변수를 통해 전달하고 있음
- insert() 메소드를 실행 후 삽입 성공한 데이터 개수를 자동으로 반환해줌
- 위의 insert() 메소드는 SQL문을 실행시켜주는 메소드 5가지 중 하나이다
SQL문을 실행시켜주는 메소드 5가지(MemberDao.java 부분)
- SQL문에 따라서 메소드가 정해져 있다
- 이 메소드를 지원하는 인터페이스 SqlSession 객체를 구해와야만 이 메소드 5개를 사용 가능하다
- 그래서 위에서 getSession() 메소드로 SqlSession 객체를 구해왔다
+ SqlSession 은 MyBatis 에서 지원되는 인터페이스
- insert SQL문은 insert() 메소드로 실행해야한다, update, delete 도 마찬가지
- 검색되는 결과가 1개인 select 문은 selectOne() 메소드로 실행
- 결과를 Object 형으로 돌려준다, 다운캐스팅
+ Member 는 DTO 클래스 이름이다
- 검색되는 결과가 2개 이상인 selec 문은 selectList() 메소드로 실행
- 결과를 List 로 돌려준다
- insert() / update() / delete() 메소드는 삽입, 수정, 삭제된 데이터 개수를 자동으로 돌려준다
- 메소드 자체적으로 값을 자동으로 돌려주므로 Mapper 파일에서 insert / update / delete 문은 resultType 을 쓰면 안됨
- resultType 은 select 문만 사용가능
<데이터를 1개 검색시>
- selectOne() 메소드를 사용시에는 값을 Object 형 으로 돌려주므로 다운캐스팅 해야한다
- resultType 에는 DTO 객체를 쓴다
<데이터를 2개 이상 검색시>
- 데이터 2개 이상 검색하는 select문에서도 resultType 에는 DTO 객체만 쓴다, List 를 쓰지 않음! 자동으로 리스트를 잡아서 돌려준다
- 일일히 가져와서 DTO 객체 에 setter 메소드로 저장했었지만 이제는 검색된 데이터의 컬럼명과 DTO 프로퍼티명이 같다면 자동으로 순차적으로 DTO 객체에 저장하면서 List 를 만들어서 돌려줌
Mapper 의 insert SQL문을 insert() 메소드로 불러와서 실행(MemberDao.java 부분, 중복)
- update(), delete() 도 마찬가지
public int insert(Member member) {
int result = 0;
SqlSession session=null;
try {
session = getSession();
result = session.insert("insert", member);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
- SqlSession 객체가 있어야 insert() 메소드 사용 가능, 이전에 정의한 getSession() 으로 객체를 받아온다
- insert() 메소드 자체적으로 삽입에 성공한 데이터 개수를 돌려주는 기능이 있으므로 Mapper 파일의 insert에 resultType 을 써선 안됨
- 그렇게 돌려받은 값을 result 변수에 받아서 그 변수를 리턴하고 있음
- insert() 메소드에서 메소드 첫번째 매개변수에는 id값, 전달될 값이 있다면 두번째 매개변수에 전달될 값을 전달
- 여기서는 전달받은 DTO 객체인 member 를 두번째 매개변수를 통해 전달하고 있음
- Mapper 파일의 parameterType 에서도 같은 자료형인 DTO 를 써야함
- Mapper 파일 member.xml 부분
<insert id="insert" parameterType="member">
insert into member22 values (#{id}, #{password})
</insert>
- parameterType 에는 전달될 값의 자료형을 적음, DTO 객체를 전달받아야하므로 alias 로 설정한 별칭인 member 를 적는다
- #{} 안에 DTO 클래스의 필드명을 써서, 값을 가져온다.
- 표기만 이럴뿐 DTO 객체에 직접 접근하는 것이 아니라 getter 메소드로 가져오는 것임
- #{id} 의 의미는 member.getId() 로 리턴받은 값을 의미함
- #{password} 의 의미는 member.getPassword() 로 리턴받은 값을 의미
+ 단점 : 값을 1개만 전달 가능
Mapper 의 select SQL문을 select() 메소드로 불러와서 실행 1(MemberDao.java 부분)
public Member select(String id) throws SQLException {
Member mem = null;
SqlSession session=null;
try { session = getSession();
mem = (Member) session.selectOne("select", id);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return mem;
}
- SqlSession 객체가 있어야 select() 메소드 사용 가능, 이전에 정의한 getSession() 으로 객체를 받아온다
- select() 메소드는 돌려주는 데이터가 몇개인지에 따라 다른 메소드를 쓴다, 1개 데이터를 돌려줄때는 selectOne() 사용
- 두번째 매개변수로 사용자의 id 값을 전달
- 마찬가지로 Mapper 파일의 parameterType 도 String 형으로 설정해야함
- Mapper 파일 member.xml 부분
<select id="select" parameterType="String" resultType="member">
select * from member22 where id = #{id}
</select>
- 넘어오는 값은 사용자의 id 값이므로 paramterType 은 String 으로 설정해야함
- #{id} 의 의미는 전달된 변수 id 값을 가져오는 것임
- 데이터 1개를 돌려주므로 resultType 을 DTO 의 alias 인 member 로 설정
- if(rs.next()) 안에서 수행했던 member.setId(rs.getString("id")) 를 더이상 쓰지 않음, 돌려주는 객체 member 에 자동으로 setter 메소드로 값을 다 저장해서 돌려준다
+ DTO 프로퍼티명과 컬럼명이 일치하는 경우에만 가능
Mapper 의 select SQL문을 select() 메소드로 불러와서 실행2(MemberDao.java 부분)
- 위의 select() 와는 다른 메소드, 이건 로그인 시 회원 인증을 해주는 chk() 메소드이다
public int chk(Member member) {
int result = 0;
SqlSession session=null;
try { session = getSession();
Member mem = (Member) session.selectOne("select", member.getId());
if (mem.getId().equals(member.getId())) {
result = -1;
if (mem.getPassword().equals(member.getPassword())) {
result = 1; // 회원인증 성공
}
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
- 로그인 시 회원인증을 처리하는 부분이다
- mem.getId() 는 DB에 저장된 id 를 의미하고, member.getId()는 사용자가 입력한 id 를 의미
- mem.getPassword() 는 DB에 저장된 password 를 의미하고, member.getPassword()는 사용자가 입력한 password 를 의미
- id, password 가 모두 일치할때는 변수 result 에 1 을 저장해서 리턴함, 이 값으로 로그인 성공을 판별하는 것은 loginPro.jsp 에서 처리함
- id 는 일치하되, passoword 가 일치하지 않을때는 변수 result 에 -1 을 저장해서 리턴, 이것도 loginPro.jsp 에서 처리
- Mapper 파일 member.xml 부분
<select id="select" parameterType="String" resultType="member">
select * from member22 where id = #{id}
</select>
회원가입 기능
Model 1 & MyBatis 회원 가입 흐름
1. 처음 index.jsp 실행 -> loginForm.jsp -> '회원가입' 눌러서 joinForm.jsp 로 넘어감
2. joinForm.jsp 에서 입력된 값을 id, password 네임값에 저장해서 joinPro.jsp 로 전달
3. joinPro.jsp 에서 useBean 과 setProperty 로 DTO 객체 mem 생성 후 값 저장, DAO 객체의 insert(mem) 호출함
4. DAO 에서 insert() 메소드를 실행, 그 안에서 Mapper 파일의 insert SQL문을 id 로 불러온다
- insert() 가 잘 수행되면 1을 돌려줌
5. joinPro.jsp 로 돌아오고, 회원가입 성공 시 loginForm.jsp 로 넘어간다, 실패(중복아이디)시 이전페이지로 이동
public int chk(Member member) {
int result = 0;
SqlSession session=null;
try { session = getSession();
Member mem = (Member) session.selectOne("select", member.getId());
if (mem.getId().equals(member.getId())) {
result = -1;
if (mem.getPassword().equals(member.getPassword())) {
result = 1; // 회원인증 성공
}
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
- member.xml 에서 로그인(회원 인증)을 처리하는 SQL문 부분 (id 가 select)
<select id="select" parameterType="String" resultType="member">
select * from member22 where id = #{id}
</select>
DAO 클래스 상단에서 MyBatis 지원 클래스 / 인터페이스 import
중간 페이지 기능
- 로그인 성공시 이동하는 main.jsp 내용을 보자
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<%
String id = (String) session.getAttribute("id");
if (id == null || id.equals("")) {
response.sendRedirect("loginForm.jsp");
} else if (id.equals("master")) {
out.println("관리자 모드!");
}
%>
<body>
로긴함
<p>
정보수정<br>
<%
if (id != null) {
if (id.equals("master")) {
%>
<a href="list.jsp">회원명단</a><br>
<%
}}
%>
<a href="logout.jsp">로그아웃</a>
</body>
</html>
-로그인 성공시 공유한 공유값id 값을 가져와서 사용
- getAttribute() 로 공유값을 가져올때는 다운캐스팅을 해야함
- 받아온 공유값인 id 가 null 인 경우, Redirect 포워딩 팡식으로 loginForm.jsp 로 넘어감
- 받아온 공유값인 id 가 "master" 인 경우 "관리자 모드!" 라는 메세지가 출력됨
<body 태그 안>
- 받아온 공유값인 id가 "master" 인 경우 "회원명단" 출력, 클릭시 list.jsp 로 이동하도록 설정
- 어느 아이디로 로그인되었느냐에 따라 main.jsp 내용이 달라짐
- '로그아웃' 클릭시 logout.jsp 로 이동 : 세션 삭제, 로그아웃 메세지 출력하고 로그인 폼으로 이동하는 작업을 한다
