CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-com-alibaba-nacos--nacos-client

Nacos client library for dynamic service discovery and configuration management in cloud native applications and microservices platforms

—

Pending
Overview
Eval results
Files

configuration.mddocs/

Configuration Management

Centralized configuration management with real-time updates, change listeners, atomic CAS operations, and pattern-based watching. Supports multiple configuration formats with filtering mechanisms for request/response processing.

Capabilities

Core Configuration Operations

Basic configuration retrieval, publishing, and removal operations for managing application configurations.

public interface ConfigService {
    // Get configuration content
    String getConfig(String dataId, String group, long timeoutMs) throws NacosException;
    
    // Get configuration and register listener simultaneously  
    String getConfigAndSignListener(String dataId, String group, long timeoutMs, Listener listener) throws NacosException;
    
    // Publish configuration
    boolean publishConfig(String dataId, String group, String content) throws NacosException;
    
    // Publish configuration with type specification
    boolean publishConfig(String dataId, String group, String content, String type) throws NacosException;
    
    // Atomic compare-and-swap publish operation
    boolean publishConfigCas(String dataId, String group, String content, String casMd5) throws NacosException;
    
    // Remove configuration
    boolean removeConfig(String dataId, String group) throws NacosException;
    
    // Get server status
    String getServerStatus();
    
    // Shutdown service
    void shutDown() throws NacosException;
}

Usage Examples

import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.ConfigFactory;
import com.alibaba.nacos.api.exception.NacosException;

// Create config service
Properties props = new Properties();
props.setProperty("serverAddr", "localhost:8848");
ConfigService configService = ConfigFactory.createConfigService(props);

// Get configuration with timeout
String config = configService.getConfig("database.properties", "DEFAULT_GROUP", 5000);

// Publish configuration
boolean success = configService.publishConfig(
    "database.properties", 
    "DEFAULT_GROUP", 
    "url=jdbc:mysql://localhost:3306/mydb\nusername=admin"
);

// CAS operation for atomic updates
String currentMd5 = "abc123"; // MD5 of current config
boolean updated = configService.publishConfigCas(
    "database.properties",
    "DEFAULT_GROUP", 
    "url=jdbc:mysql://newhost:3306/mydb\nusername=admin",
    currentMd5
);

Configuration Listeners

Real-time configuration change notifications through listener pattern.

public interface ConfigService {
    // Add configuration change listener
    void addListener(String dataId, String group, Listener listener) throws NacosException;
    
    // Remove configuration change listener
    void removeListener(String dataId, String group, Listener listener);
}

// Base listener interface
public interface Listener {
    // Receive configuration updates
    void receiveConfigInfo(String configInfo);
    
    // Get executor for async processing (optional)
    Executor getExecutor();
}

// Abstract base class for listeners
public abstract class AbstractListener implements Listener {
    public abstract void receiveConfigInfo(String configInfo);
    
    @Override
    public Executor getExecutor() {
        return null; // Use default executor
    }
}

Usage Examples

import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.config.listener.AbstractListener;

// Simple listener implementation
Listener listener = new AbstractListener() {
    @Override
    public void receiveConfigInfo(String configInfo) {
        System.out.println("Configuration updated: " + configInfo);
        // Reload application configuration
        reloadConfig(configInfo);
    }
};

// Register listener
configService.addListener("database.properties", "DEFAULT_GROUP", listener);

// Custom executor listener
Listener asyncListener = new AbstractListener() {
    @Override
    public void receiveConfigInfo(String configInfo) {
        // Handle configuration change
        handleConfigChange(configInfo);
    }
    
    @Override
    public Executor getExecutor() {
        return Executors.newSingleThreadExecutor();
    }
};

Fuzzy Watching

Pattern-based configuration watching for monitoring multiple configurations with wildcards.

public interface ConfigService {
    // Start fuzzy watching with group pattern only
    void fuzzyWatch(String groupNamePattern, FuzzyWatchEventWatcher watcher) throws NacosException;
    
    // Start fuzzy watching with both dataId and group patterns
    void fuzzyWatch(String dataIdPattern, String groupNamePattern, FuzzyWatchEventWatcher watcher) throws NacosException;
    
    // Start fuzzy watching and return matching group keys
    Future<Set<String>> fuzzyWatchWithGroupKeys(String groupNamePattern, FuzzyWatchEventWatcher watcher) throws NacosException;
    
    // Cancel fuzzy watching
    void cancelFuzzyWatch(String dataIdPattern, String groupNamePattern, FuzzyWatchEventWatcher watcher) throws NacosException;
}

// Fuzzy watch event watcher interface
public interface FuzzyWatchEventWatcher {
    // Handle set of configuration change events
    void onEvent(Set<ConfigChangeEvent> events);
}

Usage Examples

import com.alibaba.nacos.api.config.listener.FuzzyWatchEventWatcher;
import com.alibaba.nacos.api.config.ConfigChangeEvent;

// Watch all database-related configurations
FuzzyWatchEventWatcher watcher = new FuzzyWatchEventWatcher() {
    @Override
    public void onEvent(Set<ConfigChangeEvent> events) {
        for (ConfigChangeEvent event : events) {
            System.out.println("Config changed: " + event.getDataId() + 
                             " in group: " + event.getGroup());
            
            if (event.getChangeType() == PropertyChangeType.MODIFIED) {
                System.out.println("Old: " + event.getOldContent());
                System.out.println("New: " + event.getContent());
            }
        }
    }
};

// Watch pattern: all .properties files in DATABASE_GROUP
configService.fuzzyWatch("*.properties", "DATABASE_GROUP", watcher);

// Watch all configurations in a group (group pattern only)
configService.fuzzyWatch("CACHE_GROUP", watcher);

// Watch with both patterns - all configs in groups matching pattern
configService.fuzzyWatch("*", "CACHE_*", watcher);

Configuration Filters

Request and response filtering for configuration operations.

// Configuration filter interface
public interface IConfigFilter {
    void init(FilterConfig filterConfig);
    void doFilter(IConfigRequest request, IConfigResponse response, IConfigFilterChain filterChain) throws NacosException;
}

// Abstract filter base class
public abstract class AbstractConfigFilter implements IConfigFilter {
    @Override
    public void init(FilterConfig filterConfig) {
        // Default implementation
    }
    
    public abstract void doFilter(IConfigRequest request, IConfigResponse response, IConfigFilterChain filterChain) throws NacosException;
}

// Filter request interface
public interface IConfigRequest {
    String getDataId();
    String getGroup();
    String getContent();
    IConfigContext getConfigContext();
}

// Filter response interface  
public interface IConfigResponse {
    String getContent();
    void setContent(String content);
    IConfigContext getConfigContext();
}

Types

Configuration Events and Changes

// Configuration change event
public class ConfigChangeEvent {
    private String dataId;
    private String group;
    private String namespace;
    private String content;
    private String oldContent;
    private PropertyChangeType changeType;
    
    public String getDataId();
    public String getGroup();
    public String getNamespace();
    public String getContent();
    public String getOldContent();
    public PropertyChangeType getChangeType();
}

// Individual configuration item change
public class ConfigChangeItem {
    private String key;
    private String oldValue;
    private String newValue;
    private PropertyChangeType type;
    
    public String getKey();
    public String getOldValue();
    public String getNewValue();
    public PropertyChangeType getType();
}

Configuration Types and Constants

// Configuration content types
public enum ConfigType {
    PROPERTIES("properties"),
    XML("xml"),
    JSON("json"), 
    TEXT("text"),
    HTML("html"),
    YAML("yaml"),
    TOML("toml"),
    UNSET("unset");
    
    public String getType();
}

// Property change types
public enum PropertyChangeType {
    ADDED,    // Property was added
    MODIFIED, // Property was changed
    DELETED   // Property was removed
}

// Configuration property keys
public class PropertyKeyConst {
    // Server configuration
    public static final String SERVER_ADDR = "serverAddr";
    public static final String CONTEXT_PATH = "contextPath";
    public static final String CLUSTER_NAME = "clusterName";
    public static final String ENCODE = "encode";
    
    // Authentication
    public static final String USERNAME = "username";
    public static final String PASSWORD = "password";
    public static final String ACCESS_KEY = "accessKey";
    public static final String SECRET_KEY = "secretKey";
    
    // Configuration specific
    public static final String CONFIG_LONG_POLL_TIMEOUT = "configLongPollTimeout";
    public static final String CONFIG_RETRY_TIME = "configRetryTime";
    public static final String MAX_RETRY = "maxRetry";
    public static final String ENABLE_REMOTE_SYNC_CONFIG = "enableRemoteSyncConfig";
}

Annotation Support

// Configuration value injection
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface NacosValue {
    String value();
    boolean autoRefreshed() default false;
}

// Configuration properties binding
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface NacosConfigurationProperties {
    String dataId();
    String groupId() default "DEFAULT_GROUP";
    boolean autoRefreshed() default false;
    String type() default "properties";
}

// Configuration change listener
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NacosConfigListener {
    String dataId();
    String groupId() default "DEFAULT_GROUP";
}

// Ignore field during configuration binding
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NacosIgnore {
}

Configuration Converters

// Configuration content converter interface
public interface NacosConfigConverter<T> {
    // Check if can convert to target type
    boolean canConvert(Class<T> targetType);
    
    // Convert configuration content to target type
    T convert(String config);
}

Install with Tessl CLI

npx tessl i tessl/maven-com-alibaba-nacos--nacos-client

docs

configuration.md

distributed-locking.md

factory-utilities.md

index.md

service-discovery.md

tile.json