JAVA接口_java接口添加密钥-优快云博客

我们根据用户需求设计一个Java接口处理程序，主要包含两个功能：
功能1：提供一个对外接口，接收特定格式字符串，使用DES解密（密钥为JcXmSjjs20250801），然后将解密后的数据保存到MySQL数据库，并返回成功结果。
功能2：定时任务（每分钟执行一次），调用其他系统的GET和POST API接口，传入参数，解析返回的数据并存入MySQL数据库。

我们将分步骤实现：

搭建Spring Boot项目（假设使用Spring Boot，因为它简化了开发）
实现DES加解密工具类
设计数据库表（根据实际数据格式，这里用户没有给出具体格式，我们假设一个简单的表结构，实际开发中需根据需求调整）
实现第一个功能：接收字符串、解密、存储、返回结果
实现第二个功能：使用定时任务调用外部API，解析响应数据并存储
配置MySQL数据源

由于用户没有提供具体的数据格式和表结构，我们假设：
功能1：接收的字符串经过DES解密后是一个JSON字符串，包含id和content字段，我们将存储到表decrypted_data中，表结构如下：
CREATE TABLE decrypted_data (
id int(11) NOT NULL AUTO_INCREMENT,
content varchar(255) DEFAULT NULL,
PRIMARY KEY (id)
);

功能2：调用的外部API返回的数据我们也假设为JSON格式，包含字段api_id和result，存储到表api_data中，表结构如下：
CREATE TABLE api_data (
id int(11) NOT NULL AUTO_INCREMENT,
api_id int(11) DEFAULT NULL,
result varchar(255) DEFAULT NULL,
PRIMARY KEY (id)
);

注意：实际表结构应根据返回的数据格式设计。

步骤：

创建Spring Boot项目，添加依赖：Web、Spring Data JPA、MySQL Driver、Spring Boot Starter Scheduling、Spring Boot Starter Test。
DES加解密工具类：

由于密钥已经给出：JcXmSjjs20250801（8个字符，因为DES密钥是56位，通常使用8字节（64位）密钥，其中8位用于奇偶校验，实际有效56位），所以密钥长度为8个字符。

注意：DES加密模式等，这里我们使用ECB模式，PKCS5Padding填充。

实现第一个功能：编写一个Controller接收字符串，然后解密，解析JSON，存储数据库，返回成功。
实现第二个功能：使用Spring的@Scheduled注解定时执行任务，在该任务中调用外部API（GET和POST），解析数据并存储。
配置数据源和JPA。

详细代码实现：

第一步：创建Spring Boot项目并添加依赖（pom.xml）

第二步：编写DES工具类

第三步：定义实体类和Repository

第四步：编写Controller

第五步：编写定时任务

第六步：配置文件application.properties

下面逐步展开：

第一步：添加依赖（pom.xml）

XML

<dependencies>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-scheduling</artifactId> </dependency>  <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.12.0</version> </dependency>  <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> </dependency> </dependencies>

第二步：DES工具类

注意：DES加密模式使用ECB，填充使用PKCS5Padding。由于密钥是固定的，我们直接写在工具类中（实际项目中密钥应存储在安全的地方）。

创建DesUtil.java：

Java

import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import java.nio.charset.StandardCharsets; import java.util.Base64; public class DesUtil { private static final String DES_ALGORITHM = "DES/ECB/PKCS5Padding"; private static final String KEY = "JcXmSjjs20250801"; // 密钥，必须是8个字符 public static String decrypt(String data) throws Exception { DESKeySpec desKeySpec = new DESKeySpec(KEY.getBytes(StandardCharsets.UTF_8)); SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); SecretKey secretKey = keyFactory.generateSecret(desKeySpec); Cipher cipher = Cipher.getInstance(DES_ALGORITHM); cipher.init(Cipher.DECRYPT_MODE, secretKey); byte[] encryptedBytes = Base64.getDecoder().decode(data); byte[] decryptedBytes = cipher.doFinal(encryptedBytes); return new String(decryptedBytes, StandardCharsets.UTF_8); } }

第三步：定义实体类和Repository

实体类1：DecryptedData

Java

import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class DecryptedData { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; private String content; // getters and setters }

Repository接口1：DecryptedDataRepository

Java

import org.springframework.data.jpa.repository.JpaRepository; public interface DecryptedDataRepository extends JpaRepository<DecryptedData, Integer> { }

实体类2：ApiData

Java

import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class ApiData { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; private Integer apiId; private String result; // getters and setters }

Repository接口2：ApiDataRepository

Java

import org.springframework.data.jpa.repository.JpaRepository; public interface ApiDataRepository extends JpaRepository<ApiData, Integer> { }

第四步：编写Controller

创建ApiController.java：

Java

第五步：编写定时任务

创建ScheduledTask.java：

Java

import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import org.springframework.web.client.RestTemplate; @Component public class ScheduledTask { @Autowired private ApiDataRepository apiDataRepository; private RestTemplate restTemplate = new RestTemplate(); // 每分钟执行一次 @Scheduled(cron = "0 * * * * ?") public void callApiAndSaveData() { try { // 调用GET API String getUrl = "http://other-system/getApi"; String getResponse = restTemplate.getForObject(getUrl, String.class); parseAndSaveApiData(getResponse); // 调用POST API String postUrl = "http://other-system/postApi"; // 假设POST请求需要传递一个参数对象，这里使用一个简单的Map // 实际参数根据接口要求构造 // Map<String, String> params = new HashMap<>(); // params.put("param1", "value1"); // String postResponse = restTemplate.postForObject(postUrl, params, String.class); // 因为没有实际API，我们注释掉，假设已经获取到响应 // parseAndSaveApiData(postResponse); } catch (Exception e) { e.printStackTrace(); } } private void parseAndSaveApiData(String response) throws Exception { ObjectMapper objectMapper = new ObjectMapper(); JsonNode rootNode = objectMapper.readTree(response); // 假设返回的JSON是一个数组，或者根据实际结构解析 // 这里假设返回的是数组，每个元素有api_id和result if (rootNode.isArray()) { for (JsonNode node : rootNode) { Integer apiId = node.get("api_id").asInt(); String result = node.get("result").asText(); ApiData apiData = new ApiData(); apiData.setApiId(apiId); apiData.setResult(result); apiDataRepository.save(apiData); } } } }

第六步：配置文件application.properties：

properties

spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC spring.datasource.username=root spring.datasource.password=123456 spring.jpa.hibernate.ddl-auto=update spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

注意：以上代码是基于假设的数据格式编写的，实际使用时需要根据具体的数据格式进行调整。

总结：

对外接口：POST /decryptAndSave，接收一个加密字符串，解密后存储content字段到数据库。
定时任务：每分钟调用一次外部API（这里只演示了GET，POST注释了，实际需要根据API要求构造参数），解析响应数据并存储。

注意事项：

密钥硬编码在代码中，不安全，实际项目中应使用配置中心或环境变量等方式管理。
定时任务中调用的外部API地址和参数需要根据实际情况替换。
数据库表结构需要根据实际需求设计。
异常处理需要根据业务需求完善。

最后，生成相关问题：

一、系统设计架构

mermaid

classDiagram class MainController { +String decryptAndSave(String encryptedData) } class DecryptService { -String key = "JcXmSjjs20250801" +String desDecrypt(String data) } class DatabaseService { +void saveDecryptedData(String data) +void saveApiData(JSONObject apiData) } class APICallerService { +void callExternalAPIs() } class SchedulerConfig { +void scheduledTask() } MainController --> DecryptService MainController --> DatabaseService APICallerService --> DatabaseService SchedulerConfig --> APICallerService

二、核心代码实现

1. DES解密工具类（密钥管理）

Java

import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; import java.util.Base64; public class DesUtil { private static final String ALGORITHM = "DES"; private static final String KEY = "JcXmSjjs20250801"; // 8字节密钥 public static String decrypt(String encryptedData) throws Exception { SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM); Cipher cipher = Cipher.getInstance(ALGORITHM); cipher.init(Cipher.DECRYPT_MODE, keySpec); byte[] decodedData = Base64.getDecoder().decode(encryptedData); byte[] decryptedBytes = cipher.doFinal(decodedData); return new String(decryptedBytes); } }

2. 接口控制器（接收并处理加密数据）

Java

import org.springframework.web.bind.annotation.*; @RestController public class MainController { @Autowired private DatabaseService databaseService; @PostMapping("/secure/save") public ApiResponse handleEncryptedData(@RequestBody EncryptedRequest request) { try { String decrypted = DesUtil.decrypt(request.getData()); databaseService.saveDecryptedData(decrypted); return ApiResponse.success("数据保存成功"); } catch (Exception e) { return ApiResponse.error(500, "解密失败: " + e.getMessage()); } } } // DTO对象 public class EncryptedRequest { private String data; // BASE64编码的加密字符串 // getter/setter省略 }

3. 定时任务配置（每分钟执行）

Java

import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.Scheduled; @Configuration @EnableScheduling public class SchedulerConfig { @Autowired private APICallerService apiCallerService; @Scheduled(fixedRate = 60 * 1000) // 每分钟执行 public void scheduledApiCall() { apiCallerService.callExternalAPIs(); } }

4. 外部API调用服务

Java

import org.springframework.http.*; import org.springframework.web.client.RestTemplate; @Service public class APICallerService { @Autowired private DatabaseService databaseService; public void callExternalAPIs() { // GET请求示例 String getUrl = "http://external-system/api/data?param=value"; ResponseEntity<String> getResponse = new RestTemplate().getForEntity(getUrl, String.class); if(getResponse.getStatusCode() == HttpStatus.OK) { String responseBody = getResponse.getBody(); // 解析JSON数据（使用Jackson/Gson） databaseService.saveApiData(parseApiData(responseBody)); } // POST请求示例 String postUrl = "http://external-system/api/update"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); JSONObject params = new JSONObject(); params.put("timestamp", System.currentTimeMillis()); HttpEntity<String> request = new HttpEntity<>(params.toString(), headers); ResponseEntity<String> postResponse = new RestTemplate().postForEntity(postUrl, request, String.class); if(postResponse.getStatusCode().is2xxSuccessful()) { databaseService.saveApiData(parseApiData(postResponse.getBody())); } } }

5. 数据库存储服务

Java

import org.springframework.jdbc.core.JdbcTemplate; @Service public class DatabaseService { @Autowired private JdbcTemplate jdbcTemplate; public void saveDecryptedData(String data) { String sql = "INSERT INTO decrypted_data (content, create_time) VALUES (?, NOW())"; jdbcTemplate.update(sql, data); } public void saveApiData(JSONObject apiData) { String sql = "INSERT INTO api_results (api_type, response_data, call_time) VALUES (?, ?, NOW())"; jdbcTemplate.update(sql, apiData.getString("apiType"), apiData.toString()); } }

三、数据库表结构设计

SQL

-- 解密数据表 CREATE TABLE decrypted_data ( id INT AUTO_INCREMENT PRIMARY KEY, content TEXT NOT NULL, create_time DATETIME DEFAULT CURRENT_TIMESTAMP ); -- API结果表 CREATE TABLE api_results ( id INT AUTO_INCREMENT PRIMARY KEY, api_type VARCHAR(20) NOT NULL, -- GET/POST response_data JSON, call_time DATETIME DEFAULT CURRENT_TIMESTAMP );

四、安全增强措施

密钥管理：将密钥移出代码，使用环境变量或密钥管理系统
HTTPS加密：对外接口启用HTTPS传输
访问控制：添加API访问令牌验证
请求限流：防止接口被高频调用

Java

// 示例：添加简单令牌验证 @PostMapping("/secure/save") public ApiResponse handleEncryptedData( @RequestHeader("X-Auth-Token") String token, @RequestBody EncryptedRequest request) { if(!"VALID_TOKEN".equals(token)) { return ApiResponse.error(401, "未授权访问"); } // ...原有逻辑 }

五、部署运行说明

依赖库：Spring Boot 2.7+、JDBC、Jackson
启动命令：mvn spring-boot:run
测试接口：

Bash

curl -X POST http://localhost:8080/secure/save \ -H "Content-Type: application/json" \ -d '{"data": "加密后的BASE64字符串"}'

六、异常处理机制

解密失败时返回HTTP 400错误
数据库连接失败重试机制
外部API调用超时处理（设置3秒超时）

Java

@Bean public RestTemplate restTemplate() { return new RestTemplateBuilder() .setConnectTimeout(Duration.ofSeconds(3)) .setReadTimeout(Duration.ofSeconds(5)) .build(); }

此设计满足所有需求：