http://www.ajaxfaces.com/

Oracle의 숫자형 필드의 도메인은 Number로 잡는다.

그런데 java에서는 Integer와 Double로 명시적으로 사용하고 싶었다.

그리고, DATE 형은 oracle-jdbc에서 java.sql.TimeStamp 형으로 넘어와서

Bean에 자동으로 set이 안된다.

그래서 BasicRowProcess.java를 조금 바꿔서 OracleRowProcess.java로 하고

사용하고 있다.

사용방법은 Handler생성 할때 아래와 같이 하면된다.

h = new BeanListHandler( dto.getClass(), OracleRowProcess.instance() );

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

OracleRowProcess.java

=============================

 
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.RowProcessor;
import org.apache.log4j.Logger;
/**
 * @author 박종복 (asdkf_2000@yahoo.co.kr)
 * @version 1.0,  2005. 4. 14
 *
 */
public class OracleRowProcess implements RowProcessor {

    /**
     * Set a bean's primitive properties to these defaults when SQL NULL
     * is returned.  These are the same as the defaults that ResultSet get*
     * methods return in the event of a NULL column.
     */
    private static final Map primitiveDefaults = new HashMap();

    static {
        primitiveDefaults.put(Integer.TYPE, new Integer(0));
        primitiveDefaults.put(Short.TYPE, new Short((short) 0));
        primitiveDefaults.put(Byte.TYPE, new Byte((byte) 0));
        primitiveDefaults.put(Float.TYPE, new Float(0));
        primitiveDefaults.put(Double.TYPE, new Double(0));
        primitiveDefaults.put(Long.TYPE, new Long(0));
        primitiveDefaults.put(Boolean.TYPE, Boolean.FALSE);
        primitiveDefaults.put(Character.TYPE, new Character('\u0000'));
    }

    /**
     * Special array index that indicates there is no bean property that
     * matches a column from a ResultSet.
     */
    private static final int PROPERTY_NOT_FOUND = -1;

    /**
     * The Singleton instance of this class.
     */
    private static final OracleRowProcess instance = new OracleRowProcess();

    /**
     * Returns the Singleton instance of this class.
     *
     * @return The single instance of this class.
     */
    public static OracleRowProcess instance() {
        return instance;
    }

    /**
     * Protected constructor for BasicRowProcessor subclasses only.
     */
    protected OracleRowProcess() {
        super();
    }

    /**
     * Convert a <code>ResultSet</code> row into an <code>Object[]</code>.
     * This implementation copies column values into the array in the same
     * order they're returned from the <code>ResultSet</code>.  Array elements
     * will be set to <code>null</code> if the column was SQL NULL.
     *
     * @see org.apache.commons.dbutils.RowProcessor#toArray(java.sql.ResultSet)
     */
    public Object[] toArray(ResultSet rs) throws SQLException {
        ResultSetMetaData meta = rs.getMetaData();
        int cols = meta.getColumnCount();
        Object[] result = new Object[cols];

        for (int i = 0; i < cols; i++) {
            result[i] = rs.getObject(i + 1);
        }

        return result;
    }

    /**
     * Convert a <code>ResultSet</code> row into a JavaBean.  This
     * implementation uses reflection and <code>BeanInfo</code> classes to
     * match column names to bean property names.  Properties are matched to
     * columns based on several factors:
     * <br/>
     * <ol>
     *     <li>
     *     The class has a writable property with the same name as a column.
     *     The name comparison is case insensitive.
     *     </li>
     *
     *     <li>
     *     The property's set method parameter type matches the column
     *     type. If the data types do not match, the setter will not be called.
     *     </li>
     * </ol>
     *
     * <p>
     * Primitive bean properties are set to their defaults when SQL NULL is
     * returned from the <code>ResultSet</code>.  Numeric fields are set to 0
     * and booleans are set to false.  Object bean properties are set to
     * <code>null</code> when SQL NULL is returned.  This is the same behavior
     * as the <code>ResultSet</code> get* methods.
     * </p>
     *
     * @see org.apache.commons.dbutils.RowProcessor#toBean(java.sql.ResultSet, java.lang.Class)
     */
    public Object toBean(ResultSet rs, Class type) throws SQLException {

        PropertyDescriptor[] props = this.propertyDescriptors(type);

        ResultSetMetaData rsmd = rs.getMetaData();

        int[] columnToProperty = this.mapColumnsToProperties(rsmd, props);

        int cols = rsmd.getColumnCount();

        return this.createBean(rs, type, props, columnToProperty, cols);
    }

    /**
     * Convert a <code>ResultSet</code> into a <code>List</code> of JavaBeans. 
     * This implementation uses reflection and <code>BeanInfo</code> classes to
     * match column names to bean property names. Properties are matched to
     * columns based on several factors:
     * <br/>
     * <ol>
     *     <li>
     *     The class has a writable property with the same name as a column.
     *     The name comparison is case insensitive.
     *     </li>
     *
     *     <li>
     *     The property's set method parameter type matches the column
     *     type. If the data types do not match, the setter will not be called.
     *     </li>
     * </ol>
     *
     * <p>
     * Primitive bean properties are set to their defaults when SQL NULL is
     * returned from the <code>ResultSet</code>.  Numeric fields are set to 0
     * and booleans are set to false.  Object bean properties are set to
     * <code>null</code> when SQL NULL is returned.  This is the same behavior
     * as the <code>ResultSet</code> get* methods.
     * </p>
     *
     * @see org.apache.commons.dbutils.RowProcessor#toBeanList(java.sql.ResultSet, java.lang.Class)
     */
    public List toBeanList(ResultSet rs, Class type) throws SQLException {
        List results = new ArrayList();

        if (!rs.next()) {
            return results;
        }

        PropertyDescriptor[] props = this.propertyDescriptors(type);
        ResultSetMetaData rsmd = rs.getMetaData();
        int[] columnToProperty = this.mapColumnsToProperties(rsmd, props);
        int cols = rsmd.getColumnCount();

        do {
            results.add(this.createBean(rs, type, props, columnToProperty, cols));

        } while (rs.next());

        return results;
    }

    /**
     * Creates a new object and initializes its fields from the ResultSet.
     *
     * @param rs The result set
     * @param type The bean type (the return type of the object)
     * @param props The property descriptors
     * @param columnToProperty The column indices in the result set
     * @param cols The number of columns
     * @return An initialized object.
     * @throws SQLException If a database error occurs
     */
    private Object createBean(
        ResultSet rs,
        Class type,
        PropertyDescriptor[] props,
        int[] columnToProperty,
        int cols)
        throws SQLException {

        Object bean = this.newInstance(type);

        for (int i = 1; i <= cols; i++) {

            if (columnToProperty[i] == PROPERTY_NOT_FOUND) {
                continue;
            }
           
            Object value = rs.getObject(i);

            PropertyDescriptor prop = props[columnToProperty[i]];
            Class propType = prop.getPropertyType();

            if (propType != null && value == null && propType.isPrimitive()) {
                value = primitiveDefaults.get(propType);
            }
           
            this.callSetter(bean, prop, value);
        }

        return bean;
    }

    /**
     * The positions in the returned array represent column numbers.  The values
     * stored at each position represent the index in the PropertyDescriptor[]
     * for the bean property that matches the column name.  If no bean property
     * was found for a column, the position is set to PROPERTY_NOT_FOUND.
     *
     * @param rsmd The result set meta data containing column information
     * @param props The bean property descriptors
     * @return An int[] with column index to property index mappings.  The 0th
     * element is meaningless as column indexing starts at 1.
     *
     * @throws SQLException If a database error occurs
     */
    private int[] mapColumnsToProperties(
        ResultSetMetaData rsmd,
        PropertyDescriptor[] props)
        throws SQLException {

        int cols = rsmd.getColumnCount();
        int columnToProperty[] = new int[cols + 1];
       
        for (int col = 1; col <= cols; col++) {
            String columnName = rsmd.getColumnName(col);
            for (int i = 0; i < props.length; i++) {

                if (columnName.equalsIgnoreCase(props[i].getName())) {
                    columnToProperty[col] = i;
                    break;

                } else {
                    columnToProperty[col] = PROPERTY_NOT_FOUND;
                }
            }
        }

        return columnToProperty;
    }

    /**
     * Convert a <code>ResultSet</code> row into a <code>Map</code>.  This
     * implementation returns a <code>Map</code> with case insensitive column
     * names as keys.  Calls to <code>map.get("COL")</code> and
     * <code>map.get("col")</code> return the same value.
     * @see org.apache.commons.dbutils.RowProcessor#toMap(java.sql.ResultSet)
     */
    public Map toMap(ResultSet rs) throws SQLException {
        Map result = new CaseInsensitiveHashMap();
        ResultSetMetaData rsmd = rs.getMetaData();
        int cols = rsmd.getColumnCount();

        for (int i = 1; i <= cols; i++) {
            result.put(rsmd.getColumnName(i), rs.getObject(i));
        }

        return result;
    }

    /**
     * Calls the setter method on the target object for the given property.
     * If no setter method exists for the property, this method does nothing.
     * @param target The object to set the property on.
     * @param prop The property to set.
     * @param value The value to pass into the setter.
     * @throws SQLException if an error occurs setting the property.
     */
    private void callSetter(
        Object target,
        PropertyDescriptor prop,
        Object value)
        throws SQLException {

        Method setter = prop.getWriteMethod();

        if (setter == null) {
            return;
        }

        Class[] params = setter.getParameterTypes();
        try {

            // Don't call setter if the value object isn't the right type
            if( params[0].equals( Date.class) && value instanceof Timestamp ){
                setter.invoke(target, new Object[] { (java.util.Date)value } );
            }else if (this.isCompatibleType(value, params[0])) {
                    setter.invoke(target, new Object[] { value });
            }else if( params[0].equals( Integer.class) && value instanceof Number ){
                setter.invoke(target, new Object[] { new Integer(value.toString()) } );
            }else if( params[0].equals( Double.class ) && value instanceof Number ){
                setter.invoke(target, new Object[] { new Double(value.toString()) } );
            }

        } catch (IllegalArgumentException e) {
            throw new SQLException(
                "Cannot set " + prop.getName() + ": " + e.getMessage());

        } catch (IllegalAccessException e) {
            throw new SQLException(
                "Cannot set " + prop.getName() + ": " + e.getMessage());

        } catch (InvocationTargetException e) {
            throw new SQLException(
                "Cannot set " + prop.getName() + ": " + e.getMessage());
        }
    }

    /**
     * ResultSet.getObject() returns an Integer object for an INT column.  The
     * setter method for the property might take an Integer or a primitive int.
     * This method returns true if the value can be successfully passed into
     * the setter method.  Remember, Method.invoke() handles the unwrapping
     * of Integer into an int.
     *
     * @param value The value to be passed into the setter method.
     * @param type The setter's parameter type.
     * @return boolean True if the value is compatible.
     */
    private boolean isCompatibleType(Object value, Class type) {
        // Do object check first, then primitives
        if (value == null || type.isInstance(value)) {
            return true;

        } else if (type.equals(Long.TYPE) && Long.class.isInstance(value)) {
            return true;

        } else if (type.equals(Float.TYPE) && Float.class.isInstance(value)) {
            return true;

        } else if (type.equals(Short.TYPE) && Short.class.isInstance(value)) {
            return true;

        } else if (type.equals(Byte.TYPE) && Byte.class.isInstance(value)) {
            return true;

        } else if (
            type.equals(Character.TYPE) && Character.class.isInstance(value)) {
            return true;

        } else if (
            type.equals(Boolean.TYPE) && Boolean.class.isInstance(value)) {
            return true;

        } else {
            return false;
        }

    }

    /**
     * Returns a new instance of the given Class.
     *
     * @param c The Class to create an object from.
     * @return A newly created object of the Class.
     * @throws SQLException if creation failed.
     */
    private Object newInstance(Class c) throws SQLException {
        try {
            return c.newInstance();

        } catch (InstantiationException e) {
            throw new SQLException(
                "Cannot create " + c.getName() + ": " + e.getMessage());

        } catch (IllegalAccessException e) {
            throw new SQLException(
                "Cannot create " + c.getName() + ": " + e.getMessage());
        }
    }

    /**
     * Returns a PropertyDescriptor[] for the given Class.
     *
     * @param c The Class to retrieve PropertyDescriptors for.
     * @return A PropertyDescriptor[] describing the Class.
     * @throws SQLException if introspection failed.
     */
    private PropertyDescriptor[] propertyDescriptors(Class c)
        throws SQLException {
        // Introspector caches BeanInfo classes for better performance
        BeanInfo beanInfo = null;
        try {
            beanInfo = Introspector.getBeanInfo(c);

        } catch (IntrospectionException e) {
            throw new SQLException(
                "Bean introspection failed: " + e.getMessage());
        }

        return beanInfo.getPropertyDescriptors();
    }

    /**
     * A Map that converts all keys to lowercase Strings for case insensitive
     * lookups.  This is needed for the toMap() implementation because
     * databases don't consistenly handle the casing of column names.
     */
    private static class CaseInsensitiveHashMap extends HashMap {
        /**
         * Logger for this class
         */
        private static final Logger logger = Logger
                .getLogger(CaseInsensitiveHashMap.class);

        /**
         * @see java.util.Map#containsKey(java.lang.Object)
         */
        public boolean containsKey(Object key) {
            return super.containsKey(key.toString().toLowerCase());
        }

        /**
         * @see java.util.Map#get(java.lang.Object)
         */
        public Object get(Object key) {
            return super.get(key.toString().toLowerCase());
        }

        /**
         * @see java.util.Map#put(java.lang.Object, java.lang.Object)
         */
        public Object put(Object key, Object value) {
            return super.put(key.toString().toLowerCase(), value);
        }

        /**
         * @see java.util.Map#putAll(java.util.Map)
         */
        public void putAll(Map m) {
            Iterator iter = m.keySet().iterator();
            while (iter.hasNext()) {
                Object key = iter.next();
                Object value = m.get(key);
                this.put(key, value);
            }
        }

        /**
         * @see java.util.Map#remove(java.lang.ObjecT)
         */
        public Object remove(Object key) {
            return super.remove(key.toString().toLowerCase());
        }
    }

}

http://jetty.mortbay.com/jetty/index.html

출처 : http://www.ihelpers.co.kr/webdevdoc/index.php

요청 쿼리에 ?lzt=html 를 붙이니까 없어짐..

http://192.168.1.53:8080/lps-3.0/my-apps/hello1.lzx?lzt=html

http://192.168.1.53:8080/lps-3.0/my-apps/hello1.lzx?lzt=html-object

이런식으로 호출함..

라즐로 이용해서 포토 게시판 만들면 끝장이겠는걸~

http://jwebunit.sourceforge.net/

http://www.opensymphony.com/

볼꺼는 많고... 음주가무는 끊이지 않고... 고민...

출처 : LoveLazur

Opensource Web Grid

1) 대략 javascript아니면 DHTML [javascript라면 이것도 OK]
http://www.activewidgets.com/documentation/tutorial/grid/data-jsarray.htm

하지만 이렇게 작성도 가능함 [tag lib version]
http://www.activewidgets.com/messages/1694-8.htm



2) http://www.codeproject.com/useritems/DBGrid.asp
순수 jsp타입에서 접근하기엔 이게 좋아보인다.

2-2) sand box에서는 이런식으로 component화 되어있음 tablib임.
http://jakarta.apache.org/taglibs/sandbox/doc/datagrid-doc/index.html


2-3) 개인적으로 이게 좋은데... 단점이 없지 않음
http://displaytag.sourceforge.net/

------ 좋다 ... 이중에 맨 마지막거. -----

http://www.servletsuite.com/tips/cells.htm

헐.. TD 를 에디트 하다뉘.. 머리 조타...

proxool  커넥션 풀 소스를 보다가... jndi 를 이용하는 다른 방법이 보이길래 끄적여 봄...

http://tyrex.sourceforge.net/  <-- 요기에 보면 여러가지 프로젝들이 보인다..

그중... 설명은 안나온것 같은데.. 톰캣 처럼.. jndi 를 불편하게 사용해야 할 경우(반드시 server.xml 에 적어줘야 하며, 서버 재시작 필요함..  readonly 환경이라 그렇다고 하넹..)

tyrex-naming 을 이용하면 된다....

현재 버젼은 1.0.2 인가 그렇고..

테스트 한 패키지는 1.0.1 이며 naming 관련 부분만 이용했다.

먼저.. 간단한 자바 빈 클래스.. 이 녀석을 jndi 에 등록할것임..

package com.javarush.test;

public class TestBean {
   
    private String print;
   
    public TestBean(){ }

    public String getPrint() {
        return print;
    }

    public void setPrint(String print) {
        this.print = print;
    }   
}

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

초기화 시켜줄 서블릿...

web.xml 에 당근 등록해야 하고... <load-on-startup>3<load-on-startup>  으로 지정했다.

import java.io.IOException;
import java.util.Hashtable;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.spi.NamingManager;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import tyrex.naming.MemoryContextFactory;
import com.javarush.test.TestBean;

public class InittServlet extends HttpServlet {

    public void destroy() {
        super.destroy();
    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

    }

    public void init() throws ServletException {
        String alias = "myAliasName";
        String jndiName = "my/testbean";
       
        try{
           
            TestBean bean = new TestBean();
            bean.setPrint("HIHI");
       
         Hashtable env = new Hashtable();
         env.put(Context.INITIAL_CONTEXT_FACTORY, MemoryContextFactory.class.getName());
         env.put(Context.URL_PKG_PREFIXES, "tyrex.naming");
         env.put(Context.PROVIDER_URL, alias);
         Context context = new InitialContext(env);
         context.createSubcontext("my");
         context.bind(jndiName, NamingManager.getObjectInstance(bean, null, null, null));
         context.close();
       
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

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

Test 용 JSP

<%@ page contentType="text/html; charset=euc-kr"
 import = "javax.naming.*, java.util.*, com.javarush.test.*, tyrex.naming.*"

%><%

        String alias = "myAliasName";
        String jndiName = "my/testbean";
        Hashtable env = new Hashtable();
        env.put(Context.INITIAL_CONTEXT_FACTORY, MemoryContextFactory.class.getName());
        env.put(Context.URL_PKG_PREFIXES, "tyrex.naming");
        env.put(Context.PROVIDER_URL, alias);

        Context context = new InitialContext(env);
        TestBean bean = (TestBean) context.lookup(jndiName);
        context.close();
       
        out.print(bean.getPrint());

%>

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

첨부된 tyrex-1.0.1_naming.jar 파일은 WEB-INF/lib 에 두고..

실행해 보면

브라우저에 HIHI 가 출력될 것임....

	<Host name="www.mycompany.com" ...> ... <Alias>mycompany.com</Alias> ...</Host>

톰캣 설정 중에 Host name Alias 땜쉬.. 잠깐 헤맸네 ㅎㅎ

http://www.junginger.biz/eclipse/index.html

메모리 보는것과 RSS 뷰~ 

http://www.josso.org/

http://proxool.sourceforge.net/index.html

설정 엄청 편리... 관리 서블릿 제공 ... 무지 단순 -_-;

http://wiki.blojsom.com/wiki/display/blojsom

오... 벨로시티로 스킨을 .....

http://b2evolution.net/  <--- PHP 로 만든 블로그...

asp 로 만든건 없나??

심심해서(?) 잠깐 만들어봄 ㅡㅡ

PHP 는 금새 했는데 JSP 는 HttpURLConnection 에서 잠깐 헤맴 ㅜㅜ

<%@ page contentType="text/xml; charset=euc-kr" %>
<%@ page import="java.util.*, java.net.*, java.io.*, org.jdom.*, org.jdom.input.*" %>
<%

 String receipt = "http://blog.empas.com/yheesung/tb/6327649";

 String url = "http://yheesung.egloos.com/";

 String title = URLEncoder.encode("트랙백연습", "euc-kr");

 String blog_name = URLEncoder.encode("tornado Blog", "euc-kr");

 String excerpt = URLEncoder.encode("이 글의 내용은 어짜구.. 저짜구......", "euc-kr");

 URL receiptURL = new URL(receipt);

 HttpURLConnection conn = (HttpURLConnection)receiptURL.openConnection();

 conn.setDoOutput(true);

 //==================================================================
 // 특별히 Header 정보를 셋팅할 필요는 없다.
 // 보내는 부분에서는 아무 문제가 없었다.
 // Test : 이글루, 네이버, 엠파스
 //==================================================================

 conn.setRequestMethod("GET");
 
 //conn.setRequestMethod("POST");

 PrintWriter pw = new PrintWriter(conn.getOutputStream());

 pw.write("url="+url);

 pw.write("&title=" + title);

 pw.write("&blog_name=" + blog_name);

 pw.write("&excerpt=" + excerpt);

 pw.flush();

 pw.close();

 BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));

 //==================================================================
 //
 // 헐... 왜 xml문서 앞에 공백을 넣어서리..... ㅡㅡ;;
 //
 //================================================================== 
 
 String txt = "";

 while( (txt = reader.readLine()) != null){

  if(txt.indexOf("<?xml") > -1){

   break;

  }

 }

 String message = null;

 String status = null;

 boolean errorFlag = true;

 SAXBuilder builder = new SAXBuilder();

 builder.setValidation(false);

 builder.setIgnoringElementContentWhitespace(true);
  
 Document document = builder.build(reader);

 Element rootElement = document.getRootElement();

 List list = rootElement.getChildren();

 for(int i = 0; i < list.size(); i++){

  Element _el = (Element)list.get(i);

  if("error".equalsIgnoreCase(_el.getName())){

   status = _el.getValue();

  }

  if("message".equalsIgnoreCase(_el.getName())){

   message = _el.getValue();

  }

 }

 
 if("1".equals(status)){

  out.println("트랙백 핑을 보내는 중 에러가 발생하였습니다!!");

  out.print("<BR>Error code : " + status);

  out.print("<BR>Error message : " + message);

 }else{

  out.println("트랙백 핑이 에러가 없이 전송되었습니다");

 }

 reader.close();

 conn.disconnect();

%>

이 문서는 Trackback CGI를 제작하기 원하는 이들을 위해 제공하는 도움서일 뿐입니다.
제로보드용 블로그 스킨 Paz에 트랙백 기능을 추가해달라는 요구들이 많더군요. 제가 직접 할까하고 손 댔다가, 역시 코딩은 만만치 않군요. ^^; 저보다 더 잘 코딩해주실 분들이 많이 계시고, 또 현재 준비중이신 것 같아서 제가 직접 하는 것보다는 그분들을 위한 CGI설계에 도움되는 쪽이 나을 것 같아 이 문서를 작성합니다.

트랙백의 flow
트랙백은 간단한 HTTP + XML의 형태로 구현가능합니다.
편의상 트랙백을 보내는 쪽을 sender, 받는 쪽을 receiver라고 칭하겠습니다.

sender.cgi에서 receiver.cgi로 HTTP를 통해 보내는 정보는 다음과 같습니다.

POST Method

title : 해당 엔트리의 타이틀
url : 해당 엔트리의 고유주소
excerpt : 해당 엔트리의 내용 요약(혹은 설명)
blog_name : 블로그의 이름

그렇다면 receiver는 POST로 넘어온 이 값을 DB나 TXT등으로 저장 후, 잘 받았다는 값을 sender쪽에 회신해주면 됩니다.

이상이 트랙백의 전부입니다. 너무 간단하다구요? ^^; 맞습니다.

조금 더 상세히 살펴보도록 하지요.

사용자가 트랙백을 보내고자 할 때 sender와 receiver가 해야할 일은 다음과 같습니다.

1)트랙백 메시지 준비하기.
receiver쪽에 전달할 트랙백 메시지를 준비합니다. 필요한 어트리뷰트는,
*title:현재 문서의 제목
*url:현재 문서의 고유주소
*excerpt:현재 문서 내용의 요약 혹은 설명 (255자 이하로 축약하는 것이 좋음. 본문 내용에서 적당히 끊으면 되겠죠?)
*receipt:받는 쪽의 트랙백수신 CGI 주소 (사용자가 텍스트 박스등에 입력하도록 해야겠지요?)

2)트랙백 전달
receipt로 title, url, excerpt의 값을 POST 메쏘드를 이용해 전달합니다. 그리고 회신이 돌아올 때까지 기다립니다.

3)트랙백 수신
receiver쪽에서는 receipt로 넘어온 값을 확인한 후, sender에게 회신을 보내줍니다.
다음은 php로 작성한 간단한 receiver.php입니다.

<?
$fh = fopen("./tb.log", 'w');
$results = print_r($_POST, true);
$id = $_GET['id'];
fwrite($fh, $id);
fwrite($fh, $results);
fclose($fh);
header("Content-Type: text/xml");
print "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n";
print "<response>\n";
print "<error>0</error>\n";
print "</response>\n";
?>

이것만으로도 충분히 트랙백을 수신할 수 있습니다. 물론 실제로 활용하기 위해서는 받은 트랙백값을 DB에 저장해야겠지요. 위의 코드에서 id는 수신하는쪽의 문서의 id를 말합니다. 각 개별문서마다 일일이 트랙백 수신 CGI를 만들어 줄 수 없기 때문에 공용 수신 CGI를 이용해야 할테고, 그러자면 송신측에서는 자기가 어느 문서를 향해 보내는지 알리기 위한 id가 필요하겠죠. 이 id는 트랙백 규격에는 포함되지 않으므로 GET method로 그냥 보내면 됩니다. receiver.php?id=123 이런 식으로 말이죠.

header()이하 부분은 정상적인 트랙백 메시지일 경우 잘받았다는 회신으로 Sender쪽에 Response해줍니다. php에서는 그냥 print로 출력해버리면 되지요. ^^; 만약 정상적인 트랙백 메시지가 아니라서 수신을 거부할 경우 error 항목을 0대신 1로 바꿔주면 됩니다.

4)트랙백 회신 확인
이번엔 sender쪽에서 Response 받은 문자열을 분석해서 error가 0인지, 1인지 확인하면 되겠죠. 그에 따라 적당한 메시지를 출력해주면 끝.

5)문서 출력시
일단 DB를 뒤져서 이 문서로 들어온 트랙백 데이터가 있는지 확인합니다. 데이터가 있으면 문서 중에 적당한 자리에 그 정보를 붙여 넣으면 됩니다.


6)트랙백 자동발견용 RDF 아이템 문서내 삽입.
트랙백을 걸 수 있게 준비가 되면, 트랙백을 걸어도 좋다는 메시지를 문서속에 삽입해야합니다.

<!--
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/">

<rdf:Description
rdf:about="[Entry Permalink]"
dc:title="[Entry Title]"
dc:identifier="[Entry Permalink]" />
trackback:ping="[http://yourserver.com/cgi-bin/receiver.cgi/][TrackBack ID]"
</rdf:RDF>
-->

위의 코드를 각 문서내에 적절히 삽입하시면 됩니다. []안의 내용은 삽입되는 문서에 맞게 수정되어야겠지요?
만약 트랙백을 보내기 전에 먼저 해당 문서를 읽어들여, 저 코드를 발견한다면 사용자가 receiver.cgi?id=xxx식으로 일일이 적어줄 필요가 없겠죠? MT등에서는 실제로, 엔트리 작성시 본문에서 언급된 모든 링크를 찾아 다니면서 저 아이템이 있으면 자동으로 트랙백을 걸어줍니다. 사용자가 트랙백할 주소를 일일이 지정하지 않아도 되니 편리하겠지요. 요런 기능도 여유가 되시면 구현하면 좋겠죠.

그외의 트랙백 관련 확장으로는, 카테고리 별 자동 트랙백(특정 카테고리로 입력되는 엔트리는 무조건 특정 주소로 자동으로 트랙백 보내기)과, 한번에 복수개의 트랙백 보내기등이 구현되면 될 것 같네요.

혹시 개발시에 문제가 되거나 궁금하신 점이 있으면 말씀하세요.

<출처 : http://eouia.net >