• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

原文来自： 怎样了解一个行业？从哪些角度去了解？怎样去了解行业特性？

1.什么是行业？什么是产业？两者有什么区别？

答：按照定义来说， 产业应该是按照规模经济和范围经济要求集成起来的行业群体。通俗的说法就是，行业是社会分工后细化的一类工作，能以此为生，但可能行业规模和运作方式不能大批量的延伸。产业则是一个行业发展到一定程度可以大规模的开拓市场拓展商业机会。

之所以讨论一下产业和行业的区别，是因为在当前市场经济的大潮下，行业的逻辑已经逐步在用产业的方式推进。所以，有了这个大前提，就能把很多商业的问题讨论清楚。所以，后面对行业的讨论，都是在产业的模式下讨论。对于那种米上雕子、火车站带路的买卖，只能是个小众的行业。研究起来价值有限。

2.一个产业应该有什么样的参数？从哪些角度去了解？

答：我们在学习化学的时候，常常会研究他的一些通用性能。比如金属，我们会研究他的导热性、燃点、导电性、颜色……所以，涉及到一个产业，也会有类似的一些参数，依照我个人的理解。可以从下面的几个角度去了解，这几个角度中也对应了一个产业应有的参数。

按照麦肯锡的战略研究来看，一个行业比较常见的分析方法是PEST 分析、波特的五力模型、SWOT分析法、竞争者分析等等。在解决这个问题的时候，我个人不是很推崇。我觉得从 菲利普·科特勒在其畅销书《营销管理：分析、规划与控制》提出的4Ps为核心的营销组合方法把我们对一个产业的理解尽收眼底，也把前面的几个战略分析能够尽收眼底。即：产品（Product）、价格 (Price）、渠道 (Place）、促销（Promotion）。下面我来细细拆分。

首先说产品。说到产品，要倒退一步说说研发，当前中国的研发还是集中在高校和部分有实力的企业中，相比美国的企业主导研发而言，中国的研发还是处于一种和市场脱节的状态下，应用性不够好，多数为了那国家课题而制作很多不必要的创新。而好的应用性研发很稀缺，以我听说中科院的一个分所最近出售的石墨烯生产技术为例，最终成交额以亿为单位，这样招人待见、高金额的例子几乎是凤毛麟角。可见，招市场青睐的技术不是那么容易被高校制造出来。说完研发，就是产品在理论研究后如何被工业化生产出来，一个生产过程就会涉及到工业技术路线的问题。比如环保行业的除尘，为了达到这个目标可以有电除尘、也可以由布袋除尘。选哪个，为什么选，就成了一个企业的产品特色。选定了工业技术路线就会有工程实现方式，把前面的原理和技术路线变成工程可操作的现实。而最要命的是，有的产品永远是非标准化的，耐克鞋没法像可口可乐一次就一个模子；而一些道路桥梁的建设则是全国各地都没个重样的，这些都会影响到产品的特性。

因此，一个产品的研究就涉及到了 产品的基础生产原理、工业技术路线、工程实现方式、标准化程度以及上游供应商，以上种种形成了一个产品的特性，也决定了后面的定价、营销。顺便说下，很多时候服务也是无形的产品，懒得打字就不细说了。

其次说价格。一个产品的特性其实就融合了很多价格的基础。一般来说，咱们做一个产业不能亏本吧。以我熟悉的水务领域，是典型的国家规定“保本微利”行业。也就是说你不能多挣钱 。而北京的公交以四毛钱的绝对低廉，成就了一个公益性行业的美誉。除了产业特性和政策的影响外，供求关系也是绝对的影响，最近火热的艺术品投资市场，张大千等名家的画以足够的不可再生稀缺性获得了定价话语权。而在竞争性领域，华为这样的企业会把某个优势产品的价格拉到低利润，借此打垮竞争对手。总之，价格凝结了商业的很多内涵，也反映了很多产业的特性。

因此，一个产品价格的定制 涉及到了供求关系、产业特性、成本基础、政策影响、企业策略。

第三说渠道。渠道是客户买单和了解产品的基础。商业上有句话说，用渠道挣钱是一毛一毛的挣钱；用劳动力挣钱是一分一分的挣钱；用资本挣钱是一块一块的挣钱。写到这里，发现我们还在用一分一分挣钱，实在是让人倍感凄凉。不过还是要振作精神把字码完，别浪费了前面的一群汉子（汉字）。

建设渠道有很多方式，像沃尔玛这样的渠道，像苹果体验店这样的渠道，也有进批发市场的渠道，还有的产品，像第一财经日报，天然就是渠道。我听过一个故事，说某服装品牌全国建立了500家店，但是不怎么赢利，就把这个渠道网络卖掉了，就弄来了N个亿。可见没有渠道就没有产业的规模。

因此渠道的参数应该 包括渠道质量、渠道体量、渠道管控、渠道维护成本等等。

最后说说促销。到目前为止看到的促销内容，大家都多是理解为逛超市的时候搞个免费品尝、免费试用、半价促销、买二赠一……但是促销的精髓不在这种让利刺激上，而在刺激消费冲动上。注意，少了让利两个字内涵就大多了。如此说来，品牌影响力、回扣、迎合政绩等都是良好的促销方式。具体的，如果您有兴趣，我们可以细细用案例再交流。

因此，促销的参数应该包含 品牌形象、公关手法、价格联动、卖点买点等等。

好吧，以我的理解，各行各业都是从上面的四个角度去切入和理解。成为我们了解一个产业的思考模型和参数库。

3.那么，我们该如何切入一个行业去了解他呢？

答：第一位的是人。一个社会是人构成的，产业只是以经济和服务特性类似为纽带的一类人。以擒贼先擒王的思路看，就涉及到了政策制定者、技术专家、营销大师、生产能手、大客户等。不同的行业这些人散落的点不同。以GIS行业为例，政策制定者多在国土资源部、测绘地理信息局、交通部等；技术专家多在ESRI大外企、设计院、高等院校等地；营销大师和生产能手多在设计院和优质企业；大客户多是要找那些对产品购买有决策权的人。至于去哪里找到并熟悉这些人，我想展会、沙龙、产品发布会、他们上班的单位、资讯产品、论文、行研都是很好的渠道。

说完了人，其次才是事儿。也就是前面说的4Ps里面的各个环节，拆开了，揉碎了，挖深了的了解。对比不同的技术、渠道、客户等每个环节。用不了多久就能变成一个行业专家。

最后，我用一个小故事结尾吧。当年福特造汽车，还不是流水线生产，这个灵感来自于老福特参观了屠宰牛的工厂，发现一步一个工作，让效率最大化了，于是汽车工业就带来了流水线的生产。可见，对一个行业的研究和了解是一个开发的过程，跨行业的创新常常能给一个行业一次洗牌的机会。

就像马云和他的淘宝，让多少小城市的服装城欲哭无泪。

1，具体的思路如下：

　　在android中写一个Activity，里面写一个webview，这个webview加载本地的一个html文件，显示这个网页，这个网页包括一个用户名和密码的输入框和两个按钮（只有登陆按钮有用），输入用户名密码之后调用android中的类，并把输入的数据传过去，再在android中输出出来（具体你那数据做什么操作就看你的需求了），这样就做大额js与android数据交互的效果了：

　　在android端，一些webviwe的设置和自定义类的写法如下源码：

　　package com.example.webview;

　　import android.app.Activity;
　　import android.os.Bundle;
　　import android.webkit.JavascriptInterface;
　　import android.webkit.WebChromeClient;
　　import android.webkit.WebSettings;
　　import android.webkit.WebView;

　　public class MainActivity extends Activity {
　　　　private WebView webview;
　　　　private String URL = "http://192.168.31.122/word2/login.html";//这是你要访问你html文件的存放地址，我这个是放在appache中的word文件夹下的login.html文件
　　　　@Override
　　　　protected void onCreate(Bundle savedInstanceState) {
　　　　　　super.onCreate(savedInstanceState);
　　　　　　setContentView(R.layout.activity_main);
　　　　　　webview = (WebView) findViewById(R.id.webView1);
　　　　　　WebSettings webset = webview.getSettings();
　　　　　　webset.setJavaScriptEnabled(true);// 表示webview可以执行服务器端的js代码
　　　　　　webview.setWebChromeClient(new WebChromeClient(){});
　　　　　　webview.addJavascriptInterface(new JsObject(),"jsObject");
　　　　　　webview.loadUrl(URL);
　　　　}

　　　　public class JsObject {
　　　　　　@JavascriptInterface
　　　　　　public void getMessage(String name, String pwd) {
　　　　　　　　// TODO Auto-generated method stub
　　　　　　　　System.out.println("==="+"name:" + name + "---pwd:" + pwd);
　　　　　　}
　　　　}

　　}

　　而xml比较简单，只是一个比较简单的webview而已，代码如下：

　　<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

　　　　android:layout_width="fill_parent"

　　　　android:layout_height="fill_parent"
　　　　android:orientation="vertical" >

　　　　<WebView
　　　　　　android:id="@+id/webView1"
　　　　　　android:layout_width="match_parent"
　　　　　　android:layout_height="match_parent" />

　　</LinearLayout>

　　对于要加载的html文件只要放在你要访问的地方就可以，比如appache下，具体代码如下：

　　 <!DOCTYPE html>

　　<html>
　　　　<head>
　　　　　　<script>
　　　　　　　　function login(){
　　　　　　　　　　var th = document.form;
　　　　　　　　　　var user = th.user.value;
　　　　　　　　　　if(user==""){
　　　　　　　　　　　　alert("请输入用户名!");
　　　　　　　　　　}else{
　　　　　　　　　　　　var name = th.user.value;
　　　　　　　　　　　　var pwd = th.pwd.value;
　　　　　　　　　　　　var name2 = jsObject.getMessage(name,pwd);
　　　　　　　　　　}
　　　　　　　　}
　　　　　　</script>
　　　　</head>
　　　　<body>
　　　　　　<form name='form' method='post' class='form' action=''>
　　　　　　　　<table id='login_table'>
　　　　　　　　　　<tr>
　　　　　　　　　　　　<td>
　　　　　　　　　　　　　　<span>账号:</sapn>
　　　　　　　　　　　　</td>
　　　　　　　　　　　　<td>
　　　　　　　　　　　　　　<input type='text' class='usr' name='user' value=''/>
　　　　　　　　　　　　</td>
　　　　　　　　　　　　<td></td>
　　　　　　　　　　</tr>
　　　　　　　　　　<tr>
　　　　　　　　　　　　<td>
　　　　　　　　　　　　　　<span>密码:</sapn>
　　　　　　　　　　　　</td>
　　　　　　　　　　　　<td>
　　　　　　　　　　　　　　<input type='password' class='psw' name='pwd' value=''/>
　　　　　　　　　　　　</td>
　　　　　　　　　　　　<td></td>
　　　　　　　　　　</tr>
　　　　　　　　　　<tr>
　　　　　　　　　　　　<td></td>
　　　　　　　　　　　　<td>
　　　　　　　　　　　　　　<input type="file" value="上传图片" />
　　　　　　　　　　　　　　<button class='denglu' onclick="login()">登陆</button>
　　　　　　　　　　　　　　<button class='clear'>清空</button>
　　　　　　　　　　　　</td>
　　　　　　　　　　　　<td></td>
　　　　　　　　　　</tr>
　　　　　　　　</table>
　　　　　　</form>
　　　　</body>
　　</html>
　　

本文链接： WebView之js调用Android类的方法传递数据，转载请注明。

     Cookie管理是大家在做安卓app中难以避免的问题。我在此发表一些拙见。

     先先看看cookie可能存放的位置

　　1.Httpclient会存储当次请求的cookie内容，存储位置在 httpClient.getCookieStore 但是apache建议自定义cookie存储方式，因为cookiestore把cookie放在arraylist里很容易被系统回收[1]。

　　2.WebView会存储cookie在CookieManager,具体使用方式，后续的文章会讲这里不是重点。

　　正常HttpClient中得Cookie是不能与WebView中得Cookie共享的所以这里需要一个中间变量(这里叫做CookieMap)来管理Cookie。每次请求的时候都要刷新CookieMap，我推荐的Cookie管理方式是只增加、修改不删除。每次请求完成都要进行一次Cookie同步,有的app要求保持登陆状态，所以也有必要把cookie放入Preference。

　　在请求之前，如果要自己在header中setcookie的话那么就不要保留httpclient中的cookie否则容易造成给服务器提交的request的header中包含两个cookie的情况，有的会造成服务器混乱。

　　偶尔会碰到api和webview所做的请求在不同域的情况那么就要求重新设置cookie的域和path，这里鼓励把path范围设置的大一些否则有些请求可能得不到cookie。

　　下面是当Logout的时候需要做得cookie清理工作，如果使用cookie来判断是否登录的话，则只清理本地cookiemap和Preference中得cookie是不够的。还需要清理掉webview中的对应的cookie。否则下次登陆依然是登陆状态。

　　希望这篇文章对大家的工作有所帮助。接下来会写一篇关于httpclient配置的文章。

 [1].http://hc.apache.org/httpcomponents-client-ga/tutorial/html/statemgmt.html

本文链接： 关于安卓中的cookie管理，转载请注明。

• SOA集成平台降低了IT资源和人力资源投入成本
• 基于SOA的流程整合，降低了业务和流程变化造成的改造成本
• SOA实施进一步优化管理流程，减低了管理本身成本
• SOA规范和治理体系的建立，进一步降低后续IT系统运维成本

• 采用平台中心集中和节点分布管理的模式，适应机构之间垂直和横向行政管理关系并存的需求；
• 平台提供系统统一集中远程部署管理、完善的安装、远程服务组件部署、配置、远程监控等手段，保证平台高度的可管理性和维护性；
• 系统支持多种应用管理模式，如集中控制管理和分级递阶控制管理等应用管理模式，适应机构纵向、横向、分级等多种管理模式的要求。

• 采用完整、先进、成熟的软件技术和产品，充分利用中间件和企业服务总线(ESB)技术，采用完全分布式、事件驱动和面向服务(SOA)的架构设计；
• 平台底层采用可靠数据传输的中间件技术，节点业务系统之间的交换采用端对端(P2P)的可靠数据安全传输机制；
• 软件平台在架构方面保证了灵活的可扩展性，当节点和业务增加时，因为数据无须经过中央服务器，从而避免平台的效率瓶颈和中央服务器单点故障；
• 平台采用可重用的服务组件化设计，服务组件及适配器可重用性高，并支持配置管理和分布式远程部署。

• 基于底层的可靠数据传输的中间件技术，系统提供任何节点之间的可靠事件传输、断点续传等功能；
• 系统支持传输数据压缩加密的技术，保证数据的保密性、完整性和有效性，并通过集成第三方提供的CA/PKI身份认证服务，可实现节点之间的安全身份认证。
• 系统通过服务器备份和服务组件备份的两种备份机制，提供一定的容错能力与容灾能力，充分保证数据安全和系统的可靠性，重要数据的完整性、一致性和可恢复性；
• 系统具有安全运行管理措施，提供了服务异常告警和安全日志的功能；
• 系统平台提供了对业务数据(流程)的监控功能，以及使用工具来跟踪查找事件的功能。

• 平台由Java语言开发，支持Windows、Linux/Unix不同的操作系统，并支持主流数据库系统的市场现行版本，包括Oracle、DB2、SQL Server、Sybase等；
• 平台提供的预制适配服务组件，支持主流的应用服务器(J2EE 和.NET应用服务器等)软件市场现行版本，以及支持主流的消息中间件服务器(MQ, JMS Server)等产品，
• 平台支持用不同的语言开发服务，如Java、C/C++、VB、C#等，并提供多种语言(Java、C/C++、VB、C#)的API集成接口，满足集成不同委办局异构系统的要求。
• 平台系统具有强大的对现有各种异构系统的整合能力，有效地支持与各种消息中间件、各种异构数据库和不同语言开发的应用系统整合，最大限度地保护客户现有的投资。

场景：小时候我们都使用过新华字典，妈妈叫你翻开第38页，找到“坑爹”所在的位置，此时你会怎么查呢？毫无疑问，你的眼睛会从38页的第一个字开始从头至尾地扫描，直到找到“坑爹”二字为止。这种搜索方法叫做 顺序扫描法。对于少量的数据，使用顺序扫描是够用的。但是妈妈叫你查出坑爹的“坑”字在哪一页时，你要是从第一页的第一个字逐个的扫描下去，那你真的是被坑了。此时你就需要用到 索引。索引记录了“坑”字在哪一页，你只需在索引中找到“坑”字，然后找到对应的页码，答案就出来了。因为在索引中查找“坑”字是非常快的，因为你知道它的偏旁，因此也就可迅速定位到这个字。

那么新华字典的目录（索引表）是怎么编写而成的呢？首先对于新华字典这本书来说，除去目录后，这本书就是一堆没有结构的数据集。但是聪明的人类善于思考总结，发现每个字都会对应到一个页码，比如“坑”字就在第38页，“爹”字在第90页。于是他们就从中提取这些信息，构造成一个有结构的数据。类似数据库中的表结构：

word    page_no
---------------
坑        38
爹        90
...       ...

这样就形成了一个完整的目录（索引库），查找的时候就非常方便了。对于全文检索也是类似的原理，它可以归结为两个过程：1.索引创建（Indexing）2. 搜索索引（Search）。那么索引到底是如何创建的呢？索引里面存放的又是什么东西呢？搜索的的时候又是如何去查找索引的呢？带着这一系列问题继续往下看。

索引

Solr/Lucene采用的是一种反向索引，所谓 反向索引：就是从关键字到文档的映射过程，保存这种映射这种信息的索引称为反向索引

• 左边保存的是字符串序列
• 右边是字符串的文档（Document）编号链表，称为倒排表（Posting List）

字段串列表和文档编号链表两者构成了一个字典。现在想搜索”lucene”，那么索引直接告诉我们，包含有”lucene”的文档有：2，3，10，35，92，而无需在整个文档库中逐个查找。如果是想搜既包含”lucene”又包含”solr”的文档，那么与之对应的两个倒排表去交集即可获得：3、10、35、92。

索引创建

假设有如下两个原始文档：
文档一：Students should be allowed to go out with their friends, but not allowed to drink beer.
文档二：My friend Jerry went to school to see his students but found them drunk which is not allowed.
创建过程大概分为如下步骤：

一：把原始文档交给分词组件(Tokenizer)
分词组件(Tokenizer)会做以下几件事情(这个过程称为：Tokenize)，处理得到的结果是词汇单元（Token）

1. 将文档分成一个一个单独的单词
2. 去除标点符号
3. 去除停词(stop word)
   • 所谓停词(Stop word)就是一种语言中没有具体含义，因而大多数情况下不会作为搜索的关键词，这样一来创建索引时能减少索引的大小。英语中停词(Stop word)如：”the”、”a”、”this”，中文有：”的，得”等。不同语种的分词组件(Tokenizer)，都有自己的停词(stop word)集合。经过分词(Tokenizer)后得到的结果称为词汇单元(Token)。上例子中，便得到以下 词汇单元(Token)：

     "Students"，"allowed"，"go"，"their"，"friends"，"allowed"，"drink"，"beer"，"My"，"friend"，"Jerry"，"went"，"school"，"see"，"his"，"students"，"found"，"them"，"drunk"，"allowed"

二：词汇单元(Token)传给语言处理组件(Linguistic Processor)
语言处理组件(linguistic processor)主要是对得到的词元(Token)做一些语言相关的处理。对于英语，语言处理组件(Linguistic Processor)一般做以下几点：

1. 变为小写(Lowercase)。
2. 将单词缩减为词根形式，如”cars”到”car”等。这种操作称为：stemming。
3. 将单词转变为词根形式，如”drove”到”drive”等。这种操作称为：lemmatization。

语言处理组件(linguistic processor)处理得到的结果称为 词(Term)，例子中经过语言处理后得到的词(Term)如下：

"student"，"allow"，"go"，"their"，"friend"，"allow"，"drink"，"beer"，"my"，"friend"，"jerry"，"go"，"school"，"see"，"his"，"student"，"find"，"them"，"drink"，"allow"。

经过语言处理后，搜索drive时drove也能被搜索出来。 Stemming 和 lemmatization的异同：

• 相同之处：
  1. Stemming和lemmatization都要使词汇成为词根形式。
• 两者的方式不同：
  1. Stemming采用的是”缩减”的方式：”cars”到”car”，”driving”到”drive”。
  2. Lemmatization采用的是”转变”的方式：”drove”到”drove”，”driving”到”drive”。
• 两者的算法不同：
  1. Stemming主要是采取某种固定的算法来做这种缩减，如去除”s”，去除”ing”加”e”，将”ational”变为”ate”，将”tional”变为”tion”。
  2. Lemmatization主要是采用事先约定的格式保存某种字典中。比如字典中有”driving”到”drive”，”drove”到”drive”，”am, is, are”到”be”的映射，做转变时，按照字典中约定的方式转换就可以了。
  3. Stemming和lemmatization不是互斥关系，是有交集的，有的词利用这两种方式都能达到相同的转换。

三：得到的词(Term)传递给索引组件(Indexer)

1. 利用得到的词(Term)创建一个字典

   Term    Document ID
   student     1
   allow       1
   go          1
   their       1
   friend      1
   allow       1
   drink       1
   beer        1
   my          2
   friend      2
   jerry       2
   go          2
   school      2
   see         2
   his         2
   student     2
   find        2
   them        2
   drink       2
   allow       2

2. 对字典按字母顺序排序：

   Term    Document ID
   allow       1
   allow       1
   allow       2
   beer        1
   drink       1
   drink       2
   find        2
   friend      1
   friend      2
   go          1
   go          2
   his         2
   jerry       2
   my          2
   school      2
   see         2
   student     1
   student     2
   their       1
   them        2

3. 合并相同的词(Term)成为文档倒排(Posting List)链表
   • Document Frequency：文档频次，表示多少文档出现过此词(Term)
   • Frequency：词频，表示某个文档中该词(Term)出现过几次

对词(Term) “allow”来讲，总共有两篇文档包含此词(Term)，词（Term)后面的文档链表总共有两个，第一个表示包含”allow”的第一篇文档，即1号文档，此文档中，”allow”出现了2次，第二个表示包含”allow”的第二个文档，是2号文档，此文档中，”allow”出现了1次

至此索引创建完成，搜索”drive”时，”driving”，”drove”，”driven”也能够被搜到。因为在索引中，”driving”，”drove”，”driven”都会经过语言处理而变成”drive”，在搜索时，如果您输入”driving”，输入的查询语句同样经过分词组件和语言处理组件处理的步骤，变为查询”drive”，从而可以搜索到想要的文档。

搜索步骤

搜索”microsoft job”，用户的目的是希望在微软找一份工作，如果搜出来的结果是:”Microsoft does a good job at software industry…”，这就与用户的期望偏离太远了。如何进行合理有效的搜索，搜索出用户最想要得结果呢？搜索主要有如下步骤：

一：对查询内容进行词法分析、语法分析、语言处理

1. 词法分析：区分查询内容中单词和关键字，比如：english and janpan，”and”就是关键字，”english”和”janpan”是普通单词。
2. 根据查询语法的语法规则形成一棵树
   

3. 语言处理，和创建索引时处理方式是一样的。比如：leaned–>lean，driven–>drive

二：搜索索引，得到符合语法树的文档集合
三：根据查询语句与文档的相关性，对结果进行排序

我们把查询语句也看作是一个文档，对文档与文档之间的相关性（relevance）进行打分（scoring），分数高比较越相关，排名就越靠前。当然还可以人工影响打分，比如百度搜索，就不一定完全按照相关性来排名的。

如何评判文档之间的相关性？一个文档由多个（或者一个）词（Term）组成，比如：”solr”， “toturial”，不同的词可能重要性不一样，比如solr就比toturial重要，如果一个文档出现了10次toturial，但只出现了一次solr，而另一文档solr出现了4次，toturial出现一次，那么后者很有可能就是我们想要的搜的结果。这就引申出权重（Term weight）的概念。

权重表示该词在文档中的重要程度，越重要的词当然权重越高，因此在计算文档相关性时 影响力就更大。通过词之间的权重得到文档相关性的过程叫做 空间向量模型算法(Vector Space Model)

影响一个词在文档中的重要性主要有两个方面：

• Term Frequencey（tf），Term在此文档中出现的频率，ft越大表示越重要
• Document Frequency（df），表示有多少文档中出现过这个Trem，df越大表示越不重要
  物以希为贵，大家都有的东西，自然就不那么贵重了，只有你专有的东西表示这个东西很珍贵，权重的公式：
  

空间向量模型

文档中词的权重看作一个向量

Document = {term1, term2, …… ,term N}
Document Vector = {weight1, weight2, …… ,weight N}

把欲要查询的语句看作一个简单的文档，也用向量表示：

Query = {term1, term 2, …… , term N}
Query Vector = {weight1, weight2, …… , weight N}

把搜索出的文档向量及查询向量放入N维度的空间中，每个词表示一维：

夹角越小，表示越相似，相关性越大

参考： http://www.cnblogs.com/guochunguang/articles/3641008.html

相关文章

• 全文检索引擎Solr系列——入门篇
• Java 8 新特性
• Google Play服务和OAuth认证工具
• JVM 性能优化, Part 4: C4 垃圾回收
• Google I/O 2013隆重推出Android Studio （含下载地址）
• Hadoop教程（一）
• 关于《Java那么健壮，怎么会挂？》的1000条回复
• HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap
• 集合类接口和类层次关系图
• Java for-each循环解惑

㈡ 定位原因：

INSERT INTO t (col1, col2, col3, col4, col5, col6, col7) VALUES ('3532082239485507011_130_99', '130_99', 130, 99, 3532082239485507011, 2172353000317425008, 29078) 

select trx_id,trx_state,trx_started,trx_requested_lock_id,trx_weight,trx_mysql_thread_id from information_schema.innodb_trx where trx_state='RUNNING';

㈣ 我的疑问：


为什么这条执行了1个多小时的SQL没有被记录到慢查询日志中呢？？


㈤ 原来如此：


Query_time - Lock_time > long_query_time  <===记录
Query_time - Lock_time < long_query_time  <===不记录


㈥ 模拟场景：


⑴ Query_time - Lock_time > long_query_time

Session_A：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> select emp_no,hire_date from employees where emp_no=10170 for update;
+--------+------------+
| emp_no | hire_date  |
+--------+------------+
|  10170 | 1986-01-02 |
+--------+------------+
1 row in set (0.00 sec)

Session_B:

mysql> select emp_no,hire_date,sleep(3) from employees where emp_no=10170 for update;

过段时间在A做commit，B会执行、并被记录到slow log中：

# Time: 140818 22:37:31
# User@Host: root[root] @ localhost []  Id:     1
# Query_time: 3.049016  Lock_time: 0.018891 Rows_sent: 1  Rows_examined: 1
use employees;
SET timestamp=1408372651;
select emp_no,hire_date,sleep(3) from employees where emp_no=10170 for update;

Session_A：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> select emp_no,hire_date from employees where emp_no=10170 for update;
+--------+------------+
| emp_no | hire_date  |
+--------+------------+
|  10170 | 1986-01-02 |
+--------+------------+
1 row in set (0.00 sec)

Session_B:

mysql> select emp_no,hire_date from employees where emp_no=10170 for update;

㈦ 我的收获：

我们日常做性能剖析实际上应该包括2个方面：

1）基于执行时间的分析

2）基于等待时间的分析

By water

Good Luck！

1、什么是序列化和反序列化

2、JDK的序列化

import java.io.Serializable;

public class Block implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private int id;
	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Block(int id, String name) {
		this.id = id;
		this.name = name;
	}

}

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

public class TestSerializable {
	public static void main(String[] args) throws IOException,
			ClassNotFoundException {
		//将序列化化的数据写到文件out里面（持久化）
		FileOutputStream fos = new FileOutputStream("./out");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		for (int i = 0; i < 100; i++) {
			Block b = new Block(i, "B"+i);
			oos.writeObject(b);
		}
		oos.flush();
		oos.close();
		//读出一个序列化的对象的字节序列（^..^）就是反序列化
		FileInputStream fis = new FileInputStream("./out");
		ObjectInputStream ois = new ObjectInputStream(fis);
		Block b2 = (Block) ois.readObject();
		ois.close();
		System.out.println(b2.getName());
	}
}

B0

3、hadoop的序列化

package hadoop;

import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.junit.Test;

public class Testhadoop_serializable_writable {
	@Test
	public void serializable() throws IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		DataOutputStream dataOut = new DataOutputStream(out);
		FileOutputStream fos = new FileOutputStream("./hadoop_out");
		for (int i = 0; i < 10; i++) {
			Text t1 = new Text(String.valueOf(i));
			Text t2 = new Text("mw");
			MyWritable mw = new MyWritable(t1,t2);
			mw.write(dataOut);
		}
		dataOut.close();
		fos.write(out.toByteArray());
		fos.flush();
		fos.close();

		FileInputStream fis = new FileInputStream("./hadoop_out");
		DataInputStream dis = new DataInputStream(fis);
		for (int i = 0; i < 10; i++) {
			MyWritable mw = new MyWritable(new Text(), new Text());
			mw.readFields(dis);
			System.out.println(mw.getId() + " " + mw.getName());
		}

	}
}

class MyWritable implements Writable {
	private Text id;
	private Text name;

	public MyWritable(Text id, Text name) {
		super();
		this.id = id;
		this.name = name;
	}

	public synchronized Text getId() {
		return id;
	}

	public synchronized void setId(Text id) {
		this.id = id;
	}

	public synchronized Text getName() {
		return name;
	}

	public synchronized void setName(Text name) {
		this.name = name;
	}

	@Override
	public void write(DataOutput out) throws IOException {
		id.write(out);
		name.write(out);
	}

	@Override
	public void readFields(DataInput in) throws IOException {
		id.readFields(in);
		name.readFields(in);
	}

}

$.fn.listen=function(type,fn){
	returnthis.each(function(){
		$(this)[0].addEventListener(type,function(e){
			if(!fn.call($(this),e)){
				e.stopPropagation();
				e.preventDefault();
			}
		},0);
	});
}
$(document).bind("dragenter",function(){
	returnfalse;
}).bind("dragover",function(){
	returnfalse;
}).listen("drop",function(e){
	// 这里处理拖拽进来的文件（们）
});

$(document).bind("dragenter",function(){
	returnfalse;
}).bind("dragover",function(){
	returnfalse;
}).bind("drop",function(e){
	console.log(e);
}).listen("drop",function(e){
	console.log(e);
});

console.log(e.dataTransfer.files);

$(document).bind("dragenter",function(){
	returnfalse;
}).bind("dragover",function(){
	returnfalse;
}).listen("drop",function(e){
    var files=e.dataTransfer.files;
    var error='';
    for(var i=0;i<files.length;i++){
    console.log(files[i]);
    if(files[i].size>1024*100)error+='第'+(i+1)+'个文件超过大小限制\n';
    if(!/image/i.test(files[i].type))error+='第'+(i+1)+'个文件不是图片格式\n';
}
if(error)alert(error);
});

$(document).bind("dragenter",function(){
	returnfalse;
}).bind("dragover",function(){
	returnfalse;
}).listen("drop",function(e){
    var files=e.dataTransfer.files;
    var error='';
    for(var i=0;i<files.length;i++){
    if(files[i].size>1024*100)error+='第'+(i+1)+'个文件超过大小限制\n';
    if(!/image/i.test(files[i].type))error+='第'+(i+1)+'个文件不是图片格式\n';
}
// 有错误抛弃
if(error){
    alert(error);
    return;
}
// 处理文件队列
for(var i=0;i<files.length;i++){
	read(files[i]);
}
});
function read(file){
	var reader=newFileReader();
 	reader.onload=function(e){
		$("body").append('<img src="'+e.target.result+'" alt="" />');
	}
	reader.readAsDataURL(file);
}

• —软件人才免语言低担保 赴美带薪读研！—

package com.chapterOne.exercise;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * Created by yangjianzhou on 2014/8/18 21:36.
 * TODO :给定一个大小为N*M的迷宫，迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四
 * 格的通道移动。求从起点到终点所需的最小步数。
 */
public class Maze {

    private static final int INF = 100000;
    private static final int N = 10;
    private static final int M = 10;
    private static char[][] mazeMatrix = {
            {'#', 'S', '#', '#', '#', '#', '#', '#', 'o', '#'},
            {'o', 'o', 'o', 'o', 'o', 'o', '#', 'o', 'o', '#'},
            {'o', '#', 'o', '#', '#', 'o', '#', '#', 'o', '#'},
            {'o', '#', 'o', 'o', 'o', 'o', 'o', 'o', 'o', 'o'},
            {'#', '#', 'o', '#', '#', 'o', '#', '#', '#', '#'},
            {'o', 'o', 'o', 'o', '#', 'o', 'o', 'o', 'o', '#'},
            {'#', '#', '#', '#', '#', '#', '#', '#', 'o', '#'},
            {'o', 'o', 'o', '#', 'o', 'o', 'o', 'o', 'o', 'o'},
            {'o', '#', '#', '#', '#', 'o', '#', '#', '#', 'o'},
            {'o', 'o', 'o', 'o', '#', 'o', 'o', 'o', 'G', '#'}
    };
    ;
    private static int xs = 0;
    private static int ys = 1;
    private static int xe = 9;
    private static int ye = 8;
    private static int[][] distance = new int[N][M];

    private static int[] xd = {1, 0, -1, 0};
    private static int[] yd = {0, 1, 0, -1};

    public static void main(String[] args) {
        initDistance();
        Maze maze = new Maze();
        int dis = maze.bfs();
        System.out.println("shortest length is : " + dis);
        printDistance();
    }

    private int bfs() {
        Queue<Point> que = new ConcurrentLinkedQueue<Point>();
        que.add(new Point(xs, ys));
        distance[xs][ys] = 0;
        while (que.size() > 0) {
            Point point = que.poll();
            if (point.getX() == xe && point.getY() == ye) {
                break;
            }
            for (int i = 0; i < 4; i++) {
                int xp = point.getX() + xd[i];
                int yp = point.getY() + yd[i];
                if (0 <= xp && xp < N && 0 <= yp && yp < M && mazeMatrix[xp][yp] != '#' && distance[xp][yp] == INF) {
                    que.add(new Point(xp, yp));
                    distance[xp][yp] = distance[point.getX()][point.getY()] + 1;
                }
            }
        }
        return distance[xe][ye];
    }

    private static void initDistance() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                distance[i][j] = INF;
            }
        }
    }

    private static void printDistance() {
        for (int i = 0; i < N; i++) {
            System.out.println();
            for (int j = 0; j < M; j++) {
                System.out.print("\t\t" + distance[i][j]);
            }
        }
    }

    class Point {
        int x;
        int y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

        public void setX(int x) {
            this.x = x;
        }

        public void setY(int y) {
            this.y = y;
        }
    }
}

shortest length is : 22

		100000	0		100000	100000	100000	100000	100000	100000	13		100000
		2		1		2		3		4		5		100000	13		12		100000
		3		100000	3		100000	100000	6		100000	100000	11		100000
		4		100000	4		5		6		7		8		9		10		11
		100000	100000	5		100000	100000	8		100000	100000	100000	100000
		8		7		6		7		100000	9		10		11		12		100000
		100000	100000	100000	100000	100000	100000	100000	100000	13		100000
		100000	100000	100000	100000	18		17		16		15		14		15
		100000	100000	100000	100000	100000	18		100000	100000	100000	16
		100000	100000	100000	100000	100000	19		20		21		22		100000

• —软件人才免语言低担保 赴美带薪读研！—

package com.mobovip.app;

import java.text.DecimalFormat;
import java.util.ArrayList;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;

public class LocationService extends Service{

	private Context context;
	public static ArrayList<Store> stores=new ArrayList<Store>();
	public static double distance = 3;//7430km
	private LocationManager locationManager;
	private NotificationManager notificationManager;
	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void onCreate() {
		super.onCreate();
		context = this;
		locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
		
//		if(locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)){
//			locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,1000, 1f, locationListener);
//		}else{
			locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,1000, 1f,locationListener);
//		}
		
//		Location location = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);     
//        if(location != null){
//        	checkDistance(location);
//        }     
        
	}

	
	private final LocationListener locationListener = new LocationListener() {
		//当坐标改变时触发此函数，如果Provider传进相同的坐标，它就不会被触发
	    public void onLocationChanged(Location location) { 
	        // log it when the location changes
	        if (location != null) {
	        	checkDistance(location);
	        }
	    }

	    // Provider被disable时触发此函数，比如GPS被关闭
	    public void onProviderDisabled(String provider) {
	    }

	    //  Provider被enable时触发此函数，比如GPS被打开
	    public void onProviderEnabled(String provider) {
	    }

	    // Provider的在可用、暂时不可用和无服务三个状态直接切换时触发此函数
	    public void onStatusChanged(String provider, int status, Bundle extras) {
	    }
	};
	
	@Override
	public void onDestroy() {
		super.onDestroy();
		if(locationManager!=null){
			locationManager.removeUpdates(locationListener); 
			locationManager=null;
		}
	}

	private void checkDistance(Location location) {
		if (location != null) {
			float[] results = new float[1];
			for (Store store : stores) {
				Location.distanceBetween(location.getLatitude(),
						location.getLongitude(), store.getLatitude(),
						store.getLongitude(), results);
				float result=(results[0] / 1000);//km
				if (result < distance) {
					showNotification(store);
					stopSelf();//不要频繁的提醒
					break;
				}
			}
		}
	}


	private static final int NOTIFY_ID = 0;
	private void showNotification(Store store) {
		notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
		
		Intent intent = new Intent(this, BGR.class);
//		intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP|Intent.FLAG_ACTIVITY_NEW_TASK);
		intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
		PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
				intent, PendingIntent.FLAG_UPDATE_CURRENT);// FLAG_ONE_SHOT
		Notification notification = new Notification.Builder(context)
				.setTicker(context.getString(R.string.app_name, ""))
				.setContentTitle(store.getStoreName()+"("+store.getDistance()+")")
				.setContentText(store.getStoreAddress())
				.setContentIntent(pendingIntent)
				.setSmallIcon(R.drawable.ic_launch_notify)
				.setAutoCancel(true)
				.setWhen(System.currentTimeMillis())
				.setDefaults(Notification.DEFAULT_ALL)
				.getNotification();
		notificationManager.notify(NOTIFY_ID, notification);
	}
}

package com.mobovip.app;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.IBinder;

public class NetworkStateService extends Service {

	private static final String tag = "tag";
	private BroadcastReceiver mReceiver = new BroadcastReceiver() {

		@Override
		public void onReceive(Context context, Intent intent) {
			String action = intent.getAction();
			if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
				ConnectivityManager manager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
				NetworkInfo info = manager.getActiveNetworkInfo();
				if (info != null && info.isAvailable()) {
					Intent service = new Intent(context, LocationService.class);
					startService(service);
				} else {
					Intent service = new Intent(context, LocationService.class);
					stopService(service);
				}
			}
		}
	};

	@Override
	public boolean onUnbind(Intent intent) {
		// TODO Auto-generated method stub
		return super.onUnbind(intent);
	}

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void onCreate() {
		super.onCreate();
		IntentFilter mFilter = new IntentFilter();
		mFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
		registerReceiver(mReceiver, mFilter);
	}

	@Override
	public void onDestroy() {
		super.onDestroy();
		unregisterReceiver(mReceiver);
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		return super.onStartCommand(intent, flags, startId);
	}

}

package com.mobovip.app;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

/**
 * BootReceiver
 * 
 * @author NGJ
 * 
 */
public class BootReceiver extends BroadcastReceiver {

	@Override
	public void onReceive(Context context, Intent intent) {
		// TODO Auto-generated method stub
		Intent i = new Intent(context, NetworkStateService.class);
		i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
		context.startService(i);
	}

}

<service android:enabled="true" android:name="com.mobovip.app.NetworkStateService" /><service android:enabled="true" android:name="com.mobovip.app.LocationService" /><!-- <receiver android:name="com.mobovip.app.BootReceiver" ><intent-filter><action android:name="android.intent.action.BOOT_COMPLETED" /></intent-filter></receiver>
         -->

• —软件人才免语言低担保 赴美带薪读研！—

中国移动裁撤劳务派遣员工：涉及近30万人

【TechWeb报道】8月19日消息，国内有媒体报道，中移动山东、福建、山西等省公司正在进行裁员计划，其中大量劳务派遣员工被裁撤，涉及近30万人。

一份中国移动近期内部资料显示，该集团目前劳务派遣人员占比为62%。为了落实相关规定，要求劳务派遣用工占比年底前要下降到50%以下，2015年底前下降到10%以下。中国移动目前用工数约60万，按照资料内容，在2015年底之前，需要对近30万劳务工进行职位调整。

据了解，今年6月底，山东移动率先开始裁员。据山东移动省公司内部人士透露，全省17市裁员超过6000余人，其中大部分为劳务派遣人员。

此外，山西移动、黑龙江移动、福建移动等地也均在进行劳务工裁员，其中山西移动已属今年第二次裁员。山西移动给予裁员补偿，并给主动离职者提供双份补偿。

据悉，作为竞争对手的中国电信、中国联通也有相应的裁员计划。（阿茹汗）

• 轻量级的 JSON API
• HTTP 2 Client：支持 HTTP 2.0 和 WebSockets，替代传统的 HttpURLConnection
• Process API 更新：提升对操作系统进程的控制和管理

• Improve contended locking：提升访问对象时的线程竞争处理
• Segmented code cache：更好的性能、更短的扫描时间，更少的碎片
• Smart Java compiler：或者叫 sjavac, 用于更大项目的构建

• —软件人才免语言低担保 赴美带薪读研！—

更新：下面的代码使用Lucene 4.0版本！

Lucene大大简化了在应用中集成全文搜索的功能。但实际上Lucene十分简单，我可以在五分钟之内向你展示如何使用Lucene。

1. 建立索引

为了简单起见，我们下面为一些字符串创建内存索引：

StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_40);
Directory index = new RAMDirectory();

IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_40, analyzer);

IndexWriter w = new IndexWriter(index, config);
addDoc(w, "Lucene in Action", "193398817");
addDoc(w, "Lucene for Dummies", "55320055Z");
addDoc(w, "Managing Gigabytes", "55063554A");
addDoc(w, "The Art of Computer Science", "9900333X");
w.close();

addDoc()方法把文档（译者注：这里的文档是Lucene中的Document类的实例）添加到索引中。

private static void addDoc(IndexWriter w, String title, String isbn) throws IOException {
  Document doc = new Document();
  doc.add(new TextField("title", title, Field.Store.YES));
  doc.add(new StringField("isbn", isbn, Field.Store.YES));
  w.addDocument(doc);
}

注意，对于需要分词的内容我们使用TextField，对于像id这样不需要分词的内容我们使用StringField。

2.搜索请求

我们从标准输入（stdin）中读入搜索请求，然后对它进行解析，最后创建一个Lucene中的Query对象。

String querystr = args.length > 0 ? args[0] : "lucene";
Query q = new QueryParser(Version.LUCENE_40, "title", analyzer).parse(querystr);

3.搜索

我们创建一个Searcher对象并且使用上面创建的Query对象来进行搜索，匹配到的前10个结果封装在TopScoreDocCollector对象里返回。

int hitsPerPage = 10;
IndexReader reader = IndexReader.open(index);
IndexSearcher searcher = new IndexSearcher(reader);
TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);
searcher.search(q, collector);
ScoreDoc[] hits = collector.topDocs().scoreDocs;

4.展示

现在我们得到了搜索结果，我们需要想用户展示它。

System.out.println("Found " + hits.length + " hits.");
for(int i=0;i<hits.length;++i) {
    int docId = hits[i].doc;
    Document d = searcher.doc(docId);
    System.out.println((i + 1) + ". " + d.get("isbn") + "\t" + d.get("title"));
}

这里是这个小应用的完整代码。 下载HelloLucene.java。

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
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.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopScoreDocCollector;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;

import java.io.IOException;

public class HelloLucene {
  public static void main(String[] args) throws IOException, ParseException {
    // 0. Specify the analyzer for tokenizing text.
    //    The same analyzer should be used for indexing and searching
    StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_40);

    // 1. create the index
    Directory index = new RAMDirectory();

    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_40, analyzer);

    IndexWriter w = new IndexWriter(index, config);
    addDoc(w, "Lucene in Action", "193398817");
    addDoc(w, "Lucene for Dummies", "55320055Z");
    addDoc(w, "Managing Gigabytes", "55063554A");
    addDoc(w, "The Art of Computer Science", "9900333X");
    w.close();

    // 2. query
    String querystr = args.length > 0 ? args[0] : "lucene";

    // the "title" arg specifies the default field to use
    // when no field is explicitly specified in the query.
    Query q = new QueryParser(Version.LUCENE_40, "title", analyzer).parse(querystr);

    // 3. search
    int hitsPerPage = 10;
    IndexReader reader = DirectoryReader.open(index);
    IndexSearcher searcher = new IndexSearcher(reader);
    TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);
    searcher.search(q, collector);
    ScoreDoc[] hits = collector.topDocs().scoreDocs;
    
    // 4. display results
    System.out.println("Found " + hits.length + " hits.");
    for(int i=0;i<hits.length;++i) {
      int docId = hits[i].doc;
      Document d = searcher.doc(docId);
      System.out.println((i + 1) + ". " + d.get("isbn") + "\t" + d.get("title"));
    }

    // reader can only be closed when there
    // is no need to access the documents any more.
    reader.close();
  }

  private static void addDoc(IndexWriter w, String title, String isbn) throws IOException {
    Document doc = new Document();
    doc.add(new TextField("title", title, Field.Store.YES));

    // use a string field for isbn because we don't want it tokenized
    doc.add(new StringField("isbn", isbn, Field.Store.YES));
    w.addDocument(doc);
  }
}

可以直接在命令行中使用这个小应用，键入 java HelloLucene 。

下面可以做什么？

1. 阅读下面关于Lucene的书籍。
2. 你需要应该使用Apache Solr代替Apache Lucene吗？
3. 更多关于 Lucene的基本概念

一些与Lucene和搜索相关的书籍

Github上的基于maven的库

Mac Luq在Github上的基于maven的库：

https://github.com/macluq/helloLucene

用下面这条命令下载它：

git clone https://github.com/macluq/helloLucene.git

PS：如果你是Java新手的话，试试下面的命令：

wget http://repo1.maven.org/maven2/org/apache/lucene/lucene-core/4.0.0/lucene-core-4.0.0.jar
wget http://repo1.maven.org/maven2/org/apache/lucene/lucene-analyzers-common/4.0.0/lucene-analyzers-common-4.0.0.jar
wget http://repo1.maven.org/maven2/org/apache/lucene/lucene-queryparser/4.0.0/lucene-queryparser-4.0.0.jar
wget http://www.lucenetutorial.com/code/HelloLucene.java
javac -classpath .:lucene-core-4.0.0.jar:lucene-analyzers-common-4.0.0.jar:lucene-queryparser-4.0.0.jar HelloLucene.java
java -classpath .:lucene-core-4.0.0.jar:lucene-analyzers-common-4.0.0.jar:lucene-queryparser-4.0.0.jar HelloLucene

你会得到下面的结果：

Found 2 hits.
1. Lucene in Action
2. Lucene for Dummies

Erik，一个可能对你有所帮助的读者抱怨到：

编译过程还算顺利，但是我不能正常运行这段代码。在网上搜索并且自己尝试了以后发现Lucene的jar文件必须在classpath中，否则运行不起来。这可能对很多像我这样的java初学者很多帮助。

安装Lucene

PS：我发现一些初学者在安装Lucene时有些困难。

你应该先 下载Lucene，然后把它解压到一个你用于编程的目录。

如果你使用Netbeans，你也可以这么做：

• 遵循 这里的教程。
• 按照下面的步骤：

1. 通过以此点击Netbeans菜单栏上的“工具”，然后选择“库管理器”，把Lucene的jar文件作为外部类库加进来。
2. 在Lucene项目上面右键，选择“属性”
3. 在弹出来的对话框中，以此选择“类库”,”添加jar或文件夹”选项
4. 定位到从lucene-[version].tar.gz解压出来的文件夹上，选择 lucene-core-[version].jar。
5. 点击“确定”，现在jar文件就已经添加到你项目的classpath中去了。

相关文章

• 在访问者模式中使用反射
• Java中的设计模式
• Spring MVC + Hibernate + Maven: Crud操作示例
• Java线程与多线程教程
• Java Timer和TimerTask实例教程
• Java8学习：Lambda表达式、Stream API和功能性接口 — 教程、资源、书籍和实例
• 使用Specs进行单元测试
• HBase数据迁移（2）- 使用bulk load 工具从TSV文件中导入数据
• Scala基础（二）
• 数据库连接池浅析

手机应用的抓包测试相对于PC上要麻烦一些。以下内容来自公司QA的指导，感谢~

需要的软件：

1. 抓包工具Fiddler
2. WIFI共享工具： 猎豹免费WIFI （使用360WIFI等均可，只要保证在同一局域网下就都可以，连接同一个路由器也可以）

现在开始真实的抓包：

1、启动Fiddler，打开菜单栏中的 Tools > Fiddler Options

2、打开Fiddler Options后点击 Connections 然后将红框中标识的“Allow romote computers to connect”勾选上即可。（注意，此界面中的端口号可修改为你喜欢的，建议保持默认）

3、查询当前PC的局域网IP（在命令行输入ipconfig即可）

4、设置手机上的WLAN的连接信息

将手机连接上同一个WIFI，并进行设置：

• iOS手机：设置 > WIFI > 点击进入连接上的WIFI，在最下面会有HTTP代理（默认情况下使关闭），打开手动选项，在服务器栏填写刚才查看到的PC机的IP，如’192.168.8.101′，在端口号栏填写:8888，至此设置整个流程设置完毕。
• Android手机：设置 > 连接 > WLAN > 手指长按已连接的WIFI地址将会出现“修改网络配置”的选项，点击进去后将会看到一个“显示高级选项”，勾选上以后会出现代理服务器的设置，选择手动后将PC机的IP填写到“代理主机名”栏，将8888填写进“代理端口”即可。

   今天调优一条SQL语句，由于SQL比较复杂，用autotrace很难一眼看出哪里出了问题，直接上10046。

WHERE AB.RN > 0;

已用时间:  00: 00: 05.56

10046 trace的结果，可以一眼看出是递归出了问题，按照业务上来说一个节点下面没有多少数据啊，怎么会不走索引呢？

Rows     Row Source Operation
-------  ---------------------------------------------------
      1  VIEW  (cr=209038 pr=0 pw=0 time=5665797 us)
      1   COUNT STOPKEY (cr=209038 pr=0 pw=0 time=5665774 us)
      1    VIEW  (cr=209038 pr=0 pw=0 time=5665768 us)
      1     SORT ORDER BY STOPKEY (cr=209038 pr=0 pw=0 time=5665745 us)
      1      VIEW  (cr=209038 pr=0 pw=0 time=5665649 us)
      1       UNION-ALL  (cr=209038 pr=0 pw=0 time=5665631 us)
      0        HASH UNIQUE (cr=25205 pr=0 pw=0 time=570538 us)
      0         HASH JOIN  (cr=25205 pr=0 pw=0 time=570360 us)
      0          TABLE ACCESS BY INDEX ROWID GG_TECH_OBJECT_NODE (cr=25205 pr=0 pw=0 time=570095 us)
      1           NESTED LOOPS  (cr=25205 pr=0 pw=0 time=570075 us)
      0            NESTED LOOPS SEMI (cr=25205 pr=0 pw=0 time=570069 us)
      0             NESTED LOOPS  (cr=25205 pr=0 pw=0 time=570066 us)
      0              HASH JOIN  (cr=25205 pr=0 pw=0 time=570062 us)
      0               HASH JOIN  (cr=25205 pr=0 pw=0 time=569617 us)
      1                TABLE ACCESS FULL GG_CLASSIFY_CARD (cr=68 pr=0 pw=0 time=1467 us)
  21206                TABLE ACCESS FULL GG_DEVICE (cr=25137 pr=0 pw=0 time=424214 us)
      0               TABLE ACCESS FULL GG_FL_DEVICE (cr=0 pr=0 pw=0 time=0 us)
      0              TABLE ACCESS BY INDEX ROWID GG_FUNCTION_LOCATION (cr=0 pr=0 pw=0 time=0 us)
      0               INDEX UNIQUE SCAN PK_GG_FUNCTION_LOCATION (cr=0 pr=0 pw=0 time=0 us)(object id 508068)
      0             INDEX RANGE SCAN IDX_TECH_NODE_ID (cr=0 pr=0 pw=0 time=0 us)(object id 541613)
      0            INDEX RANGE SCAN IDX_TECH_OBJECT_ID (cr=0 pr=0 pw=0 time=0 us)(object id 508645)
      0          VIEW  (cr=0 pr=0 pw=0 time=0 us)
      0           FILTER  (cr=0 pr=0 pw=0 time=0 us)
      0            CONNECT BY WITH FILTERING (cr=0 pr=0 pw=0 time=0 us)
      0             TABLE ACCESS BY INDEX ROWID GG_TECH_OBJECT_NODE (cr=0 pr=0 pw=0 time=0 us)
      0              INDEX RANGE SCAN IDX_TECH_OBJECT_ID (cr=0 pr=0 pw=0 time=0 us)(object id 508645)
      0             HASH JOIN  (cr=0 pr=0 pw=0 time=0 us)
      0              CONNECT BY PUMP  (cr=0 pr=0 pw=0 time=0 us)
      0              TABLE ACCESS FULL GG_TECH_OBJECT_NODE (cr=0 pr=0 pw=0 time=0 us)
      0             TABLE ACCESS FULL GG_TECH_OBJECT_NODE (cr=0 pr=0 pw=0 time=0 us)
      1        HASH UNIQUE (cr=183833 pr=0 pw=0 time=5095035 us)
      1         HASH JOIN  (cr=183748 pr=0 pw=0 time=5090111 us)
    170          TABLE ACCESS BY INDEX ROWID GG_TECH_OBJECT_NODE (cr=15772 pr=0 pw=0 time=7653 us)
    341           NESTED LOOPS  (cr=15610 pr=0 pw=0 time=189743 us)
    170            NESTED LOOPS SEMI (cr=15268 pr=0 pw=0 time=5170 us)
    170             HASH JOIN  (cr=14926 pr=0 pw=0 time=3232 us)
      1              TABLE ACCESS FULL GG_CLASSIFY_CARD (cr=68 pr=0 pw=0 time=830 us)
   2867              TABLE ACCESS BY INDEX ROWID GG_DEVICE (cr=14858 pr=0 pw=0 time=28976 us)
   4728               NESTED LOOPS  (cr=13282 pr=0 pw=0 time=94565 us)
   1667                TABLE ACCESS FULL GG_FUNCTION_LOCATION (cr=9937 pr=0 pw=0 time=13539 us)
   3060                INDEX RANGE SCAN IDX_FLOCID (cr=3345 pr=0 pw=0 time=12458 us)(object id 507929)
    170             INDEX RANGE SCAN IDX_TECH_NODE_ID (cr=342 pr=0 pw=0 time=3171 us)(object id 541613)
    170            INDEX RANGE SCAN IDX_TECH_OBJECT_ID (cr=342 pr=0 pw=0 time=1854 us)(object id 508645)
     31          VIEW  (cr=167976 pr=0 pw=0 time=4864861 us)
     31           FILTER  (cr=167976 pr=0 pw=0 time=4864794 us)
     56            CONNECT BY WITH FILTERING (cr=167976 pr=0 pw=0 time=4865653 us)
      1             TABLE ACCESS BY INDEX ROWID GG_TECH_OBJECT_NODE (cr=4 pr=0 pw=0 time=58 us)
      1              INDEX RANGE SCAN IDX_TECH_OBJECT_ID (cr=3 pr=0 pw=0 time=25 us)(object id 508645)
     55             HASH JOIN  (cr=167972 pr=0 pw=0 time=1264029 us)
     56              CONNECT BY PUMP  (cr=0 pr=0 pw=0 time=56 us)
7048956              TABLE ACCESS FULL GG_TECH_OBJECT_NODE (cr=167972 pr=0 pw=0 time=488 us)
      0             TABLE ACCESS FULL GG_TECH_OBJECT_NODE (cr=0 pr=0 pw=0 time=0 us)          

    在无意中测试发现，去掉分页的语句之后，就非常快了，揣测是COUNT STOPKEY造成的，如果数据量大的做分页，肯定是可以提升性能的，但此条SQL语句只是返回一条数据。我的结论是rownum可以改变执行计划。