Spring Boot微服务中全局变量与应用变量定义的相关咨询

Hey there! Let's break down your questions step by step since you're splitting a monolith into 20 Spring Boot microservices—great move for scalability and maintainability by the way!

1. Can I declare global variables in application.properties? #

It depends on what you mean by "global":

• If you're talking about intra-service global variables (values used across multiple classes/components within a single microservice), absolutely! Just define them in your service's application.properties and inject them where needed using @Value("${your.variable.key}") or @ConfigurationProperties for grouped settings.
• If you mean cross-service global variables (values shared across all 20 of your microservices, like a common API timeout or third-party service key), a single service's application.properties won't work. Each microservice has its own isolated application.properties, so updating a shared value would require editing 20 files—totally not scalable for an SOA setup.

2. Where to define cross-microservice global variables? #

You’ve got two main options, and for 20 services, the second one is a no-brainer:

Option 1: Shared property files (simple but inflexible) #

If you want to avoid setting up a dedicated config server right away, you can:

• Extract all shared configs into a single file (e.g., common.properties)
• Package this file into a reusable Maven/Gradle module (like a common-config library)
• Have each microservice depend on this module, then import the shared config with @PropertySource("classpath:common.properties")
• Catch: Any config change requires rebuilding and redeploying all 20 services—this gets painful fast as your fleet grows.

Option 2: Spring Config Server (Recommended for SOA) #

Spring Config Server is built specifically for managing distributed configuration across microservices. It centralizes all your configs, lets you update them dynamically, and scales perfectly with 20+ services. Here's how to set it up:

Step 1: Spin up the Config Server

• Create a new Spring Boot project and add the spring-cloud-config-server dependency
• Add the @EnableConfigServer annotation to your main application class to enable the config server functionality
• Configure its application.properties to point to your config source (Git is the most common choice):

  server.port=8888
  # Point to your Git repo where config files are stored
  spring.cloud.config.server.git.uri=https://your-git-repo-url/microservice-configs
  # Search for configs in the "shared" folder (global) and per-service folders
  spring.cloud.config.server.git.search-paths=shared,{application}
  

Step 2: Configure each microservice as a Config Client

• Add the spring-cloud-starter-config dependency to every microservice
• Create a bootstrap.properties file (this loads before application.properties) in each service to connect to the config server:

  # Unique name of your microservice (matches the config file name in Git)
  spring.application.name=order-service
  # URL of your Config Server
  spring.cloud.config.uri=http://localhost:8888
  # Active environment (dev/test/prod)
  spring.profiles.active=dev
  

Step 3: Define global variables

In your Git repo’s shared folder, create environment-specific config files like application-dev.properties and add your global variables:

# Global timeout for all services
global.request.timeout=3000
# Shared API key for a third-party service
global.external.api.key=your-shared-api-key-here

All microservices will automatically pull these values, and you can inject them using @Value("${global.request.timeout}") or group them with @ConfigurationProperties(prefix = "global").

Pro Tips for Config Server

• Environment separation: Use profiles (application-dev.properties, application-prod.properties) to keep environment-specific configs separate
• Sensitive data protection: Enable encryption/decryption in the Config Server to secure secrets like database passwords (you can use JCE or integrate with Spring Cloud Vault)
• Dynamic config refresh: Add the spring-boot-starter-actuator dependency to your microservices, expose the /refresh endpoint, and annotate beans with @RefreshScope—this lets you update configs without restarting any services!

内容的提问来源于stack exchange，提问作者Mr.DevEng