Пробовал ли вынести параметризацию сложных собственных объектов в Runtime

Вынесение параметризации сложных объектов в Runtime

Контекст

Да, я многократно использовал эту технику. Это критически важно для создания гибких, переиспользуемых систем, особенно в микросервисной архитектуре, плагинах и DI контейнерах.

Проблема: жесткая привязка параметров

НЕПРАВИЛЬНО - параметры жестко закодированы:

public class DataProcessingConfig {
    // Все параметры захардкодены!
    private int batchSize = 100;
    private int threadCount = 4;
    private String databaseUrl = "jdbc:postgresql://localhost:5432/mydb";
    private String cacheType = "Redis";
    private int cacheTimeout = 3600;
    private boolean enableLogging = true;
    private int retryCount = 3;
    private long retryDelay = 1000;
    
    public DataProcessor createProcessor() {
        return new DataProcessor(
            batchSize,
            threadCount,
            databaseUrl,
            cacheType,
            cacheTimeout,
            enableLogging,
            retryCount,
            retryDelay
        );
    }
}

// Проблемы:
// - Изменение параметров требует перекомпиляции
// - Разные среды (dev, staging, prod) требуют разных значений
// - Невозможно менять параметры без перезагрузки приложения

Решение 1: Environment Variables

public class DataProcessingConfig {
    public DataProcessor createProcessor() {
        return new DataProcessor(
            // Параметры из environment variables!
            Integer.parseInt(getEnv("BATCH_SIZE", "100")),
            Integer.parseInt(getEnv("THREAD_COUNT", "4")),
            getEnv("DATABASE_URL", "jdbc:postgresql://localhost:5432/mydb"),
            getEnv("CACHE_TYPE", "Redis"),
            Integer.parseInt(getEnv("CACHE_TIMEOUT", "3600")),
            Boolean.parseBoolean(getEnv("ENABLE_LOGGING", "true")),
            Integer.parseInt(getEnv("RETRY_COUNT", "3")),
            Long.parseLong(getEnv("RETRY_DELAY", "1000"))
        );
    }
    
    private String getEnv(String key, String defaultValue) {
        return System.getenv().getOrDefault(key, defaultValue);
    }
}

// Использование:
// export BATCH_SIZE=500
// export THREAD_COUNT=8
// java -jar myapp.jar

Преимущества:

• Параметры меняются без перекомпиляции
• Разные переменные для разных сред

Недостатки:

• Много переменных → сложно управлять
• Нет валидации типов
• Нет документации

Решение 2: application.properties / application.yaml

application.properties (development):

data.processor.batchSize=100
data.processor.threadCount=4
data.processor.databaseUrl=jdbc:postgresql://localhost:5432/mydb
data.processor.cacheType=Redis
data.processor.cacheTimeout=3600
data.processor.enableLogging=true
data.processor.retryCount=3
data.processor.retryDelay=1000

application-prod.properties (production):

data.processor.batchSize=1000
data.processor.threadCount=32
data.processor.databaseUrl=jdbc:postgresql://prod-db:5432/mydb
data.processor.cacheType=Redis
data.processor.cacheTimeout=7200
data.processor.enableLogging=false
data.processor.retryCount=5
data.processor.retryDelay=5000

Spring Configuration с @ConfigurationProperties:

@Configuration
@ConfigurationProperties(prefix = "data.processor")
public class DataProcessorProperties {
    private int batchSize;
    private int threadCount;
    private String databaseUrl;
    private String cacheType;
    private int cacheTimeout;
    private boolean enableLogging;
    private int retryCount;
    private long retryDelay;
    
    // Getters и setters (автоматически генерируются)
    public int getBatchSize() { return batchSize; }
    public void setBatchSize(int batchSize) { this.batchSize = batchSize; }
    // ... остальные getters/setters
}

// Использование в сервисе
@Service
public class DataProcessorService {
    private DataProcessorProperties props;
    
    public DataProcessorService(DataProcessorProperties props) {
        this.props = props;
    }
    
    public DataProcessor createProcessor() {
        return new DataProcessor(
            props.getBatchSize(),
            props.getThreadCount(),
            props.getDatabaseUrl(),
            props.getCacheType(),
            props.getCacheTimeout(),
            props.isEnableLogging(),
            props.getRetryCount(),
            props.getRetryDelay()
        );
    }
}

// Запуск с разными профилями
// java -jar myapp.jar --spring.profiles.active=prod

Решение 3: JSON конфигурационные файлы

config.json:

{
  "dataProcessor": {
    "batchSize": 100,
    "threadCount": 4,
    "databaseUrl": "jdbc:postgresql://localhost:5432/mydb",
    "cacheType": "Redis",
    "cacheTimeout": 3600,
    "enableLogging": true,
    "retryCount": 3,
    "retryDelay": 1000,
    "database": {
      "connectionPool": {
        "minSize": 5,
        "maxSize": 20
      }
    }
  }
}

Загрузка JSON с использованием Jackson:

public class JsonConfigLoader {
    private static final ObjectMapper mapper = new ObjectMapper();
    
    public DataProcessorConfig loadConfig(String path) throws IOException {
        return mapper.readValue(new File(path), DataProcessorConfig.class);
    }
}

@Data
public class DataProcessorConfig {
    private DataProcessorProperties dataProcessor;
}

@Data
public class DataProcessorProperties {
    private int batchSize;
    private int threadCount;
    private String databaseUrl;
    private String cacheType;
    private int cacheTimeout;
    private boolean enableLogging;
    private int retryCount;
    private long retryDelay;
    private DatabaseConfig database;
}

@Data
public class DatabaseConfig {
    private ConnectionPoolConfig connectionPool;
}

@Data
public class ConnectionPoolConfig {
    private int minSize;
    private int maxSize;
}

// Использование
JsonConfigLoader loader = new JsonConfigLoader();
DataProcessorConfig config = loader.loadConfig("config.json");

Решение 4: Reflection для динамического создания объектов

Это мощный, но сложный подход. Используется в DI контейнерах (Spring).

Пример: Generic Factory с Reflection:

public class ReflectionFactory<T> {
    private Class<T> targetClass;
    private Map<String, Object> properties;
    
    public ReflectionFactory(Class<T> targetClass, Map<String, Object> properties) {
        this.targetClass = targetClass;
        this.properties = properties;
    }
    
    public T create() throws Exception {
        // 1. Создаю экземпляр через конструктор
        T instance = targetClass.getDeclaredConstructor().newInstance();
        
        // 2. Устанавливаю свойства через reflection
        for (Map.Entry<String, Object> entry : properties.entrySet()) {
            String fieldName = entry.getKey();
            Object value = entry.getValue();
            
            try {
                Field field = targetClass.getDeclaredField(fieldName);
                field.setAccessible(true);
                field.set(instance, value);
            } catch (NoSuchFieldException e) {
                // Пробую setter
                String setterName = "set" + capitalize(fieldName);
                Method setter = targetClass.getMethod(
                    setterName,
                    value.getClass()
                );
                setter.invoke(instance, value);
            }
        }
        
        return instance;
    }
    
    private String capitalize(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}

// Использование
Map<String, Object> config = Map.of(
    "batchSize", 100,
    "threadCount", 4,
    "databaseUrl", "jdbc:postgresql://localhost:5432/mydb",
    "cacheType", "Redis"
);

ReflectionFactory<DataProcessor> factory = 
    new ReflectionFactory<>(DataProcessor.class, config);
DataProcessor processor = factory.create();

Решение 5: Annotation-based конфигурация (как в Spring)

// Кастомная annotation
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Config {
    String value();
    String defaultValue() default "";
}

public class DataProcessor {
    @Config("batch_size")
    private int batchSize;
    
    @Config("thread_count")
    private int threadCount;
    
    @Config("database_url")
    private String databaseUrl;
    
    @Config("cache_type", defaultValue = "Redis")
    private String cacheType;
}

// Конфигурационный контейнер
public class ConfigContainer {
    private Map<String, Object> config;
    
    public ConfigContainer(Map<String, Object> config) {
        this.config = config;
    }
    
    public <T> T create(Class<T> clazz) throws Exception {
        T instance = clazz.getDeclaredConstructor().newInstance();
        
        // Reflection для установки полей с @Config
        for (Field field : clazz.getDeclaredFields()) {
            Config configAnnotation = field.getAnnotation(Config.class);
            if (configAnnotation != null) {
                String configKey = configAnnotation.value();
                Object value = config.getOrDefault(
                    configKey,
                    configAnnotation.defaultValue()
                );
                
                field.setAccessible(true);
                
                // Type conversion
                Object convertedValue = convertValue(
                    value,
                    field.getType()
                );
                
                field.set(instance, convertedValue);
            }
        }
        
        return instance;
    }
    
    private Object convertValue(Object value, Class<?> targetType) {
        if (value == null) return null;
        if (targetType.isAssignableFrom(value.getClass())) return value;
        
        if (targetType == int.class || targetType == Integer.class) {
            return Integer.parseInt(value.toString());
        }
        if (targetType == long.class || targetType == Long.class) {
            return Long.parseLong(value.toString());
        }
        if (targetType == boolean.class || targetType == Boolean.class) {
            return Boolean.parseBoolean(value.toString());
        }
        
        return value;
    }
}

// Использование
Map<String, Object> config = Map.of(
    "batch_size", "100",
    "thread_count", "4",
    "database_url", "jdbc:postgresql://localhost:5432/mydb",
    "cache_type", "Redis"
);

ConfigContainer container = new ConfigContainer(config);
DataProcessor processor = container.create(DataProcessor.class);

Реальный пример: плагин система с Runtime параметризацией

// Plugin interface
public interface DataPlugin {
    void initialize(Map<String, Object> config);
    void process(Data data);
}

// Реализация 1
public class PostgresPlugin implements DataPlugin {
    private String connectionUrl;
    private int poolSize;
    
    @Override
    public void initialize(Map<String, Object> config) {
        this.connectionUrl = (String) config.get("url");
        this.poolSize = (int) config.get("poolSize");
    }
    
    @Override
    public void process(Data data) {
        // Используем connectionUrl и poolSize
    }
}

// Реализация 2
public class MongoPlugin implements DataPlugin {
    private String connectionString;
    private String database;
    
    @Override
    public void initialize(Map<String, Object> config) {
        this.connectionString = (String) config.get("connectionString");
        this.database = (String) config.get("database");
    }
    
    @Override
    public void process(Data data) {
        // Используем connectionString и database
    }
}

// Plugin manager
public class PluginManager {
    private Map<String, DataPlugin> plugins = new HashMap<>();
    private Map<String, Map<String, Object>> configurations = new HashMap<>();
    
    public void registerPlugin(String name, String className, Map<String, Object> config) throws Exception {
        // Динамическая загрузка класса
        Class<?> pluginClass = Class.forName(className);
        DataPlugin plugin = (DataPlugin) pluginClass.getDeclaredConstructor().newInstance();
        
        // Инициализация с параметрами
        plugin.initialize(config);
        
        plugins.put(name, plugin);
        configurations.put(name, config);
    }
    
    public DataPlugin getPlugin(String name) {
        return plugins.get(name);
    }
    
    public void updatePluginConfig(String name, Map<String, Object> newConfig) throws Exception {
        DataPlugin plugin = plugins.get(name);
        if (plugin != null) {
            plugin.initialize(newConfig);
            configurations.put(name, newConfig);
        }
    }
}

// Конфигурация плагинов
PluginManager manager = new PluginManager();

// Development конфигурация
manager.registerPlugin(
    "database",
    "com.example.PostgresPlugin",
    Map.of(
        "url", "jdbc:postgresql://localhost:5432/dev",
        "poolSize", 5
    )
);

// Production конфигурация
manager.registerPlugin(
    "database",
    "com.example.PostgresPlugin",
    Map.of(
        "url", "jdbc:postgresql://prod-db:5432/prod",
        "poolSize", 50
    )
);

Выводы: когда использовать что

Практические советы

1. Начни просто: Environment variables → properties файлы
2. Добавь валидацию: Проверяй типы и значения при загрузке
3. Документируй: Все конфигурационные параметры должны быть описаны
4. Используй defaults: Не все параметры должны быть обязательными
5. Версионируй: Отслеживай изменения в конфигурациях
6. Тестируй: Убедись, что конфигурация работает для всех сценариев

Итог: Вынесение параметризации в Runtime — это критический навык для создания production-ready приложений. Это позволяет легко переносить код между средами без перекомпиляции.