如何在Spring及Spring Batch的XML与注解配置中获取命令行参数

嘿，这两个问题都是Spring生态里配置和参数传递的常见场景，我来给你一步步拆解清楚，都是实际项目里能用的方案：

Spring Batch里的命令行参数通常会封装成JobParameters，不管是XML还是注解配置，核心都是围绕这个对象来获取参数。

1. XML配置方式 #

首先，你需要在XML配置里定义Job和Step，然后通过SpEL表达式引用JobParameters里的参数。结合你给出的XML片段，完整的配置大概是这样：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:batch="http://www.springframework.org/schema/batch"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/batch
           http://www.springframework.org/schema/batch/spring-batch.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 启用组件扫描，按需添加 -->
    <context:component-scan base-package="com.your.package"/>

    <!-- 配置JobRepository（这里用内存版做示例，生产环境建议用数据库版） -->
    <bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"/>

    <!-- 配置JobLauncher -->
    <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository"/>
    </bean>

    <!-- 定义Job，关联具体Step -->
    <batch:job id="sampleJob">
        <batch:step id="sampleStep">
            <batch:tasklet>
                <batch:chunk reader="itemReader" writer="itemWriter" commit-interval="10"/>
            </batch:tasklet>
        </batch:step>
    </batch:job>

    <!-- 示例ItemReader，通过SpEL引用命令行传入的inputFile参数 -->
    <bean id="itemReader" class="org.springframework.batch.item.file.FlatFileItemReader">
        <property name="resource" value="file:#{jobParameters['inputFile']}"/>
        <!-- 可添加行映射器等其他配置 -->
    </bean>

    <!-- 示例ItemWriter，引用命令行传入的outputFile参数 -->
    <bean id="itemWriter" class="org.springframework.batch.item.file.FlatFileItemWriter">
        <property name="resource" value="file:#{jobParameters['outputFile']}"/>
        <!-- 可添加行聚合器等其他配置 -->
    </bean>
</beans>

启动Batch任务时，你可以用Spring Batch自带的CommandLineJobRunner，命令行直接传入参数：

java -jar your-batch-app.jar com.your.package.BatchConfig sampleJob inputFile=input.csv outputFile=output.csv

也可以自己写main方法手动传递参数：

public class BatchMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("batch-config.xml");
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job job = context.getBean("sampleJob", Job.class);

        // 把命令行参数转换成JobParameters
        JobParametersBuilder paramsBuilder = new JobParametersBuilder();
        for (String arg : args) {
            String[] keyValue = arg.split("=");
            if (keyValue.length == 2) {
                paramsBuilder.addString(keyValue[0], keyValue[1]);
            }
        }

        try {
            jobLauncher.run(job, paramsBuilder.toJobParameters());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. Java注解配置方式 #

用注解的话会更灵活，你可以直接用@Value注入JobParameters，或者在Step组件里获取JobExecution对象。

方式一：@Value直接注入参数 #

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    // 用@Value注入命令行参数inputFile
    @Bean
    public FlatFileItemReader<String> itemReader(@Value("#{jobParameters['inputFile']}") String inputFile) {
        FlatFileItemReader<String> reader = new FlatFileItemReader<>();
        reader.setResource(new FileSystemResource(inputFile));
        reader.setLineMapper(new PassThroughLineMapper());
        return reader;
    }

    @Bean
    public FlatFileItemWriter<String> itemWriter(@Value("#{jobParameters['outputFile']}") String outputFile) {
        FlatFileItemWriter<String> writer = new FlatFileItemWriter<>();
        writer.setResource(new FileSystemResource(outputFile));
        writer.setLineAggregator(new PassThroughLineAggregator<>());
        return writer;
    }

    @Bean
    public Step sampleStep(ItemReader<String> reader, ItemWriter<String> writer) {
        return stepBuilderFactory.get("sampleStep")
                .<String, String>chunk(10)
                .reader(reader)
                .writer(writer)
                .build();
    }

    @Bean
    public Job sampleJob(Step sampleStep) {
        return jobBuilderFactory.get("sampleJob")
                .start(sampleStep)
                .build();
    }
}

启动类用SpringApplication即可：

public class BatchMain {
    public static void main(String[] args) {
        SpringApplication.run(BatchConfig.class, args);
    }
}

启动命令和XML方式类似：

java -jar your-batch-app.jar inputFile=input.csv outputFile=output.csv

方式二：通过JobExecution获取参数 #

如果需要在Step执行过程中动态获取参数，可以实现StepExecutionListener：

@Component
public class ParamListener implements StepExecutionListener {
    private String inputFile;

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // 从JobExecution里提取参数
        JobParameters jobParameters = stepExecution.getJobExecution().getJobParameters();
        inputFile = jobParameters.getString("inputFile");
        // 执行初始化逻辑...
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        return ExitStatus.COMPLETED;
    }
}

在普通Spring应用（非Batch）里，获取命令行参数有两种常用方式：

1. 作为系统属性传入，用${}引用 #

启动应用时，把命令行参数以-D前缀作为系统属性传入：

java -jar your-app.jar -Dapp.env=prod -Dconfig.path=/etc/app/config

然后在XML配置里用${}直接引用这些系统属性：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 启用属性占位符，才能用${}引用系统属性 -->
    <context:property-placeholder/>

    <!-- 配置Bean时引用命令行传入的系统属性 -->
    <bean id="configService" class="com.your.package.ConfigService">
        <property name="env" value="${app.env}"/>
        <property name="configPath" value="${config.path}"/>
    </bean>
</beans>

2. 通过SpEL引用ApplicationArguments #

如果命令行参数是不带-D的普通参数（比如java -jar your-app.jar prod /etc/app/config），可以通过Spring的ApplicationArguments对象获取，在XML里用SpEL表达式引用：

<bean id="paramService" class="com.your.package.ParamService">
    <!-- 获取第一个命令行参数 -->
    <property name="env" value="#{applicationArguments.getSourceArgs()[0]}"/>
    <!-- 获取第二个命令行参数 -->
    <property name="configPath" value="#{applicationArguments.getSourceArgs()[1]}"/>
</bean>

注意：applicationArguments是Spring Boot自动注册的Bean，如果用的是普通Spring框架（非Boot），需要手动注册：

public class AppMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.registerBean(ApplicationArguments.class, () -> new ApplicationArguments(args));
        context.load("classpath:spring-config.xml");
        context.refresh();
        
        // 启动应用逻辑...
    }
}

内容的提问来源于stack exchange，提问作者michele