AI 助理
备案控制台
开发者社区 数据库 文章 正文

Spring Batch学习记录及示例项目代码

2024-03-14 102
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS PostgreSQL，集群系列 2核4GB
简介： Spring Batch学习记录及示例项目代码

在这里插入图片描述

Spring Batch学习记录总结

关于Spring Batch的相关知识点参考：https://mp.weixin.qq.com/s/OUMwyo2EopXkSHGn2OlghQ

Spring Batch的一些基本概念：
在这里插入图片描述

  • ItemReader：对资源的读处理，如从数据库查询、文件读取、变量读取等。

  • ItemProcessor：对读取的数据进行处理，可以实现自己的业务逻辑操作来对数据处理，如对数据进行计算、逻辑处理、格式转换等。

  • ItemWriter：对资源的写处理，如写入数据库、写入文件、打印日志等。

  • Step：一个完整的批处理步骤，一个Step是由ItemReader、ItemProcessor、ItemWriter三部分组成。

  • Job：代表一个完整的批处理过程，一个Job由一个或多个Step组成。

    在这里插入图片描述

  • Listener：监听器，可以对Step、Job状态进行监听，我们可以实现监听方法，对其进行一些逻辑处理，如打印日志等。

  • JobLauncher：负责启动Job。

  • JobRepository：存储关于配置和执行的Job(作业)的元数据。

简单使用

1、创建一个SpringBoot项目。

2、在项目中创建包config，并在该包下面创建一个Configuration类。

在类上面加上@Configuration;@EnableBatchProcessing;两个注解。

    @Configuration
    @EnableBatchProcessing
    public class SingleJobConfiguration {
   
   

        @Autowired
        private JobBuilderFactory jobBuilderFactory;

        @Autowired
        private StepBuilderFactory stepBuilderFactory;

        /**
         * 程序执行的入口
         * @return
         */
        @Bean
        public Job helloJob(){
   
   
            return jobBuilderFactory.get("hellojpb-1")
                    .start(step1())
                    .build();
        }

        @Bean
        public Step step1() {
   
   
            return stepBuilderFactory.get("step-1").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring batch");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }
    }

3、现在启动项目，发现控制台出现以下错误信息。

Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled.
2021-05-22 13:00:10.396 ERROR 15548 --- [           main] o.s.b.d.LoggingFailureAnalysisReporter   : 

***************************
APPLICATION FAILED TO START
***************************

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class

​
​ Action:
​
Consider the following:
If you want an embedded database (H2, HSQL or Derby), please put it on the classpath.
If you have database settings to be loaded from a particular profile you may need to activate it (no profiles are currently active).

解决方法：由于Spring Batch在运行的时候需要数据库来存储一些具体的信息；因此我们需要配置具体的数据库信息。

方式一：配置内存数据库H2。

         <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <scope>runtime</scope>
         </dependency>

方式二：配置Mysql数据库。

            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.25</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>

Mysql数据库连接信息：

    spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useSSL=false
    spring.datasource.username=root
    spring.datasource.password=123456

    spring.datasource.schema=classpath:/org/springframework/batch/core/schema-mysql.sql
    spring.batch.initialize-schema=always

Spring Batch具体分析

  • Step有两种实现方式。一个是tasklet的方式；一个是chunk方式。

    tasklet方式：

    在Step中，执行单个任务，Job有多个Step按照一定的顺序来组成的，每个步骤执行一个具体的任务。

    chunk方式：

    该方法是基于数据块（一部分数据）执行的，每个任务又都可以分为Read-Process-Write。

  • Spring Batch框架主要有四个角色：
    JobLauncher：任务启动器，通过它来启动任务，可以看作程序的入口。
    Job：代表一个具体的任务。
    Step：代表一个具体的步骤。一个Job有1个或多个Step构成。
    JobRepository：是存储数据的地方，可以看作一个数据库的接口，在任务执行的时候需要通过它来记录任务状态等信息。

Step的两种实现方式：

   //方式1   chunk
        @Bean
        Step step() {
   
   
            return stepBuilderFactory.get(STEP)
                    .<Music, Music>chunk(2)
                    .reader(itemReader())
                    .writer(itemWriter())
                    .build();

        }
    //方式2   tasklet
        @Bean
        public Step step1() {
   
   
            return stepBuilderFactory.get("step-1").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring batch");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

Flow的创建和使用

  • Flow是多个Step的集合。
  • 可以被多个Job复用。
  • 使用FlowBuilder来创建。
    @Configuration
    @EnableBatchProcessing
    public class FlowDemo {
   
   

        @Autowired
        private JobBuilderFactory jobBuilderFactory;

        @Autowired
        private StepBuilderFactory stepBuilderFactory;


        /**
         * 创建 Step1
         * @return
         */
        @Bean
        public Step flowDemoStep1() {
   
   
            return stepBuilderFactory.get("step-1").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring flowDemoStep1");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

        /**
         * 创建Step2
         * @return
         */
        @Bean
        public Step flowDemoStep2() {
   
   
            return stepBuilderFactory.get("step-2").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring flowDemoStep2");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

        /**
         * 创建Step3
         * @return
         */
        @Bean
        public Step flowDemoStep3() {
   
   
            return stepBuilderFactory.get("step-3").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring flowDemoStep3");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

        /**
         * 创建Flow 对象   ,指明Flow对象包含哪些Step
         */
        public Flow  flowDemoFlow(){
   
   
            return new FlowBuilder<Flow>("flowDemoFlow")
                    .start(flowDemoStep1())
                    .next(flowDemoStep2())
                    .build();
        }

        /**
         * 创建Job对象
         * @return
         */
        @Bean
        public Job  job(){
   
   
            return jobBuilderFactory.get("flowjob")
                    .start(flowDemoFlow())
                    .next(flowDemoStep3())
                    .end()
                    .build();

        }

split实现并发执行

实现任务中的多个Step或多个flow并发执行。

关键代码：

    @Configuration
    @EnableBatchProcessing
    public class SplitDemo {
   
   

        @Autowired
        private JobBuilderFactory jobBuilderFactory;

        @Autowired
        private StepBuilderFactory stepBuilderFactory;

        /**
         * 创建 Step1
         * @return
         */
        @Bean
        public Step splitDemoStep1() {
   
   
            return stepBuilderFactory.get("step-1").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring splitDemoStep1");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

        /**
         * 创建Step2
         * @return
         */
        @Bean
        public Step  splitDemoStep2() {
   
   
            return stepBuilderFactory.get("step-2").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring splitDemoStep2");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

        /**
         * 创建Step3
         * @return
         */
        @Bean
        public Step  splitDemoStep3() {
   
   
            return stepBuilderFactory.get("step-3").tasklet(
                    new Tasklet() {
   
   
                        @Override
                        public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                            System.out.println("hello spring splitDemoStep3");
                            return RepeatStatus.FINISHED;
                        }
                    }
            ).build();
        }

创建Flow 对象 ,指明Flow对象包含哪些Step：

      public Flow  splitDemoFlow1(){
   
   
​            return new FlowBuilder<Flow>("splitDemoFlow1")
​                    .start(splitDemoStep1())
​                    .build();
​        }
​    
        public Flow  splitDemoFlow2(){
   
   
            return new FlowBuilder<Flow>("splitDemoFlow2")
                    .start(splitDemoStep2())
                    .next(splitDemoStep3())
                    .build();
        }

        /**
         * 创建任务
         * @return
         */
        @Bean
        public Job  job(){
   
   
            return jobBuilderFactory.get("splitDemoJob")
                    .start(splitDemoFlow1())
                    .split(new SimpleAsyncTaskExecutor())
                    .add(splitDemoFlow2())
                    .end()
                    .build();
        }
    }

决策器的使用

接口：JobExecutionDecider

自定义决策器：MyDecider.java，实现JobExecutionDecider接口并且重写decide方法

public class MyDecider implements JobExecutionDecider {
   
   
    private int count;
    @Override
    public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {
   
   
        count ++;
        if(count % 2 == 0){
   
   
            return new FlowExecutionStatus("even");
        }else {
   
   
            return new FlowExecutionStatus("odd");
        }
    }
}

@Configuration
@EnableBatchProcessing
public class DeciderDemo {
   
   

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;



    @Bean
    public Step deciderDemoStep1(){
   
   
       return stepBuilderFactory.get("deciderDemoStep1").tasklet(new Tasklet() {
   
   
            @Override
            public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                System.out.println("hello spring deciderDemoStep1");
                return RepeatStatus.FINISHED;
        }
        }).build();
    }

    @Bean
    public Step deciderDemoStep2() {
   
   
        return stepBuilderFactory.get("deciderDemoStep2").tasklet(
                new Tasklet() {
   
   
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                        System.out.println("even");
                        return RepeatStatus.FINISHED;
                    }
                }
        ).build();
    }
    @Bean
    public Step deciderDemoStep3() {
   
   
        return stepBuilderFactory.get("deciderDemoStep3").tasklet(
                new Tasklet() {
   
   
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
   
   
                        System.out.println("odd");
                        return RepeatStatus.FINISHED;
                    }
                }
        ).build();
    }


    /**
     * 创建决策器
     * @return
     */
    @Bean
    public JobExecutionDecider myDecider(){
   
   
        return new MyDecider();
    }

    @Bean
    public Job  deciderDemoJob(){
   
   
        return jobBuilderFactory.get("deciderDemoJob")
                .start(deciderDemoStep1())
                .next(myDecider())
                .from(myDecider()).on("even").to(deciderDemoStep2())
                .from(myDecider()).on("odd").to(deciderDemoStep3())
                .from(deciderDemoStep3()).on("*").to(myDecider())
                .end()
                .build();
    }
}

完整例子

主要代码如下：
1、项目总体结构图。
在这里插入图片描述
2、在pom.xml文件中引入依赖。

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--引入Spring Batch-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
            <version>2.2.1.RELEASE</version>
        </dependency>

       <!--引入mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>

        <!--引入jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

       <!-- 引入mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

<!--        引入其他工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

3、配置数据库的连接信息。

server:
  port: 8081

#  配置Mysql连接信息
spring:
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/xk_test?useSSL=false
    username: root
    password: root
    schema: classpath:/org/springframework/batch/core/schema-mysql.sql
  batch:
    initialize-schema: always
    job:
      enabled: false

4、读数据CityDataReader.java

@Service
@Slf4j
@StepScope
public class CityDataReader implements ItemReader<City> {
   
   

    @Autowired
    private CityService cityService;

    List<City> cityInfoLists = null;
    private int nextCityIndex = 0;

    @Override
    public City read() throws Exception {
   
   
        this.init();
        City city = null;
        if(nextCityIndex < cityInfoLists.size()){
   
   
            city = cityInfoLists.get(nextCityIndex);
            nextCityIndex ++;
            return city;
        }
        return null;
    }

    private void init() {
   
   
       cityInfoLists = cityService.getCityInfoLists();
    }
}

5、处理数据CityDataProcess.java

@Slf4j
@Service
@StepScope
public class CityDataProcess implements ItemProcessor<City,City> {
   
   

    @Value("#{jobParameters['startDate']}")
    private Date date;

    @Value("#{jobParameters['name']}")
    private String name;

    @Override
    public City process(City city) throws Exception {
   
   
        log.info("开始处理第{}条数据----参数{}:{}.........",city.getId(),date,name);
        String detail = city.getProvince() + "-" + city.getCity() + "-" + city.getDistrict();
        city.setDetail(detail);
        log.info("第{}条数据已处理完成......",city.getId());

        return city;
    }
}

6、写数据CityDataWriter.java

@Service
@StepScope
@Slf4j
public class CityDataWriter implements ItemWriter<City> {
   
   

    @Autowired
    private CityService cityService;

    @Value("#{jobParameters['startDate']}")
    private Date date;

    @Value("#{jobParameters['name']}")
    private String name;

    @Override
    public void write(List<? extends City> cities) throws Exception {
   
   
        for(City city : cities) {
   
   
            log.info("第{}条数据开始更新.........}", city.getId());
            int update = cityService.update(city);
            if (update > 0 ) {
   
   
                log.info("第{}条数据更新完成.........}", city.getId());
            }
        }
    }
}

7、配置Job。JobConfig.java

@Configuration
public class JobConfig {
   
   

    private static final Logger log = LoggerFactory.getLogger(SimpleJobConfig.class);

    @Autowired
    JobBuilderFactory jobBuilderFactory;

    @Autowired
    StepBuilderFactory stepBuilderFactory;

    @Autowired
    SqlSessionFactory sqlSessionFactory;

    @Autowired
    private CityDataReader cityDataReader;

    @Autowired
    private CityDataProcess cityDataProcess;

    @Autowired
    private CityDataWriter cityDataWriter;

    @Autowired
    private MyTasketOne myTasketOne;

    //配置一个Job
    @Bean("singleJob")
    public Job singleStepJob() {
   
   
        return jobBuilderFactory.get("singleJob")
                .start(singlestep())
                .next(singlestep2())
                .listener(new MyJobExecutionListener())
                .build();
    }

    //配置第一个处理Step
    @Bean
    public Step singlestep() {
   
   
        return stepBuilderFactory.get("singlestep")
                .<City,City>chunk(9)
                .reader(cityDataReader)          // 读数据逻辑
                .processor(cityDataProcess)   //数据处理逻辑——业务处理
                .writer(cityDataWriter)         //写数据逻辑
                .listener(new MyStepExecutionListener())  //配置监听器
                .build();
    }

    //配置第二个处理Step
    @Bean
    public Step singlestep2() {
   
   
        return stepBuilderFactory.get("singlestep2")
                .tasklet(myTasketOne)
                .listener(new MyStepExecutionListener())  //配置监听器
                .build();
    }
}

8、创建controller，启动Job。

@RestController
@RequestMapping("batch")
public class JobStartController {
   
   

    @Autowired
    private Job singleJob;

    @Autowired
    private JobLauncher jobLauncher;

    /**
     * 启动 Job
     * @return
     * @throws Exception
     */
    @GetMapping("/start")
    public String invokeStep() throws Exception {
   
   
        JobParameters  jobParameters = new JobParametersBuilder()
                .addDate("startDate",DateUtil.date(System.currentTimeMillis()))
                .addString("name","xxkfz")
                .toJobParameters();
        jobLauncher.run(singleJob, jobParameters);
        return "The job is Run  start.......";
    }
}

9、主启动类上加上@EnableBatchProcessing注解。
10、测试。
访问：http://127.0.0.1:8081/batch/start 启动Job。
在这里插入图片描述
在这里插入图片描述
本案例项目代码获取方式：关注下方二维码，私信回复【Spring Batch学习项目】即可获取哦

文章标签：
云数据库 RDS MySQL 版
Java
Spring
数据库
存储
关系型数据库
关键词：
Spring学习
Spring项目
Spring代码
Spring示例
Spring Batch
相关实践学习
如何快速连接云数据库RDS MySQL
本场景介绍如何通过阿里云数据管理服务DMS快速连接云数据库RDS MySQL，然后进行数据表的CRUD操作。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
小小Java开发者
目录
相关文章
wanderInk
|
15天前
|
前端开发 安全 Java
Spring Boot 便利店销售系统项目分包设计解析
本文深入解析了基于Spring Boot的便利店销售系统分包设计，通过清晰的分层架构（表现层、业务逻辑层、数据访问层等）和模块化设计，提升了代码的可维护性、复用性和扩展性。具体分包结构包括`controller`、`service`、`repository`、`entity`、`dto`、`config`和`util`等模块，职责分明，便于团队协作与功能迭代。该设计为复杂企业级应用开发提供了实践参考。
wanderInk
49 0
蓝易云
|
3天前
|
Java Spring
Spring框架的学习与应用
总的来说，Spring框架是Java开发中的一把强大的工具。通过理解其核心概念，通过实践来学习和掌握，你可以充分利用Spring框架的强大功能，提高你的开发效率和代码质量。
蓝易云
50 20
wanderInk
|
15天前
|
SQL 前端开发 Java
深入理解 Spring Boot 项目中的分页与排序功能
本文深入讲解了在Spring Boot项目中实现分页与排序功能的完整流程。通过实际案例，从Service层接口设计到Mapper层SQL动态生成，再到Controller层参数传递及前端页面交互，逐一剖析每个环节的核心逻辑与实现细节。重点包括分页计算、排序参数校验、动态SQL处理以及前后端联动，确保数据展示高效且安全。适合希望掌握分页排序实现原理的开发者参考学习。
wanderInk
39 4
运营研究坊
|
17天前
|
Java Spring 容器
两种Spring Boot 项目启动自动执行方法的实现方式
在Spring Boot项目启动后执行特定代码的实际应用场景中，可通过实现`ApplicationRunner`或`CommandLineRunner`接口完成初始化操作，如系统常量或配置加载。两者均支持通过`@Order`注解控制执行顺序，值越小优先级越高。区别在于参数接收方式：`CommandLineRunner`使用字符串数组，而`ApplicationRunner`采用`ApplicationArguments`对象。注意，`@Order`仅影响Bean执行顺序，不影响加载顺序。
运营研究坊
67 2
阿里云云原生
|
2天前
|
人工智能 前端开发 Java
十几行代码实现 Manus，Spring AI Alibaba Graph 快速预览
Spring AI Alibaba Graph 的核心开发已完成，即将发布正式版本。开发者可基于此轻松构建工作流、智能体及多智能体系统，功能丰富且灵活。文章通过三个示例展示了其应用：1) 客户评价处理系统，实现两级问题分类与自动处理；2) 基于 ReAct Agent 的天气预报查询系统，循环执行用户指令直至完成；3) 基于 Supervisor 多智能体的 OpenManus 实现，简化了流程控制逻辑并优化了工具覆盖度。此外，还提供了运行示例的方法及未来规划，欢迎开发者参与贡献。
阿里云云原生
42 0
wanderInk
|
15天前
|
安全 前端开发 Java
Spring Boot 项目中触发 Circular View Path 错误的原理与解决方案
在Spring Boot开发中，**Circular View Path**错误常因视图解析与Controller路径重名引发。当视图名称（如`login`）与请求路径相同，Spring MVC无法区分，导致无限循环调用。解决方法包括：1) 明确指定视图路径，避免重名；2) 将视图文件移至子目录；3) 确保Spring Security配置与Controller路径一致。通过合理设定视图和路径，可有效避免该问题，确保系统稳定运行。
wanderInk
59 0
Quan_Chen
|
1月前
|
Java 数据库 微服务
微服务——SpringBoot使用归纳——Spring Boot中的项目属性配置——指定项目配置文件
在实际项目中，开发环境和生产环境的配置往往不同。为简化配置切换，可通过创建 `application-dev.yml` 和 `application-pro.yml` 分别管理开发与生产环境配置，如设置不同端口（8001/8002）。在 `application.yml` 中使用 `spring.profiles.active` 指定加载的配置文件，实现环境快速切换。本节还介绍了通过配置类读取参数的方法，适用于微服务场景，提升代码可维护性。课程源码可从 [Gitee](https://gitee.com/eson15/springboot_study) 下载。
Quan_Chen
55 0
Quan_Chen
|
1月前
|
Java 微服务 Spring
微服务——SpringBoot使用归纳——Spring Boot中的项目属性配置——少量配置信息的情形
在微服务架构中，随着业务复杂度增加，项目可能需要调用多个微服务。为避免使用`@Value`注解逐一引入配置的繁琐，可通过定义配置类（如`MicroServiceUrl`）并结合`@ConfigurationProperties`注解实现批量管理。此方法需在配置文件中设置微服务地址（如订单、用户、购物车服务），并通过`@Component`将配置类纳入Spring容器。最后，在Controller中通过`@Resource`注入配置类即可便捷使用，提升代码可维护性。
Quan_Chen
37 0
Quan_Chen
|
1月前
|
XML Java 数据库连接
微服务——SpringBoot使用归纳——Spring Boot集成MyBatis——基于 xml 的整合
本教程介绍了基于XML的MyBatis整合方式。首先在`application.yml`中配置XML路径，如`classpath:mapper/*.xml`，然后创建`UserMapper.xml`文件定义SQL映射，包括`resultMap`和查询语句。通过设置`namespace`关联Mapper接口，实现如`getUserByName`的方法。Controller层调用Service完成测试，访问`/getUserByName/{name}`即可返回用户信息。为简化Mapper扫描，推荐在Spring Boot启动类用`@MapperScan`注解指定包路径避免逐个添加`@Mapper`
Quan_Chen
62 0
Quan_Chen
|
1月前
|
前端开发 Java 数据库
微服务——SpringBoot使用归纳——Spring Boot集成Thymeleaf模板引擎——Thymeleaf 介绍
本课介绍Spring Boot集成Thymeleaf模板引擎。Thymeleaf是一款现代服务器端Java模板引擎，支持Web和独立环境，可实现自然模板开发，便于团队协作。与传统JSP不同，Thymeleaf模板可以直接在浏览器中打开，方便前端人员查看静态原型。通过在HTML标签中添加扩展属性（如`th:text`），Thymeleaf能够在服务运行时动态替换内容，展示数据库中的数据，同时兼容静态页面展示，为开发带来灵活性和便利性。
Quan_Chen
63 0

热门文章

最新文章

  • 1
    RAG 调优指南：Spring AI Alibaba 模块化 RAG 原理与使用
  • 2
    Java版Manus实现来了，Spring AI Alibaba发布开源OpenManus实现
  • 3
    Java程序员在AI时代必会的技术：Spring AI
  • 4
    使用Spring AI调用AI模型
  • 5
    Spring AI与DeepSeek实战三：打造企业知识库
  • 6
    Spring AI与DeepSeek实战四：系统API调用
  • 7
    使用 Ollama 本地模型与 Spring AI Alibaba 的强强结合，打造下一代 RAG 应用
  • 8
    Spring 和 Spring Boot 之间的比较
  • 9
    智慧班牌源码，采用Java + Spring Boot后端框架，搭配Vue2前端技术，支持SaaS云部署
  • 10
    深入理解 Spring Boot 中日期时间格式化：@DateTimeFormat 与 @JsonFormat 完整实践
  • 1
    Spring Boot开发环境的搭建
    90
  • 2
    Spring Boot开发环境搭建和项目启动
    174
  • 3
    Spring中的bean相关问题
    78
  • 4
    Spring初始化加速的思路和方案问题之DAG分析在Spring并行初始化中面临哪些困难
    111
  • 5
    通用快照方案问题之Spring Boot Admin的定义如何解决
    107
  • 6
    通用快照方案问题之Martin Flower提出的微服务之间的通信如何解决
    72
  • 7
    Spring框架
    288
  • 8
    Spring问题之如何配置Bean的初始化方法和销毁方法
    117
  • 9
    Spring问题之Spring AOP是如何实现面向切面编程的
    78
  • 10
    spring cloud使用jar包部署和docker部署的区别
    204

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第三阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    oss创建bucket