국비 지원 개발자 과정_Day40

<Front-End RoadMap>

html

View계층

일괄적인 디자인(CSS)

이벤트처리 할 수 없다

단방향서비스(if, for문이 없음) → 정적페이지

 

동적페이지

jsp, 서블릿, spring-실력차 줄여줌-F/W-추상메소드, 인터페이스

 

Javascript

변수-let

상수-const(배열, 함수, 객체 등 담음-컴파일안함’타입체크-TypeScript)

제어문, 객체, 배열, 함수, arrow fuction, 구조분해할당, 일급함수, 일급객체 등등

정적페이지에 다이나믹한 영향을 줄 수 있다

자바스크립트는 브라우저가 있어야만 실행됨 → nodejs 발표 후, 브라우저가 없어도 실행 가능해짐 → 백엔드 영역까지 확장

 

npm을 통해 nodejs에 설치가능(npm i express)

node -v / npm -v → 버전체크

라이브러리를 설치할 수 있다

Vue.js나 React.js를 하는데 Typescript가 필수는 아니다

 

순서

html-css-javascript-ECMAScript-(Restful API → 클라우드서비스(구글firebase수업예정) AWS)-NodeJS-React.js

→파이널프로젝트에서 네이버, 카카오클라우드 API를 이용해 로그인, 카카오페이, NPay 등을 할 수 있도록 하는 게 목표!

 

프레임워크

원하는 기능 구현에 집중하여 개발할 수 있도록 일정한 형태와 필요한 기능을 갖추고 있는 골격, 뼈대를 의미

애플리케이션 개발 시 필수적인 코드, 알고리즘, DB 연동과 같은 기능들을 위해 어느 정도 뼈대(구조)를 제공하며 이러한 뼈대 위에서 사용자는 코드를 작성하여 애플리케이션을 개발함

앱/서버 등의 구동, 메모리 관리, 이벤트 루프 등의 공통된 부분은 프레임워크가 관리

사용자는 프레임워크가 정해준 방식대로 클래스, 메서드들을 구현하면 됨

(Java 서버 개발에 사용되는 Spring / 웹 개발에 사용되는 Angular, Vue.js / 자바 기반의 JSP를 위한 프레임 워크 Struts)

 

라이브러리

소프트웨어를 개발할 때 컴퓨터 프로그램이 사용하는 비휘발성 자원의 모임

즉 특정 기능을 모와둔 코드, 함수들의 집합이며 코드 작성 시 활용 가능한 도구들을 의미

(Node.js에서 npm으로 설치한 모듈 / HTML의 클라이언트 사이드 조작을 단순화하는 JQuery / 웹에서 사용자 인터페이스 개발에 사용되는 React.js)

 

라이브러리와 프레임워크 차이

라이브러리를 사용하는 애플리케이션 코드는 애플리케이션 흐름을 직접 제어

단지 동작하는 중에 필요한 기능이 있을 때 능동적으로 라이브러리를 사용할 뿐

 

프레임워크는 거꾸로 애플리케이션 코드가 프레임워크에 의해 사용됨

프레임워크에는 분명한 [제어의 역전] 개념이 적용되어 있어야 함

애플리케이션 코드는 프레임워크가 짜 놓은 틀에서 수동적으로 동작해야 함

 

프레임워크와 라이브러리의 차이점은 "제어 흐름"의 권한이 어디에 있는가

라이브러리를 사용할 때 사용자는 애플리케이션 코드의 흐름을 직접 제어해야 함

반면 프레임워크는 애플리케이션의 코드가 프레임워크에 의해 사용되며, 애플리케이션 코드는 프레임워크가 짜 놓은 틀에서 수동적으로 동작하기 때문에 제어의 흐름은 프레임워크가 가지고 있고 사용자가 그 안에 필요한 코드를 작성하게 됨

 

제어의 역전(IoC, Inversion of Control)

어떠한 일을 하도록 만들어진 Framework에 Control 권한을 위임하는 것을 의미

간단히 말해 프로그램의 제어 흐름 구조가 뒤바뀐 것을 뜻함

라이브러리의 경우 애플리케이션의 흐름을 사용자가 직접 제어하지만

프레임워크의 경우 코드를 연결할 수 있는 위치를 제공하고 필요에 따라 사용자가 연결한 코드를 호출하는 제어 흐름 권한을 가지고 있음

 

MVC

model계층 → 넓은 의미에서 DAO디자인패턴도 model계층(서비스+DAO)

 

ORM(Object-relational mapping)

Object와 DB테이블을 매핑하여 데이터를 객체화하는 기술(객체 관계 매핑)

객체와 RDB를 별개로 설계하고 ORM이 중간에서 매핑해 주는 역할

SQL문이 아닌 RDB에 데이터 스 자체와 매핑하기 때문에 개발자가 반복적인 SQL을 작성할 필요가 없음

DBMS에 종속적이지 않음

 

MyBatis(Java Persistence Framework)

개발자가 지정한 SQL, 저장프로시저 그리고 몇 가지 고급 매핑(동적쿼리)을 지원하는 퍼시스턴스 프레임워크

JDBC로 처리하는 상당 부분의 코드와 수동으로 세팅하는 파라미터설정 및 결과 매핑을 대신해 줌

데이터베이스 레코드에 원시타입과 Map 인터페이스 그리고 자바 POJO를 설정하고 매핑하기 위해 XML과 애노테이션(@)을 사용할 수 있음

자바에서 SQL Mapper를 지원해 주는 프레임워크로, SQL작성을 직접 하여 객체와 매핑시켜 줌

 

SQL Mapper

SQL문을 이용하여 RDB에 접근, 데이터를 객체화 시킴

개발자가 작성한 SQL문으로 해당 ROW를 읽어온 후 결괏값을 객체화시켜 사용가능하게 만들어줌

 

SqlSessionFactory

데이터베이스와의 연결과 SQL의 실행에 대한 모든 것을 가진 가장 중요한 객체

이 객체가 DataSource를 참조하여 MyBatis와 Mysql 서버를 연동시켜 줌

커넥션을 도움(오라클과 연결통로)

 

 XML(EXtensible Markup Language)

사람과 기계가 읽을 수 있는 형식으로 문서를 인코딩하기 위한 규칙 집합을 정의하는 마크업 언어

HTML처럼 데이터를 보여주는 목적이 아닌, 데이터를 저장하고 전달할 목적으로만 만들어짐

XML 태그는 HTML 태그처럼 미리 정의되어 있지 않고, 사용자가 직접 정의할 수 있음

플랫폼 독립적, 다른 플랫폼 간의 데이터 교환을 위해 사용됨

 

JSP(Java Server Pages)

Java 언어를 기반으로 하는 Server Side 스크립트 언어

HTML 코드에 JAVA 코드를 넣어 동적웹페이지를 생성하는 웹애플리케이션 도구

정적인 HTML과 동적으로 생성된 contents(HTTP 요청 파라미터)를 혼합하여 사용가능

사용자가 입력한 contents에 맞게 동적인 웹페이지 생성

 

package com.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

public class DBConnectionMgr {
    //드라이버클래스가 필요해 물리적으로 떨어진 오라클서버에 접속
    //ojdbc6.jar ojbdc8.jar
    //오라클제품에서는 물리적으로 떨어져있는 서버에 접속하는 방식으로
    //thin방식과 oci방식을 지원하고 있다.
    //그 중 멀티티어(multitier)환경에서는 thin 방식
    //서버의 DNS ,포트번호,SID이름(물리적인 저장소 참조)
    //드라이버 이름:@ip주소
    	//이 클래스를 읽어야 오라클 제품인것을 확인가능함.
	public static final String _DRIVER = "oracle.jdbc.driver.OracleDriver";
	public static final String _URL = "jdbc:oracle:thin:@192.168.10.78:1521:orcl11";
	public static String _USER = "kiwi";
	public static String _PW = "tiger";
	public Connection getConnection(){
    Connection con = null;
    try {
        Class.forName(_DRIVER);
        con = DriverManager.getConnection(_URL, _USER, _PW);
    } catch (ClassNotFoundException e) {
        System.out.println("드라이버클래스를 찾을 수 없습니다.");
    }catch(Exception e){//멀티 블럭 작성시 범위가 가장 넓은 클래스를 뒤에 
        System.out.println("오라클 서버와 커넥션 실패");
    }//======검색 정보를 가져올 수 있다.
    return con;
}

//사용한 지원을 반납하는 코드는 명시적으로 하는 것이 원칙
//반납하는 순서는 생성된 역순으로 진행
//사용한 자원 반납하기 -INSERT, UPDATE, DELETE물리적인 테이블에 직접적인 변화
public void freeConnection (Connection con, Statement stmt){
    if (stmt != null) {
        try {
            stmt.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    if (con != null) {
        try {
            con.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

public void freeConnection (Connection con, PreparedStatement pstmt){
    if (pstmt != null) {
        try {
            pstmt.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    if (con != null) {
        try {
            con.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

//사용한 지원 반납하기 -SERECT 테이블에 있는 정보를 꺼내서 조회 -> 커서 조작이 필요
public void freeConnection (Connection con, Statement stmt, ResultSet rs){
    if (rs != null) {
        try {
            rs.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    if (stmt != null) {
        try {
            stmt.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    if (con != null) {
        try {
            con.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

public void freeConnection (Connection con, PreparedStatement pstmt, ResultSet rs){
    if (rs != null) {
        try {
            rs.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    if (pstmt != null) {
        try {
            pstmt.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    if (con != null) {
        try {
            con.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

public static void main(String[] args) {
    DBConnectionMgr dbcnn= new DBConnectionMgr();
    Connection con = dbcnn.getConnection();
System.out.println("con====>"+con);
    }
}
/*
 * JDBC API를 이용하여 DB연동하기
 * 1.각 제조사가 제공하는 드라이버 클래스를 로딩(ojdbc6.jar)
 * Class,forName(드라이버클라스(패키지까지 포함해서));
 * 
 * 2.오라클서버와 연결 통로를 확보
 * Connection 은 인터페이스이다.-오른쪽에 구현체 클래스가 와야 한다
 * Connection con = DriverManager.getConnection(URL,"scott","tiger");
 *
 * 3.DML문을 자바에서 오라클서버로 전달해 줄 인터페이스를 생성한다.(Statement:정적쿼리문, PreparedStatement:동적쿼리문지원)
 * 4,SELECT문의 경우 오라클 서버에서 제공하는 커서를지원하는 ResultSet인터페이스를 활용하여 
 * 테이블에 제공되는 커서를 조작하여  해당 로우에 데이터가 존재하면 Cursor....open....fetch과정을 통해서
 * 오라클 서버로부터 데이터를 꺼내서 List<DeptVO>에 담을 수 있다.
 * 주의 : INSERT,UPDATE, DELETE에서는 커서가 필요없다
 * 리턴값은 int이다
 * 이것들을 요청할 때는 executeUpdate(INSERT문 orUPDATE or DELETE문)
 * 
 * SELECT일때는
 * ResultSet rs = executeQuery("SELECT * FROM dept");
 * 오라클에서 제공되는 커서를 조작하는 인터페이스를 리턴타입으로 제공받아서
 * 조회결과를 Collection 에 담을 수 있다.
 * List<DeptVO> deptList =new ArrayList<>();
 * DeptVO dVO= null;
 * while(rs.next()){
 * dVO= new DeptVO();
 * deptList.add(dVO);
 * }
 * 
 * 사용한 자원을 반납할 때는 사용한 역순으로 닫아주면 됨
 * SELECT인 경우 
 * ResultSet먼저 닫고 Statement 혹은 PreparedStatement 두번째로 닫고
 * Connection 을 맨 나중에 닫아주면 된다.
 * 닫지 않으면 자동으로 언젠가 닫아주기는 하지만 명시적으로 닫아주면
 * 닫는 시간을 앞당길 수 있어 프로젝트에서는 명시적으로
 * 닫는 코드 작성을 가이드로 정한다.
 *
 *  INSERT, UPDATE,DELETE는 두번째와 세번째만 닫으면 된다.
 * 왜냐하면 리턴타입이 커서가 필요 없다
 */

 

package com.util;

import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;

public class MyBatisCommonFactory {
	Logger logger = Logger.getLogger(MyBatisCommonFactory.class);
//	MyBatis는 자바와 오라클 서버 사이에 위치하면서 DB연계를 지원하는 매핑서비스이다.
//	물리적으로 떨어져있는 서버와의 통신을위해 드라이버 클래스 로딩, 연결 통로 확보 코드가 반복적으로 작성됨
//	이것을 전담하는 SqlSessionFactory를 지원하고있음(MyBatis가)
//	스프링에선 SqlSessionFactoryBean
	public SqlSessionFactory sqlSessionFactory = null;
	//SqlSessionFactory객체를 생성해 주는 메소드 입니다.
	public void init() {
		try {
//			xml문서에 드라이버 클래스명, URL주소, 계정정보 담음
//			더하여 쿼리문을 xml문서에 따로 등록해서 관리하므로
//			쿼리문을 담고있는 xml문서의 물리적인 위치를 설정문서에 등록함
			String resource = "com\\util\\MyBatisConfig.xml";
			System.out.println("resource");
			Reader reader = Resources.getResourceAsReader(resource);
			logger.info("before sqlSessionFactory : "+sqlSessionFactory);
//			싱글톤패턴에서 객체 생성하기
			if(sqlSessionFactory == null) {
				sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader,"development");
			}
			logger.info("after sqlSessionFactory : "+sqlSessionFactory);
			System.out.println("after sqlSessionFactory : "+sqlSessionFactory);
		} catch (Exception e) {
			logger.info("[[ Exception ]] "+e.toString());
			System.out.println("[[ Exception ]] "+e.toString());
		}
	}// end of init
	public SqlSessionFactory getSqlSessionFactory() {
		System.out.println("11");
		init();
		return sqlSessionFactory;
	}
	public static void main(String[] args) {
		System.out.println("test");
		MyBatisCommonFactory mcf = new MyBatisCommonFactory();
		mcf.getSqlSessionFactory();
	}
}

 

package com.vo;

public class MemberVO {
	private String mem_no   ; //
	private String mem_id   ; //
	private String mem_pw   ; //
	private String mem_name ; //
	private String mem_nick ; //
	private String mem_birth; //
	private String mem_reg  ; //
	
	public String getMem_no() {
		return mem_no;
	}
	public void setMem_no(String mem_no) {
		this.mem_no = mem_no;
	}
	public String getMem_id() {
		return mem_id;
	}
	public void setMem_id(String mem_id) {
		this.mem_id = mem_id;
	}
	public String getMem_pw() {
		return mem_pw;
	}
	public void setMem_pw(String mem_pw) {
		this.mem_pw = mem_pw;
	}
	public String getMem_name() {
		return mem_name;
	}
	public void setMem_name(String mem_name) {
		this.mem_name = mem_name;
	}
	public String getMem_nick() {
		return mem_nick;
	}
	public void setMem_nick(String mem_nick) {
		this.mem_nick = mem_nick;
	}
	public String getMem_birth() {
		return mem_birth;
	}
	public void setMem_birth(String mem_birth) {
		this.mem_birth = mem_birth;
	}
	public String getMem_reg() {
		return mem_reg;
	}
	public void setMem_reg(String mem_reg) {
		this.mem_reg = mem_reg;
	}
}

 

package com.html;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.google.gson.Gson;
import com.util.DBConnectionMgr;
import com.util.MyBatisCommonFactory;
import com.vo.MemberVO;

public class MemberDao {
	DBConnectionMgr dbMgr = new DBConnectionMgr();
	MyBatisCommonFactory mcf = new MyBatisCommonFactory();
	Connection con = null;
	PreparedStatement pstmt = null;
	ResultSet rs = null;

	// 회원목록 가져오기
	public List<Map<String, Object>> getMemberList() {
		System.out.println("getMemberList호출");
		List<Map<String, Object>> memList = null;
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT mem_no,mem_id,mem_name\r\nFROM member");
		try {
			con = dbMgr.getConnection();// 물리적으로 떨어져 있는 오라클 서버에 연결통로
			pstmt = con.prepareStatement(sql.toString());// 연결통로를 통해서 select문을 가져가고 오라클 서버에게 요청하는객체를 로딩
			rs = pstmt.executeQuery();
			memList = new ArrayList<>();// 인스턴스화
			Map<String, Object> rmap = null;// 결괏값 받아오는
			while (rs.next()) {
				rmap = new HashMap<>();
				rmap.put("mem_no", rs.getInt("mem_no"));
				rmap.put("mem_id", rs.getString("mem_id"));
				rmap.put("mem_name", rs.getString("mem_name"));
				memList.add(rmap);
			}
			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 사용한 지원을 반납하기 명시적으로 반납 실행시점을 당기기위해
			dbMgr.freeConnection(con, pstmt, rs);
		}
		return memList;
	}

	public String jsonMemberList() {
		System.out.println("getMemberList호출");
		List<Map<String, Object>> memList = null;
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT mem_no,mem_id,mem_name\r\nFROM member");
		try {
			con = dbMgr.getConnection();// 물리적으로 떨어져 있는 오라클 서버에 연결통로
			pstmt = con.prepareStatement(sql.toString());// 연결통로를 통해서 select문을 가져가고 오라클 서버에게 요청하는객체를 로딩
			rs = pstmt.executeQuery();
			memList = new ArrayList<>();// 인스턴스화
			Map<String, Object> rmap = null;// 결괏값 받아오는
			while (rs.next()) {
				rmap = new HashMap<>();
				rmap.put("mem_no", rs.getInt("mem_no"));
				rmap.put("mem_id", rs.getString("mem_id"));
				rmap.put("mem_name", rs.getString("mem_name"));
				memList.add(rmap);
			}
//			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 사용한 지원을 반납하기 명시적으로 반납 실행시점을 당기기위해
			dbMgr.freeConnection(con, pstmt, rs);
		}
		Gson g = new Gson();
		String temp = null;
		temp = g.toJson(memList);
		return temp;
	}

	public List<Map<String, Object>> myBatisMemberList() {
		System.out.println("getMemberList 호출");
//		물리적으로 떨어져있는 서버와 연결통로 확보
//		MyBatisConfig.xml문서 정보(드라이버, URL, 계정정보+쿼리문을 담은 xml등록) 참조
		SqlSessionFactory sqlSessionFactory = null;
//		SqlSession으로 commit과 rollback을 지원받음
		SqlSession sqlSession = null;
		List<Map<String, Object>> memList = null;
		Map<String, Object> pMap = new HashMap<>();
		pMap.put("mem_no", 3);
		try {
			sqlSessionFactory = mcf.getSqlSessionFactory();
			sqlSession = sqlSessionFactory.openSession();
//			member.xml에서 id가 getMemberList를 찾아서 실행요청함
			memList = sqlSession.selectList("getMemberList", pMap); // id값
//			insert, update, delete시에 커밋 호출할 때 사용함(SqlSession)
//			sqlSession.commit();
			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return memList;
	}
	
	public List<MemberVO> myBatisMemberList2() {
		SqlSessionFactory sqlSessionFactory = null;
		SqlSession sqlSession = null;
		List<MemberVO> memList = null;
		Map<String, Object> pMap = new HashMap<>();
		pMap.put("mem_no", 0);
		try {
			sqlSessionFactory = mcf.getSqlSessionFactory();
			sqlSession = sqlSessionFactory.openSession();
			memList = sqlSession.selectList("myBatisMemberList2", pMap); // id값
			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return memList;
	}

	public static void main(String args[]) {
		MemberDao memDao = new MemberDao();
//		memDao.getMemberList();
//		String temp = memDao.jsonMemberList();
//		String temp = memDao.myBatisMemberList();
//		List<Map<String, Object>> memList = null;
//		memList = memDao.myBatisMemberList();
		List<MemberVO> memList = null;
		memList = memDao.myBatisMemberList2();
		Gson g = new Gson();
		String temp = g.toJson(memList);
		System.out.println(temp);
	}
}

 

package com.html;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.google.gson.Gson;
import com.util.DBConnectionMgr;
import com.util.MyBatisCommonFactory;
import com.vo.MemberVO;

public class MemberDao {
	DBConnectionMgr dbMgr = new DBConnectionMgr();
	MyBatisCommonFactory mcf = new MyBatisCommonFactory();
	Connection con = null;
	PreparedStatement pstmt = null;
	ResultSet rs = null;

	// 회원목록 가져오기
	public List<Map<String, Object>> getMemberList() {
		System.out.println("getMemberList호출");
		List<Map<String, Object>> memList = null;
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT mem_no,mem_id,mem_name\r\nFROM member");
		try {
			con = dbMgr.getConnection();// 물리적으로 떨어져 있는 오라클 서버에 연결통로
			pstmt = con.prepareStatement(sql.toString());// 연결통로를 통해서 select문을 가져가고 오라클 서버에게 요청하는객체를 로딩
			rs = pstmt.executeQuery();
			memList = new ArrayList<>();// 인스턴스화
			Map<String, Object> rmap = null;// 결괏값 받아오는
			while (rs.next()) {
				rmap = new HashMap<>();
				rmap.put("mem_no", rs.getInt("mem_no"));
				rmap.put("mem_id", rs.getString("mem_id"));
				rmap.put("mem_name", rs.getString("mem_name"));
				memList.add(rmap);
			}
			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 사용한 지원을 반납하기 명시적으로 반납 실행시점을 당기기위해
			dbMgr.freeConnection(con, pstmt, rs);
		}
		return memList;
	}

	public String jsonMemberList() {
		System.out.println("getMemberList호출");
		List<Map<String, Object>> memList = null;
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT mem_no,mem_id,mem_name\r\nFROM member");
		try {
			con = dbMgr.getConnection();// 물리적으로 떨어져 있는 오라클 서버에 연결통로
			pstmt = con.prepareStatement(sql.toString());// 연결통로를 통해서 select문을 가져가고 오라클 서버에게 요청하는객체를 로딩
			rs = pstmt.executeQuery();
			memList = new ArrayList<>();// 인스턴스화
			Map<String, Object> rmap = null;// 결괏값 받아오는
			while (rs.next()) {
				rmap = new HashMap<>();
				rmap.put("mem_no", rs.getInt("mem_no"));
				rmap.put("mem_id", rs.getString("mem_id"));
				rmap.put("mem_name", rs.getString("mem_name"));
				memList.add(rmap);
			}
//			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 사용한 지원을 반납하기 명시적으로 반납 실행시점을 당기기위해
			dbMgr.freeConnection(con, pstmt, rs);
		}
		Gson g = new Gson();
		String temp = null;
		temp = g.toJson(memList);
		return temp;
	}

	public List<Map<String, Object>> myBatisMemberList() {
		System.out.println("getMemberList 호출");
//		물리적으로 떨어져있는 서버와 연결통로 확보
//		MyBatisConfig.xml문서 정보(드라이버, URL, 계정정보+쿼리문을 담은 xml등록) 참조
		SqlSessionFactory sqlSessionFactory = null;
//		SqlSession으로 commit과 rollback을 지원받음
		SqlSession sqlSession = null;
		List<Map<String, Object>> memList = null;
		Map<String, Object> pMap = new HashMap<>();
		pMap.put("mem_no", 3);
		try {
			sqlSessionFactory = mcf.getSqlSessionFactory();
			sqlSession = sqlSessionFactory.openSession();
//			member.xml에서 id가 getMemberList를 찾아서 실행요청함
			memList = sqlSession.selectList("getMemberList", pMap); // id값
//			insert, update, delete시에 커밋 호출할 때 사용함(SqlSession)
//			sqlSession.commit();
			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return memList;
	}
	
	public List<MemberVO> myBatisMemberList2() {
		SqlSessionFactory sqlSessionFactory = null;
		SqlSession sqlSession = null;
		List<MemberVO> memList = null;
		Map<String, Object> pMap = new HashMap<>();
		pMap.put("mem_no", 0);
		try {
			sqlSessionFactory = mcf.getSqlSessionFactory();
			sqlSession = sqlSessionFactory.openSession();
			memList = sqlSession.selectList("myBatisMemberList2", pMap); // id값
			System.out.println(memList);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return memList;
	}

	public static void main(String args[]) {
		MemberDao memDao = new MemberDao();
//		memDao.getMemberList();
//		String temp = memDao.jsonMemberList();
//		String temp = memDao.myBatisMemberList();
//		List<Map<String, Object>> memList = null;
//		memList = memDao.myBatisMemberList();
		List<MemberVO> memList = null;
		memList = memDao.myBatisMemberList2();
		Gson g = new Gson();
		String temp = g.toJson(memList);
		System.out.println(temp);
	}
}

 

<?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="BookMapper">
	<select id="currentDate" parameterType="java.util.HashMap" resultType="java.lang.String">
		SELECT to_char(sysdate, 'YYYY-MM-DD') FROM dual    
	</select>	  	
</mapper>

 

<?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="MemberMapper">
	<!--
	사용자가 입력한 값을 받아올 때 parameterType에 해당 타입을 적는다
	만일 사용자 정의 클래스라면(예: MemberVO)
	패키지를 포함하는 full name으로 작성한다
	 -->
<!-- 	<select id="getMemberList" parameterType="com.vo.MemberVO" resultType="map"> -->
<!-- 	<select id="getMemberList" parameterType="int" resultType="map"> -->
<!-- 	<select id="getMemberList" parameterType="java.lang.Integer" resultType="map"> -->
	<select id="getMemberList" parameterType="java.util.HashMap" resultType="map">
		SELECT mem_no, mem_id, mem_name FROM member
		<where>
			<if test='mem_no > 0'>
				mem_no = #{mem_no}
			</if>
		</where>
	</select>
	<select id="myBatisMemberList2" parameterType="java.util.HashMap" resultType="com.vo.MemberVO">
		SELECT mem_no, mem_id, mem_name FROM member
		<where>
			<if test='mem_no > 0'>
				mem_no = #{mem_no}
			</if>
		</where>
		ORDER BY mem_no desc
	</select>
</mapper>

 

<%@ page language="java" contentType="application/json; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@page import="java.sql.*, java.util.*, com.util.DBConnectionMgr"%>
<%@page import="com.google.gson.Gson"%>

<%
//스크립틀릿
//out.print("jsonMemberList페이지");
DBConnectionMgr dbMgr = new DBConnectionMgr();
Connection con    	              = null;
PreparedStatement pstmt=null;
ResultSet rs = null;

List<Map<String, Object>> memList = null;
StringBuilder sql = new StringBuilder();
sql.append("SELECT mem_no,mem_id,mem_name\r\nFROM member");
try {
	con = dbMgr.getConnection();//물리적으로 떨어져 있는 오라클 서버에 연결통로
	pstmt = con.prepareStatement(sql.toString());//연결통로를 통해서 select문을 가져가고 오라클 서버에게 요청하는객체를 로딩
	rs = pstmt.executeQuery();
	memList = new ArrayList<>();//인스턴스화
	Map<String, Object> rmap = null;//결괏값 받아오는 
	while (rs.next()) {
		rmap = new HashMap<>();
		rmap.put("mem_no", rs.getInt("mem_no"));
		rmap.put("mem_id", rs.getString("mem_id"));
		rmap.put("mem_name", rs.getString("mem_name"));
		memList.add(rmap);
	}
	//	System.out.println(memList);
} catch (Exception e) {
	e.printStackTrace();
} finally {
	//사용한 지원을 반납하기 명시적으로 반납 실행시점을 당기기위해 
	dbMgr.freeConnection(con, pstmt, rs);
}
Gson g = new Gson();
String temp = null;
temp = g.toJson(memList);

out.print(temp);
%>

 

<%@ page language="java" contentType="application/json; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@page import="com.util.*, java.util.*"%>
<%@page import="com.google.gson.Gson"%>
<%@page import="org.apache.ibatis.session.*"%>
<%
MyBatisCommonFactory mcf = new MyBatisCommonFactory();
List<Map<String, Object>> memList = null;
SqlSessionFactory sqlSessionFactory = null;
//SqlSession으로 commit과 rollback을 지원받음
SqlSession sqlSession = null;
Map<String, Object> pMap = new HashMap<>();
pMap.put("mem_no", 0);
try {
	sqlSessionFactory = mcf.getSqlSessionFactory();
	sqlSession = sqlSessionFactory.openSession();
	memList = sqlSession.selectList("getMemberList", pMap); // id값
} catch (Exception e) {
	e.printStackTrace();
}
Gson g = new Gson();
String temp = null;
temp = g.toJson(memList);
out.print(temp);
%>

 

<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <!-- 
    html문서는 순차적으로 실행되므로 DOM구성이 완료된 후에 js가 동작되어야함
    반드시 defer를 붙여서 브라우저가 태그를 읽고 DOM Tree를 그릴 때까지 지연시킴
  -->
    <script defer src="./member.js"></script>
  </head>
  <body>
    <div class="root"></div>
  </body>
</html>

 

const requestOptions = {
  method: "GET",
  redirect: "follow",
};
// var는 사용하지 않음 - 호이스팅

fetch("http://localhost:9000/member/jsonMyBatisMemberList.jsp", requestOptions)
  .then((response) => response.text())
  .then((result) => {
    const jsonDoc = JSON.parse(result);
    // console.log(jsonDoc.length);
    for (let i = 0; i < jsonDoc.length; i++) {
      document.write(
        `번호: ${jsonDoc[i].MEM_NO} 아이디: ${jsonDoc[i].MEM_ID} `
      );
    }
  })
  .catch((error) => console.log("error", error));