JoyLau's Blog

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = JoylauElasticsearchApplication.class,webEnvironment = SpringBootTest.WebEnvironment.MOCK)
public class JoylauElasticsearchApplicationTests {
	@Autowired
	private RestTemplate restTemplate;

	@Autowired
	private PlaylistDAO playlistDAO;

	@Autowired
	private SongDAO songDAO;

	@Autowired
	private CommentDAO commentDAO;
	@Test
	public void createData() {
		String personalizeds = restTemplate.getForObject("http://localhost:3003/apis/v1"+"/personalized",String.class);
		JSONObject perJSON = JSONObject.parseObject(personalizeds);
		JSONArray perArr = perJSON.getJSONArray("result");
		List<Playlist> list = new ArrayList<>();
		List<Integer> playListIds = new ArrayList<>();
		for (Object o : perArr) {
			JSONObject playListJSON = JSONObject.parseObject(o.toString());
			Playlist playlist = new Playlist();
			playlist.setId(playListJSON.getIntValue("id"));
			playListIds.add(playlist.getId());
			playlist.setName(playListJSON.getString("name"));
			playlist.setPicURL(playListJSON.getString("picUrl"));
			playlist.setPlayCount(playListJSON.getIntValue("playCount"));
			playlist.setBookCount(playListJSON.getIntValue("bookCount"));
			playlist.setTrackCount(playListJSON.getIntValue("trackCount"));
			list.add(playlist);
		}
		playlistDAO.saveAll(list);



		/*存储歌曲*/
		List<Integer> songIds = new ArrayList<>();
		List<Song> songList = new ArrayList<>();
		for (Integer playListId : playListIds) {
			String res = restTemplate.getForObject("http://localhost:3003/apis/v1"+"/playlist/detail?id="+playListId,String.class);
			JSONArray songJSONArr = JSONObject.parseObject(res).getJSONObject("playlist").getJSONArray("tracks");
			for (Object o : songJSONArr) {
				JSONObject songJSON = JSONObject.parseObject(o.toString());
				Song song = new Song();
				song.setId(songJSON.getIntValue("id"));
				songIds.add(song.getId());
				song.setName(songJSON.getString("name"));
				song.setAuthor(getSongAuthor(songJSON.getJSONArray("ar")));
				song.setTime(songJSON.getLong("dt"));
				song.setPlaylistId(playListId);
				song.setPicURL(songJSON.getJSONObject("al").getString("picUrl"));
				song.setAlbum(songJSON.getJSONObject("al").getString("name"));
				songList.add(song);
			}
		}
		songDAO.saveAll(songList);



		/*存储评论*/
		List<Comment> commentList = new ArrayList<>();
		for (Integer songId : songIds) {
			String res = restTemplate.getForObject("http://localhost:3003/apis/v1"+"/comment/music?id="+songId+"&offset="+300,String.class);
			JSONArray commentArr = JSONObject.parseObject(res).getJSONArray("comments");
			for (Object o : commentArr) {
				JSONObject commentJSON = JSONObject.parseObject(o.toString());
				Comment comment = new Comment();
				comment.setId(commentJSON.getIntValue("commentId"));
				comment.setSongId(songId);
				comment.setContent(commentJSON.getString("content"));
				comment.setAuthor(commentJSON.getJSONObject("user").getString("nickname"));
				comment.setPicUrl(commentJSON.getJSONObject("user").getString("avatarUrl"));
				comment.setTime(commentJSON.getLong("time"));
				comment.setSupport(commentJSON.getIntValue("likedCount"));
				commentList.add(comment);
			}

		}

		commentDAO.saveAll(commentList);
	}

	/**
	 * 获取歌曲作者名
	 * @param arr arr
	 * @return String
	 */
	private String getSongAuthor(JSONArray arr){
		StringBuilder author = new StringBuilder();
		for (Object o : arr) {
			JSONObject json = JSONObject.parseObject(o.toString());
			author.append(json.getString("name"));
			if (arr.size() > 1){
				author.append(",");
			}
		}
		return author.toString();
	}
}

/**
 * 单字符串模糊查询，默认排序。将从所有字段中查找包含传来的word分词后字符串的数据集
 */
@Test
public void queryStringQuerySong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(queryStringQuery("Time")).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 单字符串模糊查询，单字段排序。 
 */  
@Test
public void queryStringQueryWeightSong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(queryStringQuery("Time")).withPageable(of(0,100,new Sort(Sort.Direction.DESC,"id"))).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

public void queryStringQueryWeightSong(@PageableDefault(sort = "id", direction = Sort.Direction.DESC) Pageable pageable){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(queryStringQuery("Time")).withPageable(pageable).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 单字段对某字符串模糊查询 
 */  
@Test
public void matchQuerySong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchQuery("name","Time")).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 单字段对某短语进行匹配查询，短语分词的顺序会影响结果 
 */  
@Test
public void phraseMatchSong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchPhraseQuery("name","Time")).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * term匹配，即不分词匹配，你传来什么值就会拿你传的值去做完全匹配 
 */  
@Test
public void termQuerySong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("name","Time")).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 多字段匹配 
 */  
@Test
public void multiMatchQuerySong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(multiMatchQuery("time","name","author")).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 单字段包含所有输入 
 */  
@Test
public void matchQueryOperatorSong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchQuery("name","真的").operator(Operator.AND)).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 单字段包含所有输入(按比例包含) 
 */  
@Test
public void matchQueryOperatorWithMinimumShouldMatchSong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchQuery("name","time").operator(Operator.AND).minimumShouldMatch("80%")).withPageable(of(0,100)).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

/** 
 * 多字段合并查询 
 */  
@Test
public void boolQuerySong(){
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(boolQuery().must(termQuery("userId", "2345098"))
            .should(rangeQuery("time").lt(165000)).must(matchQuery("name", "time"))).build();
    System.out.println(searchQuery.getQuery().toString());
    List<Song> songList = songDAO.search(searchQuery).getContent();
    for (Song song : songList) {
        System.out.println(JSONObject.toJSONString(song));
    }
}

@NoRepositoryBean
public interface ElasticsearchRepository<T, ID extends Serializable> extends ElasticsearchCrudRepository<T, ID> {
    <S extends T> S index(S var1);

    Iterable<T> search(QueryBuilder var1);

    FacetedPage<T> search(QueryBuilder var1, Pageable var2);

    FacetedPage<T> search(SearchQuery var1);

    Page<T> searchSimilar(T var1, String[] var2, Pageable var3);
}

public NativeSearchQuery(QueryBuilder query, QueryBuilder filter, List<SortBuilder> sorts, Field[] highlightFields) {  
        this.query = query;  
        this.filter = filter;  
        this.sorts = sorts;  
        this.highlightFields = highlightFields;  
    }  

private static void jsonPathTest() {
    JSONObject json = jsonTest();//调用自定义的jsonTest()方法获得json对象，生成上面的json
     
    //输出book[0]的author值
    String author = JsonPath.read(json, "$.store.book[0].author");
     
    //输出全部author的值，使用Iterator迭代
    List<String> authors = JsonPath.read(json, "$.store.book[*].author");
     
    //输出book[*]中category == 'reference'的book
    List<Object> books = JsonPath.read(json, "$.store.book[?(@.category == 'reference')]");               
     
    //输出book[*]中price>10的book
    List<Object> books = JsonPath.read(json, "$.store.book[?(@.price>10)]");
     
    //输出book[*]中含有isbn元素的book
    List<Object> books = JsonPath.read(json, "$.store.book[?(@.isbn)]");
     
    //输出该json中所有price的值
    List<Double> prices = JsonPath.read(json, "$..price");
     
    //可以提前编辑一个路径，并多次使用它
    JsonPath path = JsonPath.compile("$.store.book[*]"); 
    List<Object> books = path.read(json); 
}

@Component
public class MsgProducer {
    @Autowired
    private KafkaTemplate kafkaTemplate;
    public void sendMessage() {
        kafkaTemplate.send("index-vehicle","key","hello,kafka"  + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
    }
}

@Component
public class MsgConsumer {
    @KafkaListener(topics = {"index-vehicle"})
    public void processMessage(String content) {
        System.out.println(content);
    }
}

@Value("classpath:static/json/addTask.json")
Resource addTaskJson;

String jsonStr = new String(IOUtils.readFully(addTaskJson.getInputStream(), -1,true));
JSONObject json = JSONObject.parseObject(jsonStr);

@Entity(name = "t_samp_recog")
@Data
public class SampRecog {
    @Id
    @GeneratedValue
    private int id; //主键
    private String batch; // 批次
    private String img_url; // 图片路径
    private String plate_nbr; // 车辆号牌
    private boolean plate_nbr_right; // 车辆号牌是否正确
    private String brand; // 品牌
    private boolean brand_right; // 品牌是否正确
    private String veh_type; // 车辆类型
    private boolean veh_type_right; // 车辆类型是否正确
    private String veh_color; // 车身颜色
    private boolean veh_color_right; // 车身颜色是否正确
    private String sticker_pos; // 车标位置
    private boolean sticker_pos_right; // 车标位置是否全部正确
    private boolean is_right; // 是否全部正确
    private int check_status; //核对状态 1.未核对，2，正在核对，3、已经核对
}

public interface SampRecogDAO extends JpaRepository<SampRecog,Integer> {
}