返回首页

Lucene 实现 hessian序列化

时间:2009-12-16 01:17来源:未知 作者:admin 点击:
最近在做一个项目,项目实现类似于下面的结构。 搜索服务器里的搜索服务用 Hessian 的方式提供接口,这个接口只是将上传的 Query,Filter,Sort 为作搜索参数,在服务器上执行查询并将结果返回给
  

最近在做一个项目,项目实现类似于下面的结构。


搜索服务器里的搜索服务用Hessian的方式提供接口,这个接口只是将上传的Query,Filter,Sort为作搜索参数,在服务器上执行查询并将结果返回给client,这样做的目的是将查询条件的搜索逻辑交给客户端,作为客户端业务的一部分,以保证搜索服务接口实现的稳定性,不随着搜索业务的变化而改变。

 

由于clientserch server往往是两组不同的机器,在调用hessian接口时需要将搜索参数及结果进行序列化。但在实现的过程中发现一个问题,lucenequery等查询参数对象只是实现了java.io.Serializable,并且类似于TermQuery及它用到的Term对象都不提供默认的构造器,它们在hessian接口调用时总会发生序列化错误。Lucenequery等对象不能很好的支持hessian

为了解决这个问题,想过采用提供hessian自定义序列化的方式来解决,但发现这样的实现成本较高,并且扩展性也不强,序列化很大的程序上依赖于query对象的实现。经过分析发现luceneQuery等对象都实现了java.io.Serializable接口,也即这些对象能通过java的标准方式进行序列化,那我们能不能通过java的序列方式来实现hessian的接口调用呢?通过分析和尝试,发现这样的方案是可行的。其本的实现思路为提供一个基于byte[]数据的搜索接口,并且将返回结果也用byte[]数组类型。在调用这个接口时,先将接口参数通过java.io.ObjectOutputStream转化为byte[]数组,再调用hessian接口,以实现搜索服务的调用,同时由于调用的返回结果为byte[]数据类型,我们再通过java.io.ObjectInputStreambyte[]数据转化为查询结果对象。实现的结构如下:


实现的代码如下:

 

/**
定义搜索条件参数对象
**/

import org.apache.lucene.search.Filter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Sort;

public class SearchCondition implements java.io.Serializable{

    private static final long serialVersionUID = -4455245159124679717L;
    private Query query;
    private Filter filter;
    private Sort sort;
    private int begin;
    private int end;
   
    public Query getQuery() {
        return query;
    }
    public void setQuery(Query query) {
        this.query = query;
    }
    public Filter getFilter() {
        return filter;
    }
    public void setFilter(Filter filter) {
        this.filter = filter;
    }
    public Sort getSort() {
        return sort;
    }
    public void setSort(Sort sort) {
        this.sort = sort;
    }
    public int getBegin() {
        return begin;
    }
    public void setBegin(int begin) {
        this.begin = begin<=0?0:begin;;
    }
    public int getEnd() {
        return end;
    }
    public void setEnd(int end) {
        this.end = end<=0?0:end;
    }
   

}

/**
   定义返回结果对象
**/
import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

public class SearchResult<T> implements Serializable{

    private static final long serialVersionUID = 1L;

    private int begin;

    private int end;

    private int totalCount;

    private List<T> resultList;
    public SearchResult(){
        resultList=new ArrayList<T>();
    }

    public void addResult(T obj){
        resultList.add(obj);
    }

    public int getEnd() {
        return end;
    }

    public void setEnd(int end) {
        this.end = end;
    }

    public List<T> getResultList() {
        return resultList;
    }

    public void setResultList(List<T> resultList) {
        this.resultList = resultList;
    }

    public int getBegin() {
        return begin;
    }

    public void setBegin(int begin) {
        this.begin = begin;
    }

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }
}


/**
    定义客户端调用的搜索接口
**/
import java.io.IOException;

public interface Searcher{
    public SearchResult search(SearchCondition condition) throws IOException;
}


/**
   定义hessian的搜索接口。
**/
import java.io.IOException;

public interface RawSearcher {
   
    /**
     * 为了支持序列化操作的一 个搜索接口,其他参数及结果都是用java序列化后的结果,以便在网络上进行传输。
     * @param condition SearchCondition对象的序列化字节流。
     * @return SearchResult对象的序列化流。
     * @throws IOException
     */
    public byte[] search(byte[] condition) throws IOException;
}


import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class DefaultRawSearcher implements RawSearcher {
//    private static Log log = LogFactory.getLog(DefaultRawSearcher.class);
    private DefaultSearcher searcher=new DefaultSearcher();
   
    public byte[] search(byte[] condition) throws IOException {
        if(condition==null || condition.length==0){
            throw new RuntimeException("the condition cann't be null.");
        }
        ByteArrayInputStream in = new ByteArrayInputStream(condition);
        ObjectInputStream oIn=new ObjectInputStream(in);
        try {
        //将byte[]参数转化为SearchCondition对象。
            SearchCondition sCond = (SearchCondition)oIn.readObject();
        //通过lucene搜索到符合条件的结果。
            SearchResult result = searcher.search(sCond);
        //将返回结果转化为byte[]数组。
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream oOut = new ObjectOutputStream(out);
            oOut.writeObject(result);
            return out.toByteArray();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e.getMessage(),e);
        }
    }
}

/**
spring的FactoryBean,动态的创建Searcher的实现类,自动完成客户端调用时的参数序列化及返回结果反序列化操作。使客户端不用关于序列化的细节。
**/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.springframework.beans.factory.FactoryBean;

public class RawSearcherFactoryBean implements FactoryBean{
   
    private RawSearcher rawSearcher=null;

    public RawSearcher getRawSearcher() {
        return rawSearcher;
    }

    public void setRawSearcher(RawSearcher rawSearcher) {
        this.rawSearcher = rawSearcher;
    }

    public Object getObject() throws Exception {
        Object proxy = Proxy.newProxyInstance(Searcher.class.getClassLoader(), new Class[]{Searcher.class}, new InvocationHandler(){
            @SuppressWarnings("unchecked")
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
                String methodName=method.getName();
                Class[] argTypes=method.getParameterTypes();
                argTypes=new Class[args.length];
                for(int j=0;j<argTypes.length;j++){
                    argTypes[j]=byte[].class;
                }
                Method rawMethod = RawSearcher.class.getMethod(methodName, argTypes);
                Object[] rawArgs=new Object[args.length];
                int i=0;
            //将接口的查询参数进行java序列化,并转化为byte数组。
                for(Object o:args){
                    ByteArrayOutputStream out=new ByteArrayOutputStream();
                    ObjectOutputStream oOut = new ObjectOutputStream(out);
                    oOut.writeObject(o);
                    rawArgs[i]=out.toByteArray();
                    i++;
                }
                byte[] bResult = (byte[]) rawMethod.invoke(rawSearcher, rawArgs);
            //将返回结果里的byte[]数组进行反序列化,转化为SearchResult对象。
                ByteArrayInputStream in = new ByteArrayInputStream(bResult);
                ObjectInputStream oIn=new ObjectInputStream(in);
                SearchResult result = (SearchResult)oIn.readObject();
                return result;
            }
        });
        return proxy;
    }

    public Class getObjectType() {
        return Searcher.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

 

search server上,将RawSearcherhessian服务的方式提供搜索服务。在客户端,取RawSearcherhessian客户端proxy,并注入到 RawSearcherFactoryBean中,然后通过RawSearcherFactoryBean得到Searcher对象,并调用Searcher对象上的SearchResult search(SearchCondition condition)方法实现搜索。



总结:总的来说,lucene设计的很多对象对实现远程调用带来麻烦,hessian的序列化问题就是其中一个,同时对于java的序列化有时也会带来麻烦,如不同lucene版本之间的对象的serialVersionUID也不尽相同,因此为了保证调用成功,请在客户端和服务采用相同的lucene版本。在hessian方面,它对复杂对象的序列化支持还不能算太完善,不知道何时能改进。

顶一下
(0)
0%
踩一下
(0)
0%
------分隔线----------------------------
最新评论 查看所有评论
发表评论 查看所有评论
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 密码: 验证码:
发布者资料
小朱 查看详细资料 发送留言 加为好友 用户等级:超级会员 注册时间:2008-11-18 17:11 最后登录:2012-09-01 20:09
推荐内容
热点内容