include_once(‘SSDB.php‘);
try{
    $ssdb = new SimpleSSDB(‘127.0.0.1‘, 8888);
}catch(SSDBException $e){
    die(__LINE__ . ‘ ‘ . $e->getMessage());
}

$ssdb->set(‘hpl_product_autoincrement_id‘, 0);

$id = $ssdb->incr(‘hpl_product_autoincrement_id‘, 1);

class ProductModel{
	public $id;					//编号
	public $catalogid;	//所属分类
	public $name;				//产品名称
	public $cost;				//产品成本价格
	public $price;			//销售价格
	public $saleprice;	//优惠价格
	public $amount;			//产品数量
	public $facetype;		//适合皮肤类型
	public $desc;				//产品描述
	public $code;				//产品编号
	public $weight;			//净含量（克）
	public $effect;			//主要功效
	public $crowd;			//适合人群
	public $addtime;		//产品添加时间
	public $status;			//产品状态（0 = 下架 1 = 上架)
}

$key = ‘hpl_product_‘.$id;
$ssdb->zset(‘hpl_product_id‘, $key, $id);

$products = array();
//根据索引取出产品列表
$items = $ssdb->zscan(‘hpl_product_id‘, ‘‘, ‘‘, ‘‘, 10);
foreach($items as $key=>$score){
    //取出产品信息
    $json = $ssdb->hget(‘hpl_product‘, $key);
    $products[] = json_decode($json);
}

$hname = ‘hpl_product_catalog_‘.$catalogid;
$hkey = ‘hpl_product_‘.$id;
$ssdb->hset($hname, $hkey, $id);

$hname = ‘hpl_product_catalog_‘.$catalogid;
$hkey = ‘hpl_product_‘.$id;
$ssdb->hdel($hname, $hkey);

$products = array();
//根据分类取出产品列表
$hname = ‘hpl_product_catalog_‘.$catalogid;
$keys = $ssdb->hkeys($hname, ‘‘, ‘‘, 10);
foreach ($keys as $key) {
    //取出产品信息
    $json = $ssdb->hget(‘hpl_product‘, $key);
    $products[] = json_decode($json);
}

/**
Executor.java
*/
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

public class Executor
    implements Watcher, Runnable, DataMonitor.DataMonitorListener
{
    String znode;

    DataMonitor dm;

    ZooKeeper zk;

    String filename;

    String exec[];

    Process child;

    public Executor(String hostPort, String znode, String filename,
            String exec[]) throws KeeperException, IOException {
        this.filename = filename;
        this.exec = exec;
        zk = new ZooKeeper(hostPort, 3000, this);
        dm = new DataMonitor(zk, znode, null, this);
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        if (args.length < 4) {
            System.err
                    .println("USAGE: Executor hostPort znode filename program [args ...]");
            System.exit(2);
        }
        String hostPort = args[0];
        String znode = args[1];
        String filename = args[2];
        String exec[] = new String[args.length - 3];
        System.arraycopy(args, 3, exec, 0, exec.length);
        try {
            new Executor(hostPort, znode, filename, exec).run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /***************************************************************************
     * We do process any events ourselves, we just need to forward them on.
     *
     * @see org.apache.zookeeper.Watcher#process(org.apache.zookeeper.proto.WatcherEvent)
     */
    public void process(WatchedEvent event) {
        dm.process(event);
    }

    public void run() {
        try {
            synchronized (this) {
                while (!dm.dead) {
                    wait();
                }
            }
        } catch (InterruptedException e) {
        }
    }

    public void closing(int rc) {
        synchronized (this) {
            notifyAll();
        }
    }

    static class StreamWriter extends Thread {
        OutputStream os;

        InputStream is;

        StreamWriter(InputStream is, OutputStream os) {
            this.is = is;
            this.os = os;
            start();
        }

        public void run() {
            byte b[] = new byte[80];
            int rc;
            try {
                while ((rc = is.read(b)) > 0) {
                    os.write(b, 0, rc);
                }
            } catch (IOException e) {
            }

        }
    }

    public void exists(byte[] data) {
        if (data == null) {
            if (child != null) {
                System.out.println("Killing process");
                child.destroy();
                try {
                    child.waitFor();
                } catch (InterruptedException e) {
                }
            }
            child = null;
        } else {
            if (child != null) {
                System.out.println("Stopping child");
                child.destroy();
                try {
                    child.waitFor();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                FileOutputStream fos = new FileOutputStream(filename);
                fos.write(data);
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                System.out.println("Starting child");
                child = Runtime.getRuntime().exec(exec);
                new StreamWriter(child.getInputStream(), System.out);
                new StreamWriter(child.getErrorStream(), System.err);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}



/**
DataMonitor.java
 */
import java.util.Arrays;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.AsyncCallback.StatCallback;
import org.apache.zookeeper.KeeperException.Code;
import org.apache.zookeeper.data.Stat;
import com.udpwork.ssdb.SSDB;
import com.udpwork.ssdb.Link;
import com.udpwork.ssdb.MemoryStream;
import com.udpwork.ssdb.Response;

public class DataMonitor implements Watcher, StatCallback {

    ZooKeeper zk;

    String znode;

    Watcher chainedWatcher;

    boolean dead;

    DataMonitorListener listener;

    byte prevData[];

    public DataMonitor(ZooKeeper zk, String znode, Watcher chainedWatcher,
            DataMonitorListener listener) {
        this.zk = zk;
        this.znode = znode;
        this.chainedWatcher = chainedWatcher;
        this.listener = listener;
        // Get things started by checking if the node exists. We are going
        // to be completely event driven
        zk.exists(znode, true, this, null);
    }

    /**
     * Other classes use the DataMonitor by implementing this method
     */
    public interface DataMonitorListener {
        /**
         * The existence status of the node has changed.
         */
        void exists(byte data[]);

        /**
         * The ZooKeeper session is no longer valid.
         *
         * @param rc
         *                the ZooKeeper reason code
         */
        void closing(int rc);
    }

    public void process(WatchedEvent event) {
        String path = event.getPath();
        if (event.getType() == Event.EventType.None) {
            // We are are being told that the state of the
            // connection has changed
            switch (event.getState()) {
            case SyncConnected:
                // In this particular example we don‘t need to do anything
                // here - watches are automatically re-registered with 
                // server and any watches triggered while the client was 
                // disconnected will be delivered (in order of course)
                break;
            case Expired:
                // It‘s all over
                dead = true;
                listener.closing(KeeperException.Code.SessionExpired);
                break;
            }
        } else {
            if (path != null && path.equals(znode)) {
                // Something has changed on the node, let‘s find out
                //读取订单信息
                //znode = /product/order/
                ...
                
                //计算库存是否充足
                ...
                
                //生成订单数据
                ...
                
                //减少产品库存
                ...
                
                zk.exists(znode, true, this, null);
            }
        }
        if (chainedWatcher != null) {
            chainedWatcher.process(event);
        }
    }

    public void processResult(int rc, String path, Object ctx, Stat stat) {
        boolean exists;
        switch (rc) {
        case Code.Ok:
            exists = true;
            break;
        case Code.NoNode:
            exists = false;
            break;
        case Code.SessionExpired:
        case Code.NoAuth:
            dead = true;
            listener.closing(rc);
            return;
        default:
            // Retry errors
            zk.exists(znode, true, this, null);
            return;
        }

        byte b[] = null;
        if (exists) {
            try {
                b = zk.getData(znode, false, null);
            } catch (KeeperException e) {
                // We don‘t need to worry about recovering now. The watch
                // callbacks will kick off any exception handling
                e.printStackTrace();
            } catch (InterruptedException e) {
                return;
            }
        }
        if ((b == null && b != prevData)
                || (b != null && !Arrays.equals(prevData, b))) {
            listener.exists(b);
            prevData = b;
        }
    }
}

class OrderWorker extends Zookeeper {
 
  const CONTAINER = ‘/product/order‘;
 
  protected $acl = array(
                    array(
                      ‘perms‘ => Zookeeper::PERM_ALL,
                      ‘scheme‘ => ‘world‘,
                      ‘id‘ => ‘anyone‘ ) );</p><p>  private $znode;
 
  public function __construct( $host = ‘‘, $watcher_cb = null, $recv_timeout = 10000 ) {
    parent::__construct( $host, $watcher_cb, $recv_timeout );
  }
 
  //添加订单
  public function Add($order) {
    if( ! $this->exists( self::CONTAINER ) ) {
      $this->create( self::CONTAINER, null, $this->acl );
    }
 
    $this->znode = $this->create( self::CONTAINER . ‘/w-‘,
                                  null,
                                  $this->acl,
                                  Zookeeper::EPHEMERAL | Zookeeper::SEQUENCE );
                                  
    $this->set($this->znode, json_encode(array(‘status‘=>0, ‘data‘=>$order, ‘orderid‘=>‘‘)));
 
    $this->znode = str_replace( self::CONTAINER .‘/‘, ‘‘, $this->znode );
 
    return $this->znode; 
  }
  
  //获取订单处理信息
  public function Get($znode){
   $data = $this->get(self::CONTAINER .‘/‘.$znode);
   $json = json_decode($data);
   return $json;
  }
  
  //删除订单znode
  public function Del($znode){
   $this->delete(self::CONTAINER .‘/‘.$znode);
  }
 
}

$worker = new OrderWorker( ‘127.0.0.1:2181‘ );
$znode = $worker->Add($order);
echo json_encode(array(‘code‘=>0, ‘znode‘=>$znode));

$worker = new OrderWorker( ‘127.0.0.1:2181‘ );
$data = $worker->Get($znode);
if (intval($data->status) == 1)
{
	$worker->Del($znode);
	echo json_encode(array(‘status‘=>1, ‘msg‘=>‘订单处理成功‘, ‘orderid‘=>$data->orderid));
}
else if (intval($data->status) == 2)
{
	$worker->Del($znode);
	echo json_encode(array(‘status‘=>2, ‘msg‘=>‘订单处理失败‘));
}
else
{
	echo json_encode(array(‘status‘=>0, ‘msg‘=>‘正在处理‘));
}

import java.io.File;  
import java.io.FileReader;  
import java.io.IOException;  
  
import org.apache.lucene.analysis.standard.StandardAnalyzer;  
import org.apache.lucene.document.Document;  
import org.apache.lucene.document.Field;  
import org.apache.lucene.document.LongField;  
import org.apache.lucene.document.StringField;  
import org.apache.lucene.document.TextField;  
import org.apache.lucene.index.IndexWriter;  
import org.apache.lucene.index.IndexWriterConfig;  
import org.apache.lucene.store.Directory;  
import org.apache.lucene.store.FSDirectory;  
import org.apache.lucene.util.Version;  
  

public class IndexOrders {  
      
    private IndexWriter writer = null;  
    
    public void Add(String indexPath, OrderModel order)  
            throws IOException {  

        // 获取放置索引文件的位置，若传入参数为空，则读取search.properties中设置的默认值。  
        if (indexPath == null) {  
            indexPath = LoadProperties.getProperties("indexDir");  
        }  
        final File indexDir = new File(indexPath);  
        if (!indexDir.exists() || !indexDir.canRead()) {  
            System.out  
                    .println("Document directory ‘"  
                            + indexDir.getAbsolutePath()  
                            + "‘ does not exist or is not readable, please check the path");  
            System.exit(1);  
        }  
  
          
        try {  
            // 创建索引库IndexWriter  
            if(writer == null){  
                initialIndexWriter(indexDir);  
            }  
            index(writer, order);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }
    }  
    
    public void Close()
    {
    		if (null != writer)
    		{
    		 writer.close(); 
    		}
    }
    
  
    private void initialIndexWriter(File indexDir) throws IOException {  
        Directory returnIndexDir = FSDirectory.open(indexDir);  
        IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_48,new StandardAnalyzer(Version.LUCENE_48));  
        writer = new IndexWriter(returnIndexDir, iwc);  
  
    }  
  
    private void index(IndexWriter writer, OrderModel order) throws IOException {  
  
            // 创建文档Document
            Document doc = new Document();  
            Field orderidField = new StringField("orderid", order.orderid, Field.Store.YES);  
            doc.add(orderidField);  
            
            ...
  
            //向索引库中写入文档内容  
            writer.addDocument(doc);  
        }  
    }  
} 

		int pageIndex=1;
		int pageSize=1;
		int start = (pageIndex - 1) * pageSize; 
		
		String query_fields[]=new String[]{"filename","content"};//对哪几个字段进行查询检索
		File file_index_dir = new File(indexDir);
		try {
			Directory directory = new SimpleFSDirectory(file_index_dir);
			IndexReader indexReader = DirectoryReader.open(directory);

			// 创建搜索类
			IndexSearcher indexSearcher = new IndexSearcher(indexReader);
			
			TermQuery query1 = new TermQuery(new Term("orderid", orderid));
			TermQuery query2 = new TermQuery(new Term("contact", contact));
			BooleanQuery query = new BooleanQuery();
			query.add(query1, BooleanClause.Occur.MUST);  
			query.add(query2, BooleanClause.Occur.MUST);

			int max_result_size = start + pageSize;  
			
      TopScoreDocCollector topDocs = TopScoreDocCollector.create(max_result_size, false);  
      indexSearcher.search(query, topDocs);  

      int rowCount = topDocs.getTotalHits();  //满足条件的总记录数
      int pages = (rowCount - 1) / pageSize + 1; //计算总页数  
      TopDocs tds = topDocs.topDocs(start, pageSize);  
      ScoreDoc[] scoreDoc = tds.scoreDocs;  
    		
			for (int i = 0; i < scoreDoc.length; i++) {
				// 内部编号
				int doc_id = scoreDoc[i].doc;
				
				// 根据文档id找到文档
				Document mydoc = indexSearcher.doc(doc_id);
				
				//读取搜索结果
				mydoc.get("orderid");
				mydoc.get("contact");
				mydoc.get("addr");
				...
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

 

原文：http://www.cnblogs.com/bitstream/p/nosql.html