레몬팡

JAVA 풀스택 45일차 - Server (JSP MVC)

레몬팡777 — Sun, 31 May 2026 22:22:42 +0900

JSP MVC

1. 구조

View JSP
↓
logincontroller.jsp
↓
DAO
↓
DB
↓
logincontroller.jsp
↓
View JSP 또는 result.jsp

구분	파일/쿨래스	역할
View	index.jsp, adminmain.jsp, usermain.jsp, userinfo.jsp, userlistall.jsp	화면 출력
Controller	logincontroller.jsp	요청을 받아 command에 따라 기능 처리
Model	MyMemberDao, MyMemberDto, DB	DB 처리와 회원 데이터 저장

2. command 값으로 기능 구분

logincontroller.jsp는 command 값을 보고 어떤 기능을 실행할지 결정한다

String command = request.getParameter("command");

command	기능
login	로그인 처리
logout	로그아웃 처리
userlist	회원 전체 조회
userinfo	내 정보 조회
updateform	내 정보 수정 화면 이동
updateuser	내 정보 수정 처리
deleteuser	회원 탈퇴 처리
updateroleform	회원 등급 변경 화면 이동
updaterole	회원 등급 변경 처리

3. 로그인 화면

3-1 index.jsp

index.jsp는 로그인 화면이다

<form action="logincontroller.jsp" method="post">
    <input type="hidden" name="command" value="login">
    <input type="text" name="id">
    <input type="text" name="pw">
    <input type="submit" value="login">
</form>

- 사용자가 입력한 아이디와 비밀번호를 logincontroller.jsp로 전송한다.

hidden input은 화면에는 보이지 않지만, Controller에게 로그인 기능을 실행하라고 알려준다

4. 로그인 처리

4-1 Controller에서 id, pw 받기

로그인 버튼을 누르면 logincontroller.jsp에서 값을 받는다

String id = request.getParameter("id");
String pw = request.getParameter("pw");

- request.getParameter()는 form에서 전달된 값을 꺼낼 때 사용

index.jsp form 입력
↓
logincontroller.jsp
↓
id, pw 받기

4-2 DAO login 실행

Controller는 받은 id, pw를 DAO로 전달한다

MyMemberDto dto = dao.login(id, pw);

- DAO의 login() 메서드는 DB에서 아이디, 비밀번호, 가입 여부를 확인

String sql =
" SELECT * FROM MYMEMBER " +
" WHERE MYID=? AND MYPW=? AND MYENABLED=? ";

- 아이디와 비밀번호가 일치하고, MYENABLED가 "Y"인 회원만 조회한다 / 탈퇴하지 않은 정상 회원만 로그인 할 수 있다

5. MyMemberDto

MyMemberDto는 회원 한 명의 정보를 저장하는 객체이다

private int myno;
private String myid;
private String mypw;
private String myname;
private String myaddr;
private String myphone;
private String myemail;
private String myenabled;
private String myrole;

- 로그인 성공 시 DB에서 조회한 회원 정보가 MyMemberDto 객체에 저장

6. 로그인 성공 처리

6-1 로그인 성공 판단

if(dto.getMyid() != null) {
    ...
}

- dto.getMyid()가 null이 아니라면 DB에서 일치하는 회원을 찾았다는 뜻

아이디 / 비밀번호 / 가입 여부 조건 일치
↓
로그인 성공

6-2 session에 로그인 정보 저장

로그인 성공 시 회원 정보를 session에 저장한다

session.setAttribute("dto", dto);

- 로그인한 회원 정보를 dto라는 이름으로 session에 저장

session에 저장하면 다른 JSP에서도 로그인한 사용자 정보를 사용할 수 있다

6-3 session 유지 시간 설정

session.setMaxInactiveInterval(60*60);

- session 유지 시간(로그인 정보 유지 시간)을 60*60(s) 동안 진행한다

7. Session

Session은 서버가 사용자별로 정보를 저장하는 공간이다

로그인 성공
↓
session에 사용자 정보 저장
↓
다른 JSP에서도 로그인 상태 확인 가능

8. 권한별 페이지 이동

로그인 성공 후 회원 등급에 따라 이동하는 페이지가 달라진다

if(dto.getMyrole().equals("ADMIN")) {
    response.sendRedirect("adminmain.jsp");
} else if(dto.getMyrole().equals("USER")) {
    response.sendRedirect("usermain.jsp");
}

등급	이동페이지
ADMIN	adminmain.jsp
USER	usermain.jsp

9. 관리자 메인 페이지

9-1 adminmain.jsp

adminmain.jsp는 관리자 로그인 후 이동하는 메인 화면이다

MyMemberDto dto = (MyMemberDto)session.getAttribute("dto");

- session에서 로그인 정보를 꺼낸

9-2 로그인하지 않은 사용자 막기

if(dto == null) {
    pageContext.forward("index.jsp");
    return;
}

- session에 dto가 없으면 로그인하지 않은 사용자이다.

session에 dto 없음
↓
로그인하지 않음
↓
index.jsp로 이동

9-3 관리자 정보 출력

<span><%=dto.getMyname() %>님 환영합니다.(등급: <%=dto.getMyrole() %>)</span>

- JSP 표현식 <%= %>을 사용해서 로그인한 관리자의 이름과 등급을 화면에 출력

10. 사용자 메인 페이지

10-1 usermain.jsp

usermain.jsp는 일반 회원이 로그인 후 이동하는 메인 화면이다

<%
	MyMemberDto dto = (MyMemberDto)session.getAttribute("dto");
	if(dto == null){
		pageContext.forward("index.jsp");
		return;
	}
%>

<span><%=dto.getMyname() %>님 환영합니다.(등급: <%=dto.getMyrole() %>)</span>

- session에 로그인 정보가 있다면 사용자 이름과 등급을 출력

11. 로그아웃 기능

11-1 로그아웃 요청

관리자 메인과 사용자 메인에는 로그아웃 버튼이 있다

<button onclick="location.href='logincontroller.jsp?command=logout'">로그아웃</button>

- 버튼 터치 시 Controller로 로그아웃 요청을 보낸

11-2 session.invalidate()

Controller에서 로그아웃 요청을 받으면 session을 삭제한다

if (command.equals("logout")){
		session.invalidate();
}

- 현재 session에 저장된 정보를 모두 삭제

11-3 로그아웃 결과 처리

request.setAttribute("msg", "로그아웃 완료");
request.setAttribute("url", "index.jsp");
pageContext.forward("result.jsp");

- 로그아웃 후 result.jsp로 이동해서 메시지를 출력하고, 확인 버튼을 누르면 다시 로그인 페이지로 이동한다

12. result.jsp

result.jsp는 공통 결과 페이지이다

로그인 실패, 로그아웃 완료, 내 정보 수정, 회원 탈퇴, 등급 변경 결과를 출력할 때 사용한다

String msg = (String)request.getAttribute("msg");
String url = (String)request.getAttribute("url");

- Controller에서 저장한 메시지와 이동 주소를 꺼낸다

<h1><%=msg %></h1>
<button onclick="location.href='<%=url%>'">확인</button>

13. 관리자 회원 전체 조회

13-1 adminmain.jsp 요청

adminmain.jsp에는 회원 전체 조회 링크가 있다

<a href="logincontroller.jsp?command=userlist">회원 정보 조회(all)</a>

- Controller로 회원 전체 조회 요청을 보낸다

13-2 Controller에서 회원 목록 조회

List<MyMemberDto> list = dao.selectAll();

request.setAttribute("list", list);
pageContext.forward("userlistall.jsp");

- Controller는 DAO를 통해 전체 회원 목록을 조회하고, 그 결과를 list라는 이름으로 request에 저장한 뒤 userlistall.jsp로 forward한다

13-3 DAO selectAll()

DAO의 selectAll()은 MYMEMBER 테이블의 전체 회원을 조회한다

String sql = " SELECT * FROM MYMEMBER ORDER BY MYNO DESC ";

14. userlistall.jsp

userlistall.jsp는 관리자용 회원 전체 조회 화면이다

MyMemberDto dto = (MyMemberDto)session.getAttribute("dto");

if(dto == null) {
    pageContext.forward("index.jsp");
    return;
}

- session에 로그인 정보가 없으면 로그인 페이지로 보낸다

List<MyMemberDto> list =
    (List<MyMemberDto>)request.getAttribute("list");

- Controller에서 넘긴 회원 목록을 꺼낸다

for(MyMemberDto m : list) {
    ...
}

- 반복문을 통해 회원 정보 출력

15. 마이페이지

15-1 내 정보 조회 요청

사용자 메인에서 내 정보 보기를 누르면 Controller로 이동한다

<a href="logincontroller.jsp?command=userinfo&myno=<%=dto.getMyno() %>">내정보 보기</a>

- Controller에게 현재 로그인한 사용자의 정보를 조회해 달라고 요청

16-2 Controller에서 selectUser 실행

int myno = Integer.parseInt(request.getParameter("myno"));
MyMemberDto dto = dao.selectUser(myno);

request.setAttribute("dto", dto);
pageContext.forward("userinfo.jsp");

- DAO의 selectUser()는 회원 번호를 기준으로 회원 한 명의 정보를 조회한다

myno 받기
↓
dao.selectUser(myno)
↓
request에 dto 저장
↓
userinfo.jsp로 forward

15-3 userinfo.jsp

userinfo.jsp는 마이페이지 화면이다

MyMemberDto info = (MyMemberDto)request.getAttribute("dto");

- Controller에서 넘긴 회원 정보를 꺼낸다

<%=info.getMyid() %>
<%=info.getMyname() %>
<%=info.getMyaddr() %>
<%=info.getMyphone() %>
<%=info.getMyemail() %>
<%=info.getMyrole() %>

- JSP 표현식으로 회원 정보를 출력

<input type="button" value="수정" onclick="updateUser(<%=info.getMyno()%>)">
<input type="button" value="탈퇴" onclick="deleteUser(<%=info.getMyno()%>)">
<input type="button" value="목록" onclick="location.href='usermain.jsp'">

- 마이페이지에 수정, 탈퇴, 목록 버튼이 있다

16. 내 정보 수정 기능

16-1 수정 화면 이동

마이페이지에서 수정 버튼을 누르면 JavaScript 함수가 실행된다

function updateUser(myno){
    let con = window.confirm("회원 정보 수정을 하시겠습니까?");
    if(con){
        location.href="logincontroller.jsp?command=updateform&myno="+myno;
    }
}

- 확인 버튼을 누르면 Controller로 이동

16-2 Controller에서 기존 정보 조회

int myno = Integer.parseInt(request.getParameter("myno"));
MyMemberDto dto = dao.selectUser(myno);

request.setAttribute("dto", dto);
pageContext.forward("updateuser.jsp");

- 기존 회원 정보를 조회해서 updateuser.jsp로 넘긴다

16-3 updateuser.jsp

updateuser.jsp는 내 정보 수정 화면이다

MyMemberDto dto = (MyMemberDto)request.getAttribute("dto");

<input type="text" name="myaddr" value="<%=dto.getMyaddr() %>">
<input type="text" name="myphone" value="<%=dto.getMyphone() %>">
<input type="text" name="myemail" value="<%=dto.getMyemail() %>">

- 주소, 전화번호, 이메일은 수정 가능하므로 input에 기존 값을 넣어준다

16-4 Controller에서 수정값 받기

수정 완료 버튼을 누르면 logincontroller.jsp로 값이 전달된다

int myno = Integer.parseInt(request.getParameter("myno"));
String myaddr = request.getParameter("myaddr");
String myphone = request.getParameter("myphone");
String myemail = request.getParameter("myemail");

MyMemberDto dto = new MyMemberDto();
dto.setMyaddr(myaddr);
dto.setMyphone(myphone);
dto.setMyemail(myemail);
dto.setMyno(myno);

- 수정에 필요한 값들을 DTO에 담는

16-5 DAO updateUser()

Controller는 DTO를 DAO로 전달한다

boolean res = dao.updateUser(dto);

DAO의 updateUser()는 회원 번호를 기준으로 주소, 전화번호, 이메일을 수정한다

String sql =
" UPDATE MYMEMBER SET MYADDR=?, MYPHONE=?, MYEMAIL=? WHERE MYNO=? ";

- 수정 성공 시 commit(), 실패 시 rollback()을 실행하고, 성공 여부를 boolean으로 반환

17. 회원 탈퇴 기능

17-1 탈퇴 요청

마이페이지에서 탈퇴 버튼을 누르면 JavaScript 함수가 실행된다

function deleteUser(myno){
    location.href="logincontroller.jsp?command=deleteuser&myno="+myno;
}

17-2 Controller에서 탈퇴 처리

회원 번호를 받아 DAO의 탈퇴 메서드를 실행한다

int myno = Integer.parseInt(request.getParameter("myno"));
boolean res = dao.deleteMemeber(myno);

17-3 DAO deleteMember()

회원 탈퇴는 실제로 DB에서 행을 삭제하는 것이 아닌 DAO에서 MYENABLED 값을 "N"으로 변경한다

String sql =
" UPDATE MYMEMBER SET MYENABLED = 'N' WHERE MYNO=? ";

MYENABLED = 'Y' → 가입
MYENABLED = 'N' → 탈퇴

17-4 탈퇴 결과 처리

탈퇴 성공 시

request.setAttribute("msg","회원 탈퇴 성공");
request.setAttribute("url","logincontroller.jsp?command=logout");

회원 탈퇴 성공
↓
logout 요청
↓
session 삭제
↓
index.jsp 이동

- 탈퇴 성공 후에는 로그아웃을 실행하도록 보낸다

탈퇴 실패 시

request.setAttribute("msg","회원 탈퇴 실패");
request.setAttribute("url","usermain.jsp");

18. 회원 등급 변경 기능

18-1 관리자 회원 목록에서 등급 변경 요청

userlistall.jsp에는 회원마다 등급 변경 버튼이 있다

<button onclick="updateRole(<%=m.getMyno()%>)">변경</button>

const updateRole = (myno)=>{
    location.href="logincontroller.jsp?command=updateroleform&myno="+myno;
}

18-2 Controller에서 회원 정보 조회

int myno = Integer.parseInt(request.getParameter("myno"));
MyMemberDto dto = dao.selectUser(myno);

request.setAttribute("selectone", dto);
pageContext.forward("updateroleform.jsp");

- 등급을 변경할 회원의 정보를 조회하고, updateroleform.jsp로 보낸다

18-3 updateroleform.jsp

updateroleform.jsp는 회원 등급 변경 화면이다

MyMemberDto tmp = (MyMemberDto)request.getAttribute("selectone");

- controller에서 넘긴 회원 정보를 꺼낸다

<select name="myrole">
    <option value="USER">일반회원</option>
    <option value="MANAGER">매니저</option>
    <option value="ADMIN">관리자</option>
</select>

- select 태그로 등급을 선택한다

18-4 Controller에서 등급 변경 처리

int myno = Integer.parseInt(request.getParameter("myno"));
String myrole = request.getParameter("myrole");

int res = dao.updateRole(myno, myrole);

- 회원 번호와 변경할 등급을 받아 DAO로 전달한다

18-5 DAO updateRole()

DAO의 updateRole()은 회원 번호를 기준으로 회원 등급을 수정한다

String sql = " UPDATE MYMEMBER SET MYROLE=? WHERE MYNO=? ";

JAVA 풀스택 44일차 - Server (JSP MVC)

레몬팡777 — Fri, 29 May 2026 08:44:47 +0900

JSP 게시판 MVC 기능 구현

상세 조회 / 글쓰기 / 등록 / 수정 / 삭제

1. command 값으로 기능 구분

Controller가 어떤 기능을 실행할지 결정한다.

command=boardlist        → 목록 조회
command=boarddetail      → 상세 조회
command=boardinsertform  → 글쓰기 화면 이동
command=boardinsert      → 게시글 등록
command=boardupdateform  → 수정 화면 이동
command=boardupdate      → 게시글 수정
command=boarddelete      → 게시글 삭제

if(command.equals("boarddetail")) {
    ...
} else if(command.equals("boardinsertform")) {
    ...
} else if(command.equals("boardinsert")) {
    ...
}

- command는 Controller에게 전달하는 기능 이름이다

2. 상세 조회 기능

게시글 목록에서 제목을 클릭하면 상세보기로 이동

<a href="mycontroller.jsp?command=boarddetail&seq=<%=dto.getSeq()%>">
    <%=dto.getTitle() %>
</a>

mycontroller.jsp?command=boarddetail&seq=글번호

부분	의미
mycontroller.jsp	Controller JSP로 요청
command=boarddetail	상세 조회 기능 실행 요청
seq=글번호	몇 번 글인지 전달

2-1 파라미터가 2개일 때

URL 파라미터가 여러 개일 때는 &로 연결

mycontroller.jsp?command=boarddetail&seq=3

구분	의미
?command=boarddetail	첫 번째 파라미터
&seq=3	두 번째 파라미터

?는 파라미터 시작, &는 파라미터 추가

3. boarddetail.jsp에서 상세 내용 출력

boarddetail.jsp는 Controller가 넘긴 dto를 꺼낸다.

MVCBoardDto dto = (MVCBoardDto)request.getAttribute("dto");

<%=dto.getSeq() %>
<%=dto.getWriter() %>
<%=dto.getTitle() %>
<%=dto.getContent() %>

- JSP 표현식으로 화면에 출력

boardlist.jsp
↓
제목 클릭
↓
mycontroller.jsp?command=boarddetail&seq=글번호
↓
dao.selectOne(seq)
↓
request.setAttribute("dto", res)
↓
boarddetail.jsp
↓
상세 내용 출력

4. 글쓰기 화면 이동 기능

목록 페이지에서 글쓰기 버튼을 누르면 Controller로 이동한다

<input type="button" value="글쓰기"
       onclick="location.href='mycontroller.jsp?command=boardinsertform'">

- Controller에서는 boardinsertform 요청을 받으면 글쓰기 페이지로 이동

response.sendRedirect("boardinsert.jsp");

- 글쓰기 화면으로 단순 이동만 하면 되기에 redirect 사용

조회한 데이터를 request에 담아 보낼 필요 없음
→ redirect 사용 가능

5. boardinsert.jsp

5-1 글쓰기 form

boardinsert.jsp는 사용자가 글을 작성하는 화면

<form action="mycontroller.jsp" method="post">

- 입력 값을 mycontroller.jsp로 보낸다

5-2 hidden으로 command 전달

<input type="hidden" name="command" value="boardinsert">

숨겨진 input을 통해 command 값을 Controller로 전달한다.

5-3 입력값 name 속성

사용자가 입력하는 값들은 각각 name을 가진다

<input type="text" name="writer">
<input type="text" name="title">
<textarea rows="10" cols="60" name="content"></textarea>

Controller에서 값을 꺼낼 때 name 값을 사용

request.getParameter("writer");
request.getParameter("title");
request.getParameter("content");

6. 게시글 등록 처리

6-1 Controller에서 form 값 받기

등록 버튼을 누르면 form 데이터가 mycontroller.jsp로 전송

Controller에서는 command=boardinsert를 확인하고 글 등록을 처리

String writer = request.getParameter("writer");
String title = request.getParameter("title");
String content = request.getParameter("content");

- form에서 입력한 작성자, 제목, 내용을 Controller에서 받는다.

6-2 DTO 객체 생성

받은 값을 DTO 객체에 담는다.

MVCBoardDto dto = new MVCBoardDto(0, writer, title, content, null);

6-3 DAO insert 실행

Controller는 DTO를 DAO로 전달한다.

int res = dao.insert(dto);

- DAO에서 INSERT 작업을 실행하고, 결과를 res로 돌려준다

res > 0 → 등록 성공
res == 0 → 등록 실패

7. result.jsp 공통 결과 페이지

등록, 수정, 삭제 결과는 result.jsp에서 공통으로 출력한다.

msg = 글 작성 완료
url = ?command=boardlist

request.setAttribute("msg", msg);
request.setAttribute("url", url);
pageContext.forward("result.jsp");

- Controller에서는 메시지와 이동할 주소를 request에 저장한다.

String msg = (String)request.getAttribute("msg");
String url = (String)request.getAttribute("url");

- result.jsp에서는 이 값을 꺼낸다

<button onclick="location.href='mycontroller.jsp<%=url%>'">확인</button>

- 메시지를 출력하고, 확인 버튼을 누르면 다시 Controller로 이동한다.

값	의미
msg	화면에 출력할 메시지
url	확인 버튼 클릭 시 이동할 주소

8. 게시글 수정 화면

8-1 boardupdate.jsp

boardupdate.jsp는 게시글 수정 화면

수정 화면은 빈 입력창을 보여주는 것이 아니라, 기존 게시글 내용을 먼저 가져와서 form 안에 출력한다.

Controller에서 기존 게시글 조회
↓
request.setAttribute("dto", dto)
↓
boardupdate.jsp로 forward
↓
boardupdate.jsp에서 dto 꺼내기
↓
form에 기존 값 출력

8-2 기존 값 출력

수정 화면에서는 form 안에 기존 내용을 넣어준다

<input type="text" name="title" value="<%=dto.getTitle() %>">

- 기존 제목을 input 태그 안에 출력한다

9. hidden input

<input type="hidden" name="command" value="boardupdate">
<input type="hidden" name="seq" value="<%=dto.getSeq()%>">

hidden은 화면에는 보이지 않지만, submit할 때 함께 전송되는 값이다

hidden 값	의미
command=boardupdate	Controller에게 수정 기능 실행 요청
seq=게시글번호	몇 번 글을 수정할지 전달

10. 게시글 수정 처리

수정 버튼을 누르면 form 데이터가 Controller로 전송된다.

command = boardupdate
seq = 게시글 번호
title = 수정한 제목
content = 수정한 내용

- 전송되는 값

command=boardupdate 확인
↓
seq, title, content 값 받기
↓
DTO 객체 생성
↓
dao.update(dto)
↓
결과에 따라 msg, url 저장
↓
result.jsp로 forward

- Controller에서는 boardupdate 요청을 확인한 뒤 값을 받는다.

MVCBoardDto dto = new MVCBoardDto(seq, null, title, content, null);

- 작성자와 작성일은 수정하지 않으므로 null로 둔다

String sql = " UPDATE MVCBOARD SET TITLE=?, CONTENT=? WHERE SEQ=? ";

값	의미
seq	수정할 게시글 번호
title	수정한 제목
content	수정한 내용

11. 게시글 삭제 처리

흐름

삭제 버튼 클릭
↓
mycontroller.jsp?command=boarddelete&seq=게시글번호
↓
Controller에서 seq 받기
↓
dao.delete(seq)
↓
결과에 따라 result.jsp로 이동

int seq = Integer.parseInt(request.getParameter("seq"));

- Controller에서는 seq를 받아 숫자로 변환

String sql = " DELETE FROM MVCBOARD WHERE SEQ=? ";

- 삭제에 필요한 것은 게시글 번호 한 개이므로 한 개만 받아온다

url = ?command=boardlist

- 삭제 성공 시 목록으로 이동하도록 url 설정

JAVA 풀스택 43일차 - Server(JSP CRUD / MVC)

레몬팡777 — Thu, 28 May 2026 08:50:11 +0900

JSP 게시판 CRUD 기능 구현

1. JSP 게시판 전체 흐름

mylist.jsp
 ├─ 상세 조회 → selectone.jsp
 ├─ 글쓰기 → myinsert.jsp → myinsert_res.jsp
 ├─ 수정 → myupdate.jsp → myupdate_res.jsp
 └─ 삭제 → mydelete.jsp

JSP 파일	역할
mylist.jsp	게시글 목록 출력, 상세/글쓰기 페이지로 이동
selectone.jsp	게시글 번호를 받아 상세 내용 출력
myinsert.jsp	글쓰기 입력 form 화면
myinsert_res.jsp	입력값을 받아 DB에 게시글 등록
myupdate.jsp	기존 게시글 내용을 수정 form에 출력
myupdate_res.jsp	수정된 값을 받아 DB UPDATE 실행
mydelete.jsp	게시글 번호를 받아 DB DELETE 실행

2. 상세 조회 기능

2-1 mylist.jsp에서 상세페이지로 이동

<a href="./selectone.jsp?myno=<%= list.get(i).getMyno() %>">
    <%= list.get(i).getMytitle() %>
</a>

<%= %>을 이용하여 HTML안에서 Java 코드를 구현 및 JSP라는 것을 알 수 있다.

3. URL 파라미터 전달

URL 파라미터는 URL 뒤에 값을 붙여서 다른 페이지로 전달하는 방식

페이지주소?이름=값

selectone.jsp?myno=5

- selectone.jsp로 이동하면서 myno라는 이름으로 5를 전달

부분	의미
selectone.jsp	이동할 JSP 페이지
?	파라미터 시작
myno	전달할 값의 이름
5	전달할 실제 값

4. 전달된 파라미터 받기

다른 JSP에서 전달한 값은 request.getParameter()로 받는다

<%
    int myno = Integer.parseInt(request.getParameter("myno"));
%>

4-1 request.getParameter()

request.getParameter("myno")

myno라는 이름으로 전달된 값을 가져온다.

만약 주소가

selectone.jsp?myno=5

라면 request.getParameter("myno")의 결과는 5로 전달된다.

4-2 Integet.parseInt()

request.getParameter()로 받은 값은 문자열이다.

하지만 게시글 번호는 숫자로 사용해야함으로 문자열을 int로 변환해야 한다.

int myno = Integer.parseInt(request.getParameter("myno"));

5. selectone.jsp와 selectOne()

selectone.jsp에서는 전달받은 myno를 이용해 DAO의 selectOne()을 실행

<%
    int myno = Integer.parseInt(request.getParameter("myno"));

    MyBoardDao dao = new MyBoardDao();
    MyBoardDto dto = dao.selectOne(myno);
%>

흐름

1. URL로 전달된 myno 값 받기
2. 문자열을 숫자로 변환
3. DAO 객체 생성
4. dao.selectOne(myno) 실행
5. 조회 결과를 DTO에 저장
6. DTO 값을 JSP 화면에 출력

6. 글쓰기 기능

6-1 myinsert.jsp

myinsert.jsp는 게시글을 작성하는 입력 화면이다

<form action="myinsert_res.jsp" method="post">
    <input type="text" name="myname">
    <input type="text" name="mytitle">
    <textarea rows="10" cols="60" name="mycontent"></textarea>

    <input type="submit" value="입력">
    <input type="button" value="취소" onclick="history.back();">
</form>

- J SP 페이지에서 사용자 입력 화면을 만들고, 입력값을 다른 JSP로 전송한다.

6-2 form 태그

<form action="myinsert_res.jsp" method="post">

속성	의미
action	입력값을 처리할 JSP 페이지
method	값을 보내는 방식

7. 게시글 등록 기능

7-1 myinsert_res.jsp

글쓰기 form에서 전달된 값을 받아 DB에 저장하는 처리용 JSP이다.

form 값 받기
↓
DTO 객체 생성
↓
DAO insert 실행
↓
결과에 따라 alert 출력
↓
목록으로 이동

7-2 JSP에서 form 값 받기

myinsert.jsp에서 보낸 값을 request.getParameter()로 받는다.

<%
    String name = request.getParameter("myname");
    String title = request.getParameter("mytitle");
    String content = request.getParameter("mycontent");
%>

7-3 JSP에서 DTO 생성

form에서 받은 값을 DTO 객체에 담는다

<%
    MyBoardDto dto = new MyBoardDto(0, name, title, content, null);
%>

값	의미
0	게시글 번호는 DB 시퀀스가 자동 생성
null	작성일은 DB에서 SYSDATE로 자동 저장

7-4 DAO insert 실행

JSP에서 DAO 객체를 만들고 insert()를 실행한다.

<%
    MyBoardDao dao = new MyBoardDao();
    int res = dao.insert(dto);
%>

- executeUpdate() 실행 결과가 res에 저장되고, res > 0이면 등록 성공

String sql =
" INSERT INTO MYBOARD VALUES(SEQ_MYBOARD.NEXTVAL,?,?,?, SYSDATE) ";

7-5 JSP에서 등록 결과 처리

<%
    if(res > 0){
%>
    <script type="text/javascript">
        alert("게시글 등록 성공");
        location.href="mylist.jsp";
    </script>
<%
    } else {
%>
    <script type="text/javascript">
        alert("게시글 등록 실패");
        location.href="mylist.jsp";
    </script>
<%
    }
%>

서버에서 JSP의 if문 실행
↓
성공이면 성공 alert 스크립트 생성
실패이면 실패 alert 스크립트 생성
↓
브라우저에서 JavaScript 실행
↓
알림창 출력 후 페이지 이동

8. 게시글 수정 기능

8-1 myupdate.jsp 역할

수정 form에서 넘어온 값을 받아 DB에 UPDATE를 실행하는 JSP

<%
    int no = Integer.parseInt(request.getParameter("myno"));
    String title = request.getParameter("mytitle");
    String content = request.getParameter("mycontent");
%>

8-2 수정용 DTO 생성

<%
    MyBoardDto dto = new MyBoardDto(no, null, title, content, null);
%>

작성자, 작성일은 그대로 유지하기에 null로 둔다

8-3 DAO update 실행

<%
    int res = new MyBoardDao().update(dto);
%>

String sql = " UPDATE MYBOARD SET MYTITLE=?, MYCONTENT=? WHERE MYNO=? ";

8-4 JSP에서 수정 결과 처리

수정 성공 시

<script type="text/javascript">
    alert("게시글 수정 성공");
    location.href="selectone.jsp?myno=<%=dto.getMyno() %>";
</script>

- 수정된 글의 상세 페이지로 이동

수정 실패 시

<script type="text/javascript">
    alert("게시글 수정 실패");
    location.href="myupdate.jsp?myno=<%=dto.getMyno() %>";
</script>

- 다시 수정 패이자로 이동

9. 게시글 삭제 기능

9-1 mydelete.jsp

게시글 번호를 받아 DB에서 해당 글을 삭제하는 처리용 JSP

<%
    int myno = Integer.parseInt(request.getParameter("myno"));
    int res = new MyBoardDao().delete(myno);
%>

1. URL 파라미터로 myno 받기
2. 숫자로 변환
3. dao.delete(myno) 실행
4. 결과에 따라 JavaScript 출력

9-2 DAO delete 실행

String sql = " DELETE FROM MYBOARD WHERE MYNO=? ";

9-3 JSP에서 삭제 결과 처리

삭제 성공 시

<script type="text/javascript">
    alert("게시글 삭제 성공");
    location.href="mylist.jsp";
</script>

- 목록 페이지로 이동

삭제 실패 시

<script type="text/javascript">
    alert("게시글 삭제 실패");
    location.href="selectone.jsp?myno=<%=myno%>";
</script>

- 다시 상세 페이지로 이동

JSP 게시판 MVC 기능 구현

게시판 목록 조회

1. JSP MVC 구조

구분	파일	역할
View	index.html, boardlist.jsp	사용자가 보는 화면
Controller	mycontroller.jsp	요청을 받아 어떤 기능을 실행할지 판단
Model	MVCBoardDao, MVCBoardDto, DB	데이터 조회와 저장

2. index.html

처음 접속하는 메인 화면

<a href="mycontroller.jsp?command=boardlist">글 목록</a>

- 이 링크를 클릭하면 boardlist.jsp로 바로 가는 것이 아니라, 먼저 mycontroller.jsp로 이동한다

부분	의미
mycontroller.jsp	요청을 받을 Controller JSP
?	파라미터 전달 시작
command	요청 이름
boardlist	게시글 목록 조회 기능

3. command 파라미터

어떤 기능을 실행하지 알려주는 값

mycontroller.jsp?command=boardlist

- boardlist 기능을 실행시키라는 의미

4. mycontroller.jsp

Controller 역할을 하는 JSP

<%
    String command = request.getParameter("command");
%>

request.getParameter("command")는 URL로 전달된 command 값을 가져온다.

5. Controller에서 기능 구분

command 값에 따라 실행할 기능을 결정

<%
    MVCBoardDao dao = new MVCBoardDao();

    if(command.equals("boardlist")){
        List<MVCBoardDto> list = dao.selectAll();

        request.setAttribute("allList", list);

        pageContext.forward("boardlist.jsp");
    }
%>

흐름

1. command 값 확인
2. command가 "boardlist"인지 확인
3. DAO 객체 생성
4. dao.selectAll() 실행
5. DB에서 게시글 목록 조회
6. 조회 결과를 request에 저장
7. boardlist.jsp로 forward

mycontroller.jsp는 게시글을 직접 출력하지 않고, 게시글 목록 데이터를 준비한 뒤 boardlist.jsp에게 넘긴다

6. DAO 목록 조회

public List<MVCBoardDto> selectAll()

String sql = " SELECT * FROM MVCBOARD ORDER BY SEQ DESC ";

- MVCBOARD 테이블의 모든 게시글을 조회한다. SEQ 번호가 큰 순서대로 정렬한다

while(rs.next()) {
    MVCBoardDto tmp = new MVCBoardDto();

    tmp.setSeq(rs.getInt(1));
    tmp.setWriter(rs.getString(2));
    tmp.setTitle(rs.getString(3));
    tmp.setContent(rs.getString(4));
    tmp.setRegdate(rs.getDate(5));

    res.add(tmp);
}

- 조회 결과는 MVCBoardDto 객체에 담고, 여러 개의 DTO를 List에 저장

7. MVCBoardDto

게시글 하나의 데이터를 저장하는 객체

private int seq;
private String writer;
private String title;
private String content;
private Date regdate;

8. request.setAttribute()

Controller에서 조회한 게시글 목록은 바로 화면에 출력하지 않고, request 객체에 담아서 View JSP로 전달

request.setAttribute("allList", list);

- list 데이터를 allList라는 이름으로 request에 저장한다.

9. pageContext.forward()

Controller에서 데이터를 request에 담은 뒤, 화면을 출력할 JSP로 이동

pageContext.forward("boardlist.jsp");

- boardlist.jsp로 화면 처리를 넘기는 코드

forward 사용 시 request에 담은 값이 유지된다.

mycontroller.jsp
↓ request에 allList 저장
↓ forward
boardlist.jsp
↓ request에서 allList 꺼내 사용 가능

10. boardlist.jsp

View 역할을 하는 JSP

<%
    List<MVCBoardDto> list =
        (List<MVCBoardDto>)request.getAttribute("allList");
%>

- getAttribute()는 Object 타입으로 값을 반환하기 때문에, 원래 타입인 List<MVCBoardDto>로 형변환

11. 게시글 처리

11-1 게시글이 없을 경우

<%
    if(list.size()==0){
%>
    <tr>
        <td colspan="4">---- 글이 존재하지 않습니다 ----</td>
    </tr>
<%
    }
%>

- list에 게시글이 하나도 없으면 "글이 존재하지 않습니다" 출력

11-2 게시글이 있을 경우

<%
    for(MVCBoardDto dto : list){
%>
    <tr>
        <td><%=dto.getSeq() %></td>
        <td><%=dto.getWriter() %></td>
        <td><%=dto.getTitle() %></td>
        <td><%=dto.getRegdate() %></td>
    </tr>
<%
    }
%>

12. forward / redirect 차이

forward

서버 내부에서 페이지 이동
request 값 유지
주소창 변경 없음

Controller에서 request에 담은 allList를 View에서 그대로 사용할 수 있다.

redirect

브라우저가 새로운 페이지를 다시 요청
request 값 유지 안 됨
주소창 변경됨

redirect는 새로운 요청이기 때문에 기존 request에 담은 값이 사라진다.

JAVA 풀스택 42일차 - Server(JSP)

레몬팡777 — Wed, 27 May 2026 08:46:52 +0900

JSP(Java Server Pages)

HTML 안에 JAVA 코드를 넣어서 동적으로 웹페이지를 만들어주는 기술

HTML = 화면 작성
Java = 데이터 처리
JSP = Java로 처리한 결과를 HTML 화면에 출력

1. HTML 한계

HTML은 화면을 만드는 언어이다.

<h1>게시판</h1>
<p>안녕하세요</p>

위와 같이 사용하면 브라우저에 글자가 나온다.

하지만 HTML은 정적인 화면으로 항상 똑같은 내용만 보여준다.

하지만 실제 웹사이트에서는

- 새로 작성된 글

- 사용자가 검색한 글

- 로그인한 사용자의 이름

등 웹사이트의 내용이 바뀐다.

이런 내용은 HTML만으로는 만들기 어렵다.

이런 데이터는 보통 DB에 저장되어 있고 화면에 보여주기 위해서는 JAVA와 같은 프로그램을 통해 데이터를 가져와야 한다.

2. JSP 역할

HTML 화면을 만들면서, 필요할 때 Java 코드를 실행해서 데이터를 가져올 수 있다.

Java로 데이터 처리
+
HTML로 화면 출력

JSP는 Java와 HTML을 연결해서 동적인 웹 페이지를 만드는 역할을 한다.

3. JSP 실행 위치

JSP는 브라우저가 아닌 서버에서 실행된다.

사용자 브라우저
↓ 요청
서버
↓ JSP 실행
Java 코드 처리
↓
HTML 결과 생성
↓ 응답
사용자 브라우저

사용자는 JSP 코드를 직접 보는 것이 아니라, 서버가 JSP를 실행한 뒤 만들어낸 HTML 결과 화면을 보게 된다.

4. JSP 흐름

1. 사용자가 브라우저에서 JSP 페이지 요청
2. 서버가 JSP 파일을 실행
3. JSP 안의 Java 코드가 실행
4. 필요한 데이터를 DB나 Java 객체에서 가져옴
5. 가져온 데이터를 HTML에 넣음
6. 완성된 HTML을 브라우저로 보냄
7. 사용자는 완성된 웹 화면을 봄

서버에서 JAVA 코드를 실행한 결과로 화면을 만들어준다.

구분	HTML	JSP
역할	화면 작성	Java로 처리한 결과를 화면에 출력
내용 변화	고정적	데이터에 따라 변경 가능
Java 사용	불가능	가능
DB 연결	직접 불가능	Java 코드를 통해 가능
실행 위치	브라우저가 해석	서버가 실행

5. HTML / JSP 예시

HTML

<p>홍길동님 환영합니다.</p>

항상 [홍길동님 환영합니다.] 출력

JSP

<p><%= userName %>님 환영합니다.</p>

userName 값에 따라 출력되는 값이 달라진다.

userName = 홍길동 → 홍길동님 환영합니다.
userName = 김철수 → 김철수님 환영합니다.

6. JSP 주요 문법

6-1 Comment tag

<%-- JSP 주석입니다. --%>

JSP에서 사용하는 주석

6-2 Directive tag

<%@ page contentType="text/html; charset=UTF-8" %>

JSP 페이지의 설정을 작성할 때 사용

<%@ page import="java.util.List" %>

- List 클래스를 사용하기 위해 import

6-3 Declaration tag

<%!
    int count = 0;

    public int add(int a, int b) {
        return a + b;
    }
%>

변수나 메서드를 선언할 때 사용

6-4 Scriptlet tag

<%
    String name = "홍길동";
    int age = 20;
%>

JSP 안에서 Java 코드를 실행할 때 사용

6-5 Expression tag

<%= name %>

Java 변수나 메서드 결과를 화면에 출력할 때 사용

<p><%= name %>님 환영합니다.</p>

name이 '홍길동'이라면 홍길동님 환영합니다. 출력

태그 이름	표기법	역할
Comment tag	<%-- 주석 --%>	JSP 주석
Directive tag	<%@ 지시자 %>	JSP 페이지 설정
Declaration tag	<%! 선언문 %>	변수 / 메서드 선언
Scriptlet tag	<% Java 코드 %>	Java 실행 코드 작성
Expression tag	<%= 표현식 %>	값을 화면에 출력

JSP 코드 리뷰

1. index.jsp

처음 접속하는 메인 페이지 역할

<h1>index</h1>

<h3><a href="./mylist.jsp">목록</a></h3>

링크 클릭시 mylist.jsp 로 이동한다.

사용자가 목록 클릭
↓
mylist.jsp 요청
↓
게시판 목록 화면으로 이동

2. mylist.jsp

게시글 목록을 출력하는 JSP 페이지

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

JSP 페이지에서 Java를 사용하고, 문자 인코딩을 UTF-8로 설정한다는 것을 의미

2-1 request / response 인코딩 설정

<% request.setCharacterEncoding("UTF-8"); %>
<% response.setContentType("text/html; charset=UTF-8"); %>

사용자가 보내는 값과 브라우저에 출력되는 값의 문자 인코딩을 UTF-8로 맞추는 코드

코드	의미
request.setCharacterEncoding("UTF-8")	요청 데이터 한글 처리
response.setContentType(...)	응답 화면 한글 처리

3. JSP에서 JAVA 클래스 import

<%@ page import = "com.my.dao.MyBoardDao" %>
<%@ page import = "com.my.dto.MyBoardDto" %>
<%@ page import = "java.util.List" %>

import	역할
MyBoardDao	DB 조회 메서드 사용
MyBoardDto	게시글 데이터 저장 객체 사용
List	게시글 여러 개 저장

4. JSP에서 JAVA 코드

JSP 안에서 Java 코드를 작성할 때는 <% %>를 사용

<%
    MyBoardDao dao = new MyBoardDao();
    List<MyBoardDto> list = dao.selectAll();
%>

1. MyBoardDao 객체 생성
2. selectAll() 메서드 실행
3. DB에서 게시글 전체 조회
4. 조회 결과를 List<MyBoardDto>에 저장

selectAll()은 MYBOARD 테이블의 데이터를 조회하고, 조회 결과를 MyBoardDto 객체로 만들어 List에 담아 반환

5. MyBoardDto

게시글 하나의 데이터를 저장하는 클래스

private int myno;
private String myname;
private String mytitle;
private String mycontent;
private Date mydate;

DB에서 조회한 게시글 한 줄이 Java에서는 MyBoardDto 객체 하나로 저장

6. MyBoardDao

DB에 접근해서 게시글 데이터를 조회하는 클래스

String sql = " SELECT * FROM MYBOARD ORDER BY MYNO DESC ";

MYBOARD 테이블의 모든 데이터를 조회한다.
게시글 번호가 큰 순서대로 정렬한다.

6-1 DAO 조회 흐름

DB 연결
↓
SQL 준비
↓
SQL 실행
↓
ResultSet으로 결과 받기
↓
DTO 객체 생성
↓
List에 저장
↓
DB 종료
↓
List 반환

while(rs.next()) {
    MyBoardDto dto =
        new MyBoardDto(
            rs.getInt(1),
            rs.getString(2),
            rs.getString(3),
            rs.getString(4),
            rs.getDate(5)
        );

    res.add(dto);
}

7. JSP에서 table로 출력

DB에서 가져온 list를 HTML table에 출력

<table border="1">
    <tr>
        <th>NO</th>
        <th>NAME</th>
        <th>TITLE</th>
        <th>DATE</th>
    </tr>

- 테이블의 제목 줄

7-1 반복문으로 게시글 출력

<%
    for(int i=0; i<list.size(); i++){
%>
    <tr>
        <td><%= list.get(i).getMyno() %></td>
        <td><%= list.get(i).getMyname() %></td>
        <td><%= list.get(i).getMytitle() %></td>
        <td><%= list.get(i).getMydate() %></td>
    </tr>
<%
    }
%>

<%= %>는 값을 화면에 출력할 때 사용

JAVA 풀스택 41일차 - Algorithm2 (정렬 / 이진탐색트리)

레몬팡777 — Mon, 25 May 2026 21:06:11 +0900

1. 정렬

여러 개의 데이터를 일정한 기준에 따라 순서대로 배치하는 것

2. 삽입 정렬

배열의 요소를 하나씩 선택한 뒤, 그 요소가 들어갈 알맞은 위치를 찾아 삽입하는 방식

2-1 코드

 public static void insertionSort(int[] a) {
	// i = 1부터 시작하는 이유:
	// 0번째 요소는 앞에 비교할 값이 없으므로
	// 일단 정렬된 상태라고 본다.
	for(int i = 1; i < a.length; i++) {
		int j;

		// 현재 삽입할 값
		// 예: a[i] 값을 앞쪽의 알맞은 위치에 넣을 예정
		int tmp = a[i];

		// j는 현재 선택한 위치 i부터 시작
		// j > 0 : 배열의 맨 앞을 넘지 않도록 하는 조건
		// a[j - 1] > tmp : 앞쪽 값이 tmp보다 크면 뒤로 밀어야 함
		for(j = i; j > 0 && a[j - 1] > tmp; j--) {
			// 앞쪽 값이 tmp보다 크므로 한 칸 뒤로 이동
			a[j] = a[j - 1];
 		}

		// 반복문이 끝난 위치 j가 tmp가 들어갈 자리
		a[j] = tmp;
	}
}

tmp는 현재 선택된 값

앞쪽 값들이 tmp보다 크면 한칸씩 뒤로 밀고, 알맞은 자리에 tmp를 삽입

2-2 순서

하나를 선택한다.
↓
앞쪽 데이터들과 비교한다.
↓
큰 값들을 뒤로 민다.
↓
알맞은 위치에 삽입한다.

3. 선택 정렬

정렬되지 않은 부분에서 가장 작은 값을 찾아 맨 앞으로 보내는 방식

3-1 코드

public static void selectionSort(int[] a) {

	// i는 현재 정렬할 위치
	// 마지막 요소는 자동으로 정렬되므로 a.length - 1까지만 반복
	for(int i = 0; i < a.length - 1; i++) {

		// min은 가장 작은 값의 인덱스를 저장하는 변수
		// 처음에는 현재 위치 i를 최솟값 위치라고 가정
		int min = i;

		// i 다음 위치부터 배열 끝까지 비교
		// 정렬되지 않은 부분에서 최솟값 찾기
		for(int j = i + 1; j < a.length; j++) {

			// 현재 j 위치의 값이 min 위치의 값보다 작다면
			if(a[j] < a[min]) {

			// 최솟값 위치를 j로 변경
			min = j;
			}
		}

		// 최솟값을 찾았으므로
		// 현재 위치 i와 최솟값 위치 min을 교환
		int tmp = a[i];
		a[i] = a[min];
		a[min] = tmp;
	}
}

3-2 순서

정렬되지 않은 부분에서 최솟값을 찾는다.
↓
최솟값을 맨 앞으로 보낸다.
↓
다음 위치에서 다시 반복한다.

4. 퀵 정렬

기준 값을 하나 정한 뒤, 그 기준값보다 작은 값은 왼쪽, 큰 값을 오른쪽으로 나누면서 정렬하는 방식

이때 기준 값은 피벗이라고 한다

4-1 코드

public static void quickSort(int[] a, int left, int right) {

	// 왼쪽에서 오른쪽으로 이동할 커서
	int lc = left;

	// 오른쪽에서 왼쪽으로 이동할 커서
	int rc = right;

	// 피벗 선택
	// 여기서는 정렬 범위의 가운데 값을 피벗으로 사용
	int x = a[(lc + rc) / 2];

	do {
		// 왼쪽 커서는 피벗보다 작은 값을 만나면 계속 오른쪽으로 이동
		// 피벗보다 크거나 같은 값을 만나면 멈춤
		while(a[lc] < x) {
			lc++;
		}

		// 오른쪽 커서는 피벗보다 큰 값을 만나면 계속 왼쪽으로 이동
		// 피벗보다 작거나 같은 값을 만나면 멈춤
		while(a[rc] > x) {
			rc--;
		}

		// lc가 rc보다 왼쪽에 있거나 같은 위치라면 교환 가능
		if(lc <= rc) {

			// 왼쪽에서 찾은 큰 값과
			// 오른쪽에서 찾은 작은 값을 교환
			int tmp = a[lc];
			a[lc] = a[rc];
			a[rc] = tmp;

			// 교환 후 커서를 한 칸씩 이동
			lc++;
			rc--;
		}

	// 왼쪽 커서와 오른쪽 커서가 엇갈릴 때까지 반복
	} while(lc <= rc);

	// 왼쪽 부분에 아직 정렬할 값이 남아 있으면 다시 퀵 정렬
	if(left < rc) {
		quickSort(a, left, rc);
	}

	// 오른쪽 부분에 아직 정렬할 값이 남아 있으면 다시 퀵 정렬
	if(right > lc) {
		quickSort(a, lc, right);
	}
}

4-2 변수 의미

변수의미

변수	의미
left	정렬할 범위의 시작 인덱스
right	정렬할 범위의 끝 인덱스
lc	왼쪽에서 오른쪽으로 이동하는 커서
rc	오른쪽에서 왼쪽으로 이동하는 커서
x	피벗 값

4-3 순서

피벗을 정한다.
↓
피벗보다 작은 값은 왼쪽으로 보낸다.
↓
피벗보다 큰 값은 오른쪽으로 보낸다.
↓
나뉜 왼쪽/오른쪽을 다시 정렬한다.

5. 병합 정렬

배열을 계속 반으로 나눈 뒤, 작은 단위부터 정렬하면서 다시 합치는 정렬

5-1 코드

// 병합할 때 임시로 값을 저장할 배열
// 왼쪽 배열 값을 잠시 보관하는 용도로 사용
static int[] buff;

public static void mergeSort(int[] a) {

	// 원본 배열과 같은 크기의 임시 배열 생성
	buff = new int[a.length];

	// 배열 전체 범위를 정렬
	// 시작 인덱스: 0
	// 끝 인덱스: a.length - 1
	mSort(a, 0, a.length - 1);
}

public static void mSort(int[] a, int left, int right) {

	// left가 right보다 작을 때만 나눌 수 있음
	// 예: left == right 이면 요소가 1개라 더 이상 나눌 필요 없음
	if(left < right) {

		// 배열을 반으로 나누기 위한 가운데 인덱스
		int center = (left + right) / 2;

		// buff 배열의 인덱스
		int p = 0;

		// buff 배열을 읽을 때 사용할 인덱스
		int j = 0;

		// 원본 배열 a에 다시 값을 넣을 위치
		int k = left;

		// 왼쪽 부분 정렬
		mSort(a, left, center);

		// 오른쪽 부분 정렬
		mSort(a, center + 1, right);

		// 왼쪽 부분 배열을 buff에 복사
		// 예: a[left] ~ a[center] 값을 buff에 저장
		for(int i = left; i <= center; i++) {
			buff[p++] = a[i];
		}

		// 오른쪽 부분의 시작 위치
		int i = center + 1;

		// buff에 저장된 왼쪽 부분과
		// a 배열의 오른쪽 부분을 비교하면서 작은 값을 a에 넣음
		while(i <= right && j < p) {

			// buff[j] <= a[i] 이면 buff[j]를 a[k]에 넣고 j 증가
			// 아니면 a[i]를 a[k]에 넣고 i 증가
			a[k++] = (buff[j] <= a[i]) ? buff[j++] : a[i++];
		}

		// 오른쪽 부분은 이미 a 배열 안에 남아 있으므로
		// buff에 남은 값만 원본 배열 a에 복사하면 됨
		while(j < p) {
			a[k++] = buff[j++];
 		}
	}
}

5-2 흐름

배열을 반으로 나눈다.
↓
왼쪽을 정렬한다.
↓
오른쪽을 정렬한다.
↓
두 부분을 작은 값부터 다시 합친다.

6. 버블 정렬

옆에 있는 두 값을 비교해서 순서가 틀리면 바꾸는 정렬

6-1-1 코드

public static void bubbleSort(int[] a) {

	// 배열 전체를 여러 번 반복
	// 한 번 반복할 때마다 작은 값이 앞쪽으로 이동
	for(int i = 0; i < a.length - 1; i++) {

		// 교환 횟수 저장 변수
		// 한 번도 교환이 없으면 이미 정렬된 상태라고 판단 가능
		int cnt = 0;

		// 뒤쪽에서 앞쪽 방향으로 인접한 두 값 비교
		// j는 배열의 마지막 인덱스부터 시작
		for(int j = a.length - 1; j > i; j--) {

			// 앞 값이 뒤 값보다 크면 순서가 잘못된 상태
			if(a[j - 1] > a[j]) {

				// 두 값 교환
				int tmp = a[j - 1];
				a[j - 1] = a[j];
				a[j] = tmp;

				// 교환이 일어났으므로 cnt 증가
				cnt++;
			}
		}
		
		// 이번 반복에서 한 번도 교환이 없었다면
		// 이미 정렬이 끝난 상태이므로 반복 종료
		if(cnt == 0) {
			break;
		}
	}
}

6-1-2 코드

public static void bubbleSort2(int[] a) {

	// 앞에서부터 인접한 요소 두 개를 비교해가며 정렬
	// 한 번 반복할 때마다 가장 큰 값이 오른쪽으로 이동
	for(int i = 0; i < a.length - 1; i++) {

		// 교환 횟수 저장 변수
		int cnt = 0;

		// 앞에서부터 인접한 두 값 비교
		// a[j]와 a[j + 1]을 비교
		for(int j = i; j < a.length - 1 - i; j++) {

			// 앞 값이 뒤 값보다 크면 교환
			if(a[j] > a[j + 1]) {

				// 두 값 교환
				int tmp = a[j + 1];
				a[j + 1] = a[j];
				a[j] = tmp;

				// 교환 횟수 증가
				cnt++;
			}
		}

		// 교환이 한 번도 없으면 이미 정렬된 상태
		if(cnt == 0) {
			break;
		}
	}
}

6-2 흐름

앞에서부터 두 개씩 비교한다.
↓
앞 값이 더 크면 바꾼다.
↓
큰 값이 점점 오른쪽으로 이동한다.
↓
반복하면서 정렬된다.

7. 이진탐색트리

데이터를 크기 기준으로 왼쪽 / 오른쪽에 나누어 저장하는 자료구조

현재 노드보다 작은 값 → 왼쪽
현재 노드보다 큰 값 → 오른쪽

7-1 Node 클래스

트리에서 데이터 하나를 저장하는 단위를 노드(Node)라고 한다

class Node<K, V> {
    private K key;          // 비교 기준이 되는 값
    private V data;         // 실제 저장할 데이터
    private Node<K,V> left; // 왼쪽 자식 노드
    private Node<K,V> right;// 오른쪽 자식 노드
}

이름	뜻
key	비교 기준이 되는 값
data	실제로 저장할 데이터
left	왼쪽 자식 노드
right	오른쪽 자식 노드

7-2 K, V 제네릭

public class BinarySearchTree<K,V>

K = key의 자료형 
V = data의 자료형
 

BinarySearchTree<Integer, Data> tree = new BinarySearchTree<Integer, Data>();

key는 Integer 타입
data는 Data 타입

7-3 root

private Node<K,V> root;

root는 트리의 시작 노드

트리는 검색, 추가할 때 항상 root부터 시작

7-4 key 비교

int cond = com(key, n.getKey());

비교 결과에 따라 왼쪽으로 갈지, 오른쪽으로 갈지 결정

결과	의미	이동 방향
음수	찾는 key가 현재 key보다 작음	왼쪽
0	key가 같음	찾음
양수	찾는 key가 현재 key보다 큼	오른쪽

7-5 검색 search()

검색은 원하는 key를 가진 데이터를 찾는 기능

흐름

root부터 시작
↓
찾는 key와 현재 노드 key 비교
↓
같으면 데이터 반환
↓
작으면 왼쪽 이동
↓
크면 오른쪽 이동
↓
끝까지 못 찾으면 null 반환

Node<K,V> n = root;

while(true) {
    if(n == null) {
        return null;
    }

    int cond = com(key, n.getKey());

    if(cond == 0) {
        return n.getValue();
    } else if(cond < 0) {
        n = n.left;
    } else {
        n = n.right;
    }
}

root부터 시작해서 key를 비교하고, 작으면 왼쪽 노드, 크면 오른쪽 노드로 이동

key와 같으면 해당 노드의 data를 반환

7-6 추가 add()

노드 추가 시 규칙

작으면 왼쪽
크면 오른쪽

if(root==null) {
			root = new Node<K,V>(key,data,null,null);
		}else {
			addNode(root,key,data);
		}

root가 있다면 addNode()를 이용해 들어갈 위치를 찾음

흐름

추가할 key와 현재 노드 key 비교
↓
같으면 추가하지 않음
↓
작으면 왼쪽으로 이동
↓
크면 오른쪽으로 이동
↓
비어 있는 위치를 찾으면 새 노드 추가

7-7 출력 print()

출력 순서

왼쪽 출력
↓
현재 노드 출력
↓
오른쪽 출력

private void printSubTree(Node node) {
    if(node != null) {
        printSubTree(node.left);
        System.out.println(node.key + " " + node.data);
        printSubTree(node.right);
    }
}

7-8 삭제 remove()

1. 왼쪽 자식이 없는 경우
2. 오른쪽 자식이 없는 경우
3. 자식이 2개 있는 경우

7-8-1 삭제할 노드 찾기

Node<K,V> p = root;
Node<K,V> parent = null;
boolean isLeftChild = true;

변수	의미
p	현재 확인 중인 노드
parent	현재 노드의 부모 노드
isLeftChild	현재 노드가 부모의 왼쪽 자식인지 확인

7-8-2 왼쪽 자식이 없는 경우

삭제할 노드의 왼쪽 자식이 없다면, 삭제할 노드 대신 오른쪽 자식을 연결

if(p.left == null) {
    parent.left = p.right;
}

7-8-3 오른쪽 자식이 없는 경우

삭제할 노드의 오른쪽 자식이 없다면, 삭제할 노드 대신 왼쪽 자식을 연결

else if(p.right == null) {
    parent.left = p.left;
}

7-8-4 자식이 2개 있는 경우

Node<K,V> left = p.left;

while(left.right != null) {
    parent = left;
    left = left.right;
}

p.key = left.key;
p.data = left.data;

왼쪽 서브트리에서 가장 오른쪽으로 계속 이동하면 가장 큰 값을 찾을 수 있다.

그 값을 삭제할 노드에 덮어써서 트리 규칙을 유지

개념	설명
Tree	나무처럼 가지가 뻗는 자료구조
Node	데이터 하나를 저장하는 단위
root	트리의 시작 노드
key	비교 기준
data	실제 저장할 값
left	현재 key보다 작은 값이 연결되는 방향
right	현재 key보다 큰 값이 연결되는 방향
search	key를 비교하며 데이터 찾기
add	규칙에 맞는 위치에 노드 추가
remove	규칙이 깨지지 않게 노드 삭제
중위 순회	왼쪽 → 현재 → 오른쪽 순서로 출력

JAVA 풀스택 40일차 - Algorithm (재귀함수 / 이중연결리스트 / 스택,큐)

레몬팡777 — Fri, 22 May 2026 08:46:56 +0900

1. 재귀함수 (Recursion)

자기 자신을 다시 호출하는 함수

1-1 특징

함수 안에서 자기 자신을 다시 실행

종료 조건이 반드시 있어야 함

1-2 팩토리얼 함수

public static int factorial(int no) {
    return (no==1)? 1: no*factorial(no-1);
}

- no가 1이면 1 반환 아니면 '현재값 * factorial(no-1)' 반환

2. 유클리드 호제법

두 수의 최대 공약수를 구하는 알고리즘

public static int eculid(int no1, int no2) {
    if(no2==0) {
        return no1;
    }else {
        return eculid(no2,no1%no2);
    }
}

- 큰 수를 작은 수로 나눈 나머지를 이용
- 나머지가 0이 될 때의 수가 최대공약수

3. 하노이탑

public static void hanoi(int no, int x, int y) {
	if(no>1) {
		hanoi(no-1,x,6-x-y);
	}
	System.out.println("원판: " + no +"을 " + x + "기둥에서 " + y + "기둥으로 옮김");	
	if(no>1) {
		hanoi(no-1,6-x-y,y);
	}
}

매개변수	의미
no	원판 개수
x	시작 기둥
y	목표 기둥
6-x-y	남은 기둥 번호

4. 이중 연결 리스트

4-1 연결 리스트

데이터를 배열처럼 순서대로 저장하지만 각 데이터가 다음 데이터를 직접 가리키는 구조

배열은 인덱스로 접근하지만, 연결 리스트는 노드끼리 연결

4-2 이중 연결 리스트

각 노드가 두방향을 기억

이전 노드 ← 현재 노드 → 다음 노드

4-3 Node 클래스

class Node<E>{
	private E data;    
	private Node<E> prev;  
	private Node<E> next; 	
    
	Node(){
		data = null;
		prev = this;
		next = this;
	}
	Node(E obj, Node<E> prev, Node<E> next){
		data = obj;
		this.prev = prev;
		this.next = next;
	}
}

필드	의미
data	실제 저장할 데이터
prev	이전 노드 주소
next	다음 노드 주소

4-4 head, crnt

private Node<E> head;
private Node<E> crnt;

변수	의미
head	리스트의 시작을 관리하는 더미 노드
crnt	현재 선택된 노드

4-5 리스트가 비었는지 확인

public boolean isEmpty() {
    return head.next == head;
}

- head.next 가 head라면 중간에 데이터 노드가 없다는 것

head → head

상태이면 리스트가 비어있다는 것

4-6 데이터 추가

public void add(E obj) {
    Node<E> node = new Node<E>(obj,crnt,crnt.next);
    crnt.next = crnt.next.prev = node;
    crnt = node;
}

- 현재 노드 뒤에 새로운 노드 추가

현재 노드와 다음 노드 사이에 새 노드를 끼워 넣는 것

4-7 맨 앞 / 맨 뒤 추가

public void addFirst(E obj) {
    crnt = head;
    add(obj);
}

- head 바로 뒤에 추가하므로 첫번째 위치로 들어감

public void addLast(E obj) {
    crnt = head.prev;
    add(obj);
}

- 마지막 노드 뒤에 추가하므로 맨 뒤에 들어감

4-8 노드 삭제

public void removeCrnt() {
    if(!isEmpty()) {
        crnt.prev.next = crnt.next;
        crnt.next.prev = crnt.prev;
        crnt = crnt.prev;
    }
}

- 앞 노드와 뒤 노드를 서로 연결해서 삭제할 노드를 연결 구조에서 제외

4-9 전체 삭제

public void clear() {
    while(!isEmpty()) {
        removeFirst();
    }
}

- 리스트가 빌 때까지 첫 번째 노드를 계속 삭제

5. stack

마지막에 넣은 데이터가 먼저 나오는 방식의 자료 구조 (LIFO)

5-1 stack 필드

private int[] s;
private int capacity;
private int ptr;

- 배열을 이용하여 정수 데이터 저장

필드	의미
s	데이터 저장 배열
capacity	스택 최대 용량
ptr	현재 저장된 데이터 개수이자 다음 저장 위치

5-2 push()

스택에 데이터를 추가하는 기능

public int push(int no) throws Exception {
    if(ptr>= capacity) {
        System.out.println("[스택이 가득 참]");
        throw new Exception();
    }
    return s[ptr++] = no;
}

ptr 위치에 값을 넣고 ptr을 1 증가시킴

5-3 pop()

가장 마지막에 넣은 데이터를 꺼냄

public int pop() throws Exception {
    if(ptr <= 0) {
        System.out.println("[스택이 비었음]");
        throw new Exception();
    }
    int res = s[--ptr];
    return res;
}

ptr을 먼저 1 줄이고, 그 위치의 데이터를 꺼냄 (배열의 인덱스는 0부터 시작)

5-4 peek()

데이터를 꺼내지는 않고 맨 위 데이터를 확인만 함

public int peek() throws Exception {
    if(ptr <= 0) {
        System.out.println("[스택이 비었음]");
        throw new Exception();
    }
    return s[ptr-1];
}

6. Queue

먼저 넣은 데이터가 먼저 나오는 자료구조(FIFO)

6-1 Queue 필드

private int[] q;
private int capacity;
private int num;
private int front;
private int rear;

필드	의미
q	데이터 저장 배열
capacity	큐 최대 용량
num	현재 저장된 데이터 개수
front	가장 앞 데이터 위치
rear	다음 데이터가 들어갈 위치

6-2 enqueue()

큐에 데이터를 추가하는 기능

public int enqueue(int no) throws Exception {
    if(num>=capacity) {
        System.out.println("[큐가 가득참]");
        throw new Exception();
    }
    q[rear++] = no;
    num++;

    if(rear == capacity) {
        rear = 0;
    }
    return no;
}

데이터는 rear 위치에 들어가고, rear은 다음 위치로 이동

6-3 dequeue()

가장 먼저 들어온 데이터를 꺼냄

public int dequeue() throws Exception {
    if(num <= 0) {
        System.out.println("[큐가 비었다]");
        throw new Exception();
    }

    int val = q[front++];
    num--;

    if(front == capacity) {
        front = 0;
    }

    return val;
}

데이터는 front 위치에서 꺼내고, front는 다음 위치로 이

6-4 원형 큐

if(rear == capacity) {
    rear = 0;
}

if(front == capacity) {
    front = 0;
}

배열의 끝까지 갔을 경우 다시 0번 인덱스로 돌아감

배열을 일직선이 아니라 동그랗게 이어진 것처럼 사용

7. Stack / Queue 차이

구분	Stack	Queue
구조	마지막 데이터가 먼저 나옴	먼저 넣은 데이터가 먼저 나옴
방식	LIFO	FIFO
비유	접시 쌓기	줄 서기
추가	push	enqueue
삭제	pop	dequeue
확인	peek	peek

JAVA 풀스택 39일차 - JDBC (MVC 패턴)

레몬팡777 — Thu, 21 May 2026 12:39:57 +0900

1. MVC 심화 구조

1-1 기존 방식

기능 + 구현코드 (한 클래스에 작성)

- 관리 어려움

- 수정 어려움

public class MemberDao {

    public List<Member> selectAll(Connection con){
        // SQL 실행 코드
    }
}

2. Interface - impl 구조

MemberDao ← 인터페이스 (기능 정의)
MemberDaoImpl ← 실제 구현 클래스 (실제 구현)

MemberService ← 인터페이스 (기능 정의)
MemberServiceImpl ← 실제 구현 클래스 (실제 구현)

3. Interface

기능의 규칙을 미리 정의하는 것

public interface MemberDao{

public List<Member> selectAll(Connection con);

public Member selectOne(Connection con, int n);

public int insert(Connection con, Member m);

public int update(Connection con, Member m);

public int delete(Connection con, int n);
}

- 기능

4. Impl 클래스

인터페이스에서 정의한 기능을 실제 구현하는 클래스

public class MemberDaoImpl implements MemberDao{
	public int insert(Connection con, Member m) {
	String sql = " INSERT INTO MEMBER VALUES(SEQ_MEMBER.NEXTVAL, ?,?,?,?,?,?,?) ";

	// SQL 실행 코드
	}
}

5. Interface - Impl 구조 사용 이유

5-1 역할 분리

인터페이스 (규칙 정의), Impl (실제 구현) 분리

5-2 유지보수 쉬움

DB 구조가 변경되어도 인터페이스는 그대로 두고 Impl만 수정 가능

5-3 코드 교체 쉬움

DB가 Oracle 에서 MySQL로 변경되어도 Impl만 바꿔도 사용 가능

6. SQL문 상수화

String selectAll = " SELECT * FROM MEMBER ";
String selectOne = " SELECT * FROM MEMBER WHERE M_NO = ? ";
String insert = " INSERT INTO MEMBER VALUES(SEQ_MEMBER.NEXTVAL, ?,?,?,?,?,?,?) ";
String update = " UPDATE MEMBER SET M_LOCATION = ?, M_JOB = ?, M_TEL = ? WHERE M_NO = ? ";
String delete = " DELETE MEMBER WHERE M_NO = ? ";

- SQL 수정 시 한 곳만 변경함으로 전체 수정 가능

- SQL 관리 편함

6-1 기존 방식

pstm = con.prepareStatement(" SELECT * FROM MEMBER ");

- SQL 직접 작성

6-2 상수화 방식

pstm = con.prepareStatement(selectAll);

- 변수처럼 재사용 가능

7. 기존 Controller

기존에는 기능별로 Controller을 따로 구현

MemberInsertController
MemberSelectController
MemberDeleteController

- 클래스 관리 어려움

- 중복 코드 증가

8. 통합 Controller

기능을 하나의 Controller로 통합

public Object doMethod(Object ... obj) {
    String req = (String) obj[0];

    if(req.equals("selectAll")) {
        List<Member> res = s.selectAll();
        return res;

    } else if(req.equals("selectOne")) {
        int no = (int) obj[1];
        Member res = s.selectOne(no);
        return res;

    } else if(req.equals("insert")) {
        Member m = (Member) obj[1];
        int res = s.insert(m);
        return res;
    }

    return null;
}

- Controller 클래스 하나로 여러 기능 처리 가능

9. 가변인자

매개 변수 개수를 자유롭게 받을 수 있는 문법

public Object doMethod(Object ... obj)

9-1 가변인자 사용하는 이유

통합 Controller에서는 기능마다 필요한 값 개수가 다르기 때문

기능	필요한 값
전체 조회	"selectAll"
선택 조회	"selectOne", 회원 번호
추가	"insert", Member 객체

- 매개변수를 자유롭게 받기 위해 가변인자 사용

예시

전체 조회

con.doMethod("selectAll");

선택 조회

con.doMethod("selectOne", inputNo());

추가

con.doMethod("insert", inputMember());

10. req 기능 구분

String req = (String)obj[0];

- 첫 번째 값에 기능 이름 저장

예시

"selectAll"
"insert"
"delete"

JAVA 풀스택 38일차 - JDBC (MVC 패턴)

레몬팡777 — Wed, 20 May 2026 08:44:57 +0900

JDBC MVC 패턴

1. MVC 패턴

프로그램을 역할별로 나누어 관리하는 구조

이름	의미
M(Model)	데이터 / DB 처리
V(View)	화면 / 사용자 입력 출력
C(Controller)	중간 연결 역할

2. MVC 패턴 구조

View
↓
Controller
↓
Service
↓
DAO
↓
DB

클래스	역할
Run	프로그램 시작
View	사용자 입력 / 출력
Controller	View와 Service 연결
Service	비즈니스 로직 / commit / rollback 처리
DAO	실제 SQL 실행
VO(Product)	데이터 저장 객체
JDBCTemplate	공통 JDBC 기능 관리

3. Run 클래스

프로그램의 시작 클래스

public class Run {
    public static void main(String[] args) {
        new ProductView().menu();
    }
}

- ProductView 객체를 생성하고 menu 실행

- 프로그램이 시작되면 가장 먼저 사용자 메뉴 화면으로 이동

4. ProductView 클래스

사용자가 직접 보는 화면 역할

- 메뉴 출력

- 사용자 입력 받기

- Controller 호출

- 결과 출력

private ProductController controller = new ProductController();

- View는 DB에 직접 접근하지 않고 Controller에 요청

List<Product> resAll = controller.selectAll();

- 전체 조회 시 사용

controller.insert(insertProduct());

- 추가 시 사용자가 입력한 정보를 Product 객체로 만들어 Controller에 전달

View는 SQL을 실행하지 않고 사용자 입력과 출력만 담당

5. ProductController

View와 Service 사이를 연결

public int insert(Product dto) {
    return service.insert(dto);
}

- View에서 받은 요청을 Service로 전달하고, Service 결과를 다시 View로 돌려줌

중간 전달자 역할

View 요청 받기
↓
Service에게 전달
↓
Service 결과를 View로 반환

6. ProductService

DB 작업 흐름을 관리

- Connection 생성

- DAO 호출

- 성공 시 commit, 실패 시 rollback

- connection 종료

public int insert(Product dto) {
    Connection con = getConnection();
    int res = dao.insert(con, dto);

    if(res > 0) {
        commit(con);
    } else {
        rollback(con);
    }

    close(con);
    return res;
}

1. DB 연결 생성
2. DAO에게 insert 작업 요청
3. 결과가 1 이상이면 commit
4. 실패하면 rollback
5. DB 연결 종료
6. 결과 반환

SQL 실행은 DAO에게 맡기고, Service는 성공 여부에 따라 commit / rollback을 처리

7. ProductDao

실제 SQL을 작성하고 실행

String sql = " INSERT INTO PRODUCT VALUES(?,?,?,?) ";

? 는 나중에 값이 들어가는 자리

pstm = con.prepareStatement(sql);
pstm.setString(1, dto.getPid());
pstm.setString(2, dto.getPname());
pstm.setInt(3, dto.getPrice());
pstm.setString(4, dto.getDes());
		
res = pstm.executeUpdate();

- executeUpdate()로 INSERT, UPDATE, DELETE 같은 데이터 변경 SQL을 실행

8. Product VO

DB 데이터를 저장하는 객체

private String pid;
private String pname;
private int price;
private String des;

public Product(String pid, String pname, int price, String des) {
		super();
		this.pid = pid;
		this.pname = pname;
		this.price = price;
		this.des = des;
	}

9. JDBCTemplate

JDBC에서 반복되는 코드를 모아둔 공통 클래스

- getConnection() : DB와 연결

- close() : DB 연결 종료

- commit : DB 변경 사항 저장

- rollback : DB 변경 사 취소

Connection con = getConnection();

- Service 클래스에서 DB 연결을 만들 때 사용

commit(con);
rollback(con);

- 작업 성공 시 commit, 작업 실패 시 rollback 사용

close(con);

- 작업 종료 시 Connection 종료

10. 전체 흐름

10-1 전체 조회 흐름

사용자 조회 요청
↓
ProductView에서 controller.selectAll() 호출
↓
ProductController에서 service.selectAll() 호출
↓
ProductService에서 DB 연결 생성
↓
ProductService에서 dao.selectAll(con) 호출
↓
ProductDao에서 SELECT 실행
↓
조회 결과를 Product 객체로 변환
↓
Product 객체들을 List에 담아 반환
↓
View에서 List를 출력

String sql = " SELECT * FROM PRODUCT ";

- DAO 에서 실행하는 SQL

List<Product> res = new ArrayList<>();

- 조회 결과가 여러 개일 수 있기에 List<Product>에 담음

while(rs.next()) {
    Product p = new Product(
        rs.getString(1),
        rs.getString(2),
        rs.getInt(3),
        rs.getString(4)
    );

    res.add(p);
}

- 조회 결과 한 줄을 Product 객체 하나로 만들고, 그 객체를 List에 저장

10-2 INSERT 흐름

사용자가 제품 ID, 이름, 가격, 설명 입력
↓
View에서 Product 객체 생성
↓
View에서 controller.insert(product) 호출
↓
Controller에서 service.insert(product) 호출
↓
Service에서 DB 연결 생성
↓
DAO에서 INSERT 실행
↓
성공하면 Service에서 commit
↓
실패하면 Service에서 rollback
↓
결과를 View로 반환
↓
View에서 성공/실패 메시지 출력

return new Product(id, name, price, des);

- View에서 사용자가 입력한 값을 Product 객체로 만

String sql = " INSERT INTO PRODUCT VALUES(?,?,?,?) ";

- DAO에서 INSERT SQL문을 실행

res = pstm.executeUpdate();

- res가 1 이상(수정된 줄이 1줄 이상)이면 성공

10-3 UPDATE 흐름

수정할 제품 선택
↓
변경할 값 입력
↓
View에서 Product 객체 생성
↓
Controller → Service → DAO 순서로 전달
↓
DAO에서 UPDATE 실행
↓
성공하면 commit
↓
실패하면 rollback
↓
View에서 결과 출력

String sql = " UPDATE PRODUCT SET PRICE = ? WHERE P_ID = ? ";

- DAO에서 UPDATE SQL문 실행

10-4 DELETE 흐름

삭제할 제품 선택
↓
View에서 controller.delete(id) 호출
↓
Controller에서 service.delete(id) 호출
↓
Service에서 DB 연결 생성
↓
DAO에서 DELETE 실행
↓
성공하면 commit
↓
실패하면 rollback
↓
View에서 결과 출력

String sql = " DELETE PRODUCT WHERE P_ID = ? ";

- DAO에서 DELETE SQL문 실행

JAVA 풀스택 37일차 - JDBC2

레몬팡777 — Tue, 19 May 2026 08:59:55 +0900

1. JDBCTemplate

JDBC에서 반복되는 코드를 따로 모아두는 클래스 (반복되는 코드를 따로 빼기)

기존 JDBC는

Class.forName(...)

DriverManager.getConnection(...)

con.close()

위 코드들을 항상 적어야 하기 때문에 코드가 길어지기에 이를 해결하기 위한 클래스

1-1 JDBCTemplate 안에 포함되는 기능

기능	역할
getConnection()	DB 연결
close()	연결 종료

2. getConnection()

Oracle DB 연결 생성 메소드

public static Connection getConnection()

- 드라이버 등록

- DB 연결

- Auto Commit 설정

2-1 getConnection() 전체 코드

public class JDBCTemplate {

    // 1. DB 연결 메소드
    // 다른 클래스에서 getConnection()을 호출하면
    // Oracle DB와 연결된 Connection 객체를 반환해준다.
    public static Connection getConnection() {

        // Connection 객체를 담을 변수
        Connection con = null;

        // 1-1. Oracle JDBC 드라이버 등록
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            // Java가 Oracle DB와 연결할 수 있도록 드라이버를 불러오는 코드
        } catch (ClassNotFoundException e) {
            System.out.println("[Error] 드라이버 등록 실패");
            e.printStackTrace();
        }

        // 1-2. DB 연결 정보
        String url = "jdbc:oracle:thin:@localhost:1521/orcl";
        String id = "ID";
        String pw = "PW";

        // 1-3. DB 연결
        try {
            con = DriverManager.getConnection(url, id, pw);
            // url, id, pw를 이용해서 DB에 접속

            con.setAutoCommit(false);
            // 자동 커밋 해제
            // INSERT, UPDATE, DELETE 후
            // 직접 commit() 또는 rollback() 하기 위해 설정

        } catch (SQLException e) {
            System.out.println("[Error] 오라클 연결 실패");
            e.printStackTrace();
        }

        // 1-4. 연결된 Connection 객체 반환
        return con;
    }
 }

2-2 Auto Commit

자동 저장 기능 활성화 여부

con.setAutoCommit(false);

false : 비활성화

true : 활성화

직접 commit, rollback 처리 가능

3. close()

사용 끝난 DB 연결 종료

public static void close(Connection con)

- Connection 종료

- Statement 종료

- ResultSet 종료

3-1 close() 전체 코드

public class JDBCTemplate {
    // 2. Connection 종료 메소드
    // DB 연결 종료
    public static void close(Connection con) {
        try {
            if(con != null) {
                con.close();
            }
        } catch (SQLException e) {
            System.out.println("[Error] con close 실패");
            e.printStackTrace();
        }
    }

    // 3. Statement 종료 메소드
    // SQL 실행 도구 종료
    public static void close(Statement stmt) {
        try {
            if(stmt != null) {
                stmt.close();
            }
        } catch (SQLException e) {
            System.out.println("[Error] stmt close 실패");
            e.printStackTrace();
        }
    }

    // 4. ResultSet 종료 메소드
    // SELECT 결과 저장 객체 종료
    public static void close(ResultSet rs) {
        try {
            if(rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            System.out.println("[Error] rs close 실패");
            e.printStackTrace();
        }
    }
}

4. 다른 클래스에서 사용

4-1 static import

다른 클래스의 static 메소드를 클래스명 없이 바로 사용할 수 있게 해주는 기능

import static common.JDBCTemplate.*;

- 클래스명 없이 메소드 사용 가능

getConnection();

해당 형식으로 클래스명을 생략하여 사용 가능

4-2 static 없이 import

import common.JDBCTemplate.*;

JDBCTemplate.getConnection();

메소드 앞에 클래스명이 항상 붙여야 한다.

5. executeUpdate()

데이터를 추가, 수정, 삭제하기 위해 사용하는 기

int res = stmt.executeUpdate(sql);

- res에 SQL 실행 결과로 몇 개의 행이 영향을 받았는지 저장

5-2 executeQuery()와 executeUpdate() 차이

메소드	사용 SQL	결과
executeQuery()	SELECT	ResultSet 반환
executeUpdate()	INSERT, UPDATE, DELETE	int 반환

SELECT 일 때

조회 결과가 필요하기에 ResultSet으로 결과를 받는다.

ResultSet rs = stmt.executeQuery(sql);

INSERT 일 때

몇 행이 추가되었는지 확인하기 때문에 int로 결과를 받는다.

int res = stmt.executeUpdate(sql);

5-3 executeUpdate() 반환

if(res > 0) {
    System.out.println("insert 성공");
} else {
    System.out.println("insert 실패");
}

res 반환값으로 추가/수정/삭제 성공 여부 출력 가능

6. PreparedStatement

SQL문을 미리 준비하고, 값을 나중에 넣는 방식

String sql = " INSERT INTO MYTEST VALUES(?,?,?) ";

- ? 는 나중에 값을 넣을 자리

7. PreparedStatement 사용 순서

7-1 SQL 작성

String sql = " INSERT INTO MYTEST VALUES(?,?,?) ";

7-2 PreparedStatement 생성

pstm = con.prepareStatement(sql);

7-3 ?에 값 넣기

pstm.setInt(1, no);
pstm.setString(2, name);
pstm.setString(3, nickName);

7-4 실행

int res = pstm.executeUpdate();

8. Statement와 PreparedStatement 비교

	Statement	PreparedStatement
SQL 작성	문자열 직접 연결	? 사용
값 넣기	문자열에 직접 포함	setInt(), setString()
가독성	복잡함	깔끔함
실수 가능성	높음	낮음
보안	상대적으로 취약	더 안전함

9. Delete

테이블에서 데이터를 삭제하는 SQL

String sql = " DELETE FROM MYTEST WHERE MNAME=? ";

9-1 PreparedStatement로 DELETE 실행

String name = new Scanner(System.in).next();

pstm = con.prepareStatement(sql);
pstm.setString(1, name);

int res = pstm.executeUpdate();

1. 사용자가 이름 입력

2. ? 자리에 이름 넣기
3. DELETE 실행
4. 삭제된 행 개수 반환

JAVA 풀스택 36일차 - Oracle DB 6 / JDBC

레몬팡777 — Sun, 17 May 2026 22:07:36 +0900

Oracle DB

1. INDEX (인덱스)

데이터를 더 빨리 찾기 위한 기

- 검색 속도 향상용 기능

1-1 장점

- 검색 속도 향상

- SELECT 성능 개선

1-2 단점

- 데이터를 수정할 때마다 다시 계산해야 함

- 저장 공간 추가 사용

1-3 인덱스 정보 조회

SELECT *
FROM USER_IND_COLUMNS;

2. 고유 인덱스 (UNIQUE INDEX)

중복 없는 값

CREATE UNIQUE INDEX IDX_EMP_NO
ON EMPLOYEE(EMP_NO);

- 중복값 허용 안함

- PRIMARY KEY / UNIQUE 생성 시 오라클이 자동 생성하기도 함

3. 일반 INDEX

자주 조회하는 컬럼 기준 인덱스

CREATE INDEX IDX_DEPT_CODE
ON EMPLOYEE(DEPT_CODE);

4. INDEX 삭제

DROP INDEX IDX_DEPT_CODE;

5. PL / SQL

오라클의 절차형 프로그래밍 언어

- SQL 안에서 변수, 조건문, 반복문 사용 가능

5-1 특징

- 변수 사용 가능

- 조건문 사용 가능

- 반복문 사용 가능

- 예외 처리 가능

5-2 PL/SQL 기본 구조

DECLARE
BEGIN
EXCEPTION
END;

영역	의미
DECLARE	변수 선언
BEGIN	실행 영역
EXCEPTION	예외 처리
END	종료

5-3 예외 처리

EXCEPTION
WHEN 예외명
THEN 실행코드;

EXCEPTION
WHEN DUP_VAL_ON_INDEX
THEN DBMS_OUTPUT.PUT_LINE('이미 존재');

- 중복 값 오류 발생 시 메시지 출력

5-4 DBMS_OUTPUT.PUT_LINE()

출력 함수

DBMS_OUTPUT.PUT_LINE('HELLO');

5-5 변수 사용

값을 저장하는 공간

DECLARE
	vid NUMBER;

5-6 SELECT INTO

조회 결과를 변수에 저장

SELECT EMP_ID
INTO vid
FROM EMPLOYEE
WHERE EMP_NAME='레몬팡';

6. %TYPE / %ROWTYPE

6-1 %TYPE

컬럼 자료형 그대로 가져오기

ID EMPLOYEE.EMP_ID%TYPE;

- EMP_ID와 같은 타입으로 변수 생성

6-2 %ROWTYPE

테이블 한줄 전체 저장

myrow EMPLOYEE%ROWTYPE;

- EMPLOYEE 한 행 전체 저장 가능

7. IF문

조건에 따라 다르게 실행

IF 조건 THEN
	실행문
END IF;

7-1 여러 조건

IF 조건1 THEN
ELSIF 조건2 THEN
ELSE
END IF;

7-2 ELSIF

IF 조건 THEN
	실행문
ELSIF 조건 THEN
	실행문
ELSE
	실행문
END IF;

8. LOOP (반복문)

같은 작업 여러 번 반복

8-1 기본 구조

LOOP
	반복내용
END LOOP;

- 무한 반복 가능

8-2 EXIT (종료)

조건 만족 시 종료

LOOP
	DBMS_OUTPUT.PUT_LINE(N);
 	N := N-1;
	IF N = 0 THEN 
		EXIT;
	END IF;
END LOOP;

8-3 EXIT WHEN

조건 만족 시 반복문 종료

LOOP
	DBMS_OUTPUT.PUT_LINE(N);
 	N := N-1;
	EXIT WHEN N=0;
END LOOP;

8-4 FOR LOOP

조건 반복문

FOR N IN 1..5 LOOP
	DBMS_OUTPUT.PUT_LINE(N);
END LOOP;

8-5 FOR문 INSERT

FOR X IN 1..10 LOOP
	INSERT INTO TEST_FOR
	VALUES(X, CURRENT_DATE);
END LOOP;

8-6 REVERSE

FOR X IN REVERSE 1..10 LOOP
	INSERT INTO TEST_FOR
	VALUES(X, CURRENT_DATE);
END LOOP;

9. PROCEDURE (프로시저)

자주 사용하는 SQL을 저장하고 필요할 때 실행하는 기능

9-1 기본 구조

CREATE OR REPLACE PROCEDURE 프로시저명
IS
BEGIN
    실행할 코드
END;

코드	의미
CREATE OR REPLACE	이미 있으면 덮어쓰고 없으면 생성
PROCEDURE	프로시저를 생성하겠다는 의미
IS	변수 선언 영역
BEGIN	실행 코드 시작
END	종료

CREATE OR REPLACE PROCEDURE DEL_ALL_EMP
IS
BEGIN
    DELETE FROM EMP_TMP;
END;

- DEL_ALL_EMP를 실행하면 EMP_TMP 테이블 전체 삭제

9-2 실행 방법

BEGIN
    DEL_ALL_EMP;
END;

EXEC DEL_ALL_EMP;

10. FUNCTION (함수)

계산 후 결과값을 돌려주는 기능

10-1 기본 구조

CREATE OR REPLACE FUNCTION 함수명(매개변수)
RETURN 자료형
IS
BEGIN
    실행 코드

    RETURN 값;
END;

CREATE OR REPLACE FUNCTION BONUS_CALC(V_EMP_ID IN EMPLOYEE.EMP_ID%TYPE)
RETURN NUMBER
IS

10-2 사용 방법

SELECT EMP_NAME, BONUS_CALC(EMP_ID)
FROM EMPLOYEE;

11. 프로시저, 함수 차이

프로시저	함수
작업 실행	값 반환
RETURN 없어도 됨	RETURN 반드시 필요

12. TRIGGER (트리거)

특정 일이 발생하면 자동 실행되는 기능

12-1 기본 구조

CREATE OR REPLACE TRIGGER 트리거명
실행시점
BEGIN
    실행 코드
END;

CREATE OR REPLACE TRIGGER TRG_01
AFTER INSERT ON PRODUCT_DETAIL
FOR EACH ROW
BEGIN

12-1-1 AFTER INSERT

- INSERT 이후 실행

12-1-2 ON PRODUCT_DETAIL

- PRODUCT_DETAIL 테이블에서 발생 시

12-1-3 FOR EACH ROW

- 행 하나 추가될 때마다 실행

13. :NEW

:NEW.STATUS

- 새로 들어온 데이터

- 방금 INSERT 된 값

JDBC

1. JDBC

JAVA와 DB를 연결해주는 기술

Java 프로그램 → Oracle DB 접속 → SQL 실행 → 결과 가져오기

2. JDBC 흐름

// 1. 드라이버 등록
Class.forName("oracle.jdbc.driver.OracleDriver");

// 2. DB 연결
Connection con = DriverManager.getConnection(url, id, pw);

// 3. SQL 실행
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);

// 4. 결과 처리
while(rs.next()) {
    ...
}

// 5. 종료
rs.close();
stmt.close();
con.close();

2-1 드라이버 등록

Class.forName("oracle.jdbc.driver.OracleDriver");

- JAVA가 Oracle DB가 연결할 수 있게 불러오는 코드

2-2 DB 연결

String url = "jdbc:oracle:thin:@localhost:1521/orcl";
String id = "ID";
String pw = "PW";

Connection con = DriverManager.getConnection(url, id, pw);

DB에 로그인하는 영역

- url : DB 주소

- id : DB 계정

- pw : DB 비밀번호

- Connection : DB와 연결된 통로

2-3 SQL 작성

Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);

- Statement : SQL 실행 도구

- ResultSet : SELECT 결과를 담는 상자

executeQuery()는 SELECT문 실행 시 사용

2-4 결과 출력

while(rs.next()) {
    System.out.println(rs.getInt(1) + "\t" + rs.getString(2));
}

- rs.next() : 결과를 한 줄씩 이동화면서 읽는 코드

3. ResultSet 값 꺼내기

3-1 컬럼 번호로 꺼내기

rs.getInt(1)
rs.getString(2)

- rs.getInt(1) : 1번째 컬럼 꺼내기

3-2 컬럼 이름으로 꺼내기

rs.getInt("SALARY")
rs.getString("DEPT_TITLE")

- 컬럼 이름으로 값을 꺼냄

4. 연결 종료

rs.close();
stmt.close();
con.close();

코드	의미
Class.forName()	DB 드라이버 등록
DriverManager.getConnection()	DB 연결
Connection	DB 연결 통로
Statement	SQL 실행 도구
executeQuery()	SELECT 실행
ResultSet	조회 결과 저장
rs.next()	다음 행으로 이동
getString()	문자 데이터 꺼내기
getInt()	숫자 데이터 꺼내기
close()	자원 반납