Trackback Address :: http://www.ssial.com/trackback/224
'JSP'에 해당되는 글 33건
- 2008/12/03 servlet-2.2 publicdraft (17)
- 2008/12/03 Web-Tier Security Details (8)
- 2008/12/03 Understanding Login Authentication (7)
- 2008/12/03 URL descript (8)
- 2008/12/02 [링크]struts-taglib API Documents (11)
- 2008/11/27 JavaServer Pages Standard Tag Library (8)
- 2008/11/27 jstl API (8)
- 2008/11/25 taglib download site (6)
- 2008/11/20 JSP 페이징 블록 처리 테스트 예제 (3)
- 2008/11/07 DBCP Container 이용하여 Pool 객체 이용하기 (7)
Web-Tier Security Details
When the deployment container gets a request for a resource that is protected by the web-tier declarative security-constraint, it must evaluate the credentials of the user against the agent realm to ensure that only authorized requests go through. In order to process such a request, the deployment container requires the user to sign on using the specified form login page as mentioned in the form-login-config element of the web.xml descriptor. Based on the specification of the FORM authentication mechanism, it is required that the user submits a valid user name as j_username and a valid password as j_password to the special URI j_security_check using the HTTP POST method of form submission.
The agent, once configured to support web-tier declarative security for the given application can isolate the request for accessing form-login-page and instead can stream out some data to the client browser. This data contains the user’s login name and temporary encrypted password, which in turn uses Javascript to do automatic form submission as required. This gives the user a seamless single sign-on experience since the user does not have to re-login in order to access the protected resources for a deployed application that uses web-tier declarative security.
By default, the content that the agent sends to the client browser on intercepting a request for the form login page is read from the file called FormLoginContent.txt located in the locale directory of the agent installation. This file contains the following HTML code:
<html>
<head>
<title>Security Check</title>
</head>
<body onLoad="document.security_check_form.submit()">
<form name="security_check_form" action="j_security_check" method="POST">
<input type="hidden" value="am.filter.j_username" name="j_username">
<input type="hidden" value="am.filter.j_password" name="j_password">
</form>
</body>
</html>
|
Before the agent streams out the contents of this file, it replaces all occurrences of the string am.filter.j_username by the appropriate user name. Similarly, all occurrences of the string am.filter.j_password are replaced by a temporary encrypted string that acts as a one-time password for the user.
출처 : http://docs.sun.com/app/docs/doc/820-4802/gazki?l=en&a=view
Trackback Address :: http://www.ssial.com/trackback/223
출처 : http://java.sun.com/j2ee/1.4/docs/tutorial-update2/doc/Security5.htmlUnderstanding Login Authentication
When you try to access a protected Web resource, the Web container activates the authentication mechanism that has been configured for that resource. You can specify the following authentication mechanisms:
- HTTP basic authentication
- Form-based login authentication
- Client certificate authentication
- Mutual authentication
- Digest authentication
If you do not specify one of these mechanisms, the user will not be authenticated.
Using HTTP Basic Authentication
Figure 32-2 shows what happens if you specify HTTP basic authentication.
Figure 32-2 HTTP Basic Authentication
With basic authentication, the following things occur:
- A client requests access to a protected resource.
- The Web server returns a dialog box that requests the user name and password.
- The client submits the user name and password to the server.
- The server validates the credentials and, if successful, returns the requested resource.
HTTP basic authentication is not particularly secure. Basic authentication sends user names and passwords over the Internet as text that is uu-encoded (Unix-to-Unix encoded) but not encrypted. This form of authentication, which uses Base64 encoding, can expose your user names and passwords unless all connections are over SSL. If someone can intercept the transmission, the user name and password information can easily be decoded.
Example: Basic Authentication with JAX-RPC is an example application that uses HTTP basic authentication in a JAX-RPC service.
Using Form-Based Authentication
Figure 32-3 shows what happens if you specify form-based authentication, in which you can customize the login screen and error pages that an HTTP browser presents to the end user.
Figure 32-3 Form-Based Authentication
With form-based authentication, the following things occur:
- A client requests access to a protected resource.
- If the client is unauthenticated, the server redirects the client to a login page.
- The client submits the login form to the server.
- If the login succeeds, the server redirects the client to the resource. If the login fails, the client is redirected to an error page.
Form-based authentication is not particularly secure. In form-based authentication, the content of the user dialog box is sent as plain text, and the target server is not authenticated. This form of authentication can expose your user names and passwords unless all connections are over SSL. If someone can intercept the transmission, the user name and password information can easily be decoded.
Example: Using Form-Based Authentication is an example application that uses form-based authentication.
Using Client-Certificate Authentication
Client-certificate authentication is a more secure method of authentication than either basic or form-based authentication. It uses HTTP over SSL, in which the server and, optionally, the client authenticate one another using public key certificates. Secure Socket Layer (SSL) provides data encryption, server authentication, message integrity, and optional client authentication for a TCP/IP connection. You can think of a public key certificate as the digital equivalent of a passport. It is issued by a trusted organization, which is called a certificate authority (CA), and provides identification for the bearer.
If you specify client-certificate authentication, the Web server will authenticate the client using the client's X.509 certificate, a public key certificate that conforms to a standard that is defined by X.509 Public Key Infrastructure (PKI). Before running an application that uses SSL, you must configure SSL support on the server (see Installing and Configuring SSL Support) and set up the public key certificate (see Understanding Digital Certificates).
Example: Client-Certificate Authentication over HTTP/SSL with JAX-RPC describes an example application that uses client-certificate authentication.
Using Mutual Authentication
With mutual authentication, the server and the client authenticate each other. There are two types of mutual authentication:
- Certificate-based mutual authentication (see Figure 32-4)
- User name- and password-based mutual authentication (see Figure 32-5)
Figure 32-4 shows what occurs during certificate-based mutual authentication.
Figure 32-4 Certificate-Based Mutual Authentication
In certificate-based mutual authentication, the following things occur:
- A client requests access to a protected resource.
- The Web server presents its certificate to the client.
- The client verifies the server's certificate.
- If successful, the client sends its certificate to the server.
- The server verifies the client's credentials.
- If successful, the server grants access to the protected resource requested by the client.
Example: Client-Certificate Authentication over HTTP/SSL with JAX-RPC describes an example application that uses certificate-based mutual authentication.
Figure 32-5 shows what occurs during user name- and password-based mutual authentication.
Figure 32-5 User Name- and Password-Based Mutual Authentication
In user name- and password-based mutual authentication, the following things occur:
- A client requests access to a protected resource.
- The Web server presents its certificate to the client.
- The client verifies the server's certificate.
- If successful, the client sends its user name and password to the server, which verifies the client's credentials.
- If the verification is successful, the server grants access to the protected resource requested by the client.
Using Digest Authentication
Like HTTP basic authentication, HTTP digest authentication authenticates a user based on a user name and a password. However, the authentication is performed by transmitting the password in an encrypted form which is much more secure than the simple base64 encoding used by basic authentication. Digest authentication is not currently in widespread use, therefore, there is no further discussion of it in this document.
Configuring Authentication
To configure the authentication mechanism that the Web resources in a WAR will use, select the WAR in the
deploytooltree. Select the Security tabbed pane, and then proceed as follows:
- Select one of the user authentication methods described earlier.
- Specify a security realm. If omitted, the
filerealm is assumed. Select the Settings button beside the User Authentication Mechanism field to specify the realm.- If the authentication method is specified as form-based, specify a form login page and form error page. Select the Settings button beside the User Authentication Mechanism field to specify the login page and the error page to be used for form-based authentication.
Example: Using Form-Based Authentication
In this section, we discuss how to add form-based authentication to a basic JSP page. With form-based authentication, you can customize the login screen and error pages that are presented to the Web client for authentication of their user name and password. If the topic of authentication is new to you, please refer to the section Understanding Login Authentication.
The example application discussed in this tutorial can be found in
<INSTALL>/j2eetutorial14/examples/security/formbasedauth/. In general, the following steps are necessary to add form-based authentication to a Web client. In the example application included with this tutorial, most of these steps have been completed for you and are listed here to show what needs to be done should you wish to create a similar application.
- Map the role name to the appropriate users and groups defined for the Application Server. See Adding Authorized Users for more information on needed modifications.
- Edit the
build.propertiesfile. Thebuild.propertiesfile needs to be modified because the properties in this file are specific to your installation of the Application Server and J2EE 1.4 Tutorial. See Building the Examples for information on which properties need to be set.- Create the Web client. For this example, the Web client, a very simple JSP page, is already created. The client is discussed in Creating a Web Client for Form-Based Authentication.
- Create the login form and login error form pages. For this example, these files are already created. These pages are discussed in Creating the Login Form and Error Page.
- Add the appropriate security elements using
deploytool. See Specifying Security Elements for Form-Based Authentication for information on which settings need to be made.- Build, package, deploy, and run the Web application (see Building, Packaging, Deploying, and Running the Form-Based Authentication Example). You will use the
asanttool to compile the example application and to run the client. You will usedeploytoolto package and deploy the server.Adding Authorized Users
This example application will be configured to authorize access for users assigned to the role of
loginUser. To specify which users can assume that role and can access the protected parts of the application, you must map this role to users and groups defined for the Application Server.When the Application Server is started, it reads the settings in its configuration files. When a constrained resource is accessed, the Application Server verifies that the user name and password are authorized to access that resource before granting access to the requester. The roles that are authorized to access a resource are specified in the security constraint for that application.
Information for adding users to the Application Server is provided in Managing Users. For this example, create a new user and assign that user to the group
loginUser. For information about the steps required to map the user assigned to the group ofloginUseras defined on the Application Server to the role ofloginUserauthorized to access this application, see Adding Security to the Form-Based Example.Creating a Web Client for Form-Based Authentication
The Web client is a standard JSP page. None of the code that adds form-based authentication to the example is included in the Web client. The information that adds the form-based authentication to this example is specified in the deployment descriptor, which is created with
deploytool. The code for the JSP page used in this example,formbasedauth/web/index.jsp, is listed next. The running application is shown later in Figure 32-7.<html> <head><title>Hello</title></head> <body bgcolor="white"> <img src="duke.waving.gif"> <h2>My name is Duke.</h2> <h2><font color="black">Hello, ${pageContext.request.userPrincipal.name}!</font></h2> </body> </html>Creating the Login Form and Error Page
When you create a form-based login mechanism, you must specify which JSP page contains the form to obtain the user name and password to verify access. You also must specify which page is displayed if login authentication fails. This section discusses how to create the login form and error page. Adding Security to the Form-Based Example discusses how to specify these pages when you are setting up form-based authentication.
The login page can be an HTML page, a JSP page, or a servlet, and it must return an HTML page containing a form that conforms to specific naming conventions (see the Java Servlet 2.4 specification for more information on these requirements). The content of the login form in an HTML page, JSP page, or servlet for a login page should be coded as follows:
<form method=post action="j_security_check" > <input type="text" name= "j_username" > <input type="password" name= "j_password" > </form>The full code for the login page used in this example can be found at
<INSTALL>/j2eetutorial14/examples/security/formbasedauth/web/logon.jsp. An example of the running login form page is shown later in Figure 32-6.The login error page is displayed if the user enters a user name and password combination that is not authorized to access the protected URI. For this example, the login error page can be found at
<INSTALL>/j2eetutorial14/examples/security/formbasedauth/web/logonError.jsp. Here is the code for this page:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <head> <title> Login Error </title> </head> <body> <c:url var="url" value="/index.jsp"/> <p><a href="${url}">Try again.</a></p> </body> </html>Specifying Security Elements for Form-Based Authentication
To enable form-based authentication, you add the following elements to this application using
deploytool.
- A security constraint, which is used to define the access privileges to a collection of resources using their URL mapping.
- A Web resource collection, which is used to identify a subset of the resources within a Web application to which a security constraint applies. In this example, by specifying a URL pattern of
/*, we are specifying that all resources in this application are protected.- An authorized roles list, which indicates the user roles that should be permitted access to this resource collection. In this example, it is users assigned the role of
loginUser. If no role name is provided, no user is allowed to access the portion of the Web application described by the security constraint.- A user authentication method, which is used to configure the authentication method used and the attributes needed by the form login mechanism. The login page parameter provides the URI of a Web resource relative to the document root that will be used to authenticate the user. The error page parameter requires a URI of a Web resource relative to the document root that sends a response when authentication has failed.
In the Application Server, these security elements are added to the application using
deploytool, after the application has been packaged. Information on adding the security elements to this application usingdeploytoolis discussed in Adding Security to the Form-Based Example.Building, Packaging, Deploying, and Running the Form-Based Authentication Example
To build, package, deploy, and run the
security/formbasedauthexample, which uses form-based authentication, follow these steps.Building the Form-Based Authentication Example
- Follow the instructions in Building the Examples.
- Follow the instructions in Adding Authorized Users.
- Go to the
<INSTALL>/j2eetutorial14/examples/security/formbasedauth/directory.- Build the Web application by entering the following command at the terminal window or command prompt:
asant buildPackaging the Web Application
You can package the form-based authentication example using
asantordeploytool, or you can just open the WAR file located in the<INSTALL>/j2eetutorial14/examples/security/provided-wars/formbasedauth.warfile.To package the example using
asant, run the following command:To package the example using
deploytool, follow these steps:
- Start the Application Server if you have not already done so. For information on starting the Application Server, see Starting and Stopping the Application Server.
- Start
deploytool. Information on startingdeploytoolcan be found in Starting the deploytool Utility.- Package the
formbasedauthexample usingdeploytoolfollowing these steps. More detail on packaging Web applications can be found in Packaging Web Modules.
- Select File
New
deploytoolmenu.- Select Next from the Introduction page.
- Select the Create New Stand-Alone WAR Module radio button.
- In the WAR Location field, browse to the
<INSTALL>/j2eetutorial14/examples/security/formbasedauth/directory and create the fileformbasedauth.war. Give the WAR the nameFormBasedAuth.- Enter
/formbasedauthin the Context Root field.- Click Edit Contents to add the contents of the application to the WAR file. Select the
formbasedauth/directory from the Starting Directory list. Select each of the filesindex.jsp,logon.jsp,logonError.jsp, andduke.waving.giffrom thebuild/directory, and then click Add. Click OK to close this dialog box.- Click Next.
- Select JSP.
- Click Next.
- Select
index.jspin the JSP File Name field.- Click Next.
- Click Finish. The
FormBasedAuthexample displays in thedeploytooltree.- Select Save from the File menu to save the Web component.
Adding Security to the Form-Based Example
To add form-based authentication to your application, select the application in the
deploytooltree and then follow these steps:
- Select the Security tabbed pane.
- Select
Form Basedin the User Authentication Method field.- Select the Settings button. Set the following properties in this dialog box:
- Set Realm Name to
file.- Select
logon.jspfrom the Login Page list.- Select
logonError.jspfrom the Login Error Page list.- Click OK.
- Select Add Constraints to add a security constraint to this example.
- Select Add Collections to add a Web resource collection to this example.
- With the security constraint and Web resource collection selected, click the Edit Contents button.
- In the Edit Contents dialog box, select Add URL Pattern. In the edit box, make sure that the URL pattern reads
/*. Click OK to close this dialog box. Using a URL pattern of/*and selecting no HTTP patterns means that all files and methods in this application are protected and may be accessed only by a user who provides an authorized login.- Click OK.
- Click Edit Roles on the Security tabbed pane and then Edit Roles again in the Authorized Roles dialog box. Click Add, and then enter the role
loginUserin the Name column. This is the authorized role for this security constraint. Click OK to close this dialog box.- Select
loginUserin the left pane and click Add to add it to the list of authorized roles for this application. Select OK to close this dialog box.The next step is to map the authorized role of
loginUser, as defined in the application, to the group ofloginUserthat is defined for the Application Server. To do this, follow these steps:
- Select the General tabbed pane.
- Click the Sun-specific Settings button.
- In the Sun-specific Settings dialog box, select User to Role Mappings from the View list.
- Select
loginUserfrom the list of roles.- Click the Edit button under the Group box.
- Select
loginUserfrom the Available Groups list, and then click the Add button to map the role ofloginUser(defined for the application) to the group ofloginUser(defined for the Application Server). Click OK.
Note: If you don't see the list of users or groups that you defined using the Admin Console, connect to the Admin Server by double-clicking
localhost:4848in thedeploytooltree and entering your admin user name and password. If this is not the current target server, change to this server by selecting it and then selecting File
- Click Close to return to the General tabbed pane.
- Select File
After all the security elements have been added, view the generated deployment descriptor by selecting Tools
deploytoolmenu.Deploying the Web Application
To deploy the example using
asant, run the following command:To deploy the example using
deploytool, follow these steps:
- Select the
FormBasedAuthapplication in thedeploytooltree.- Select Tools
- Make sure the server is correct.
- Enter your admin user name and password.
- Click OK.
- Click the Close button after the messages indicating successful completion are finished.
Running the Web Application
Run the Web client by entering the following URL in your Web browser:
The login form displays in the browser, as shown in Figure 32-6. Enter a user name and password combination that corresponds to the role of
loginUser, and then click the Submit button.
Figure 32-6 Form-Based Login Page
If you entered
Debbieas the name and if there is a user defined for the Application Server with the user name ofDebbiethat also matches the password you entered and is assigned to the group ofloginUserthat we mapped to the role ofloginUser, the display will appear as in Figure 32-7.
Figure 32-7 The Running Form-Based Authentication Example
Note: For repetitive testing of this example, you may need to close and reopen your browser.
Using Authentication with SSL
Passwords are not protected for confidentiality with HTTP basic or form-based authentication, meaning that passwords sent between a client and a server on an unprotected session can be viewed and intercepted by third parties. To overcome this limitation, you can run these authentication protocols over an SSL-protected session and ensure that all message content is protected for confidentiality. To configure HTTP basic or form-based authentication over SSL, specify
CONFIDENTIALorINTEGRALas the network security requirement on the WAR's Security pane indeploytool. Read the section Specifying a Secure Connection for more information.
Trackback Address :: http://www.ssial.com/trackback/222
The following are two example URIs and their component parts
foo://username:password@example.com:8042/over/there/?name=ferret#nose
\ / |________________| |___________||__||_________| |_________| |___|
| | | | | | |
| userinfo hostname port path query fragment
| |________________________________|
scheme authority
|
| path
| ___________|____________
| | | |
urn:example:animal:ferret:nose
출처 : http://en.wikipedia.org/wiki/URI_scheme
foo://username:password@example.com:8042/over/there/?name=ferret#nose
\ / |________________| |___________||__||_________| |_________| |___|
| | | | | | |
| userinfo hostname port path query fragment
| |________________________________|
scheme authority
|
| path
| ___________|____________
| | | |
urn:example:animal:ferret:nose
출처 : http://en.wikipedia.org/wiki/URI_scheme
Trackback Address :: http://www.ssial.com/trackback/221
Trackback Address :: http://www.ssial.com/trackback/194
Trackback Address :: http://www.ssial.com/trackback/164
Trackback Address :: http://www.ssial.com/trackback/163
http://jakarta.apache.org/site/downloads/downloads_taglibs.html
jstl.jar 와 standard.jar를 WEB-INF\lib에 복사한다.
jstl은 인터페이스이고 standard는 구현체이다.
http://java.sun.com/products/jsp/taglibraries/index.jsp
jstl.jar 와 standard.jar를 WEB-INF\lib에 복사한다.
jstl은 인터페이스이고 standard는 구현체이다.
http://java.sun.com/products/jsp/taglibraries/index.jsp
Trackback Address :: http://www.ssial.com/trackback/161
=========================== PagingTest.jsp ==================================
<html>
<head><title>페이징 블록 처리 테스트</title>
<link href="style.css" rel="stylesheet" type="text/css">
<body>
<center>
<br>
<br>
<h2>페이징 블록 처리 테스트</h2>
<FORM METHOD=POST ACTION="PagingResult.jsp">
총 레코드 값 : <INPUT TYPE="text" NAME="totalRecord">
<INPUT TYPE="submit" value="보내기">
</FORM>
</center>
</body>
</html>
=========================== PagingResult.jsp ==================================
<%@ page contentType="text/html;charset=EUC-KR"%>
<%
/*
페이징에 필요한 변수 10가지
// 초기값 변수 3개
01. totalRecord //전체 record 수 , 배열의 length, size(), length(), sql문의 count()
02. NUM_PER_PAGE = 10; // 한 페이지에 보여질 행(목록)의 수 지정 , 상수
03. PAGE_PER_BLOCK = 20; // 한 블록에서 보여질 페이지의 수 지정, 상수
// 사용자 요청 변수 2개
04. nowPage // 디폴트 값은 1페이지(인덱스 값은 0), 사용자의 요청의 의해서 결정 ,
// request.getParameter("nowPage"); 으로 받아서 사용
// beginPerPage를 계산하는 데 사용하기 때문에 타입케스팅이 필요하다.
// Integer.parseInt(request.getParameter("nowPage"));
05. nowBlock // 디폴트 값은 1 블록(인덱스 값은 0), 사용자의 요청의 의해서 결정 ,
// request.getParameter("nowBlock"); 으로 받아서 사용
// 페이징의 페이지에 표시되는 숫자의 인덱스 값을 구하기 위해서 타입케스팅이 필요하다.
// Integer.parseInt(request.getParameter("nowBlock"));
// 검색 처리 변수 2개
06. keyField // 검색기능을 수행 할 때 필요한 필드명를 저장하는 변수, sql문에서 사용
07. keyWord // 검색기능을 수행 할 때 필요한 필드의 검색하려는 내용을 저장하는 변수, sql문에서 사용
// select * from board where " + keyField + " like '%" + keyWord + "%'
// 페이징을 화면에 표시 할 때 필요한 변수 3개
08. beginPerPage // 페이지를 출력 할 때 첫번째 위치를 찾는 변수, for문의 초기값에 사용
// 계산하는 방법은 = (nowPage * NUM_PER_PAGE) + 1;
09. totalPage // 전체 페이지의 숫자를 저장해서 페이징의 페이지 숫자를 표시 할 때 필요,
// 계산하는 방법은 = (totalREecord / NUM_PER_PAGE) + (((totalRecord % NUM_PER_PAGE) != 0) ? 1 : 0);
// 계산하는 방법은 = (int)Math.ceil((double)totalRecord / NUM_PER_PAGE);
10. totalBlock // 전체 블록수를 저장해서 페이징의 블록 숫자를 표시 할 때 필요,
// 계산하는 방법은 = (totalPage / NUM_PER_BLOCK) + (((totalRecord % NUM_PER_BLOCK) != 0) ? 1 : 0);
// 계산하는 방법은 = (int)Math.ceil((double)totalPage / NUM_PER_BLOCK);
*/
int nowPage = 0;
int nowBlock = 0;
int totalRecord = Integer.parseInt(request.getParameter("totalRecord"));
int NUM_PER_PAGE = 7;
int PAGE_PER_BLOCK = 10;
int totalPage =(int)Math.ceil((double)totalRecord / NUM_PER_PAGE);
int totalBlock =(int)Math.ceil((double)totalPage / PAGE_PER_BLOCK);
if (request.getParameter("nowPage") != null){
nowPage= Integer.parseInt(request.getParameter("nowPage")); }
if (request.getParameter("nowBlock") != null){
nowBlock = Integer.parseInt(request.getParameter("nowBlock"));}
int beginPerPage = nowPage * NUM_PER_PAGE;
%>
<html>
<head><title>JSPBoard</title>
<link href="style.css" rel="stylesheet" type="text/css">
<script>
function preBlock(nowBlock,nowPage){
document.total.nowBlock.value = nowBlock;
document.total.nowPage.value = nowPage;
total.submit();
}
function prePage(nowBlock,nowPage){
document.total.nowBlock.value = nowBlock;
document.total.nowPage.value = nowPage;
total.submit();
}
function afterBlock(nowBlock,nowPage){
document.total.nowBlock.value = nowBlock;
document.total.nowPage.value = nowPage;
total.submit();
}
</script>
</head>
<body><center><br>
<h2>페이징 블록 처리 테스트</h2>
<br>
<table>
<tr>
<td>게시물번호 : </td>
</tr>
<%
for (int i = beginPerPage;i < (beginPerPage+NUM_PER_PAGE); i++) {
if (i==totalRecord){ break;}
%>
<tr>
<td align=center><%= i + 1 %> </td>
</tr>
<%}%>
</table><p>
<table>
<tr>
<td align="left" >
<% if(totalRecord !=0){ %> Go to Page
<% if (nowBlock > 0) {%>
<a href="javascript:preBlock('<%=nowBlock - 1 %>','<%=((nowBlock - 1) * PAGE_PER_BLOCK)%>')">
이전 <%=PAGE_PER_BLOCK %>개</a>
<%}%>
:::
<%
for (int i = 0; i < PAGE_PER_BLOCK; i++) { %>
<a href="javascript:prePage('<%=nowBlock%>','<%=(nowBlock*PAGE_PER_BLOCK) + i %>')">
<%=(nowBlock * PAGE_PER_BLOCK) + i + 1 %></a>
<% if ((nowBlock * PAGE_PER_BLOCK) + i + 1 == totalPage) { break; } %>
<%} %>
:::
<% if (totalBlock > nowBlock + 1) { %>
<a href="javascript:afterBlock('<%=nowBlock + 1 %>','<%=((nowBlock +1) * PAGE_PER_BLOCK)%>')">
다음 <%=PAGE_PER_BLOCK%>개</a>
<%}%>
<%} else{out.println("등록된 게시물이 없습니다."); }%>
</td>
</tr>
</table>
<form name="total">
<input type="hidden" name ="totalRecord" value="<%=totalRecord%>">
<input type="hidden" name ="nowBlock">
<input type="hidden" name ="nowPage">
</form>
</center>
</body>
</html>
Trackback Address :: http://www.ssial.com/trackback/149
Container를 이용해서 pool객체를 이용하기 위해서는 JNDI를 이용해야 한다.
JNDI는 J2EE의 javax.naming.* 패키지안의 JNDI 클래스를 import해야한다.
============== 데이터를 처리하는 JDBC 로직을 수행하는 파일 ==============
<%@ page import="javax.sql.*"%>
<%@ page import="javax.naming.*"%>
<%
.
.
.
Context initCtx = new InitialContext();
Context envCtx = (Context)initCtx.lookup("java:comp/env");
DataSource ds = (DataSource)envCtx.lookup("jdbc/MySQLDataSource");
con = ds.getConnection();
.
.
.
%>
그리고 프로젝트 WEB-INF\web.xml과 %CATALINA_HOME%\conf\server.xml 을 수정해야 한다.
================ web.xml ============================
<resource-ref>element를 추가한다.
=====================================================
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
.
.
.
<resource-ref>
<res-ref-name>jdbc/MySQLDataSource</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
.
.
.
</web-app>
================ server.xml ============================
<Resource>element를 두 곳에 추가한다.
=======================================================
<Server port="8005" shutdown="SHUTDOWN">
.
.
.
<GlobalNamingResources>
<Resource auth="Container" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" name="UserDatabase" pathname="conf/tomcat-users.xml" type="org.apache.catalina.UserDatabase"/>
<Resource auth="Container" name="jdbc/MySQLDataSource" type="javax.sql.DataSource" driverClassName="com.mysql.jdbc.Driver" password="1234" maxIdle="2" maxWait="5000" username="jspuser"
url="jdbc:mysql://localhost:3306/testboarddb"
maxActive="4"/>
</GlobalNamingResources>
.
.
.
<Service name="Catalina">
.
.
.
<Engine defaultHost="localhost" name="Catalina">
.
.
.
<Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true" xmlNamespaceAware="false" xmlValidation="false">
.
.
.
<Context docBase="TestBoard" path="/TestBoard" reloadable="true" source="org.eclipse.jst.jee.server:TtestBoard">
<Resource auth="Container" name="jdbc/MySQLDataSource" type="javax.sql.DataSource" driverClassName="com.mysql.jdbc.Driver" password="1234" maxIdle="2" maxWait="5000" username="jspuser"
url="jdbc:mysql://localhost:3306/testboarddb"
maxActive="4"/>
</Context>
</Host>
</Engine>
</Service>
</Server>
JNDI는 J2EE의 javax.naming.* 패키지안의 JNDI 클래스를 import해야한다.
============== 데이터를 처리하는 JDBC 로직을 수행하는 파일 ==============
<%@ page import="javax.sql.*"%>
<%@ page import="javax.naming.*"%>
<%
.
.
.
Context initCtx = new InitialContext();
Context envCtx = (Context)initCtx.lookup("java:comp/env");
DataSource ds = (DataSource)envCtx.lookup("jdbc/MySQLDataSource");
con = ds.getConnection();
.
.
.
%>
그리고 프로젝트 WEB-INF\web.xml과 %CATALINA_HOME%\conf\server.xml 을 수정해야 한다.
================ web.xml ============================
<resource-ref>element를 추가한다.
=====================================================
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
.
.
.
<resource-ref>
<res-ref-name>jdbc/MySQLDataSource</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
.
.
.
</web-app>
================ server.xml ============================
<Resource>element를 두 곳에 추가한다.
=======================================================
<Server port="8005" shutdown="SHUTDOWN">
.
.
.
<GlobalNamingResources>
<Resource auth="Container" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" name="UserDatabase" pathname="conf/tomcat-users.xml" type="org.apache.catalina.UserDatabase"/>
<Resource auth="Container" name="jdbc/MySQLDataSource" type="javax.sql.DataSource" driverClassName="com.mysql.jdbc.Driver" password="1234" maxIdle="2" maxWait="5000" username="jspuser"
url="jdbc:mysql://localhost:3306/testboarddb"
maxActive="4"/>
</GlobalNamingResources>
.
.
.
<Service name="Catalina">
.
.
.
<Engine defaultHost="localhost" name="Catalina">
.
.
.
<Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true" xmlNamespaceAware="false" xmlValidation="false">
.
.
.
<Context docBase="TestBoard" path="/TestBoard" reloadable="true" source="org.eclipse.jst.jee.server:TtestBoard">
<Resource auth="Container" name="jdbc/MySQLDataSource" type="javax.sql.DataSource" driverClassName="com.mysql.jdbc.Driver" password="1234" maxIdle="2" maxWait="5000" username="jspuser"
url="jdbc:mysql://localhost:3306/testboarddb"
maxActive="4"/>
</Context>
</Host>
</Engine>
</Service>
</Server>
Trackback Address :: http://www.ssial.com/trackback/139
