'개발이야기'에 해당되는 글 49건

1. 드래그 구현

마우스를 누른 상태에서 움직이면 선택한 요소가 함께 이동하는 것을 드래그라고 한다. 이런 드래그 기능을 구현하기 위해서는 다음의 3가지 마우스 이벤트를 사용하면 된다.

mousedown - 드래그할 객체를 선택할때 사용
mousemove - 객체를 드래그할 때 사용
mouseup - 드래그를 종료할 때 사용 


mousedown  발생하면 
드래그할 요소지정, 마우스 포인트와 요소 좌측상단 사이의 거리 저장
document 객체에 mousemove와 mouseup 이벤트를 등록한다
이벤트 전파를 중지.


mousemove 발생
드래그 할 요소 위치를 이동, 이 때 앞서 저장한 마우스 포인트와 요소 좌측 상단 사이의 거리값을 사용.
이벤트 전파를 중지.

mouseup 발생
드래그 중이 아닌 것으로 지정
이벤트 전파 중지

가장 먼저 할 작업은 드래그로 이동하길 원하는 요소에 mousedown 이벤트 핸들러를 등록하는 것이다. mousedown 이벤트가 발생하면 해당 요소를 드래그 할 것이라고 표시하게 된다. 이때 마우스 포인터와 드래그 요소의 좌측 상단 사이의 거리를 저장해야 한다. 그 이유는 마우스를 움직일 때 알맞게 요소를 이동시키기 위해서 이다. 그 이유는 마우스를 움직일 때 알맞게 요소를 이동시키기 위해서 이다.

마우스가 이동하면 요소의 좌측 상단을 마우스 이동한 거리에 비례해서 이동시켜 주어야 하는데, 드래그할 요소를 선택할 때 마우스 포인터와 요소 좌측 상단사이의 거리를 저장하지 않는다면 비례해서 이동할 수 없을 것이다.

실제로 드래그 기능을 어떻게 구현하는지 SimpleDragSource 모듈을 통해서 살펴보자.

1.1 단순 드래그를 지원하는 SimpleDragSource 모듈 작성하기

이번 절에서는 다음과 같은 코드만 실행하면 관련 요소를 드래그할수 있도록 해주는 SimpleDragSource를 만들어 보기로 한다.

var drag  = new ajax.dnd.SimpleDragSource("car");


dnd.js


  
        ajax.dnd = {};
        ajax.dnd.SimpleDrag = function (elementid) {
        this.element = document.getElementById(elementid);  //드래그 가능하게 할요소구함
        this.dragging = false; //현재 드래그 중인지 여부 표시
        this.selected = false; //현재 마우스 다운 상태인지 표시
        this.diff = null;         //마우스 위치와 객체 위치
        
        this.mouseDown = ajax.Event.bindAsListener(this.doMouseDown, this);
        this.mouseMove = ajax.Event.bindAsListener(this.doMouseMove, this);
        this.mouseup = ajax.Event.bindAsListener(this.doMouseUp, this);
        
        ajax.Event.addListener(this.element, "mousedown",this.mouseDown);
        //드래그할 요소에 mousedown 이벤트 등록
       }
       
       ajax.dnd.SimpleDrag.prototype = {
       
         doMouseDown : function(e) {
            var event = window.event || e;
            if(!ajax.Event.isLeftButton(event))           return;
         this.selected = true; //드래그 하기 위해 선택한 상태로 표시
         
         //드래그할 요소와 마우스 포인터 사이의 거리를 구해서 저장
        var elementXY = ajax.GUI.getXY(this.element);
         var mouseXY = ajax.Event.getMouseXY(event);
         this.diff = {
            x: mouseXY.x - elementXY.x,
            y: mouseXY.y - elementXY.y
            
            };
            
          ajax.Event.addListener(document, "mousemove", this.mouseMove);
          ajax.Event.addListener(document, "mouseup" , this.mouseUp);
          //document에 mousemove와 mouseup 핸들러 추가
          ajax.Event.stopEvent(event);
         
         },
         
        doMouseMove: function(e) {         //mousedown 처리 후, mousemove 발생하면 호출
           if(!this.selected) return false; //선택된 상태가 아니면 이동시키지 않음
         
         if(!this.dragging) {
            this.dragging = true;
            ajax.GUI.setOpacity(this.element, 0.60);  
            }
            // 첫 번째 mousemove 발생시 드레그 상태로 변경하고, 요소를 투명하게 처리
            
           var event = window.event || e;
           var mouseXY = ajax.Event.getMouseXY(event);
           var newXY = {
              x: mouseXY.x - this.diff.x,       //마우스 위치에서 라인 25에서 저장한 거리 값을 빼서 요소의 새로운 위치를 구함
              y: mouseXY.y - this.diff.y
            }
           ajax.GUI.setXY(this.element, newXY.x, newXY.y); //위치변경
           
           ajax.Event.stopEvent(event);
        },
        
        doMouseUp: function(e) {        // mousedown 처리 후, mouseup 발생하면 호출
            if(!this.selected) return;
            
            this.selected = false;  //선택되지 않은 상태로 변경하고 앞서 구한 마우스와의 거리 값도 없앰
            this.diff = null;
            
            var event = window.event || e;
            if(this.dragging) {
                this.dragging = false;
                ajax.GUI.setOpacity(this.element, 1.0); //드레그 중이었으면 드레그 상태 아니라고 표시하고, 요소를 불투명하게 처리
            }
            
            ajax.Event.removeListener(document, "mousemove", this.mouseMove);
            ajax.Event.removeListener(document, "mouseup" , this.mouseUp);
            ajax.Event.stopEvent(event);
        }
      }  


SimpleDrag  클래스의 생성자에서 드래그할 요소에 mousedown 이벤트 핸들러를 등록한다. 사용자가 드래그할 요소에서 mousedown 이벤트를 발생 시키면 doMouseDown 함수가 호출된다.

doMouseDown 함수는 드래그 요소가 선택되었다는 것을 나타내기 위해 this.selected 변수 값을 true로 할당한다. 그런 뒤, 마우스 포인터와 드래그 요소 사이의 거리를 구해서 this.diff에 저장한다. 마지막으로 document 객체에 mousemove 이벤트 핸들러와 mouseup 이벤트 핸들러를 등록하고 이벤트 전파를 중지시킨다.

이제 사용자가 마우스를 이동하면 doMouseMove 함수가 호출된다. doMouseMove 함수는 드래그 요소를 선택한 이후(즉, mousedown 이벤트 발생 이후) 처음 마우스를 이동한 경우, 드래그 상태임을 표시하기 위해 this.dragging 변수 값을 true로 지정한다. 이때 요소를  토명하게 함으로써 이동 중임을 시각적으로 알 수 있게 하였다. 이후 mousedown 이벤트가 발생하면 this.dragging 값이 true 이므로 ,
    if(!this.dragging) {
            this.dragging = true;
            ajax.GUI.setOpacity(this.element, 0.60);  
            }
라인은 더이상 실행되지 않는다.

doMouseMove 함수는 this.dragging 값을 판단한 후, 마우스 포인터의 위치를 구한다. 마우스 포인터의 위치로부터 this.diff에 저장된 값을 빼서 드래그 요소의 새위치를 구한다. 그런 뒤 요소를 새로운 위치로 이동한다.

마우스를 이동하다가 버튼을 떼면 doMouseUp 함수가 호출된다. doMouseUp 함수는 현재 드래그 중인지의 여부를 판단한다. 그 이유는 마우스 버튼을 누른 뒤, 마우스를 이동하지 않으면 마우스가 드래그 중이지 않았으므로 이동과 관련된 마무리 처리를 할 필요가 없기 때문이다. 드래그 중이었다면 this.dragging의 값을 false로 지정해서 드래그 중이 아닌 상태로 변경하고, 드래그 중에 요소를 투명하게 설정했으므로 요소를 불투명하게 변경한다.

마지막으로 document 등록했던 mousemove 이벤트 핸들러와 mouseup 이벤트 핸들러를 등록한다. 만약 이 두 이벤트 핸들러를 제거하지 않으면, 드래그 중인지에 상관업이 마우스가 이동되거나 버튼을 뗄 때마다 이 두 이벤트 핸들러가 호출되어 불필요하게 자원을 소모하게 된다.

SimpleDrag.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="SimpleDrag.aspx.cs" Inherits="SimpleDrag" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>제목 없음</title>
    <script type="text/javascript" src="ajax.js"></script>
    <script type="text/javascript" src="dnd.js"></script>
    <script type="text/javascript">
    window.onload = function() {
        var drag1 = new ajax.dnd.SimpleDragSource("car");
        var drag2 = new ajax.dnd.SimpleDragSource("navi");
    
    }
    </script>
    <style type="text/css">
    #navi {
        position: absolute;
        background-color: #aaa;
        left:200px top:90px;
        width: 150px; height: 80px;
       }
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <img src="car.jpg" id="car"/>
    자동차 이미지를 생각해봅시다.
        <div id="navi">
     플로팅 메뉴<br/>
     메뉴1<br/>메뉴2
     </div>
        </form>
</body>
</html>

실행결과

드래그 후

출처 : Ajax/최범균님의 AjaxProgramming 다시읽기

여러가지 원인이 있을수있는데 주로 DB관련작업을 하는 sql구문이 잘못됬기때문이다.
pstmt=conn.prepareStatement("select seq, name, passwd, title, content, regdate, readcount from board where seq = ?");
이렇게 적혀있는 코드였고..SQL서버에서 쿼리를 실행했을때 아무 오류가 없었는데..이상했다.

결국 코딩을 고쳤더니..제대로 수행되더라 -ㅁ-;;이런 젠장할늠의 띄어쓰기..
String sql="select  seq, name, passwd, title, content, regdate, readcount from board where seq = ?";
pstmt=conn.prepareStatement(sql);

이걸로 ㅠ.ㅠ 아까운 시간을 한시간이나 보냈다..젠장 ㅠ.ㅠ

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<fmt:formatDate value="${schedule.matchTime}" type="both" pattern="MM:dd" />

편집할 그리드를 더블클릭하여 그리드툴 편집대화상자를 연다.

BODY에 체크박스를 선택하고 Edit(E) 속성을 속택하고 오른쪽마우수를 두번 더블클릭하면 다음과 같은 수식편집 대화상자가 나타난다.

마이플랫폼 메뉴얼에서 iif 함수에 대해서 검색해보자.

Parameters

Return Value

currow 그리드에서 현재 선택된 레코드의 값이 2일경우 Edit에 속성을 'none'로 설정하고 그렇지 않을경우 checkboxk로 설정한다.

2번째 row가 선택된 경우는 checkbox가 선택되지 않는다.

여기서 특정한 조건에따라서 2번째 로우를 제어하고 싶으므로

iif( gQmPlanType==3 && currow == 2, 'none' ,'checkbox' )  global변수에 특정값을 조건에 추가해주었다.

Unique Key를 생성하는 방법은 DBMS마다 차이가 있다.
MS-SQL은 IDENTITY를, MySQL은 auto_increment와 같이 쉽게 사용할 수 있는 방법이 있는데 오라클에서는 Sequence를 사용하여 다음과 같이 유사하게 구현할 수 있다

1. 자동증가컬럼을 사용하고자 하는 MYTABLE테이블을 생성한다.

        CREATE TABLE MYTABLE
                (ID NUMBER, NAME VARCHAR2(20));

2. CREATE SEQUENCE 라는 문장을 사용하여 SEQ_ID라는 이름의 시퀀스를 만든다.

        CREATE SEQUENCE SEQ_ID INCREMENT BY 1 START WITH 10000;

       -- INCREMENT BY 1 : 증가값은 1
       -- START WITH 10000 :  10000부터 증가

3.  테이블에 데이터 입력시에는 NEXTVAL이라는 슈도 칼럼(Pseudo-column)을 이용하여 시퀸스를 사용한다.

        INSERT INTO MYTABLE VALUES( SEQ_ID.NEXTVAL, '홍길동');

        -- CURRVAL : 현재 값을 반환 합니다. . 
        -- NEXTVAL : 현재 시퀀스값의 다음 값을 반환 합니다. 

----------------------------------------------------------------------------------------------------------

* Sequence 구문

CREATE SEQUENCE sequence_name 
        [START WITH n]
        [INCREMENT BY n]
        [MAXVALUE n | NOMAXVALUE]
        [MINVALUE n | NOMINVALUE]
        [CYCLE | NOCYCLE]

* START WITH
시퀀스의 시작 값을 지정합니다. n을 1로 지정하면 1부터 순차적으로 시퀀스번호가 증가 합니다.

* INCREMENT BY
시퀀스의 증가 값을 말합니다. n을 2로 하면 2씩 증가합니다. 
START WITH를 1로 하고 INCREMENT BY를 2으로 하면 1, 3, 5,7,..
이렇게 시퀀스  번호가 증가하게 됩니다.

* MAXVALUE n | NOMAXVALUE 
MAXVALUE는 시퀀스가 증가할수 있는 최대값을 말합니다. 
NOMAXVALUE는 시퀀스의 값을 무한대로 지정합니다.

* MINVALUE n  | NOMINVALUE
MINVALUE는 시퀀스의 최소값을 지정 합니다. 
기본값은 1이며, NOMINVALUE를 지정할 경우 최소값은 무한대가 됩니다

[사용규칙]

  * NEXTVAL, CURRVAL을 사용할 수 있는 경우
    - subquery가 아닌 select문
    - insert문의 select절
    - insert문의 value절
    - update문의 set절

  * NEXTVAL, CURRVAL을 사용할 수 없는 경우
    - view의 select절
    - distinct 키워드가 있는 select문
    - group by, having, order by절이 있는 select문
    - select, delete, update의 subquery
    - create table, alter table 명령의 default값

[수정과 삭제]

ALTER SEQUENCE sequence_name 
        [INCREMENT BY n]
        [MAXVALUE n | NOMAXVALUE]
        [MINVALUE n | NOMINVALUE]
        [CYCLE | NOCYCLE]

START WITH는 수정할수 없습니다. 
START WITH 절이 없다는 점을 빼고는 CREATE SEQUENCE와 같습니다.

DROP SEQUENCE  sequence_name

server.xml

* 빨간색으로 강조한 것들에 대해서 POST번호를 바꿔준다.

<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- Example Server Configuration File -->
<!-- Note that component elements are nested corresponding to their
     parent-child relationships with each other -->

<!-- A "Server" is a singleton element that represents the entire JVM,
     which may contain one or more "Service" instances.  The Server
     listens for a shutdown command on the indicated port.

     Note:  A "Server" is not itself a "Container", so you may not
     define subcomponents such as "Valves" or "Loggers" at this level.
 -->

<Server port="2005" shutdown="SHUTDOWN">

  <!-- Comment these entries out to disable JMX MBeans support used for the 
       administration web application -->
  <Listener className="org.apache.catalina.core.AprLifecycleListener" />
  <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.storeconfig.StoreConfigLifecycleListener"/>

  <!-- Global JNDI resources -->
  <GlobalNamingResources>

    <!-- Test entry for demonstration purposes -->
    <Environment name="simpleValue" 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" />

  </GlobalNamingResources>

  <!-- A "Service" is a collection of one or more "Connectors" that share
       a single "Container" (and therefore the web applications visible
       within that Container).  Normally, that Container is an "Engine",
       but this is not required.

       Note:  A "Service" is not itself a "Container", so you may not
       define subcomponents such as "Valves" or "Loggers" at this level.
   -->

  <!-- Define the Tomcat Stand-Alone Service -->
  <Service name="Catalina">

    <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned.  Each Connector passes requests on to the
         associated "Container" (normally an Engine) for processing.

         By default, a non-SSL HTTP/1.1 Connector is established on port 8080.
         You can also enable an SSL HTTP/1.1 Connector on port 8443 by
         following the instructions below and uncommenting the second Connector
         entry.  SSL support requires the following steps (see the SSL Config
         HOWTO in the Tomcat 5 documentation bundle for more detailed
         instructions):
         * If your JDK version 1.3 or prior, download and install JSSE 1.0.2 or
           later, and put the JAR files into "$JAVA_HOME/jre/lib/ext".
         * Execute:
             %JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA (Windows)
             $JAVA_HOME/bin/keytool -genkey -alias tomcat -keyalg RSA  (Unix)
           with a password value of "changeit" for both the certificate and
           the keystore itself.

         By default, DNS lookups are enabled when a web application calls
         request.getRemoteHost().  This can have an adverse impact on
         performance, so you can disable it by setting the
         "enableLookups" attribute to "false".  When DNS lookups are disabled,
         request.getRemoteHost() will return the String version of the
         IP address of the remote client.
    -->

    <!-- Define a non-SSL HTTP/1.1 Connector on port 8080 -->
    <Connector port="2020" maxHttpHeaderSize="8192"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
    <!-- Note : To disable connection timeouts, set connectionTimeout value
     to 0 -->
 
 <!-- Note : To use gzip compression you could set the following properties :
 
      compression="on" 
      compressionMinSize="2048" 
      noCompressionUserAgents="gozilla, traviata" 
      compressableMimeType="text/html,text/xml"
 -->

    <!-- Define a SSL HTTP/1.1 Connector on port 8443 -->
    <!--
    <Connector port="8443" maxHttpHeaderSize="8192"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS" />
    -->

    <!-- Define an AJP 1.3 Connector on port 8009 -->
    <Connector port="2009" 
               enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />

    <!-- Define a Proxied HTTP/1.1 Connector on port 8082 -->
    <!-- See proxy documentation for more information about using this. -->
    <!--
    <Connector port="8082" 
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" acceptCount="100" connectionTimeout="20000"
               proxyPort="80" disableUploadTimeout="true" />
    -->

    <!-- An Engine represents the entry point (within Catalina) that processes
         every request.  The Engine implementation for Tomcat stand alone
         analyzes the HTTP headers included with the request, and passes them
         on to the appropriate Host (virtual host). -->

    <!-- You should set jvmRoute to support load-balancing via AJP ie :
    <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">         
    --> 
         
    <!-- Define the top level container in our container hierarchy -->
    <Engine name="Catalina" defaultHost="localhost">

      <!-- The request dumper valve dumps useful debugging information about
           the request headers and cookies that were received, and the response
           headers and cookies that were sent, for all requests received by
           this instance of Tomcat.  If you care only about requests to a
           particular virtual host, or a particular application, nest this
           element inside the corresponding <Host> or <Context> entry instead.

           For a similar mechanism that is portable to all Servlet 2.4
           containers, check out the "RequestDumperFilter" Filter in the
           example application (the source for this filter may be found in
           "$CATALINA_HOME/webapps/examples/WEB-INF/classes/filters").

           Note that this Valve uses the platform's default character encoding.
           This may cause problems for developers in another encoding, e.g.
           UTF-8.  Use the RequestDumperFilter instead.

           Also note that enabling this Valve will write a ton of stuff to your
           logs.  They are likely to grow quite large.  This extensive log writing
           will definitely slow down your server.

           Request dumping is disabled by default.  Uncomment the following
           element to enable it. -->
      <!--
      <Valve className="org.apache.catalina.valves.RequestDumperValve"/>
      -->

      <!-- Because this Realm is here, an instance will be shared globally -->

      <!-- This Realm uses the UserDatabase configured in the global JNDI
           resources under the key "UserDatabase".  Any edits
           that are performed against this UserDatabase are immediately
           available for use by the Realm.  -->
      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
             resourceName="UserDatabase"/>

      <!-- Comment out the old realm but leave here for now in case we
           need to go back quickly -->
      <!--
      <Realm className="org.apache.catalina.realm.MemoryRealm" />
      -->

      <!-- Replace the above Realm with one of the following to get a Realm
           stored in a database and accessed via JDBC -->

      <!--
      <Realm  className="org.apache.catalina.realm.JDBCRealm"
             driverName="org.gjt.mm.mysql.Driver"
          connectionURL="jdbc:mysql://localhost/authority"
         connectionName="test" connectionPassword="test"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
      -->

      <!--
      <Realm  className="org.apache.catalina.realm.JDBCRealm"
             driverName="oracle.jdbc.driver.OracleDriver"
          connectionURL="jdbc:oracle:thin:@ntserver:1521:ORCL"
         connectionName="scott" connectionPassword="tiger"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
      -->

      <!--
      <Realm  className="org.apache.catalina.realm.JDBCRealm"
             driverName="sun.jdbc.odbc.JdbcOdbcDriver"
          connectionURL="jdbc:odbc:CATALINA"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
      -->

      <!-- Define the default virtual host
           Note: XML Schema validation will not work with Xerces 2.2.
       -->
      <Host name="localhost" appBase="webapps"
       unpackWARs="true" autoDeploy="true"
       xmlValidation="false" xmlNamespaceAware="false">

        <!-- Defines a cluster for this node,
             By defining this element, means that every manager will be changed.
             So when running a cluster, only make sure that you have webapps in there
             that need to be clustered and remove the other ones.
             A cluster has the following parameters:

             className = the fully qualified name of the cluster class

             clusterName = a descriptive name for your cluster, can be anything

             mcastAddr = the multicast address, has to be the same for all the nodes

             mcastPort = the multicast port, has to be the same for all the nodes
             
             mcastBindAddress = bind the multicast socket to a specific address
             
             mcastTTL = the multicast TTL if you want to limit your broadcast
             
             mcastSoTimeout = the multicast readtimeout

             mcastFrequency = the number of milliseconds in between sending a "I'm alive" heartbeat

             mcastDropTime = the number a milliseconds before a node is considered "dead" if no heartbeat is received

             tcpThreadCount = the number of threads to handle incoming replication requests, optimal would be the same amount of threads as nodes

             tcpListenAddress = the listen address (bind address) for TCP cluster request on this host, 
                                in case of multiple ethernet cards.
                                auto means that address becomes
                                InetAddress.getLocalHost().getHostAddress()

             tcpListenPort = the tcp listen port

             tcpSelectorTimeout = the timeout (ms) for the Selector.select() method in case the OS
                                  has a wakup bug in java.nio. Set to 0 for no timeout

             printToScreen = true means that managers will also print to std.out

             expireSessionsOnShutdown = true means that

             useDirtyFlag = true means that we only replicate a session after setAttribute,removeAttribute has been called.
                            false means to replicate the session after each request.
                            false means that replication would work for the following piece of code: (only for SimpleTcpReplicationManager)
                            <%
                            HashMap map = (HashMap)session.getAttribute("map");
                            map.put("key","value");
                            %>
             replicationMode = can be either 'pooled', 'synchronous' or 'asynchronous'.
                               * Pooled means that the replication happens using several sockets in a synchronous way. Ie, the data gets replicated, then the request return. This is the same as the 'synchronous' setting except it uses a pool of sockets, hence it is multithreaded. This is the fastest and safest configuration. To use this, also increase the nr of tcp threads that you have dealing with replication.
                               * Synchronous means that the thread that executes the request, is also the
                               thread the replicates the data to the other nodes, and will not return until all
                               nodes have received the information.
                               * Asynchronous means that there is a specific 'sender' thread for each cluster node,
                               so the request thread will queue the replication request into a "smart" queue,
                               and then return to the client.
                               The "smart" queue is a queue where when a session is added to the queue, and the same session
                               already exists in the queue from a previous request, that session will be replaced
                               in the queue instead of replicating two requests. This almost never happens, unless there is a 
                               large network delay.
        -->             
        <!--
            When configuring for clustering, you also add in a valve to catch all the requests
            coming in, at the end of the request, the session may or may not be replicated.
            A session is replicated if and only if all the conditions are met:
            1. useDirtyFlag is true or setAttribute or removeAttribute has been called AND
            2. a session exists (has been created)
            3. the request is not trapped by the "filter" attribute

            The filter attribute is to filter out requests that could not modify the session,
            hence we don't replicate the session after the end of this request.
            The filter is negative, ie, anything you put in the filter, you mean to filter out,
            ie, no replication will be done on requests that match one of the filters.
            The filter attribute is delimited by ;, so you can't escape out ; even if you wanted to.

            filter=".*\.gif;.*\.js;" means that we will not replicate the session after requests with the URI
            ending with .gif and .js are intercepted.
            
            The deployer element can be used to deploy apps cluster wide.
            Currently the deployment only deploys/undeploys to working members in the cluster
            so no WARs are copied upons startup of a broken node.
            The deployer watches a directory (watchDir) for WAR files when watchEnabled="true"
            When a new war file is added the war gets deployed to the local instance,
            and then deployed to the other instances in the cluster.
            When a war file is deleted from the watchDir the war is undeployed locally 
            and cluster wide
        -->
        
        <!--
        <Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
                 managerClassName="org.apache.catalina.cluster.session.DeltaManager"
                 expireSessionsOnShutdown="false"
                 useDirtyFlag="true"
                 notifyListenersOnReplication="true">

            <Membership 
                className="org.apache.catalina.cluster.mcast.McastService"
                mcastAddr="228.0.0.4"
                mcastPort="45564"
                mcastFrequency="500"
                mcastDropTime="3000"/>

            <Receiver 
                className="org.apache.catalina.cluster.tcp.ReplicationListener"
                tcpListenAddress="auto"
                tcpListenPort="4001"
                tcpSelectorTimeout="100"
                tcpThreadCount="6"/>

            <Sender
                className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
                replicationMode="pooled"
                ackTimeout="15000"
                waitForAck="true"/>

            <Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
                   filter=".*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;"/>
                   
            <Deployer className="org.apache.catalina.cluster.deploy.FarmWarDeployer"
                      tempDir="/tmp/war-temp/"
                      deployDir="/tmp/war-deploy/"
                      watchDir="/tmp/war-listen/"
                      watchEnabled="false"/>
                      
            <ClusterListener className="org.apache.catalina.cluster.session.ClusterSessionListener"/>
        </Cluster>
        -->       

        <!-- Normally, users must authenticate themselves to each web app
             individually.  Uncomment the following entry if you would like
             a user to be authenticated the first time they encounter a
             resource protected by a security constraint, and then have that
             user identity maintained across *all* web applications contained
             in this virtual host. -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
        -->

        <!-- Access log processes all requests for this virtual host.  By
             default, log files are created in the "logs" directory relative to
             $CATALINA_HOME.  If you wish, you can specify a different
             directory with the "directory" attribute.  Specify either a relative
             (to $CATALINA_HOME) or absolute path to the desired directory.
        -->
        <!--
        <Valve className="org.apache.catalina.valves.AccessLogValve"
                 directory="logs"  prefix="localhost_access_log." suffix=".txt"
                 pattern="common" resolveHosts="false"/>
        -->

        <!-- Access log processes all requests for this virtual host.  By
             default, log files are created in the "logs" directory relative to
             $CATALINA_HOME.  If you wish, you can specify a different
             directory with the "directory" attribute.  Specify either a relative
             (to $CATALINA_HOME) or absolute path to the desired directory.
             This access log implementation is optimized for maximum performance,
             but is hardcoded to support only the "common" and "combined" patterns.
        -->
        <!--
        <Valve className="org.apache.catalina.valves.FastCommonAccessLogValve"
                 directory="logs"  prefix="localhost_access_log." suffix=".txt"
                 pattern="common" resolveHosts="false"/>
        -->

      </Host>

    </Engine>

  </Service>

</Server>

C:\workspace 작업할 워크스페이스를 생성한다.

Window->Preferences 에서

Server에서 톰켓을 선택한다.

Server 뷰에서  New -> Server로 톰켓 서버를 추가한다.

다음과 같이 서버가 추가된 것을 볼 수 있다.

이클립스에서 자바 프로젝트를 생성한다.

 Next -> 버튼을 눌러서 Add Libray  톰켓 5.5 를 추가 한다.

추가로 임시로 필요 한 웹프로젝트를 만든다.

여기서 WebContent 밑으로 나머지 부분이 필요해서 만드는 것이므로 만든후에 삭제한다.

WebProject를 선택하고 WebContent 아래로 index.jsp 파일을 생성한다.

Server 뷰에서 톰켓서버를 더블클릭하면 톰켓설정화면이 나타난다.

Server Locations 정보는  Use Tomcat Installiation 으로 선택하고

Deploy Path는 webapps로 변경한다. 근데 이건 default설정인 wtpwebapps로  변경해도 상관없는듯 하다.

PORT번호 같은경우 충돌이 날경우 대비해서 알아서 바꿔주는게 좋겠다.

톰켓의 베이스 폴더에서 다음 폴더로 가서 ROOT.xml파일을 생성한다.

ROOT.xml파일을 열고

다음 내용을 추가한다.

설정을 저장하고 톰켓을 재기동한다.