yoho-search / yoho-search-consumer · Commits

Go to a project

Authored by 胡古飞
Commit a8c23b971257eb5f6f30e53b766bb971fbd71dd2 2 parents 0b0df1fb ae257188

Merge branch 'wn_forbidden'

Inline Side-by-side
Showing 5 changed files with 311 additions and 165 deletions
  1 +package com.yoho.search.dal;
  2 +
  3 +import com.yoho.search.dal.model.ForbiddenSortBrand;
  4 +
  5 +import java.util.List;
  6 +
  7 +public interface ForbiddenSortBrandMapper {
  8 + int deleteByPrimaryKey(Short id);
  9 +
  10 + int insert(ForbiddenSortBrand record);
  11 +
  12 + ForbiddenSortBrand selectByPrimaryKey(Short id);
  13 +
  14 + void insertBatch(List<ForbiddenSortBrand> list);
  15 +
  16 + void deleteAll();
  17 +}
  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.yoho.search.dal.ForbiddenSortBrandMapper">
  4 + <resultMap id="BaseResultMap" type="com.yoho.search.dal.model.ForbiddenSortBrand">
  5 + <id column="id" property="id" jdbcType="INTEGER"/>
  6 + <result column="max_sort_id" property="maxSortId" jdbcType="INTEGER"/>
  7 + <result column="middle_sort_id" property="middleSortId" jdbcType="INTEGER"/>
  8 + <result column="small_sort_id" property="smallSortId" jdbcType="INTEGER"/>
  9 + <result column="brand_id" property="brandId" jdbcType="INTEGER"/>
  10 + <result column="create_time" property="createTime" jdbcType="INTEGER"/>
  11 + </resultMap>
  12 + <sql id="Base_Column_List">
  13 + id, max_sort_id, middle_sort_id, small_sort_id, brand_id, create_time
  14 + </sql>
  15 + <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Short">
  16 + select
  17 + <include refid="Base_Column_List"/>
  18 + from forbidden_sort_brand
  19 + where id = #{id,jdbcType=INTEGER}
  20 + </select>
  21 + <delete id="deleteByPrimaryKey" parameterType="java.lang.Short">
  22 + delete from forbidden_sort_brand
  23 + where id = #{id,jdbcType=INTEGER}
  24 + </delete>
  25 + <delete id="deleteAll">
  26 + delete from forbidden_sort_brand
  27 + where 1=1
  28 + </delete>
  29 + <insert id="insert" parameterType="com.yoho.search.dal.model.ForbiddenSortBrand">
  30 + insert into forbidden_sort_brand (id, max_sort_id, middle_sort_id, small_sort_id,
  31 + brand_id, create_time)
  32 + values (#{id,jdbcType=INTEGER}, #{maxSortId,jdbcType=INTEGER}, #{middleSortId,jdbcType=INTEGER}, #{smallSortId,jdbcType=INTEGER},
  33 + #{brandId,jdbcType=INTEGER}, #{createTime,jdbcType=INTEGER})
  34 + </insert>
  35 + <insert id="insertBatch" parameterType="java.util.List" timeout="20000">
  36 + insert ignore into forbidden_sort_brand (max_sort_id, middle_sort_id, small_sort_id,brand_id, create_time)
  37 + values
  38 + <foreach collection="list" item="item" index="index"
  39 + separator=",">
  40 + (#{item.maxSortId, jdbcType=INTEGER},
  41 + #{item.middleSortId, jdbcType=INTEGER},
  42 + #{item.smallSortId, jdbcType=INTEGER},
  43 + #{item.brandId, jdbcType=INTEGER},
  44 + #{item.createTime, jdbcType=INTEGER})
  45 + </foreach>
  46 + </insert>
  47 +</mapper>
1 package com.yoho.search.consumer.service.logic; 1 package com.yoho.search.consumer.service.logic;
2 2
3 -import java.util.ArrayList;  
4 -import java.util.HashMap;  
5 -import java.util.LinkedHashMap;  
6 -import java.util.List;  
7 -import java.util.Map;  
8 -import java.util.stream.Collectors;  
9 - 3 +import com.yoho.search.base.utils.FileUtils;
  4 +import com.yoho.search.consumer.service.base.BrandService;
  5 +import com.yoho.search.consumer.service.base.ProductSortService;
  6 +import com.yoho.search.dal.ForbiddenSortBrandMapper;
  7 +import com.yoho.search.dal.model.Brand;
  8 +import com.yoho.search.dal.model.ForbiddenSortBrand;
  9 +import com.yoho.search.dal.model.ProductSort;
10 import org.apache.commons.collections.CollectionUtils; 10 import org.apache.commons.collections.CollectionUtils;
11 import org.apache.commons.lang3.StringUtils; 11 import org.apache.commons.lang3.StringUtils;
12 import org.slf4j.Logger; 12 import org.slf4j.Logger;
@@ -14,165 +14,248 @@ import org.slf4j.LoggerFactory; @@ -14,165 +14,248 @@ import org.slf4j.LoggerFactory;
14 import org.springframework.beans.factory.annotation.Autowired; 14 import org.springframework.beans.factory.annotation.Autowired;
15 import org.springframework.stereotype.Service; 15 import org.springframework.stereotype.Service;
16 16
17 -import com.yoho.search.base.utils.FileUtils;  
18 -import com.yoho.search.consumer.service.base.BrandService;  
19 -import com.yoho.search.consumer.service.base.ProductSortService;  
20 -import com.yoho.search.dal.model.Brand;  
21 -import com.yoho.search.dal.model.ProductSort; 17 +import java.util.*;
  18 +import java.util.stream.Collectors;
22 19
23 @Service 20 @Service
24 public class ForbidenSortBrandLogicService { 21 public class ForbidenSortBrandLogicService {
25 22
26 - private static final Logger logger = LoggerFactory.getLogger(ForbidenSortBrandLogicService.class);  
27 -  
28 - private static final Integer PARENTID_OF_MAXSORT = Integer.valueOf(0);  
29 - private static final String LINE_SEPARATOR = System.lineSeparator();  
30 -  
31 - @Autowired  
32 - private ProductSortService productSortService;  
33 - @Autowired  
34 - private BrandService brandService;  
35 -  
36 - private final String forbiddenSortBrandFileName = "inner/forbidden_brands.txt";  
37 -  
38 - private Map<Integer, Map<Integer, List<Integer>>> forbiddenSortBrandMap;  
39 -  
40 - private void checkAndInit() {  
41 - if (forbiddenSortBrandMap != null) {  
42 - return;  
43 - }  
44 - synchronized (this) {  
45 - if (forbiddenSortBrandMap != null) {  
46 - return;  
47 - }  
48 - forbiddenSortBrandMap = genForbiddenSortBrandMap();  
49 - }  
50 - }  
51 -  
52 - public Map<Integer, Map<Integer, List<Integer>>> getForbiddenSortBrandMap() {  
53 - checkAndInit();  
54 - return forbiddenSortBrandMap;  
55 - }  
56 -  
57 - public boolean isForbiddenSortBrand(Integer maxSortId, Integer middleSortId, Integer brandId) {  
58 - if (maxSortId == null || middleSortId == null || brandId == null) {  
59 - return false;  
60 - }  
61 - checkAndInit();  
62 - Map<Integer, List<Integer>> middleSortMap = forbiddenSortBrandMap.get(maxSortId);  
63 - if (middleSortMap == null) {  
64 - return false;  
65 - }  
66 - List<Integer> brandIds = middleSortMap.get(middleSortId);  
67 - if (brandIds == null) {  
68 - return false;  
69 - }  
70 - return brandIds.contains(brandId);  
71 - }  
72 -  
73 - private Map<Integer, Map<Integer, List<Integer>>> genForbiddenSortBrandMap() {  
74 - //1、获取所有的品牌信息  
75 - Map<String, Integer> brandNameToIdMap = this.getBrandNameToIdMap();  
76 -  
77 - //2、获取所有的品类信息  
78 - List<ProductSort> productSortList = productSortService.getPageLists(0, Integer.MAX_VALUE);  
79 -  
80 - //3、获取大分类Map  
81 - Map<String,Integer> maxSortMap = new HashMap<String, Integer>();  
82 - productSortList.stream().filter(sort -> PARENTID_OF_MAXSORT.equals(sort.getParentId())).collect(Collectors.toList())  
83 - .forEach(sort -> maxSortMap.put(sort.getSortName(), sort.getId()));  
84 -  
85 - //4、构造大分类和中分类的对应关系  
86 - Map<Integer,Map<String,Integer>> maxSortToMiddleSort = new HashMap<Integer, Map<String,Integer>>();  
87 - for (Integer maxSortId : maxSortMap.values()) {  
88 - Map<String,Integer> middleSortMap = new HashMap<String, Integer>();  
89 - for (ProductSort productSort : productSortList) {  
90 - if(productSort.getParentId().equals(maxSortId)){  
91 - middleSortMap.put(productSort.getSortName(), productSort.getId());  
92 - }  
93 - }  
94 - maxSortToMiddleSort.put(maxSortId, middleSortMap);  
95 - }  
96 -  
97 - //5、读取文件  
98 - String filePath = this.getClass().getResource("/").getPath();  
99 - List<String> records = FileUtils.readFile(filePath + forbiddenSortBrandFileName);  
100 - if (CollectionUtils.isEmpty(records)) {  
101 - return new HashMap<Integer, Map<Integer, List<Integer>>>();  
102 - }  
103 -  
104 - //6、构建数据  
105 - Map<Integer, Map<Integer, List<Integer>>> resultMap = new LinkedHashMap<>();  
106 - StringBuilder transferResult = new StringBuilder(10000);  
107 - for (int i = 1; i < records.size(); i++) {  
108 - String[] contents = records.get(i).split("\\\t", 3);  
109 - if (contents == null || contents.length != 3) {  
110 - contents = records.get(i).split(" ", 3);  
111 - if (contents == null || contents.length != 3) {  
112 - logger.warn("Process line [{}] failed.", i);  
113 - continue;  
114 - }  
115 - }  
116 - Integer maxSortId = maxSortMap.get(contents[0]);  
117 - if (maxSortId == null) {  
118 - logger.warn("Process line [{}] with maxSort [{}] failed.", i, contents[0]);  
119 - continue;  
120 - }  
121 - Integer middleSortId = maxSortToMiddleSort.get(maxSortId).get(contents[1]);  
122 - if (middleSortId == null) {  
123 - logger.warn("Process line [{}] with middleSort [{}] failed.", i, contents[1]);  
124 - continue;  
125 - }  
126 - Integer brandId = brandNameToIdMap.get(contents[2]);  
127 - if (brandId == null) {  
128 - logger.warn("Process line [{}] with brand [{}] failed.", i, contents[2]);  
129 - continue;  
130 - }  
131 - Map<Integer, List<Integer>> innerMap = resultMap.get(maxSortId);  
132 - if (innerMap == null) {  
133 - innerMap = new LinkedHashMap<>(1000);  
134 - resultMap.put(maxSortId, innerMap);  
135 - }  
136 - List<Integer> innerBrandIds = innerMap.get(middleSortId);  
137 - if (innerBrandIds == null) {  
138 - innerBrandIds = new ArrayList<>(1000);  
139 - innerMap.put(middleSortId, innerBrandIds);  
140 - }  
141 - innerBrandIds.add(brandId);  
142 - transferResult.append(maxSortId).append("-").append(middleSortId).append("-").append(brandId).append(LINE_SEPARATOR);  
143 - }  
144 -  
145 - // 7、拼接数据  
146 - StringBuilder calResult = new StringBuilder(10000);  
147 - for (Map.Entry<Integer, Map<Integer, List<Integer>>> maxSortEntry : resultMap.entrySet()) {  
148 - for (Map.Entry<Integer, List<Integer>> middleSortEntry : maxSortEntry.getValue().entrySet()) {  
149 - String brandIdList = middleSortEntry.getValue().stream().map(String::valueOf).collect(Collectors.joining(","));  
150 - calResult.append(maxSortEntry.getKey()).append("|").append(middleSortEntry.getKey()).append("|").append(brandIdList).append(LINE_SEPARATOR);  
151 - }  
152 - }  
153 - logger.info("[ForbiddenBrandsController][forbidden_cal]" + LINE_SEPARATOR + calResult.toString());  
154 - FileUtils.writeFile("forbidden_cal.txt", calResult.toString());  
155 - FileUtils.writeFile("forbidden_tranfer.txt", transferResult.toString());  
156 -  
157 - // 8、返回结果  
158 - return resultMap;  
159 - }  
160 -  
161 - private Map<String, Integer> getBrandNameToIdMap() {  
162 - Map<String, Integer> brandNameToIdMap = new HashMap<String, Integer>();  
163 - List<Brand> brandList = brandService.getBrandPageLists(0, Integer.MAX_VALUE);  
164 - brandList.forEach(brand -> {  
165 - if (StringUtils.isNotEmpty(brand.getBrandName())) {  
166 - brandNameToIdMap.put(brand.getBrandName(), brand.getId());  
167 - }  
168 - if (StringUtils.isNotEmpty(brand.getBrandNameEn())) {  
169 - brandNameToIdMap.put(brand.getBrandNameEn(), brand.getId());  
170 - }  
171 - if (StringUtils.isNotEmpty(brand.getBrandNameCn())) {  
172 - brandNameToIdMap.put(brand.getBrandNameCn(), brand.getId());  
173 - }  
174 - });  
175 - return brandNameToIdMap;  
176 - } 23 + private static final Logger logger = LoggerFactory.getLogger(ForbidenSortBrandLogicService.class);
  24 +
  25 + private static final Integer PARENTID_OF_MAXSORT = Integer.valueOf(0);
  26 + private static final String LINE_SEPARATOR = System.lineSeparator();
  27 +
  28 + @Autowired
  29 + private ProductSortService productSortService;
  30 + @Autowired
  31 + private BrandService brandService;
  32 + @Autowired
  33 + private ForbiddenSortBrandMapper forbiddenSortBrandMapper;
  34 +
  35 + private final String forbiddenSortBrandFileName = "inner/forbidden_brands.txt";
  36 +
  37 + private Map<Integer, Map<Integer, Map<Integer, List<Integer>>>> forbiddenSortBrandMap;
  38 +
  39 + private void checkAndInit() {
  40 + if (forbiddenSortBrandMap != null) {
  41 + return;
  42 + }
  43 + synchronized (this) {
  44 + if (forbiddenSortBrandMap != null) {
  45 + return;
  46 + }
  47 + forbiddenSortBrandMap = genForbiddenSortBrandMap();
  48 + //insert to DB
  49 + List<ForbiddenSortBrand> forbiddenSortBrands = new ArrayList<>();
  50 + forbiddenSortBrandMap.forEach((maxSortId, middleSmallBrandMap) -> {
  51 + middleSmallBrandMap.forEach((middleSortId,smallBrandMap)->{
  52 + smallBrandMap.forEach((smallSortId, list) -> {
  53 + for (Integer brandId : list) {
  54 + ForbiddenSortBrand forbiddenSortBrand = new ForbiddenSortBrand();
  55 + forbiddenSortBrand.setMaxSortId(maxSortId);
  56 + forbiddenSortBrand.setMiddleSortId(middleSortId);
  57 + forbiddenSortBrand.setSmallSortId(smallSortId);
  58 + forbiddenSortBrand.setBrandId(brandId);
  59 + long time = System.currentTimeMillis() / 1000L;
  60 + forbiddenSortBrand.setCreateTime((int) time);
  61 + forbiddenSortBrands.add(forbiddenSortBrand);
  62 + }
  63 + });
  64 + });
  65 + });
  66 + forbiddenSortBrandMapper.deleteAll();
  67 + long begin = System.currentTimeMillis();
  68 + logger.info("deleteAll forbiddenSortBrand success [cost={}]", (System.currentTimeMillis() - begin));
  69 + List<List<ForbiddenSortBrand>> result = createList(forbiddenSortBrands, 1000);
  70 + logger.info("batch insert forbiddenSortBrand begin");
  71 + for (int i = 0; i < result.size(); i++) {
  72 + forbiddenSortBrandMapper.insertBatch(result.get(i));
  73 + logger.info("batch insert forbiddenSortBrand [page={}]of[{}],[cost={}]", i, result.size(), (System.currentTimeMillis() - begin));
  74 + }
  75 + logger.info("batch insert forbiddenSortBrand success,[cost={}]", (System.currentTimeMillis() - begin));
  76 + }
  77 + }
  78 +
  79 + public Map<Integer, Map<Integer, Map<Integer, List<Integer>>>> getForbiddenSortBrandMap() {
  80 + checkAndInit();
  81 + return forbiddenSortBrandMap;
  82 + }
  83 +
  84 + public boolean isForbiddenSortBrand(Integer maxSortId, Integer middleSortId,Integer smallSortId, Integer brandId) {
  85 + if (maxSortId == null || middleSortId == null || brandId == null) {
  86 + return false;
  87 + }
  88 + checkAndInit();
  89 + Map<Integer, Map<Integer, List<Integer>>> middleSortMap = forbiddenSortBrandMap.get(maxSortId);
  90 + if (middleSortMap == null) {
  91 + return false;
  92 + }
  93 + Map<Integer, List<Integer>> smallSortMap = middleSortMap.get(middleSortId);
  94 + if (smallSortMap == null) {
  95 + return false;
  96 + }
  97 + List<Integer> brandIds = smallSortMap.get(smallSortId);
  98 + if (brandIds == null) {
  99 + return false;
  100 + }
  101 + return brandIds.contains(brandId);
  102 + }
  103 +
  104 + private Map<Integer, Map<Integer, Map<Integer, List<Integer>>>> genForbiddenSortBrandMap() {
  105 + //1、获取所有的品牌信息
  106 + Map<String, Integer> brandNameToIdMap = this.getBrandNameToIdMap();
  107 +
  108 + //2、获取所有的品类信息
  109 + List<ProductSort> productSortList = productSortService.getPageLists(0, Integer.MAX_VALUE);
  110 +
  111 + //3、获取大分类Map
  112 + Map<String, Integer> maxSortMap = new HashMap<String, Integer>();
  113 + productSortList.stream().filter(sort -> PARENTID_OF_MAXSORT.equals(sort.getParentId())).collect(Collectors.toList())
  114 + .forEach(sort -> maxSortMap.put(sort.getSortName(), sort.getId()));
  115 +
  116 + //4、构造大分类和中分类的对应关系
  117 + Map<Integer, Map<String, Integer>> maxSortToMiddleSort = new HashMap<Integer, Map<String, Integer>>();
  118 + Map<Integer, Map<String, Integer>> middleSortToSmallSort = new HashMap<>();
  119 + for (Integer maxSortId : maxSortMap.values()) {
  120 + Map<String, Integer> middleSortMap = new HashMap<String, Integer>();
  121 + for (ProductSort productSort : productSortList) {
  122 + if (productSort.getParentId().equals(maxSortId)) {
  123 + middleSortMap.put(productSort.getSortName(), productSort.getId());
  124 + }
  125 + }
  126 + maxSortToMiddleSort.put(maxSortId, middleSortMap);
  127 + //构建中分类个小分类的对应关系
  128 + Map<String, Integer> smallSortMap = new HashMap<String, Integer>();
  129 + middleSortMap.forEach((middleSortName, middleSortId) -> {
  130 + for (ProductSort productSort : productSortList) {
  131 + if (productSort.getParentId().equals(middleSortId)) {
  132 + smallSortMap.put(productSort.getSortName(), productSort.getId());
  133 + }
  134 + }
  135 + middleSortToSmallSort.put(middleSortId, smallSortMap);
  136 + });
  137 + }
  138 +
  139 + //5、读取文件
  140 + String filePath = this.getClass().getResource("/").getPath();
  141 + List<String> records = FileUtils.readFile(filePath + forbiddenSortBrandFileName);
  142 + if (CollectionUtils.isEmpty(records)) {
  143 + return new HashMap<Integer, Map<Integer, Map<Integer, List<Integer>>>>();
  144 + }
  145 +
  146 + //6、构建数据
  147 + Map<Integer, Map<Integer, Map<Integer, List<Integer>>>> resultMap = new LinkedHashMap<>();
  148 + StringBuilder transferResult = new StringBuilder(10000);
  149 + for (int i = 1; i < records.size(); i++) {
  150 + String[] contents = records.get(i).split("\\\t", 4);
  151 + if (contents == null || contents.length != 4) {
  152 + contents = records.get(i).split(" ", 4);
  153 + if (contents == null || contents.length != 4) {
  154 + logger.warn("Process line [{}] failed.", i);
  155 + continue;
  156 + }
  157 + }
  158 + Integer maxSortId = maxSortMap.get(contents[0]);
  159 + if (maxSortId == null) {
  160 + logger.warn("Process line [{}] with maxSort [{}] failed.", i, contents[0]);
  161 + continue;
  162 + }
  163 + Integer middleSortId = maxSortToMiddleSort.get(maxSortId).get(contents[1]);
  164 + if (middleSortId == null) {
  165 + logger.warn("Process line [{}] with middleSort [{}] failed.", i, contents[1]);
  166 + continue;
  167 + }
  168 +
  169 + Integer smallSortId = 0;
  170 + if (contents[2].equals("全部")) {
  171 + } else {
  172 + smallSortId = middleSortToSmallSort.get(middleSortId).get(contents[2]);
  173 + }
  174 +
  175 + if (middleSortId == null) {
  176 + logger.warn("Process line [{}] with smallSort [{}] failed.", i, contents[2]);
  177 + continue;
  178 + }
  179 + Integer brandId = brandNameToIdMap.get(contents[3]);
  180 + if (brandId == null) {
  181 + logger.warn("Process line [{}] with brand [{}] failed.", i, contents[3]);
  182 + continue;
  183 + }
  184 +
  185 + Map<Integer, Map<Integer, List<Integer>>> middleSmallBrandMap = resultMap.get(maxSortId);
  186 + if (middleSmallBrandMap == null) {
  187 + middleSmallBrandMap = new LinkedHashMap<>(1000);
  188 + resultMap.put(maxSortId, middleSmallBrandMap);
  189 + }
  190 + Map<Integer, List<Integer>> smallBrandMap = middleSmallBrandMap.get(middleSortId);
  191 + if (smallBrandMap == null) {
  192 + smallBrandMap = new LinkedHashMap<>(1000);
  193 + middleSmallBrandMap.put(middleSortId,smallBrandMap);
  194 + resultMap.put(maxSortId, middleSmallBrandMap);
  195 + }
  196 + List<Integer> innerBrandIds = smallBrandMap.get(smallSortId);
  197 + if (innerBrandIds == null) {
  198 + innerBrandIds = new ArrayList<>(1000);
  199 + smallBrandMap.put(smallSortId,innerBrandIds);
  200 + middleSmallBrandMap.put(middleSortId,smallBrandMap);
  201 + resultMap.put(maxSortId, middleSmallBrandMap);
  202 + }
  203 + innerBrandIds.add(brandId);
  204 +
  205 + transferResult.append(maxSortId).append("-").append(middleSortId).append("-").append(smallSortId).append("-").append(brandId).append(LINE_SEPARATOR);
  206 + }
  207 +
  208 + // 7、拼接数据
  209 + StringBuilder calResult = new StringBuilder(10000);
  210 +
  211 + resultMap.forEach((maxSortId,middleSmallBrand)->{
  212 + middleSmallBrand.forEach((middleSortId,smallBrand)->{
  213 + smallBrand.forEach((smallSortId,brandIdList)->{
  214 + String brandIdListString = brandIdList.stream().map(String::valueOf).collect(Collectors.joining(","));
  215 + calResult.append(maxSortId).append("|").append(middleSortId).append("|").append(smallSortId).append("|").append(brandIdListString).append(LINE_SEPARATOR);
  216 + });
  217 + });
  218 + });
  219 +
  220 + logger.info("[ForbiddenBrandsController][forbidden_cal]" + LINE_SEPARATOR + calResult.toString());
  221 + FileUtils.writeFile("forbidden_cal.txt", calResult.toString());
  222 + FileUtils.writeFile("forbidden_tranfer.txt", transferResult.toString());
  223 +
  224 + // 8、返回结果
  225 + return resultMap;
  226 + }
  227 +
  228 + private Map<String, Integer> getBrandNameToIdMap() {
  229 + Map<String, Integer> brandNameToIdMap = new HashMap<String, Integer>();
  230 + List<Brand> brandList = brandService.getBrandPageLists(0, Integer.MAX_VALUE);
  231 + brandList.forEach(brand -> {
  232 + if (StringUtils.isNotEmpty(brand.getBrandName())) {
  233 + brandNameToIdMap.put(brand.getBrandName(), brand.getId());
  234 + }
  235 + if (StringUtils.isNotEmpty(brand.getBrandNameEn())) {
  236 + brandNameToIdMap.put(brand.getBrandNameEn(), brand.getId());
  237 + }
  238 + if (StringUtils.isNotEmpty(brand.getBrandNameCn())) {
  239 + brandNameToIdMap.put(brand.getBrandNameCn(), brand.getId());
  240 + }
  241 + });
  242 + return brandNameToIdMap;
  243 + }
177 244
  245 + private static List<List<ForbiddenSortBrand>> createList(List<ForbiddenSortBrand> target, int size) {
  246 + List<List<ForbiddenSortBrand>> listArr = new ArrayList<List<ForbiddenSortBrand>>();
  247 + //获取被拆分的数组个数
  248 + int arrSize = target.size() % size == 0 ? target.size() / size : target.size() / size + 1;
  249 + for (int i = 0; i < arrSize; i++) {
  250 + List<ForbiddenSortBrand> sub = new ArrayList<ForbiddenSortBrand>();
  251 + //把指定索引数据放入到list中
  252 + for (int j = i * size; j <= size * (i + 1) - 1; j++) {
  253 + if (j <= target.size() - 1) {
  254 + sub.add(target.get(j));
  255 + }
  256 + }
  257 + listArr.add(sub);
  258 + }
  259 + return listArr;
  260 + }
178 } 261 }
@@ -52,14 +52,13 @@ public class SpecialDealLogicService { @@ -52,14 +52,13 @@ public class SpecialDealLogicService {
52 } 52 }
53 53
54 private int getIsForbiddenSortBrand(ProductIBO productIBO) { 54 private int getIsForbiddenSortBrand(ProductIBO productIBO) {
55 - boolean isForbidenSortBrand = forbidenSortBrandLogicService.isForbiddenSortBrand(productIBO.getMaxSortId(), productIBO.getMiddleSortId(), productIBO.getBrandId()); 55 + boolean isForbidenSortBrand = forbidenSortBrandLogicService.isForbiddenSortBrand(productIBO.getMaxSortId(), productIBO.getMiddleSortId(),productIBO.getSmallSortId(), productIBO.getBrandId());
56 return isForbidenSortBrand ? 1 : 0; 56 return isForbidenSortBrand ? 1 : 0;
57 } 57 }
58 58
59 /** 59 /**
60 * 全量建索引時對PI的某些字段做特殊處理 60 * 全量建索引時對PI的某些字段做特殊處理
61 * 61 *
62 - * @param productIndex  
63 */ 62 */
64 public void specialDealProductI(ProductIBO productIBO) { 63 public void specialDealProductI(ProductIBO productIBO) {
65 // 1、处理ageLevel 64 // 1、处理ageLevel
This diff could not be displayed because it is too large.