1. 위 라이브러리들을 $CATALINA_HOME/common/lib 에 복사한다. 그 이외 디렉토리에 두면 안된다. ZIP 파일은 JAR로 확장자를 바꿔야 한다. 톰캣은 JAR파일만 클래스패스에 추가한다.
2. Connection 풀을 이용할 경우에는 ResultSet과 Connection 객체를 필히 직접 닫아 줘야만 한다.
3. $CATALINA_HOME/conf/server.xml 혹은 각 웹 컨텍스트별 XML 파일의 <Context>의 자식 요소로 다음을 추가한다.
4. <Resource name="jdbc/forumDb" auth="Container" type="javax.sql.DataSource"/>
5. <!-- Resource의 name 속성을 이용해서 각 어플리케이션에서
6. javax.sql.DataSource 객체를 얻어가게 된다. -->
7.
8.
9. <!-- 자세한 파라미터 설정은
10. http://jakarta.apache.org/tomcat/tomcat-5.0-doc/jndi-datasource-examples-howto.html 참조 -->
11. <ResourceParams name="jdbc/forumDb">
12. <parameter>
13. <name>factory</name>
14. <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
15. </parameter>
16.
17. <parameter>
18. <name>maxActive</name>
19. <value>100</value>
20. </parameter>
21.
22. <parameter>
23. <name>maxIdle</name>
24. <value>30</value>
25. </parameter>
26.
27. <parameter>
28. <name>maxWait</name>
29. <value>10000</value>
30. </parameter>
31.
32. <!-- DB 사용자명과 비밀번호 설정 -->
33. <parameter>
34. <name>username</name>
35. <value>dbuser</value>
36. </parameter>
37. <parameter>
38. <name>password</name>
39. <value>dbpasswd</value>
40. </parameter>
41.
42. <!-- JDBC 드라이버 클래스 -->
43. <parameter>
44. <name>driverClassName</name>
45. <value>oracle.jdbc.driver.OracleDriver</value>
46. </parameter>
47.
48. <!-- JDBC 접속 URL -->
49. <parameter>
50. <name>url</name>
51. <value>jdbc:oracle:thin:@dbhost:1521:ORA</value>
52. </parameter>
53.
54. <!-- 커넥션에 문제 없는지 테스트하는 쿼리 -->
55. <parameter>
56. <name>validationQuery</name>
57. <value>select sysdate</value>
58. </parameter>
59. </ResourceParams>
60. 웹 어플리케이션의 web.xml파일에 다음을 추가하여 JNDI 리소스를 사용할 수 있도록 한다.
61. <resource-ref>
62. <description>Forum DB Connection</description>
63. <!-- 다음이 바로 리소스의 이름 -->
64. <res-ref-name>jdbc/forumDb</res-ref-name>
65. <res-type>javax.sql.DataSource</res-type>
66. <res-auth>Container</res-auth>
67. </resource-ref>
이제 다음과 같이 JNDI를 이용해 DataSource 객체를 얻고, 그 객체에서 커넥션을 얻어오면 된다.
다음은 서블릿을 작성하고, 그 서블릿에서 DB커넥션을 얻고, 쿼리를 날린 뒤, 그 결과를 JSP 파일에 포워딩하여 JSTL을 이용해 출력하는 것이다.
1. 예제 테이블과 데이터 SQL - 오라클 계정으로 다음과 같은 데이터를 생성했다고 가정하면
2. create table test (
3. num NUMBER NOT NULL,
4. name VARCHAR2(16) NOT NULL
5. );
6.
7. truncate table test;
8.
9. insert into test values(1,'영희');
10. insert into test values(2, '철수');
11. insert into test values(3, '미숙');
12. commit;
13. test.JndiDataSourceTestServlet 소스
14. package test;
15.
16. import java.io.IOException;
17. import java.sql.Connection;
18. import java.sql.ResultSet;
19. import java.sql.SQLException;
20. import java.sql.Statement;
21. import java.util.ArrayList;
22. import java.util.HashMap;
23. import java.util.List;
24. import java.util.Map;
25.
26. import javax.naming.Context;
27. import javax.naming.InitialContext;
28. import javax.naming.NamingException;
29. import javax.servlet.RequestDispatcher;
30. import javax.servlet.ServletException;
31. import javax.servlet.http.HttpServlet;
32. import javax.servlet.http.HttpServletRequest;
33. import javax.servlet.http.HttpServletResponse;
34. import javax.sql.DataSource;
35.
36. public class JndiDataSourceTestServlet extends HttpServlet {
37.
38. protected void doGet(HttpServletRequest request,
39. HttpServletResponse response) throws ServletException, IOException {
40.
41. Connection conn = null;
42. ResultSet rs = null;
43. Statement stmt = null;
44.
45. try {
46. // 커넥션을 얻기 위한 전초작업. 이 부분을 메소드화 하면 되겠다. ------------
47. Context initContext = new InitialContext();
48. Context envContext = (Context)initContext.lookup("java:/comp/env");
49. DataSource ds = (DataSource)envContext.lookup("jdbc/forumDb");
50.
51. // 커넥션 얻기
52. conn = ds.getConnection();
53. //------------------------------------------------------------------
54.
55. String sql = "SELECT * from test";
56. stmt = conn.createStatement();
57.
58. rs = stmt.executeQuery(sql);
59.
60. List results = new ArrayList();
61.
62. while (rs.next()) {
63. Map row = new HashMap();
64.
65. row.put("num", rs.getString("num"));
66. row.put("name", rs.getString("name"));
67.
68. results.add(row);
69. }
70.
71. request.setAttribute("results", results);
72.
73. RequestDispatcher rd = request.getRequestDispatcher("/dbtest.jsp");
74. rd.forward(request, response);
75.
76. } catch (NamingException e) {
77. throw new ServletException("JNDI 부분 오류", e);
78. } catch (Exception e) {
79. throw new ServletException("뭔가 다른 부분 오류", e);
80. } finally {
81. // 리소스를 필히 반환할 것!
82. if (rs != null) { try { rs.close(); } catch (Exception ignored) {} }
83. if (stmt != null) { try { stmt.close(); } catch (Exception ignored) {} }
84. if (conn != null) { try { conn.close(); } catch (Exception ignored) {} }
85. }
86. }
87. }
88. web.xml에 서블릿 등록
89. <servlet>
90. <servlet-name>dbtest.svl</servlet-name>
91. <servlet-class>test.JndiDataSourceTestServlet</servlet-class>
92. </servlet>
93. <servlet-mapping>
94. <servlet-name>dbtest.svl</servlet-name>
95. <url-pattern>/dbtest.svl</url-pattern>
96. </servlet-mapping>
97. /dbtest.jsp 소스
98. <%@ page contentType="text/html" pageEncoding="EUC-KR" %>
99. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
100. <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>
101.
102. <!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">
103. <html>
104. <head>
105. <title>JNDI DataSource Test</title>
106. </head>
107. <body bgcolor="#FFFFFF">
108. <h2>Results</h2>
109.
110. <c:forEach var="row" items="${results}">
111. NUM : ${row.num}<br />
112. Name : ${row.name}<br />
113. <hr />
114. </c:forEach>
115. </body>
116. </html>
117.이제 웹 브라우저에서 "/dbtest.svl" 을 호출해보면 결과를 볼 수 있다.
<Resource>와 <ResourceParams> 요소를 server.xml의 <GlobalNamingResources> 의 자식노드로 옮기면 특정 웹 어플리케이션이 아니라, 이 톰캣에 설치된 전체 웹 어플리케이션에서 사용 할 수 있게 된다. 하지만 각 웹 어플리케이션 "<Context>"에 다음과 같은 설정을 해야 한다.
<ResourceLink
name="jdbc/forumDb"
global="jdbc/forumDb"
type="javax.sql.DataSource"
/>
아니면 server.xml에서 <Host> 요소의 자식으로 다음을 추가하면 각 컨텍스트별 설정 필요없이 전체 웹 어플리케이션 컨텍스트에서 GlobalNamingResources로 지정된 JNDI 리소스를 사용할 수 있다.
<DefaultContext>
<ResourceLink
name="jdbc/forumDb"
global="jdbc/forumDb"
type="javax.sql.DataSource"
/>
</DefaultContext>
1. DB 커넥션이 간혹 끊어져요.
Tomcat이 작동중인 JVM이 가비지 컬렉션을 할 때, 그 시간이 JNDI Resource에 파라미터로 설정한 maxWait보다 길게 갈 경우 DB 커넥션이 끊어질 수 있다.
CATALINA_OPTS=-verbose:gc 옵션을 주면 $CATALINA_HOME/logs/catalina.out에 가비지 컬렉션 상황이 기록된다. 거기에 GC 작업에 걸린 시간도 나오니 그것을 참조로 maxWait 파라미터를 늘려주면 된다. 보통 10~15초로 주면 된다.
GC 시간은 거의 99% 이상 1초 이내에 끝나야 하나보다..
2. 무작위로 커넥션이 close 되요.
그건.. Connection 객체를 두 번 이상 close 했기 때문이다.
DB Connection Pool은 close()를 호출할 때 정말로 닫는 것이 아니라, 단지 재사용할 수 있다고 표시만 할 뿐이다.
커넥션을 사용하다가 close()하면 다른 쓰레드이서 이 커넥션을 쓸 수 있는데, 이걸 현재 쓰레드에서 계속 잡고 있다가 또 다시 close()를 해버리면, 다른 쓰레드에서 사용중에 close()됐다고 나와 버리게 되는 거다.
3. conn.close();
4. conn = null;
위와 같이 커넥션을 close()한 뒤에 바로 null 로 설정하여 절대로 다시 사용할 수 없게 만들면 이런 실수는 생기지 않을 것이다.
<Resource name="jdbc/myDbResource" auth="Container" type="javax.sql.DataSource"
maxActive="10" maxIdle="5" maxWait="10000"
username="ao" password="ao"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/myWebApp"
removeAbandoned="true"
removeAbandonedTimeout="60"
logAbandoned="true"
validationQuery="select 1"
testOnBorrow="true"
testWhileIdle="true"
timeBetweenEvictionRunsMillis="10000"
minEvictableIdleTimeMillis="60000"
/>
저기서 removeAbandoned는 리소스 반환에 실패한 (혹은 안한) 커넥션을 자동으로 닫아주는 것이다.
validationQuery는 커넥션이 살아 있는지 테스트하는 코드이다.
MySQL, Connector/J 와 Tomcat 5 예제
http://dev.mysql.com/doc/connector/j/en/cj-tomcat-config.html 에 나온 내용임.
<Context ....>
...
<Resource name="jdbc/MySQLDB"
auth="Container"
type="javax.sql.DataSource"/>
<!-- The name you used above, must match _exactly_ here!
The connection pool will be bound into JNDI with the name
"java:/comp/env/jdbc/MySQLDB"
-->
<ResourceParams name="jdbc/MySQLDB">
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<!-- Don't set this any higher than max_connections on your
MySQL server, usually this should be a 10 or a few 10's
of connections, not hundreds or thousands -->
<parameter>
<name>maxActive</name>
<value>10</value>
</parameter>
<!-- You don't want to many idle connections hanging around
if you can avoid it, onl y enough to soak up a spike in
the load -->
<parameter>
<name>maxIdle</name>
<value>5</value>
</parameter>
<!-- Don't use autoReconnect=true, it's going away eventually
and it's a crutch for older connection pools that couldn't
test connections. You need to decide if your application is
supposed to deal with SQLExceptions (hint, it should), and
how much of a performance penalty you're willing to pay
to ensure 'freshness' of the connection -->
<parameter>
<name>validationQuery</name>
<value>SELECT 1</value>
</parameter>
<!-- The most conservative approach is to test connections
before they're given to your application. For most applications
this is okay, the query used above is very small and takes
no real server resources to process, other than the time used
to traverse the network.
If you have a high-load application you'll need to rely on
something else. -->
<parameter>
<name>testOnBorrow</name>
<value>true</value>
</parameter>
<!-- Otherwise, or in addition to testOnBorrow, you can test
while connections are sitting idle -->
<parameter>
<name>testWhileIdle</name>
<value>true</value>
</parameter>
<!-- You have to set this value, otherwise even though
you've asked connections to be tested while idle,
the idle evicter thread will never run -->
<parameter>
<name>timeBetweenEvictionRunsMillis</name>
<value>10000</value>
</parameter>
<!-- Don't allow connections to hang out idle too long,
never longer than what wait_timeout is set to on the
server...A few minutes or even fraction of a minute
is sometimes okay here, it depends on your application
and how much spikey load it will see -->
<parameter>
<name>minEvictableIdleTimeMillis</name>
<value>60000</value>
</parameter>
<!-- Username and password used when connecting to MySQL -->
<parameter>
<name>username</name>
<value>someuser</value>
</parameter>
<parameter>
<name>password</name>
<value>somepass</value>
</parameter>
<!-- Class name for the Connector/J driver -->
<parameter>
<name>driverClassName</name>
<value>com.mysql.jdbc.Driver</value>
</parameter>
<!-- The JDBC connection url for connecting to MySQL, notice
that if you want to pass any other MySQL-specific parameters
you should pass them here in the URL, setting them using the
parameter tags above will have no effect, you will also
need to use & to separate parameter values as the
ampersand is a reserved character in XML -->
<parameter>
<name>url</name>
<value>jdbc:mysql://localhost:3306/test</value>
</parameter>
</ResourceParams>
</Context>
원문 : http://www.microdeveloper.com/html/JNDI_Orcl_Tomcat1p.html
1) Modify the server.xml file
In<CATALINA_HOME>/conf/server.xml between <GlobalNamingResources> and </GlobalNamingResources> add the following
<Resource name="jdbc/<alias>"
auth="Cont ainer"
type="oracle.jdbc.pool.OracleDataSource"
driverClassName="oracle.jdbc.driver.OracleDriver"
factory="oracle.jdbc.pool.OracleDataSourceFactory"
url="jdbc:oracle:thin:@<host>:<port>:<sid>"
[user=<user>]
[password=<password>]
maxActive="20"
maxIdle="10"
maxWait="-1" />
Example
<!-- Global JNDI resources -->
<GlobalNamingResources>
<!-- Test entry for demonstration purposes -->
<Environment name="simpl eVal ue" type="java.lang.Integer" value="30"/>
<!-- Editable user database that can also be used by
UserDatabaseRealm to authenticate users -->
<Resource name="UserDatabase" auth="Container"
type="org.apache.catalina.UserDatabase"
description="User database that can be updated and saved"
factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
pathname="conf/tomcat-users.xml" />
<!-- Every connection to 'db1' uses the same user -->
<Resource name="jdbc/db1"
auth="Container"
type="oracle.jdbc.pool.OracleDataSource"
driverClassName="oracle.jdbc.driver.OracleDriver"
factory="oracle.jdbc.pool.OracleDataSourceFactory"
url="jdbc:oracle:thin:@oracle.microdeveloper.com:1521:db1"
user="scott"
password="tiger"
maxActive="20"
maxIdle="10"
maxWait="-1" />
<!-- Every connection to 'db2' must provide a username and password --> <Resource name="jdbc/db2"
auth="Container"
type="oracle.jdbc.pool.OracleDataSource"
driverClassName="oracle.jdbc.driver.OracleDriver"
factory="oracle.jdbc.pool.OracleDataSourceFactory"
url="jdbc:oracle:thin:@oracle.microdeveloper.com:1521:db2"
maxActive="20"
maxIdle="10"
maxWait="-1" />
</GlobalNamingResources>
2) Modify the context.xml file
In <CATALINA_HOME>/conf/context.xml between <Context> and </Context> add the following for each entry in the JNDI resource list:
<ResourceLink global="jdbc/<alias>" name="jdbc/<alias>" type="oracle.jdbc.pool.OracleDataSource"/>
Example
<!-- The contents of this file will be loaded for each web application -->
<Context>
<!-- Default set of monitored resources -->
<WatchedResource>WEB-INF/web.xml</WatchedResource>
<WatchedResource>META-INF/context.xml</WatchedResource>
<!-- Uncomment this to disable session persistence across Tomcat restarts -->
<!--
<Manager pathname="" />
-->
<ResourceLink global="jdbc/db1" name="jdbc/db1" type="oracle.jdbc.pool.OracleDataSource"/>
<ResourceLink global="jdbc/db2" name="jdbc/db2" type="oracle.jdbc.pool.OracleDataSource"/>
</Context>
3) Modify the context's web.xml file (5.0.x step only - not necessary for 5.5.x)
In the <CONTEXT>/WEB-INF/web.xml between <web-app> and </web-app> add the following:
<resource-ref>
<description><Your Description></description>
<res-ref-name>jdbc/<alias></res-ref-name>
<res-type>oracle.jdbc.pool.OracleDataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
Example
<resource-ref>
<description>Oracle Development Datasource</description>
<res-ref-name>jdbc/db1</res-ref-name>
<res-type>oracle.jdbc.pool.OracleDataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
<resource-ref>
<description>Oracle Development Datasource</description>
<res-ref-name>jdbc/db2</res-ref-name>
<res-type>oracle.jdbc.pool.OracleDataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
4) Restart Tomcat
1. DBCP 컴포넌트 설치
1.1 http://commons.apache.org/downloads/index.html 에서 다음 컴포넌트 다운로드
- Collections
- DBCP
- Pool
1.2 각 컴포넌트의 jar 파일을 WEB-INF/lib로 import
1.3 프로젝트 Properties의 Java Build Path에 WEB-INF/lib에 import한 jar를 추가
2. Tomcat 환경설정
2.1 conf/Server.xml 파일에 다음 내용 추가
<Resource name="jdbc/myoracle" auth="Container"
type="javax.sql.DataSource" driverClassName="oracle.jdbc.OracleDriver"
url="jdbc:oracle:thin:@127.0.0.1:1521:mysid"
username="scott" password="tiger" maxActive="20" maxIdle="10"
maxWait="-1"/>
2.2. WEB-INF/web.xml 파일에 다음 내용 추가
<resource-ref>
<description>Oracle Datasource example</description>
<res-ref-name>jdbc/myoracle</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
2.3 conf/context.xml에 다음 내용 추가
<ResourceLink global="jdbc/java62" name="jdbc/java62"
type="oracle.jdbc.pool.OracleDataSource"/>
3. JSP, JAVA Source
Context initContext = new InitialContext();
Context envContext = (Context)initContext.lookup("java:/comp/env");
DataSource ds = (DataSource)envContext.lookup("jdbc/myoracle");
Connection conn = ds.getConnection(); // 새로운 연결을 요청하는 것이 아니고 풀로부터 연결 주소를 받도록 오버라이딩 되어 있음
...
conn.close(); // 실제로 연결을 닫는 것이 아니고 연결을 반환하도록 오버라이딩 되어 있음
