Java 고급 (38)

자바

[Java 고급] 21장 W3C DOM, 유스케이스 다이어그램

2024. 2. 13. 13:53

W3C (World Wide Web Consortium) DOM (Document Object Model)

DOM : 문서에 접근하는 표준방법.

이를 이용하면 플랫폼 및 개발언어에 독립적으로 문서의 내용, 구조 및 스타일 정보를 핸들링(접근, 수정, 삭제 등) 할 수 있다.

- W3C DOM 표준 3가지
Core DOM : 모든 문서타입을 위한 핵심 표준모델(API)
XML DOM : XML문서를 위한 표준 모델
HTML DOM : HTML문서를 위한 표준 모델
HTML DOM은 HTML 엘리먼트 요소 및 속성 정보를 핸들링하기 위한 인터페이스(API) 제공.

XML DOM을 이용한 XML문서 생성

package kr.or.ddit.basic;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * XML DOM을 이용한 XML문서 생성하기
 * @author PC-10
 *
 */
public class T01DOMCreationTest {
/*
 * W3C(World Wide Web Consortium) DOM(Document Object Model) 표준에 대하여...
 * 
 * 	DOM은 문서에 접근하는 표준방법으로서, 이를 이용하면 플랫폼 및 개발언어에 독립적으로 문서의 내용,
 * 구조 및 스타일 정보를 핸들링(접근, 수정, 삭제 등) 할 수 있다.
 * 
 * W3C DOM 표준은 크게 다음과 같이 크게 3가지로 나누어 볼 수 있다.
 * 
 * Core DOM - 모든 문서타입을 위한 핵심 표준모델(API)
 * XML DOM - XML문서를 위한 표준 모델
 * HTML DOM - HTML문서를 위한 표준 모델
 * 
 * 예를 들면, HTML DOM은 HTML 엘리먼트 요소 및 속성 정보를 핸들링하기 위한 인터페이스(API)를 제공한다.
 */
	
	public void creatDoc() throws ParserConfigurationException {
		
		// XML문서를 생성하기 위한 DocumentBuilder 객체 생성하기
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();
		
		// Document 객체 생성
		Document document = db.newDocument();
		
		// root 엘리먼트 생성
		Element root = document.createElement("root");
		
		// booklist 엘리먼트 생성
		Element booklist = document.createElement("booklist");
		
		// book 엘리먼트 생성 및 속성값 설정하기
		Element book = document.createElement("book");
		book.setAttribute("isbn", "B001");
		book.setAttribute("kind", "JAVA");
		
		// 자식 엘리먼트 생성 및 설정
		Element title = document.createElement("title");
		title.setTextContent("JAVA초급");
		Element author = document.createElement("author");
		author.setTextContent("이순신");
		Element price = document.createElement("price");
		price.setTextContent("25000");
		
		// book 엘리먼트에 자식 엘리먼트 추가하기
		book.appendChild(title);
		book.appendChild(author);
		book.appendChild(price);
		
		// booklist 엘리먼트에 book 엘리먼트 추가하기
		booklist.appendChild(book);
		// -----------------------------------------------------------
        
		// root 엘리먼트에 booklist 엘리먼트 추가하기
		root.appendChild(booklist);
        
		// 문서에 root 엘리먼트 추가하기
		document.appendChild(root);
	}
}

=> 위의 파일 html 형태 예시

<root>
	<booklist>
		<book isbn="B001" kind="JAVA">
			<title>JAVA초급</title>
			<author>이순신</author>
			<price>이순신</price>
		</book>
	</booklist>
</root>

XML 문서 변환기 생성 및 저장

package kr.or.ddit.basic;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * XML DOM을 이용한 XML문서 생성하기
 * @author PC-10
 *
 */
public class T01DOMCreationTest {
/*
 * W3C(World Wide Web Consortium) DOM(Document Object Model) 표준에 대하여...
 * 
 * 	DOM은 문서에 접근하는 표준방법으로서, 이를 이용하면 플랫폼 및 개발언어에 독립적으로 문서의 내용,
 * 구조 및 스타일 정보를 핸들링(접근, 수정, 삭제 등) 할 수 있다.
 * 
 * W3C DOM 표준은 크게 다음과 같이 크게 3가지로 나누어 볼 수 있다.
 * 
 * Core DOM - 모든 문서타입을 위한 핵심 표준모델(API)
 * XML DOM - XML문서를 위한 표준 모델
 * HTML DOM - HTML문서를 위한 표준 모델
 * 
 * 예를 들면, HTML DOM은 HTML 엘리먼트 요소 및 속성 정보를 핸들링하기 위한 인터페이스(API)를 제공한다.
 */
	
	public void creatDoc() throws ParserConfigurationException, FileNotFoundException, TransformerException {
		
		// XML문서를 생성하기 위한 DocumentBuilder 객체 생성하기
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();
		
		// Document 객체 생성
		Document document = db.newDocument();
		
		// root 엘리먼트 생성
		Element root = document.createElement("root");
		
		// booklist 엘리먼트 생성
		Element booklist = document.createElement("booklist");
		
		// book 엘리먼트 생성 및 속성값 설정하기
		Element book = document.createElement("book");
		book.setAttribute("isbn", "B001");
		book.setAttribute("kind", "JAVA");
		
		// 자식 엘리먼트 생성 및 설정
		Element title = document.createElement("title");
		title.setTextContent("JAVA초급");
		Element author = document.createElement("author");
		author.setTextContent("이순신");
		Element price = document.createElement("price");
		price.setTextContent("25000");
		
		// book 엘리먼트에 자식 엘리먼트 추가하기
		book.appendChild(title);
		book.appendChild(author);
		book.appendChild(price);
		
		// booklist 엘리먼트에 book 엘리먼트 추가하기
		booklist.appendChild(book);
		// -----------------------------------------------------------
		
		// book 엘리먼트 생성 및 속성값 설정하기
		book = document.createElement("book");
		book.setAttribute("isbn", "B002");
		book.setAttribute("kind", "JAVA");
		
		// 자식 엘리먼트 생성 및 설정
		title = document.createElement("title");
		title.setTextContent("JAVA고급");
		author = document.createElement("author");
		author.setTextContent("강감찬");
		price = document.createElement("price");
		price.setTextContent("28000");
		
		// book 엘리먼트에 자식 엘리먼트 추가하기
		book.appendChild(title);
		book.appendChild(author);
		book.appendChild(price);
		
		// booklist 엘리먼트에 book 엘리먼트 추가하기
		booklist.appendChild(book);
		// -----------------------------------------------------------
		
		// book 엘리먼트 생성 및 속성값 설정하기
		book = document.createElement("book");
		book.setAttribute("isbn", "B003");
		book.setAttribute("kind", "DB");
		
		// 자식 엘리먼트 생성 및 설정
		title = document.createElement("title");
		title.setTextContent("DB초급");
		author = document.createElement("author");
		author.setTextContent("일지매");
		price = document.createElement("price");
		price.setTextContent("30000");
		
		// book 엘리먼트에 자식 엘리먼트 추가하기
		book.appendChild(title);
		book.appendChild(author);
		book.appendChild(price);
		
		// booklist 엘리먼트에 book 엘리먼트 추가하기
		booklist.appendChild(book);
		// -----------------------------------------------------------
		
		// book 엘리먼트 생성 및 속성값 설정하기
		book = document.createElement("book");
		book.setAttribute("isbn", "B004");
		book.setAttribute("kind", "DB");
		
		// 자식 엘리먼트 생성 및 설정
		title = document.createElement("title");
		title.setTextContent("DB고급");
		author = document.createElement("author");
		author.setTextContent("성춘향");
		price = document.createElement("price");
		price.setTextContent("35000");
		
		// book 엘리먼트에 자식 엘리먼트 추가하기
		book.appendChild(title);
		book.appendChild(author);
		book.appendChild(price);
		
		// booklist 엘리먼트에 book 엘리먼트 추가하기
		booklist.appendChild(book);
		// -----------------------------------------------------------
		
		// root 엘리먼트에 booklist 엘리먼트 추가하기
		root.appendChild(booklist);
		
		// 문서에 root 엘리먼트 추가하기
		document.appendChild(root);
		
		//////////////////////////////////////////////////////////
		
		// XML 문서 변환기 생성하기
		TransformerFactory transformerFactory = TransformerFactory.newInstance();
		Transformer transformer = transformerFactory.newTransformer();
		
		// 출력 인코딩 정보 설정하기
		transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
		
		// 들여쓰기 설정하기(공백크기 : 2)
		transformer.setOutputProperty(OutputKeys.INDENT, "yes");
		transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
		
		// XML 문서 변환작업 하기
		DOMSource source = new DOMSource(document);
		StreamResult result = new StreamResult();
		
		// 파일로 문서 저장하기
		FileOutputStream fos = new FileOutputStream("./src/new_book.xml");
		result.setOutputStream(fos);
		transformer.transform(source, result); // 변환 시작...
		
		System.out.println("변환 작업 끝...");
	}
	
	public static void main(String[] args) throws FileNotFoundException, ParserConfigurationException, TransformerException {
		new T01DOMCreationTest().creatDoc();
	}
}

=> new_book.xml 파일

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<root>
  <booklist>
    <book isbn="B001" kind="JAVA">
      <title>JAVA초급</title>
      <author>이순신</author>
      <price>25000</price>
    </book>
    <book isbn="B002" kind="JAVA">
      <title>JAVA고급</title>
      <author>강감찬</author>
      <price>28000</price>
    </book>
    <book isbn="B003" kind="DB">
      <title>DB초급</title>
      <author>일지매</author>
      <price>30000</price>
    </book>
    <book isbn="B004" kind="DB">
      <title>DB고급</title>
      <author>성춘향</author>
      <price>35000</price>
    </book>
  </booklist>
</root>

XML 문서 읽기

package kr.or.ddit.basic;

import java.awt.print.Book;
import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class T02DOMParsingTest {
	public void parseDoc() throws ParserConfigurationException, SAXException, IOException {
		// XML문서를 생성하기 위한 DocumentBuilder 객체 생성하기
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();

		// Document 객체 생성(기존 문서를 읽어와 파싱하기)
		Document document = db.parse(new File("./src/new_book.xml"));
		
		// root 엘리먼트 접근하기
		Element root = document.getDocumentElement();
		System.out.println("루트 엘리먼트 태그명 : " + root.getTagName());
		
		// 하위 엘리먼트 접근하기
		NodeList bookNodeList = root.getElementsByTagName("book");
		Node firstBookNode = bookNodeList.item(0); // 첫번째 항목 가져오기
		Element firstBookElement = (Element) firstBookNode;
		
		// 앨리먼트 객체의 속성값 가져오기
		System.out.println("firstBookElement 의 속성 isbn 속성값 => "
							+ firstBookElement.getAttribute("isbn"));
		
		// 모든 book 정보 출력하기
		System.out.println("------------------------------------------------------");
		System.out.println("------------------------------------------------------");
		System.out.println("------------------------------------------------------");
	}
	
	public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
		new T02DOMParsingTest().parseDoc();
	}
}

package kr.or.ddit.basic;

import java.awt.print.Book;
import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class T02DOMParsingTest {
	public void parseDoc() throws ParserConfigurationException, SAXException, IOException {
		// XML문서를 생성하기 위한 DocumentBuilder 객체 생성하기
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();

		// Document 객체 생성(기존 문서를 읽어와 파싱하기)
		Document document = db.parse(new File("./src/new_book.xml"));
		
		// root 엘리먼트 접근하기
		Element root = document.getDocumentElement();
		
		// 하위 엘리먼트 접근하기
		NodeList bookNodeList = root.getElementsByTagName("book");
		Node firstBookNode = bookNodeList.item(0); // 첫번째 항목 가져오기
		Element firstBookElement = (Element) firstBookNode;
		
		// 모든 book 정보 출력하기
		System.out.println("------------------------------------------------------");
		System.out.printf("%8s %8s %12s %10s %8s\n", "ISBN", "분류", "제목", "저자", "가격");
		System.out.println("------------------------------------------------------");
		
		for (int i = 0; i < bookNodeList.getLength(); i++) {
			Element bookE1 = (Element) bookNodeList.item(i);
			
			String isbn = bookE1.getAttribute("isbn");
			String kind = bookE1.getAttribute("kind");
			String title = bookE1.getElementsByTagName("title")
							.item(0).getTextContent().trim();
			String author = bookE1.getElementsByTagName("author")
					.item(0).getTextContent().trim();
			String price = bookE1.getElementsByTagName("price")
					.item(0).getTextContent().trim();
			
			System.out.printf("%8s %8s %12s %10s %8s\n", 
								isbn, kind, title, author, price);
		}
		
	}
	
	public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
		new T02DOMParsingTest().parseDoc();
	}
}

문서 파싱

package kr.or.ddit.basic;

import java.net.MalformedURLException;
import java.net.URL;

public class T03DOMParsingExam {
	public void parseDOC() throws MalformedURLException {
		String svcKey = "Grid_20150827000000000227_1";  // 레시피 재료 정보 조회 서비스
		String apiKey = "1df7e8571e8df3f8cbc9b87691ca7d3e4d04f03c593d477e52bf67b03f0b6e1c"; // 개인별 발급.
		String startIdx = "1";  	// 레시피 재료 시작 순번
		String endIdx = "5";	// 레시피 재료 종료 순번
		String recipeId = "195428";	// 래시피가 궁금한 음식 ID

		URL url = new URL("http://211.237.50.150:7080/openapi/"+ apiKey
				+ "/xml/"+ svcKey + "/"+startIdx +"/" + endIdx
				+"?RECIPE_ID=" +  recipeId);
		
		System.out.println(url);
	}
	
	public static void main(String[] args) throws Exception {
		new T03DOMParsingExam().parseDOC();
	}
}

url 파싱

package kr.or.ddit.basic;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class T03DOMParsingExam {
	public void parseDOC() throws ParserConfigurationException, SAXException, IOException {
		String svcKey = "Grid_20150827000000000227_1";  // 레시피 재료 정보 조회 서비스
		String apiKey = "1df7e8571e8df3f8cbc9b87691ca7d3e4d04f03c593d477e52bf67b03f0b6e1c"; // 개인별 발급.
		String startIdx = "1";  	// 레시피 재료 시작 순번
		String endIdx = "5";	// 레시피 재료 종료 순번
		String recipeId = "195428";	// 래시피가 궁금한 음식 ID

		URL url = new URL("http://211.237.50.150:7080/openapi/"+ apiKey
				+ "/xml/"+ svcKey + "/"+startIdx +"/" + endIdx
				+"?RECIPE_ID=" +  recipeId);
		
		//System.out.println(url);
		
		// XML문서를 생성하기 위한 DocumentBuilder 객체 생성하기
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();

		// Document 객체 생성(기존 문서를 읽어와 파싱하기)
		Document document = db.parse(url.toString());
		
		Element root = document.getDocumentElement();

		// 전체 레시피 수 접근
		String totalCnt = root.getElementsByTagName("totalCnt")
							.item(0).getTextContent();
		System.out.println("totalCnt : " + totalCnt);
		
		// 모든 레시피 확인 url 다시 생성
		url = new URL("http://211.237.50.150:7080/openapi/"+ apiKey
				+ "/xml/"+ svcKey + "/"+startIdx +"/" + totalCnt
				+"?RECIPE_ID=" +  recipeId);
		
		document = db.parse(url.toString());
		
		root = document.getDocumentElement();
		
		String code = root.getElementsByTagName("code")
						.item(0).getTextContent();
		
		if(code.equals("INFO-000")) { // 정상 조회된 경우....
			NodeList rowNodeList = root.getElementsByTagName("row");
			
			for(int i=0; i<rowNodeList.getLength(); i++) {
				
				Element rowEl = (Element) rowNodeList.item(i);
				
				String rowNum = rowEl.getElementsByTagName("ROW_NUM")
									.item(0).getTextContent();
				String irdntNm = rowEl.getElementsByTagName("IRDNT_NM")
						.item(0).getTextContent();
				String irdntCpcty = rowEl.getElementsByTagName("IRDNT_CPCTY")
						.item(0).getTextContent();
				String irdntTyNm = rowEl.getElementsByTagName("IRDNT_TY_NM")
						.item(0).getTextContent();
				
				System.out.printf("%3s %8s %10s %10s %8s\n", 
									rowNum, recipeId, irdntTyNm, irdntNm, irdntCpcty);
				System.out.println("---------------------------------------------------------");
			}
		}
	}
	
	public static void main(String[] args) throws Exception {
		new T03DOMParsingExam().parseDOC();
	}
}

클래스 다이어그램

: 시간에 따라 변하지 않는 시스템의 정적인 면을 보여주는 대표적인 UML 구조 다이어그램이다.

시스템을 구성하는 클래스들 사이의 관계를 표현한다.

관계

1. 연관 관계 (associtation)

2. 일반화 관계 (generalization)

: 한 클래스가 다른 클래스를 포함하는 상위 개념일때 두 클래스 사이의 관계

3. 집합 관계

: 전체와 부분의 관계를 명확하게 명시할 때 사용

1) 집약 관계 (aggregation) : 한 객체가 다른 객체를 포함하는 것

2) 합성 관계 (composition) : 부분 객체가 전체 객체에 속하는 관계

4. 의존 관계 (dependency)

: 클래스가 다른 클래스를 사용하는 경우

5. 실체화 관계 (realization)

: 인터페이스와 클래스들 사이 간의 관계

유스케이스 명세서

유스케이스(Use case) : 사용 예, 행위자가 유용한 일을 달성하기 위한 시나리오의 집합

유스케이스 다이어그램은 유스케이스가 제공하는 모든 기능을 명시한다.

유스케이스 사이의 관계

1. 포함 관계(<<include>>) : 중복적으로 발생하는 흐름을 표현하기 위해 사용

2. 확장 관계(<<extend>>) : 유스케이스에서 특정 조건에서 여러가지 형태로 분류될 경우 사용

주의 사항

1. Use Case 간의 관계를 정의할 수 없음

2. Use Case의 시나리오를 명확하게 나눠야 함

3. 외부 시스템 Actor는 수행 Actor로 정의하지 않음

4. Use Case 추출 시 대응되는 필요 기능 필수

5. 시스템의 기능과 관련 없는 Use Case 추출 금지

6. Use Case의 역할을 나타낼 수 있는 명칭 사용

7. 개발 시스템의 이름을 액터로 제작 불가

ex) 도서 대출 시스템 개발 시 도서 대출 시스템은 액터가 될 수 없음

예시

'자바' 카테고리의 다른 글

[Java 고급] 23장 소켓 (1)	2024.02.15
[Java 고급] 22장 IP주소 정보 (0)	2024.02.14
[Java 고급] 20장 로깅 (0)	2024.02.08
[Java 고급] 19장 Mybatis (0)	2024.02.07
[Java 고급] 18장 Singleton 패턴 (0)	2024.02.07

자바

[Java 고급] 20장 로깅

2024. 2. 8. 13:53

로깅

: 로그 시스템의 사용하여 기록하는 것

Log4J

: Java를 위한 로깅 프레임 워크

주석 처리로 출력하지 않아도 편하게 로그 정보를 확인할 수 있다. 또한 여러 방법으로 정보를 출력하여 볼 수 있으며, 로그 레벨에 따라 확인할 수 있다.

- 주요 구성 요소

Loggers : 로깅 정보 캡처

appenders : 다양한 목적지로 로깅 정보 출력

Log4j 로그레벨

로그레벨	설명
TRACE	모든 로깅정보 출력
DEBUG	애플리케이션 디버그
INFO	정보성 메시지 출력
WARN	잠재적 위험(경고) 메시지 출력
ERROR	애플리케이션 실행 중 발생 에러 출력
FATAL	심각한 에러메시지 출력 (애플리케이션 실행 멈추기 가능)

사용법

private static final Logger SQL_LOGGER = 
	LogManager.getLogger("log4jexam.sql.Query");

// 로깅 프레임워크 사용 : 디버그 레벨
//System.out.println("sql : " + sql);
SQL_LOGGER.debug("sql : " + sql);

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>

  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>

  <Loggers>
  	<!-- 여기에 로거 추가 -->

    <Root level="trace">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>

</Configuration>

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>

  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
    <File name="MyFile" fileName="Logs/app.log">
      <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </File>
  </Appenders>

  <Loggers>
  	<!-- 여기에 로거 추가 -->
	<!--additivity="false"로 중복 출력 막음-->
	<Logger name="log4jexam.sql.Query" level="trace" additivity="false">
      <AppenderRef ref="Console"/>
	</Logger>
	<Logger name="log4jexam.sql.Parameter" level="trace" additivity="false">
      <AppenderRef ref="Console"/>
      <AppenderRef ref="MyFile"/>
	</Logger>
	<Logger name="kr.or.ddit.basic.T01MemberInfoTest" level="trace" additivity="false">
      <AppenderRef ref="Console"/>
	</Logger>
	
    <Root level="info">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>

</Configuration>

package kr.or.ddit.basic;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDate;
import java.util.Scanner;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import kr.or.ddit.util.JDBCUtil3;

/*
	회원정보를 관리하는 프로그램을 작성하는데 
	아래의 메뉴를 모두 구현하시오. (CRUD기능 구현하기)
	(DB의 MYMEMBER테이블을 이용하여 작업한다.)
	
	* 자료 삭제는 회원ID를 입력 받아서 삭제한다.
	
	예시메뉴)
	----------------------
		== 작업 선택 ==
		1. 자료 입력			---> insert
		2. 자료 삭제			---> delete
		3. 자료 수정			---> update
		4. 전체 자료 출력	---> select
		5. 작업 끝.
	----------------------
	 
	   
// 회원관리 프로그램 테이블 생성 스크립트 
create table mymember(
    mem_id varchar2(8) not null,  -- 회원ID
    mem_name varchar2(100) not null, -- 이름
    mem_tel varchar2(50) not null, -- 전화번호
    mem_addr varchar2(128),    -- 주소
    reg_dt DATE DEFAULT sysdate, -- 등록일
    CONSTRAINT MYMEMBER_PK PRIMARY KEY (mem_id)
);

*/
public class T01MemberInfoTest {
	
	private Connection conn;
	private Statement stmt;
	private PreparedStatement pstmt;
	private ResultSet rs;
	
	private Scanner scan = new Scanner(System.in);
	
	// 객체가 변경되지 않게 하기 위해 설정
	private static final Logger SQL_LOGGER = 
			LogManager.getLogger("log4jexam.sql.Query");
	private static final Logger PARAM_LOGGER = 
			LogManager.getLogger("log4jexam.sql.Parameter");
	private static final Logger RESULT_LOGGER = 
			LogManager.getLogger(T01MemberInfoTest.class);
	
	/**
	 * 메뉴를 출력하는 메서드
	 */
	public void displayMenu(){
		System.out.println();
		System.out.println("----------------------");
		System.out.println("  === 작 업 선 택 ===");
		System.out.println("  1. 자료 입력");
		System.out.println("  2. 자료 삭제");
		System.out.println("  3. 자료 수정");
		System.out.println("  4. 전체 자료 출력");
		System.out.println("  5. 작업 끝.");
		System.out.println("----------------------");
		System.out.print("원하는 작업 선택 >> ");
	}
	
	/**
	 * 프로그램 시작메서드
	 */
	public void start(){
		int choice;
		do{
			displayMenu(); //메뉴 출력
			choice = scan.nextInt(); // 메뉴번호 입력받기
			switch(choice){
				case 1 :  // 자료 입력
					insertMember();
					break;
				case 2 :  // 자료 삭제
					deleteMember();
					break;
				case 3 :  // 자료 수정
					updateMember();
					break;
				case 4 :  // 전체 자료 출력
					displayMember();
					break;
				case 5 :  // 작업 끝
					System.out.println("작업을 마칩니다.");
					break;
				default :
					System.out.println("번호를 잘못 입력했습니다. 다시입력하세요");
			}
		}while(choice!=5);
	}
	
	/**
	 * 회원정보를 모두 출력하기 위한 메서드
	 */
	private void displayMember() {
		System.out.println();
		System.out.println("---------------------------------------------");
		System.out.println(" ID\t생성일\t이 름\t전화번호\t\t주    소");
		System.out.println("---------------------------------------------");
		
		try {
			conn = JDBCUtil3.getConnection();
			
			String sql = "select * from mymember";
			
			stmt = conn.createStatement();
			rs = stmt.executeQuery(sql);
			
			while(rs.next()) {
				String memId = rs.getString("mem_id");
				String memName = rs.getString("mem_name");
				String memTel = rs.getString("mem_tel");
				String memAddr = rs.getString("mem_addr");
				
				// 날짜만 가져올 때: LocalDate, 시간까지 가져올 때: LocalDateTime
				LocalDate regDt = rs.getTimestamp("reg_dt")
						.toLocalDateTime().toLocalDate();
				
				System.out.println(" " + memId + "\t" + regDt 
									+ "\t" + memName + "\t" + memTel
									+ "\t\t" + memAddr);
			}
			
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			JDBCUtil3.close(conn, pstmt, stmt, rs);
		}
	}

	/**
	 * 회원정보를 삭제하기 위한 메서드
	 */
	private void deleteMember() {
		
		System.out.println();
		System.out.println("삭제할 회원 정보를 입력하세요.");
		System.out.print("회원ID >> ");
		String memId = scan.next();
		
		try {
			conn = JDBCUtil3.getConnection();
			
			String sql = "delete from mymember where mem_id = ? ";
			
			pstmt = conn.prepareStatement(sql);
			pstmt.setString(1, memId);
			
			int cnt = pstmt.executeUpdate();
			
			if(cnt > 0) {
				System.out.println(memId + "인 회원정보 삭제 성공!");
			} else {
				System.out.println(memId + "인 회원정보 삭제 실패!");
			}
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			JDBCUtil3.close(conn, pstmt, stmt, rs);
		}
	}

	/**
	 * 회원정보를 수정하기 위한 메서드
	 */
	private void updateMember() {
		boolean isExist = false;
		
		System.out.println();
		System.out.println("수정할 회원 정보를 입력하세요.");
		System.out.print("회원ID >> ");
		String memId = scan.next();
		
		isExist = checkMember(memId);
		
		if(!isExist) {
			System.out.println(memId + "인 회원이 존재하지 않습니다.");
			System.out.println("다시 입력해 주세요.");
			return;
		}
		
		System.out.print("회원 이름 >> ");
		String memName = scan.next();
		
		System.out.print("회원 전화번호 >> ");
		String memTel = scan.next();
		
		scan.nextLine(); // 버퍼에 남아있을 엔터키 제거용
		
		System.out.print("회원 주소 >> ");
		String memAddr = scan.nextLine();
		
		// JDBC 코딩 시작...
		
		try {
			// 오라클 접속...
			conn = JDBCUtil3.getConnection();
			
			String sql = "update mymember\r\n" + 
						 "set mem_name = ?,\r\n" + 
						 "mem_tel = ?,\r\n" + 
						 "mem_addr = ?\r\n" + 
						 "where mem_id = ?";
			
			pstmt = conn.prepareStatement(sql);
			pstmt.setString(1, memName);
			pstmt.setString(2, memTel);
			pstmt.setString(3, memAddr);
			pstmt.setString(4, memId);
			
			// executeQuery // select 할 때
			int cnt = pstmt.executeUpdate(); // insert, update, delete
			
			System.out.println();
			if(cnt > 0) {
				System.out.println(memId + "회원 정보 수정작업 성공!");
			} else {
				System.out.println(memId + "회원 정보 수정작업 실패...");
			}
			
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			// 자원 반납 필수!! 하지 않을 시 메모리 누수 현상이 발생함
			JDBCUtil3.close(conn, pstmt, stmt, rs);
		}
	}

	/**
	 * 회원 정보를 등록하기 위한 메서드
	 */
	private void insertMember() {
		
		boolean isExist = false;
		
		System.out.println();
		System.out.println("추가할 회원 정보를 입력하세요.");
		System.out.print("회원ID >> ");
		String memId = scan.next();
		
		isExist = checkMember(memId);
		
		if(isExist) {
			System.out.println(memId + "인 회원이 이미 존재합니다.");
			System.out.println("다시 입력해 주세요.");
			return;
		}
		
		System.out.print("회원 이름 >> ");
		String memName = scan.next();
		
		System.out.print("회원 전화번호 >> ");
		String memTel = scan.next();
		
		scan.nextLine(); // 버퍼에 남아있을 엔터키 제거용
		
		System.out.print("회원 주소 >> ");
		String memAddr = scan.nextLine();
		
		// JDBC 코딩 시작...
		
		try {
			// 오라클 접속...
			conn = JDBCUtil3.getConnection();
			
			String sql = "insert into mymember" + 
					" (mem_id, mem_name, mem_tel, mem_addr)\r\n" + 
					"values (?, ?, ?, ?)";
			
			// 로깅 프레임워크 사용 : 디버그 레벨
//			System.out.println("sql : " + sql);
			SQL_LOGGER.debug("sql : " + sql);
			
			pstmt = conn.prepareStatement(sql);
			pstmt.setString(1, memId);
			pstmt.setString(2, memName);
			pstmt.setString(3, memTel);
			pstmt.setString(4, memAddr);
			
			PARAM_LOGGER.debug("param : " + "memId = " + memId + ", memName = " + memName
								+ ", memTel = " + memTel + ", memAddr = " + memAddr);
			
			// executeQuery // select 할 때
			int cnt = pstmt.executeUpdate(); // insert, update, delete
			
			RESULT_LOGGER.info("cnt : " + cnt);
			
			
			System.out.println();
			if(cnt > 0) {
				System.out.println(memId + "회원 정보 등록작업 성공!");
			} else {
				System.out.println(memId + "회원 정보 등록작업 실패...");
			}
			
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			// 자원 반납 필수!! 하지 않을 시 메모리 누수 현상이 발생함
			JDBCUtil3.close(conn, pstmt, stmt, rs);
		}
	}

	/**
	 * 회원 정보가 존재하는지 체크하기 위한 메서드
	 * @param memId 체크할 회원ID
	 * @return
	 */
	private boolean checkMember(String memId) {
		
		boolean isExist = false;
		
		try {
			conn = JDBCUtil3.getConnection();
			
			String sql = "select count(*) cnt\r\n" + 
					"from mymember\r\n" + 
					"where mem_id = ?";
			
			pstmt = conn.prepareStatement(sql);
			pstmt.setString(1, memId);
			
			rs = pstmt.executeQuery();
			
			while(rs.next()) {
				int cnt = rs.getInt("cnt");
				
				if(cnt > 0) {
					isExist = true;
				}
			}
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			JDBCUtil3.close(conn, pstmt, stmt, rs);
		}
		
		return isExist;
	}

	public static void main(String[] args) {
		T01MemberInfoTest memObj = new T01MemberInfoTest();
		memObj.start();
	}

}

package kr.or.ddit.member;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDate;
import java.util.List;
import java.util.Scanner;

import kr.or.ddit.member.dao.IMemberDao;
import kr.or.ddit.member.dao.MemberDaoImplForJDBC;
import kr.or.ddit.member.service.IMemberService;
import kr.or.ddit.member.service.MemberServiceImpl;
import kr.or.ddit.member.vo.MemberVO;
import kr.or.ddit.util.JDBCUtil3;

/*
	회원정보를 관리하는 프로그램을 작성하는데 
	아래의 메뉴를 모두 구현하시오. (CRUD기능 구현하기)
	(DB의 MYMEMBER테이블을 이용하여 작업한다.)
	
	* 자료 삭제는 회원ID를 입력 받아서 삭제한다.
	
	예시메뉴)
	----------------------
		== 작업 선택 ==
		1. 자료 입력			---> insert
		2. 자료 삭제			---> delete
		3. 자료 수정			---> update
		4. 전체 자료 출력	---> select
		5. 작업 끝.
	----------------------
	 
	   
// 회원관리 프로그램 테이블 생성 스크립트 
create table mymember(
    mem_id varchar2(8) not null,  -- 회원ID
    mem_name varchar2(100) not null, -- 이름
    mem_tel varchar2(50) not null, -- 전화번호
    mem_addr varchar2(128),    -- 주소
    reg_dt DATE DEFAULT sysdate, -- 등록일
    CONSTRAINT MYMEMBER_PK PRIMARY KEY (mem_id)
);

*/
public class MemberMain {
	
	private IMemberService memService;
	private Scanner scan;
	
	public MemberMain() {
		memService = MemberServiceImpl.getInstance();
		scan = new Scanner(System.in);
	}
	
	/**
	 * 메뉴를 출력하는 메서드
	 */
	public void displayMenu(){
		System.out.println();
		System.out.println("----------------------");
		System.out.println("  === 작 업 선 택 ===");
		System.out.println("  1. 자료 입력");
		System.out.println("  2. 자료 삭제");
		System.out.println("  3. 자료 수정");
		System.out.println("  4. 전체 자료 출력");
		System.out.println("  5. 자료 검색");
		System.out.println("  6. 작업 끝.");
		System.out.println("----------------------");
		System.out.print("원하는 작업 선택 >> ");
	}
	
	/**
	 * 프로그램 시작메서드
	 */
	public void start(){
		int choice;
		do{
			displayMenu(); //메뉴 출력
			choice = scan.nextInt(); // 메뉴번호 입력받기
			switch(choice){
				case 1 :  // 자료 입력
					insertMember();
					break;
				case 2 :  // 자료 삭제
					deleteMember();
					break;
				case 3 :  // 자료 수정
					updateMember();
					break;
				case 4 :  // 전체 자료 출력
					displayMember();
					break;
				case 5 :  // 검색
					searchMember();
					break;
				case 6 :  // 작업 끝
					System.out.println("작업을 마칩니다.");
					break;
				default :
					System.out.println("번호를 잘못 입력했습니다. 다시입력하세요");
			}
		}while(choice!=6);
	}
	
	/**
	 * 회원정보 검색을 위한 메서드
	 */
	private void searchMember() {
		/*
			검색할 회원ID, 회원이름, 전화번호, 주소 등을 입력하면
			입력한 정보만 사용하여 검색하는 기능을 구현하시오.
			주소는 입력한 값이 포함만 되어도 검색 가능하도록 한다.
			입력하지 않을 데이터는 엔터키로 다음 입력으로 넘긴다.
		 */
		
		scan.nextLine(); // 버퍼 비우기
		
		System.out.println();
		System.out.println("검색할 회원 정보를 입력하세요.");
		System.out.print("회원 ID >> ");
		String memId = scan.nextLine().trim();
		
		System.out.print("회원 이름 >> ");
		String memName = scan.nextLine().trim();
		
		System.out.print("회원 전화번호 >> ");
		String memTel = scan.nextLine().trim();
		
		System.out.print("회원 주소 >> ");
		String memAddr = scan.nextLine().trim();
		
		MemberVO paramMv = new MemberVO(memId, memName, memTel, memAddr);
		
		List<MemberVO> memList = memService.searchMember(paramMv);
		
		////////////////////////////////////////////////////////////////
		
		System.out.println();
		System.out.println("----------------------------------------------------------");
		System.out.println(" ID\t생성일\t\t이 름\t전화번호\t\t주    소");
		System.out.println("----------------------------------------------------------");
		
		if(memList.size() == 0) {
			System.out.println("회원정보가 존재하지 않습니다.");
		} else {
			
			for (MemberVO mv : memList) {
				System.out.println(" " + mv.getMemId() + "\t" + mv.getRegDt() 
						+ "\t" + mv.getMemName() + "\t" + mv.getMemTel()
						+ "\t\t" + mv.getMemAddr());
			}
		}
		
	}

	/**
	 * 회원정보를 모두 출력하기 위한 메서드
	 */
	private void displayMember() {
		System.out.println();
		System.out.println("----------------------------------------------------------");
		System.out.println(" ID\t생성일\t\t이 름\t전화번호\t\t주    소");
		System.out.println("----------------------------------------------------------");
		
		List<MemberVO> memList = memService.displayMember();
		
		if(memList.size() == 0) {
			System.out.println("회원정보가 존재하지 않습니다.");
		} else {
			
			for (MemberVO mv : memList) {
				System.out.println(" " + mv.getMemId() + "\t" + mv.getRegDt() 
						+ "\t" + mv.getMemName() + "\t" + mv.getMemTel()
						+ "\t\t" + mv.getMemAddr());
			}
		}
	}

	/**
	 * 회원정보를 삭제하기 위한 메서드
	 */
	private void deleteMember() {
		
		System.out.println();
		System.out.println("삭제할 회원 정보를 입력하세요.");
		System.out.print("회원ID >> ");
		String memId = scan.next();
		
		int cnt = memService.removeMember(memId);
		
		if(cnt > 0) {
			System.out.println(memId + "인 회원정보 삭제 성공!");
		} else {
			System.out.println(memId + "인 회원정보 삭제 실패!");
		}
	}

	/**
	 * 회원정보를 수정하기 위한 메서드
	 */
	private void updateMember() {
		boolean isExist = false;
		
		System.out.println();
		System.out.println("수정할 회원 정보를 입력하세요.");
		System.out.print("회원ID >> ");
		String memId = scan.next();
		
		isExist = memService.checkMember(memId);
		
		if(!isExist) {
			System.out.println(memId + "인 회원이 존재하지 않습니다.");
			System.out.println("다시 입력해 주세요.");
			return;
		}
		
		System.out.print("회원 이름 >> ");
		String memName = scan.next();
		
		System.out.print("회원 전화번호 >> ");
		String memTel = scan.next();
		
		scan.nextLine(); // 버퍼에 남아있을 엔터키 제거용
		
		System.out.print("회원 주소 >> ");
		String memAddr = scan.nextLine();
		
		
		MemberVO mv = new MemberVO(memId, memName, memTel, memAddr);
		int cnt = memService.modifyMember(mv);
		
		System.out.println();
		if(cnt > 0) {
			System.out.println(memId + "회원 정보 수정작업 성공!");
		} else {
			System.out.println(memId + "회원 정보 수정작업 실패...");
		}
	}

	/**
	 * 회원 정보를 등록하기 위한 메서드
	 */
	private void insertMember() {
		
		boolean isExist = false;
		
		System.out.println();
		System.out.println("추가할 회원 정보를 입력하세요.");
		System.out.print("회원ID >> ");
		String memId = scan.next();
		
		isExist = memService.checkMember(memId);
		
		if(isExist) {
			System.out.println(memId + "인 회원이 이미 존재합니다.");
			System.out.println("다시 입력해 주세요.");
			return;
		}
		
		System.out.print("회원 이름 >> ");
		String memName = scan.next();
		
		System.out.print("회원 전화번호 >> ");
		String memTel = scan.next();
		
		scan.nextLine(); // 버퍼에 남아있을 엔터키 제거용
		
		System.out.print("회원 주소 >> ");
		String memAddr = scan.nextLine();
		
		MemberVO mv = new MemberVO(memId, memName, memTel, memAddr);
		
		int cnt = memService.registMember(mv);
		
		System.out.println();
		if(cnt > 0) {
			System.out.println(memId + "회원 정보 등록작업 성공!");
		} else {
			System.out.println(memId + "회원 정보 등록작업 실패...");
		}
	}

	public static void main(String[] args) {
		MemberMain memObj = new MemberMain();
		memObj.start();
	}

}

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>

  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
    <File name="MyFile" fileName="Logs/app.log">
      <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </File>
  </Appenders>

  <Loggers>
  	<!-- 여기에 로거 추가 -->
	
    <Root level="trace">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>

</Configuration>

'자바' 카테고리의 다른 글

[Java 고급] 22장 IP주소 정보 (0)	2024.02.14
[Java 고급] 21장 W3C DOM, 유스케이스 다이어그램 (0)	2024.02.13
[Java 고급] 19장 Mybatis (0)	2024.02.07
[Java 고급] 18장 Singleton 패턴 (0)	2024.02.07
[Java 고급] 17장 MVC 패턴 (0)	2024.02.06

자바

[Java 고급] 19장 Mybatis

2024. 2. 7. 13:53

Mybatis

: 데이터베이스를 쉽게 다룰 수 있도록 도와주는 오픈 소스 ORM(Object-Relational Mapping) 프레임워크

DB를 쉽게 다룰 수 있으며 동적 쿼리 작성이 가능하다.

=> preparedstatement처럼 쿼리문을 복잡하게 입력하지 않고 실제 쿼리문과 유사하게 작성 가능

.properties 파일에 기입했던 정보들 기입

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

	<environments default="dev">
		<environment id="dev">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
				<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
				<property name="username" value=""/>
				<property name="password" value=""/>
			</dataSource>
		</environment>
	</environments>

	<mappers>
		<mapper resource="mapper/member.xml"/>
	</mappers>
</configuration>

- 사용할 수 있는 기본적인 태그들

<select> ~~~ </select>
<insert> ~~~ </insert>
<update> ~~~ </update>
<delete> ~~~ </delete>

- 위 태그에서 사용되는 주요 속성들
1) id : 해당 태그를 호출할 때 namespace값과 연결하여 사용하는 id값

2) parameterType : 파라미터 객체의 타입정보를 지정한다.
(보통 VO클래스명, 자바의 데이터타입 등이 사용된다. ALias명 사용 가능함.)

3) resultType : select문을 실행한 결과값을 담을 객체타입을 지정한다.
(보통 VO클래스명, 자바의 데이터타입 등이 사용된다. ALias명 사용 가능함.)

4) resultMap : 결과 레코드 컬럼명과 VO객체의 속성명이 다를 경우에 적절한 매핑을 위해 사용한다.

insert

<?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="memberTest">

	<insert id="insertMember" parameterType="kr.or.ddit.member.vo.MemberVO">
		insert into mymember 
		(mem_id, mem_name, mem_tel, mem_addr) 
		values (#{memId}, #{memName}, #{memTel}, #{memAddr})
	</insert>
	
</mapper>

package kr.or.ddit.basic;

import java.io.IOException;
import java.io.Reader;
import java.nio.charset.Charset;

import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import kr.or.ddit.member.vo.MemberVO;

public class MybatisTest {
	public static void main(String[] args) {
		
		// 1. myBatis의 환경설정 파일을 읽어와 실행시킨다.
		SqlSessionFactory sqlSessionFactory = null;
		
		try {
			// 1-1. xml 설정문서 읽어오기
			Charset charset = Charset.forName("UTF-8"); // 설정파일의 한글처리를 위해서...
			Resources.setCharset(charset);
			
			// 반드시 설정 파일을 넣어야 함. xml형식 고정
			Reader rd = Resources.getResourceAsReader("config/mybatis-config.xml");
			
			// 1-2. 위에서 생성한 Reader객체를 사용하여 SqlSessionFactory 객체 생성한다.
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(rd);
			
			rd.close(); // 사용한 스트림 객체 닫아주기
			
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		/////////////////////////////////////////////////////////////////////
		
		// 2. 실행한 SQL문이 있는 쿼리문을 지정하여 원하는 작업을 수행한다.
		
		// 2-1. insert작업 연습
		System.out.println("insert 작업 시작...");
		
		// 1) 저장할 데이터를 VO에 담는다.
		MemberVO mv = new MemberVO();
		mv.setMemId("d001");
		mv.setMemName("강감찬");
		mv.setMemTel("111-111");
		mv.setMemAddr("경남 진주시");
		
		// SqlSession객체를 이용하여 해당 쿼리문을 수행시킨다.
		// ex) SqlSession객체.insert("namespace값.id값", 파라미터객체);
		SqlSession sqlSession = sqlSessionFactory.openSession(false); // 오토커밋 여부 지정 >> false 이기에 따로 커밋 처리 해줘야함.
		
		try {
			int cnt = sqlSession.insert("memberTest.insertMember", mv);
			
			if(cnt > 0) {
				System.out.println("insert 작업 성공!");
				
				sqlSession.commit(); // 커밋... / 커밋 하지 않을 때 close 할 시 롤백이 진행됨.
				
			} else {
				System.out.println("insert 작업 실패!!!");
			}
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}
}

update

<?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="memberTest">

	<update id="updateMember" parameterType="kr.or.ddit.member.vo.MemberVO">
		update mymember
		set mem_name = #{memName}, 
		mem_tel = #{memTel}, 
		mem_addr = #{memAddr} 
		where mem_id = #{memId}
	</update>
    
</mapper>

package kr.or.ddit.basic;

import java.io.IOException;
import java.io.Reader;
import java.nio.charset.Charset;
import java.time.Period;
import java.util.List;

import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import kr.or.ddit.member.vo.MemberVO;

public class MybatisTest {
	public static void main(String[] args) {
		
		// 1. myBatis의 환경설정 파일을 읽어와 실행시킨다.
		SqlSessionFactory sqlSessionFactory = null;
		
		try {
			// 1-1. xml 설정문서 읽어오기
			Charset charset = Charset.forName("UTF-8"); // 설정파일의 한글처리를 위해서...
			Resources.setCharset(charset);
			
			// 반드시 설정 파일을 넣어야 함. xml형식 고정
			Reader rd = Resources.getResourceAsReader("config/mybatis-config.xml");
			
			// 1-2. 위에서 생성한 Reader객체를 사용하여 SqlSessionFactory 객체 생성한다.
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(rd);
			
			rd.close(); // 사용한 스트림 객체 닫아주기
			
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		/////////////////////////////////////////////////////////////////////
		
		// 2. 실행한 SQL문이 있는 쿼리문을 지정하여 원하는 작업을 수행한다.
		
		// 2-2. update 연습
		System.out.println("update작업 시작...");
		
		MemberVO mv2 = new MemberVO();
		mv2.setMemId("d001");
		mv2.setMemName("박채연");
		mv2.setMemTel("555-555");
		mv2.setMemAddr("부산시");
		
		sqlSession = sqlSessionFactory.openSession();
		
		try {
			// update()의 반환값도 성공한 레코드 수이다.
			int cnt = sqlSession.update("memberTest.updateMember", mv2);
			
			if(cnt > 0) {
				System.out.println("update작업 성공");
			} else {
				System.out.println("update작업 실패!!!");
			}
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}
}

delete

넘어오는 게 하나일 경우 어떤 글자를 쓰든 신경쓰지 않고 집어 넣음

<?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="memberTest">
	
	<delete id="deleteMember" parameterType="String">
		delete from mymember where mem_id = #{오병준}
	</delete>
	
</mapper>

package kr.or.ddit.basic;

import java.io.IOException;
import java.io.Reader;
import java.nio.charset.Charset;
import java.time.Period;
import java.util.List;

import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import kr.or.ddit.member.vo.MemberVO;

public class MybatisTest {
	public static void main(String[] args) {
		
		// 1. myBatis의 환경설정 파일을 읽어와 실행시킨다.
		SqlSessionFactory sqlSessionFactory = null;
		
		try {
			// 1-1. xml 설정문서 읽어오기
			Charset charset = Charset.forName("UTF-8"); // 설정파일의 한글처리를 위해서...
			Resources.setCharset(charset);
			
			// 반드시 설정 파일을 넣어야 함. xml형식 고정
			Reader rd = Resources.getResourceAsReader("config/mybatis-config.xml");
			
			// 1-2. 위에서 생성한 Reader객체를 사용하여 SqlSessionFactory 객체 생성한다.
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(rd);
			
			rd.close(); // 사용한 스트림 객체 닫아주기
			
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		/////////////////////////////////////////////////////////////////////
		
		// 2. 실행한 SQL문이 있는 쿼리문을 지정하여 원하는 작업을 수행한다.
		
		// 2-3. delete 연습
		System.out.println("delete 작업 시작...");
		
		sqlSession = sqlSessionFactory.openSession();
		
		try {
			int cnt = sqlSession.delete("memberTest.deleteMember", "d001");
			
			if(cnt > 0) {
				System.out.println("삭제 작업 성공!");
				sqlSession.commit();
			} else {
				System.out.println("삭제 작업 실패!!!");
				sqlSession.rollback();
			}
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}
}

selectList

select의 경우 실행한 결과값을 담을 객체타입 지정이 필수다.

<?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="memberTest">
	
	<select id="selectAllMember" resultType="kr.or.ddit.member.vo.MemberVO">
		select mem_id as memId, 
			mem_name as memName, 
			mem_tel as memTel, 
			mem_addr as memAddr 
		from mymember
	</select>
	
</mapper>

package kr.or.ddit.basic;

import java.io.IOException;
import java.io.Reader;
import java.nio.charset.Charset;
import java.time.Period;
import java.util.List;

import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import kr.or.ddit.member.vo.MemberVO;

public class MybatisTest {
	public static void main(String[] args) {
		
		// 1. myBatis의 환경설정 파일을 읽어와 실행시킨다.
		SqlSessionFactory sqlSessionFactory = null;
		
		try {
			// 1-1. xml 설정문서 읽어오기
			Charset charset = Charset.forName("UTF-8"); // 설정파일의 한글처리를 위해서...
			Resources.setCharset(charset);
			
			// 반드시 설정 파일을 넣어야 함. xml형식 고정
			Reader rd = Resources.getResourceAsReader("config/mybatis-config.xml");
			
			// 1-2. 위에서 생성한 Reader객체를 사용하여 SqlSessionFactory 객체 생성한다.
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(rd);
			
			rd.close(); // 사용한 스트림 객체 닫아주기
			
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		/////////////////////////////////////////////////////////////////////
		
		// 2. 실행한 SQL문이 있는 쿼리문을 지정하여 원하는 작업을 수행한다.
		
		// 2-4. select 연습
		// 1) 응답결과가 여러개일 경우
		System.out.println("select 연습 시작(결과가 여러개인 경우)...");
		
		// 응답결과가 여러개일 경우에는 selectList를 사용한다.
		sqlSession = sqlSessionFactory.openSession(true);
		
		try {
			List<MemberVO> memList = 
					sqlSession.selectList("memberTest.selectAllMember");
			
			for (MemberVO mv3 : memList) {
				System.out.println("ID : " + mv3.getMemId());
				System.out.println("이름 : " + mv3.getMemName());
				System.out.println("전화 : " + mv3.getMemTel());
				System.out.println("주소 : " + mv3.getMemAddr());
				System.out.println("=========================================");
			}
			
			System.out.println("출력 작업 끝...");
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			sqlSession.close();
		}		
	}
}

selectOne

<?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="memberTest">

	<select id="getMember" resultType="kr.or.ddit.member.vo.MemberVO">
		select mem_id as memId, 
			mem_name as memName, 
			mem_tel as memTel, 
			mem_addr as memAddr 
		from mymember
		where mem_id = #{memId}
	</select>
    
</mapper>

package kr.or.ddit.basic;

import java.io.IOException;
import java.io.Reader;
import java.nio.charset.Charset;
import java.time.Period;
import java.util.List;

import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import kr.or.ddit.member.vo.MemberVO;

public class MybatisTest {
	public static void main(String[] args) {
		
		// 1. myBatis의 환경설정 파일을 읽어와 실행시킨다.
		SqlSessionFactory sqlSessionFactory = null;
		
		try {
			// 1-1. xml 설정문서 읽어오기
			Charset charset = Charset.forName("UTF-8"); // 설정파일의 한글처리를 위해서...
			Resources.setCharset(charset);
			
			// 반드시 설정 파일을 넣어야 함. xml형식 고정
			Reader rd = Resources.getResourceAsReader("config/mybatis-config.xml");
			
			// 1-2. 위에서 생성한 Reader객체를 사용하여 SqlSessionFactory 객체 생성한다.
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(rd);
			
			rd.close(); // 사용한 스트림 객체 닫아주기
			
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		/////////////////////////////////////////////////////////////////////
		
		// 2. 실행한 SQL문이 있는 쿼리문을 지정하여 원하는 작업을 수행한다.
		
		// 2-4. select 연습
		// 1) 응답결과가 여러개일 경우
        
		// 2) 응답결과가 1개일 경우
		System.out.println("select 연습(결과값이 1개가 확실한 경우)...");
		
		sqlSession = sqlSessionFactory.openSession(true);
		
		try {
			MemberVO mv4 = sqlSession.selectOne("memberTest.getMember", "a001");
			
			System.out.println("ID : " + mv4.getMemId());
			System.out.println("이름 : " + mv4.getMemName());
			System.out.println("전화 : " + mv4.getMemTel());
			System.out.println("주소 : " + mv4.getMemAddr());
			System.out.println("=========================================");
			
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			sqlSession.close();
		}
	}
}

회원정보 관리 프로그램

=> Dao의 기능을 하는 Mybatis를 이용하여 변경한다.

기존에 있던 프로그램을 응용하여 추가 및 수정한다.

package kr.or.ddit.member.dao;

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

import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.session.SqlSession;

import kr.or.ddit.member.vo.MemberVO;
import kr.or.ddit.util.MyBatisUtil;

public class MemberDaoImpl implements IMemberDao{

	private static IMemberDao memDao;
	
	private MemberDaoImpl() {
		
	}
	
	public static IMemberDao getInstance() {
		if(memDao == null) {
			memDao = new MemberDaoImpl();
		}
		return memDao;
	}
	
	@Override
	public int insertMember(MemberVO mv) {
		
		SqlSession session = MyBatisUtil.getSqlSession();
		int cnt = 0;
		
		try {
			cnt = session.insert("member.insertMember", mv);
			
			if(cnt > 0) {
				session.commit();
			}
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			session.close();
		}
		return cnt;
	}

	@Override
	public int updateMember(MemberVO mv) {
		SqlSession session = MyBatisUtil.getSqlSession();
		int cnt = 0;
		
		try {
			cnt = session.update("member.updateMember", mv);
			
			if(cnt > 0) {
				session.commit();
			}
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			session.close();
		}
		return cnt;
	}

	@Override
	public boolean checkMember(String memId) {
		
		SqlSession session = MyBatisUtil.getSqlSession(true);
		
		boolean isExist = false;
		
		try {
			int cnt = session.selectOne("member.checkMember", memId);
			
			if(cnt > 0) {
				isExist = true;
			}
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			session.close();
		}
		
		return isExist;
	}

	@Override
	public int deleteMember(String memId) {
		SqlSession session = MyBatisUtil.getSqlSession();
		int cnt = 0;
		
		try {
			cnt = session.delete("member.deleteMember", memId);
			
			if(cnt > 0) {
				session.commit();
			}
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			session.close();
		}
		return cnt;
	}

	@Override
	public List<MemberVO> getAllMember() {
		
		SqlSession session = MyBatisUtil.getSqlSession(true);
		
		List<MemberVO> memList = new ArrayList<MemberVO>();
		
		try {
			memList = session.selectList("member.selectAllMember");
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			session.close();
		}
		
		return memList;
	}

	@Override
	public List<MemberVO> searchMember(MemberVO mv) {
SqlSession session = MyBatisUtil.getSqlSession(true);
		
		List<MemberVO> memList = new ArrayList<MemberVO>();
		
		try {
			memList = session.selectList("member.searchMember", mv);
			
		} catch (PersistenceException ex) {
			ex.printStackTrace();
		} finally {
			session.close();
		}
		
		return memList;
	}

}

package kr.or.ddit.util;

import java.io.IOException;
import java.io.Reader;
import java.nio.charset.Charset;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtil {
	
	private static SqlSessionFactory sqlSessionFactory;
	
	static {
		try {
			// 1-1. xml 설정문서 읽어오기
			Charset charset = Charset.forName("UTF-8"); // 설정파일의 한글처리를 위해서...
			Resources.setCharset(charset);
			
			// 반드시 설정 파일을 넣어야 함. xml형식 고정
			Reader rd = Resources.getResourceAsReader("config/mybatis-config.xml");
			
			// 1-2. 위에서 생성한 Reader객체를 사용하여 SqlSessionFactory 객체 생성한다.
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(rd);
			
			rd.close(); // 사용한 스트림 객체 닫아주기
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
	
	/**
	 * SqlSesson객체를 제공하는 메서드
	 * @return SqlSession객체
	 */
	public static SqlSession getSqlSession() {
		return sqlSessionFactory.openSession();
	}
	
	/**
	 * SqlSession객체를 제공하는 메서드
	 * @param autoCommit 오토커밋 여부
	 * @return SqlSession객체
	 */
	public static SqlSession getSqlSession(boolean autoCommit) {
		return sqlSessionFactory.openSession(autoCommit);
	}
	
}

member.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="member">

<!-- 
	이 영역에 sql문에 맞는 태그를 사용하여 SQL문을 기술한다.
	
	사용할 수 있는 기본적인 태그들
	<select> ~~~ </select>
	<insert> ~~~ </insert>
	<update> ~~~ </update>
	<delete> ~~~ </delete>
	
	위 태그에서 사용되는 주요 속성들
	
	1) id : 해당 태그를 호출할 때 namespace값과 연결하여 사용하는 id값
	
	2) parameterType : 파라미터 객체의 타입정보를 지정한다.
					   (보통 VO클래스명, 자바의 데이터타입 등이 사용된다. ALias명 사용 가능함.)
	
	3) resultType : select문을 실행한 결과값을 담을 객체타입을 지정한다.
					(보통 VO클래스명, 자바의 데이터타입 등이 사용된다. ALias명 사용 가능함.)

	4) resultMap : 결과 레코드 컬럼명과 VO객체의 속성명이 다를 경우에 적절한 매핑을 위해 사용한다.
-->

	<insert id="insertMember" parameterType="kr.or.ddit.member.vo.MemberVO">
		insert into mymember 
		(mem_id, mem_name, mem_tel, mem_addr) 
		values (#{memId}, #{memName}, #{memTel}, #{memAddr})
	</insert>
	
	<update id="updateMember" parameterType="kr.or.ddit.member.vo.MemberVO">
		update mymember
		set mem_name = #{memName}, 
		mem_tel = #{memTel}, 
		mem_addr = #{memAddr} 
		where mem_id = #{memId}
	</update>
	
	<delete id="deleteMember" parameterType="String">
		delete from mymember where mem_id = #{오병준}
	</delete>
	
	<select id="selectAllMember" resultType="kr.or.ddit.member.vo.MemberVO">
		select mem_id as memId, 
			mem_name as memName, 
			mem_tel as memTel, 
			mem_addr as memAddr 
		from mymember
	</select>
	
	<select id="getMember" resultType="kr.or.ddit.member.vo.MemberVO">
		select mem_id as memId, 
			mem_name as memName, 
			mem_tel as memTel, 
			mem_addr as memAddr 
		from mymember
		where mem_id = #{memId}
	</select>
	
	<select id="checkMember" resultType="int">
		select count(*) as cnt
		from mymember
		where mem_id = #{memId}
	</select>
	
	<select id="searchMember">
		select * from mymember where 1=1 
			
			<if test='memId != null and memId != ""'>
				and mem_id = #{memId}
			</if>
			<if test='memName != null and !memName.equals("")'>
				and mem_name = #{memName}
			</if>
			<if test='memTel != null and !memTel.equals("")'>
				and mem_tel = #{memTel}
			</if>
			<if test='memAddr != null and !memAddr.equals("")'>
				and mem_addr like '%' || #{memAddr} || '%' 
			</if>
	</select>
	
</mapper>

package kr.or.ddit.member.service;

import java.util.List;

import kr.or.ddit.member.dao.IMemberDao;
import kr.or.ddit.member.dao.MemberDaoImpl;
import kr.or.ddit.member.dao.MemberDaoImplForJDBC;
import kr.or.ddit.member.vo.MemberVO;

public class MemberServiceImpl implements IMemberService{

	private static IMemberService memService;
	
	private IMemberDao memDao;
	
	public static IMemberService getInstance() {
		if(memService == null) {
			memService = new MemberServiceImpl();
		}
		return memService;
	}
	
	private MemberServiceImpl() {
		memDao = MemberDaoImpl.getInstance();
	}

	@Override
	public int registMember(MemberVO mv) {
		int cnt = memDao.insertMember(mv);
		return cnt;
	}

	@Override
	public int modifyMember(MemberVO mv) {
		int cnt = memDao.updateMember(mv);
		return cnt;
	}

	@Override
	public boolean checkMember(String memId) {
		return memDao.checkMember(memId);
	}

	@Override
	public int removeMember(String memId) {
		int cnt = memDao.deleteMember(memId);
		return cnt;
	}

	@Override
	public List<MemberVO> displayMember() {
		return memDao.getAllMember();
	}

	@Override
	public List<MemberVO> searchMember(MemberVO mv) {
		return memDao.searchMember(mv);
	}
}

'자바' 카테고리의 다른 글

[Java 고급] 21장 W3C DOM, 유스케이스 다이어그램 (0)	2024.02.13
[Java 고급] 20장 로깅 (0)	2024.02.08
[Java 고급] 18장 Singleton 패턴 (0)	2024.02.07
[Java 고급] 17장 MVC 패턴 (0)	2024.02.06
[Java 고급] 16장 JDBC (0)	2024.02.02

1 2 3 4 5 6 7 8 ··· 13

[Java 고급] 21장 W3C DOM, 유스케이스 다이어그램

[Java 고급] 21장 W3C DOM, 유스케이스 다이어그램

[Java 고급] 20장 로깅

[Java 고급] 20장 로깅

[Java 고급] 19장 Mybatis

[Java 고급] 19장 Mybatis

'자바' 카테고리의 다른 글

'자바' 카테고리의 다른 글

'자바' 카테고리의 다른 글

티스토리툴바