낮의 빛으로

Things you can do with RDF which you can't do with XML include

• You can parse the semantic tree, which end up giving you a set of (possibly mutually referential) triples and then you can use the ones you want ignoring the ones you don't understand.

Problems with basing you understanding on the structure include

• Without having gone to the trouble of getting the schema, or having an application hand-programmed to recognise a particular document type, you can't pick up any semantic information from a document;
• When an XML schema changes, it could typically introduce new intermediate elements (like "details" in the tree above or "div" is HTML). These may or may or may not invalidate any query which has been based on the structure of the document.
• If you haven't gone to the trouble of making a semantic model, then you may not have a well defined one. ( Look at a label on the jam jar which says: "Expires 1999". What expires: the label, or the jam? Here the ambiguity is between a statement about a statement about a document, and a statement about a document. )

소개

누구나 검색이 필요하다. 그것이 열쇠든, 휴대전화든, 지갑이든, 마음이든 간에 말이다. 매장 데이터베이스의 모든 제품을 검색할 수 있다면 어떨까? 혹은 인트라넷과 관련된 파일들은 어떤가? 이것이 본 튜토리얼에서 다룰 내용이다.

아파치 루씬

루씬 자바는 주요 아파치 루씬 프로젝트이며 다른 프로젝트도 여기서 비롯됐다. 이는 자바로 작성된 최고의 고성능 검색 엔진 라이브러리를 목표로 만들어졌고, 그래서 여기엔 서브프로젝트가 그리 많지 않다.

아파치 루씬은 오픈 소스이기 때문에 개발자들이 사용하기에 더 알맞다. 루씬으로 맞춤 애플리케이션에 견고한 검색 엔진을 만들 수 있고, 이것이 솔라나 넛치(Nutch) 같은 다른 서브프로젝트가 등장하는 방법이기도 하다.

웹 크롤러가 필요하다면 직접 만들어야 한다. 그리고 나서 크롤러를 사용해 웹 크롤러가 웹을 기어다니면서 웹에서 꺼낸 파일을 목록에 넣어야 한다. 하지만 이미 작성된 것이 있다면 왜 굳이 직접 만들어야 할까? 그래서 아파치 넛치와 하둡(Hadoop)이 등장했다.

넛치와 하둡, 아피치 루씬 서브프로젝트

넛 치는 루씬에 웹 페이지를 검색하고 다른 문서 포맷에서 HTML을 파스하는 방법이 필요하다는 명백한 이유로 만들어졌다. 넛치는 모든 웹 크롤링, 인트라넷에서 로컬 파일 크롤링, 모든 인덱싱을 포함하는 수많은 멋진 특징들을 가지고 있다.

하 둡은 넛치가 잠재적으로 저장, 처리할 수 있는 페타바이트의 데이터를 처리할 수 있도록 고안됐다. 사실 하둡은 자체 파일 시스템인 HDFS(Hadoop Distributed File System)를 갖고 있다. 이는 어떠한 평범한 저가 하드웨어에서도 작동할 수 있다. 하둡은 클러스터의 모든 서버에 걸쳐 파일 시스템 데이터 중 일부분을 저장한다. 새 질의가 들어오면 HDFS는 "움직이는 계산은 움직이는 데이터보다 저렴하다"라는 규칙(즉 질의 처리를 움직여 데이터에 가장 가깝게 하는 것은 클러스터 내에 마구잡이로 질의를 놓고 데이터를 네트워크 전반에 먼 거리로 이동시키는 것보다 빠르다는 뜻이다)을 따른다.

오픈 소스 검색 서버 아파치 솔라

그 렇다면 왜 솔라가 필요한 것일까? 솔라는 파일을 인덱스하는 검색 엔진 이상이기 때문이다. 이는 XML 요청을 HTTP를 통해 보내는 웹 서비스 API가 있는 검색 서버다. 그러므로 솔라 검색 서버 URL을 사용하여 인터넷을 통해(XML 요청을 HTTP를 통해 보냄으로써) 파일을 질의, 인덱스하는 어느 곳에서나 애플리케이션을 가질 수 있다. 또한 다른 솔라 검색 서버로 캐싱과 복사가 가능한 최적화된 검색 서버다.

/*
 *  PHEX - The pure-java Gnutella-servent.
 *  Copyright (C) 2001 - 2006 Phex Development Group
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 *  Created on 17.02.2005
 *  --- CVS Information ---
 *  $Id: DirectByteBufferProvider.java 3536 2006-08-05 22:16:44Z gregork $
 */
package phex.utils;

import java.nio.ByteBuffer;
import java.util.*;

import phex.common.Environment;

/**
 * TODO find out the usuall requested buffer sizes and provide storage slots for 
 * these sizes.
 */
public class DirectByteBufferProvider
{
    public static final int BUFFER_SIZE_64K = 64 * 1024;
    private static final DirectByteBufferProvider instance;

    private Map<Integer, Set<DirectByteBuffer>> sizeToBufferListMap;

    /**
     * Max use 10MB in buffer cache.
     */
    private static final long MAX_TOTAL_BUFFER_SIZE = 10 * 1024 * 1024;

    static
    {
        instance = new DirectByteBufferProvider();
    }

    private DirectByteBufferProvider()
    {
        sizeToBufferListMap = new LinkedHashMap<Integer, Set<DirectByteBuffer>>();
        
        Environment.getInstance().scheduleTimerTask(new CleanupCheckerTask(),
            CleanupCheckerTask.TIMER_PERIOD, CleanupCheckerTask.TIMER_PERIOD);
    }

    public static DirectByteBuffer requestBuffer(int sizeInBytes)
    {
        return instance.requestDirectByteBuffer(sizeInBytes);
    }

    protected synchronized void releaseDirectByteBuffer(
        DirectByteBuffer directByteBuffer)
    {
        //NLogger.debug( NLoggerNames.GLOBAL, "Releasing DirectByteBuffer:" + directByteBuffer );
        debugDump();
        ByteBuffer buffer = directByteBuffer.getInternalBuffer();
        int kb = (int) Math.ceil(buffer.capacity() / 1024.0);
        Integer key = new Integer(kb);
        Set<DirectByteBuffer> set = sizeToBufferListMap.get(key);
        if (set == null)
        {
            set = new HashSet<DirectByteBuffer>();
            sizeToBufferListMap.put(key, set);
        }
        set.add(directByteBuffer);
        debugDump();
    }

    private synchronized DirectByteBuffer requestDirectByteBuffer(int capacity)
    {
        //NLogger.debug( NLoggerNames.GLOBAL, "Requesting DirectByteBuffer:" + capacity );
        debugDump();
        
        int kb = (int) Math.ceil(capacity / 1024.0);
        Integer key = new Integer(kb);
        Set<DirectByteBuffer> set = sizeToBufferListMap.get(key);
        if (set == null)
        {
            set = new HashSet<DirectByteBuffer>();
            sizeToBufferListMap.put(key, set);
        }
        DirectByteBuffer directByteBuffer;
        if (set.isEmpty())
        {
            directByteBuffer = allocateDirectByteBuffer(kb * 1024);
        }
        else
        {
            directByteBuffer = set.iterator().next();
            set.remove(directByteBuffer);
        }
        ByteBuffer buffer = directByteBuffer.getInternalBuffer();
        buffer.clear();
        buffer.limit(capacity);
        
        //NLogger.debug( NLoggerNames.GLOBAL, "Requested DirectByteBuffer:" + directByteBuffer );
        debugDump();
        return directByteBuffer;
    }

    /**
     * @param kb
     * @return
     */
    private synchronized DirectByteBuffer allocateDirectByteBuffer(int capacity)
    {
        ByteBuffer byteBuffer;
        try
        {
            byteBuffer = ByteBuffer.allocateDirect(capacity);
        }
        catch (OutOfMemoryError err)
        {
            clearBuffers();
            System.runFinalization();
            System.gc();
            Thread.yield();
            try
            {
                byteBuffer = ByteBuffer.allocateDirect(capacity);
            }
            catch (OutOfMemoryError err2)
            {
                NLogger.error( DirectByteBufferProvider.class,
                    "Out of memory while trying to allocated direct byte buffer.");
                throw err2;
            }
        }
        DirectByteBuffer directByteBuffer = new DirectByteBuffer(byteBuffer,
            this);
        return directByteBuffer;
    }

    /**
     * Clears available buffers of the provider.
     */
    private synchronized void clearBuffers()
    {
        for ( Set<DirectByteBuffer> set : sizeToBufferListMap.values() )
        {
            set.clear();
        }
    }

    private synchronized void cleanupChecker()
    {
        long bytesUsed = 0;
        Iterator<Integer> iterator = sizeToBufferListMap.keySet().iterator();
        while (iterator.hasNext())
        {
            Integer key = iterator.next();
            Set<DirectByteBuffer> set = sizeToBufferListMap.get(key);

            bytesUsed += key.intValue() * set.size() * 1024;
        }

        if (bytesUsed > MAX_TOTAL_BUFFER_SIZE)
        {
            performCleanup(bytesUsed - MAX_TOTAL_BUFFER_SIZE);
        }
    }

    private synchronized void performCleanup(long bytesToFree)
    {
        // we remove buffers from sizes with the highest amount of cached buffers
        int mapSize = sizeToBufferListMap.size();
        int highestCount = 0;
        int[] bufferSizeArr = new int[mapSize];
        Set[] bufferSetArr = new Set[mapSize];

        int i = 0;
        Iterator<Integer> listIterator = sizeToBufferListMap.keySet().iterator();
        while (listIterator.hasNext())
        {
            Integer key = listIterator.next();
            Set<DirectByteBuffer> set = sizeToBufferListMap.get(key);
            bufferSizeArr[i] = key.intValue() * 1024;
            bufferSetArr[i] = set;
            int setSize = set.size();
            if (setSize > highestCount)
            {
                highestCount = setSize;
            }
            i++;
        }

        long bytesFreed = 0;
        while (bytesFreed < bytesToFree && highestCount > 0)
        {
            for (i = 0; i < mapSize; i++)
            {
                // if this is the largest buffer list remove 
                // one buffer.
                if (bufferSetArr[i].size() == highestCount)
                {
                    bufferSetArr[i].remove( bufferSetArr[i].iterator().next() );
                    bytesFreed += bufferSizeArr[i];
                }
            }
            highestCount--;
        }
    }
    
    private synchronized void debugDump()
    {
//        Iterator keys = sizeToBufferListMap.keySet().iterator();
//        while ( keys.hasNext() )
//        {
//            Integer key = (Integer) keys.next();
//            System.out.println( "------------------------" );
//            System.out.println( "Key: " + key.intValue() );
//            Set keySet = (Set) sizeToBufferListMap.get(key);
//            Iterator bufferIterator = keySet.iterator();
//            while ( bufferIterator.hasNext() )
//            {
//                DirectByteBuffer buffer = (DirectByteBuffer) bufferIterator.next();
//                System.out.println( buffer );
//            }
//        }
    }

    private class CleanupCheckerTask extends TimerTask
    {
        private static final int TIMER_PERIOD = 10 * 60 * 1000;

        /**
         * @see java.util.TimerTask#run()
         */
        public void run()
        {
            cleanupChecker();
        }

    }
}

Why use anonymous classes?

As with local classes, objects instantiated from anonymous classes share many of the characteristics of objects instantiated from member classes.  However, in some cases, an anonymous class can be defined closer to its point of use than would be possible with a member class or a local class.  Once you become accustomed to the somewhat cryptic syntax used with anonymous classes, this can often lead to improved code readability.

Probably the most important benefit of anonymous classes has to do with accessing the members of enclosing classes.  Just like with member classes and local classes, methods of an anonymous class have direct access to all the members of the enclosing classes, including private members. Thus the use of anonymous classes can often eliminate the requirement to connect objects together via constructor parameters.

In addition, although not demonstrated in this lesson, as with local classes, objects of anonymous classes have access to final local variables that are declared within the scope of the anonymous class.

An anonymous class can be particularly useful in those cases where

• There is no reason for an object of the anonymous class to exist in the absence of an object of the enclosing class.
• There is no reason for an object of the anonymous class to exist outside a method of the enclosing class.
• Methods of the object of the anonymous class need access to members of the object of the enclosing class.
• Methods of the object of the anonymous class need access to final local variables and method parameters belonging to the method in which the anonymous class is defined.
• Only one instance of the anonymous class is needed.
• There is no need for the class to have a name that is accessible elsewhere in the program.