solrj核心包     /solr-4.10.3/dist/solr-solrj-4.10.3.jar

solrj依赖包     /solr-4.10.3/dist/solrj-lib下的所有包

日志依赖包     /solr-4.10.3/example/lib/ext目录下的所有jar包

jdbc驱动包     mysql-connector-java-5.1.10-bin.jar

public class product {

private integer pid;

private string name;

private string catalog_name;

private double price;

private string description;

private string picture;

// 补全get、set方法

}

package cn.gzsxt.solr.dao;

import java.sql.connection;

import java.sql.drivermanager;

import java.sql.preparedstatement;

import java.sql.resultset;

import java.sql.sqlexception;

import java.util.arraylist;

import java.util.list;

import cn.gzsxt.solr.pojo.product;

public class productdao {

private connection connection;

private preparedstatement pst;   

private resultset rs;

/**

 * 采集数据，查询所有商品

 * @return

 */

public list<product> getallproducts() {

 list<product> products = new arraylist<>();

try {

//1、加载驱动

class.forname("com.mysql.jdbc.driver");

//2、获取connection连接

connection = drivermanager.getconnection("jdbc:mysql://localhost:3306/solr", "root", "gzsxt");

//3、获取preparedstatement,执行预编译

pst = connection.preparestatement("select pid,name, catalog_name,price,description,picture from products");

//4、执行sql搜索

rs = pst.executequery();

product p = null;

while(rs.next()){

p = new product();

p.setpid(rs.getint("pid"));

p.setname(rs.getstring("name"));

p.setprice(rs.getfloat("price"));

p.setpicture(rs.getstring("picture"));

p.setdescription(rs.getstring("description"));           

p.setcatalog_name(rs.getstring("catalog_name"));

products.add(p);

}

} catch (exception e) {

e.printstacktrace();

}finally {

if(null!=rs){

try {

rs.close();

} catch (sqlexception e) {

// todo auto-generated catch block

e.printstacktrace();

}

}

if(null!=pst){

try {

pst.close();

} catch (sqlexception e) {

// todo auto-generated catch block

e.printstacktrace();

}

}

if(null!=connection){

try {

connection.close();

} catch (sqlexception e) {

// todo auto-generated catch block

e.printstacktrace();

}

}

}

return products;

}

}

package cn.gzsxt.solr.test;

import org.junit.test;

import cn.gzsxt.solr.dao.productdao;

public class productdaotest {

@test

public void getallproducts(){

productdao dao = new productdao();

system.out.println(dao.getallproducts());

}

}

public solrinputdocument(map fields){

        _documentboost = 1.0f;

        _fields = fields;

}

public void addfield(string name, object value){

        addfield(name, value, 1.0f);

}

域

tokened

indexed

stored

商品的id

n

y

y

商品的名称

y

y

y

商品的类别

n

y

y

商品的价格

y

y

y

商品的图片

n

n

y

商品描述信息

y

y

n

<!--product-->

<field name="id" type="string" indexed="true" stored="true" required="true"

multivalued="false" />

<field name="product_name" type="text_general" indexed="true" stored="true"/>

<field name="product_catalog_name" type="string" indexed="true" stored="true" />

<field name="product_price"  type="double" indexed="true" stored="true"/>

<field name="product_description" type="text_general" indexed="true" stored="false" />

<field name="product_picture" type="string" indexed="false" stored="true" />

/**

 * 将采集到的商品数据，转换成solr文档类型

 * @param products

 * @return

 */

public list<solrinputdocument> getdocuments(list<product> products){

list<solrinputdocument> docs = new arraylist<>();

solrinputdocument doc = null;

for (product product : products) {

doc = new solrinputdocument();

doc.addfield("id", product.getpid());

doc.addfield("product_name", product.getname());

doc.addfield("product_price", product.getprice());

doc.addfield("product_catalog_name", product.getcatalog_name());

doc.addfield("product_description", product.getdescription());

doc.addfield("product_picture", product.getpicture());

docs.add(doc);

}

return docs;

}

@test

public void createindex(){

// 1、 创建httpsolrserver对象，通过它和solr服务器建立连接。

// 参数：solr服务器的访问地址

httpsolrserver server = new httpsolrserver("http://localhost:8080/solr/solrcore0719");

// 2、 通过httpsolrserver对象将solrinputdocument添加到索引库。

productdao dao = new productdao();

        try {

server.add(dao.getdocuments(dao.getallproducts()));

// 3、 提交。

server.commit();

system.out.println("创建索引库成功!!!");

} catch (solrserverexception e) {

e.printstacktrace();

} catch (ioexception e) {

e.printstacktrace();

}

}

@test

public void queryindex() throws exception {

// 创建httpsolrserver对象，通过它和solr服务器建立连接。

// 参数：solr服务器的访问地址

httpsolrserver server = new httpsolrserver("http://localhost:8080/solr/solrcore0719");

// 创建solrquery对象

solrquery query = new solrquery();

// 设置查询条件,参考主界面

query.set("q", "*:*");

// 调用server的查询方法，查询索引库

queryresponse response = server.query(query);

// 查询结果

solrdocumentlist results = response.getresults();

// 查询结果总数

long cnt = results.getnumfound();

system.out.println("查询结果总数:" + cnt);

system.out.println("--------------------分隔符-------------------");

for (solrdocument solrdocument : results) {

system.out.println("商品id:"+solrdocument.get("id"));

system.out.println("商品名称:"+solrdocument.get("product_name"));

system.out.println("商品价格:"+solrdocument.get("product_price"));

system.out.println("商品类别:"+solrdocument.get("product_catalog_name"));

system.out.println("商品图片:"+solrdocument.get("product_picture"));

system.out.println("----------------------------------------");

}

}

@test

public void querydynamic(){

//1、连接solr服务器

httpsolrserver server = new httpsolrserver("http://localhost:8080/solr/solrcore0719");

//2、创建查询对象，封装查询条件

solrquery query = new solrquery();

//设置默认搜索的域

query.set("df", "product_name");

//参考管理界面中的 "q"标签，封装查询的关键词

query.set("q", "音乐盒");

//添加价格过滤

query.addfilterquery("product_price:[10 to 50]");

//添加类别过滤

query.addfilterquery("product_catalog_name:幽默杂货");

//设置排序  价格升序

query.set("sort","product_price asc");

//设置分页信息  第二页 每页10条   start=(page-1)*pagesize

query.set("start", 10);

query.set("rows",10);

//设置要查询字段

query.set("fl", "id,product_name,product_price");

//3、执行查询

try {

queryresponse response = server.query(query);

//获取查询的响应码

int status = response.getstatus();

system.out.println("响应码:"+status);

if(0==status){

solrdocumentlist solrdocumentlist = response.getresults();

long numfound = solrdocumentlist.getnumfound();

system.out.println("共查询到"+numfound+"条满足条件的数据!");

system.out.println("--------------");

for (solrdocument s : solrdocumentlist) {

system.out.println("商品的id:"+s.get("id"));

system.out.println("商品的名称:"+s.get("product_name"));

system.out.println("商品的价格:"+s.get("product_price"));

system.out.println("商品的图片:"+s.get("product_picture"));

system.out.println("商品的类别名称:"+s.get("product_catalog_name"));

system.out.println("商品的描述:"+s.get("product_decsription"));

system.out.println("-----------分隔符---------------");

}

}

} catch (solrserverexception e) {

e.printstacktrace();

}

}

<lib dir="f:/depjar/contrib/dataimporthandler/lib/" regex=".*\.jar" />

<lib dir="f:/depjar/contrib/db/lib/" regex=".*\.jar" />

<?xml version="1.0" encoding="utf-8" ?>  

<dataconfig>   

<datasource type="jdbcdatasource"   

  driver="com.mysql.jdbc.driver"   

  url="jdbc:mysql://localhost:3306/solr"   

  user="root"   

  password="gzsxt"/>   

<document>   

<entity name="product" query="select pid,name,catalog,catalog_name,price,description,picture from products ">

 <field column="pid" name="id"/>

 <field column="name" name="product_name"/>

 <field column="catalog_name" name="product_catalog_name"/>

 <field column="price" name="product_price"/>

 <field column="description" name="product_description"/>

 <field column="picture" name="product_picture"/>

</entity>   

</document>   

</dataconfig>

<requesthandler name="/dataimport"

class="org.apache.solr.handler.dataimport.dataimporthandler">

           <lst name="defaults">

           <str name="config">data-config.xml</str>

           </lst>

  </requesthandler> 

<!-- ikanalyzer-->

    <fieldtype name="text_ik" class="solr.textfield">

             <analyzer class="org.wltea.analyzer.lucene.ikanalyzer"/>

    </fieldtype>

<field name="id" type="string" indexed="true" stored="true" required="true" multivalued="false" />

   <field name="product_name" type="text_ik" indexed="true" stored="true"/>

   <field name="product_catalog_name" type="string" indexed="true" stored="true" />

   <field name="product_price"  type="double" indexed="true" stored="true"/>

   <field name="product_description" type="text_ik" indexed="true" stored="false" />

   <field name="product_picture" type="string" indexed="false" stored="true" />

<?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:mvc="http://www.springframework.org/schema/mvc"

xmlns:context="http://www.springframework.org/schema/context"

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-3.1.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.1.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.1.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.1.xsd ">

<!-- 配置扫描包 -->

<context:component-scan base-package="cn.gzsxt" />

<!-- 配置注解驱动 -->

<mvc:annotation-driven />

<!-- jsp视图解析器 -->

<bean

class="org.springframework.web.servlet.view.internalresourceviewresolver">

<!-- 前缀 -->

<property name="prefix" value="/web-inf/jsp/"></property>

<!-- 后缀 -->

<property name="suffix" value=".jsp"></property>

</bean>

<bean class="org.apache.solr.client.solrj.impl.httpsolrserver">

<constructor-arg value="http://localhost:8080/solr/solrcore0719"></constructor-arg>

</bean>

</beans>

<?xml version="1.0" encoding="utf-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="webapp_id" version="3.1">

  <display-name>jd0719</display-name>

  <!-- springmvc配置 -->

<servlet>

<servlet-name>springmvc</servlet-name>

<servlet-class>org.springframework.web.servlet.dispatcherservlet</servlet-class>

<init-param>

<param-name>contextconfiglocation</param-name>

<param-value>classpath:springmvc.xml</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>springmvc</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

<filter>

<filter-name>character encoding</filter-name>

<filter-class>org.springframework.web.filter.characterencodingfilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>utf-8</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>character encoding</filter-name>

<url-pattern>*.action</url-pattern>

</filter-mapping>

</web-app>

package cn.gzsxt.solr.controller;

import org.springframework.stereotype.controller;

import org.springframework.web.bind.annotation.pathvariable;

import org.springframework.web.bind.annotation.requestmapping;

@controller

public class pagecontroller {

@requestmapping(value="/{page}")

public string showpage(@pathvariable("page")string page){

return page;

}

}

<bean class="org.apache.solr.client.solrj.impl.httpsolrserver">

<constructor-arg value="http://localhost:8888/solr/solrcore0719"></constructor-arg>

</bean>

请求路径

list.action

请求方式

post

请求参数

querystring、catalog_name、price、curpage、sort（共5个）

返回结果

定义product 以及productmodel

public class product {

// 商品编号

private string pid;

// 商品名称

private string name;

// 商品分类名称

private string catalog_name;

// 价格

private double price;

// 商品描述

private string description;

// 图片名称

private string picture;

}

public class resultmodel {

private list<product> productlist;

// 商品总数

private long recordcount;

// 总页数

private int pagecount;

// 当前页

private int currentpage;

}

public interface productdao {

//查询商品信息，包括分页信息

public resultmodel queryproduct(solrquery query) throws exception;

}

package cn.gzsxt.dao.impl;

import java.util.arraylist;

import java.util.list;

import java.util.map;

import org.apache.solr.client.solrj.solrquery;

import org.apache.solr.client.solrj.impl.httpsolrserver;

import org.apache.solr.client.solrj.response.queryresponse;

import org.apache.solr.common.solrdocument;

import org.apache.solr.common.solrdocumentlist;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.stereotype.repository;

import cn.gzsxt.bean.product;

import cn.gzsxt.bean.resultmodel;

import cn.gzsxt.dao.productdao;

@repository

public class productdaoimpl implements productdao {

@autowired

private httpsolrserver server;

@override

public resultmodel queryproduct(solrquery query) throws exception {

resultmodel result = new resultmodel();

// 通过server查询索引库

queryresponse response = server.query(query);

// 获得查询结果

solrdocumentlist documentlist = response.getresults();

// 把查询结果总数设置到resultmodel

result.setrecordcount(documentlist.getnumfound());

list<product> productlist = new arraylist<>();

product product = null;

// 高亮信息

map<string, map<string, list<string>>> highlighting = response

.gethighlighting();

for (solrdocument solrdocument : documentlist) {

product = new product();

product.setpid((string) solrdocument.get("id"));

string prodname = (string) solrdocument.get("product_name");

list<string> list = highlighting.get(solrdocument.get("id")).get(

"product_name");

if (list != null)

prodname = list.get(0);

product.setname(prodname);

product.setcatalog_name((string) solrdocument

.get("product_catalog_name"));

product.setprice((float) solrdocument.get("product_price"));

product.setpicture((string) solrdocument.get("product_picture"));

productlist.add(product);

}

// 把商品列表放到resultmap中

result.setproductlist(productlist);

return result;

}

}

public interface productservice {

public resultmodel queryproduct(string querystring, string cataname,

string price, string sort, integer curpage) throws exception;

}

package cn.gzsxt.service.impl;

import org.apache.solr.client.solrj.solrquery;

import org.apache.solr.client.solrj.solrquery.order;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.stereotype.service;

import cn.gzsxt.dao.productdao;

import cn.gzsxt.service.productservice;

import cn.gzsxt.vo.resultmodel;

@service

public class productserviceimpl implements productservice {

@autowired

private productdao productdao;

@override

public resultmodel queryproduct(string querystring, string cataname,

string price, string sort, integer curpage) throws exception {

//封装查询条件

solrquery query = new solrquery();

//判断查询条件是否为空

if(!"".equals(querystring)&& null != querystring){

query.setquery(querystring);

}else{

query.setquery("*:*");

}

//判断过滤条件是否为空

if(!"".equals(cataname)&& null !=cataname){

query.addfilterquery("product_catalog_name:"+cataname);

}

//判断商品价格是否为空

if(!"".equals(price) && null != price){

string[] prices = price.split("-");

if(prices.length == 2){

query.addfilterquery("product_price:["+prices[0]+" to "+prices[1]+"]");

}

}

//设置排序

if("1".equals(sort)){

query.setsort("product_price", order.desc);

}else {

query.setsort("product_price", order.asc);

}

//设置分页信息

if(null == curpage){

curpage = 1;

}

query.setstart((curpage-1)*20);

query.setrows(20);  //每页20条数据

//设置默认搜索域

query.set("df","product_name");

query.sethighlight(true);

query.addhighlightfield("product_name");

query.sethighlightsimplepre("<font style=\"color:red\">");

query.sethighlightsimplepost("</font>");

resultmodel result = productdao.queryproduct(query);

result.setcurrentpage(curpage);

// 总页数 = 总数量 / 每页数据条数  结果向上取整

double ceil = math.ceil(result.getrecordcount().doublevalue()/20);

result.setpagecount((int)ceil);

return result;

}

}

package cn.gzsxt.controller;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.stereotype.controller;

import org.springframework.ui.modelmap;

import org.springframework.web.bind.annotation.requestmapping;

import cn.gzsxt.service.productservice;

import cn.gzsxt.vo.resultmodel;

@controller

public class productcontroller {

@autowired

private productservice productservice;

@requestmapping("/list.action")

public string queryproduct(string querystring, string catalog_name,

string price, string sort, integer curpage, modelmap model)

throws exception {

resultmodel resultmodel = productservice.queryproduct(querystring, catalog_name,

price, sort, curpage);

model.addattribute("result", resultmodel);

model.addattribute("querystring", querystring);

model.addattribute("catalog_name", catalog_name);

model.addattribute("price", price);

model.addattribute("sort", sort);

model.addattribute("page", curpage);

return "product_list";

}

}