Lösung für das Datenasymmetrieproblem zwischen MySQL und Elasticsearch

mysql> Beschreibungsartikel;
+-------------+--------------+------+-----+--------------------------------+-----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-------------+--------------+------+-----+--------------------------------+-----------+
| Ich würde | int(11) | NEIN | | 0 | |
| Titel | Mitteltext | NEIN | | NULL | |
| Beschreibung | Mitteltext | JA | | NULL | |
| Autor | varchar(100) | JA | | NULL | |
| Quelle | varchar(100) | JA | | NULL | |
| Inhalt | Langtext | JA | | NULL | |
| Status | Aufzählung('J','N')| NEIN | | 'N' | |
| ctime | Zeitstempel | NEIN | | AKTUELLER_ZEITSTEMPEL | |
| mtime | Zeitstempel | JA | | BEI UPDATE CURRENT_TIMESTAMP | |
+-------------+--------------+------+-----+--------------------------------+-----------+
7 Zeilen im Satz (0,00 Sek.)

jdbc {
  jdbc_driver_library => "/usr/share/java/mysql-connector-java.jar"
  jdbc_driver_class => "com.mysql.jdbc.Treiber"
  jdbc_connection_string => "jdbc:mysql://localhost:3306/cms"
  jdbc_user => "cms"
  jdbc_password => "Passwort"
  Zeitplan => "* * * * *" #Zeitgesteuerter Cron-Ausdruck, hier wird er einmal pro Minute ausgeführt. Anweisung => "select * from article where mtime > :sql_last_value"
  use_column_value => wahr
  Tracking-Spalte => "mtime"
  tracking_column_type => "Zeitstempel" 
  record_last_run => wahr
  last_run_metadata_path => "/var/tmp/article-mtime.last"
 }

Tabelle „elasticsearch_trash“ erstellen (
 `id` int(11) NICHT NULL,
 `ctime` Zeitstempel NULL DEFAULT CURRENT_TIMESTAMP,
 PRIMÄRSCHLÜSSEL (`id`)
) ENGINE=InnoDB STANDARD-CHARSET=utf8

CREATE DEFINER=`dba`@`%` TRIGGER `article_BEFORE_UPDATE` VOR DEM UPDATE AUF `article` FÜR JEDE ZEILE
BEGINNEN
 - Die Logik hier besteht darin, das Problem zu lösen, dass, wenn der Artikelstatus N ändert, die entsprechenden Daten in der Suchmaschine gelöscht werden müssen.
 WENN NEU.status = 'N' DANN
 in elasticsearch_trash(id) Werte (OLD.id) einfügen;
 ENDE, WENN;
 – Die Logik hierbei besteht darin, dass bei einer Änderung des Status auf Y die Artikel-ID weiterhin in der Methode elasticsearch_trash vorhanden ist, was zu einer versehentlichen Löschung führen kann. Daher müssen Sie die Recyclingdatensätze im Papierkorb löschen.
  WENN NEU.status = 'J' DANN
 aus elasticsearch_trash löschen, wobei ID = OLD.id;
 ENDE, WENN;
ENDE

CREATE DEFINER=`dba`@`%` TRIGGER `article_BEFORE_DELETE` VOR DEM LÖSCHEN VON `article` FÜR JEDE ZEILE
BEGINNEN
 – Die Logik hierbei besteht darin, dass ein Artikel beim Löschen in den Papierkorb der Suchmaschine verschoben wird.
 in elasticsearch_trash(id) Werte (OLD.id) einfügen;
ENDE

Paket cn.netkiller.api.domain.elasticsearch;

importiere java.util.Date;

importiere javax.persistence.Column;
importiere javax.persistence.Entity;
importiere javax.persistence.Id;
importiere javax.persistence.Table;

@Juristische Person
@Tisch
öffentliche Klasse ElasticsearchTrash {
 @Ausweis
 private int-ID;

 @Column(columnDefinition = "ZEITSTEMPEL STANDARD AKTUELLER_ZEITSTEMPEL")
 privates Datum ctime;

 öffentliche int getId() {
 Rückgabe-ID;
 }

 öffentliche void setId(int id) {
 diese.id = ID;
 }

 öffentliches Datum getCtime() {
 ctime zurückgeben;
 }

 öffentliche void setCtime(Datum ctime) {
 dies.ctime = ctime;
 }

}

Paket cn.netkiller.api.repository.elasticsearch;

importiere org.springframework.data.repository.CrudRepository;

importiere com.example.api.domain.elasticsearch.ElasticsearchTrash;

öffentliche Schnittstelle ElasticsearchTrashRepository erweitert CrudRepository<ElasticsearchTrash, Integer>{


}

Paket cn.netkiller.api.schedule;

importiere org.elasticsearch.action.delete.DeleteResponse;
importiere org.elasticsearch.client.transport.TransportClient;
importiere org.elasticsearch.rest.RestStatus;
importiere org.slf4j.Logger;
importiere org.slf4j.LoggerFactory;
importiere org.springframework.beans.factory.annotation.Autowired;
importiere org.springframework.scheduling.annotation.Scheduled;
importiere org.springframework.stereotype.Component;

importiere com.example.api.domain.elasticsearch.ElasticsearchTrash;
importiere com.example.api.repository.elasticsearch.ElasticsearchTrashRepository;

@Komponente
öffentliche Klasse ScheduledTasks {
 privater statischer finaler Logger-Logger = LoggerFactory.getLogger (ScheduledTasks.class);

 @Autowired
 privater TransportClient-Client;

 @Autowired
 privates ElasticsearchTrashRepository alasticsearchTrashRepository;

 öffentliche ScheduledTasks() {
 }

 @Scheduled(fixedRate = 1000 * 60) // Führe die geplante Aufgabe alle 60 Sekunden aus public void cleanTrash() {
 für (ElasticsearchTrash elasticsearchTrash : alasticsearchTrashRepository.findAll()) {
  DeleteResponse-Antwort = Client.prepareDelete("Information", "Artikel", elasticsearchTrash.getId() + "").get();
  RestStatus status = antwort.status();
  logger.info("löschen {} {}", elasticsearchTrash.getId(), status.toString());
  wenn (status == RestStatus.OK || status == RestStatus.NICHT_GEFUNDEN) {
  alasticsearchTrashRepository.delete(elasticsearchTrash);
  }
 }
 }
}

Paket cn.netkiller.api;

importiere org.springframework.boot.SpringApplication;
importiere org.springframework.boot.autoconfigure.SpringBootApplication;
importiere org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootAnwendung
@EnableScheduling
öffentliche Klasse Anwendung {

 öffentliche statische void main(String[] args) {
 SpringApplication.run(Anwendung.Klasse, Argumente);
 }
}