1.solr（数据导入solr自带数据库）：

　　

　  　ImportItemController.java：

  1. package com.solr.controller;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6.  
  7. import com.solr.service.ItemService;
  8.  
  9. @RestController
  10. @RequestMapping("/importItem")
  11. public class ImportItemController {
  12.  
  13.     @Autowired
  14.     private ItemService itemService;
  15.  
  16.     @RequestMapping("/import")
  17.     public String importImtems() {
  18.         // 调用service
  19.         return itemService.importItems();
  20.     }
  21.  
  22. }

　　SearchItemController.java：

  1. package com.solr.controller;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import com.solr.service.SearchItemService;
  12. import com.solr.utils.JSONUtil;
  13.  
  14. @RestController
  15. @RequestMapping("/searchItem")
  16. public class SearchItemController {
  17.  
  18.     @Autowired
  19.     private SearchItemService searchItemService;
  20.  
  21.     /**
  22.      * @description queryCondition就是前端搜索框中用户输入的内容
  23.      * @param param
  24.      * @return
  25.      */
  26.     @RequestMapping("/byQueryCondition/{q}")
  27.     public String searchItems(@PathVariable("q") String queryCondition) {
  28.         Map<Integer, Object> resultMap = new HashMap<Integer, Object>();
  29.         // 第一步：判断用户是否输入了搜索关键字
  30.         if (null == queryCondition && "".equals(queryCondition)) {
  31.             // 报错404
  32.             resultMap.put(500, "未找到查询条件");
  33.         } else {
  34.             // 调用service来从solr中查询出所需要的数据
  35.             try {
  36.                 queryCondition = new String(queryCondition.getBytes("ISO-8859-1"), "UTF-8");
  37.                 String resultJson = searchItemService.queryItem(queryCondition);
  38.                 resultMap.put(200, resultJson);
  39.             } catch (Exception e) {
  40.                 e.printStackTrace();
  41.                 resultMap.put(500, "solr服务器未检索到数据");
  42.             }
  43.         }
  44.         return JSONUtil.toJSONString(resultMap);
  45.     }
  46. }

　　ItemCategoryMapper.java：

  1. package com.solr.mapper;
  2.  
  3. import com.solr.model.ItemCategory;
  4. import tk.mybatis.mapper.common.Mapper;
  5.  
  6. public interface ItemCategoryMapper extends Mapper<ItemCategory> {
  7. }

　　ItemDescMapper.java：

  1. package com.solr.mapper;
  2.  
  3. import com.solr.model.ItemDesc;
  4. import tk.mybatis.mapper.common.Mapper;
  5.  
  6. public interface ItemDescMapper extends Mapper<ItemDesc> {
  7. }

　　ItemMapper.java：

  1. package com.solr.mapper;
  2.  
  3. import com.solr.model.Item;
  4. import tk.mybatis.mapper.common.Mapper;
  5.  
  6. public interface ItemMapper extends Mapper<Item> {
  7. }

　　Item.java（生成器自动生成）：

  1. package com.solr.model;
  2.  
  3. import java.util.Date;
  4. import javax.persistence.*;
  5.  
  6. @Table(name = "ego_item")
  7. public class Item {
  8.     /**
  9.      * 商品id，同时也是商品编号
  10.      */
  11.     @Id
  12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  13.     private Long id;
  14.  
  15.     /**
  16.      * 商品标题
  17.      */
  18.     private String title;
  19.  
  20.     /**
  21.      * 商品卖点
  22.      */
  23.     @Column(name = "sell_point")
  24.     private String sellPoint;
  25.  
  26.     /**
  27.      * 商品价格，单位为：分
  28.      */
  29.     private Long price;
  30.  
  31.     /**
  32.      * 库存数量
  33.      */
  34.     private Integer num;
  35.  
  36.     /**
  37.      * 商品条形码
  38.      */
  39.     private String barcode;
  40.  
  41.     /**
  42.      * 商品图片
  43.      */
  44.     private String image;
  45.  
  46.     /**
  47.      * 所属类目，叶子类目
  48.      */
  49.     private Long cid;
  50.  
  51.     /**
  52.      * 商品状态，1-正常，2-下架，3-删除
  53.      */
  54.     private Byte status;
  55.  
  56.     /**
  57.      * 创建时间
  58.      */
  59.     private Date created;
  60.  
  61.     /**
  62.      * 更新时间
  63.      */
  64.     private Date updated;
  65.  
  66.     /**
  67.      * 获取商品id，同时也是商品编号
  68.      *
  69.      * @return id - 商品id，同时也是商品编号
  70.      */
  71.     public Long getId() {
  72.         return id;
  73.     }
  74.  
  75.     /**
  76.      * 设置商品id，同时也是商品编号
  77.      *
  78.      * @param id 商品id，同时也是商品编号
  79.      */
  80.     public void setId(Long id) {
  81.         this.id = id;
  82.     }
  83.  
  84.     /**
  85.      * 获取商品标题
  86.      *
  87.      * @return title - 商品标题
  88.      */
  89.     public String getTitle() {
  90.         return title;
  91.     }
  92.  
  93.     /**
  94.      * 设置商品标题
  95.      *
  96.      * @param title 商品标题
  97.      */
  98.     public void setTitle(String title) {
  99.         this.title = title == null ? null : title.trim();
  100.     }
  101.  
  102.     /**
  103.      * 获取商品卖点
  104.      *
  105.      * @return sell_point - 商品卖点
  106.      */
  107.     public String getSellPoint() {
  108.         return sellPoint;
  109.     }
  110.  
  111.     /**
  112.      * 设置商品卖点
  113.      *
  114.      * @param sellPoint 商品卖点
  115.      */
  116.     public void setSellPoint(String sellPoint) {
  117.         this.sellPoint = sellPoint == null ? null : sellPoint.trim();
  118.     }
  119.  
  120.     /**
  121.      * 获取商品价格，单位为：分
  122.      *
  123.      * @return price - 商品价格，单位为：分
  124.      */
  125.     public Long getPrice() {
  126.         return price;
  127.     }
  128.  
  129.     /**
  130.      * 设置商品价格，单位为：分
  131.      *
  132.      * @param price 商品价格，单位为：分
  133.      */
  134.     public void setPrice(Long price) {
  135.         this.price = price;
  136.     }
  137.  
  138.     /**
  139.      * 获取库存数量
  140.      *
  141.      * @return num - 库存数量
  142.      */
  143.     public Integer getNum() {
  144.         return num;
  145.     }
  146.  
  147.     /**
  148.      * 设置库存数量
  149.      *
  150.      * @param num 库存数量
  151.      */
  152.     public void setNum(Integer num) {
  153.         this.num = num;
  154.     }
  155.  
  156.     /**
  157.      * 获取商品条形码
  158.      *
  159.      * @return barcode - 商品条形码
  160.      */
  161.     public String getBarcode() {
  162.         return barcode;
  163.     }
  164.  
  165.     /**
  166.      * 设置商品条形码
  167.      *
  168.      * @param barcode 商品条形码
  169.      */
  170.     public void setBarcode(String barcode) {
  171.         this.barcode = barcode == null ? null : barcode.trim();
  172.     }
  173.  
  174.     /**
  175.      * 获取商品图片
  176.      *
  177.      * @return image - 商品图片
  178.      */
  179.     public String getImage() {
  180.         return image;
  181.     }
  182.  
  183.     /**
  184.      * 设置商品图片
  185.      *
  186.      * @param image 商品图片
  187.      */
  188.     public void setImage(String image) {
  189.         this.image = image == null ? null : image.trim();
  190.     }
  191.  
  192.     /**
  193.      * 获取所属类目，叶子类目
  194.      *
  195.      * @return cid - 所属类目，叶子类目
  196.      */
  197.     public Long getCid() {
  198.         return cid;
  199.     }
  200.  
  201.     /**
  202.      * 设置所属类目，叶子类目
  203.      *
  204.      * @param cid 所属类目，叶子类目
  205.      */
  206.     public void setCid(Long cid) {
  207.         this.cid = cid;
  208.     }
  209.  
  210.     /**
  211.      * 获取商品状态，1-正常，2-下架，3-删除
  212.      *
  213.      * @return status - 商品状态，1-正常，2-下架，3-删除
  214.      */
  215.     public Byte getStatus() {
  216.         return status;
  217.     }
  218.  
  219.     /**
  220.      * 设置商品状态，1-正常，2-下架，3-删除
  221.      *
  222.      * @param status 商品状态，1-正常，2-下架，3-删除
  223.      */
  224.     public void setStatus(Byte status) {
  225.         this.status = status;
  226.     }
  227.  
  228.     /**
  229.      * 获取创建时间
  230.      *
  231.      * @return created - 创建时间
  232.      */
  233.     public Date getCreated() {
  234.         return created;
  235.     }
  236.  
  237.     /**
  238.      * 设置创建时间
  239.      *
  240.      * @param created 创建时间
  241.      */
  242.     public void setCreated(Date created) {
  243.         this.created = created;
  244.     }
  245.  
  246.     /**
  247.      * 获取更新时间
  248.      *
  249.      * @return updated - 更新时间
  250.      */
  251.     public Date getUpdated() {
  252.         return updated;
  253.     }
  254.  
  255.     /**
  256.      * 设置更新时间
  257.      *
  258.      * @param updated 更新时间
  259.      */
  260.     public void setUpdated(Date updated) {
  261.         this.updated = updated;
  262.     }
  263. }

　　ItemCategory.java：

  1. package com.solr.model;
  2.  
  3. import java.util.Date;
  4. import javax.persistence.*;
  5.  
  6. @Table(name = "ego_item_cat")
  7. public class ItemCategory {
  8.     /**
  9.      * 类目ID
  10.      */
  11.     @Id
  12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  13.     private Long id;
  14.  
  15.     /**
  16.      * 父类目ID=0时，代表的是一级的类目
  17.      */
  18.     @Column(name = "parent_id")
  19.     private Long parentId;
  20.  
  21.     /**
  22.      * 类目名称
  23.      */
  24.     private String name;
  25.  
  26.     /**
  27.      * 状态。可选值:1(正常),2(删除)
  28.      */
  29.     private Integer status;
  30.  
  31.     /**
  32.      * 排列序号，表示同级类目的展现次序，如数值相等则按名称次序排列。取值范围:大于零的整数
  33.      */
  34.     @Column(name = "sort_order")
  35.     private Integer sortOrder;
  36.  
  37.     /**
  38.      * 该类目是否为父类目，1为true，0为false
  39.      */
  40.     @Column(name = "is_parent")
  41.     private Boolean isParent;
  42.  
  43.     /**
  44.      * 创建时间
  45.      */
  46.     private Date created;
  47.  
  48.     /**
  49.      * 创建时间
  50.      */
  51.     private Date updated;
  52.  
  53.     /**
  54.      * 获取类目ID
  55.      *
  56.      * @return id - 类目ID
  57.      */
  58.     public Long getId() {
  59.         return id;
  60.     }
  61.  
  62.     /**
  63.      * 设置类目ID
  64.      *
  65.      * @param id 类目ID
  66.      */
  67.     public void setId(Long id) {
  68.         this.id = id;
  69.     }
  70.  
  71.     /**
  72.      * 获取父类目ID=0时，代表的是一级的类目
  73.      *
  74.      * @return parent_id - 父类目ID=0时，代表的是一级的类目
  75.      */
  76.     public Long getParentId() {
  77.         return parentId;
  78.     }
  79.  
  80.     /**
  81.      * 设置父类目ID=0时，代表的是一级的类目
  82.      *
  83.      * @param parentId 父类目ID=0时，代表的是一级的类目
  84.      */
  85.     public void setParentId(Long parentId) {
  86.         this.parentId = parentId;
  87.     }
  88.  
  89.     /**
  90.      * 获取类目名称
  91.      *
  92.      * @return name - 类目名称
  93.      */
  94.     public String getName() {
  95.         return name;
  96.     }
  97.  
  98.     /**
  99.      * 设置类目名称
  100.      *
  101.      * @param name 类目名称
  102.      */
  103.     public void setName(String name) {
  104.         this.name = name == null ? null : name.trim();
  105.     }
  106.  
  107.     /**
  108.      * 获取状态。可选值:1(正常),2(删除)
  109.      *
  110.      * @return status - 状态。可选值:1(正常),2(删除)
  111.      */
  112.     public Integer getStatus() {
  113.         return status;
  114.     }
  115.  
  116.     /**
  117.      * 设置状态。可选值:1(正常),2(删除)
  118.      *
  119.      * @param status 状态。可选值:1(正常),2(删除)
  120.      */
  121.     public void setStatus(Integer status) {
  122.         this.status = status;
  123.     }
  124.  
  125.     /**
  126.      * 获取排列序号，表示同级类目的展现次序，如数值相等则按名称次序排列。取值范围:大于零的整数
  127.      *
  128.      * @return sort_order - 排列序号，表示同级类目的展现次序，如数值相等则按名称次序排列。取值范围:大于零的整数
  129.      */
  130.     public Integer getSortOrder() {
  131.         return sortOrder;
  132.     }
  133.  
  134.     /**
  135.      * 设置排列序号，表示同级类目的展现次序，如数值相等则按名称次序排列。取值范围:大于零的整数
  136.      *
  137.      * @param sortOrder 排列序号，表示同级类目的展现次序，如数值相等则按名称次序排列。取值范围:大于零的整数
  138.      */
  139.     public void setSortOrder(Integer sortOrder) {
  140.         this.sortOrder = sortOrder;
  141.     }
  142.  
  143.     /**
  144.      * 获取该类目是否为父类目，1为true，0为false
  145.      *
  146.      * @return is_parent - 该类目是否为父类目，1为true，0为false
  147.      */
  148.     public Boolean getIsParent() {
  149.         return isParent;
  150.     }
  151.  
  152.     /**
  153.      * 设置该类目是否为父类目，1为true，0为false
  154.      *
  155.      * @param isParent 该类目是否为父类目，1为true，0为false
  156.      */
  157.     public void setIsParent(Boolean isParent) {
  158.         this.isParent = isParent;
  159.     }
  160.  
  161.     /**
  162.      * 获取创建时间
  163.      *
  164.      * @return created - 创建时间
  165.      */
  166.     public Date getCreated() {
  167.         return created;
  168.     }
  169.  
  170.     /**
  171.      * 设置创建时间
  172.      *
  173.      * @param created 创建时间
  174.      */
  175.     public void setCreated(Date created) {
  176.         this.created = created;
  177.     }
  178.  
  179.     /**
  180.      * 获取创建时间
  181.      *
  182.      * @return updated - 创建时间
  183.      */
  184.     public Date getUpdated() {
  185.         return updated;
  186.     }
  187.  
  188.     /**
  189.      * 设置创建时间
  190.      *
  191.      * @param updated 创建时间
  192.      */
  193.     public void setUpdated(Date updated) {
  194.         this.updated = updated;
  195.     }
  196. }

　　ItemDesc.java：

  1. package com.solr.model;
  2.  
  3. import java.util.Date;
  4. import javax.persistence.*;
  5.  
  6. @Table(name = "ego_item_desc")
  7. public class ItemDesc {
  8.     /**
  9.      * 主键
  10.      */
  11.     @Id
  12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  13.     private Long id;
  14.  
  15.     /**
  16.      * 商品ID
  17.      */
  18.     @Column(name = "item_id")
  19.     private Long itemId;
  20.  
  21.     /**
  22.      * 创建时间
  23.      */
  24.     private Date created;
  25.  
  26.     /**
  27.      * 更新时间
  28.      */
  29.     private Date updated;
  30.  
  31.     /**
  32.      * 商品描述
  33.      */
  34.     @Column(name = "item_desc")
  35.     private String itemDesc;
  36.  
  37.     /**
  38.      * 获取主键
  39.      *
  40.      * @return id - 主键
  41.      */
  42.     public Long getId() {
  43.         return id;
  44.     }
  45.  
  46.     /**
  47.      * 设置主键
  48.      *
  49.      * @param id 主键
  50.      */
  51.     public void setId(Long id) {
  52.         this.id = id;
  53.     }
  54.  
  55.     /**
  56.      * 获取商品ID
  57.      *
  58.      * @return item_id - 商品ID
  59.      */
  60.     public Long getItemId() {
  61.         return itemId;
  62.     }
  63.  
  64.     /**
  65.      * 设置商品ID
  66.      *
  67.      * @param itemId 商品ID
  68.      */
  69.     public void setItemId(Long itemId) {
  70.         this.itemId = itemId;
  71.     }
  72.  
  73.     /**
  74.      * 获取创建时间
  75.      *
  76.      * @return created - 创建时间
  77.      */
  78.     public Date getCreated() {
  79.         return created;
  80.     }
  81.  
  82.     /**
  83.      * 设置创建时间
  84.      *
  85.      * @param created 创建时间
  86.      */
  87.     public void setCreated(Date created) {
  88.         this.created = created;
  89.     }
  90.  
  91.     /**
  92.      * 获取更新时间
  93.      *
  94.      * @return updated - 更新时间
  95.      */
  96.     public Date getUpdated() {
  97.         return updated;
  98.     }
  99.  
  100.     /**
  101.      * 设置更新时间
  102.      *
  103.      * @param updated 更新时间
  104.      */
  105.     public void setUpdated(Date updated) {
  106.         this.updated = updated;
  107.     }
  108.  
  109.     /**
  110.      * 获取商品描述
  111.      *
  112.      * @return item_desc - 商品描述
  113.      */
  114.     public String getItemDesc() {
  115.         return itemDesc;
  116.     }
  117.  
  118.     /**
  119.      * 设置商品描述
  120.      *
  121.      * @param itemDesc 商品描述
  122.      */
  123.     public void setItemDesc(String itemDesc) {
  124.         this.itemDesc = itemDesc == null ? null : itemDesc.trim();
  125.     }
  126. }

　　ItemService.java：

  1. package com.solr.service;
  2.  
  3. import java.io.IOException;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7. import org.apache.solr.client.solrj.SolrServer;
  8. import org.apache.solr.client.solrj.SolrServerException;
  9. import org.apache.solr.common.SolrInputDocument;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Service;
  12. import com.solr.mapper.ItemCategoryMapper;
  13. import com.solr.mapper.ItemDescMapper;
  14. import com.solr.mapper.ItemMapper;
  15. import com.solr.model.Item;
  16. import com.solr.model.ItemDesc;
  17. import com.solr.utils.JSONUtil;
  18.  
  19. @Service
  20. public class ItemService {
  21.  
  22.     @Autowired
  23.     private ItemMapper itemMapper;
  24.     @Autowired
  25.     private ItemCategoryMapper itemCategoryMapper;
  26.     @Autowired
  27.     private ItemDescMapper itemDescMapper;
  28.     @Autowired
  29.     private SolrServer solrServer;
  30.  
  31.     /**
  32.      * @description 从数据库中查询出数据导入solr库
  33.      * @return
  34.      */
  35.     public String importItems() {
  36.         Map<Integer, Object> resultMap = new HashMap<Integer, Object>();
  37.         // 第一步：从mysql数据库中查询出商品信息(List<Item>)，需要ItemMapper
  38.         List<Item> itemList =  itemMapper.selectAll();// 从mysql中查询出所有的商品信息
  39.         // 第二步：开始向solr库中进行导入
  40.         // 在solr配置文件(schema.xml)中，只需要item_title,sell_porint,price,image,category,desc，但是从mysql查询出的字段多余
  41.         for(Item item : itemList) {
  42.             // SolrInputDocument
  43.             SolrInputDocument solrDocument = new SolrInputDocument();
  44.             solrDocument.addField("id", item.getId());
  45.             solrDocument.addField("item_title", item.getTitle());
  46.             solrDocument.addField("item_sell_point", item.getSellPoint());
  47.             solrDocument.addField("item_price", item.getPrice());
  48.             solrDocument.addField("item_image", item.getImage());
  49.             if(item.getCid() != null && item.getCid() > 0L) {
  50.                 // 从数据库中通过cid查询出商品类目名称
  51.                 solrDocument.addField("item_category_name", itemCategoryMapper.selectByPrimaryKey(item.getCid()).getName());
  52.             }
  53.             ItemDesc itemDesc = new ItemDesc();
  54.             itemDesc.setItemId(item.getId());
  55.             ItemDesc itemDescription = itemDescMapper.selectOne(itemDesc);
  56.             if(itemDescription != null) {
  57.                 solrDocument.addField("item_desc", itemDescription.getItemDesc());
  58.             }
  59.             // 需要通过某一个class向solr服务器存入数据
  60.             try {
  61.                 solrServer.add(solrDocument);
  62.                 resultMap.put(200, "数据导入成功");
  63.             } catch (SolrServerException e) {
  64.                 e.printStackTrace();
  65.                 resultMap.put(500, "数据导入异常");
  66.             } catch (IOException e) {
  67.                 e.printStackTrace();
  68.                 resultMap.put(500, "数据导入异常");
  69.             }
  70.         }
  71.         return JSONUtil.toJSONString(resultMap);
  72.     }
  73.  
  74. }

　　SearchItemService.java：

  1. package com.solr.service;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Map;
  6.  
  7. import org.apache.solr.client.solrj.SolrQuery;
  8. import org.apache.solr.client.solrj.SolrServer;
  9. import org.apache.solr.client.solrj.response.QueryResponse;
  10. import org.apache.solr.common.SolrDocument;
  11. import org.apache.solr.common.SolrDocumentList;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Service;
  14.  
  15. import com.solr.model.Item;
  16. import com.solr.utils.JSONUtil;
  17.  
  18. @Service
  19. public class SearchItemService {
  20.  
  21.     @Autowired
  22.     private SolrServer solrServer;
  23.  
  24.     public String queryItem(String param) throws Exception {
  25.  
  26.         // 第一步：创建出solr的搜索对象SolrQuery-->solr-solrj，java调用solr提供的查询数据的接口
  27.         SolrQuery query = new SolrQuery();
  28.         // 把需要写入的条件传入到SolrQuery对象中
  29.         query.setQuery(param);
  30.         // 设置查询的起始条数
  31.         query.setStart(0);
  32.         // 每页显示的条数
  33.         query.setRows(20);
  34.         // 设置查询关键字
  35.         query.set("df", "item_keywords");
  36.  
  37.         // 设置高亮显示
  38.         query.setHighlight(true);
  39.         // 设置需要高亮显示的字段
  40.         query.addHighlightField("item_title");
  41.         // 设置需要高亮显示的颜色
  42.         // 用户在搜索框中搜索了"华为"---><font color="yellow">华为</font>
  43.         query.setHighlightSimplePre("<font style='color:red'>");
  44.         query.setHighlightSimplePost("</font>");
  45.  
  46.         // 首先从solr服务器中查询出所有的匹配结果 并且返回
  47.         QueryResponse response = solrServer.query(query);
  48.         // response-->用户在搜索框中输入的关键字-->点击搜索按钮-->调用controller-->调用service-->到solr服务器中进行查询
  49.         // -->把查询出的封装成QueryResponse(搜索出的数据)
  50.         SolrDocumentList solrDocumentList = response.getResults();// response.getResults();获取的是查询出的所有结果集文档
  51.  
  52.         // response.getHighlighting();-->获取存入的高亮信息<font style="color:yellow;">华为</font>xxxxxx....
  53.         Map<String, Map<String, List<String>>> hl = response.getHighlighting();
  54.  
  55.         // 转换为Java对象的结果集
  56.         List<Item> itemList = new ArrayList<>();
  57.         // 数据导入的时候，把查询出的实体类集合进行便利-->存入solrDocument
  58.         // 从solr查询数据的时候，首先把查询出的solrDocumentList便利-->存入每一个实体类中-->把存好的实体类再存入list集合中
  59.         // 方便页面通过jstl进行展示
  60.         for (SolrDocument doc : solrDocumentList) {
  61.             // 把结果集文档，转换成实体对象-->最终要显示页面上
  62.             Item item = new Item();
  63.             item.setId(Long.parseLong((String) doc.get("id")));
  64.             item.setImage((String) doc.get("item_image"));
  65.             item.setPrice((Long) doc.get("item_price"));
  66.  
  67.             // 因为map比较适合转换为json对象，所以封装到map中比较合适
  68.             Map<String, List<String>> h = hl.get((String) doc.get("id"));
  69.             // Map<String, List<String>>-->map:key=item_title
  70.             //List<String>:带有高亮显示的item_title
  71.             //List<String>:<font style="color:yellow;">索尼</font>(SONY) KD-55X9000B 55英寸 智能 4K 电视
  72.             List<String> l = h.get("item_title");
  73.             if (l != null && l.size() > 0) {
  74.                 item.setTitle(l.get(0));// 现在item实体类已经拥有了高亮显示的title信息
  75.             } else {
  76.                 item.setTitle((String) doc.get("item_title"));// 如果没有获取到数据，就把不是高亮显示的title信息封装到实体对象中
  77.             }
  78.             itemList.add(item);
  79.         }
  80.         return JSONUtil.toJSONString(itemList);
  81.     }
  82.  
  83. }

　　JSONUtil.java：

  1. package com.solr.utils;
  2.  
  3. import java.util.List;
  4. import com.fasterxml.jackson.core.JsonProcessingException;
  5. import com.fasterxml.jackson.databind.JavaType;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7.  
  8. public class JSONUtil {
  9.  
  10.     // 定义jackson对象
  11.     private static final ObjectMapper mapper = new ObjectMapper();
  12.     /**
  13.      * 将对象转换成json字符串
  14.      * @param data
  15.      * @return
  16.      */
  17.     public static String toJSONString(Object data) {
  18.         try {
  19.             String string = mapper.writeValueAsString(data);
  20.             return string;
  21.         } catch (JsonProcessingException e) {
  22.             e.printStackTrace();
  23.         }
  24.         return null;
  25.     }
  26.  
  27.     /**
  28.      * 将json结果集转化为对象
  29.      * @param jsonData
  30.      * @param beanType
  31.      * @return
  32.      */
  33.     public static <T> T parseObject(String jsonData, Class<T> beanType) {
  34.         try {
  35.             T t = mapper.readValue(jsonData, beanType);
  36.             return t;
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.         return null;
  41.     }
  42.  
  43.     /**
  44.      * 将json数据转换成list
  45.      * @param jsonData
  46.      * @param beanType
  47.      * @return
  48.      */
  49.     public static <T> List<T> parseArray(String jsonData, Class<T> beanType) {
  50.         JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, beanType);
  51.         try {
  52.             List<T> list = mapper.readValue(jsonData, javaType);
  53.             return list;
  54.         } catch (Exception e) {
  55.             e.printStackTrace();
  56.         }
  57.         return null;
  58.     }
  59. }

　　ItemCategoryMapper.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.solr.mapper.ItemCategoryMapper" >
  4.   <resultMap id="BaseResultMap" type="com.solr.model.ItemCategory" >
  5.     <!--
  6.       WARNING - @mbg.generated
  7.     -->
  8.     <id column="id" property="id" jdbcType="BIGINT" />
  9.     <result column="parent_id" property="parentId" jdbcType="BIGINT" />
  10.     <result column="name" property="name" jdbcType="VARCHAR" />
  11.     <result column="status" property="status" jdbcType="INTEGER" />
  12.     <result column="sort_order" property="sortOrder" jdbcType="INTEGER" />
  13.     <result column="is_parent" property="isParent" jdbcType="BIT" />
  14.     <result column="created" property="created" jdbcType="TIMESTAMP" />
  15.     <result column="updated" property="updated" jdbcType="TIMESTAMP" />
  16.   </resultMap>
  17. </mapper>

　　ItemDescMapper.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.solr.mapper.ItemDescMapper" >
  4.   <resultMap id="BaseResultMap" type="com.solr.model.ItemDesc" >
  5.     <!--
  6.       WARNING - @mbg.generated
  7.     -->
  8.     <id column="id" property="id" jdbcType="BIGINT" />
  9.     <result column="item_id" property="itemId" jdbcType="BIGINT" />
  10.     <result column="created" property="created" jdbcType="TIMESTAMP" />
  11.     <result column="updated" property="updated" jdbcType="TIMESTAMP" />
  12.     <result column="item_desc" property="itemDesc" jdbcType="LONGVARCHAR" />
  13.   </resultMap>
  14. </mapper>

　　ItemMapper.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.solr.mapper.ItemMapper" >
  4.   <resultMap id="BaseResultMap" type="com.solr.model.Item" >
  5.     <!--
  6.       WARNING - @mbg.generated
  7.     -->
  8.     <id column="id" property="id" jdbcType="BIGINT" />
  9.     <result column="title" property="title" jdbcType="VARCHAR" />
  10.     <result column="sell_point" property="sellPoint" jdbcType="VARCHAR" />
  11.     <result column="price" property="price" jdbcType="BIGINT" />
  12.     <result column="num" property="num" jdbcType="INTEGER" />
  13.     <result column="barcode" property="barcode" jdbcType="VARCHAR" />
  14.     <result column="image" property="image" jdbcType="VARCHAR" />
  15.     <result column="cid" property="cid" jdbcType="BIGINT" />
  16.     <result column="status" property="status" jdbcType="TINYINT" />
  17.     <result column="created" property="created" jdbcType="TIMESTAMP" />
  18.     <result column="updated" property="updated" jdbcType="TIMESTAMP" />
  19.   </resultMap>
  20. </mapper>

　　mybatis-config.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  4. <configuration>
  5.     <!-- mybatis默认是没有开启延迟加载的 需要手动开启 -->
  6.     <settings>
  7.         <!-- 延迟加载 默认false -->
  8.         <setting name="lazyLoadingEnabled" value="true" />
  9.         <!-- 积极加载 默认true -->
  10.         <setting name="aggressiveLazyLoading" value="false" />
  11.         <!--开启缓存-->
  12.         <setting name="cacheEnabled" value="true"/>
  13.     </settings>
  14. </configuration>

　　applicationContext-db.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
  4.     xmlns:context="http://www.springframework.org/schema/context" xmlns="http://www.springframework.org/schema/beans"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/tx
  8.        http://www.springframework.org/schema/tx/spring-tx.xsd
  9.        http://www.springframework.org/schema/aop
  10.        http://www.springframework.org/schema/aop/spring-aop.xsd
  11.        http://www.springframework.org/schema/context
  12.        http://www.springframework.org/schema/context/spring-context.xsd">
  13.  
  14.     <!--数据源配置 -->
  15.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
  16.         init-method="init" destroy-method="close">
  17.         <property name="driverClassName" value="${jdbc.driverClassName}" />
  18.         <property name="url" value="${jdbc.url}" />
  19.         <property name="username" value="${jdbc.username}" />
  20.         <property name="password" value="${jdbc.password}" />
  21.     </bean>
  22.  
  23.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  24.         <property name="dataSource" ref="dataSource" />
  25.         <!-- 自动扫描mapping.xml文件，**表示迭代查找 -->
  26.         <property name="mapperLocations" value="classpath*:mapper/*Mapper.xml" />
  27.         <!--mybatis配置文件位置 -->
  28.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
  29.     </bean>
  30.  
  31.     <!--扫描com.solr下的mapper接口 -->
  32.     <bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
  33.         <property name="basePackage" value="com.solr" />
  34.         <!--使用mybatis通用mapper插件 -->
  35.         <property name="properties">
  36.             <value>
  37.                 mappers=tk.mybatis.mapper.common.Mapper
  38.             </value>
  39.         </property>
  40.     </bean>
  41. </beans>

　　applicationContext-solr.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  8.     http://www.springframework.org/schema/context
  9.     http://www.springframework.org/schema/context/spring-context-4.3.xsd
  10.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
  11.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
  12.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">
  13.  
  14.     <bean id="solrServer" class="org.apache.solr.client.solrj.impl.HttpSolrServer">
  15.     <!-- baseURL:用来连接solr的集群(服务器) -->
  16.         <!-- baseURL：指向了solr的地址 http://ip地址:端口号/solr -->
  17.         <constructor-arg name="baseURL" value="${solr.service.url}" />
  18.     </bean>
  19.  
  20. </beans>

　　applicationContext-tx.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
  4.     xmlns:context="http://www.springframework.org/schema/context" xmlns="http://www.springframework.org/schema/beans"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  7.        http://www.springframework.org/schema/tx
  8.        http://www.springframework.org/schema/tx/spring-tx.xsd
  9.        http://www.springframework.org/schema/aop
  10.        http://www.springframework.org/schema/aop/spring-aop.xsd
  11.        http://www.springframework.org/schema/context
  12.        http://www.springframework.org/schema/context/spring-context.xsd">
  13.  
  14.     <!-- 事务管理器 -->
  15.     <bean id="transactionManager"
  16.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  17.         <property name="dataSource" ref="dataSource" />
  18.     </bean>
  19.     <!-- 事务详情 -->
  20.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  21.         <tx:attributes>
  22.             <!-- <tx:method name="select*" read-only="true" />
  23.             <tx:method name="find*" read-only="true" />
  24.             <tx:method name="get*" read-only="true" /> -->
  25.             <tx:method name="*" />
  26.         </tx:attributes>
  27.     </tx:advice>
  28.     <!--支持基于注解的aspectj -->
  29.     <aop:aspectj-autoproxy />
  30.  
  31.     <!--aop编程，切入点表达式 确定增强的连接器，从而获得切入点 -->
  32.     <aop:config>
  33.         <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.solr.service..*.*(..)))" />
  34.     </aop:config>
  35. </beans>

　　applicationContext-mvc.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  7.       http://www.springframework.org/schema/mvc
  8.       http://www.springframework.org/schema/mvc/spring-mvc.xsd
  9.       http://www.springframework.org/schema/context
  10.       http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  11.  
  12.     <!-- 自动扫描且只扫描@Controller 扫描的是controller -->
  13.     <context:component-scan base-package="com.solr.controller" />
  14.  
  15.     <!-- 当在web.xml 中 DispatcherServlet使用 <url-pattern>/</url-pattern> 映射时，能映射静态资源 -->
  16.     <mvc:default-servlet-handler />
  17.  
  18.     <!-- 可用在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。 -->
  19.     <mvc:annotation-driven>
  20.         <mvc:message-converters>
  21.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
  22.                 <constructor-arg index="0" value="UTF-8" />
  23.             </bean>
  24.             <!-- json的格式化 -->
  25.             <bean
  26.                 class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
  27.                 <property name="prettyPrint" value="true" />
  28.             </bean>
  29.         </mvc:message-converters>
  30.     </mvc:annotation-driven>
  31. </beans>

　　application.properties：

  1. #MYSQL jdbc
  2. jdbc.driverClassName=com.mysql.jdbc.Driver
  3. jdbc.url=jdbc:mysql://localhost:3306/test
  4. jdbc.username=root
  5. jdbc.password=root
  6.  
  7. #solr resource
  8. solr.service.url=http\://192.168.1.184\:8080/solr

　　applicationContext.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
  4.     xmlns:context="http://www.springframework.org/schema/context" xmlns="http://www.springframework.org/schema/beans"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  7.        http://www.springframework.org/schema/tx
  8.        http://www.springframework.org/schema/tx/spring-tx.xsd
  9.        http://www.springframework.org/schema/aop
  10.        http://www.springframework.org/schema/aop/spring-aop.xsd
  11.        http://www.springframework.org/schema/context
  12.        http://www.springframework.org/schema/context/spring-context.xsd">
  13.  
  14.        <!-- 加载application.properties配置文件 -->
  15.        <context:property-placeholder location="classpath:application.properties" />
  16.  
  17.        <!-- 开启扫描注解，spring只扫描service -->
  18.        <context:component-scan base-package="com.solr.service" />
  19.  
  20.        <!-- 需要哪个配置文件就引入哪个 -->
  21.        <import resource="spring/applicationContext-db.xml"/>
  22.        <import resource="spring/applicationContext-solr.xml"/>
  23.        <import resource="spring/applicationContext-tx.xml"/>
  24.  
  25. </beans>

　　web.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
  4.          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  5.     version="3.0">
  6.     <!--spring入口文件的配置 -->
  7.     <!-- 确定配置文件位置 -->
  8.     <context-param>
  9.         <param-name>contextConfigLocation</param-name>
  10.         <param-value>classpath:applicationContext.xml</param-value>
  11.     </context-param>
  12.     <!-- 配置spring 监听器，加载xml配置文件 -->
  13.     <listener>
  14.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  15.     </listener>
  16.     <!-- 解决POST请求的中文乱码 -->
  17.     <filter>
  18.         <filter-name>CharacterEncodingFilter</filter-name>
  19.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  20.         <init-param>
  21.             <param-name>encoding</param-name>
  22.             <param-value>utf-8</param-value>
  23.         </init-param>
  24.     </filter>
  25.     <filter-mapping>
  26.         <filter-name>CharacterEncodingFilter</filter-name>
  27.         <url-pattern>/*</url-pattern>
  28.     </filter-mapping>
  29.     <!-- DispatcherServlet：前端控制器 配置前端控制器servlet -->
  30.     <servlet>
  31.         <servlet-name>solr_demo</servlet-name>
  32.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  33.         <!--加载前端控制器配置文件 上下文配置位置 -->
  34.         <init-param>
  35.             <param-name>contextConfigLocation</param-name>
  36.             <param-value>classpath:springmvc/applicationContext-mvc.xml</param-value>
  37.         </init-param>
  38.         <!-- 表示随WEB服务器启动 -->
  39.         <load-on-startup>1</load-on-startup>
  40.     </servlet>
  41.  
  42.     <servlet-mapping>
  43.         <servlet-name>solr_demo</servlet-name>
  44.         <url-pattern>/</url-pattern>
  45.     </servlet-mapping>
  46. </web-app>

　　pom.xml：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <groupId>com.solr</groupId>
  5.     <artifactId>solr_demo</artifactId>
  6.     <packaging>war</packaging>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <name>solr_demo Maven Webapp</name>
  9.     <url>http://maven.apache.org</url>
  10.  
  11.     <properties>
  12.  
  13.         <!-- junit begin -->
  14.         <junit.version>4.12</junit.version>
  15.         <!-- junit end -->
  16.  
  17.         <!-- spring begin -->
  18.         <spring.version>4.3.4.RELEASE</spring.version>
  19.         <!-- spring end -->
  20.  
  21.         <!-- json begin -->
  22.         <jackson.version>2.8.1</jackson.version>
  23.         <fastjson.version>1.2.17</fastjson.version>
  24.         <!-- json end -->
  25.  
  26.         <!-- servlet jsp jstl begin -->
  27.         <servlet-api.version>3.0.1</servlet-api.version>
  28.         <jsp-api.version>2.0</jsp-api.version>
  29.         <jstl.version>1.2</jstl.version>
  30.         <!-- servlet jsp jstl end -->
  31.  
  32.         <!-- mysql begin -->
  33.         <mysql.version>5.1.40</mysql.version>
  34.         <!-- mysql begin -->
  35.  
  36.         <!-- druid begin -->
  37.         <druid.version>1.0.26</druid.version>
  38.         <!-- druid end -->
  39.  
  40.         <!-- mybatis begin -->
  41.         <mybatis.version>3.3.0</mybatis.version>
  42.         <mybatis.spring.version>1.2.3</mybatis.spring.version>
  43.         <mybatis.paginator.version>1.2.15</mybatis.paginator.version>
  44.         <mybatis.mapper.version>3.3.9</mybatis.mapper.version>
  45.         <!-- mybatis end -->
  46.  
  47.         <!-- ehcache begin -->
  48.         <ehcache.version>2.10.3</ehcache.version>
  49.         <!-- ehcache end -->
  50.  
  51.         <!-- solr begin -->
  52.         <solrj.version>4.10.3</solrj.version>
  53.         <!-- solr end -->
  54.  
  55.     </properties>
  56.  
  57.     <dependencies>
  58.         <!-- 所需要的jar包 -->
  59.         <!-- junit start -->
  60.         <dependency>
  61.             <groupId>junit</groupId>
  62.             <artifactId>junit</artifactId>
  63.             <version>${junit.version}</version>
  64.             <scope>test</scope>
  65.         </dependency>
  66.         <!-- junit end -->
  67.  
  68.         <!--spring start -->
  69.         <dependency>
  70.             <groupId>org.springframework</groupId>
  71.             <artifactId>spring-context</artifactId>
  72.             <version>${spring.version}</version>
  73.         </dependency>
  74.         <dependency>
  75.             <groupId>org.springframework</groupId>
  76.             <artifactId>spring-aspects</artifactId>
  77.             <version>${spring.version}</version>
  78.         </dependency>
  79.         <dependency>
  80.             <groupId>org.springframework</groupId>
  81.             <artifactId>spring-jdbc</artifactId>
  82.             <version>${spring.version}</version>
  83.         </dependency>
  84.         <dependency>
  85.             <groupId>org.springframework</groupId>
  86.             <artifactId>spring-test</artifactId>
  87.             <version>${spring.version}</version>
  88.             <scope>test</scope>
  89.         </dependency>
  90.  
  91.         <dependency>
  92.             <groupId>org.springframework</groupId>
  93.             <artifactId>spring-web</artifactId>
  94.             <version>${spring.version}</version>
  95.         </dependency>
  96.  
  97.         <dependency>
  98.             <groupId>org.springframework</groupId>
  99.             <artifactId>spring-webmvc</artifactId>
  100.             <version>${spring.version}</version>
  101.         </dependency>
  102.         <!--spring end -->
  103.  
  104.         <!--json start -->
  105.         <dependency>
  106.             <groupId>com.fasterxml.jackson.core</groupId>
  107.             <artifactId>jackson-core</artifactId>
  108.             <version>${jackson.version}</version>
  109.         </dependency>
  110.  
  111.         <dependency>
  112.             <groupId>com.fasterxml.jackson.core</groupId>
  113.             <artifactId>jackson-databind</artifactId>
  114.             <version>${jackson.version}</version>
  115.         </dependency>
  116.  
  117.         <dependency>
  118.             <groupId>com.fasterxml.jackson.core</groupId>
  119.             <artifactId>jackson-annotations</artifactId>
  120.             <version>${jackson.version}</version>
  121.         </dependency>
  122.  
  123.         <dependency>
  124.             <groupId>com.alibaba</groupId>
  125.             <artifactId>fastjson</artifactId>
  126.             <version>${fastjson.version}</version>
  127.         </dependency>
  128.         <!--json end -->
  129.  
  130.         <!-- servlet -->
  131.         <dependency>
  132.             <groupId>javax.servlet</groupId>
  133.             <artifactId>javax.servlet-api</artifactId>
  134.             <version>${servlet-api.version}</version>
  135.             <scope>provided</scope>
  136.         </dependency>
  137.  
  138.         <!-- jsp -->
  139.         <dependency>
  140.             <groupId>javax.servlet</groupId>
  141.             <artifactId>jsp-api</artifactId>
  142.             <version>${jsp-api.version}</version>
  143.             <scope>provided</scope>
  144.         </dependency>
  145.  
  146.         <!-- jstl -->
  147.         <dependency>
  148.             <groupId>javax.servlet</groupId>
  149.             <artifactId>jstl</artifactId>
  150.             <version>${jstl.version}</version>
  151.             <scope>runtime</scope>
  152.         </dependency>
  153.  
  154.         <!-- database begin -->
  155.         <dependency>
  156.             <groupId>mysql</groupId>
  157.             <artifactId>mysql-connector-java</artifactId>
  158.             <version>${mysql.version}</version>
  159.             <scope>runtime</scope>
  160.         </dependency>
  161.         <dependency>
  162.             <groupId>com.alibaba</groupId>
  163.             <artifactId>druid</artifactId>
  164.             <version>${druid.version}</version>
  165.         </dependency>
  166.         <dependency>
  167.             <groupId>org.mybatis</groupId>
  168.             <artifactId>mybatis</artifactId>
  169.             <version>${mybatis.version}</version>
  170.         </dependency>
  171.         <dependency>
  172.             <groupId>org.mybatis</groupId>
  173.             <artifactId>mybatis-spring</artifactId>
  174.             <version>${mybatis.spring.version}</version>
  175.         </dependency>
  176.         <!-- database end -->
  177.  
  178.         <!-- mybatis plugins begin -->
  179.         <dependency>
  180.             <groupId>tk.mybatis</groupId>
  181.             <artifactId>mapper</artifactId>
  182.             <version>${mybatis.mapper.version}</version>
  183.         </dependency>
  184.         <!-- mybatis plugins end -->
  185.  
  186.         <!--ehcache 缓存配置 -->
  187.         <dependency>
  188.             <groupId>net.sf.ehcache</groupId>
  189.             <artifactId>ehcache</artifactId>
  190.             <version>${ehcache.version}</version>
  191.         </dependency>
  192.  
  193.         <!-- solr客户端 -->
  194.             <dependency>
  195.                 <groupId>org.apache.solr</groupId>
  196.                 <artifactId>solr-solrj</artifactId>
  197.                 <version>${solrj.version}</version>
  198.             </dependency>
  199.     </dependencies>
  200.     <build>
  201.         <finalName>solr_demo</finalName>
  202.     </build>
  203. </project>

java：solr的更多相关文章

  1. 注意事项： Solr设备 Hello World

    试用 Solr-4.10.2 一 shards, 这两款机器 一是垃圾 rm -r example/solr/collection1/data/* 启动一个 node cd example java ...

  2. BugPhobia沟通篇章：Solr模式配置与数据导入调研

    0x01 :Scrum Meeting特别说明 特别说明,考虑到编译原理课程考核的时间安排,每天开发时间急剧缩短以至于难以维系正常的Scrum Meeting,因此,将2015/12/13 00:00 ...

  3. Solr系列一：Solr（Solr介绍、Solr应用架构、Solr安装使用）

    一.前言 前面已经学习了Lucene的分词.索引详解.搜索详解的知识,已经知道开发一个搜索引擎的流程了.现在就会有这样的一个问题:如果其他的系统也需要使用开发的搜索引擎怎么办呢?这个时候就需要把开发的 ...

  4. solr学习篇（四） java使用solr简单查询（初识solrj）

    使用java实现solr查询 目录:1:导入jar包 2:核心类介绍 3:代码实现 4:注意事项 一 导入jar包 solrj可以使Java应用程序很方便的访问与操作solr. solrj有几个核心类 ...

  5. java：redis（java代码操作redis，实体类mapper生成器（generator））

    1.redis_demo Maven  ItemMapper.xml: <?xml version="1.0" encoding="UTF-8" ?> ...

  6. Kotlin中变量不同于Java： var 对val（KAD 02）

    原文标题:Variables in Kotlin, differences with Java. var vs val (KAD 02) 作者:Antonio Leiva 时间:Nov 28, 201 ...

  7. Java：类与继承

    Java:类与继承 对于面向对象的程序设计语言来说,类毫无疑问是其最重要的基础.抽象.封装.继承.多态这四大特性都离不开类,只有存在类,才能体现面向对象编程的特点,今天我们就来了解一些类与继承的相关知 ...

  8. 深入理解Java：注解

    注解作用:每当你创建描述符性质的类或者接口时,一旦其中包含重复性的工作,就可以考虑使用注解来简化与自动化该过程. Java提供了四种元注解,专门负责新注解的创建工作. 元注解 元注解的作用就是负责注解 ...

  9. 转载：Solr的自动完成实现方式（第二部分：Suggester方式）

    转自:http://www.cnblogs.com/ibook360/archive/2011/11/30/2269077.html 在Solr的自动完成/自动补充实现介绍(第一部分) 中我介绍了怎么 ...

随机推荐

  1. 最全的PHP正则表达式

    一.校验数字的表达式 1 数字:^[0-9]*$2 n位的数字:^\d{n}$3 至少n位的数字:^\d{n,}$4 m-n位的数字:^\d{m,n}$5 零和非零开头的数字:^(0|[1-9][0- ...

  2. openGL中的gl,glu,glut

    OpenGL函数库相关的API有核心库(gl).实用库(glu).辅助库(aux).实用工具库(glut).窗口库(glx.agl.wgl)和扩展函数库等.gl是核心,glu是对gl的部分封装.glx ...

  3. IO框架：asyncio 上篇

    如何定义/创建协程 只要在一个函数前面加上 async 关键字,这个函数对象是一个协程,通过isinstance函数,它确实是Coroutine类型. from collections.abc imp ...

  4. Tomcat管理页面

    下面就是 Manager的界面: Server Status 上面个两个配置任意一个配置好了后,都可以启用Server Status的GUI界面:

  5. 1024·程序员节来啦！MyEclipse致敬改变世界的程序猿

    1024·程序员狂欢季 MyEclipse/CodeMix — Java开发利器!现金红包免费领! 快拆开看你的最大优惠券是多少,幸运奖红包翻倍!   (活动期间在线下单的客户才可享受此优惠,过期恢复 ...

  6. MQTT 入门介绍——菜鸟教程

    一.简述 MQTT(Message Queuing Telemetry Transport,消息队列遥测传输协议),是一种基于发布/订阅(publish/subscribe)模式的"轻量级& ...

  7. 基于LVM 测试磁盘写性能.md

    准备工作 /dev/sdb 创建一个卷组,基于卷组创建5个逻辑卷,各100G 在10.10.88.214 新建5台虚拟机,每台虚拟机用到lvm建的逻辑卷 dd 压测 在每台虚拟机上执行dd 命令: d ...

  8. APP技术选型

  9. mac使用sublime text3打开当前文件夹的终端

    打开sublime text3,同时按住shift+command+p打开扩展列表, 选择Package Control: Install Pageage,回车. 在输入框输入: terminal,回 ...

  10. go之基本数据类型

    一.整形 Go语言里支持有符号和无符号两种整型.这里的符号就是正负号. 1.分类: 有符号的整型:int , int8 , int16 , int32 , int64 无符号的整型:uint,uint ...