Development Guide

# Preface

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

# Target Audience

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

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

No.	Document	Description
1	Apusic In-Memory Data Cache V2.0.5 Quick Start Guide	A brief introduction on how to quickly get started with AMDC.
2	Apusic In-Memory Data Cache V2.0.5 Installation Guide	Detailed introduction on how to install AMDC on various operating systems, AMDC service start/stop operations, and the product registration process.
3	Apusic In-Memory Data Cache V2.0.5 Cache 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.5 Console User Manual	Detailed instructions on using and operating AMDC console features.
5	Apusic In-Memory Data Cache V2.0.5 Development Guide	Detailed instructions for developing AMDC client applications using various programming languages.
6	Apusic In-Memory Data Cache V2.0.5 Migration Guide	Detailed instructions for migrating AMDC from historical versions to V2.0.5, as well as migrating from Redis to AMDC.
7	Apusic In-Memory Data Cache V2.0.5 Operations Guide	Detailed instructions for AMDC monitoring, operations, security hardening, and other operational procedures.
8	Apusic In-Memory Data Cache V2.0.5 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

This document uses three common languages — Java, Python, and Go — to demonstrate AMDC's compatibility with Redis clients in various languages.

# Java Application Development

Jedis is recommended for developing Redis client applications in Java. Jedis (opens new window) is a lightweight, 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 that is close to native commands.

The following provides development examples of using Jedis to connect to cache core services deployed in AMDC standalone, Sentinel, and cluster modes, and performing data read/write operations.

Single-node connection and usage

Jedis amdc = new Jedis("10.0.1.100 (example IP; replace with the actual IP)", 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(
    "10.0.1.110 (example IP; replace with the actual IP):27000",
    "10.0.1.110 (example IP; replace with the actual IP):27001",
    "10.0.1.110 (example IP; replace with the actual IP):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("10.0.1.110 (example IP; replace with the actual IP)", 7000));
clusterNodes.add(new HostAndPort("10.0.1.110 (example IP; replace with the actual IP)", 7001));
clusterNodes.add(new HostAndPort("10.0.1.110 (example IP; replace with the actual IP)", 7002));
clusterNodes.add(new HostAndPort("10.0.1.110 (example IP; replace with the actual IP)", 7003));
clusterNodes.add(new HostAndPort("10.0.1.110 (example IP; replace with the actual IP)", 7004));
clusterNodes.add(new HostAndPort("10.0.1.110 (example IP; replace with the actual IP)", 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 the Redis data storage protocol, so external clients can seamlessly switch to the AMDC product.

# Create a Project and Add Configuration

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

    # Connection pool configuration (important!)
    lettuce:
      pool:
        max-active: 16   # Maximum number of connections
        max-idle: 8      # Maximum number of idle connections
        min-idle: 4      # Minimum number of idle connections
        max-wait: 1000ms # Maximum wait time for obtaining a 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 keys (important!)
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // Use JSON serialization for values
        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

The following 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 is retained for 7 days

        // Store using Hash
        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 Java client and real-time data platform for Redis, providing developers with the most convenient and easy-to-use approach. Through Redisson objects, it builds 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 the functionality of Redis, implementing many distributed features not available natively, including distributed collections, distributed locks, distributed objects, distributed services, and more.

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

# Quick Start

First, configure the dependency

<!-- 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:6359"
          password: "your_password"
          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

The following shows how to use caches of different modes integrated in code, along with the configuration of some parameters.

@Configuration
public class RedissonConfig {

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

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

        // Cluster mode (recommended for financial and 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); // Number of Netty I/O threads

        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

The following also uses the approval workflow example:

@Service
public class ApprovalWorkflowService {

    @Autowired
    private RedissonClient redisson;

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

        // 1. Acquire the workflow lock
        RLock flowLock = redisson.getLock("approval:flow:" + applicationId);

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

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

                // 3. Check whether approval is allowed
                if (!"PENDING".equals(status)) {
                    throw new IllegalStateException("The application has already been processed");
                }

                // 4. Update the 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 the approval completed event
                RTopic topic = redisson.getTopic("approval:completed");
                topic.publishAsync(new ApprovalEvent(applicationId, approved));

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

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

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

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

        // Each approver processes independently
        for (String approver : approvers) {
            // Submit asynchronously to the approver
            submitToApprover(applicationId, approver, latchKey);
        }

        try {
            // Wait for all approvers to complete (up to 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

Single-node connection and usage

import redis
import time

r = redis.Redis(host='10.0.1.100 (example IP; replace with the actual IP)', 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 = [("10.0.1.120 (example IP; replace with the actual IP)", "26359"), ("10.0.1.120 (example IP; replace with the actual IP)", "26360"), ("10.0.1.120 (example IP; replace with the actual IP)", "26361")]
def sentinel():
    amdc = redis.Sentinel(sentinels=SENTINELADDRS)
    # Get the master instance
    master = amdc.master_for("mymaster")
    # Get the slave instance
    slave = amdc.slave_for("mymaster")
    # Write to the master instance
    print(master.set("key2", "value2"))
    time.sleep(2)
    # Read from the 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":"10.0.1.120 (example IP; replace with the actual IP)", "port":"6359"}, {"host":"10.0.1.120 (example IP; replace with the actual IP)", "port":"6360"}, {"host":"10.0.1.120 (example IP; replace with the actual IP)", "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

Single-node connection and usage

package main

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

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "10.0.1.120 (example IP; replace with the actual IP):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{"10.0.1.120 (example IP; replace with the actual IP):26359", "10.0.1.120 (example IP; replace with the actual IP):26360", "10.0.1.120 (example IP; replace with the actual IP):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{"10.0.1.120 (example IP; replace with the actual IP):6359", "10.0.1.120 (example IP; replace with the actual IP):6360", "10.0.1.120 (example IP; replace with the actual IP):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())
    }
}