`
xiangxingchina
  • 浏览: 509495 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

用compass实现站内全文搜索引擎

搜索引擎全文检索BeanSpringAOP 
阅读更多

Compass是一个强大的,事务的,高性能的对象/搜索引擎映射(OSEM:object/search engine mapping)与一个Java持久层框架.Compass包括: 
* 搜索引擎抽象层(使用Lucene搜索引荐),
* OSEM (Object/Search Engine Mapping) 支持,
* 事务管理,
* 类似于Google的简单关键字查询语言,
* 可扩展与模块化的框架,
* 简单的API.

如果你需要做站内搜索引擎，而且项目里用到了hibernate，那用compass是你的最佳选择。

本文用到compass2.14和IK中文分词包,另外将会使用注解来实现

废话不说，先给出关键的实现代码

假如现在有个需求，需要根据关键字搜索出文章，

Java代码
  1. @Searchable (alias= "article" )   
  2. public   class  Article {  
  3.   
  4.     private  Long ID;  // 标识ID   
  5.     private  String content;  // 正文   
  6.     private  String title;  // 文章标题   
  7.     private  Date createTime;  // 创建时间   
  8.   
  9.     @SearchableId   
  10.     public  Long getID() {  
  11.         return  ID;  
  12.     }  
  13.   
  14.     public   void  setID(Long id) {  
  15.         ID = id;  
  16.     }  
  17.   
  18.     @SearchableProperty (index = Index.TOKENIZED, store = Store.YES)  
  19.     public  String getContent() {  
  20.         return  content;  
  21.     }  
  22.   
  23.     public   void  setContent(String content) {  
  24.         this .content = content;  
  25.     }  
  26.   
  27.   
  28.   
  29.     @SearchableProperty (index = Index.TOKENIZED, store = Store.YES)  
  30.     public  String getTitle() {  
  31.         return  title;  
  32.     }  
  33.   
  34.     public   void  setTitle(String title) {  
  35.         this .title = title;  
  36.     }  
  37.   
  38.   
  39.     @SearchableProperty (index = Index.TOKENIZED, store = Store.YES)  
  40.     public  Date getCreateTime() {  
  41.         return  createTime;  
  42.     }  
  43.   
  44.     public   void  setCreateTime(Date createTime) {  
  45.         this .createTime = createTime;  
  46.     }  
  47.   
  48.   
  49.   
  50.       
  51.   
  52.   
  53. }   
@Searchable(alias="article") 
public class Article {

	private Long ID; // 标识ID
	private String content; // 正文
	private String title; // 文章标题
	private Date createTime; // 创建时间

	@SearchableId
	public Long getID() {
		return ID;
	}

	public void setID(Long id) {
		ID = id;
	}

	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}



	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}


	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public Date getCreateTime() {
		return createTime;
	}

	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}



	


}



简单解释一下：
@Searchable(alias="article")表示这个是可以搜索实体，别人为article.
@SearchableId  这个是实体搜索的标识ID,和hibernate里的概念差不多，用来区分索引文件里的实体索引。
@SearchableProperty(index = Index.TOKENIZED, store = Store.YES) 表示这个属性存入索引文件,而且是在分词后在存入.

 

 

接下来是要建立搜索的服务类

Java代码
  1. import  java.util.ArrayList;  
  2. import  java.util.HashMap;  
  3. import  java.util.List;  
  4. import  java.util.Map;  
  5. import  org.compass.core.Compass;  
  6. import  org.compass.core.CompassCallback;  
  7. import  org.compass.core.CompassException;  
  8. import  org.compass.core.CompassHighlighter;  
  9. import  org.compass.core.CompassHits;  
  10. import  org.compass.core.CompassQuery;  
  11. import  org.compass.core.CompassSession;  
  12. import  org.compass.core.CompassTemplate;  
  13. import  org.compass.core.CompassTransaction;  
  14. import  cn.rgcenter.entity.Article;  
  15.   
  16. public   class  SearchServiceBean {  
  17.   
  18.     private  Compass compass;  
  19.     /** 索引查询 * */   
  20.     public  Map find( final  String keywords,  final  String type,  final   int  start,  
  21.             final   int  end) {  
  22.         CompassTemplate ct = new  CompassTemplate(compass);  
  23.         return  ct.execute( new  CompassCallback<Map>() {  
  24.   
  25.             public  Map doInCompass(CompassSession session)  
  26.                     throws  CompassException {  
  27.                 List result = new  ArrayList();  
  28.                 int  totalSize =  0 ;  
  29.                 Map container = new  HashMap();  
  30.                 CompassQuery query = session.queryBuilder().queryString(  
  31.                         keywords).toQuery();  
  32.                 CompassHits hits = query.setAliases(type).hits();  
  33.                 totalSize = hits.length();  
  34.                 container.put("size" , totalSize);  
  35.                 int  max =  0 ;  
  36.                 if  (end < hits.length()) {  
  37.                     max = end;  
  38.                 } else  {  
  39.                     max = hits.length();  
  40.                 }  
  41.   
  42.        if (type.equals( "article" )){  
  43.                     for  ( int  i = start; i < max; i++) {  
  44.                         Article article = (Article) hits.data(i);  
  45.                         String title = hits.highlighter(i).fragment("title" );  
  46.                         if  (title !=  null ) {  
  47.                             article.setTitle(title);  
  48.                         }  
  49.                         String content = hits.highlighter(i).setTextTokenizer(  
  50.                                 CompassHighlighter.TextTokenizer.AUTO)  
  51.                                 .fragment("content" );  
  52.                         if  (content !=  null ) {  
  53.   
  54.                             article.setContent(content);  
  55.                         }  
  56.                         result.add(article);  
  57.                     }  
  58.                 }  
  59.                 container.put("result" , result);  
  60.                 return  container;  
  61.             }  
  62.         });  
  63.     }  
  64.   
  65.     public  Compass getCompass() {  
  66.         return  compass;  
  67.     }  
  68.   
  69.     public   void  setCompass(Compass compass) {  
  70.         this .compass = compass;  
  71.     }  
  72.   
  73. }   
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.compass.core.Compass;
import org.compass.core.CompassCallback;
import org.compass.core.CompassException;
import org.compass.core.CompassHighlighter;
import org.compass.core.CompassHits;
import org.compass.core.CompassQuery;
import org.compass.core.CompassSession;
import org.compass.core.CompassTemplate;
import org.compass.core.CompassTransaction;
import cn.rgcenter.entity.Article;

public class SearchServiceBean {

	private Compass compass;
	/** 索引查询 * */
	public Map find(final String keywords, final String type, final int start,
			final int end) {
		CompassTemplate ct = new CompassTemplate(compass);
		return ct.execute(new CompassCallback<Map>() {

			public Map doInCompass(CompassSession session)
					throws CompassException {
				List result = new ArrayList();
				int totalSize = 0;
				Map container = new HashMap();
				CompassQuery query = session.queryBuilder().queryString(
						keywords).toQuery();
				CompassHits hits = query.setAliases(type).hits();
				totalSize = hits.length();
				container.put("size", totalSize);
				int max = 0;
				if (end < hits.length()) {
					max = end;
				} else {
					max = hits.length();
				}

       if(type.equals("article")){
					for (int i = start; i < max; i++) {
						Article article = (Article) hits.data(i);
						String title = hits.highlighter(i).fragment("title");
						if (title != null) {
							article.setTitle(title);
						}
						String content = hits.highlighter(i).setTextTokenizer(
								CompassHighlighter.TextTokenizer.AUTO)
								.fragment("content");
						if (content != null) {

							article.setContent(content);
						}
						result.add(article);
					}
				}
				container.put("result", result);
				return container;
			}
		});
	}

	public Compass getCompass() {
		return compass;
	}

	public void setCompass(Compass compass) {
		this.compass = compass;
	}

}



索引的查询主要是根据传过来的参数，关键字keywords,是搜索的关键字,类型type，先判断是不是要搜索文章，因为一般来说，页面的搜索引擎不单单只搜索文章一个实体.
至于int 和end是为了分页取出部分结果的.
String title = hits.highlighter(i).fragment("title");这段是检索titile这个属性有没有出现搜索的关键字，有就将它高亮 （其实就是在关键字前后加个<font></font>的html标记设置颜色，等下可以看到在配置文件里可以自由设置高亮的颜 色）.
String content = hits.highlighter(i).setTextTokenizer(
CompassHighlighter.TextTokenizer.AUTO)
.fragment("content");

这段代码和上面的title具有一样的一样的功能，另外还多了个很重要的功能，自动选择正文中最匹配关键字的内容中的一部分输出。因为很多时候一篇文章几千字，我们只想显示有关键字的那部分的摘要，这时候这个功能就很方便.


这之后还要写一个建立索引的服务类，让服务器启动的时候或者定时重建索引.

Java代码
  1. import  org.compass.gps.CompassGps;  
  2. import  org.springframework.beans.factory.InitializingBean;  
  3.   
  4. public   class  CompassIndexBuilder  implements  InitializingBean {    
  5.       
  6.     // 是否需要建立索引，可被设置为false使本Builder失效.      
  7.     private   boolean  buildIndex =  false ;     
  8.     
  9.     // 索引操作线程延时启动的时间，单位为秒      
  10.     private   int  lazyTime =  10 ;     
  11.     
  12.     // Compass封装      
  13.     private  CompassGps compassGps;     
  14.     
  15.     // 索引线程      
  16.     private  Thread indexThread =  new  Thread() {     
  17.     
  18.         @Override     
  19.         public   void  run() {     
  20.             try  {     
  21.                 Thread.sleep(lazyTime * 1000 );     
  22.                 System.out.println("begin compass index..." );     
  23.                 long  beginTime = System.currentTimeMillis();     
  24.                 // 重建索引.      
  25.                 // 如果compass实体中定义的索引文件已存在，索引过程中会建立临时索引，      
  26.                 // 索引完成后再进行覆盖.      
  27.                 compassGps.index();     
  28.                 long  costTime = System.currentTimeMillis() - beginTime;     
  29.                 System.out.println("compss index finished." );     
  30.                 System.out.println("costed "  + costTime +  " milliseconds" );     
  31.             } catch  (InterruptedException e) {     
  32.                 e.printStackTrace();     
  33.             }     
  34.         }     
  35.     };     
  36.     
  37.     /**    
  38.      * 实现<code>InitializingBean</code>接口，在完成注入后调用启动索引线程.  
  39.      */     
  40.     public   void  afterPropertiesSet()  throws  Exception {     
  41.         if  (buildIndex) {     
  42.             indexThread.setDaemon(true );     
  43.             indexThread.setName("Compass Indexer" );     
  44.             indexThread.start();     
  45.         }     
  46.     }     
  47.     
  48.     public   void  setBuildIndex( boolean  buildIndex) {     
  49.         this .buildIndex = buildIndex;     
  50.     }     
  51.     
  52.     public   void  setLazyTime( int  lazyTime) {     
  53.         this .lazyTime = lazyTime;     
  54.     }     
  55.     
  56.     public   void  setCompassGps(CompassGps compassGps) {     
  57.         this .compassGps = compassGps;     
  58.     }     
  59. }    
import org.compass.gps.CompassGps;
import org.springframework.beans.factory.InitializingBean;

public class CompassIndexBuilder implements InitializingBean {  
	
    // 是否需要建立索引，可被设置为false使本Builder失效.   
    private boolean buildIndex = false;   
  
    // 索引操作线程延时启动的时间，单位为秒   
    private int lazyTime = 10;   
  
    // Compass封装   
    private CompassGps compassGps;   
  
    // 索引线程   
    private Thread indexThread = new Thread() {   
  
        @Override  
        public void run() {   
            try {   
                Thread.sleep(lazyTime * 1000);   
                System.out.println("begin compass index...");   
                long beginTime = System.currentTimeMillis();   
                // 重建索引.   
                // 如果compass实体中定义的索引文件已存在，索引过程中会建立临时索引，   
                // 索引完成后再进行覆盖.   
                compassGps.index();   
                long costTime = System.currentTimeMillis() - beginTime;   
                System.out.println("compss index finished.");   
                System.out.println("costed " + costTime + " milliseconds");   
            } catch (InterruptedException e) {   
                e.printStackTrace();   
            }   
        }   
    };   
  
    /**  
     * 实现<code>InitializingBean</code>接口，在完成注入后调用启动索引线程.
     */  
    public void afterPropertiesSet() throws Exception {   
        if (buildIndex) {   
            indexThread.setDaemon(true);   
            indexThread.setName("Compass Indexer");   
            indexThread.start();   
        }   
    }   
  
    public void setBuildIndex(boolean buildIndex) {   
        this.buildIndex = buildIndex;   
    }   
  
    public void setLazyTime(int lazyTime) {   
        this.lazyTime = lazyTime;   
    }   
  
    public void setCompassGps(CompassGps compassGps) {   
        this.compassGps = compassGps;   
    }   
}


实现了spring的InitializingBean接口，让服务器启动，bean初始化的时候去建立索引


剩下的就是配置文件了

Java代码
  1. <?xml version= "1.0"  encoding= "UTF-8" ?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"   
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  5.     xmlns:aop="http://www.springframework.org/schema/aop"   
  6.     xmlns:tx="http://www.springframework.org/schema/tx"   
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  8.             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  9.             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">   
  10.   
  11.     <bean id="annotationConfiguration"   
  12.         class = "org.compass.annotations.config.CompassAnnotationsConfiguration" >  
  13.     </bean>  
  14.   
  15.     <!-- compass Bean  -->  
  16.     <bean id="compass"   class = "org.compass.spring.LocalCompassBean" >  
  17.         <property name="compassConfiguration"   
  18.             ref="annotationConfiguration"  />  
  19.         <!-- 数据索引存储位置 -->  
  20.         <property name="connection" >  
  21.             <value>/compass/indexes</value>  
  22.         </property>  
  23.         <property name="transactionManager"  ref= "transactionManager"  />  
  24.         <property name="compassSettings" >  
  25.             <props>  
  26.                 <prop key="compass.transaction.factory" >  
  27.                     org.compass.spring.transaction.SpringSyncTransactionFactory  
  28.                 </prop>  
  29.               
  30.                 <prop  
  31.                     key="compass.engine.highlighter.default.formatter.simple.pre" >  
  32.                     <![CDATA[<span style='background-color:yellow;color:red;' >]]>  
  33.                 </prop>  
  34.                 <prop  
  35.                     key="compass.engine.highlighter.default.formatter.simple.post" >  
  36.                     <![CDATA[</span>]]>  
  37.                 </prop>  
  38.     <!--定义分词器-->            
  39. <prop  
  40.                     key="compass.engine.analyzer.default.type" >  
  41.                     org.mira.lucene.analysis.IK_CAnalyzer  
  42.                 </prop>  
  43.             </props>  
  44.         </property>  
  45.         <property name="classMappings" >  
  46.             <list>  
  47.               
  48.                 <value>cn.rgcenter.entity.Article</value>  
  49.             </list>  
  50.         </property>  
  51.     </bean>  
  52.   
  53.     <!--hibernate驱动-->  
  54.     <bean id="hibernateGpsDevice"   
  55.         class = "org.compass.spring.device.hibernate.dep.SpringHibernate3GpsDevice" >  
  56.         <property name="name" >  
  57.             <value>hibernateDevice</value>  
  58.         </property>  
  59.         <property name="sessionFactory"  ref= "sessionFactory"  />  
  60.         <property name="mirrorDataChanges" >  
  61.             <value>true </value>  
  62.         </property>  
  63.     </bean>  
  64.   
  65.     <!-- 数据库中的数据变化后同步更新索引 -->  
  66.     <bean id="hibernateGps"   
  67.         class = "org.compass.gps.impl.SingleCompassGps"  init-method= "start"   
  68.         destroy-method="stop" >  
  69.         <property name="compass" >  
  70.             <ref bean="compass"  />  
  71.         </property>  
  72.         <property name="gpsDevices" >  
  73.             <list>  
  74.                 <bean  
  75.                     class = "org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper" >  
  76.                     <property name="gpsDevice"  ref= "hibernateGpsDevice"  />  
  77.                 </bean>  
  78.             </list>  
  79.         </property>  
  80.     </bean>  
  81.   
  82.     <!-- compass模版 -->  
  83.     <bean id="compassTemplate"   
  84.         class = "org.compass.core.CompassTemplate" >  
  85.         <property name="compass"  ref= "compass"  />  
  86.     </bean>  
  87.   
  88.     <!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->  
  89.     <bean id="compassIndexBuilder"   
  90.         class = "cn.rgcenter.compass.service.CompassIndexBuilder"   
  91.         lazy-init="false" >  
  92.         <property name="compassGps"  ref= "hibernateGps"  />  
  93.         <property name="buildIndex"  value= "true"  />  
  94.         <property name="lazyTime"  value= "5"  />  
  95.     </bean>  
  96.   
  97.     <!-- 搜索引擎服务类 -->  
  98.     <bean id="searchService"   
  99.         class = "cn.rgcenter.compass.service.SearchServiceBean" >  
  100.         <property name="compass" >  
  101.             <ref bean="compass"  />  
  102.         </property>  
  103.     </bean>  
  104.   
  105.     <!-- 搜索引擎Action -->  
  106.     <bean id="searchAction"   class = "cn.rgcenter.action.SearchAction" >  
  107.         <property name="searchService" >  
  108.             <ref bean="searchService"  />  
  109.         </property>  
  110.     </bean>  
  111.   
  112. </beans>   
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<bean id="annotationConfiguration"
		class="org.compass.annotations.config.CompassAnnotationsConfiguration">
	</bean>

	<!-- compass Bean  -->
	<bean id="compass" class="org.compass.spring.LocalCompassBean">
		<property name="compassConfiguration"
			ref="annotationConfiguration" />
	    <!-- 数据索引存储位置 -->
	    <property name="connection">
            <value>/compass/indexes</value>
        </property>
		<property name="transactionManager" ref="transactionManager" />
		<property name="compassSettings">
			<props>
				<prop key="compass.transaction.factory">
					org.compass.spring.transaction.SpringSyncTransactionFactory
				</prop>
			
				<prop
					key="compass.engine.highlighter.default.formatter.simple.pre">
					<![CDATA[<span style='background-color:yellow;color:red;'>]]>
				</prop>
				<prop
					key="compass.engine.highlighter.default.formatter.simple.post">
					<![CDATA[</span>]]>
				</prop>
	<!--定义分词器-->			
<prop
					key="compass.engine.analyzer.default.type">
					org.mira.lucene.analysis.IK_CAnalyzer
				</prop>
			</props>
		</property>
		<property name="classMappings">
			<list>
			
				<value>cn.rgcenter.entity.Article</value>
			</list>
		</property>
	</bean>

	<!--hibernate驱动-->
	<bean id="hibernateGpsDevice"
		class="org.compass.spring.device.hibernate.dep.SpringHibernate3GpsDevice">
		<property name="name">
			<value>hibernateDevice</value>
		</property>
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="mirrorDataChanges">
			<value>true</value>
		</property>
	</bean>

	<!-- 数据库中的数据变化后同步更新索引 -->
	<bean id="hibernateGps"
		class="org.compass.gps.impl.SingleCompassGps" init-method="start"
		destroy-method="stop">
		<property name="compass">
			<ref bean="compass" />
		</property>
		<property name="gpsDevices">
			<list>
				<bean
					class="org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper">
					<property name="gpsDevice" ref="hibernateGpsDevice" />
				</bean>
			</list>
		</property>
	</bean>

	<!-- compass模版 -->
	<bean id="compassTemplate"
		class="org.compass.core.CompassTemplate">
		<property name="compass" ref="compass" />
	</bean>

	<!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->
	<bean id="compassIndexBuilder"
		class="cn.rgcenter.compass.service.CompassIndexBuilder"
		lazy-init="false">
		<property name="compassGps" ref="hibernateGps" />
		<property name="buildIndex" value="true" />
		<property name="lazyTime" value="5" />
	</bean>

    <!-- 搜索引擎服务类 -->
	<bean id="searchService"
		class="cn.rgcenter.compass.service.SearchServiceBean">
		<property name="compass">
			<ref bean="compass" />
		</property>
	</bean>

	<!-- 搜索引擎Action -->
	<bean id="searchAction" class="cn.rgcenter.action.SearchAction">
		<property name="searchService">
			<ref bean="searchService" />
		</property>
	</bean>

</beans>


至于action就不列出代码了，很简单了，只需要传搜索方法的那几个参数过去就可以了.

最后看一下搜索结果示例图:



  • 大小: 41.1 KB
分享到：
| ant环境变量的配置
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    compass搜索引擎技术

    compass搜索引擎技术 eclipse mysql 实现像google的搜索功能

    struts2+spring2.5+hibernate3.26+compass2.1搜索引擎简单实现（无jar包）

    初学compass，参照网上代码写的。有什么不对的地方请大家指教。

    开源企业搜索引擎Solr的应用教程.doc

    由于搜索引擎功能在门户社区中对提高用户体验有着重在门户社区中涉及大量需要搜索引擎的功能需求，目前在实现搜索引擎的方案上有集中方案可供选择： 1) 基于Lucene自己进行封装实现站内搜索。工作量及扩展性都较大，...

    compass-2.2.0.zip

    compass-2.2.0.zip，Compass是第一个实现java搜索引擎的开源框架,它是基于Lucene之上的，提供更简单的搜索引擎API，事务支持，对象到搜索引擎映射

    Compass 2.0M2 DocumenTation(API) chm英文版

    Compass是第一个实现java搜索引擎的开源框架,它是基于Lucene之上的，提供更简单的搜索引擎API，事务支持，对象到搜索引擎映射（Annotations

    Compass 2.0M2 DocumenTation(API)-with-UsesIndex chm英文版

    Compass是第一个实现java搜索引擎的开源框架,它是基于Lucene之上的，提供更简单的搜索引擎API，事务支持，对象到搜索引擎映射（Annotations

    compass-2.1.2.jar'、lucene-analyzers-2.4.0.jar、 lucene-core-2.3.0.jar、 lucene-highlighter-2.4.0.jar、 struts2-core-2.0.9.jar、 struts2-spring-plugin-2.0.9.jar、 xwork-2.0.4.jar

    使用compass+lucene实现简单的全文检索功能 里面整合了spring2.5、hibernate3.2、struts2.0，是对数据库进行全文检索的一个非常好的demo的所有jar包组合！ 对研究基于数据库检索的java开源搜索引擎的朋友有很大的...

    java开源包3

    AutoTips基于搜索引擎Apache Lucene实现。AutoTips提供统一UI。 WAP浏览器 j2wap j2wap 是一个基于Java的WAP浏览器，目前处于BETA测试阶段。它支持WAP 1.2规范，除了WTLS 和WBMP。 Java注册表操作类 jared jared是...

    JAVA上百实例源码以及开源项目源代码

    得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥验证签名结果，使用公钥初始化签名对象,用于...

    JAVA上百实例源码以及开源项目

    得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥验证签名结果，使用公钥初始化签名对象,用于...

    java开源包4

    AutoTips基于搜索引擎Apache Lucene实现。AutoTips提供统一UI。 WAP浏览器 j2wap j2wap 是一个基于Java的WAP浏览器，目前处于BETA测试阶段。它支持WAP 1.2规范，除了WTLS 和WBMP。 Java注册表操作类 jared jared是...

    java源码包---java 源码 大量 实例

    得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥验证签名结果，使用公钥初始化签名对象,用于...

    java源码包2

    得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥验证签名结果，使用公钥初始化签名对象,用于...

    java开源包8

    AutoTips基于搜索引擎Apache Lucene实现。AutoTips提供统一UI。 WAP浏览器 j2wap j2wap 是一个基于Java的WAP浏览器，目前处于BETA测试阶段。它支持WAP 1.2规范，除了WTLS 和WBMP。 Java注册表操作类 jared jared是...

    java源码包3

    得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥验证签名结果，使用公钥初始化签名对象,用于...

    java源码包4

    得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥验证签名结果，使用公钥初始化签名对象,用于...

    java开源包1

    AutoTips基于搜索引擎Apache Lucene实现。AutoTips提供统一UI。 WAP浏览器 j2wap j2wap 是一个基于Java的WAP浏览器，目前处于BETA测试阶段。它支持WAP 1.2规范，除了WTLS 和WBMP。 Java注册表操作类 jared jared是...

    java开源包11

    AutoTips基于搜索引擎Apache Lucene实现。AutoTips提供统一UI。 WAP浏览器 j2wap j2wap 是一个基于Java的WAP浏览器，目前处于BETA测试阶段。它支持WAP 1.2规范，除了WTLS 和WBMP。 Java注册表操作类 jared jared是...

    java开源包2

    AutoTips基于搜索引擎Apache Lucene实现。AutoTips提供统一UI。 WAP浏览器 j2wap j2wap 是一个基于Java的WAP浏览器，目前处于BETA测试阶段。它支持WAP 1.2规范，除了WTLS 和WBMP。 Java注册表操作类 jared jared是...

Magicbox
Global site tag (gtag.js) - Google Analytics