name age sex
Lucy 22 woman
Lily 23 woman
Tom 24 man
Lucy 22 woman
Lily 23 woman
LiLei 25 man

2只talk C栗子吧(第十十七回:C语言实例–使用共享内部存款和储蓄器进行进度间通讯二)


诸君看官们,大家好,上贰次中我们说的是选择共享内部存款和储蓄器实行进程间通信的例子,那三次大家接着上一回内容继续说应用共享内部存款和储蓄器进行进度间通讯。闲话休提,言归正转。让大家一齐talk
C栗子吧!

咱俩在上一次中介绍了共享内部存款和储蓄器的定义和有关函数的用法,这一回中大家经过切实的例证来验证什么利用共享内部存储器实行进度间的通讯。上边是选取共享内部存款和储蓄器的具体步骤:

1.概念1个构造体类型,用来作为共享内部存储器的花色;
2.选用shmget函数到手共享内部存款和储蓄器,代码中的键使用了111以此自由数字;
3.使用shmat函数把共享连接到进度的地址空间中;
4.从共享内部存款和储蓄器中读取数据,只怕向共享内存中写入数据;
5.使用shmdt函数把共享内部存款和储蓄器从进程的地点空间中分离出来;
6.使用shmctl函数删除共享内部存款和储蓄器,要求动用的指令:IPC_RMID;

看官们,正文中就不写代码了,详细的代码放到了自作者的财富中,我们能够点击那里下载使用。

上边是先后的运维结果,请我们参考:

./s -r                                  //运行程序并且使用-r参数,表示启动读取数据的进程
there is not any data in share memory   //这时共享内存中还没有数据
./s -w                                  //运行程序并且使用-w参数,表示启动写入数据的进程
write data into share memory.count:3,data:hello share memory //提示写入的数据
./s -r                                //再次运行程序并且使用-r参数,表示启动读取数据的进程                
the data of share memory.count:3,data:hello share memory  //显示从共享内存中读取的数据

在程序中大家利用参数来分别不一样的经过,同时利用2个符号位来判断共享内部存款和储蓄器中是还是不是有多少。别的,使用共享内部存款和储蓄器举行过程间通讯时索要采纳同步机制,比如我们在刚初叶运转程序时,因为还尚未履行写进度,共享内部存款和储蓄器中没有多少,那时候,读进度不能够从共享内部存款和储蓄器中读取到多少。

各位看官,关于利用共享内部存款和储蓄器进行进度间通讯的例子我们就说到那里。欲知前边还有如何例子,且听下回分解


 

C栗子吧(第9拾6回:C语言实例–使用共享内部存款和储蓄器进行进程间通讯二)
各位看官们,大家好,上二遍中我们说的是利用共享内部存款和储蓄器实行…

一 、是或不是实行实时搜索

  • 实时搜索:只要数据库一变更,立刻要更新索引,要运用writer.commit来操作,但是那种情景太耗费能源。
  • 近实时追寻:当用户修改了音信之后,先把索引保存到内部存款和储蓄器中,然后在二个联结的时间内对内部存储器中的目录实行提交操作。基于这么些缘故大家一般实行的是近实时搜索。

在面向对象开发中,平常碰到七个类间传值,总括起来即正向传值,反向传值(利用对象,使用TargetAction,使用协议代理,使用系统自带的Block,使用自定义Block),双向传值(A<—>B)(使用NSUserDefaults实行多少传值,使用系统的UIApplication单例举办传值,使用本人的单例类实行传值,使用公告中央NSNotificationCenter进行传值,使用KVC进行传值)。

List<Person> list_persons = new List<Person>(new Person("Lucy",22,"woman"),new Person("Lily",23,"woman"),new Person("Tom",24,"man"),new Person("Lucy",22,"woman"),new Person("Lily",23,"woman"),new Person("LiLei",25,"man"));

二 、入门程序(工程lucene-nearRealTime

IndexUtil.java

package cn.itcast.util;
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Fieldable;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.FieldInfo.IndexOptions;
import org.apache.lucene.index.StaleReaderException;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.SearcherManager;
import org.apache.lucene.search.SearcherWarmer;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;

public class IndexUtil {
    private String[] ids = {"1", "2", "3", "4", "5", "6"};
    //下面是邮件
    private String[] emails = {"aa@qq.com", "bb@sina.edu", "cc@yahu.org", "ss@sina.com", "dd@gmail.com", "ee@163.com"};
    //下面是邮件内容
    private String[] content = {
            "welcom to visited the space,I like football", 
            "hello boy, i like someone", 
            "come on baby", 
            "first blood", 
            "I like football,I like football", 
            "my girlfriend is so beatiful, every body like game"
    };
    private int[] attaches = {2,5,6,5,8,4};//附件数量
    //发件人名字
    private String[] names = {"Tom", "Jack", "goudan", "alibaba", "jerry", "kitty"};
    //邮件的日期
    private Date[] dates = null;

    private Directory directory = null;
    private Map<String, Float> scores = new HashMap<String, Float>();//新建一个Map,用来存储权值
    /*private static IndexReader reader = null;//声明一个IndexReader的属性*/
    private SearcherManager mgr = null;

    public IndexUtil() {
        try {
            setDates();//设置日期
            scores.put("qq.com", 2.0f);//如果是"qq.com"结尾的索引则让其权值为2.0,注意:默认是1.0
            scores.put("sina.edu", 1.5f);
            directory = FSDirectory.open(new File("E:/myeclipse/Lucene/index"));
            mgr = new SearcherManager(directory, new SearcherWarmer() {
                //在重新打开的时候可能需要做一个控制,这些控制可以在这个方法中做
                @Override
                public void warm(IndexSearcher searcher) throws IOException {
                    System.out.println("has changed");
                }
            }, Executors.newCachedThreadPool());
        } catch (IOException e) {
            e.printStackTrace(); 
        }
    }

    //创建索引
    public void index(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            //此方法可将索引全部清空
            writer.deleteAll();
            Document document = null;
            for(int i = 0; i < ids.length; i++){
                document = new Document();
                //id需要存储,不需要加权、分词,email也需要存储,但不需要分词,有时候也需要加权
                //对于内容,我们不需要存储和加权,但需要分词。而名字需要存储,不需要分词和加权
                //这里我们先不对整型数据进行索引,后面再说
                document.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
                document.add(new Field("email", emails[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
                document.add(new Field("content", content[i], Field.Store.NO, Field.Index.ANALYZED));
                document.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));

                //为数字添加索引,第三个参数设置为true表示默认索引
                document.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attaches[i]));
                //为日期添加索引
                document.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime()));


                String et = emails[i].substring(emails[i].lastIndexOf("@") + 1);
                System.out.println(et);
                //加入权值
                if(scores.containsKey(et)){
                    document.setBoost(scores.get(et));
                }else{
                    document.setBoost(0.5f);
                }
                writer.addDocument(document);
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(writer != null){
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //查询
    public void query(){
        try {
            IndexReader reader = IndexReader.open(directory);
            //maxDoc 和 numDocs()方法的区别:maxDoc()返回索引中删除和未被删除的文档总数,
            //后者返回索引中未被删除的文档总数,通过reader可以有效获取文档的数量
            System.out.println("numDocs: " + reader.numDocs());
            System.out.println("maxDocs: " + reader.maxDoc());
            //查看被删除的索引
            System.out.println("deleteDocs : " + reader.numDeletedDocs());
            //记得用完之后关闭
            reader.close();

        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //删除索引
    public void delete(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));

            //参数可以是一个选项,可以是一个query,也可以是一个term,term是一个精确查找的值
            //这里我们测试此方法之后再次执行搜索方法,发现文档数numDocs还有5个,比之前少了一个,但是maxDoc还是6个
            //在我们的索引目录中发现出现了一个delete的文件。这里的删除就像一个回收站一样,是可以恢复的
            writer.deleteDocuments(new Term("id", "1"));//这里表示删除索引为1的id
            writer.commit();
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //更新索引
    public void update(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));

            /* lucene并没有提供更新,这里的更新操作其实是如下两个操作的合集
             * 先删除之后再添加,所以不是在之前的位置更新
             * 测试之后我们会发现回收站中有一个索引
             * */
            Document document = new Document();
            document.add(new Field("id", "11", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            document.add(new Field("email", emails[0], Field.Store.YES, Field.Index.NOT_ANALYZED));
            document.add(new Field("content", content[0], Field.Store.NO, Field.Index.ANALYZED));
            document.add(new Field("name", names[0], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            writer.updateDocument(new Term("id", "1"), document);
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(writer != null){
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void search01(){
        IndexReader reader;
        try {
            reader = IndexReader.open(directory);
            IndexSearcher searcher = new IndexSearcher(reader);
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                //这里我们获取权值getBoost()的时候发现都是1.0,这是因为这里是获取的一个document,和原来的没有关系。
                //要想看其权值信息,可以使用luke工具
                //而这里的日期需要我们转换成日期格式
                System.out.println("(" + sd.doc + "权值:"+ doc.getBoost() + ")" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                            + doc.get("id") + "-->" + doc.get("attach") + "-->" + doc.get("date"));
                reader.close();
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //设置日期
    private void setDates(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            dates = new Date[ids.length];
            dates[0] = sdf.parse("2015-02-15");
            dates[1] = sdf.parse("2015-03-01");
            dates[2] = sdf.parse("2015-05-18");
            dates[3] = sdf.parse("2015-09-05");
            dates[4] = sdf.parse("2015-12-15");
            dates[5] = sdf.parse("2015-08-29");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    public void search02(){
        IndexSearcher searcher = null;
        try {
            mgr.maybeReopen();//判断是否需要重新打开一个IndexSearcher
            searcher = mgr.acquire();
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                System.out.println("(" + sd.doc + "权值:"+ doc.getBoost() + ")" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                            + doc.get("id") + "-->" + doc.get("attach") + "-->" + doc.get("date"));
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                mgr.release(searcher);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

说明:那是我们事先写过的3个工具类,和事先不一样的是大家那边不再直接获得IndexReader,而是定义三个SearcherManager对象:

private SearcherManager mgr = null;

然后对IndexUtil措施开始展览改造,大家经过SearcherManager来管理IndexReader,同时在我们立异索引的进度中大家还足以对能源做一些操作。再对章程search02措施举行改建,那里我们是通过SearcherManager来获得IndexReader对象的,同时是或不是打开三个新的IndexReaderSearcherManager的方法maybeReopenList集合去重使用lambda表明式,实时搜索。来支配。而利用完今后大家也不须求关闭IndexReader,只须求将其释放即可,使用办法release

下边进行测试:

package cn.lucene.test;
import org.junit.Test;
import cn.itcast.util.IndexUtil;

public class TestIndex {
    @Test
    public void testIndex(){
        IndexUtil util = new IndexUtil();
        util.index();
    }

    @Test
    public void testQuery(){
        IndexUtil util = new IndexUtil();
        util.query();
    }

    @Test
    public void testDelete(){
        IndexUtil util = new IndexUtil();
        util.delete();
    }

    @Test
    public void testUpdate(){
        IndexUtil util = new IndexUtil();
        util.update();
    }
    @Test
    public void testSearch01(){
        IndexUtil util = new IndexUtil();
        util.search01();
    }
    @Test
    public void testSearch02(){
        IndexUtil util = new IndexUtil();
        for(int i = 0; i < 5; i++){
            util.search02();//这里我们让其执行5次
            System.out.println("************************");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

说明:在测试方法testSearch02此前咱们先利用形式testIndex重建索引,然后我们利用情势testQuery可以看看记录数:

金沙注册送58 1

1

而在testSearch02格局还一贯不运营完时我们使用testDelete办法开始展览删除,此时大家发现testSearch02格局在末端的出口少了一条记下。将记录0给删除了。尽管那样,当大家再一次利用testQuery措施查询的时候发现记录没有被删掉,那是因为并不曾付诸,而选拔SearcherManager亟需举办writer.commit才会检查和测试到,于是那就必要运用NRTManager这几个类了。

注意:我们在reopen时或者要求对少数财富做一些操作,能够在艺术SearcherWarmer. Warm中进行,我们在testSearch02措施的出口中也得以看出打字与印刷出了has changed

1.正向传值

 

叁 、近实时追寻(工程lucene-nearRealTime01

只是使用SearcherManager是不能够兑现实时搜索的,因为只是更新的内部存款和储蓄器,而并没有当真的提交。
在类IndexUtil.java中大家添加八个属性:

private NRTManager nrtMgr = null;
private IndexWriter writer;

对有关措施开展改造:

package cn.itcast.util;
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Fieldable;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.FieldInfo.IndexOptions;
import org.apache.lucene.index.StaleReaderException;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NRTManager;
import org.apache.lucene.search.NRTManagerReopenThread;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.SearcherManager;
import org.apache.lucene.search.SearcherWarmer;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;

public class IndexUtil {
    private String[] ids = {"1", "2", "3", "4", "5", "6"};
    //下面是邮件
    private String[] emails = {"aa@qq.com", "bb@sina.edu", "cc@yahu.org", "ss@sina.com", "dd@gmail.com", "ee@163.com"};
    //下面是邮件内容
    private String[] content = {
            "welcom to visited the space,I like football", 
            "hello boy, i like someone", 
            "come on baby like", 
            "first blood like", 
            "I like football,I like football", 
            "my girlfriend is so beatiful, every body like game"
    };
    private int[] attaches = {2,5,6,5,8,4};//附件数量
    //发件人名字
    private String[] names = {"Tom", "Jack", "goudan", "alibaba", "jerry", "kitty"};
    //邮件的日期
    private Date[] dates = null;

    private Directory directory = null;
    private Map<String, Float> scores = new HashMap<String, Float>();//新建一个Map,用来存储权值
    /*private static IndexReader reader = null;//声明一个IndexReader的属性*/
    private SearcherManager mgr = null;
    private NRTManager nrtMgr = null;
    private IndexWriter writer;

    public IndexUtil() {
        try {
            setDates();//设置日期
            scores.put("qq.com", 2.0f);//如果是"qq.com"结尾的索引则让其权值为2.0,注意:默认是1.0
            scores.put("sina.edu", 1.5f);
            directory = FSDirectory.open(new File("E:/myeclipse/Lucene/index"));
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            nrtMgr = new NRTManager(writer, new SearcherWarmer() {

                @Override
                public void warm(IndexSearcher arg0) throws IOException {
                    System.out.println("reopen");

                }
            });
            //重新打开的时候间隔最大为5.0,最小为0.025,0.025为25秒
            NRTManagerReopenThread reopen = new NRTManagerReopenThread(nrtMgr, 5.0, 0.025);
            reopen.setDaemon(true);
            reopen.setName("NrtManger Reopen Thread");
            reopen.start();//启动线程NRTManager的reopen线程
            mgr = nrtMgr.getSearcherManager(true);//允许所有更新
        } catch (IOException e) {
            e.printStackTrace(); 
        }
    }

    //创建索引
    public void index(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            //此方法可将索引全部清空
            writer.deleteAll();
            Document document = null;
            for(int i = 0; i < ids.length; i++){
                document = new Document();
                //id需要存储,不需要加权、分词,email也需要存储,但不需要分词,有时候也需要加权
                //对于内容,我们不需要存储和加权,但需要分词。而名字需要存储,不需要分词和加权
                //这里我们先不对整型数据进行索引,后面再说
                document.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
                document.add(new Field("email", emails[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
                document.add(new Field("content", content[i], Field.Store.NO, Field.Index.ANALYZED));
                document.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));

                //为数字添加索引,第三个参数设置为true表示默认索引
                document.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attaches[i]));
                //为日期添加索引
                document.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime()));


                String et = emails[i].substring(emails[i].lastIndexOf("@") + 1);
                System.out.println(et);
                //加入权值
                if(scores.containsKey(et)){
                    document.setBoost(scores.get(et));
                }else{
                    document.setBoost(0.5f);
                }
                writer.addDocument(document);
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(writer != null){
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //查询
    public void query(){
        try {
            IndexReader reader = IndexReader.open(directory);
            //maxDoc 和 numDocs()方法的区别:maxDoc()返回索引中删除和未被删除的文档总数,
            //后者返回索引中未被删除的文档总数,通过reader可以有效获取文档的数量
            System.out.println("numDocs: " + reader.numDocs());
            System.out.println("maxDocs: " + reader.maxDoc());
            //查看被删除的索引
            System.out.println("deleteDocs : " + reader.numDeletedDocs());
            //记得用完之后关闭
            reader.close();

        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //删除索引
    public void delete(){
        IndexWriter writer = null;
        try {
            nrtMgr.deleteDocuments(new Term("id", "1"));//这里表示删除索引为1的id
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //更新索引
    public void update(){
        try {
            /* lucene并没有提供更新,这里的更新操作其实是如下两个操作的合集
             * 先删除之后再添加,所以不是在之前的位置更新
             * 测试之后我们会发现回收站中有一个索引
             * */
            Document document = new Document();
            document.add(new Field("id", "11", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            document.add(new Field("email", emails[0], Field.Store.YES, Field.Index.NOT_ANALYZED));
            document.add(new Field("content", content[0], Field.Store.NO, Field.Index.ANALYZED));
            document.add(new Field("name", names[0], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            nrtMgr.updateDocument(new Term("id", "1"), document);
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void search01(){
        IndexReader reader;
        try {
            reader = IndexReader.open(directory);
            IndexSearcher searcher = new IndexSearcher(reader);
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                //这里我们获取权值getBoost()的时候发现都是1.0,这是因为这里是获取的一个document,和原来的没有关系。
                //要想看其权值信息,可以使用luke工具
                //而这里的日期需要我们转换成日期格式
                System.out.println("(" + sd.doc + "权值:"+ doc.getBoost() + ")" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                            + doc.get("id") + "-->" + doc.get("attach") + "-->" + doc.get("date"));
                reader.close();
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //设置日期
    private void setDates(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            dates = new Date[ids.length];
            dates[0] = sdf.parse("2015-02-15");
            dates[1] = sdf.parse("2015-03-01");
            dates[2] = sdf.parse("2015-05-18");
            dates[3] = sdf.parse("2015-09-05");
            dates[4] = sdf.parse("2015-12-15");
            dates[5] = sdf.parse("2015-08-29");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    public void search02(){
        IndexSearcher searcher = null;
        try {
            mgr.maybeReopen();//判断是否需要重新打开一个IndexSearcher
            searcher = mgr.acquire();
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                System.out.println(doc.get("id") + "-->" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                             + doc.get("attach") + "-->" + doc.get("date"));
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                mgr.release(searcher);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void commit(){
        try {
            writer.commit();
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明:在方法IndexUtil中我们实例化了IndexWriter对象,同时选拔NRTManager对象来收获SearcherManager指标,进而管理IndexSearcher。在deleteupdate办法中,直接利用NRTManager来拓展相关的操作,因为此指标完结了IndexSearcher的拥有办法,所以大家不直接利用IndexSearcher了。在点子search0第22中学我们选择方法maybeReopen判定是或不是供给再行打开IndexSearcher,而以此打开的时间大家在点子IndexUtil中装置的为25-四千秒之内。

测试:
测试时对testSearch02办法开始展览改动:

    @Test
    public void testSearch02(){
        IndexUtil util = new IndexUtil();
        for(int i = 0; i < 5; i++){
            util.search02();//这里我们让其执行5次
            System.out.println("************************");
            util.delete();
            if(i == 2){
                util.update();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

说明:测试结果:

1-->Tom[aa@qq.com]-->2-->1423929600000
2-->Jack[bb@sina.edu]-->5-->1425139200000
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
reopen
2-->Jack[bb@sina.edu]-->5-->1425139200000
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
2-->Jack[bb@sina.edu]-->5-->1425139200000
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
reopen
2-->Jack[bb@sina.edu]-->5-->1425139200000
11-->Tom[aa@qq.com]-->null-->null
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
2-->Jack[bb@sina.edu]-->5-->1425139200000
11-->Tom[aa@qq.com]-->null-->null
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************

此处大家是先举办查询,之后进行删除,同时在第四回询问的时候举办翻新,更新其实正是将事先id为1(删除的那条记下)更新为11,能够看到相应的结果。而那时候大家再将去除和翻新的有个别注释掉,即:

util.delete();
if(i == 2){
    util.update();
}

再次查询,发现并没有去除,那是因为除去只是在内部存款和储蓄器中开始展览,而并从未提交。那里要专注的是:那里之所以叫近实时搜索,正是这么些立异的时光是由线程序控制制,那里我们得以将休眠时间独家该为1秒和2秒(同时将mgr.maybeReopen();诠释掉)来查看效果。当然在这几个测试方法的末尾加上

uti.commit();

才会将相关的立异持久化。而相比较SearcherManagerNRTManager不须要提交就能被搜寻到,那样大家就能够在2个联合的年华对索引进行创新了。

未完待续。。。

质量传值

犹如上表中,名字(name)中再一次的想要去除,使用linq举行去重的点子,使用Distinct()根本不可能达到需求。那么:

在B类中定义属性用于接收A类传来的数码

var list_distinct = list_Persons.GroupBy(c => c.name).Select(c => c.First());

2.反向传值

实质上的趣味是基于某一列进行分组,然后拿走每一组的首先条数据,能够解决本次须要

1)利用对象反向传值

 

将A类对象定义成B类的性质进行传值

如,通过KGSubViewController修改 KGRootViewController的Label

KGRootViewController

//在KGRootViewController中定义函数接收返回的数据-backValue:(NSString *)string color:(UIColor *)color{ //将参数的值赋给label label.text = string; //将颜色赋给赋给lable的字体颜色 label.textColor = color;}

金沙注册送58 ,界面跳转至KGSubViewController,并将KGRootViewController对象传到KGSubViewController中

-touchesBegan:touches withEvent:(UIEvent *)event{ KGSubViewController * svc = [[KGSubViewController alloc]init]; //让B持有A svc.rvc = self; [self presentViewController:svc animated:YES completion:nil];}

KGSubViewController

//创建一个Root对象@property(nonatomic,retain) KGRootViewController * rvc;//在销毁之前,做一些回传数据的事-touchesBegan:touches withEvent:(UIEvent *)event{ [self.rvc backValue:tf.text color:[UIColor redColor]]; [self dismissViewControllerAnimated:YES completion:nil];}

2)使用TargetAction反向传值

因此点名回传方法和回传对象举行传值

仍以上例为例,达成格局为:KGRootViewController

-touchesBegan:touches withEvent:(UIEvent *)event{ KGSubViewController * svc = [[KGSubViewController alloc]init]; //将回传对象进行指定 svc.target = self; //这里的self是指rootviewcontrller //将回传方法,进行指定 svc.selector = @selector(backValue:); [self presentViewController:svc animated:YES completion:nil];}-backValue:(NSString *)string{ //回传数据方法 label.text = string;}

KGSubViewController

//在这里定义两个属性,用来接收目标和方法,用来进行反向传值//接收要回传的对象@property(nonatomic,retain) id target; //接收回传数据的方法@property(nonatomic,assign) SEL selector;//在销毁之前,将数据回传回去-touchesBegan:touches withEvent:(UIEvent *)event{ //利用保存的target 和 action 来进行回传 if ([self.target respondsToSelector:self.selector]) { [self.target performSelector:self.selector withObject:tf.text]; } [self dismissViewControllerAnimated:YES completion:nil];}

3)使用协议代理反向传值

情商代理是回调中常用的办法,顾名思义,把某部对象要做的事务委托给别的对象去做。那么别的对象就是其一指标的代理,代理它来打理要做的政工。使用协议代理不仅能够正向传值,亦可反向传值。在选择中,须要专注哪些类是委托方,哪个类是代理方。同理可得:哪个人传值何人是委托方

如,通过KGSubViewController改变KGRootViewController中label值

在KGSubViewController页面里,制定三个磋商

@protocol BackValue <NSObject>//回传数据的协议方法-backValue:(NSString *)string;@end@property(nonatomic,retain) id < BackValue > delegate;

在KGSubViewController使代理方实现形式

-touchesBegan:touches withEvent:(UIEvent *)event{ //代理方实现协议中的方法 [self.delegate backValue:tf.text]; [self dismissViewControllerAnimated:YES completion:nil];}

在KGRootViewController中贯彻协议 <BackValue>

-touchesBegan:touches withEvent:(UIEvent *)event{ KGSubViewController * svc = [[KGSubViewController alloc]init]; //让A同意B所提出的协议条件 svc.delegate = self; [self presentViewController:svc animated:YES completion:nil];}//实现协议 方法-backValue:(NSString *)string{ label.text = string;}

4)使用系统自带的Block举行反向传值

block是代码块的对象,类似函数指针,调用block仿佛调用代码块中的代码,利用block能够兑现回调。

在系统提供情势中,有广小运用block方法,如界面跳转presentViewController时

将KGRootViewController中label.text值传给KGSubViewController
textField.text

-touchesBegan:touches withEvent:(UIEvent *)event{ KGSubViewController * svc = [[KGSubViewController alloc]init]; svc.rvc = self; //OC中,block用来去指向一个匿名的语句块,从而可以当成函数还调用该语句块 //这个方法的第三个参数是一个block,意思说,当弹出来的svc显示完成后,执行block里的内容 [self presentViewController:svc animated:YES completion:^{ //正向传值 svc.textField.text = self.label.text; }];}

将KGSubViewController textField.text值传给
KGRootViewController中label.text

-touchesBegan:touches withEvent:(UIEvent *)event{ [self dismissViewControllerAnimated:YES completion:^{ self.rvc.label.text = self.textField.text; }];}

5)使用自定义Block反向传值

KGSubViewController

//定义一个block的属性@property(nonatomic,copy)void (NSString *);-touchesBegan:touches withEvent:(UIEvent *)event{ //执行block self.block; [self dismissViewControllerAnimated:YES completion:nil];}

KGRootViewController

-touchesBegan:touches withEvent:(UIEvent *)event{ KGSubViewController * svc = [[KGSubViewController alloc]init]; //给block赋值,做用是让svc知道block指向的代码块的功能 svc.block = ^(NSString * string){ label.text = string; }; [self presentViewController:svc animated:YES completion:nil];}

3.双向产值1)使用NSUserDefaults进行数据传值

NSUserDefaults纪录本地一些轻量级的数目,是单例类。其通过userDefaults对象来将当选按钮的目录给保存到NSUserDefaults的plist文件中。这么些文件实际上是2个plist文件,在沙盒中的/Library/Preferences/NSUserDefaults.plist
那一个职责

当KGSubViewController调用view威尔Appear时读取沙盒内容

-viewWillAppear:animated{ [super viewWillAppear:animated]; //获取NSUserDefaults文件,读取里面内容,来决定让哪一个按钮进行选中 NSUserDefaults * ud = [NSUserDefaults standardUserDefaults]; //通过存的时候的key值来进行取值 NSString * value = (NSString *)[ud objectForKey:@"ButtonIndex"]; //计算出按钮的tag值 int buttonIndex = 1000 + value.intValue; //利用tag值取到按钮 UIButton * button = (UIButton *)[self.view viewWithTag:buttonIndex]; button.selected = YES;}

KGRootViewController点击button将点击按钮的索引存入沙盒中

-buttonClick:(UIButton *)button{ for (int i = 1;i<6; i++) { UIButton * btn = (UIButton *)[self.view viewWithTag:1000+i]; if (btn.selected == YES) { btn.selected = NO; } } button.selected = YES; //将每次点击选中的按钮索引给存起来 NSUserDefaults * userDefaults = [NSUserDefaults standardUserDefaults]; NSLog(@"%@",[NSBundle mainBundle]); //通过userDefaults对象来将选中按钮的索引给保存到NSUserDefaults的plist文件中 //这个文件实际上是一个plist文件,在沙盒中的/Library/Preferences/NSUserDefaults.plist 这个位置 [userDefaults setObject:[NSString stringWithFormat:@"%d",button.tag - 1000] forKey:@"ButtonIndex"]; //回写文件 [userDefaults synchronize]; //synchronize:使同步,同时发生}

KGRootViewController

-viewWillAppear:animated{ [super viewWillAppear:animated]; //获取NSUserDefaults文件,读取里面内容,来决定让哪一个按钮进行选中 NSUserDefaults * ud = [NSUserDefaults standardUserDefaults]; //通过存的时候的key值来进行取值 NSString * value = (NSString *)[ud objectForKey:@"ButtonIndex"]; label.text = [NSString stringWithFormat:@"上次按下的是第 %@ 个按钮",value];}

2)使用系统的UIApplication单例进行传值

单例类在程序中只开创一回实例对象,利用那性情子能够拓展传值。在iOS开发中,UIApplication正是个单例类,利用她可实现传值。

在UIApplication定义存款和储蓄内容

//创建一个公共数组,用来存放数据,@property(nonatomic,retain) NSMutableArray * array;

在相应ViewController中使用

//应该去利用系统的UIApplication这个单例来获取系统已经创建好的那个AppDelegate里的对象//这是一个单例 对象,在整个程序中,只有一个唯一的实例存在UIApplication * application = [UIApplication sharedApplication];//通过这个单例对象来找到它持有的AppDelegate对象KGAppDelegate * appDelegate = application.delegate;//通过appDelegate对象拿到他的数组[appDelegate.array addObject:self.title];

3)使用本身的单例类进行传值

除此而外选拔系统自带的单例类外,仍是能够使用自定义单例类用来传值

自定义单例类K放线菌壮观素yApplication

//为application类,添加一个属性,用来接收MyAppDelegate对象@property(nonatomic,retain) KGMyAppDelegate * delegate;//使用这个方法来实例一个单例对象+(KGMyApplication *)sharedMyApplication;+(KGMyApplication *)sharedMyApplication{ static KGMyApplication * obj = nil; if  { //给obj创建单例对象 obj = [[KGMyApplication alloc]init]; //给单例对象的delegate属性赋值 obj.delegate = [[KGMyAppDelegate alloc]init]; } return obj;}

概念K核糖霉素yAppDelegate类保存数据

//这个类不是一个单例类,但是,需要在这里保存数据@property(nonatomic,retain)NSMutableArray * array;

在相应ViewController中使用

//首先获取MyApplication的单例对象KGMyApplication * app = [KGMyApplication sharedMyApplication];//通过这个单例对象里的delegate属性来获取MyAppDelegate对象KGMyAppDelegate * appDelegate = app.delegate;//获取MyAppDelegate里的数组NSMutableArray * array = [appDelegate array];static int n = 0;[array addObject:[NSString stringWithFormat:@"VC1-%d",n++]];

4)使用通告中央NSNotificationCenter进行传值

布告由布告大旨发送,公告焦点在全路工程中唯有八个。通告主题能够发送多条音讯,能够在全部工程中的任何岗位接收新闻,通过公告中央的名号区分音信。

三个简易的应用,从界面2中发送布告,界面第11中学收受

KGFirstViewController

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(doSomeThing:) name:@"xiaoxi" object:nil];- doSomeThing:(NSNotification *)noti{ NSLog; label.text = [noti.userInfo objectForKey:@"key"];}

KGSecondViewController

NSNotification *noti = [[NSNotification alloc]initWithName:@"xiaoxi" object:self userInfo:[NSDictionary dictionaryWithObjectsAndKeys:[NSString stringWithFormat:@"%@", btn.titleLabel.text],@"key", nil]]; // 发送 [[NSNotificationCenter defaultCenter] postNotification:noti];

类间传值是编制程序时最常用的法门,也是最基础的语法。在先后中采纳差异的措施能够使的程序编的越发灵敏。除上述措施外,还有KVC等措施,将在再三再四详解。

迎接各位指教

相关文章

网站地图xml地图