So erreichen Sie eine Datensynchronisierung basierend auf Java

Geschäftshintergrund

Das Einrichten geplanter Aufgaben im neuen System erfordert eine Echtzeitsynchronisierung der Daten im Kundensystem, um die Datenkonsistenz aufrechtzuerhalten.

Implementierungslogik

1 Je nach der vom Kunden bereitgestellten Schnittstelle verwendet dieses System die HTTP-Post-Anforderungsmethode, um die Schnittstellendaten abzurufen.
2. Da die vom Kunden bereitgestellte Schnittstelle über die Seitenzahl und Seitenkapazität verfügen muss, sind mehrere Anforderungen an die Schnittstelle erforderlich, um die gesamte Datenmenge abzurufen, sodass derselbe Vorgang rekursiv ausgeführt werden kann.
3. Jedes Mal, wenn Sie die Schnittstelle anfordern, können Sie entsprechend der Seitenkapazität (Seitengröße) mehrere Daten abrufen. Zu diesem Zeitpunkt können Sie Datenbanken stapelweise hinzufügen und Anweisungen mit Batch-SQL hinzufügen.
4. Da die Datensynchronisierung die Konsistenz der Daten zwischen den beiden Systemen aufrechterhalten muss, ist es notwendig, geplante Aufgaben zu verwenden und die Synchronisierungshäufigkeit anzugeben, zum Beispiel: einmal täglich oder zweimal täglich.
5. Die Verwendung geplanter Aufgaben führt zum Problem der Datenduplizierung. Erstellen Sie daher einen eindeutigen Index basierend auf einem eindeutigen Feld, um das Problem des wiederholten Hinzufügens von Daten zu vermeiden.
6. Durch die Einrichtung eines eindeutigen Index kann das Problem des wiederholten Hinzufügens desselben Datensatzes vermieden werden, jedoch nicht das Problem von Datenänderungen in anderen Feldern desselben Datensatzes mit Ausnahme des eindeutigen Indexfelds Das Hinzufügen einer SQL-Anweisung kann dieses Problem lösen.

Tipps: a. Wenn festgestellt wird, dass diese Datenzeile bereits in der Tabelle vorhanden ist (basierend auf dem Primärschlüssel oder dem eindeutigen Index), löschen Sie diese Datenzeile zuerst, und fügen Sie dann neue Daten ein. b. Andernfalls fügen Sie neue Daten direkt ein.

Technologie nutzen

1 Geplante Aufgaben einrichten.
2. Verwenden Sie die HTTP-Post-Methode, um Schnittstellendaten abzurufen.
3. An einem rekursiven Schleifenaufruf sind mehrere Datenseiten beteiligt.
4. Batch-Operationsdatenbank (ersetzen in).
5. Erstellen Sie einen eindeutigen Index, um wiederholtes Einfügen von Daten zu vermeiden.

Codedetails

1.StudentMapper.java

/**
     * 批量添加数据同步接口学生数据
     * @param studentList
     * @return
     */
    int addBatchStudent(@Param(value = "studentList") List<Student> studentList);

2.SyncStudentServiceImpl.java-Code lautet wie folgt:

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import ***.common.utils.HttpUtils;
import ***.common.utils.StringUtils;
import ***.entity.sync.Student;
import ***.mapper.sync.StudentMapper;
import ***.service.sync.SyncStudentService;
import ***.vo.StudentVO;
import lombok.extern.slf4j.Slf4j;

/**
 * 数据同步的学生实现类
 * @author hc
 * @create 2021/03/25 11:20
 * @version 1.0
 * @since 1.0
 */
@Service
@Slf4j
public class SyncStudentServiceImpl implements SyncStudentService {
    @Autowired
    private StudentMapper studentMapper;
    @Autowired
    private HttpUtils httpUtils;

    @Override
    public void bulkAddStudent(StudentVO studentVO) {
        log.info("调取学生接口传的参数对象studentVO："+studentVO);
        log.info("开始调取学生接口获取第" + studentVO.getPageIndex() + "页数据");
        //如何页面容量小于100，则按100计算
        if(studentVO.getPageSize() < 100) {
            studentVO.setPageSize(100);
        }
        //根据当前页码和页面容量调取获取学生数据接口
        JSONObject jsonObject = this.sendStudentHttpPost(studentVO);
        //判断返回JSONObject是否为null
        if (StringUtils.isNotNull(jsonObject) && jsonObject.containsKey("errcode") && jsonObject.getInteger("errcode") == 0) {
            if(jsonObject.containsKey("data")){
                JSONArray jsonArray = jsonObject.getJSONArray("data");
                //通过判断获取的jsonObject对象中key值为data是否为null和其 jsonArray的长度来判断是否进行递归
                //提示：此判断方法好于通过计算总页码的方式来递归拿数据（对获取的total依赖过大，因此放弃此方式）
                if(jsonObject.getString("data") != null && jsonArray.size() > 0) {
                   log.info("当前数据加载到几页》》》》：{}", studentVO.getPageIndex());
                   //调取批量添加数据
                   this.addStudentCycleData(jsonObject, studentVO);
                   //页码加1，继续调取下一页数据
                      studentVO.setPageIndex(studentVO.getPageIndex() + 1);
                     //采用递归方式直至循环结束
                   this.bulkAddStudent(studentVO);
                }else {
                    log.info("学生数据同步结束》》》");
                }
            }
        }
    }

    /**
     * 批量添加学生数据
     * @param jsonObject
     * @param areaVO
     * @return
     */
    public void addStudentCycleData(JSONObject jsonObject, StudentVO studentVO){
        List<Student> studentList = null;
        //判断jsonArray时候为空
        if (jsonObject != null && StringUtils.isNotBlank(jsonObject.getString("data"))) {
            //把JsonArray转成对应实体类集合
            studentList = JSONObject.parseArray(jsonObject.getString("data"), Student.class);
        }
        try {
            log.info("学生接口第" + studentVO.getPageIndex() + "页数据开始入库...");
            //调取方法批量进行添加学生数据
            studentMapper.addBatchStudent(studentList);
            log.info("学生接口第" + studentVO.getPageIndex() + "页数据入库成功...");
        } catch (Exception e) {
            log.error("学生批量添加数据库异常：{}", e.getMessage());
        }
    }

    /**
     * 根据studentVO(当前页码和页面容量)发送获取学生数据的请求
     * @param studentVO
     * @return
     */
    public JSONObject sendStudentHttpPost(StudentVO studentVO){
        JSONObject jsonObject = null;
        String studentUrl = "http://*****/async-api/jc/student";
        try {
            if (StringUtils.isNotEmpty(studentUrl)) {
                Map<String, Object> param = new HashMap<>();
                param.put("pageIndex", studentVO.getPageIndex());
                param.put("pageSize", studentVO.getPageSize());
                log.info("开始发起http请求...");
                jsonObject = httpUtils.sendHttpPost(param, studentUrl);
            }
        } catch (Exception e) {
            log.error("调取客户学生同步接口出现异常：{}，页面容量为：{}，页码：{}", e.getMessage(), 
            studentVO.getPageSize(), studentVO.getPageIndex());
        }
        return jsonObject;
    }
}

#🎜🎜 #3 Der .StudentVO.java-Code lautet wie folgt:

import lombok.Data;
/**
 * 数据同步接口获取学生数据传的参数VO类
 * @author hc
 * @create 2021/3/11 10:35
 * @version 1.0
 * @since 1.0
 */
@Data
public class StudentVO{
    //当前页码(初始值为0)
    private Integer pageIndex = 0;
    //页码容量
    private Integer pageSize;
}

4. Der HttpUtils.java-Code lautet wie folgt:

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;
import java.util.Map;

/**
 * Http请求工具类
 * @author hc
 * @create 2021/3/4
 * @version 1.0
 */
@Component
@Slf4j
public class HttpUtils {
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * 发送http的post请求方法
     * @param param
     * @return
     */
    public JSONObject sendHttpPost(Integer type, Map<String, Object> param, String url){
        log.info("调取同步接口Url:{}", url);
        JSONObject jsonObject = null;
        //发起http的post准备工作
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.add("Content-Type", "application/json");
        HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(param, httpHeaders);
        ResponseEntity<String> response = null;
        try {
            log.info("param参数为：{}",param.toString());
            response = restTemplate.postForEntity(url, httpEntity, String.class);
        } catch (HttpClientErrorException e) {
            log.error("发起http请求报错信息：{}",e.getResponseBodyAsString());
        }
        String bodyData = response.getBody();
        if (StringUtils.isNotEmpty(bodyData)) {
            jsonObject = JSONObject.parseObject(bodyData);
        }
        return jsonObject;
    }
}

5. Die SQL-Anweisung von StudentMapper.xml lautet wie folgt:

<!-- 批量添加数据同步接口中获取的学生数据 -->
<insert id="addBatchStudent" parameterType="***.entity.sync.Student">
    replace into xf_clue_sync_student(id, student_code, student_name, status, create_date, update_date)
    <foreach collection="studentList" item="student" open="values" separator="," >
       (#{student.id,jdbcType=BIGINT}, #{student.studentCode,jdbcType=INTEGER}, #{student.studentName,jdbcType=VARCHAR}, 
        #{student.status,jdbcType=INTEGER}, #{student.createDate,jdbcType=VARCHAR}, #{student.updateDate,jdbcType=VARCHAR})
    </foreach>
</insert>

#🎜 🎜#Funktionszusammenfassung

1 Der Code für die Konfiguration geplanter Aufgaben wird hier nicht mehr angezeigt. Das SpringBoot-Framework verwendet Anmerkungen, um geplante Aufgaben und die Aufrufhäufigkeit festzulegen .

2. Die Entwicklung der Datensynchronisationsschnittstelle erfordert je nach Anwendungsszenario unterschiedliche Methoden. Sie können beispielsweise auch Kettle-Tools usw. verwenden.

Das obige ist der detaillierte Inhalt vonSo erreichen Sie eine Datensynchronisierung basierend auf Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!