反射 是一个 好东西,它让JAVA更灵活,不过考虑到效率 最好不要大量使用,

相关推荐: 系出名门Android(10) - HTTP 通信, XML 解析, 通过 Hander 实现异步消息处理 关于hessian中使用Session的问题 SOCKET发送ESC/POS指令检测打印机状态 Android照片墙应用实现,再多的图片也不怕崩溃 JSP 实用程序之简易图片服务器 android LruCache技术异步记载大量图片,并且有效解决OOM错误 如何成为Android高手 备份CSDN博客正文到本地存档
推荐群组: C++语言
更多相关推荐
OO 小弟遇到一个难题,请高人们指点一下.我在客户端创建了一个HttpURLConnection连接,发送xml请求,接收的也是xml,并且用SAX来解析,正常情况下都可以成功, 但是有一个情况,服务端接收到请求后不往socket里写东西,而客户端就停住了, 自己做了一个超时的处理线程去关闭HttpURLConnection连接,但是感觉socket还是没有关闭,客户端依然在等待,也没有socket异常. 有没有什么好办法,能使连接超时后能给一个异常. 以下是代码: ////接收数据 private void receiveResponse( HttpURLConnection connection ) throws Exception { MonitorXMLHandler handler = null; InputStream bis = null; handler = handlerFactory.get( monitorName, this ); try { status = connection.getResponseCode(); errorMessage = connection.getResponseMessage(); if ( logger.isLoggable( Level.FINER ) ) { logger.finer( "receive message : status=[" + status + "], messege=[" + errorMessage + "]" ); } bis = new BufferedInputStream( connection.getInputStream() ); connManager.startTimeoutCheck( connection, bis ); // 到这个函数里面就停住不走了,也没有异常,似乎在等待服务端写数据 if ( !handler.getResult( bis ) ) { throw new Exception( "It is not demand treatable." ); } if ( logger.isLoggable( Level.FINER ) ) { logger.finer( "All messages were received." ); } } finally { try { if ( bis != null ) { bis.close(); bis = null; } } catch ( IOException e ) { if ( bis != null ) { try { bis.close(); bis = null; } catch ( IOException ioe ) { if ( logger.isLoggable( Level.FINEST ) ) { logger.finest( "The input stream cannot close." ); } } } } } } import org.xml.sax.helpers.DefaultHandler; public class MonitorXMLHandler extends DefaultHandler { private SAXParser parser = null; ... // 解析xml public boolean getResult( InputStream is ) throws Exception { if ( message == null || is == null ) { return false; } if ( logger.isLoggable( Level.FINEST ) ) { logger.finest( "The analysis of the message begins." ); } //到此处就不往下走了. parser.parse( is, this ); if ( logger.isLoggable( Level.FINEST ) ) { logger.finest( "The analysis of the message finished." ); } return true; } .... } public void startTimeoutCheck() { //判断超时 if (超时) { bis.close(); bis = null; connection.disconnect(); connection = null; } } 另外我用的JDK1.4,没有使用jdk1.5里的HttpURLConnection 的设置超时的新函数.

相关推荐: 必须掌握的全文检索Lucene,带你一周从入门到精通搜索引擎！ Lucene学习笔记【2013-04-10更新】 Lucene 索引和搜索过程核心类详解 Lucene全文检索框架+Solr搜索引擎（2018版.Java） lucene3.5近实时搜索 nrtManagr实现方案 Lucene全文检索框架+Solr+ElasticSearch搜索引擎(Java高级必备.ES) Lucene全文检索从入门到精通（精细讲解含代码笔记答疑服务） lucene4之后的近实时搜索实现
推荐群组: lucene爱好者
更多相关推荐
Lucene 1：lucene3.5中提供了实现近实时搜索的管理类 nrtManager nrtMnangerPoolThread。。。。 2：基本原理是 首先更新的索引时在内存中的 自动管理reopen打开索引,通过一个线程定时提交commit到硬盘, 3：在数据库更新,或者索引添加突然断电的情况 在数据中 建立一张表 id oid type opreator 保存信息 数据库索引同步 用触发器方式向表中添加数据 4：基本都实现 在ssi中,但是索引没怎么优化。 5：lucene自定义评分,研究下。

对,全文索引有一定的延迟性,如果要及时的话,恐怕lucene应该不是用这场景吧

相关推荐: lucene 入门学习,简单实例模访google搜索 Lucene入门实例。 lucene3.0学习笔记2-(再学Lucene的简单例子) Apache Lucene全文检索和IKAnalyzer分词工具类 基于Lucene的文件检索 【Lucene】Apache Lucene全文检索引擎架构之搜索功能 【手把手教你全文检索】Apache Lucene初探 Lucene实现全文检索
推荐群组: lucene爱好者
更多相关推荐
Lucene 最近因工作需要,研究了下lucene检索的关键类Hits,发现Hits采用Vector缓存了查询结果,然后又用双链表存储了得分较高的前200个doc（如果有这么多结果）,但是这个双链表每次查询就会初始化为空,这有什么意义呢？不知道大家对此有何看法？

相关推荐: Lucene学习笔记【2013-04-10更新】 搜索篇:lucene的简单实例<一> [ppt] Lucene today, tomorrow and beyond Lucene的Directory文件目录操作MMapDirectory等类详解及区别（4.5） ES内存那点事 ElasticSearch&Lucene学习总结 Lucene数据存储实现：LSQL行存&列存 掌握它才说明你真正懂Elasticsearch
推荐群组: 电脑DIY
更多相关推荐
Lucene 公司的一个全文检索项目,索引文件大约30G左右,JVM设置为2048M,系统常驻一直在1.5G左右波动,有技术大神给分析下,lucene在检索的时候都要加载些什么到内存,只是内存占有率如此之高？

 怎么说呢,可能你对solr还不完全了解吧,估计源码也是粗略的看了看,知道为什么有fl=*,score这个fl参数吗,不管是通过httpclient还是solrJ,均能拿到文档的评分,比如在solrJ中,可以使用：
  SolrQuery query = new SolrQuery("导论"); query.setParam("fl", "id,kname,score"); query.setRows(10); QueryResponse response = null; try { response = server.query(query); System.out.println(response); } catch (SolrServerException e) { e.printStackTrace(); } List docs = response.getResults(); for (SolrDocument doc : docs) { for (Iterator iter = doc.iterator(); iter.hasNext();) { Map.Entry entry = (Entry) iter.next(); System.out.print("Key :" + entry.getKey() + " "); System.out.println("Value :" + entry.getValue()); } System.out.println("------------"); }
 
3Q...却是如君所言,没有细致的看...受教了...

相关推荐: Lucene学习总结之六：Lucene打分公式的数学推导 Lucene关于实现Similarity自定义排序 Lucene的评分(score)机制的简单解释 [ solr扩展 ] MoreLikeThis的原理分析 Lucene相似搜索组件MoreLikeThis原理与代码分析 Lucene&Solr&ElasticSearch-面试题
推荐群组: lucene爱好者
更多相关推荐
Lucene
 
在solr中有两种方式实现MoreLikeThis：MoreLikeThisHandler和在SearchHandler中的MoreLikeThisComponent。
两种方式大同小异：
一是：将MoreLikeThis作为一个单独的Handler来处理,体现主体地位。
二是：将MoreLikeThis作为一个组件放到SearchHandler中,为Search加入了MLT的功能,是一种辅助功能。
 
这里我们借助方法一,来简单阐述MLT的实现步骤。
步骤1：
MLT是根据一篇文档（document）的相关字段进行“相似匹配”,例如：
http://localhost:8983/solr3.5/core0/mlt?q=id:82790&mlt.fl=ti,ab,mcn&mlt.mindf=1&mlt.mintf=1&fl=id,ti,score
这里我们提供的检索式为：q=id:82790,因此其只有唯一一个检索结果。
MLT第一步工作就是根据我们提供的检索式获取文档（document）。
 
步骤2：
MLT可以看成是一种特殊的检索,只是他的检索式是根据我们提供的一篇文档（document）生成的。
因此关键是怎么生成这个检索式！！！
MoreLikeThis.java public Query like(int docNum) throws IOException { if (fieldNames == null) { // gather list of valid fields from lucene Collection fields = ir .getFieldNames(IndexReader.FieldOption.INDEXED); fieldNames = fields.toArray(new String[fields.size()]); } return createQuery(retrieveTerms(docNum)); }
  在创建这个“神奇”的query之前,我们先要获得相关的原始term（retrieveTerms）。
  public PriorityQueue retrieveTerms(int docNum) throws IOException { Map termFreqMap = new HashMap(); for (int i = 0; i < fieldNames.length; i++) { String fieldName = fieldNames[i]; TermFreqVector vector = ir.getTermFreqVector(docNum, fieldName); // field does not store term vector info if (vector == null) { Document d = ir.document(docNum); String text[] = d.getValues(fieldName); if (text != null) { for (int j = 0; j < text.length; j++) { addTermFrequencies(new StringReader(text[j]), termFreqMap, fieldName); } } } else { addTermFrequencies(termFreqMap, vector); } } 　　return createQueue(termFreqMap); }
  首先获取每一个字段的TermFreqVector,然后将其添加到TermFrequencies中, 该过程是计算TF的过程 ,结果存放在map中,key为term,value为该term出现的次数（termFrequencies）。 在该过程中需要降噪,及去掉一些无关紧要的term,其判断方式如下：
  private boolean isNoiseWord(String term) { int len = term.length(); if (minWordLen > 0 && len < minWordLen) { return true; } if (maxWordLen > 0 && len > maxWordLen) { return true; } if (stopWords != null && stopWords.contains(term)) { return true; } return false; }
  主要两个依据：
1.term长度必须在minWordLen和maxWordLen范围内；
2.term不应出现在stopWords内。
我们再回到retrieveTerms方法中,他返回的是一个PriorityQueue,因此我们还要将之前创建的map（tf）进行一定的处理（重要）。
“Find words for a more-like-this query former.”
“Create a PriorityQueue from a word->tf map.”
该方法我们遍历所有的term,并取出其 tf 以及 在所有指定字段（例如：mlt.fl=ti,ab,mcn）中最大的df 。根据df和当前索引文档数计算idf,然后计算该term的score=tf*idf。 private PriorityQueue createQueue(Map words) throws IOException { // have collected all words in doc and their freqs int numDocs = ir.numDocs(); FreqQ res = new FreqQ(words.size()); // will order words by score Iterator it = words.keySet().iterator(); while (it.hasNext()) { // for every word String word = it.next(); int tf = words.get(word).x; // term freq in the source doc if (minTermFreq > 0 && tf < minTermFreq) { continue; // filter out words that don't occur enough times in the // source } // go through all the fields and find the largest document frequency String topField = fieldNames[0]; int docFreq = 0; for (int i = 0; i < fieldNames.length; i++) { int freq = ir.docFreq(new Term(fieldNames[i], word)); topField = (freq > docFreq) ? fieldNames[i] : topField; docFreq = (freq > docFreq) ? freq : docFreq; } if (minDocFreq > 0 && docFreq < minDocFreq) { continue; // filter out words that don't occur in enough docs } if (docFreq > maxDocFreq) { continue; // filter out words that occur in too many docs } if (docFreq == 0) { continue; // index update problem? } float idf = similarity.idf(docFreq, numDocs); float score = tf * idf; // only really need 1st 3 entries, other ones are for troubleshooting res.insertWithOverflow(new Object[] {word, // the word topField, // the top field Float.valueOf(score), // overall score Float.valueOf(idf), // idf Integer.valueOf(docFreq), // freq in all docs Integer.valueOf(tf)}); } return res; }
创建好PriorityQueue后,我们就可以将他转变成之前提到的那个“神奇”的query了。
“Create the More like query from a PriorityQueue”
构建一个BooleanQuery,按照score从大到小取出一定数量的term（maxQueryTerm）进行组建： private Query createQuery(PriorityQueue q) { BooleanQuery query = new BooleanQuery(); Object cur; int qterms = 0; float bestScore = 0; while (((cur = q.pop()) != null)) { Object[] ar = (Object[]) cur; TermQuery tq = new TermQuery(new Term((String) ar[1], (String) ar[0])); if (boost) { if (qterms == 0) { bestScore = ((Float) ar[2]).floatValue(); } float myScore = ((Float) ar[2]).floatValue(); tq.setBoost(boostFactor * myScore / bestScore); } try { query.add(tq, BooleanClause.Occur.SHOULD); } catch (BooleanQuery.TooManyClauses ignore) { break; } qterms++; if (maxQueryTerms > 0 && qterms >= maxQueryTerms) { break; } } return query; }
query.add(tq, BooleanClause.Occur.SHOULD);
这里简单理解就是——取出文档中（相关字段）最重要（tf*idf）的前N个term,组建一个BooleanQuery（Should关联）。
 
步骤3：
用第二步创建的query进行一次检索,取出得分最高的N篇文档即可。
 
原理分析： （1）在MLT中主要是tf、idf,根据score(tf*idf)获取对分类最重要的term,并构建目标Query。
MLT可以理解为：找出给定文档同一类的其他文档。
在一份给定的文件里, 词频 （term frequency,TF）指的是某一个给定的词语在该文件中出现的频率。这个数字是对 词数 (term count)的归一化,以防止它偏向长的文件。（同一个词语在长文件里可能会比短文件有更高的词数,而不管该词语重要与否。）对于在某一特定文件里的词语  t i  来说,它的重要性可表示为：
以上式子中  n i , j  是该词在文件 d j 中的出现次数,而分母则是在文件 d j 中所有字词的出现次数之和。
逆向文件频率 （inverse document frequency,IDF）是一个词语普遍重要性的度量。某一特定词语的IDF,可以由总文件数目除以包含该词语之文件的数目,再将得到的商取 对数 得到：
其中 |D|：语料库中的文件总数 ：包含词语 t i 的文件数目（即 的文件数目）如果该词语不在语料库中,就会导致被除数为零,因此一般情况下使用
然后
某一特定文件内的高词语频率,以及该词语在整个文件集合中的低文件频率,可以产生出高权重的TF-IDF。 因此,TF-IDF倾向于过滤掉常见的词语,保留重要的词语。
 
（2）根据提供的Query,利用lucene的打分算法,找到相似文档。
 Lucene 将信息检索中的Boolean model (BM)和Vector Space Model (VSM)联合起来,实现了自己的评分机制。
具体内容参见：
http://lucene.apache.org/core/old_versioned_docs/versions/2_9_1/api/core/org/apache/lucene/search/Similarity.html
  那么有哪些环节可以提高相似检索精度呢？ 1.降噪环节需要强化,目前solr中是基于term长度和停用此表联合过滤。
例如将term的最小长度限定成2,即单个字不能作为计算的term,例如：
ab:扩印 ab:胶卷 ab:印机 ab:彩色 ab:传动轴 ab:两根 ab:垫板 ab:手轮 ab:齿轮 ab:从动 ab:传动 ab:设置 ab:自动 ab:电动机 mcn:g03b27/46 ab:电动 ab:上片 ab:上手 ab:支撑 ab:精确度 ab:动机 ab:压片 ab:以及 ab:机构 ab:下压
2.提高分词器的精度,并且对于行业性的业务最好提供行业性的词库,并且进行人工维护。
 
3.调整、改进相似度算法。
简单的我们试试将term的数量（构建目标query的term数量）进行控制,设置成10。例如：
ab:扩印 ab:胶卷 ab:印机 ab:彩色 ab:传动轴 ab:两根 ab:垫板 ab:手轮 ab:齿轮 ab:从动 以上实例只是一个简单说明,更多调整（挑战）还需要在实践中具体分析。
 
 
 
 
 
 
 

相关推荐: solr1.3新特性,solrj的使用 [ solr - MoreLikeThis ] - MoreLikeThis的原理分析 如何在eclipse中部署solr的web工程？ Apache-Solr-Reference-Guide-v3.5 windows环境 solr-7.4.0安装【一篇就够】 Solr-5.3.1安装配置 solr-7.4.0 启动报错 已解决 Linux环境之solr-7.7.0的搭建配置
推荐群组: solr交流圈
更多相关推荐
Lucene

solr-searching过程分析（一）
——searching过程粗略梳理
下午看了一会solr的启动过程,往细的看相当繁琐。换个头绪先看看solr的searching过程。
1.拦截请求,解析请求并构建相应的handler。
发送检索请求,例如： http://localhost:8983/solr3.5/core2/select/?q=*%3A*&version=2.2&start=0&rows=10&indent=on
首先他将被SolrDispatchFilter拦截。 doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
 
通过对request的分析,获知当前request是做什么的（/select）,并构造相应的handler（SearchHandler）。
 
2.SolrCore出面处理上层工作（具体工作交由handler处理）
将handler、SolrQueryRequest、SolrQueryResponse交由solrCore的execute方法处理 public void execute(SolrRequestHandler handler, SolrQueryRequest req, SolrQueryResponse rsp)
  在该方法中主要还是由handler来完成的。 SolrRequestHandler是一个接口,他主要的方法就是： SolrRequestHandler的实现类的结构图如下： public void handleRequest(SolrQueryRequest req, SolrQueryResponse rsp);    其中RequestHandlerBase为大部分的Handler实现了部分功能,主要包括 public void handleRequest(SolrQueryRequest req, SolrQueryResponse rsp){ 　　...... 　　handleRequestBody( req, rsp ); 　　...... }
然而具体怎么做就交给具体的子类去执行了！（handleRequestBody( req, rsp );） 例如：这里是做检索,那么就交由SearchHandler处理。 （这里的设计方式有点类似于servlet,GenericSerlet实现了一些公用方法,而具体的则有其子类完成,例如HttpServlet）
 
3.SearchHandler具体的检索过程
现在的检索没有使用shards,在跟踪代码的过程中,发现以下过程是检索的主要环节。 if(!rb.isDebug()) { // Process for( SearchComponent c : components ) { c.process(rb); } }
从中可知真正的检索需要经过多个SearchComponent,在当前的实验环境下包括6个,如下：  
4.各个SearchComponent配合工作完成检索
我们先重点了解QueryComponent。
获得SolrIndexSearcher,这个对象是检索的主要执行者。
同时获取SolrIndexSearcher.QueryCommand、SolrIndexSearcher.QueryResult,并将其作为查询条件和查询结果提交给SolrIndexSearcher进行检索。 searcher.search(result,cmd);
在SolrIndexSearcher中search方法如下： public QueryResult search(QueryResult qr, QueryCommand cmd) throws IOException { getDocListC(qr,cmd); return qr; }    getDocListC又是一个比较复杂的方法,在这里加入的cache。
如果当前检索被缓存了（缓存也是个重点内容,后续详细分析！）,那么直接返回结果,否则重新进行检索,检索的方法是： private void getDocListNC(QueryResult qr,QueryCommand cmd)   在该方法中,和我们使用lucene进行检索十分相似,采用的具体方法是： super.search(query, luceneFilter, collector);   检索完成将结果进行封装,放入QueryResult当中。 qr.setDocList(new DocSlice(0,sliceLen,ids,scores,totalHits,maxScore));  
检索完成后,将结果放入缓存中,“造福后人”！
至此QueryComponent的工作就算完成了。
如果做简单查询（如： http://localhost:8983/solr3.5/core2/select/?q=*%3A*&version=2.2&start=0&rows=10&indent=on ）
那么后面5个Component就直接过了（没有真正被执行）。
 
5.收尾工作
将结果封装好,写入相应的ResponseHeaders,关闭SolrQueryRequest、solrCore。
-----------------------------------------------------
以上是solr-searching最粗略的过程,本着先脉络后细节的思想,以后再对各个重要环节做深入分析。
searching主要执行方法如下：
SolrDispatchFilter（doFilter,execute）
->SolrCore(execute)
->RequestHandlerBase(handleRequest)
->SearchHandler(handleRequestBody) //有可能执行多个Component
->QueryComponent(process)
->SolrIndexSearcher(search,getDocListC)
 
 
 
 
 

youarestupid 写道
selvemen 写道 public class WaterMarkUtils { /** * 给图片添加水印 * * @param filePath 需要添加水印的图片的路径 * @param markContent 水印的文字 * @param markContentColor 水印文字的颜色 * @param qualNum 图片质量 * @return */ public void mark(String srcImgPath, String outImgPath, String watermarkStr) { try { // 读取原图片信息 File srcImgFile = new File(srcImgPath); Image srcImg = ImageIO.read(srcImgFile); int srcImgWidth = srcImg.getWidth(null); int srcImgHeight = srcImg.getHeight(null); // 加水印 BufferedImage bufImg = new BufferedImage(srcImgWidth, srcImgHeight, BufferedImage.TYPE_INT_RGB); Graphics2D g = bufImg.createGraphics(); g.drawImage(srcImg, 0, 0, srcImgWidth, srcImgHeight, null); Font font = new Font("宋体", Font.PLAIN, 50); g.setColor(Color.gray); // 根据图片的背景设置水印颜色 g.setFont(font); int x = (srcImgWidth - getWatermarkLength(watermarkStr, g)) / 2; int y = srcImgHeight / 2; g.drawString(watermarkStr, x, y); g.dispose(); // 输出图片 FileOutputStream outImgStream = new FileOutputStream(outImgPath); ImageIO.write(bufImg, "jpg", outImgStream); outImgStream.flush(); outImgStream.close(); } catch (Exception e) { e.printStackTrace(); } } // 获取水印文字总长度 public int getWatermarkLength(String str, Graphics2D g) { return g.getFontMetrics(g.getFont()).charsWidth(str.toCharArray(), 0, str.length()); } public static void main(String[] args) { // 原图位置, 输出图片位置, 水印文字 new WaterMarkUtils().mark("c://12.jpg", "c://watermark.jpg", "水印就是这样的!!!!"); } }
有没有加水印图片的。 public final class WaterMark { private static List logoImgs; private static List bgImgs; private static boolean flag; public static List getBgImgs() { return bgImgs; } /** * 把图片印刷到图片上 * * @param pressImg -- * 水印文件 * @param targetImg -- * 目标文件 * @param x * --x坐标 * @param y * --y坐标 * @param out * 输出流(可以来自HttpServletReponse的输出) */ public final static void pressImage(String pressImg, String targetImg, int x, int y,OutputStream out) { try { //目标文件 File _file = new File(targetImg); Image src = ImageIO.read(_file); int wideth = src.getWidth(null); int height = src.getHeight(null); BufferedImage image = new BufferedImage(wideth, height, BufferedImage.TYPE_INT_RGB); Graphics g = image.createGraphics(); g.drawImage(src, 0, 0, wideth, height, null); //水印文件 File _filebiao = new File(pressImg); Image src_biao = ImageIO.read(_filebiao); int wideth_biao = src_biao.getWidth(null); int height_biao = src_biao.getHeight(null); g.drawImage(src_biao, (wideth - wideth_biao) / 2, (height - height_biao) / 2, wideth_biao, height_biao, null); //水印文件结束 g.dispose(); JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out); encoder.encode(image); out.close(); } catch (Exception e) { e.printStackTrace(); } } /** * 打印文字水印图片 * * @param pressText * --文字 * @param targetImg -- * 目标图片 * @param fontName -- * 字体名 * @param fontStyle -- * 字体样式 * @param color -- * 字体颜色 * @param fontSize -- * 字体大小 * @param x -- * 偏移量(从右下角算起) * @param y -- * 偏移量(从右下角算起) * * @param out * 输出流(可以来自HttpServletReponse的输出) */ public static void pressText(String pressText, String targetImg, String fontName, int fontStyle, int color, int fontSize, int x, int y,OutputStream out) { try { File _file = new File(targetImg); Image src = ImageIO.read(_file); int wideth = src.getWidth(null); int height = src.getHeight(null); BufferedImage image = new BufferedImage(wideth, height, BufferedImage.TYPE_INT_RGB); Graphics g = image.createGraphics(); g.drawImage(src, 0, 0, wideth, height, null); g.setColor(new Color(color)); g.setFont(new Font(fontName, fontStyle, fontSize)); g.drawString(pressText, wideth - fontSize - x, height - fontSize / 2 - y); g.dispose(); JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out); encoder.encode(image); out.close(); } catch (Exception e) { System.out.println(e); } } /** * 设置背景水印图片的路径并把图片加载到内存 * * @param bgImgUrls * 背景水印图片的相对路径集合 * @param path * 图片组所在的文件夹路径 */ public static void setBgImgs(List bgImgUrls, String path) { bgImgs = new ArrayList(); for (Iterator it = bgImgUrls.iterator(); it.hasNext();) { String tem = (String) it.next(); ImageIcon waterIcon = new ImageIcon(path + tem); bgImgs.add(waterIcon.getImage()); } } public static List getLogoImgs() { return logoImgs; } /** * 设置图标水印图片的路径并把图片加载到内存 * * @param logoImgUrls * 图标水印图片的相对路径集合 * @param path * 图片组所在的文件夹路径 */ public static void setLogoImgs(List logoImgUrls, String path) { logoImgs = new ArrayList(); for (Iterator it = logoImgUrls.iterator(); it.hasNext();) { String tem = (String) it.next(); ImageIcon waterIcon = new ImageIcon(path + tem); logoImgs.add(waterIcon.getImage()); } } /** * 图片中添加图标水印并输出到指定流 * * @param data * @param out * @param channel * @return * @throws Exception */ public static boolean createLogoMark(byte[] data, FileOutputStream out, String channel) throws Exception { int i = (int) (logoImgs.size() * Math.random()); return createMark(data, out, (Image) logoImgs.get(i), true); } /** */ /** * 图片中添加背景水印并输出到指定流 * * @param data * @param out * @param channelName * @return * @throws Exception */ public static boolean createBgMark(byte[] data, FileOutputStream out, String channelName) throws Exception { int i = (int) (bgImgs.size() * Math.random()); return createMark(data, out, (Image) bgImgs.get(i), false); } /** * 生成随机水印并输出到指定流 * * @param data * @param out * @return * @throws Exception */ public static boolean createRandomMark(byte[] data, FileOutputStream out) throws Exception { int i = 0; Image temImg = null; if (!flag) { i = (int) (logoImgs.size() * Math.random()); temImg = (Image) logoImgs.get(i); } else { i = (int) (bgImgs.size() * Math.random()); temImg = (Image) bgImgs.get(i); } flag = !flag; return createMark(data, out, temImg, flag); } /** * 生成水印并输出到指定流 * * @param data * @param out * @param waterImg * 水印图片的类型（背景或图标）,应与isLogoImg参数一致 * @param isLogoImg * 等于true 时生成图标水印,否则为背景水印 * @return * @throws Exception */ private static boolean createMark(byte[] data, FileOutputStream out, Image waterImg, boolean isLogoImg) throws Exception { ImageIcon imgIcon = new ImageIcon(data); Image theImg = imgIcon.getImage(); int width = theImg.getWidth(null); int height = theImg.getHeight(null); if (width < 200 || height < 200) {// 小图片不加水印真接输入,如头像图片 BufferedOutputStream fout = null; ByteArrayInputStream in = new ByteArrayInputStream(data); try { byte[] b = new byte[1024 * 10]; fout = new BufferedOutputStream(out); while (in.read(b) > 0) { out.write(b); } out.flush(); out.close(); in.close(); return true; } catch (Exception e) { e.printStackTrace(); throw e; } } return false; } }

master-slave架构对于频繁更新的索引不实用,期待SolrCloud。
macrochen 写道
原文: http://java.dzone.com/articles/lucene-solr-year-2011-review
2011年已经过去, 在这里针对本年lucene和solr领域发生的点点滴滴进行一下回顾, 也算是对lucene和solr的一个盘点.
lucene成为apache基金会项目已逾十年(实际上lucene存在的历史已超过10年), solr 作为apache基金项目也差不多度过了六个春秋. 而这两个项目的发展离不开Otis( http://twitter.com/otisg )的长期努力.
在这一年里, solr和lucene发生了非常显著的变化, 增加了大量新的功能, 而这个变化可以说超过以往任何一年.
其中最激动人心的功能莫过于近实时搜索功能(Near Real-Time search http://search-lucene.com/?q=NRT )的实现, 即对文档的修改会立马出现在搜索结果中. 虽然NRT依然还在继续改进中, 但是很多用户已经开始使用该功能.
字段折叠(Field Collapsing http://wiki.apache.org/solr/FieldCollapsing ) 也是solr社区中长期以来期待的一个功能. 这个功能已在今年实现. 现在solr和lucene用户可以基于字段和查询条件对结果集进行进行分组. 并实现了对分组进行控制. 此外还可以基于分组进行facet运算(而以前只能基于文档).
在这一年, lucene也引入了faceting module( https://issues.apache.org/jira/browse/LUCENE-3079 ), 从此以后, facet将不再是solr的专利. lucene用户可以进行facet运算了.
从今年开始, 你可以通过使用Join module( http://wiki.apache.org/solr/Join ) 对父子关联的文档建索引, 这样我们可以在查询的过程中根据文档索引将父子文档进行连接.
2011年, 在多语言支持方面( http://wiki.apache.org/solr/LanguageAnalysis#Stemming ) ,solr和lucene也取得了重大突破: 加入了KStemFilter English stemmer( http://wiki.apache.org/solr/LanguageAnalysis#Notes_about_solr.KStemFilterFactory ) , 提供了对Unicode 4完整的支持, 增加了对中文和日文的支持, 增加了一个新的stemmer保护机制. 降低了synonym filter对内存的消耗. 其中最大的一个增强是集成了Hunspell( http://wiki.apache.org/solr/LanguageAnalysis#Notes_about_solr.HunspellStemFilterFactory ), 这样可以使用OpenOffice所支持的语言进行stemming处理.
lucene 3.5.0的发布, 大幅度的降低了term词典的内存消耗(在对term词典处理时, 比以前减少了3~5倍).
以前在使用lucene的时候, 如果对大数据量的搜索结果进行分页处理, 从头翻到尾会出现问题. 而在lucene 3.5.0这个版本, 通过引入searchAfter方法进行了彻底的解决.
在这一年, lucene和solr提供了一个新的, 更高效, 更可靠的基于Term Vector的高亮功能.
在这一年, solr集成了扩展的Dismax查询解析器( http://search-lucene.com/?q=Extended+Dismax ), 进一步提高了搜索结果的质量.
这一年, 你可以使用函数( http://wiki.apache.org/solr/FunctionQuery#Sort_By_Function )对搜索结果进行排序(比如根据某个值到指定点的距离进行排序), 并且提供了一个新的根据空间搜索过滤器.
solr也提供了一个新的, 基于FST机器人(可以显著的降低内存消耗)的suggest ( http://wiki.apache.org/solr/Suggester )/自动完成搜索功能, 如果你对这个功能感兴趣, 可以关注一下Sematext ( http://sematext.com/products/autocomplete/index.html )提供的自动完成搜索功能.
这里还需要提到的就是solr即将提供的新的事务日志(transaction log https://issues.apache.org/jira/browse/SOLR-2700 )支持, 该支持将实现实时返回(real-time get https://issues.apache.org/jira/browse/SOLR-2656 )的功能, 即在添加一个文档之后你能立即根据id返回该文档. 事务日志也将用于SolrCloud分布式节点的恢复.
说到SolrCloud( http://wiki.apache.org/solr/SolrCloud ) 这里( http://blog.sematext.com/2011/09/14/solr-digest-spring-summer-2011-part-2-solr-cloud-and-near-real-time-search/ )还有一篇介绍. 对于SolrCloud, 用一句话来概括, 就是运用最新的设计原则并借助其他软件模块(比如zookeeper)更快速的搭建一套更强大solr分布式集群. 其核心思想就是拒绝单点故障, 采用中心化的集群和配置管理, 打破原有的master-slave架构, 做到容灾自动切换和动态调整.
2010年将两个项目的开发进行整合之后, 这两个项目的发展非常迅猛. 在2011年, lucene和solr在众多committer们的大力支持下发布了5个版本. 三月, lucene和solr 3.1版本发布, 3个月后的6月4日, 3.2版本发布. 一个月之后, 7月1日, lucene和solr 3.3版本发布. 9月14日, 3.4版本发布, 11月, 3.5.0版本顺利发布.
在2011年, lucene和solr相关的会议也不少, 首先登场是是5月份在旧金山举行的Lucene Revolution, otis在大会上做了题为"Search Analytics: What? Why? How?"( http://java.dzone.com/articles/lucene-solr-year-2011-review )的演讲, 其他干货猛击这里 ( http://lucenerevolution.com/2011/agenda ) . 在六月份的Buzzwords大会上, otis在大会上做了"Search Analytics: What? Why? How?"的升级版演讲. 相关资料可参考官方网站: http://berlinbuzzwords.de . 10月份, 在巴塞罗那举行了专门针对lucene和solr的 Lucene Eurocon 2011 大会. Otis 在大会上做了主题为"Search Analytics: Business Value & BigData NoSQL Backend"( http://www.lucidimagination.com/sites/default/files/file/Eurocon2011/otis_gospodnetic_search_analytics_lucene_eurocon_2011.ppt )的主题演讲, 而Rafał( http://twitter.com//kucrafal )在大会上做了"Explaining & Visualizing Solr 'explain' information"( http://www.lucidimagination.com/sites/default/files/file/Eurocon2011/Understanding%20and%20Visualizing%20Solr%20Explain%20information%20-%20Solr.pl%20-%20version%202.pdf )的演讲.
在2011年, lucene和solr又迎来了一批新的志同道合者:
•Andi Vajda
•Chris Male
•Dawid Weiss
•Erick Erickson
•Jan Høydahl
•Martin van Groningen
•Stanisław Osiński
对于一个成功的开源项目, 相关的图书对使用者也是必不可少. 虽然今年Lucene in Action没有推出新的版本, 但是Rafał Kuć在今年7月给我们带来了它的新作"Solr 3.1 Cookbook". 在该书中, 为解决solr的一些常见问题, Rafał给出了他的答案. 而David Smiley 和 Eric Pugh在今年十一月推出了"Apache Solr 3 Enterprise Search Server"的新版本.
至于2012年, lucene和solr会带来什么新的惊喜, 让我们拭目以待.

相关推荐: Lucene 入门与实战 lucene3.0学习笔记2-(再学Lucene的简单例子) 搜索篇：lucene简单实例<二> SSM整合进阶项目实战-个人博客系统 Lucene入门实例 lucene入门实例 Apache Lucene3.0 入门实例介绍 Lucene学习笔记（一）Lucene入门实例
推荐群组: 中文分词
更多相关推荐
企业应用 Lucene Lucene 简介 Lucene 是一个基于 Java 的全文信息检索工具包,它不是一个完整的搜索应用程序,而是为你的应用程序提供索引和搜索功能。Lucene 目前是 Apache Jakarta 家族中的一个开源项目。也是目前最为流行的基于 Java 开源全文检索工具包。 目前已经有很多应用程序的搜索功能是基于 Lucene 的,比如 Eclipse 的帮助系统的搜索功能。Lucene 能够为文本类型的数据建立索引,所以你只要能把你要索引的数据格式转化的文本的,Lucene 就能对你的文档进行索引和搜索。比如你要对一些 HTML 文档,PDF 文档进行索引的话你就首先需要把 HTML 文档和 PDF 文档转化成文本格式的,然后将转化后的内容交给 Lucene 进行索引,然后把创建好的索引文件保存到磁盘或者内存中,最后根据用户输入的查询条件在索引文件上进行查询。不指定要索引的文档的格式也使 Lucene 能够几乎适用于所有的搜索应用程序。 图 1 表示了搜索应用程序和 Lucene 之间的关系,也反映了利用 Lucene 构建搜索应用程序的流程： 索引和搜索 索引是现代搜索引擎的核心,建立索引的过程就是把源数据处理成非常方便查询的索引文件的过程。为什么索引这么重要呢,试想你现在要在大量的文档中搜索含有某个关键词的文档,那么如果不建立索引的话你就需要把这些文档顺序的读入内存,然后检查这个文章中是不是含有要查找的关键词,这样的话就会耗费非常多的时间,想想搜索引擎可是在毫秒级的时间内查找出要搜索的结果的。这就是由于建立了索引的原因,你可以把索引想象成这样一种数据结构,他能够使你快速的随机访问存储在索引中的关键词,进而找到该关键词所关联的文档。Lucene 采用的是一种称为反向索引（inverted index）的机制。反向索引就是说我们维护了一个词 / 短语表,对于这个表中的每个词 / 短语,都有一个链表描述了有哪些文档包含了这个词 / 短语。这样在用户输入查询条件的时候,就能非常快的得到搜索结果。我们将在本系列文章的第二部分详细介绍 Lucene 的索引机制,由于 Lucene 提供了简单易用的 API,所以即使读者刚开始对全文本进行索引的机制并不太了解,也可以非常容易的使用 Lucene 对你的文档实现索引。 对文档建立好索引后,就可以在这些索引上面进行搜索了。搜索引擎首先会对搜索的关键词进行解析,然后再在建立好的索引上面进行查找,最终返回和用户输入的关键词相关联的文档。 Lucene 软件包分析 Lucene 软件包的发布形式是一个 JAR 文件,下面我们分析一下这个 JAR 文件里面的主要的 JAVA 包,使读者对之有个初步的了解。 Package: org.apache.lucene.document 这个包提供了一些为封装要索引的文档所需要的类,比如 Document, Field。这样,每一个文档最终被封装成了一个 Document 对象。 Package: org.apache.lucene.analysis 这个包主要功能是对文档进行分词,因为文档在建立索引之前必须要进行分词,所以这个包的作用可以看成是为建立索引做准备工作。 Package: org.apache.lucene.index 这个包提供了一些类来协助创建索引以及对创建好的索引进行更新。这里面有两个基础的类：IndexWriter 和 IndexReader,其中 IndexWriter 是用来创建索引并添加文档到索引中的,IndexReader 是用来删除索引中的文档的。 Package: org.apache.lucene.search 这个包提供了对在建立好的索引上进行搜索所需要的类。比如 IndexSearcher 和 Hits, IndexSearcher 定义了在指定的索引上进行搜索的方法,Hits 用来保存搜索得到的结果。 一个简单的搜索应用程序 假设我们的电脑的目录中含有很多文本文档,我们需要查找哪些文档含有某个关键词。为了实现这种功能,我们首先利用 Lucene 对这个目录中的文档建立索引,然后在建立好的索引中搜索我们所要查找的文档。通过这个例子读者会对如何利用 Lucene 构建自己的搜索应用程序有个比较清楚的认识。 建立索引 为了对文档进行索引,Lucene 提供了五个基础的类,他们分别是 Document, Field, IndexWriter, Analyzer, Directory。下面我们分别介绍一下这五个类的用途： Document Document 是用来描述文档的,这里的文档可以指一个 HTML 页面,一封电子邮件,或者是一个文本文件。一个 Document 对象由多个 Field 对象组成的。可以把一个 Document 对象想象成数据库中的一个记录,而每个 Field 对象就是记录的一个字段。 Field Field 对象是用来描述一个文档的某个属性的,比如一封电子邮件的标题和内容可以用两个 Field 对象分别描述。 Analyzer 在一个文档被索引之前,首先需要对文档内容进行分词处理,这部分工作就是由 Analyzer 来做的。Analyzer 类是一个抽象类,它有多个实现。针对不同的语言和应用需要选择适合的 Analyzer。Analyzer 把分词后的内容交给 IndexWriter 来建立索引。 IndexWriter IndexWriter 是 Lucene 用来创建索引的一个核心的类,他的作用是把一个个的 Document 对象加到索引中来。 Directory 这个类代表了 Lucene 的索引的存储的位置,这是一个抽象类,它目前有两个实现,第一个是 FSDirectory,它表示一个存储在文件系统中的索引的位置。第二个是 RAMDirectory,它表示一个存储在内存当中的索引的位置。 熟悉了建立索引所需要的这些类后,我们就开始对某个目录下面的文本文件建立索引了,清单 1 给出了对某个目录下的文本文件建立索引的源代码。 对文本文件建立索引 package TestLucene; import java.io.File; import java.io.FileReader; import java.io.Reader; import java.util.Date; 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; import org.apache.lucene.index.IndexWriter; /** * This class demonstrate the process of creating index with Lucene * for text files */ public class TxtFileIndexer { public static void main(String[] args) throws Exception{ //indexDir is the directory that hosts Lucene's index files File indexDir = new File("D:\\luceneIndex"); //dataDir is the directory that hosts the text files that to be indexed File dataDir = new File("D:\\luceneData"); Analyzer luceneAnalyzer = new StandardAnalyzer(); File[] dataFiles = dataDir.listFiles(); IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true); long startTime = new Date().getTime(); for(int i = 0; i < dataFiles.length; i++){ if(dataFiles[i].isFile() && dataFiles[i].getName().endsWith(".txt")){ System.out.println("Indexing file " + dataFiles[i].getCanonicalPath()); Document document = new Document(); Reader txtReader = new FileReader(dataFiles[i]); document.add(Field.Text("path",dataFiles[i].getCanonicalPath())); document.add(Field.Text("contents",txtReader)); indexWriter.addDocument(document); } } indexWriter.optimize(); indexWriter.close(); long endTime = new Date().getTime(); System.out.println("It takes " + (endTime - startTime) + " milliseconds to create index for the files in directory " + dataDir.getPath()); } } 以上代码中我们注意到类 IndexWriter 的构造函数需要三个参数,第一个参数指定了所创建的索引要存放的位置,他可以是一个 File 对象,也可以是一个 FSDirectory 对象或者 RAMDirectory 对象。第二个参数指定了 Analyzer 类的一个实现,也就是指定这个索引是用哪个分词器对文挡内容进行分词。第三个参数是一个布尔型的变量,如果为 true 的话就代表创建一个新的索引,为 false 的话就代表在原来索引的基础上进行操作。接着程序遍历了目录下面的所有文本文档,并为每一个文本文档创建了一个 Document 对象。然后把文本文档的两个属性：路径和内容加入到了两个 Field 对象中,接着在把这两个 Field 对象加入到 Document 对象中,最后把这个文档用 IndexWriter 类的 add 方法加入到索引中去。这样我们便完成了索引的创建。接下来我们进入在建立好的索引上进行搜索的部分。 搜索文档 利用 Lucene 进行搜索就像建立索引一样也是非常方便的。在上面一部分中,我们已经为一个目录下的文本文档建立好了索引,现在我们就要在这个索引上进行搜索以找到包含某个关键词或短语的文档。Lucene 提供了几个基础的类来完成这个过程,它们分别是呢 IndexSearcher, Term, Query, TermQuery, Hits. 下面我们分别介绍这几个类的功能。 Query 这是一个抽象类,他有多个实现,比如 TermQuery, BooleanQuery, PrefixQuery. 这个类的目的是把用户输入的查询字符串封装成 Lucene 能够识别的 Query。 Term Term 是搜索的基本单位,一个 Term 对象有两个 String 类型的域组成。生成一个 Term 对象可以有如下一条语句来完成：Term term = new Term(“fieldName”,”queryWord”); 其中第一个参数代表了要在文档的哪一个 Field 上进行查找,第二个参数代表了要查询的关键词。 TermQuery TermQuery 是抽象类 Query 的一个子类,它同时也是 Lucene 支持的最为基本的一个查询类。生成一个 TermQuery 对象由如下语句完成： TermQuery termQuery = new TermQuery(new Term(“fieldName”,”queryWord”)); 它的构造函数只接受一个参数,那就是一个 Term 对象。 IndexSearcher IndexSearcher 是用来在建立好的索引上进行搜索的。它只能以只读的方式打开一个索引,所以可以有多个 IndexSearcher 的实例在一个索引上进行操作。 Hits Hits 是用来保存搜索的结果的。 介绍完这些搜索所必须的类之后,我们就开始在之前所建立的索引上进行搜索了,清单 2 给出了完成搜索功能所需要的代码。 在建立好的索引上进行搜索 package TestLucene; import java.io.File; import org.apache.lucene.document.Document; import org.apache.lucene.index.Term; import org.apache.lucene.search.Hits; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.TermQuery; import org.apache.lucene.store.FSDirectory; /** * This class is used to demonstrate the * process of searching on an existing * Lucene index * */ public class TxtFileSearcher { public static void main(String[] args) throws Exception{ String queryStr = "lucene"; //This is the directory that hosts the Lucene index File indexDir = new File("D:\\luceneIndex"); FSDirectory directory = FSDirectory.getDirectory(indexDir,false); IndexSearcher searcher = new IndexSearcher(directory); if(!indexDir.exists()){ System.out.println("The Lucene index is not exist"); return; } Term term = new Term("contents",queryStr.toLowerCase()); TermQuery luceneQuery = new TermQuery(term); Hits hits = searcher.search(luceneQuery); for(int i = 0; i < hits.length(); i++){ Document document = hits.doc(i); System.out.println("File: " + document.get("path")); } searcher.close(); } } 以上代码中,类 IndexSearcher 的构造函数接受一个类型为 Directory 的对象,Directory 是一个抽象类,它目前有两个子类：FSDirctory 和 RAMDirectory. 我们的程序中传入了一个 FSDirctory 对象作为其参数,代表了一个存储在磁盘上的索引的位置。构造函数执行完成后,代表了这个 IndexSearcher 以只读的方式打开了一个索引。然后我们程序构造了一个 Term 对象,通过这个 Term 对象,我们指定了要在文档的内容中搜索包含关键词”lucene”的文档。接着利用这个 Term 对象构造出 TermQuery 对象并把这个 TermQuery 对象传入到 IndexSearcher 的 search 方法中进行查询,返回的结果保存在 Hits 对象中。最后我们用了一个循环语句把搜索到的文档的路径都打印了出来。好了,我们的搜索应用程序已经开发完毕,怎么样,利用 Lucene 开发搜索应用程序是不是很简单。 总结 本文首先介绍了 Lucene 的一些基本概念,然后开发了一个应用程序演示了利用 Lucene 建立索引并在该索引上进行搜索的过程。希望本文能够为学习 Lucene 的读者提供帮助。 Lucene下载地址： http://apache.oregonstate.edu/lucene/java/ 之前有童鞋下载不到包,请到这篇博文的附件下载jar包： http://rwg109.iteye.com/blog/840630

相关推荐: 学习xpath的天堂!! javascript基础知识大集锦(1) Javascript正则表达式笔记 Lucene CSV import 先后顺序 Lucene:为文本文件创建索引 neo4j︱neo4j批量导入neo4j-import （五） Lucene从入门到进阶（6.6.0版本） Lucene 分词 统计分词次数
推荐群组: solr交流圈
更多相关推荐
搜索引擎 Lucene
 
curl "http://localhost:8080/solr/update/csv?stream.file=../solr/docs/books.csv&stream.contentType=text/plain;charset=utf-8&commit=true&fieldnames=id,manu,cat&header=true& f.cat.map=AAA:BBB & keepEmpty=true & f.cat.split=true&f.cat.separator=%20 "
 
请求顺序如下：
  keepEmpty=true f.cat.split=true&f.cat.separator=%20 f.cat.map=AAA:BBB
e.g.
 
CVS:
 
cat ___ AAA ___
_ 代表空格   AAA前后都有三个空格
 
Result XML:
 
 




BBB




 
 
 
 
 
 
 
 
 

相关推荐: 开放源代码的全文检索引擎Lucene(转载） Lucene学习笔记【2013-04-10更新】 搜索篇：lucene简单实例<二> LuceneInAction(第2版)_中文版 Lucene基本使用和代码实现 Lucene学习教程——Lucene介绍 Lucene 开源项目Lucene的架构详细解析----用软件构架分析的方法
推荐群组: lucene爱好者
更多相关推荐
Lucene 编程综合 理解Lucene系统结构的另一个方式是去探讨其中数据流的走向,并以此摸清楚Lucene系统内部的调用时序。在此基础上,我们能够更加深入的理解Lucene的系统结构组织,以方便以后在Lucene系统上的开发工作。这部分的分析,是深入Lucene系统的钥匙,也是进行重写的基础。 我们来看看在Lucene系统中的主要的数据流以及它们之间的关系图 上图很好的表明了Lucene在内部的数据流组织情况,并且沿着数据流的方向我们也可以对与Lucene内部的执行时序有一个清楚的了解。 现在将图中的涉及到的流的类型与各个逻辑对应系统的相关部分的关系说明一下。 图中共存在4种数据流,分别是文本流、token流、字节流与查询语句对象流。文本流表示了对于索引目标和交互控制的抽象,即用文本流表示了将要索引的文件,用文本流向用户输出信息；在实际的实现中,Lucene中的文本流采用了UCS-2作为编码,以达到适应多种语言文字的处理的目的。 Token流是Lucene内部所使用的概念,是对传统文字中的词的概念的抽象,也是Lucene在建立索引时直接处理的最小单位；简单的讲Token就是一个词和所在域值的组合,后面在叙述文件格式时也将继续涉及到token,这里不详细展开。 字节流则是对文件抽象的直接操作的体现,通过固定长度的字节（Lucene定义为8比特位长,后面文件格式将详细叙述）流的处理,将文件操作解脱出来,也做到了与平台文件系统的无关性。 查询语句对象流则是仅仅在查询语句解析时用到的概念,它对查询语句抽象,通过类的继承结构反映查询语句的结构,将之传送到查找逻辑来进行查找的操作。 图中的涉及到了多种逻辑,基本上直接对应于系统某一模块,但是也有跨模块调用的问题发生,这是因为Lucene的重用程度非常好,因此很多实现直接调用了以前的工作成果,这在某种程度上其实是加强了模块耦合性,但是也是为了避免系统的过于庞大和不必要的重复设计的一种折衷体现。 词法分析逻辑对应于org.apache.lucene.analysis部分。 查询语句语法分析逻辑对应于org.apache.lucene.queryParser部分,并且调用了org.apache.lucene.analysis的代码。查询结束之后向评分排序逻辑输出token流,继而由评分排序逻辑处理之后给出文本流的结果,这一部分的实现也包含在了org.apache.lucene.search中。 索引构建逻辑对应于org.apache.lucene.index部分。 索引查找逻辑则主要是org.apache.lucene.search,但是也大量的使用了org.apache.lucene.index部分的代码和接口定义。存储抽象对应于org.apache.lucene.store。 没有提到的模块则是做为系统公共基础设施存在。 Lucene 数据流分析 http://www.ossez.com/forum.php?mod=viewthread&tid=11988&fromuid=426

相关推荐: lucene ssh框架项目实例：Lucene中文分词、分页查询 Lucene中文分词、分页查询、高亮显示 Lucene入门,小例子,笔记 一个Lucene3.0.3 高亮显示实例 全文检索 使用最新lucene3.0.3+最新盘古分词 pangu2.4 .net 实例 lucene3.0 Lucene实现索引和查询 Apache Lucene 3.x推荐教程
推荐群组: lucene爱好者
更多相关推荐
搜索引擎 Lucene 一个没有索引,直接使用高亮显示的实例：使用的时候请注意lucene与highlighter的版本。本实例使用的是： lucene3.0.3 lucene-highlighter-3.0.3 package com.hpjianhua.lucene; import java.io.StringReader; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.index.Term; import org.apache.lucene.queryParser.QueryParser; import org.apache.lucene.search.Query; import org.apache.lucene.search.Scorer; import org.apache.lucene.search.TermQuery; import org.apache.lucene.search.highlight.Highlighter; import org.apache.lucene.search.highlight.QueryScorer; import org.apache.lucene.search.highlight.SimpleHTMLFormatter; import org.apache.lucene.util.Version; import org.wltea.analyzer.lucene.IKAnalyzer; /** * * @author hpjianhua * @version 1.0 * */ public class HighlighterTester { public static void main(String[] args) throws Exception { String text = "flower:A man can fail many times, but he isn't a failure until he begins to blame somebody else.flower wirter"; QueryParser parser = new QueryParser(Version.LUCENE_30, "field", new StandardAnalyzer(Version.LUCENE_30)); Query query = parser.parse("flower"); SimpleHTMLFormatter formatter = new SimpleHTMLFormatter("",""); Highlighter highlight = new Highlighter(formatter, new QueryScorer(query)); TokenStream tokens = new IKAnalyzer().tokenStream("field", new StringReader(text)); System.out.println(highlight.getBestFragment(tokens, text)); } } output: flower:A man can fail many times, but he isn't a failure until he begins to blame somebody jar包见下面：

相关推荐: Lucene简单入门示例 lucene3.0学习笔记2-(再学Lucene的简单例子) lucene为什么查不出结果 LuceneInAction(第2版)_中文版 Lucene 字符编码问题 字符编码及空白汉字占位符 lucene高亮显示 Lucene的基础知识
推荐群组: lucene爱好者
更多相关推荐
Java综合 Lucene
现在如果一个txt文件中包含了ANSI编码的文本文件和Unicode编码的文本文件,如下图这种：

 当用Lucene来建索引搜索时,这个文档中的内容是搜索不到的。
 
需要搜索的文本在附件中提供。
 
创建索引的源代码： 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.index.IndexWriter; import org.apache.lucene.store.FSDirectory; import org.apache.lucene.util.Version; public class IndexFiles { // 主要代码 索引docDir文件夹下文档,索引文件在INDEX_DIR文件夹中 @SuppressWarnings("deprecation") public static void main(String[] args) { File indexDir = new File("e:\\Lucene\\index"); File docDir = new File("e:\\Lucene\\content"); try { // 索引器 IndexWriter standardWriter = new IndexWriter(FSDirectory .open(indexDir), new StandardAnalyzer( Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED); // 不建立复合式索引文件,默认的情况下是复合式的索引文件 standardWriter.setUseCompoundFile(false); String[] files = docDir.list(); for (String fileStr : files) { File file = new File(docDir, fileStr); if (!file.isDirectory()) { Document doc = new Document(); // 文件名称,可查询,不分词 String fileName = file.getName().substring(0, file.getName().indexOf(".")); System.out.println("fileName:"+fileName); doc.add(new Field("name", fileName, Field.Store.YES, Field.Index.NOT_ANALYZED)); // 文件路径,可查询,不分词 String filePath = file.getPath(); doc.add(new Field("path", filePath, Field.Store.YES, Field.Index.NOT_ANALYZED)); // 文件内容,需要检索 doc.add(new Field("content", new FileReader(file))); standardWriter.addDocument(doc); } } standardWriter.optimize(); // 关闭索引器 standardWriter.close(); } catch (IOException e) { System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage()); } } }
 
搜索的源代码： import java.io.BufferedReader; import java.io.File; import java.io.IOException; import java.io.InputStreamReader; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.index.IndexReader; import org.apache.lucene.queryParser.QueryParser; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.Searcher; import org.apache.lucene.search.TopScoreDocCollector; import org.apache.lucene.store.FSDirectory; import org.apache.lucene.util.Version; /** * 检索索引 */ public class SearchFiles { /** Simple command-line based search demo. */ @SuppressWarnings("deprecation") public static void main(String[] args) throws Exception { String index = "E:\\Lucene\\index"; String field = "content"; String queries = null; boolean raw = false; // 要显示条数 int hitsPerPage = 10; // searching, so read-only=true IndexReader reader = IndexReader.open( FSDirectory.open(new File(index)), true); // only Searcher searcher = new IndexSearcher(reader); Analyzer standardAnalyzer = new StandardAnalyzer(Version.LUCENE_CURRENT); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, field, standardAnalyzer); while (true) { if (queries == null) // prompt the user System.out.println("Enter query: "); String line = in.readLine(); if (line == null || line.length() == -1) break; line = line.trim(); if (line.length() == 0) break; Query query = parser.parse(line); System.out.println("Searching for: " + query.toString(field)); doPagingSearch(in, searcher, query, hitsPerPage, raw, queries == null); } reader.close(); } public static void doPagingSearch(BufferedReader in, Searcher searcher, Query query, int hitsPerPage, boolean raw, boolean interactive) throws IOException { TopScoreDocCollector collector = TopScoreDocCollector.create( hitsPerPage, false); searcher.search(query, collector); ScoreDoc[] hits = collector.topDocs().scoreDocs; int end, numTotalHits = collector.getTotalHits(); System.out.println(numTotalHits + " total matching documents"); int start = 0; end = Math.min(hits.length, start + hitsPerPage); for (int i = start; i < end; i++) { Document doc = searcher.doc(hits[i].doc); String path = doc.get("path"); if (path != null) { System.out.println((i + 1) + ". " + path); } else { System.out .println((i + 1) + ". " + "No path for this document"); } } } }
 

imjl 写道
提升标题的权重,,lucene的代码看setboost
solr的更简单,直接在url中修改

谢谢你的回复. 现在的需要是这样,全部在标题命中关键字是需要排名靠前,同时这批全部命中标题的记录会再按记录的发布时间来去倒序排序的,所以需要使用全部命中标题的记录得到的score的值是一样的,所以如果简直的设置标题的setBoost的权重是不能保证全部命中关键字的记录的score都相等.所以也不会符合以上的需求了...

相关推荐: JE评论字终级版,JE评论框通用版插件,支持Firefox Chrome Opera IE10。beta新版放出,支持菊花文和边框文。 读文章《离职交接没事做, 弄个JE评论彩色字... 》有感,改进版,随机颜色和大小 离职交接没事做, 弄个JE评论彩色字... 用于Lucene的各中文分词比较 Lucene/Solr开发经验 某Java大佬在地表最强Java企业（阿里）面试总结 【遇见CUDA】要更快,请提高数据传输效率！
推荐群组: 电脑DIY
更多相关推荐
Lucene JavaEye solr['səulə]
solr发音同 solar ['səulə]----馊了；
lucene['lu:si:n]
lucene的发音来源是Doug Cutting的妻子的 名字中的中间名.读做 ['lu:si:n]

备案！

相关推荐: 搜索篇:lucene的简单实例<一> 用lucene 搜索时出现Parser错误,望解!! lucene3.0学习笔记2-(再学Lucene的简单例子) Lucene 的特殊字符 处理 Lucene中的特殊字符 Lucene 特殊字符的问题 lucene中特殊字符的转译问题 JAVA基于Lucene实现建立索引以及检索
推荐群组: lucene爱好者
更多相关推荐
Java综合 Lucene 这是个郁闷的问题,今天遇到了,但在lucene中查询的关键字保护有特殊字符,譬如--,会出现如下异常： org.apache.lucene.queryParser.ParseException: Cannot parse '': Encountered " " at line 1, column 0. Was expecting one of: ... "+" ... "-" ... "(" ... "*" ... ... ... ... ... "[" ... "{" ... ... 解决方法： 使用 QueryParser的静态方法escape(string s),进行自动转义特殊字符后再进行关键字的查询 lucene的特殊字符保护了以下的字符： + - && || ! ( ) { } [ ] ^ " ~ * ? :

这个算法很不错,可以略作修改后,进行分布式的翻页查询,更深入的说,是一种mapreduce的实现基础

相关推荐: 基于最小堆（小根堆）的topn算法 Java最小堆实现 HashMap深度分析 基于lucene的搜索引擎总结 Lucene搜索引擎-搜索 Lucene系列之全局搜索引擎入门教程 使用Lucene开发简单的站内新闻搜索引擎(索引的搜索) 搜索引擎---Lucene
推荐群组: Pipboy
更多相关推荐
搜索引擎 Lucene
       本博客属原创文章,欢迎转载！转载请务必注明出处:http://guoyunsky.iteye.com/blog/723963
      本博客已迁移到本人独立博客: http://www.yun5u.com/
       欢迎加入Heritrix群(QQ)： 109148319 , 10447185   , Lucene/Solr群(QQ) :  118972724    
      通过Lucene搜索返回的是评分(Score)前N的结果,默认是前100.这里我将这段算法复制下来,具体请看注释,同时这段算法不依赖Lucene任何组件,可以直接运行。
  /** * 在一对数中找出前N个大的数,采用二叉堆 * 模仿Lucene中的获得评分前N的DocumentID * * @author Administrator * */ public class LuceneFindTopN { private int[] heap; //存储数据 private int size; //已存数据个数,也代表指针位置 private int maxSize; //取前maxSize大的数 private int minElement; //数据中最小的元素 public LuceneFindTopN(int maxSize) { super(); this.maxSize = maxSize; heap=new int[maxSize+1]; size=0; minElement=0; } /** * 插入数据 * @param element * @return */ public boolean insert(int element){ if(size0&&element>top()){ //大于最小的元素才进入,并调整数据顺序 heap[1]=element; //替换头部元素(也就是最小的元素)为当前元素(因为当前元素比头部元素大) adjustTop(); //调整头部元素 return true; }else{ return false; } } /** * 存入数据 * @param element */ public void put(int element){ size++; heap[size]=element; upheap(); } /** * 返回top * @return */ public int top(){ if(size>0){ return heap[1]; }else{ return 0; } } public int getSize() { return size; } public void setSize(int size) { this.size = size; } public final void upheap(){ int i=size; int node=heap[i]; int j=i>>>1; //父节点位置 while(j>0&&node>>1; //迭代父节点的父节点,以此类推 } heap[i]=node; //要插入的数据放入合适位置 } /** * 排放数据,从最小的元素开始排放,会删除该元素 * @return */ public int pop(){ if(size>0){ int result=heap[1]; //第一个元素作为结果返回,因为第一个元素最小 heap[1]=heap[size]; //第一个元素置为最大的元素 heap[size]=-1; //最大的元素清空 size--; //指针前移 downHeap(); return result; }else{ return -1; } } public final void adjustTop(){ downHeap(); } public void downHeap(){ int i = 1; int node = heap[i]; // 第一个元素,也就是刚插入的元素 int j = i << 1; // 第二个元素 int k = j + 1; // 第三个元素 if (k <= size && heap[k] 

相关推荐: Lucene搜索数据库信息,一对多的数据如何存储(新手) 倒底该怎么写DAO的单元测试？ 自己实现了一个较实用的Pojo（实体）基类 Lucene全文检索框架+Solr+ElasticSearch搜索引擎(Java高级必备.ES) Lucene3.0结果排序原理+操作+示例 lucene搜索结果排序问题 LuceneInAction(第2版)_中文版
推荐群组: 中文分词
更多相关推荐
企业应用 Lucene 这里先说明一下应用场景：对用户进行lucene搜索,而希望得到的结果排序有要求,具体如下： 现在假如有下面几条数据： 名字 年龄 地址 个人介绍 备注 user1 李四 19 江南大道 路过 与张三是同学 user2 张三 20 江南大道 张三的介绍 abc user3 王五 42 三三大道 abc 与李四是同事 user4 赵六 33 江南大道 张三峰是牛人呀 赵 上面几个用户信息全部生成索引,现在通过lucene搜索“张三”（在所有的字段中搜索） 会搜索出 user1（备注中出现张三）,user2（名字是张三）,user4（个人介绍中出现张三）, 现在希望结果是user2,user4,user1这样的排序,也就是说得到的结果要求 名字包含“张三" 个人介绍包含”张三“ 备注包含”张三“ 而不是随便的从上到下user1,user2,user4 也就是说得到的结果集中希望名字匹配优先,然后是个人介绍,然后是备注,依照这样的顺序进行排序下来, 在这里来问一下各位大侠们,有没有什么好办法 ？

排序是和查询的query无关的。就你的例子,其实只是个select * from xx in (...)操作。

shijiyu 写道
如果输入了,则调用上面第1种或第4种方法（第三种方法虽然也包含filter条件,但是返回类型为void,肯定不行） 第三种方法也是可行的 自己好好看看 呵呵 不用看了,想起来了,对的,这个能用,呵呵,谢谢指正～～～

相关推荐: Lucene入门实例。 开源全文搜索引擎框架JBOX-beta版发布 Lucene学习笔记【2013-04-10更新】 Lucene全文检索框架+Solr搜索引擎（2018版.Java） SSM整合进阶项目实战-个人博客系统 Lucene+Nutch搜索引擎开发（PDF电子书完整版） Lucene搜索引擎-搜索 【读书笔记】Lucene+nutch搜索引擎开发
推荐群组: lucene爱好者
更多相关推荐
Lucene 编程综合
有一个小小较完整的实例,详见说明.txt
见附件,解压密码： http://deepfuture.javaeye.com/

相关推荐: 介绍一个PDF的生成方案 JA检测字符串编码并转换 MySQL全文检索中Like索引的实现 【判断字符串】【OO面向对象】Java判断字符串中的大写字母,小写字母,其它字母。 java字符串之判断java标识符 Java中的字符串（二）——检查特定字符串出现的次数 java字符串应用之18位身份证格式验证 java字符串应用之表达式解析器
推荐群组: lucene爱好者
更多相关推荐
OO 关于在Java中判断一个字符是否是中文,看到过一些方法,在这里抛砖引玉,提出来大家讨论下。1、转化为unicode,利用中文字符转化后双字节中首个字节不为0,而英文字符首字节为0.但是这样的话,可能会有别的国家字符也是双字符且首字符非0. 2、正则表达式判断。一到龥 3、 public boolean isChinesrChar(char ch) { int v = (int) ch; if(v>=19968 && v <= 171941) { return true; } else { return false; } } 4、 public boolean isChinese(char c) { Character.UnicodeBlock ub = Character.UnicodeBlock.of(c); if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) { return true; } return false; } 仅为抛砖引玉,期待更多更好的意见和想法

相关推荐: 线程池示例代码,请大家多指教 『出错』DBCP的疑惑 Common Pool对象池的中断策略和ThreadPoolExecutor中断策略 玩转Linux：常用命令实例指南 一篇关于apache commons类库的详解 YOLOv4目标检测实战：训练自己的数据集
推荐群组: 高级语言虚拟机
更多相关推荐
OO
代码是前段时间看的（Commons Pool还是很容易理解的）,昨天有时间就整理了下···原文见博客吧~
 
对象池(对Apache Commons部分源码分析)
1,commons pool中的StatckObjectPool 和 ReferenceObjectPool等 本身设计的确实不允许"脏"对象的外围的activate(), passivate()充当了"清理"工作..
2,如果pool的_maxSleeping阀值设置不当的话,在多线程APP下确实会导致堵塞...上限阀值和下限阀值很重要吧...
3,另外commons提供了一个ReferenceObjectPool,这种的好处在于内存不足时,GC无条件回收pool中的空闲对象,.这样资源可适当得到利用..不过pool中总要有一定量的闲对象,不可能每次都new吧。
4,commons中,是borrow()时,如果pool中没有空闲obj的时候,就创建新的obj,当然这个新对象是无状态的,所以建立在pool存储也需要建立在"无状态对象"的基本之上...  
 
什么时候不要池化?
    采用对象池化的本意,是要通过减少对象生成的次数,减少花在对象初始化上面的开销,然而池化处理本身也要付出代价,因此,并非任何情况下都适合采用对象池化。
    Dr. Cliff Click在JavaOne 2003上发表的《Performance Myths Exposed》中测试表明:
1#类似Point这样的轻量级对象,进行池化处理后,性能反而下降.
2#类似Point这样的轻量级对象,进行池化处理后,性能反而下降.
3#类似JPanel\Connection这样的重量级对象,进行池化处理后,性能有所上升,可以考虑池化。
 
Commons的几个功能方面:
1,pool的每个进出object都进行类型检查
2,提供了一个线程安全的版本.
3,对当前active object和sleeping object的控制
4,对object的获取和释放的时间控制
5,容错处理
 
设计结构:
 1,PoolableObjectFactory用于管理被池化的对象的产生、激活、挂起、校验和销毁；
 2,ObjectPool用于管理要被池化的对象的借出和归还,并通知PoolableObjectFactory完成相应的工作；
 
设计重点:
 1,池用某个容器存储对象（如Stack,List等）。
 2,池中的每个对象是“干净”对象,或者说每一个从池中读取的对象都是一样初始化的对象（可取个别名为“裸对象”）。
 3,对象<-->裸对象 由外围的Factory来处理。
 4,接口方式为：ObjectPool <-- BaseObjectPool <--StackObjectPool  
 
接口设计代码(对原设计有做简化）：
清单：
以下是CommonsPool的接口,也就是最抽象的一层；
1、ObjectPool.java（pool的基本接口）
2、PoolableObjectFactory.java（Factory的基本接口）
#######################ObjectPool.java############### package pools.inter; import java.util.NoSuchElementException; import pools.impl.pool.BaseObjectPool; /** * A pooling interface. * * * @author Rodney Waldhoff * @author Sandy McArthur * @since Pool 1.0 */ public interface ObjectPool { // 从池中拿裸对象 Object borrowObject() throws Exception, NoSuchElementException, IllegalStateException; // 返回给池 void returnObject(Object obj) throws Exception; // 销毁对象,需要Factory(因为设计Factory就是负责对象处理等） void invalidateObject(Object obj) throws Exception; // 利用Factory创建一个新对象 void addObject() throws Exception, IllegalStateException, UnsupportedOperationException; // 获得池中对象个数 int getNumIdle() throws UnsupportedOperationException; // 获取池外活动的对象个数 int getNumActive() throws UnsupportedOperationException; // 清空池中对象,就是把所有对象丢给Factory来销毁 void clear() throws Exception, UnsupportedOperationException; // 关闭池,但不销毁对象 void close() throws Exception; void setFactory(PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException; }
  
 
 
 
#######################PoolableObjectFactory.java###############
  public interface PoolableObjectFactory { Object makeObject() throws Exception; void destroyObject(Object obj) throws Exception; boolean validateObject(Object obj); void activateObject(Object obj) throws Exception; void passivateObject(Object obj) throws Exception; }
 
 
 
实现设计：
清单：
 
1\BaseObjectPool.java
2\SoftReferenceObjectPool.java
3\StackObjectPool.java
 
以下是一个抽象类而已,关联的是上面的那个接口,注释同上
######################BaseObjectPool.java################# public abstract class BaseObjectPool implements ObjectPool { public abstract Object borrowObject() throws Exception; public abstract void returnObject(Object obj) throws Exception; public abstract void invalidateObject(Object obj) throws Exception; public int getNumIdle() throws UnsupportedOperationException { return -1; } public int getNumActive() throws UnsupportedOperationException { return -1; } public void clear() throws Exception, UnsupportedOperationException { throw new UnsupportedOperationException(); } public void addObject() throws Exception, UnsupportedOperationException { throw new UnsupportedOperationException(); } public void close() throws Exception { closed = true; } public void setFactory(PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException { throw new UnsupportedOperationException(); } protected final boolean isClosed() { return closed; } protected final void assertOpen() throws IllegalStateException { if (isClosed()) { throw new IllegalStateException("Pool not open"); } } /** Whether or not the pool is closed */ private volatile boolean closed = false; }
 
 
 
 
######################SoftReferenceObjectPool.java#############
一个弱引用对象池的实现类,这个对象池的特点是内存不足时,GC无条件回收池中的对象.
  public class SoftReferenceObjectPool extends BaseObjectPool implements ObjectPool { public static int DEFAULT_INIT_SLEEPING_CAPACITY; public static int DEFAULT_MAX_SLEEPING; public SoftReferenceObjectPool() { _pool = new ArrayList(); // 能看出来,池中的对象是用List数据结构来存储的 _factory = null; } public SoftReferenceObjectPool(PoolableObjectFactory factory) { _pool = new ArrayList(); _factory = factory; } public SoftReferenceObjectPool(PoolableObjectFactory _factory2, int sleeping, int capacity) { // TODO Auto-generated constructor stub } public synchronized Object borrowObject() throws Exception { assertOpen(); Object obj = null; boolean newlyCreated = false; while(null == obj) { if(_pool.isEmpty()) { if(null == _factory) { throw new NoSuchElementException(); } else { newlyCreated = true; obj = _factory.makeObject(); } } else { SoftReference ref = (SoftReference)(_pool.remove(_pool.size() - 1)); obj = ref.get(); ref.clear(); // prevent this ref from being enqueued with refQueue. } if (null != _factory && null != obj) { try { _factory.activateObject(obj); if (!_factory.validateObject(obj)) { throw new Exception("ValidateObject failed"); } } catch (Throwable t) { try { _factory.destroyObject(obj); } catch (Throwable t2) { // swallowed } finally { obj = null; } if (newlyCreated) { throw new NoSuchElementException( "Could not create a validated object, cause: " + t.getMessage()); } } } } _numActive++; return obj; } public synchronized void returnObject(Object obj) throws Exception { boolean success = !isClosed(); if (_factory != null) { if(!_factory.validateObject(obj)) { success = false; } else { try { _factory.passivateObject(obj); } catch(Exception e) { success = false; } } } boolean shouldDestroy = !success; _numActive--; if(success) { _pool.add(new SoftReference(obj, refQueue)); } notifyAll(); // _numActive has changed if (shouldDestroy && _factory != null) { try { _factory.destroyObject(obj); } catch(Exception e) { // ignored } } } public synchronized void invalidateObject(Object obj) throws Exception { _numActive--; if (_factory != null) { _factory.destroyObject(obj); } notifyAll(); // _numActive has changed } /** * Create an object, and place it into the pool. * addObject() is useful for "pre-loading" a pool with idle objects. */ public synchronized void addObject() throws Exception { assertOpen(); if (_factory == null) { throw new IllegalStateException("Cannot add objects without a factory."); } Object obj = _factory.makeObject(); boolean success = true; if(!_factory.validateObject(obj)) { success = false; } else { _factory.passivateObject(obj); } boolean shouldDestroy = !success; if(success) { _pool.add(new SoftReference(obj, refQueue)); notifyAll(); // _numActive has changed } if(shouldDestroy) { try { _factory.destroyObject(obj); } catch(Exception e) { // ignored } } } /** Returns an approximation not less than the of the number of idle instances in the pool. */ public synchronized int getNumIdle() { pruneClearedReferences(); return _pool.size(); } public synchronized int getNumActive() { return _numActive; } /** * Clears any objects sitting idle in the pool. */ public synchronized void clear() { if(null != _factory) { Iterator iter = _pool.iterator(); while(iter.hasNext()) { try { Object obj = ((SoftReference)iter.next()).get(); if(null != obj) { _factory.destroyObject(obj); } } catch(Exception e) { // ignore error, keep destroying the rest } } } _pool.clear(); pruneClearedReferences(); } public void close() throws Exception { super.close(); clear(); } public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException { assertOpen(); if(0 < getNumActive()) { throw new IllegalStateException("Objects are already active"); } else { clear(); _factory = factory; } } private void pruneClearedReferences() { Reference ref; while ((ref = refQueue.poll()) != null) { try { _pool.remove(ref); } catch (UnsupportedOperationException uoe) { // ignored } } } /** My pool. */ private List _pool = null; /** My {@link PoolableObjectFactory}. */ private PoolableObjectFactory _factory = null; private final ReferenceQueue refQueue = new ReferenceQueue(); /** Number of active objects. */ private int _numActive = 0; }
 
 
 
########################StackObjectPool.java#############
以下是一个Stack容器的对象池
  public class StackObjectPool extends BaseObjectPool implements ObjectPool { public StackObjectPool() { this((PoolableObjectFactory)null,DEFAULT_MAX_SLEEPING,DEFAULT_INIT_SLEEPING_CAPACITY); } public StackObjectPool(int maxIdle) { this((PoolableObjectFactory)null,maxIdle,DEFAULT_INIT_SLEEPING_CAPACITY); } public StackObjectPool(int maxIdle, int initIdleCapacity) { this((PoolableObjectFactory)null,maxIdle,initIdleCapacity); } public StackObjectPool(PoolableObjectFactory factory) { this(factory,DEFAULT_MAX_SLEEPING,DEFAULT_INIT_SLEEPING_CAPACITY); } public StackObjectPool(PoolableObjectFactory factory, int maxIdle) { this(factory,maxIdle,DEFAULT_INIT_SLEEPING_CAPACITY); } public StackObjectPool(PoolableObjectFactory factory, int maxIdle, int initIdleCapacity) { _factory = factory; _maxSleeping = (maxIdle < 0 ? DEFAULT_MAX_SLEEPING : maxIdle); int initcapacity = (initIdleCapacity < 1 ? DEFAULT_INIT_SLEEPING_CAPACITY : initIdleCapacity); _pool = new Stack(); _pool.ensureCapacity( initcapacity > _maxSleeping ? _maxSleeping : initcapacity); } public synchronized Object borrowObject() throws Exception { assertOpen(); Object obj = null; boolean newlyCreated = false; while (null == obj) { if (!_pool.empty()) { obj = _pool.pop(); } else { if(null == _factory) { throw new NoSuchElementException(); } else { obj = _factory.makeObject(); newlyCreated = true; if (obj == null) { throw new NoSuchElementException("PoolableObjectFactory.makeObject() returned null."); } } } if (null != _factory && null != obj) { try { _factory.activateObject(obj); if (!_factory.validateObject(obj)) { throw new Exception("ValidateObject failed"); } } catch (Throwable t) { try { _factory.destroyObject(obj); } catch (Throwable t2) { // swallowed } finally { obj = null; } if (newlyCreated) { throw new NoSuchElementException( "Could not create a validated object, cause: " + t.getMessage()); } } } } _numActive++; return obj; } public synchronized void returnObject(Object obj) throws Exception { boolean success = !isClosed(); if(null != _factory) { if(!_factory.validateObject(obj)) { success = false; } else { try { _factory.passivateObject(obj); } catch(Exception e) { success = false; } } } boolean shouldDestroy = !success; _numActive--; if (success) { Object toBeDestroyed = null; if(_pool.size() >= _maxSleeping) { shouldDestroy = true; toBeDestroyed = _pool.remove(0); // remove the stalest object } _pool.push(obj); obj = toBeDestroyed; // swap returned obj with the stalest one so it can be destroyed } notifyAll(); // _numActive has changed if(shouldDestroy) { // by constructor, shouldDestroy is false when _factory is null try { _factory.destroyObject(obj); } catch(Exception e) { // ignored } } } public synchronized void invalidateObject(Object obj) throws Exception { _numActive--; if (null != _factory) { _factory.destroyObject(obj); } notifyAll(); // _numActive has changed } public synchronized int getNumIdle() { return _pool.size(); } public synchronized int getNumActive() { return _numActive; } /** * Clears any objects sitting idle in the pool. */ public synchronized void clear() { if(null != _factory) { Iterator it = _pool.iterator(); while(it.hasNext()) { try { _factory.destroyObject(it.next()); } catch(Exception e) { // ignore error, keep destroying the rest } } } _pool.clear(); } public void close() throws Exception { super.close(); clear(); } public synchronized void addObject() throws Exception { assertOpen(); if (_factory == null) { throw new IllegalStateException("Cannot add objects without a factory."); } Object obj = _factory.makeObject(); boolean success = true; if(!_factory.validateObject(obj)) { success = false; } else { _factory.passivateObject(obj); } boolean shouldDestroy = !success; if (success) { Object toBeDestroyed = null; if(_pool.size() >= _maxSleeping) { shouldDestroy = true; toBeDestroyed = _pool.remove(0); // remove the stalest object } _pool.push(obj); obj = toBeDestroyed; // swap returned obj with the stalest one so it can be destroyed } notifyAll(); // _numIdle has changed if(shouldDestroy) { // by constructor, shouldDestroy is false when _factory is null try { _factory.destroyObject(obj); } catch(Exception e) { // ignored } } } public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException { assertOpen(); if(0 < getNumActive()) { throw new IllegalStateException("Objects are already active"); } else { clear(); _factory = factory; } } /** The default cap on the number of "sleeping" instances in the pool. */ public static final int DEFAULT_MAX_SLEEPING = 8; public static final int DEFAULT_INIT_SLEEPING_CAPACITY = 4; /** My pool. */ protected Stack _pool = null; /** My {@link PoolableObjectFactory}. */ protected PoolableObjectFactory _factory = null; /** The cap on the number of "sleeping" instances in the pool. */ protected int _maxSleeping = DEFAULT_MAX_SLEEPING; /** Number of object borrowed but not yet returned to the pool. */ protected int _numActive = 0; }
 
 
 
工厂实现代码：
清单：
1、BasePoolableObjectFactory.java
2\SoftReferencePoolFactory.java
3\StackObjectPoolFactory.java
#############################BasePoolableObjectFactory.java########## public abstract class BasePoolableObjectFactory implements PoolableObjectFactory { public abstract Object makeObject() throws Exception; /** No-op. */ public void destroyObject(Object obj) throws Exception { } /** * This implementation always returns true. * @return true */ public boolean validateObject(Object obj) { return true; } /** No-op. */ public void activateObject(Object obj) throws Exception { } /** No-op. */ public void passivateObject(Object obj) throws Exception { } }
 
 
 
#########################SoftReferencePoolFactory.java###########
public class SoftReferencePoolFactory implements PoolableObjectFactory { /** * Create a new StackObjectPoolFactory. * * @see StackObjectPool#StackObjectPool() */ public SoftReferencePoolFactory() { this((PoolableObjectFactory)null,StackObjectPool.DEFAULT_MAX_SLEEPING,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY); } /** * Create a new StackObjectPoolFactory. * * @param maxIdle cap on the number of "sleeping" instances in the pool. * @see StackObjectPool#StackObjectPool(int) */ public SoftReferencePoolFactory(int maxIdle) { this((PoolableObjectFactory)null,maxIdle,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY); } /** * Create a new StackObjectPoolFactory. * * @param maxIdle cap on the number of "sleeping" instances in the pool. * @param initIdleCapacity - initial size of the pool (this specifies the size of the container, it does not cause the pool to be pre-populated.) * @see StackObjectPool#StackObjectPool(int, int) */ public SoftReferencePoolFactory(int maxIdle, int initIdleCapacity) { this((PoolableObjectFactory)null,maxIdle,initIdleCapacity); } /** * Create a new StackObjectPoolFactory. * * @param factory the PoolableObjectFactory used by created pools. * @see StackObjectPool#StackObjectPool(PoolableObjectFactory) */ public SoftReferencePoolFactory(PoolableObjectFactory factory) { this(factory,StackObjectPool.DEFAULT_MAX_SLEEPING,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY); } /** * Create a new StackObjectPoolFactory. * * @param factory the PoolableObjectFactory used by created pools. * @param maxIdle cap on the number of "sleeping" instances in the pool. */ public SoftReferencePoolFactory(PoolableObjectFactory factory, int maxIdle) { this(factory,maxIdle,SoftReferenceObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY); } /** * Create a new StackObjectPoolFactory. * * @param factory the PoolableObjectFactory used by created pools. * @param maxIdle cap on the number of "sleeping" instances in the pool. * @param initIdleCapacity - initial size of the pool (this specifies the size of the container, it does not cause the pool to be pre-populated.) */ public SoftReferencePoolFactory(PoolableObjectFactory factory, int maxIdle, int initIdleCapacity) { _factory = factory; _maxSleeping = maxIdle; _initCapacity = initIdleCapacity; } public ObjectPool createPool() { return new SoftReferenceObjectPool(_factory,_maxSleeping,_initCapacity); } protected PoolableObjectFactory _factory = null; protected int _maxSleeping = SoftReferenceObjectPool.DEFAULT_MAX_SLEEPING; protected int _initCapacity = SoftReferenceObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY; public void activateObject(Object obj) throws Exception { // TODO Auto-generated method stub } public void destroyObject(Object obj) throws Exception { // TODO Auto-generated method stub } public Object makeObject() throws Exception { // TODO Auto-generated method stub return null; } public void passivateObject(Object obj) throws Exception { // TODO Auto-generated method stub } public boolean validateObject(Object obj) { // TODO Auto-generated method stub return false; } }
 
 
 
 附加实例：
另一人写的简单objectpool package com.thoughtworks.xstream.core.util; /** * A simple pool implementation. * * @author Jörg Schaible * @author Joe Walnes */ public class Pool { public interface Factory { public Object newInstance(); } private final int initialPoolSize; private final int maxPoolSize; private final Factory factory; private transient Object[] pool; private transient int nextAvailable; private transient Object mutex = new Object(); public Pool(int initialPoolSize, int maxPoolSize, Factory factory) { this.initialPoolSize = initialPoolSize; this.maxPoolSize = maxPoolSize; this.factory = factory; } public Object fetchFromPool() { Object result; synchronized (mutex) { if (pool == null) { pool = new Object[maxPoolSize]; for (nextAvailable = initialPoolSize; nextAvailable > 0; ) { putInPool(factory.newInstance()); } } while (nextAvailable == maxPoolSize) { try { mutex.wait(); } catch (InterruptedException e) { throw new RuntimeException("Interrupted whilst waiting " + "for a free item in the pool : " + e.getMessage()); } } result = pool[nextAvailable++]; if (result == null) { result = factory.newInstance(); putInPool(result); ++nextAvailable; } } return result; } protected void putInPool(Object object) { synchronized (mutex) { pool[--nextAvailable] = object; mutex.notify(); } } private Object readResolve() { mutex = new Object(); return this; } }
 
 

无明 写道
这得要database支持。本来是用rest模式调用自己的controller,由controller去发送sql,这么干就变成直接把database变成controller了。这可是走回把业务逻辑在database端实现的老路啊。 将需要的sql put 到指定资源即可. database并没有变成controller 仅仅是单纯的数据库 执行sql返回结果. 在rest中没有controller 只有资源和向资源发出的请求. 我好象听说mysql也在开发rest api. 本来想放弃rest 结果发现了这个, 这样rest几乎可以完成99.99%的应用了

dlee 写道
HTTP认证的实现方法在《Ajax模式与最佳实践》的第5章：置换模式中有详细的介绍。
我一再提到这本书,并不是为了多卖几本书增加我本人的收入。而是因为这本书实际上就是目前国内已出版的关于REST架构设计最为详尽深入的专著。这本书同时对于深入理解HTTP的能力也非常有帮助,强烈建议你买一本来阅读。
这本书的勘误在：
http://blog.csdn.net/bvbook/archive/2007/04/30/1593604.aspx 现在外边旅行带书会增加重量不方便. 要是有电子图书下载就好了

相关推荐: 业务流程编排器学习笔记 (2) —— 调用JAVA服务 大型企业信息化中的BPM和SOA实战 BPEL为啥没多少人关注呢？ 微服务与微服务架构的主要思想和原则 值得关注的开源软件推荐 【学习笔记】Java 开发手册（嵩山版） XML系列——（一）基础知识 EveryDay笔记
推荐群组: 系统架构与架构应用
更多相关推荐
SOA
业务流程编排器的基本环境： l          开发环境：WID（集成开发工具） l          运行环境：WPS（业务流程应用服务器） 概念
WSDL ：使用 XML 语言描述 WS 的接口。
SCA 规范：由一组能提供 WS 的组件组成的应用模块,每个组件都由 WSDL 描述,该模块封装在 J2EE 的企业应用中。
业务流程：使用 BPEL 规范（关于流程有很多规范,但是 For WS 的目前只有 BPEL ,也是符合 SCA 的规范,即可以自主暴露为一个服务组件）。
BPEL ：符合 SCA 的一类组件,按照一定的顺序执行的一系列的活动。
BPEL 要素：活动元素、控制线、变量（贯穿在整个 BPEL 中）、伙伴连接（调用其他 SCA 组件）、相关集（高级部分讲解）。
介绍
用户输入一个名字,返回“ Hello World ”。
架构
一个独立的流程。   
流程
三个活动：
l          Receive ：流程的起点,接收外部的消息；
l          Snippet ：一段 Java 代码；
l          Reply ：流程的终点,返回结果。
一个变量：保存消息。
开发（使用 WID ）
1.          创建一个 Module 项目（ Module 项目即是一个 SCA 模块, WID 会自动创建相关的 EAR 、 EJB 和 WEB 项目）,项目名称： HelloWorld 。
2.          创建一个业务流程文件（没有创建 WSDL , WID 会提供一个输入、输出都是字符串的缺省 WSDL ,实际开发中需要事先创建 WSDL ,如果参数是自定义的对象,也需要事先创建）,流程名 HelloWorldProcess ,文件夹 bpc/sample ,使用缺省的命名空间。
3.          在流程中拖拽一个 Snippet 活动,在属性视图的详细卡中,切换到 Java ,输入如下代码：
System.out.println("Hello, " + Input1); // Input1 是流程中的全局变量,在所有活动中都可以使用；
Input1 = "Hello World!"; //
4.          打开装配图,将创建的业务流程拖入到装配图中。
5.          将 WID 自动生成的 EAR 项目 HelloWorldApp 部署到 WPS 中。
运行（使用 WPS ）
1.          打开浏览器,输入 http://localhost:9080/bpc/ ,打开业务流程资源管理器。
2.          在流程模版中,选中 HelloWorldProcess ,并启动实例。
3.          在输入框,输入 Tom ,并提交。
4.          查看页面输出： Hello World!
5.          查看控制台输出： Hello, Tom

相关推荐: JavaSE6.0 Web Service学习笔记 请讨论一下Web Service开发的两种模式：wsdl first vs. java first CODE first or WSDL frist CodeFirst Or ContractFirst 初步理解一下：SOA, SOAP, Web Service, WSDL等 Contract-First, the key of Service-Oriented
推荐群组: WebServices
更多相关推荐
SOA 如果要构建一个Web Services,CXF提供了两种构建方式一个是Code First,另一个WSDL First。那什么是Code First,什么又是WSDL First呢？ 大家知道,如果我们要将一个服务发布一个WebService,我们需要定义这个服务所支持的方法,以及调用这些方法所提供的参数并将其转化成为WSDL,供其它的客户端调用。Code First是第一代的WebService开发工具所提供的构建WebService的一种方式。以Java为例,我们可以通过Interface定义一组Web服务所提供的方法,Code First就是通过获取这个Interface的信息构建出Web Services 所需要的信息,并在这些信息的基础上生成WSDL。 而WSDL First就是通过WSDL文件,生成相关的Aritifacts,例如有相关的接口以及实现的代码框架等,这CORBA开发一样,先使用IDL描述我们的CORBA服务,通过IDL2XXX生成相关的接口和实现框架（屏蔽了网络传输中Marshal和Unmarshal的操作）。 这两种构建Web Services各有特点,适合在不同的场景。 接触过WSDL的朋友应该都有这样的感觉,WSDL虽然是用XML来进行描述的,但是如果让你在不借助任何工具的情况下写一个正确的WSDL,或者是改正一个错误的WSDL是很难的。Code First可以说是为我们提供了一个不错的选择。 但是Web Services的Best Practies并不推荐Code First这一Web Services的构建方式。原因是什么呢？ 这是因为我们在使用Code First构建方式时很少考虑到Web Services之间的交互是以文档方式进行（这样可以大大提高Web Services的互交互性）,如果是使用Code First来构建WSDL信息,在描述描述交互信息的XML Schema都是以我们的Code中定义的类型信息来生成的,这样就可能会暴露一些比较细粒度的信息。同时大家知道不同的语言（C＋＋,Java, C＃,PHP）对XML Schema映射是各不相同的,如果我们Code中定义的类型很特殊,就可能产生出一个不能互操作的现象。 所以Best Practies建议你在创建Web Services从交互的消息Schema入手,构建一个中间层来提供一个比较粗粒度的描述,这样可以比较好的解决Web Services的互交互问题。

相关推荐: CXF 2.0.1 发布 CXF 2.0.2 发布了 CXF 2.0 发布了 Ogre 2.0 doc (slides) - Updated 1st dec 2012 Eclipse STP(SOA Tools Platform)安装 java中最常用jar包的用途 常用jar包用途
推荐群组: webservice讨论组
更多相关推荐
SOA
经过4个月的努力,CXF 2.0 RC发布了, 我们会在后续的几个月中推出2.0正式版。
 大家可以 在此下载 .
   
下面是Mail List中的公告。
The Apache CXF team is proud to announce the availability of the
2.0-incubator-RC release! Release notes and download information can
be found here:
Apache CXF is a Java open source service development framework. This
release contains the following features:
* JAX-WS frontend - Apache CXF uses/implements the JAX-WS API's but
makes no representation that this release is JAX-WS compliant.
* Java2WSDL and WSDL2Java tools and Maven plugin
* SOAP 1.1 & 1.2, XML and RESTful HTTP bindings
* JAXB 2.0 Databinding support
* WSDL 1.1 support
* WS-Addressing, WS-ReliableMessaging, WS-Security, and WS-Policy support
* MTOM attachment support
* HTTP, Servlet, JMS and Local Transports
* Simple POJO service frontend
* Javascript frontend
* JBI Service Engine. CXF services can be deployed into any JBI
compliant container (ServiceMix or OpenESB)
* JCA 1.0 support, J2EE application can integrate with legacy
application through JCA 1.0 support in CXF
* Spring Support
* JSON support with Jettison
* Many other bug fixes and feature enhancements
For more information see:
* Website: http://incubator.apache.org/cxf/
* Release Notes:
http://incubator.apache.org/cxf/apache-cxf-20-rc-incubating-release-notes.html
* Mailing lists: http://incubator.apache.org/cxf/mailing-lists.html
If you have feedback, questions or would like to get involved in the
CXF project please join the mailing lists and let us know your
thoughts.
The Apache Incubator CXF Team
 
 

"我们都在面向接口编程, 我们的程序不依赖于哪个具体实现。 我们的程序架构就是面向服务的(SOA)。"programming to interface != SOA

相关推荐: Axis2/C 基础入门 这套系统的框架该如何选择？ 使用Axis2快速开发web服务 Web service框架 论SOA架构的几种主要开发方式 SpringBoot2.x系列教程78--Web Service详细讲解 WebService编程（1:Axis；2:Axis2/XFire；3:CXF；4:jdk6)
推荐群组: WebServices
更多相关推荐
SOA 我也明白web services是基于标准的只要对方发送SOAP,你接收并且解析就ok了 但是axis2框架里边,生产服务器端代码有一种使用AXIOM的方式,服务器端接收的是OMElement对象,返回的也是OMElement对象,那我的客户端,非要发送这个对象和解析这个对象才行？ 那还存在web services的跨语言和平台嘛？ 最近开始搞这个东西,遇到这个一直不解 如果项目中客户端是C++或者。net写成的,服务器端是axis2使用AXIOM方法生产的,要如何？ 希望高手们解惑！

相关推荐: 关于基于XFire的webservice实现和调用的疑惑 [提问]在spring怎样配置多个cfg.xml? 在bo和dao之间传什么好？ AJAX为何一定要用XML? SOA系列文章(一)Web服务中使用SOA方案 SOA系列文章之(三):在Web服务中使用SOA方案 WebService与SOA的实现 SOA （面向服务的体系结构）
推荐群组: D语言
更多相关推荐
SOA 参数是以xml的形式传递的,知道xml schema,能否通过一定的方法,获得具体的xml nodes,谢谢

相关推荐: 手把手教你用axis创建自己的webservice(五) 手把手教你用axis创建自己的webservice(三) 手把手教你用axis创建自己的webservice（一） Axis创建自己的WebService－－Step by Step (转)手把手教你用axis创建自己的webservice 手把手教你用axis创建自己的webservice（一） Axis2(WebService)经典教程
推荐群组: JBPM @net
更多相关推荐
SOA
除了最后两个发布文件以外最重要的有两个文件,即 MobileBossSoapBindingImpl.java 和 MobileBossServiceLocator.java
MobileBossSoapBindingImpl 代码如下：
java 代码
1.    java 代码
/**  
2.            * MobileBossSoapBindingImpl.java  
3.            *  
4.            * This file was auto-generated from WSDL  
5.            * by the Apache Axis 1.3 Oct 05, 2005 (05:23:37 EDT) WSDL2Java emitter.  
6.            */   
7.             
8.           package  com.yy.ws;   
9.             
10.        public   class  MobileBossSoapBindingImpl  implements  com.yy.ws.MobileBoss{   
11.             public  com.yy.ws.ServerResponse charge(com.yy.ws.ClientRequest in0)  throws  java.rmi.RemoteException {   
12.                 return   null ;   
13.            }   
14.          
15.        }   
我们需要在这个 webservice 中实现自己的业务方法！我们加入如下业务代码：
java 代码
1.           /**  
2.            * MobileBossSoapBindingImpl.java  
3.            *  
4.            * This file was auto-generated from WSDL  
5.            * by the Apache Axis 1.3 Oct 05, 2005 (05:23:37 EDT) WSDL2Java emitter.  
6.            */   
7.             
8.           package  com.yy.ws;   
9.             
10.        public   class  MobileBossSoapBindingImpl  implements  com.yy.ws.MobileBoss {   
11.          
12.             /*  
13.             *   
14.             * implements the service methods  
15.             */   
16.             public  com.yy.ws.ServerResponse charge(com.yy.ws.ClientRequest req)   
17.                     throws  java.rmi.RemoteException {   
18.                String bizInfo = req.getPhoneNumber() +  "/"  + req.getOpType() +  "/"   
19.                        + req.getAmount();   
20.                System.out.println(bizInfo);   
21.                System.out.println(req.getPhoneNumber() +  "is charged successfully!" );   
22.                ServerResponse res =  new  ServerResponse();   
23.                res.setMessage(bizInfo); // save service informations.   
24.                res.setResultCode( 8888 ); // save result code.   
25.                 return  res;   
26.            }   
27.          
28.        }   
 

相关推荐: 关于 Web Service 的一些理解 如何接收SOAP消息 从银行WebService报文接口系统中,学习敏捷设计 基于Apache CXF构建SOA应用—任钢 SOA、WebService、UDDI、WSDL、SOAP、MSMQ概念.docx C#实现SOAP调用WebService C++的soap通信类 初步理解一下：SOA, SOAP, Web Service, WSDL等
推荐群组: Runtime
更多相关推荐
SOA 开发了一个web service,想查看client 与 service之间的具体传输的soap信息,包括头信息,希望大家指教啊！

相关推荐: 手把手教你用axis创建自己的webservice(五) 手把手教你用axis创建自己的webservice(三) 在axis中通过wsdd文件发布和卸载webservice WebService实例&调用本质&权限控制 WebService与SOA的实现 WebService的 http/soap调用 完整过程 SOA SOAP WebService 跨系统调用接口方案----WebService
推荐群组: D语言
更多相关推荐
SOA 最近在学WebService,可是当中碰到了问题,不是很明白,断点跟踪也不知道为什么环境是：axis1.4,jdk1.5,tomcat5.0 调用端的代码： ClientRequest req = new ClientRequest(); req.setUserName(form.getUserName()); req.setPassworld(form.getPassworld()); LoginService sl = new LoginServiceLocator(); Login mb = sl.getLogin();// default port ServerResponse resp = mb.validLogin(req); if (resp.getMessage() != null && resp.getMessage().size() != 0) { path = "success"; Vector result = resp.getMessage(); request.setAttribute("message",((java.util.Date)result.get(0)));//就是这里出错,我在WebService中设置的是util里的Date,但这里却报CLASS转换异常,我断点进去看了下,却是GregorianCalendar这个类型,请各位帮忙看看 } else { path = "error"; } SoapBindingImpl的代码： public com.cj.webservice.ServerResponse validLogin(com.cj.webservice.ClientRequest cr) throws java.rmi.RemoteException { ServerResponse sr = new ServerResponse(); Vector v = new Vector(); try{ if(cr.getUserName().equals("chenjun") && cr.getPassworld().equals("12345")) { v.add(new java.util.Date()); //这里设的是util的Date } sr.setMessage(v); }catch(Exception e){ e.printStackTrace(); } return sr; }

相关推荐: 用Axis创建的Webservice的集成与发布(下) 实战WebService II: SOAP篇(基于php) CXF WebService视频教程,自己录的（更新第7集 异步调用 2009.1.15）。 使用 PHP 开发基于 Web 服务的应用程序 从 PHP 脚本中访问企业应用程序 使用 PHP 5 SOAP 扩展访问 WebSphere Web 服务 21天通关Python（仅视频课） 学习MySQL这一篇就够了
推荐群组: phper
更多相关推荐
SOA java如何调用php用NuSOAP写的WebService,感觉跟axis的jws提供的webservice接口不一样。如localhost/test.php 这种方式 或者是localhost/test.php?WSDL 这种方式 有谁用过吗？指点一下~~

相关推荐: XFire 最新生火指南（上） XFire令WebService如此简单 关于XFire来做Web Service, 传入Service接口方法中的Collection类的值丢失的问题 dubbo 用户指南 CXF笔记 计算机科学精彩帖子收集--JAVA和分布式专栏 DUBBO使用指南 DUBBO用户指南(笔记)
推荐群组: Spring之旅
更多相关推荐
SOA 请问如果用xfire,在service类的接口方法中,如果有传入参数或传出参数是自定义类型的, 那么相应的aegis文件应该怎么写?我在官网上查到,如果要有自定义类型的对象传到stub的接口方法中, 需要另外写一个ClassName.aegis.xml文件,放在这个自定义VO类的同一个包下的, 见: http://xfire.codehaus.org/Aegis+Binding , 不过介绍得不清楚, 连个完整的例子也没给出. 请问有谁做过的, 请给出个例子来参考一下.这个问题困扰了我两个星期了.谢谢大家.