Lucene 实现 hessian序列化

 

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

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

 

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

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

 

实现的代码如下：

 

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

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上，将RawSearcher以hessian服务的方式提供搜索服务。在客户端，取RawSearcher的hessian客户端proxy，并注入到 RawSearcherFactoryBean中，然后通过RawSearcherFactoryBean得到Searcher对象，并调用Searcher对象上的SearchResult search(SearchCondition condition)方法实现搜索。

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