Java节点配置案例如何实操

wen java案例 2026-06-28 240

本文目录导读：

Java节点配置案例如何实操

Java节点配置基础环境
Maven项目节点配置
Spring Boot多环境配置
Java配置类实现
数据库配置示例
Docker容器化配置
启动与验证

我来为你详细讲解Java节点配置的实操案例,包含几种常见的场景。

Java节点配置基础环境

JDK安装配置

# Windows环境
# 设置环境变量
JAVA_HOME=C:\Program Files\Java\jdk-17
PATH=%JAVA_HOME%\bin;%PATH%
CLASSPATH=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
# Linux/Mac环境
# 编辑 ~/.bashrc 或 ~/.zshrc
export JAVA_HOME=/usr/local/jdk-17
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
# 验证安装
java -version
javac -version

Maven项目节点配置

pom.xml基础配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 项目坐标 -->
    <groupId>com.example</groupId>
    <artifactId>node-config-demo</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <!-- 项目属性配置 -->
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.boot.version>3.1.0</spring.boot.version>
    </properties>
    <!-- 依赖管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!-- 项目依赖 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
    </dependencies>
    <!-- 构建配置 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring.boot.version}</version>
            </plugin>
        </plugins>
    </build>
</project>

Spring Boot多环境配置

application.yml主配置

# 应用基础配置
server:
  port: 8080
  servlet:
    context-path: /api
spring:
  application:
    name: node-config-demo
  profiles:
    active: dev  # 默认使用开发环境
# 日志配置
logging:
  level:
    root: INFO
    com.example: DEBUG
  file:
    path: ./logs
    name: ${spring.application.name}.log
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

application-dev.yml

# 开发环境配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db
    username: dev_user
    password: dev_password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
# 自定义配置
app:
  config:
    node-name: Development-Node-01
    enable-cache: false
    cors:
      allowed-origins: http://localhost:3000

application-prod.yml

# 生产环境配置
spring:
  datasource:
    url: jdbc:mysql://prod-db-server:3306/prod_db
    username: prod_user
    password: ${DB_PASSWORD}  # 从环境变量读取
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 300000
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
# 自定义配置
app:
  config:
    node-name: Production-Node-01
    enable-cache: true
    cache-type: redis
    cors:
      allowed-origins: https://example.com
# 服务器配置
server:
  port: 8443
  ssl:
    enabled: true
    key-store: classpath:keystore.p12
    key-store-password: ${KEYSTORE_PASSWORD}
    key-store-type: PKCS12

Java配置类实现

配置属性类

package com.example.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "app.config")
public class AppConfig {
    private String nodeName;
    private boolean enableCache;
    private String cacheType;
    private Cors cors;
    // Getters and Setters
    public String getNodeName() {
        return nodeName;
    }
    public void setNodeName(String nodeName) {
        this.nodeName = nodeName;
    }
    public boolean isEnableCache() {
        return enableCache;
    }
    public void setEnableCache(boolean enableCache) {
        this.enableCache = enableCache;
    }
    public String getCacheType() {
        return cacheType;
    }
    public void setCacheType(String cacheType) {
        this.cacheType = cacheType;
    }
    public Cors getCors() {
        return cors;
    }
    public void setCors(Cors cors) {
        this.cors = cors;
    }
    // 内部类
    public static class Cors {
        private List<String> allowedOrigins;
        public List<String> getAllowedOrigins() {
            return allowedOrigins;
        }
        public void setAllowedOrigins(List<String> allowedOrigins) {
            this.allowedOrigins = allowedOrigins;
        }
    }
}

Java配置类

package com.example.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebConfig {
    @Bean
    @Profile("dev")
    public WebMvcConfigurer corsConfigurerDev(AppConfig appConfig) {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
                    .allowedOrigins(
                        appConfig.getCors().getAllowedOrigins()
                            .toArray(new String[0])
                    )
                    .allowedMethods("GET", "POST", "PUT", "DELETE")
                    .allowedHeaders("*")
                    .allowCredentials(true);
            }
        };
    }
    @Bean
    @Profile("prod")
    public WebMvcConfigurer corsConfigurerProd(AppConfig appConfig) {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/api/**")
                    .allowedOrigins(
                        appConfig.getCors().getAllowedOrigins()
                            .toArray(new String[0])
                    )
                    .allowedMethods("GET", "POST")
                    .allowedHeaders("Authorization", "Content-Type")
                    .maxAge(3600);
            }
        };
    }
}

数据库配置示例

多数据源配置

package com.example.config;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
@Configuration
public class DataSourceConfig {
    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

application-datasource.yml

spring:
  datasource:
    primary:
      url: jdbc:mysql://localhost:3306/primary_db
      username: primary_user
      password: primary_pass
      driver-class-name: com.mysql.cj.jdbc.Driver
      hikari:
        maximum-pool-size: 10
    secondary:
      url: jdbc:postgresql://localhost:5432/secondary_db
      username: secondary_user
      password: secondary_pass
      driver-class-name: org.postgresql.Driver
      hikari:
        maximum-pool-size: 5

Docker容器化配置

Dockerfile

FROM openjdk:17-jdk-slim
# 设置工作目录
WORKDIR /app
# 复制jar包
COPY target/node-config-demo-1.0.0.jar app.jar
# 暴露端口
EXPOSE 8080
# 设置环境变量
ENV SPRING_PROFILES_ACTIVE=prod
ENV JAVA_OPTS="-Xms512m -Xmx1024m"
# 启动命令
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

docker-compose.yml

version: '3.8'
services:
  app:
    build: .
    container_name: java-node-app
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_PASSWORD=${DB_PASSWORD}
      - KEYSTORE_PASSWORD=${KEYSTORE_PASSWORD}
    volumes:
      - ./logs:/app/logs
    networks:
      - app-network
    depends_on:
      - mysql
      - redis
  mysql:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: prod_db
      MYSQL_USER: prod_user
      MYSQL_PASSWORD: prod_password
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    ports:
      - "6379:6379"
    networks:
      - app-network
volumes:
  mysql-data:
networks:
  app-network:
    driver: bridge

启动与验证

启动应用程序

# 开发环境
java -jar target/node-config-demo-1.0.0.jar --spring.profiles.active=dev
# 生产环境
java -jar target/node-config-demo-1.0.0.jar --spring.profiles.active=prod
# Docker部署
docker-compose up -d

验证配置

package com.example.controller;
import com.example.config.AppConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ConfigController {
    @Autowired
    private AppConfig appConfig;
    @GetMapping("/config")
    public AppConfig getConfig() {
        return appConfig;
    }
}

测试API

# 测试配置接口
curl http://localhost:8080/api/config
# 返回示例
{
    "nodeName": "Development-Node-01",
    "enableCache": false,
    "cacheType": null,
    "cors": {
        "allowedOrigins": ["http://localhost:3000"]
    }
}

这个实操案例涵盖了Java节点配置的主要场景,包括环境配置、多环境管理、数据库配置、容器化部署等，你可以根据实际需求进行调整和使用。

本文地址： https://www.bmjup.com/post/11175.html