Detect text abusing

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;

import java.util.Base64;
import org.jooq.tools.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.extern.slf4j.Slf4j;

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

@Slf4j
public class TadsComponent {

@Autowired
RestTemplate restTemplate;

@Autowired
ObjectMapper objectMapper;


public void sendHttp() throws Exception{
    String projectKey =  <PROJECT_KEY>; // provide the project key
    String secretKey =  <SECRET_KEY>;  // provide the project secret key

    String url = "https://tads.withhive.com/cads2/send-text-data";
    String user_id = "432414";
    String channel_info = "4342314"; // Use it only when it is required
    String room_num = "12312"; // Use it only when it is required
    String text_type = "chat_whisper"; // Use it only when it is required
    String lang_code = "ko";
    String text_1 = "test1";
    String text_2 = "test2";

    DateTimeFormatter formatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
    ZonedDateTime now = ZonedDateTime.now();

    Map<String, Object> payload = new HashMap<>();
    payload.put("project_key", projectKey);

    Map<String, Object> textLog = new HashMap<>();
    textLog.put("text_count", 2); // should match the number of elements of text_array

    Map<String, Object> textArray1 = new HashMap<>();
    textArray1.put("time_stamp", now.format(formatter));
    textArray1.put("text_info", encrypt(text_1, user_id, channel_info, room_num, text_type, lang_code, secretKey));


Map<String, Object> textArray2 = new HashMap<>();
   textArray2.put("time_stamp", now.format(formatter));
   textArray2.put("text_info", encrypt(text_2, user_id, channel_info, room_num, text_type, lang_code, secretKey));

    Object[] textArrayObj = {textArray1, textArray2};
    textLog.put("text_array", textArrayObj);
    payload.put("text_log", textLog);
    JsonNode callBodyNode = objectMapper.valueToTree(payload);
    HttpHeaders headers = new HttpHeaders();
    headers.add("Content-Type", "application/json");
    HttpEntity<String> entity = new HttpEntity<>(callBodyNode.toString(), headers);
    ResponseEntity<String> responseEntity =  restTemplate.exchange(url, HttpMethod.POST, entity, String.class);
    int responseStatusCode =  responseEntity.getStatusCodeValue();
    String responseBodyString = responseEntity.getBody();
    JsonNode responseBodyNode = objectMapper.readTree(responseBodyString);
    return;
}

public static String encrypt(String text, String UserId, String channelInfo, String roomNum, String textType, String langCode, String secretKey) {
    try {
        Cipher aes = Cipher.getInstance("AES/ECB/PKCS5Padding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(), "AES");
        aes.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("room_num", roomNum); // Use it only when it is required
        map.put("channel_info", channelInfo); // Use it only when it is required
        map.put("lang_code", langCode);
        map.put("text", text);
        map.put("text_type", textType); // Use it only when it is required
        map.put("user_id", UserId);
        String encrypt_str = JSONObject.toJSONString(map);
        byte[] paddedData = padString(encrypt_str).getBytes();
        byte[] encryptedData = aes.doFinal(paddedData);
        return Base64.getEncoder().encodeToString(encryptedData);
    } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
        e.printStackTrace();
        return null;
    }
}
private static String padString(String source) {
    char paddingChar = ' ';
    int size = 16;
    int x = source.length() % size;
    int padLength = size - x;
    StringBuilder paddedString = new StringBuilder(source);
    for (int i = 0; i < padLength; i++) {
        paddedString.append(paddingChar);
    }
    return paddedString.toString();
}} // the codes for encryption