Development Manual

# Preface

This document is the development guide for Apusic In-Memory Data Cache (AMDC) V2.0.4, helping users quickly learn how to develop using Apusic In-Memory Data Cache.

# Target Audience

This document is intended for development engineers, software architects, and R&D managers.

For more information about AMDC V2.0.4, please refer to the following AMDC V2.0.4 product manual documentation set:

No.	Document	Description
1	Apusic In-Memory Data Cache V2.0.4 Quick Start Guide	A brief introduction on how to quickly get started with AMDC.
2	Apusic In-Memory Data Cache V2.0.4 Installation Guide	Detailed introduction on how to install AMDC on various operating systems, AMDC service start/stop operations, and product registration process.
3	Apusic In-Memory Data Cache V2.0.4 Core User Manual	Detailed introduction on how to use, configure, and manage AMDC features and supporting tools.
4	Apusic In-Memory Data Cache V2.0.4 Console User Manual	Detailed instructions on using and operating AMDC console features.
5	Apusic In-Memory Data Cache V2.0.4 Development Guide	Detailed instructions for developing AMDC client applications using various programming languages.
6	Apusic In-Memory Data Cache V2.0.4 Migration Guide	Detailed instructions for migrating AMDC from historical versions to V2.0.4, as well as migrating from Redis to AMDC.
7	Apusic In-Memory Data Cache V2.0.4 Operations Guide	Detailed instructions for AMDC monitoring, operations, security hardening, and other operational procedures.
8	Apusic In-Memory Data Cache V2.0.4 Performance Tuning Guide	Detailed instructions for AMDC performance tuning.

# Technical Support

AMDC products provide comprehensive technical support services. You can obtain technical support through the following channels:

Website: www.apusic.com
Phone: 400-855-5800
Email: support@apusic.com
Kingdee Cloud Community: https://vip.kingdee.com/?productId=73&productLineId=14&lang=zh-CN

When requesting technical support, please provide the following information:

Your name
Company information and contact details
Operating system and version
Product version number
Detailed information including logs, screenshots, etc. of any exceptions or errors

# Client Application Development

We will use Java, Python, and Go, three commonly used languages, to demonstrate AMDC's compatibility with various Redis clients.

# Java Application Development

For Java development of Redis client applications, Jedis is recommended. Jedis (opens new window) is a lightweight and high-performance synchronous Java client officially recommended by Redis. It allows Java developers to conveniently and efficiently connect to, operate, and manage Redis databases in a way close to native commands.

Below are development examples for connecting to AMDC cache core services deployed in standalone, sentinel, and cluster modes using Jedis and performing data read/write operations.

Standalone Node Connection and Usage

Jedis amdc = new Jedis("172.24.4.212", 6359);
System.out.println(amdc.ping());
System.out.println(amdc.set("key11", "value11"));
System.out.println(amdc.get("key11"));

1
2
3
4

Sentinel Mode Connection and Usage

Set<String> sentinels = new HashSet<String>(Arrays.asList(
    "172.24.6.110:27000",
    "172.24.6.110:27001",
    "172.24.6.110:27002"
));
JedisSentinelPool pool = new JedisSentinelPool("mymaster", sentinels, jedisPoolConfig);
Jedis jedis = pool.getResource();
System.out.println(jedis.set("key12", "value12"));
System.out.println(jedis.get("key12"));

1
2
3
4
5
6
7
8
9

Cluster Mode Connection and Usage

Set<HostAndPort> clusterNodes = new HashSet<>();
clusterNodes.add(new HostAndPort("172.24.6.110", 7000));
clusterNodes.add(new HostAndPort("172.24.6.110", 7001));
clusterNodes.add(new HostAndPort("172.24.6.110", 7002));
clusterNodes.add(new HostAndPort("172.24.6.110", 7003));
clusterNodes.add(new HostAndPort("172.24.6.110", 7004));
clusterNodes.add(new HostAndPort("172.24.6.110", 7005));
JedisCluster ac = new JedisCluster(clusterNodes, genericObjectPoolConfig);
System.out.println(ac.set("test1", "a"));
System.out.println(ac.set("1test", "b"));
System.out.println(ac.set("aaatest", "c"));
System.out.println("------------------------");
System.out.println(ac.get("test1"));
System.out.println(ac.get("1test"));
System.out.println(ac.get("aaatest"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Spring Boot Project Integration

AMDC is compatible with Redis data storage protocol, external clients can seamlessly switch to use AMDC product.

# Create Project and Add Configuration

# application.yml
spring:
  redis:
    host: localhost      # Redis address
    port: 6379          # Port
    timeout: 2000ms     # Connection timeout
    database: 0         # Use database 0 (0-15)

    # Connection pool configuration (important!)
    lettuce:
      pool:
        max-active: 16   # Maximum connections
        max-idle: 8      # Maximum idle connections
        min-idle: 4      # Minimum idle connections
        max-wait: 1000ms # Maximum wait time to get connection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Configure RedisTemplate

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(
            RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // Use String serialization for Key (important!)
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // Use JSON serialization for Value
        template.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        template.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));

        return template;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Usage Example

Below is an example of cache participating in approval process status management.

@Service
public class ApprovalService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * Store approval status
     */
    public void saveApprovalStatus(String approvalId,
                                   String status,
                                   String approver) {
        String key = "approval:status:" + approvalId;

        Map<String, String> data = new HashMap<>();
        data.put("status", status);
        data.put("approver", approver);
        data.put("updateTime", LocalDateTime.now().toString());
        data.put("expireAt", LocalDateTime.now()
            .plusDays(7).toString()); // Approval data retained for 7 days

        // Use Hash storage
        redisTemplate.opsForHash().putAll(key, data);

        // Set expiration time
        redisTemplate.expire(key, 7, TimeUnit.DAYS);
    }

    /**
     * Get approval progress
     */
    public Map<Object, Object> getApprovalProgress(String approvalId) {
        String key = "approval:status:" + approvalId;
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * Batch get pending items
     */
    public List<String> getPendingApprovals(String approver) {
        String key = "approval:pending:" + approver;
        List<Object> list = redisTemplate.opsForList().range(key, 0, -1);

        return list != null ?
            list.stream()
                .map(Object::toString)
                .collect(Collectors.toList()) :
            Collections.emptyList();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# Redisson Cache Usage Example

Redisson (opens new window) is a Redis Java client and real-time data platform that provides developers with the most convenient and easy-to-use way. Through Redisson objects, it establishes an elegant abstraction layer between Java code and Redis, allowing developers to focus on business logic and data models. At the same time, Redisson greatly extends Redis functionality, implementing many distributed features not available natively, including distributed collections, distributed locks, distributed objects, distributed services, etc.

This section demonstrates AMDC's development support and compatibility features for Redisson framework, providing relevant code examples for reference.

# Quick Start

First we need to configure dependencies

<!-- pom.xml -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.27.1</version>
</dependency>

1
2
3
4
5
6

# application.yml - Standalone mode
spring:
  redis:
    redisson:
      config: |
        singleServerConfig:
          address: "redis://127.0.0.1:6379"
          password: null
          database: 0
          # Connection pool settings
          connectionPoolSize: 64
          connectionMinimumIdleSize: 24
          # Timeout settings (milliseconds)
          connectTimeout: 10000
          timeout: 3000
          retryAttempts: 3
        # Use JSON serialization
        codec: !<org.redisson.codec.JsonJacksonCodec> {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Below are usage methods and partial parameter configurations for integrating different cache modes in code.

@Configuration
public class RedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();

        // Standalone mode
        config.useSingleServer()
              .setAddress("redis://127.0.0.1:6379")
              .setPassword("yourPassword")
              .setDatabase(0)
              .setConnectionPoolSize(64)
              .setConnectionMinimumIdleSize(10);

        // Cluster mode (recommended for financial government production environments)
        // config.useClusterServers()
        //       .addNodeAddress(
        //           "redis://node1:6379",
        //           "redis://node2:6379",
        //           "redis://node3:6379"
        //       )
        //       .setScanInterval(2000); // Cluster status scan interval

        // Sentinel mode
        // config.useSentinelServers()
        //       .setMasterName("mymaster")
        //       .addSentinelAddress(
        //           "redis://sentinel1:26379",
        //           "redis://sentinel2:26379"
        //       );

        // Serialization configuration
        config.setCodec(new JsonJacksonCodec());

        // Thread configuration
        config.setThreads(16);  // Number of threads processing Redis responses
        config.setNettyThreads(32); // Netty I/O thread count

        return Redisson.create(config);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

Similarly, we use the approval workflow example:

@Service
public class ApprovalWorkflowService {

    @Autowired
    private RedissonClient redisson;

    /**
     * Distributed approval process
     */
    public void processApproval(String applicationId,
                                String approver,
                                boolean approved) {

        // 1. Get process lock
        RLock flowLock = redisson.getLock("approval:flow:" + applicationId);

        if (flowLock.tryLock()) {
            try {
                // 2. Get current process status
                RMap<String, String> flowState =
                    redisson.getMap("approval:state:" + applicationId);

                String currentStep = flowState.get("currentStep");
                String status = flowState.get("status");

                // 3. Check if approval is possible
                if (!"PENDING".equals(status)) {
                    throw new IllegalStateException("Application already processed");
                }

                // 4. Update approval status
                flowState.put("approver", approver);
                flowState.put("approved", String.valueOf(approved));
                flowState.put("approvalTime", LocalDateTime.now().toString());
                flowState.put("status", approved ? "APPROVED" : "REJECTED");

                // 5. Publish approval completion event
                RTopic topic = redisson.getTopic("approval:completed");
                topic.publishAsync(new ApprovalEvent(applicationId, approved));

                // 6. Record approval history
                RList<ApprovalRecord> history =
                    redisson.getList("approval:history:" + applicationId);
                history.add(new ApprovalRecord(approver, approved, LocalDateTime.now()));

            } finally {
                flowLock.unlock();
            }
        }
    }

    /**
     * Multi-level countersign (requires all approvers to agree)
     */
    public boolean multiSignApproval(String applicationId, List<String> approvers) {
        String latchKey = "approval:latch:" + applicationId;
        RCountDownLatch latch = redisson.getCountDownLatch(latchKey);

        // Initialize counter
        latch.trySetCount(approvers.size());

        // Each approver processes independently
        for (String approver : approvers) {
            // Asynchronously submit to approver
            submitToApprover(applicationId, approver, latchKey);
        }

        try {
            // Wait for all approvers to complete (maximum 1 hour)
            return latch.await(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

# Python Application Development

Standalone Node Connection and Usage

import redis
import time

r = redis.Redis(host='172.24.4.212', port=6359, db=0, decode_responses=True)
print(r.set("key1", "value1"))
print(r.get("key1"))
r.expire("key1", 10)
print(r.ttl("key1"))
time.sleep(1)
print(r.ttl("key1"))

1
2
3
4
5
6
7
8
9
10

Sentinel Mode Connection and Usage

from redis.sentinel import Sentinel

SENTINELADDRS = [("172.21.33.69", "26359"), ("172.21.33.69", "26360"), ("172.21.33.69", "26361")]
def sentinel():
    amdc = redis.Sentinel(sentinels=SENTINELADDRS)
    # Get master instance
    master = amdc.master_for("mymaster")
    # Get slave instance
    slave = amdc.slave_for("mymaster")
    # Write to master instance
    print(master.set("key2"))
    time.sleep(2)
    # Get from slave instance
    print(slave.get("key2"))

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Cluster Mode Connection and Usage

from redis.cluster import RedisCluster

CLUSTERADDRS = [{"host":"172.21.33.69", "port":"6359"}, {"host":"172.21.33.69", "port":"6360"}, {"host":"172.21.33.69", "port":"6361"}]
def cluster():
   amdc_cluster=RedisCluster(startup_nodes=CLUSTERADDRS,decode_responses=True,socket_keepalive=True)
   print(amdc_cluster.set("key3","value3"))
   print(amdc_cluster.get("key3"))

1
2
3
4
5
6
7

# Go Application Development

Standalone Node Connection and Usage

package main

import (
    "fmt"
    "github.com/go-redis/redis"
)

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "172.21.33.69:6359",
    })
    if err := rdb.Ping().Err(); err != nil {
        fmt.Println("Ping error:", err)
    } else {
        fmt.Println("Ping:", rdb.Ping().Val())
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Sentinel Mode Connection and Usage

package main

import (
    "fmt"
    "github.com/go-redis/redis/v8"
)

func main() {
    rdb := redis.NewFailoverClient(&redis.FailoverOptions{
        MasterName: "mymaster",
        SentinelAddrs: []string{"172.21.33.69:26359", "172.21.33.69:26360", "172.21.33.69:26361"},
    })
    defer rdb.Close()
    _, err := rdb.Set("hahakey", "hahavalue", 0).Result()
    if err != nil {
        fmt.Println("Set error:", err)
    } else {
        fmt.Println("Set hahakey: hahavalue")
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Cluster Mode Connection and Usage

package main

import (
    "fmt"
    "github.com/go-redis/redis/v8"
)

func main() {
    addrs := []string{"172.21.33.69:6359", "172.21.33.69:6360", "172.21.33.69:6361"}
    rdb := redis.NewClusterClient(&redis.ClusterOptions{
        Addrs: addrs,
    })
    if err := rdb.Ping().Err(); err != nil {
        fmt.Println("Ping error:", err)
    } else {
        fmt.Println("Ping:", rdb.Ping().Val())
    }
}