反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。

package com.serviceimpl;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
 
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

import com.service.LuceneDao;

/**
 * @author 三劫散仙
 * LuceneDao接口的实现类
 * **/
public class LuceneDaoImpl implements LuceneDao {
	
	
	
	
	
	/**
	 * 抽象的父类文件夹
	 * */
	public static Directory directory;
	  /**
	   * 返回IndexWriter
	   * */
	  public static IndexWriter getWriter() throws Exception{
		  Analyzer analyzer=new StandardAnalyzer(Version.LUCENE_43);//设置标准分词器 ,默认是一元分词
		  IndexWriterConfig iwc=new IndexWriterConfig(Version.LUCENE_43, analyzer);//设置IndexWriterConfig
		 //  iwc.setRAMBufferSizeMB(3);//设置缓冲区大小
		  return new IndexWriter(directory,iwc);
	  }
	  
	  /***
	   * @param indexPath 查询的路径
	   * @param field     查询的字段类型
	   * @param searchText  搜索的文本
	   * 
	   * 
	   * **/
	   public void searchTermQuery(String indexPath,String field,String searchText){
		   
		   try {
			directory=FSDirectory.open(new File(indexPath));//打开索引库
			IndexReader reader=DirectoryReader.open(directory);//流读取
			IndexSearcher search=new IndexSearcher(reader);//搜索
			//Query q=new PhraseQuery();//查询实例
			Query  q=new TermQuery(new Term(field, searchText));
			//q.add();
			TopDocs td=search.search(q, 1000);//获取最高得分命中
			for(ScoreDoc doc:td.scoreDocs){
				Document d=search.doc(doc.doc);
				System.out.println("id:"+d.get("id"));
				System.out.println("name:"+d.get("name"));
				System.out.println("content:"+d.get("content"));
				
			}
			reader.close();//关闭读取流
			directory.close();//文件夹
			
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		   
		   
		   
		   
		   
	   }
	  
	  
	  /**
	   * 添加的方法
	   * */
	@Override
	public void add(String indexWriterPath) {
		 IndexWriter writer=null;
		  try{
		 directory=FSDirectory.open(new File(indexWriterPath));//打开存放索引的路径
		 writer=getWriter();
		 Document doc=new Document();
		 doc.add(new StringField("id", "5", Store.YES));//ID类型不分词存储
		 doc.add(new TextField("name", "秋去春来，几多愁", Store.YES));//name使用默认一元分词
		 doc.add(new TextField("content", "命运总是颠沛流离，命运总是崎岖厉害", Store.YES));//存储
//		 doc.add(new StringField("id", "1", Store.YES));//存储
//		 doc.add(new StringField("name", "张飞", Store.YES));//存储
//		 doc.add(new StringField("content", "也许放弃,才能靠近你!", Store.YES));//存储
		 writer.addDocument(doc);//添加进写入流里
		 writer.forceMerge(1);//优化压缩段,大规模添加数据的时候建议，少使用本方法，会影响性能
		 writer.commit();//提交数据 
		 System.out.println("添加成功");
		  }catch(Exception e){
			  
			  e.printStackTrace();
			  
		  }finally{
			  
			  if(writer!=null){
				  try{
				  writer.close();//关闭流
				  }catch(Exception e){
					  e.printStackTrace();
				  }
			  }
			  
			  
		  }
		
	}
   
	/***
	 *  简单查询的方法
	 *  @param indexReadPath 读取的索引路径
	 *  @param  filed 查询的字段类型
	 *  @param  searchText查询的文本
	 * */
 
	public void simpleSearch1(String indexReadPath, String field,
			String searchText) {
		try{
		directory=FSDirectory.open(new File(indexReadPath));//打开索引文件夹
		IndexReader  reader=DirectoryReader.open(directory);//读取目录
		IndexSearcher search=new IndexSearcher(reader);//初始化查询组件
		
		//Query query=new TermQuery(new Term(field, searchText));//查询
		
		  QueryParser parser=new QueryParser(Version.LUCENE_43, field, new StandardAnalyzer(Version.LUCENE_43));//标准分析器查询时候一元分词效果
	   	  Query query=parser.parse(searchText);
	   	  
		 TopDocs td=search.search(query, 10000);//获取匹配上元素的一个docid
		ScoreDoc[] sd=td.scoreDocs;//加载所有的Documnet文档
		System.out.println("本次命中数据:"+sd.length);
		for(int i=0;i<sd.length;i++){
			
			int z=sd[i].doc;//获取每一个文档编号
			Document doc=search.doc(z);//获取文档
			System.out.println("id:"+doc.get("id"));
			System.out.println("name:"+doc.get("name"));
			System.out.println("content:"+doc.get("content"));
		}
		
		 reader.close();//关闭资源
		 directory.close();//关闭连接
		
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
 
	

	/***
	 * 查询数据总量
	 * @param indexFile 索引路径
	 * */
	public int findIndexDbCount(String indexFile) {
		int total = 0;
		try {
			Directory dir = FSDirectory.open(new File(indexFile));//打开文件夹
			IndexReader reader = DirectoryReader.open(dir);//读取数据
			total = reader.numDocs();//数据总量
			reader.close();//释放资源
			dir.close();//释放资源
		} catch (Exception e) {
			e.printStackTrace();
		}

		return total;

	}


	/***
	 * 删除方法
	 * @param indexPath 索引路径
	 * @param id 根据ID删除
	 * */
	@Override
	public void delete(String indexPath, String id) {
		try{
			directory=FSDirectory.open(new File(indexPath));//打开文件索引目录
		IndexWriter writer=getWriter();
		
		IndexReader  reader=DirectoryReader.open(directory);//读取目录
		Query q=new TermQuery(new Term("id", id));
		writer.deleteDocuments(q);//删除指定ID的Document
		writer.commit();//提交
		writer.close();//关闭
		reader.close();//关闭
		System.out.println("删除id为"+id+"的记录成功");
		
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
	
	/***
	 * 根据ID进行更行的方法
	 * 
	 * */
	@Override
	public void updateByID(String indexPath, String docID,
			HashMap<String, String> map) {
		try{
		directory=FSDirectory.open(new File(indexPath));//打开文件索引目录
		IndexWriter writer=getWriter();
		
		//IndexReader  reader=DirectoryReader.open(directory);//读取目录
		 //Document doc=reader.document(Integer.parseInt(docID));
		 Document d=new Document();
		 d.add(new StringField("id",map.get("id").toString(),Store.YES));
		 d.add(new TextField("name",map.get("name").toString(),Store.YES));
		 d.add(new TextField("content",map.get("content").toString(),Store.YES));
		  writer.updateDocument(new Term("id", docID), d);
		 
		  writer.commit();
		  writer.close();//关闭
		  directory.close();//关闭
		  System.out.println("更新成功!");
		
		}catch(Exception e){
			e.printStackTrace();
			
		}
	}

}

package com.cari.web.cache;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;

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

/**
 * @author zsy
 */
public class CacheOperation {
    private static final Log log = LogFactory.getLog(CacheOperation.class);
    private static CacheOperation singleton = null;
    
    private Hashtable cacheMap;//存放缓存数据
    
    private ArrayList threadKeys;//处于线程更新中的key值列表
    
    public static CacheOperation getInstance() {
        if (singleton == null) {
            singleton = new CacheOperation();
        }
        return singleton;
    }
    
    private CacheOperation() {
        cacheMap = new Hashtable();
        threadKeys = new ArrayList();
    }
    
    /**
     * 添加数据缓存
     * 与方法getCacheData(String key, long intervalTime, int maxVisitCount)配合使用
     * @param key
     * @param data
     */
    public void addCacheData(String key, Object data) {
        addCacheData(key, data, true);
    }
    
    private void addCacheData(String key, Object data, boolean check) {
        if (Runtime.getRuntime().freeMemory() < 5L*1024L*1024L) {//虚拟机内存小于10兆，则清除缓存
            log.warn("WEB缓存：内存不足，开始清空缓存！");
            removeAllCacheData();
            return;
        } else if(check && cacheMap.containsKey(key)) {
            log.warn("WEB缓存：key值= " + key + " 在缓存中重复, 本次不缓存！");
            return;
        }
        cacheMap.put(key, new CacheData(data));
    }
    
    /**
     * 取得缓存中的数据
     * 与方法addCacheData(String key, Object data)配合使用
     * @param key 
     * @param intervalTime 缓存的时间周期，小于等于0时不限制
     * @param maxVisitCount 访问累积次数，小于等于0时不限制
     * @return
     */
    public Object getCacheData(String key, long intervalTime, int maxVisitCount) {
        CacheData cacheData = (CacheData)cacheMap.get(key);
        if (cacheData == null) {
            return null;
        }
        if (intervalTime > 0 && (System.currentTimeMillis() - cacheData.getTime()) > intervalTime) {
            removeCacheData(key);
            return null;
        }
        if (maxVisitCount > 0 && (maxVisitCount - cacheData.getCount()) <= 0) {
            removeCacheData(key);
            return null;
        } else {
            cacheData.addCount();
        }
        return cacheData.getData();
    }
    
    /**
     * 当缓存中数据失效时，用不给定的方法线程更新数据
     * @param o 取得数据的对像(该方法是静态方法是不用实例，则传Class实列)
     * @param methodName 该对像中的方法
     * @param parameters 该方法的参数列表(参数列表中对像都要实现toString方法,若列表中某一参数为空则传它所属类的Class)
     * @param intervalTime 缓存的时间周期，小于等于0时不限制
     * @param maxVisitCount 访问累积次数，小于等于0时不限制
     * @return
     */
    public Object getCacheData(Object o, String methodName,Object[] parameters, 
            long intervalTime, int maxVisitCount) {
        Class oc = o instanceof Class ? (Class)o : o.getClass();
        StringBuffer key = new StringBuffer(oc.getName());//生成缓存key值
        key.append("-").append(methodName);
        if (parameters != null) {
            for (int i = 0; i < parameters.length; i++) {
                if (parameters[i] instanceof Object[]) {
                    key.append("-").append(Arrays.toString((Object[])parameters[i]));
                } else {
                    key.append("-").append(parameters[i]);
                }
            }
        }
        
        CacheData cacheData = (CacheData)cacheMap.get(key.toString());
        if (cacheData == null) {//等待加载并返回
            Object returnValue = invoke(o, methodName, parameters, key.toString());
            return returnValue instanceof Class ? null : returnValue;
        }
        if (intervalTime > 0 && (System.currentTimeMillis() - cacheData.getTime()) > intervalTime) {
            daemonInvoke(o, methodName, parameters, key.toString());//缓存时间超时,启动线程更新数据
        } else if (maxVisitCount > 0 && (maxVisitCount - cacheData.getCount()) <= 0) {//访问次数超出,启动线程更新数据
            daemonInvoke(o, methodName, parameters, key.toString());
        } else {
            cacheData.addCount();
        }
        return cacheData.getData();
    }
    
    /**
     * 递归调用给定方法更新缓存中数据据
     * @param o
     * @param methodName
     * @param parameters
     * @param key
     * @return 若反射调用方法返回值为空则返回该值的类型
     */
    private Object invoke(Object o, String methodName,Object[] parameters, String key) {
        Object returnValue = null;
        try {
            Class[] pcs = null;
            if (parameters != null) {
                pcs = new Class[parameters.length];
                for (int i = 0; i < parameters.length; i++) {
                    if (parameters[i] instanceof MethodInfo) {//参数类型是MethodInfo则调用该方法的返回值做这参数
                        MethodInfo pmi = (MethodInfo)parameters[i];
                        Object pre = invoke(pmi.getO(), pmi.getMethodName(), pmi.getParameters(), null);
                        parameters[i] = pre;
                    }
                    if (parameters[i] instanceof Class) {
                        pcs[i] = (Class)parameters[i];
                        parameters[i] = null;
                    } else {
                        pcs[i] = parameters[i].getClass();
                    }
                }
            }
            Class oc = o instanceof Class ? (Class)o : o.getClass();
        //    Method m = oc.getDeclaredMethod(methodName, pcs);
            Method m = matchMethod(oc, methodName, pcs);
            returnValue = m.invoke(o, parameters);
            if (key != null && returnValue != null) {
                addCacheData(key, returnValue, false);
            }
            if (returnValue == null) {
                returnValue = m.getReturnType();
            }
        } catch(Exception e) {
            log.error("调用方法失败,methodName=" + methodName);
            if (key != null) {
                removeCacheData(key);
                log.error("更新缓存失败，缓存key=" + key);
            }
            e.printStackTrace();
        }
        return returnValue;
    }
    
    /**
     * 找不到完全匹配的方法时,对参数进行向父类匹配
     * 因为方法aa(java.util.List) 与 aa(java.util.ArrayList)不能自动匹配到
     * 
     * @param oc
     * @param methodName
     * @param pcs
     * @return
     * @throws NoSuchMethodException 
     * @throws NoSuchMethodException
     */
    private Method matchMethod(Class oc, String methodName, Class[] pcs
            ) throws NoSuchMethodException, SecurityException {
        try {
            Method method = oc.getDeclaredMethod(methodName, pcs);
            return method;
        } catch (NoSuchMethodException e) {
            Method[] ms = oc.getDeclaredMethods();
            aa:for (int i = 0; i < ms.length; i++) {
                if (ms[i].getName().equals(methodName)) {
                    Class[] pts = ms[i].getParameterTypes();
                    if (pts.length == pcs.length) {
                        for (int j = 0; j < pts.length; j++) {
                            if (!pts[j].isAssignableFrom(pcs[j])) {
                                break aa;
                            }
                        }
                        return ms[i];
                    }
                }
            }
            throw new NoSuchMethodException();
        }
    }
    
    /**
     * 新启线程后台调用给定方法更新缓存中数据据
     * @param o
     * @param methodName
     * @param parameters
     * @param key
     */
    private void daemonInvoke(Object o, String methodName,Object[] parameters, String key) {
        if (!threadKeys.contains(key)) {
            InvokeThread t = new InvokeThread(o, methodName, parameters, key);
            t.start();
        }
    }
    
    /**
     * 些类存放方法的主调对像,名称及参数数组
     * @author zsy
     *
     */
    public class MethodInfo {
        private Object o;
        private String methodName;
        private Object[] parameters;
        public MethodInfo(Object o, String methodName,Object[] parameters) {
            this.o = o;
            this.methodName = methodName;
            this.parameters = parameters;
        }
        public String getMethodName() {
            return methodName;
        }
        public void setMethodName(String methodName) {
            this.methodName = methodName;
        }
        public Object getO() {
            return o;
        }
        public void setO(Object o) {
            this.o = o;
        }
        public Object[] getParameters() {
            return parameters;
        }
        public void setParameters(Object[] parameters) {
            this.parameters = parameters;
        }
        
        public String toString() {
            StringBuffer str = new StringBuffer(methodName);
            if (parameters != null) {
                str.append("(");
                for (int i = 0; i < parameters.length; i++) {
                    if (parameters[i] instanceof Object[]) {
                        str.append(Arrays.toString((Object[])parameters[i])).append(",");
                    } else {
                        str.append(parameters[i]).append(",");
                    }
                }
                str.append(")");
            }
            return str.toString();
        }
    }
    
    /**
     * 线程调用方法
     * @author zsy
     *
     */
    private class InvokeThread extends Thread {
        private Object o;
        private String methodName;
        private Object[] parameters;
        private String key;
        public InvokeThread(Object o, String methodName,Object[] parameters, String key) {
            this.o = o;
            this.methodName = methodName;
            this.parameters = parameters;
            this.key = key;
        }
        
        public void run() {
            threadKeys.add(key);
            invoke(o, methodName, parameters, key);
            threadKeys.remove(key);
        }
    }
    
    /**
     * 移除缓存中的数据
     * @param key
     */
    public void removeCacheData(String key) {
        cacheMap.remove(key);
    }
    
    /**
     * 移除所有缓存中的数据
     *
     */
    public void removeAllCacheData() {
        cacheMap.clear();
    }
    
    public String toString() {
        StringBuffer sb = new StringBuffer("************************ ");
        sb.append("正在更新的缓存数据： ");
        for (int i = 0; i < threadKeys.size(); i++) {
            sb.append(threadKeys.get(i)).append(" ");
        }
        sb.append("当前缓存大小：").append(cacheMap.size()).append(" ");
        sb.append("************************");
        return sb.toString();
    }
}

public class Server {
   
   public static void main(String args[]) throws IOException {
      //为了简单起见，所有的异常信息都往外抛
     int port = 8899;
      //定义一个ServerSocket监听在端口8899上
     ServerSocket server = new ServerSocket(port);
      while (true) {
         //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的
         Socket socket = server.accept();
         //每接收到一个Socket就建立一个新的线程来处理它
         new Thread(new Task(socket)).start();
      }
   }
   
   /**
    * 用来处理Socket请求的
   */
   static class Task implements Runnable {
 
      private Socket socket;
      
      public Task(Socket socket) {
         this.socket = socket;
      }
      
      public void run() {

         try {

            handleSocket();
         } catch (Exception e) {
            e.printStackTrace();
         }
      }
      
      /**
       * 跟客户端Socket进行通信
       * @throws Exception
       */
      private void handleSocket() throws Exception {
         Reader reader = new InputStreamReader(socket.getInputStream());
         char chars[] = new char[64];
         int len;
         StringBuilder sb = new StringBuilder();
         String temp;
         int index;
         while ((len=reader.read(chars)) != -1) {
            temp = new String(chars, 0, len);
            if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
             sb.append(temp.substring(0, index));
                break;
            }
            sb.append(temp);
         }
         System.out.println("from client: " + sb);
         //读完后写一句
       Writer writer = new OutputStreamWriter(socket.getOutputStream());
         writer.write("Hello Client.");
         writer.flush();
         writer.close();
         reader.close();
         socket.close();
      }
      
   }
   
}