#19 JDBC

# JDBC? (Java Database Connectivity)

Java 코드에서 데이터베이스를 사용하기 위해 제공해주는 API. 참고로 JDBC가 나오기 이전에는 MS진형 ( C언어)에서 만든 ODBC API (Open DB Connectivity)를 제공했었다.

JDBC API를 이용해 비슷한 코드로 다양한 종류의 DB와 연결할 수 있다.

 

---

# JDBC의 기능

참고로 JDBC를 사용하는 방법에는 여러가지 유형이 있긴하나 [유형 4] 이외 직접 사용할 일은 거의 없다고 보면 된다.

1. 유형 I : JDBC- ODBC 브리지 ( Java <-> JDBC <-> ODBC <-> DB)
2. 유형 II : 네이티브 APT-부분적으로 Java 드라이버 ( 유형 1에서 ODBC부분을 개발자가 코드로 직접 구현)
3. 유형 III : 네트워크 프로토콜-완전 Java 드라이버 ( 응용 프로그램단에서 자바로 네트워크 직접 구현, 추천 X)
4. 유형 IV : Thin Driver- Fully Java Driver ( DB 업체별로 JDBC 드라이버 제공 )
   클라이언트 JVM에 직접 설치되어 별도의 소프트웨어가 필요없고, DB공급 업체에서 직접 JDBC 드라이버 개발.

유형4. 자바 앱의 JDBC 사용방법

 

---

# JDBC 연결하기

# 1. Import 패키지

JDBC API 4.0(2017년) 기준, java.sql 패키지와 javax.sql(확장 API, 서버측 데이터 처리기능 제공) 패키지를 제공한다. 

---

# 2. JDBC Driver 연결

Import한 API를 사용해서 사용하고자하는 JDBC 드라이버를 자바 앱으로 가져와 사용할 수 있다.

•  Class.forName()

Class.forName("JDBC 드라이버 이름")

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); // MS-SQL 드라이버 등록
Class.forName(“postgresql.Driver”); // PostgreSQL 드라이버 등록
Class.forName(“oracle.jdbc.driver.OracleDriver”); // Oracle 드라이버 등록

* Java 1.6, JDBC 4.0 이후의 JDBC에서는 서비스 로더(java.util.ServiceLoader) 기반으로 JDBC Driver가 자동으로 등록됩니다. 즉 Class.forName("com.mysql.jdbc.Driver") 류의 코드를 수동으로 호출하지 않아도 등록됩니다.

// JDBC를 연결하는 코드 예제
Class.forName("oracle.jdbc.driver.OracleDriver"); //java 1.6 이후에서는 생략해도 등록됨.
conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
stmt = conn.createStatement();
String sql = "select * from tablename";
rs = stmt.executeQuery(sql);

 

• Class.forName의 동작

우선, 'Class' 객체는 JVM에서 동작할 클래스의 정보를 관리하는 Java의 Meta-Class라고 생각하면 됩니다. Class.forName("package.ClassName") 은 해당 문자열에 해당하는 클래스 생성 후 반환해줍니다. 참고로 모든 JDBC 패키지의 내부는 아래와 비슷한 같은 구조를 가집니다.

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static { // static!!
        try {
        	// 새로운 드라이버를 등록하는 코드
           java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    ...
}

즉, 내부적으로 DriverManager.registerDriver(new Driver()); 를 이용하여 드라이버 객체를 만듭니다. 이렇게 생성한 드라이버 객체는, DriverManager.getConnection(~)을 이용하여 커넥션이 생성되는 시점에 사용할 수 있습니다.

pakage.SomeClass obj = new pakage.SomeClass(); 으로 사용하지않고 굳이 Class.forName()을 사용하는 이유는 static 객체로 관리되어지기 때문입니다. 만약 new로 객체를 생성해버리면 JDBC 드라이버 객체는 인스턴스를 받는 참조변수도, 대입도 하지 않기 때문에 객체 참조 카운트가 0이 되어 JVM의 GC의 대상이 됩니다.

// Class.forName() 메서드 정의. static 메서드이다.
// 즉, JDBC 드라이버 생성 메서드가 다른 객체보다 먼저 생성된다. 
// java.sql.DriverManager.registerDriver(new Driver());

public static Class<?> forName(String className)
                        throws ClassNotFoundException

정적 메서드인 Class.forName(~)을 사용하면 해당 클래스의 정보가 static 블럭에 관리되어 GC의 대상이 되지않고, 다른 클래스보다 먼저 JVM 메모리에 인스턴스의 생성과 초기화가 이루어지게 됩니다.

---

JDBC 드라이버와 관련된 바이트코드(.class) 파일을 런타임에 객체로 생성하는 방법이다.  참고로 Class.forName() 내부에서 DriverManager.registerDriver()를 호출함으로써 JDBC 드라이버를 등록하고 인스턴스를 생성한다.

DBMS 이름	JDBC 드라이버 패키지 경로(=이름)
MySQL	com.mysql.jdbc.Driver
Oracle	oracle.jdbc.driver.OracleDriver
MS SQL Server	com.microsoft.sqlserver.jdbc.SQLServerDriver
MS Access	net.ucanaccess.jdbc.UcanaccessDriver
PostgreSQL	org.postgresql.Driver
IBM DB2	com.ibm.db2.jdbc.net.DB2Driver

---

• DriverManager.registerDriver()

특정 DB의 JDBC 드라이버를 개발자가 직접 구현할 때 사용한다. Class.forName( " JDBC 패키지 이름 ") 에서, JDBC 패키지 내부에서 해당 메서드를 이용해 드라이버 객체를 생성할 수 있다.

DriverManager.registerDrivers(new oracle.jdbc.driver.OracleDriver()); // Oracle 드라이버 등록

// DB 드라이버 패키지 내부에서 사용된다.
// Class.forName("java.sql.Driver");
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
           java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    ...
}

 

---

# 2. DB Connection 만들기

만들어진 드라이버 객체를 이용해 해당 DB와 연결한다. 

• getConnection (URL, 사용자 이름, 암호); – URL(*jdbDriver 경로), 사용자 이름, 비밀번호가 있다.
• getConnection (URL); – URL(*jdbDriver 경로)에는 사용자 이름과 비밀번호가 포함되어야한다.

DBMS	Connection URL
MySQL	jdbc : mysql : // HOST_NAME : PORT / DATABASE_NAME
Oracle	jdbc : oracle : thin : @HOST_NAME : PORT : SERVICE_NAME
Ms SQL Server	jdbc : sqlserver : // HOST_NAME : PORT; DatabaseName =
PostgreSQL	jdbc : postgresql : // HOST_NAME : PORT / DATABASE_NAME

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

try { 
    // DriverManager.getConnection( jdbcDriver, dbUser, dbPassword)
    conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
	
    // 연결에 성공하면 아래와 같이 사용가능.
    stmt = conn.createStatement();
    String sql = "select * from tablename";
    rs = stmt.executeQuery(sql);	

} catch ( SQLException ex ) {
    //  예외처리...
} finally {
    if (conn != null )
        try { conn.close()
        } catch ( SQLException ex ){}
}

 

---

# 3. (SQL) Statement 작성 & 쿼리 실행

// 정적인(고정된) 쿼리문을 실행 할 경우
Statement stmt = null; // Statement 객체 생성
String sql = "select * from test";
stmt = conn.createStatement(sql);


// 파라미터를 입력 받아 동적인 쿼리문을 실행할 경우
PreparedStatement pstmt = null; // PreparedStatement 객체 생성
String sql = "INSERT INTO test VALUES (?,?)";
pstmt = conn.prepareStatement(sql);

// 파라메타 입력 (3,"LEE")
pstmt.setInt(1,3);
pstmt.setString(2, "LEE");

//insert, update, delete등 리턴 값이 필요 없는 쿼리문일 때 사용
pstmt.executeUpdate(SQL);
stmt.executeUpdate(SQL);
  
  
// select등 리턴 값이 필요한 쿼리문일 때 사용
ResultSEt rs = null;
rs = pstmt.executeQuery(SQL);
rs = stmt.executeQuery(SQL);

// 받아온 ResultSet은 iter처럼 사용가능.
while(rs.next()){
    String name = rs.getString("name");
}

rs.next()

---

# 4. Close Connection

데이터베이스 커넥션을 생성한 역순으로 반납. 보통 finally 블럭 object.close() 형식으로 사용된다.

참고로 Java7(1.7)부터 제공되는 Try-with-Resource 구문을 사용하면 close를 사용하지 않고도 쉽게 처리할 수 있다. 참고로 Java9 부터는 Try-with-Resource문에서 밖에서 선언된 객체를 가져와도 동일하게 관리해준다.

Try-with-Resource 에 대하여 

#7 Exception (예외처리)

conn.close() // dbDriver 커넥션
pstmt.close() // 쿼리문
stmt.close();

public class Class1 {
    public method1() throws Exception {
      Connection conn = DriverManager.getConnection("...");
      Statement stat = conn.createStatement();
      ResultSet rs = stat.executeQuery("SELECT 1 from dual")
		
      // Java9 부터는 이런 식으로 밖에서 선언된 객체를 가져와 사용할 수도있다.
      try (conn; stat; rs) {
          // ...
      } catch (Exception e) {
          // ...
      } 
    }
}

Connection connection=dataSource.getConnection();
        // Java7 부터 지원되는 try(자원) 관리 기능.
        // finally로 따로 close 해줄 필요가 없다.
        try(connection){
            connection.setAutoCommit(false);
            //execute some SQL statements...
            connection.commit(); 
        }catch(SQLException e){
            connection.rollback();
}

* 해당 예제에서 나오는 트랜잭션 처리는 다음 글( JDBC 트랜잭션 )에서 따로 다룰 예정이다.

 

---

# 실제 사용 예제

• 데이터 읽어오기 (고전적인 방법)

package test;

// JDBC API import
import java.sql.*;
import org.apache.log4j.Logger;

public class dbconn {
    // 실제 DB 접근 코드에서 user와 pw은 암호화해서 사용하는 것을 권장한다.
    // 해당 코드가 퍼지거나 해킹당하더라도 추가적인 피해를 막을 수 있다.
    static Logger logger = Logger.getLogger(dbconn.class); // logging
    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
    static final String DB_URL = "jdbc:mysql://192.168.0.143:3306/test";
    static final String USERNAME = "root";
    static final String PASSWORD = "1234";

    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            Class.forName(JDBC_DRIVER);
            conn = DriverManager.getConnection(DB_URL, USERNAME, PASSWORD);
            stmt = conn.createStatement();

            String sql1 = "select * from test";
            rs = stmt.executeQuery(sql1);

            while (rs.next()) {
                String no = rs.getString("no");
                String name = rs.getString("name");
                System.out.println("no = " + no + " , " + "name = " + name);
            }

        } catch (SQLException se1) {
            // SQL 관련 예외처리

        } catch (Exception ex) {
            // 그 외의 예외처리

        } finally {
            // 사용을 완료한 객체들은 .close()로 반환.
            rs.close();
            stmt.close();
            conn.close();
        }
    }
}

 

• 데이터 입력하기 (Try-with-resource)

package test;

import java.sql.*;

public class dbpstmt {
    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
    static final String DB_URL = "jdbc:mysql://192.168.0.143:3306/test";
    static final String USERNAME = "root";
    static final String PASSWORD = "1234";

    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        PreparedStatement pstmt = null;
		
        // Try-with-Resource
        try(
            Class.forName(JDBC_DRIVER);
            conn = DriverManager.getConnection(DB_URL, USERNAME, PASSWORD);
            pstmt = conn.prepareStatement("INSERT INTO test VALUES (?,?)");
        ){
            String sql = "INSERT INTO test VALUES (?,?)";
            Class.forName(JDBC_DRIVER);

            conn = DriverManager.getConnection(DB_URL, USERNAME, PASSWORD);
            pstmt = conn.prepareStatement(sql);
            pstmt.setInt(1, 3);
            pstmt.setString(2, "LEE");

            pstmt.executeUpdate();

        } catch (SQLException e) {
            // 예외처리
        } catch (Exception e) {
            // 예외처리
        }
    }
}

---

# 커넥션 풀 (DataBase Connection Pool)

멀티 쓰레드의 쓰레드 풀처럼, DB와 연결하는 커넥션을 미리 생성해두고 필요할 때 꺼내 쓰는 기법을 말한다. 커넥션 풀의 오픈소스에는 대표적으로 DBCP 와 C3P0가 있는데, 여기에서는 DBCP에 대해서 다루고자 한다.

JDBC를 이용해 DB에 접근하는 과정은 다음과 같이 요약 가능하다.

1. DB 접속을 위한 JDBC 드라이버 로드
2. getConnection Method로 부터 DB 커넥션 객체를 얻음
3. 쿼리 수행을 위한 PreparedStatement, Statement 객체 생성
4. excuteQuery를 실행해서 결과를 받아옴.
5. 처리가 완료되면 리소스들을 close하여 반환 (또는 try-with-resoucre문 사용으로 해당 과정 생략)

Java에서 DB에 접근할 때마다 Driver를 로드하고, 커넥션 객체를 생성하는 것은 상당히 비효율적인 작업이다. 그래서 WAS등을 사용할 때 미리 일정량의 DB Connection 객체를 생성하고 이를 할당받는 방법(Connection Pool)으로 사용할 수 있게 만들어준다.

 

커넥션 풀 라이브러리로는 무료인 DBCP가 많이 사용되었고, 최근(2021)에 사용되는 스프링 부트 2.0부터는 HikariCP 를 사용한다고 한다.

HikariCP

HikariCP는 스프링 부트 2.0부터 설정된 default JDBC Connection Pool입니다.기존의 DBCP들 보다 빠르게 작업을 처리하고 가볍습니다.많은 Connection pool 라이브러리들은 PreparedStatement caching을 지원하지만 HikariCP는 지원하지 않습니다. 즉 HikariCP 는 Statement Cache 를 사용하지 않습니다.

 

 

• 대부분의 JDBC 드라이버들은 Statement cache 를 가지고 있습니다. (ex. Oracle, MySQL, DB2)
• 이런 드라이버들의 특징 중 하나는 실행 계획을 커넥션 간 공유하는 기능이 있는 것입니다.

 

• Connection Pool Layer에서 PreparedStatement Caching 은 connection 하나당 캐시가 이루어집니다.
• 어플리케이션이 100개의 실행된 쿼리와 10개의 connection pool 을 가지고 있다면 데이터베이스는 1000개의 실행 계획을 holding 하고 있는 셈이죠.
• 이 커넥션풀은 실행계획과 함께 preparedStatement도 많이 caching 되어 있는 상태입니다.

• 위에서 애기한 1000개의 실행 계획을 커넥션풀에서 hoding 하는 것보다 데이터베이스 내에 100개의 쿼리를 캐싱하는 것이 낫다는 것이 Statement Cache를 사용하지 않는 이유입니다. 이렇게하면 성능을 향상 시킬 수 있습니다. 

HikariCP는 이처럼 Statement 캐싱을 Connection Pool에 설정하는 것이 아닌 Driver에 설정한다는 특징이 있습니다. 실제 이 방식을 이용하여 다른 DBCP보다 벤치마킹상 더 나은 성능을 보여주고 있습니다.

 

출처: github.com/brettwooldridge/HikariCP (HikariCP 개발자의 깃허브)

 

참고로 HikariCP말고 사용되던 DBCP들은 다음과 같습니다.
- C3P0 (과거 하이버네이트에서 추천, 성능이 타 CP에 비해서 별로)
- DBCP (아파치에서 관리, C3P0보다 성능이 좋음)
- proxool (정말 좋았지만 2008년이후 업데이트가 없음)
- Bone CP (JDBC, C3P0의 느림이 싫어서 빠름을 컨셉으로 개발, JDBC CP기반)
- HikariCP (Bone CP보다 빠름. 현재 Spring에서 밀고있는 CP)

---

# Commons DBCP (= Apache DBCP)

대표적인 커넥션 풀 오픈소스 라이브러리이다. 현재 DBCP는 아파치 사이트에서 JAR 파일을 다운 받을 수 있는데, DBCP 내부에서 사용한 Pool인  Commons Pool 과 로그기록에 사용되는 Commons Logging을 함께 받아야 사용 할 수 있다.

Commons DBCP2 : http://commons.apache.org/proper/commons-dbcp/

Commons Pool2 : http://commons.apache.org/proper/commons-pool/

Commons Logging : http://commons.apache.org/proper/commons-logging/

JSP에서 사용하려면 사이트에서 필요한 JAR파일들을 다운받아 WEB-INF/lib 디렉토리에 복사하면 사용 가능하다. 다운로드한 DBCP는 서블릿으로 초기화하고 난 뒤, 커넥션 객체를 [DBCP 커넥션 풀]에서 받아와 사용할 수 있다.

 

# web.xml에서 DBCP 초기화 서블릿 등록.

<load-on-stratup> 태그를 이용해 앱이 실행될 때 해당 서블릿이 동작하도록 설정할 수 있다.

    <servlet>
        <servlet-name>DBCPInit</servlet-name>
        <servlet-class>jdbc.DBCPInit</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

 

# 커넥션 풀에서 커넥션을 가져오는 방법

web.xml에 DBCP 초기화 서블릿을 등록했다면, 다음과 커넥션을 가져와 사용할 수 있다.

String jdbcDriver = "jdbc:apache:commons:dbcp:cp";
...
conn = DriverManager.getConnection(jdbcDriver);

 

# DBCP 초기화 서블릿 (DBCPInit.java)

참고로 해당 서블릿에서 DBCP의 설정값을 지정해줄 수 있다.

package jdbc;

import java.sql.DriverManager;
import java.util.Properties;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

import org.apache.commons.dbcp2.ConnectionFactory;
import org.apache.commons.dbcp2.DriverManagerConnectionFactory;
import org.apache.commons.dbcp2.PoolableConnection;
import org.apache.commons.dbcp2.PoolableConnectionFactory;
import org.apache.commons.dbcp2.PoolingDriver;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

public class DBCPInit extends HttpServlet {

    @Override
    public void init() throws ServletException {
            loadJDBCDriver();
            initConnectionPool();
    }
    private void loadJDBCDriver() {
        try {
            //커넥션 풀에서 사용할 jdbc 드라이버를 로딩
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException("fail to load JDBC Driver", ex);
        }
    }
    private void initConnectionPool() {
        try {
            String jdbcUrl = "jdbc:mysql://localhost:3306/chap14?" + "useUnicode=true&characterEncoding=utf8";
            String username = "phs1116";
            String pw = "1234";
            
            //커넥션팩토리 생성. 커넥션 팩토리는 새로운 커넥션을 생성할때 사용한다.
            ConnectionFactory connFactory = new DriverManagerConnectionFactory(jdbcUrl, username, pw);
            
            //DBCP가 커넥션 풀에 커넥션을 보관할때 사용하는 PoolableConnectionFactory 생성
            //실제로 내부적으로 커넥션을 담고있고 커넥션을 관리하는데 기능을 제공한다. ex)커넥션을 close하면 종료하지 않고 커넥션 풀에 반환
            PoolableConnectionFactory poolableConnFactory = new PoolableConnectionFactory(connFactory, null);
            //커넥션이 유효한지 확인할때 사용하는 쿼리를 설정한다.
            poolableConnFactory.setValidationQuery("select 1");
            
            
            //커넥션 풀의 설정 정보를 생성한다.
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            //유휴 커넥션 검사 주기
            poolConfig.setTimeBetweenEvictionRunsMillis(1000L * 60L * 1L);
            //풀에 있는 커넥션이 유효한지 검사 유무 설정
            poolConfig.setTestWhileIdle(true);
            //커넥션 최소갯수 설정
            poolConfig.setMinIdle(4);
            //커넥션 최대 갯수 설정
            poolConfig.setMaxTotal(50);

            //커넥션 풀 생성. 인자로는 위에서 생성한  PoolabeConnectionFactory와 GenericObjectPoolConfig를 사용한다.
            GenericObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnFactory,
                    poolConfig);
            
            //PoolabeConnectionFactory에도 커넥션 풀을 연결
            poolableConnFactory.setPool(connectionPool);
            
            //커넥션 풀을 제공하는 jdbc 드라이버를 등록.
            Class.forName("org.apache.commons.dbcp2.PoolingDriver");
            
 
            PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
            //위에서 커넥션 풀 드라이버에 생성한 커넥션 풀을 등룍한다. 이름은 cp이다.
            driver.registerPool("cp", connectionPool);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

 

---

# Tomcat DBCP 이용하기

따로 다운로드 받지않고 Tomcat WAS에 내장된 Tomcat DBCP를 사용하는 방법이다. 

톰캣을 설치했다면 $CATALINA_HOME/lib/tomcat-dbcp.jar 경로에 해당 DBCP가 함께 설치되있다.

 

1. Tomcat/conf/server.xml 에 있는 GlobalNamingResources 태그 사이에 DBCP 정보를 적는다.

해당 예제는 오라클을 사용해서 driverClassName = "oracle.jdbc.driver.OracleDriver" 라고 설정해주었다. 나머지는 DBCP 설정 값이다. maxIdle은 평상시에 가지고 있는 커넥션 객체 수, maxTotal 은 최대 수를 의미한다.

Tomcat/conf/server.xml

<GlobalNamingResources>
	<!-- Editable user database that can also be used by UserDatabaseRealm 
			to authenticate users -->
           
        <!-- My DBCP Setting ========================= -->
	<Resource auth="Container"
		driverClassName="oracle.jdbc.driver.OracleDriver" maxIdle="10"
		maxTotal="20" maxWaitMillis="-1" name="jdbc/myshop" password="tiger"
		type="javax.sql.DataSource" url="jdbc:oracle:thin:@127.0.0.1:1521:XE"
		username="myshop" />
	<!-- ========================================= -->
</GlobalNamingResources>

2. 그리고 context.xml에 위에서 지정한 DBCP의 이름을 등록해준다.

Tomcat/conf/context.xml

<!-- MyDBCP Setting =================================== -->
	<ResourceLink global="jdbc/myshop" name="jdbc/myshop" type="org.apache.tomcat.dbcp.dbcp2.BasicDataSource"/>
<!-- ================================================== -->

3. 이후 WEB-INF/web.xml에 DBCP 세팅을 해주면 톰캣에 내장된 DBCP를 사용할 수 있다.

<web-app>
	<!-- My DBCP Setting ================================== -->
  	<resource-ref>
 		<description>Oracle Datasource example</description>
 		<res-ref-name>jdbc/myshop</res-ref-name>
 		<res-type>javax.sql.DataSource</res-type>
 		<res-auth>Container</res-auth>
  	</resource-ref>
 	<!-- ================================================== -->
</web-app>

 

4. 이후 아래와 같이 자바코드에서 DBCP 커넥션을 받아올 수 있다.

Context initContext = new InitialContext(); 
// Initialcontext 생성 -> 이름으로 객체 찾을 수 있도록 도와준다.

Context envContext  = (Context)initContext.lookup("java:/comp/env"); 
// 톰캣(서버)을 먼저 찾는다.
// 톰캣을 찾을 때는 java:comp/env 로 찾는다.

DataSource ds = (DataSource)envContext.lookup("jdbc/myshop"); 
// server.xml에 등록했던 이름 myshop을 찾는다.(타입은 DataSource 타입)
// 참고로 이렇게 이름으로 객체를 찾는 방식을 JNDI(Java Naming Directory Interface)라 한다.

Connection conn = ds.getConnection();

System.out.println("<h1>데이터 소스 룩업 성공: "+ds +"</h1>");
System.out.println("<h2> con="+ conn + "</h2>");
	
if(conn!=null) conn.close();
// 커넥션 연결을 끊는 것이 아니라 커넥션풀에 자동으로 반납을 한다.