SpringBoot教程（二十四） | SpringBoot实现分布式定时任务之Quartz（多数据源配置）

已于 2024-10-09 10:19:58 修改
阅读量408 收藏 7
点赞数 4
分类专栏： SpringBoot学习篇 文章标签： spring boot 分布式 后端
于 2024-10-09 10:08:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20236937/article/details/142779180
版权

SpringBoot教程（二十四） | SpringBoot实现分布式定时任务之Quartz（多数据源配置）

前言

我这边的SpringBoot的版本为2.6.13，其中Quartz是使用的以下方式引入

<!--quartz定时任务-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

由于我目前需要使用@QuartzDataSource去指定数据源，所以就不通过@DS注解去实现多数据源
而是通过自定义DynamicDataSource 去实现了多数据源

多数据源配置

引入aop依赖

<!--spring切面aop依赖-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

1. properties配置多数据源

# 应用服务 WEB 访问端口
server.port=9081

# 主数据源
spring.datasource.db1.url=jdbc:mysql://localhost:3306/sharding?useSSL=false&serverTimezone=UTC
spring.datasource.db1.jdbc-url=jdbc:mysql://localhost:3306/sharding?useSSL=false&serverTimezone=UTC
spring.datasource.db1.username=root
spring.datasource.db1.password=root
spring.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver

# 次数据源
spring.datasource.db2.url=jdbc:mysql://localhost:3306/sharding?useSSL=false&serverTimezone=UTC
spring.datasource.db2.jdbc-url=jdbc:mysql://localhost:3306/sharding?useSSL=false&serverTimezone=UTC
spring.datasource.db2.username=root
spring.datasource.db2.password=root
spring.datasource.db2.driver-class-name=com.mysql.cj.jdbc.Driver

# quartz 数据源
#spring.datasource.task.url=jdbc:mysql://localhost:3306/quartz
spring.datasource.task.jdbc-url=jdbc:mysql://localhost:3306/quartz
spring.datasource.task.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.task.username=root
spring.datasource.task.password=root

# Quartz Scheduler 配置
# 指定作业存储类型为JDBC，使用数据库来存储作业和调度信息
spring.quartz.job-store-type=jdbc
# 在关闭时等待作业完成
spring.quartz.wait-for-jobs-to-complete-on-shutdown=true
# 不初始化数据库架构，假设数据库架构已经存在
spring.quartz.jdbc.initialize-schema=never
# Quartz Scheduler 属性配置
spring.quartz.properties.org.quartz.jobStore.dataSource=quartz_jobs
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_
# 启用集群模式
spring.quartz.properties.org.quartz.jobStore.isClustered=true
# 集群检查间隔时间（毫秒）
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=1000
# 不使用属性来存储作业数据，改为使用BLOB字段
spring.quartz.properties.org.quartz.jobStore.useProperties=false
# 指定作业存储的类，这里使用Spring提供的LocalDataSourceJobStore，但通常这个配置是隐式的，
# 除非你有特殊的实现需求，否则通常不需要显式设置这个属性。
# spring.quartz.properties.org.quartz.jobStore.class=org.springframework.scheduling.quartz.LocalDataSourceJobStore
# 注意：上面的行已被注释掉，因为通常不需要显式设置
# 调度器实例名称和ID（org.quartz.scheduler.instanceName 这个是保证属于同一个集群）
spring.quartz.properties.org.quartz.scheduler.instanceName=SC_Scheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
# 线程池配置
# 线程池中线程的数量
spring.quartz.properties.org.quartz.threadPool.threadCount=25
# 线程优先级
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
# 线程池实现类
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool

2. 创建数据源枚举类

package com.example.springbootfull.quartztest.enums;

/**
 * 数据源
 */
public enum DataSourceType {
    /**
     * 数据源1
     * */
    DB1,

    /**
     * 数据源2
     * */
    DB2
}

3. 线程参数配置类

定义一个工具类来设置当前线程的数据源枚举值

package com.example.springbootfull.quartztest.datasource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 数据源切换处理
 */
public class DynamicDataSourceContextHolder {
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源的变量
     */
    public static void setDataSourceType(String dsType) {
        log.info("切换到{}数据源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 获得数据源的变量
     */
    public static String getDataSourceType() {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 清空数据源变量
     */
    public static void clearDataSourceType() {
        CONTEXT_HOLDER.remove();
    }
}

4. 数据源动态切换类

package com.example.springbootfull.quartztest.datasource;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;



/**
 * Spring的AbstractRoutingDataSource抽象类，实现动态数据源（他的作用就是动态切换数据源）
 * AbstractRoutingDataSource中的抽象方法determineCurrentLookupKey是实现数据源的route的核心，
 * 这里对该方法进行Override。【上下文DynamicDataSourceContextHolder为一线程安全的ThreadLocal】
 */
public class DynamicDataSource extends AbstractRoutingDataSource {


    /**
     * 取得当前使用哪个数据源
     * @return dbTypeEnum
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

5. 多数据源配置类

HikariCP 版本

package com.example.springbootfull.quartztest.config;

import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.example.springbootfull.quartztest.datasource.DynamicDataSource;
import com.example.springbootfull.quartztest.enums.DataSourceType;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.quartz.QuartzDataSource;
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 org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.Resource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * 多数据源配置
 */
@Configuration
public class DataSourceConfig {

    /**
     * 创建第一个数据源
     *
     * @return dataSource
     */
    @Bean(name = "dataSource1")
    @ConfigurationProperties(prefix = "spring.datasource.db1")
    public DataSource dataSource1() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 创建第二个数据源
     *
     * @return dataSource
     */
    @Bean(name = "dataSource2")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource dataSource2() {
        return DataSourceBuilder.create().build();
    }

    //quartz数据库 dataSourceTask数据源
    //使用@QuartzDataSource后，不需要动态配置
    @Bean(name = "dataSourceTask")
    @ConfigurationProperties(prefix = "spring.datasource.task")
    @QuartzDataSource
    public DataSource dataSourceTask() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 动态数据源配置
     *
     * @return dataSource
     */
    @Primary
    @Bean("multipleDataSource")
    public DataSource multipleDataSource(@Qualifier("dataSource1") DataSource db1,
                                         @Qualifier("dataSource2") DataSource db2) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSources = new HashMap<>();
        dataSources.put(DataSourceType.DB1, db1);
        dataSources.put(DataSourceType.DB2, db2);
        dynamicDataSource.setTargetDataSources(dataSources);
        //默认数据源
        dynamicDataSource.setDefaultTargetDataSource(db1);
        return dynamicDataSource;
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("multipleDataSource") DataSource multipleDataSource) throws Exception {
        // 导入mybatissqlsession配置
        MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
        // 指明数据源
        sessionFactory.setDataSource(multipleDataSource);
        // 设置mapper.xml的位置路径
        Resource[] resources = new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/**/*.xml");
        sessionFactory.setMapperLocations(resources);
        //指明实体扫描(多个package用逗号或者分号分隔)
        //sessionFactory.setTypeAliasesPackage("com.szylt.projects.project.entity");
        // 导入mybatis配置
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        sessionFactory.setConfiguration(configuration);
        return sessionFactory.getObject();
    }


    //数据源事务配置
    @Bean
    public PlatformTransactionManager transactionManager(DataSource multipleDataSource) {
        return new DataSourceTransactionManager(multipleDataSource);
    }

}

Druid 版本

需要先引入 Druid 依赖，这里使用的是 Druid 官方的 Starter

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid-spring-boot-starter</artifactId>
   <version>1.2.8</version>
</dependency>

然后，在properties配置文件中 为每个数据源配置DruidDataSour数据库连接池

spring.datasource.db1.type=com.alibaba.druid.pool.DruidDataSour
spring.datasource.db2.type=com.alibaba.druid.pool.DruidDataSour
spring.datasource.task.type=com.alibaba.druid.pool.DruidDataSour

接着把一下DataSourceConfig 类里面的
DataSource 对象 换成 DruidDataSource 对象
DataSourceBuilder 对象 换成 DruidDataSourceBuilder 对象
就好了

6. 自定义多数据源切换注解

package com.example.springbootfull.quartztest.annotation;

import com.example.springbootfull.quartztest.enums.DataSourceType;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义多数据源切换注解
 * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource
{
    /**
     * 切换数据源名称
     */
    public DataSourceType value() default DataSourceType.DB1;
}

7. 数据源注解截面AOP

package com.example.springbootfull.quartztest.aspectj;

import java.util.Objects;

import com.example.springbootfull.quartztest.annotation.DataSource;
import com.example.springbootfull.quartztest.datasource.DynamicDataSourceContextHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


/**
 * 多数据源处理
 *
 */
@Aspect
@Order(1)
@Component
public class DataSourceAspect {
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(com.example.springbootfull.quartztest.annotation.DataSource)"
            + "|| @within(com.example.springbootfull.quartztest.annotation.DataSource)")
    public void dsPointCut() {

    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DataSource dataSource = getDataSource(point);
        if (dataSource != null) {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }
        try {
            return point.proceed();
        } finally {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
        if (Objects.nonNull(dataSource)) {
            return dataSource;
        }

        return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
    }
}

8. 测试 多数据源 是否起效

创建了一个控制层测试类

package com.example.springbootfull.mybatisplustest.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.springbootfull.mybatisplustest.entity.SysUser;
import com.example.springbootfull.mybatisplustest.mapper.SysUserMapper;
import com.example.springbootfull.quartztest.annotation.DataSource;
import com.example.springbootfull.quartztest.enums.DataSourceType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.stereotype.Controller;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author jiang
 * @since 2024-09-13
 */
@Controller
@RequestMapping("/mybatisplustest/sysUser")
public class SysUserController {

    @Autowired
    private SysUserMapper sysUserMapper;

    @RequestMapping("/selectAll")
    @DataSource(value = DataSourceType.DB1)
    public void contextLoads() {
        //第一页，10个
        Page<SysUser> page = new Page<>(1, 10);
        QueryWrapper<SysUser> wrapper = new QueryWrapper<>();
        //查询liek人1的
        //wrapper.eq("enabled", true).like("account", "小明机器人10号");
        //查询授权=true的;
        wrapper.like("account", "人1");
        IPage<SysUser> iPage = sysUserMapper.selectPage(page, wrapper);

        //总页数
        System.out.println("总页数："+iPage.getPages());
        //总条数
        System.out.println("总条数："+iPage.getTotal());
        //每页条数
        System.out.println("每页条数："+iPage.getSize());
        //当前页的结果集
        System.out.println("当前页的结果集："+iPage.getRecords());
        //当前页号
        System.out.println("当前页号："+iPage.getCurrent());

//        // 创建实体类
//        SysUser sysUser = new SysUser();
//        sysUser.setAccount("mybtis呀");
//        sysUser.setEnabled(Boolean.TRUE);
//        sysUser.setCreateAt(new Date());
//        sysUserDao.insertSelective(sysUser);
//
//        // 根据自增ID检索实体
//        SysUser sysUser1 = sysUserDao.selectByPrimaryKey(sysUser.getId());

//        logger.info("user={}", sysUser1);
    }

}

运行如下截图：
两者都有触发
在这里插入图片描述
参考文章如下：
【1】Springboot+Mybatis+MySql整合多数据源及其使用
【2】Springboot定时任务quartz整合（多数据源+quartz持久化到数据库）
【3】springboot+MybatisPlus+HikariCP多数据源动态配置（实战篇）
【4】springboot+mybatis-plus+quartz多数据源操作，亲测可用

Slow菜鸟
关注
专栏目录
springboot整合quartz，实现数据库方式执行定时任务
11-19
这里`myDataSource`是你的数据源名称，`QRTZ_`是Quartz表前缀，可以根据实际需求更改。 然后，创建一个Quartz的配置类，用于定制Quartz的行为： ```java @Configuration public class QuartzConfig { @Autowired...
springboot整合quartz定时任务yml文件配置方式
03-23
2. **数据库配置**：由于我们选择了基于数据库的作业存储（job-store-type: jdbc），所以需要配置数据库连接信息，包括数据源和表前缀。 ```yaml datasource: url: jdbc:mysql://localhost:3306/quartz?useSSL=...
Springboot整个Quartz实现动态定时任务的示例代码
08-26
SpringBoot 整个 Quartz 实现动态定时任务的示例代码 SpringBoot 是一个基于 Java 的开源框架， Quartz 是一个功能强大的任务调度器，两者的结合可以实现动态定时任务的示例代码。在本文中，我们将详细介绍如何使用...
动态定时任务 SpringBoot quartz集群分布式。动态指定任意-demo-quartz-dynamic.zip
01-30
动态指定任意-demo-quartz-dynamic.zip"正是这样一个示例，它展示了如何在SpringBoot应用中实现动态管理和调度Quartz定时任务，并且支持在分布式环境下运行。 首先，让我们深入理解SpringBoot与Quartz的集成。...
SpringBoot整合quartz2.2.3自定义数据源和websocket通信
03-21
在本文中，我们将深入探讨如何将SpringBoot与quartz 2.2.3集成，以及如何利用自定义数据源和WebSocket技术实现高效、灵活的定时任务管理和前后端通信。首先，我们来理解SpringBoot和quartz的核心概念。 **...
Spring Boot学习资源库：微服务架构的加速器
2401_85743969的博客
10-09 924
性能测试是黑盒测试别称，程序本身的运作通过程序的进程来观察，主要是看一下程序是不是能够像我们预期的目标那样发展，看一看我们的程序最终能不能完整的得到我们最后想要的功能和储存想得到的数据，到最后看一下我们的这个程序完整性能不能达到要求。该系统的开发工具使用的都是免费的开发工具，且内容较为简单，一台计算机便可以开发出这个系统，且后期的维护，修改等对本系统的改动，都可以只通过一台计算机实现，因此开发该系统的成本在有计算机的情况下基本为0，所以本系统在经济上是可行的。对测试计划的把握是测试方案的重中之重。
Spring Boot应用开发详解
Chujun123528的博客
10-09 343
Spring Boot是一种基于Spring框架的轻量级开发框架，它简化了Spring应用的开发过程，提供了一套预设的开发规范和约束，并且内置了大量常用的第三方库。Spring Boot的核心思想是“约定大于配置”，它通过封装和自动配置的方式，让开发者可以快速构建一个独立运行的、生产级别的Spring应用。Spring Boot提供了自动化的配置方式，大部分的配置都可以通过约定来实现，不再需要繁琐的配置文件。
利用Spring Boot构建足球青训管理平台
2402_85762143的博客
10-01 1082
Spring Boot是一个简化程序设置的拥有开箱即用的框架，它主要的优点是根据程序员不同的设置而生成不同的代码配置文件，这样开发人员就不用每个项目都配置相同的文件，从而减低了开发人员对于传统配置文件的时间，提高了开发效率。综上所述，该系统具有技术可行性。在设计之初，我在网上参考了许多相关系统的界面布局设计，发现该系统界面展示比较简单，功能罗列齐全，操作流程简单明了，系统用户不用担心不会操作，系统各个功能模块都会有相应的提示，一看就明白，实在不知道的话，稍微指点就能上手，上手速度很快，时间不会耽误太多。
足球青训俱乐部后台：Spring Boot开发策略
2401_85761003的博客
10-01 1103
采用B/S体系结构开发的应用软件仅仅需要在客户端安装谷歌浏览器或者其他浏览器就可以操作，对于维护和升级操作则在服务器端就能完成，不用在客户端进行操作，这样就节省了许多开销，B/S模式能够保证软件应用的跨平台性和通用性，采用它开发软件是最佳选择。数据库在整个系统中，就是这个系统的基础。系统结构设计是整个系统设计中重要的一部分，在结构设计过程中，首先对系统进行需求分析，然后进行系统初步设计，将系统功能模块细化，具体分析每一个功能模块具体应该首先哪些功能，最后将各个模块进行整合，实现系统结构的最终设计。
Spring Boot 整合 Minio
cmh1008611的博客
10-09 593
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
Spring Boot 3 配置 Redis 兼容单例和集群
最新发布
IOsetting的专栏
10-09 179
Spring Boot 在application.yml中默认的 Redis 单例和集群配置格式是不同的, 如果要用同一套格式兼容两种配置, 需要自定义 RedisConnectionFactory 的初始化
redis集成到spring boot中使用
huapiaoy的博客
10-09 823
redis服务器在官网中公开了自己使用的协议--RESP，所以我们可以使用这个协议来访问redis服务器，但是如果我们要自己实现库，那肯定是非常麻烦的，所以我们可以使用网上的库，我们直接调用接口，不需要关注redis协议的细节，我们这里使用的是jedis。本身我们这里是需要通过windows主机，来访问云服务器的6379端口的，于是我们就构造一个特殊的ssh数据包，把要访问6379端口的请求，放到数据报里，此时我们的数据报就变成了这样。查询key对应的value（注意这里的返回值为set类型）
大学生就业市场：Spring Boot招聘系统的设计与实现
2401_85439108的博客
10-05 914
概念模式的设计方法是在需求分析的基础上，用概念数据模型（例如E-R模型）表示数据及数据之间的相互联系，设计出反映用户信息需求和处理需求的数据库系统概念模式。概念设计的目标是准确描述应用领域的信息模式，支持用户的各种应用，这样既容易转换为数据库系统逻辑模式，又容易为用户理解。在概念模式的设计中，E-R模型法是最常见的设计方法。概念设计的目标是设计出反映某个组织部门信息需求的数据库系统概念模式，数据库系统的概念模式独立于数据库系统的逻辑结构、独立于数据库管理系统（DBMS）、独立于计算机系统。
spring boot集成日志
hang_sa_mu的博客
09-30 1475
-日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->-- springboot默认是用logback的日志框架的(性能差)，所以需要排除logback，不然会出现jar依赖冲突的报错 -->-- 滚动文件 达到触发条件，生成新的文件，原来的内容会存档，存档的文件根据filePatternt规则增加年月日 -->-- Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。
大学生就业与招聘：Spring Boot系统设计
2401_85760095的博客
10-05 668
同时也大大提高了手的能力，使其难以充分体会探索的乐趣和成功的创作过程，设计过程中汲取的东西，是一笔宝贵的财富。可以保证关键数据的安全性。
告别@Value，Spring Boot 3.3更优雅的配置注入方案
2301_76419561的博客
10-09 299
在Spring Boot的早期版本中，我们常使用@Value注解来注入配置文件中的属性值。然而，这种方式虽然简单直接，却存在一些局限，比如它只能注入基本类型的值，并且需要显式地在每个需要注入的字段上使用注解。随着Spring Boot的发展，特别是到了3.3版本，我们有更优雅、更强大的配置注入方案，其中成为了推荐的方式。
Spring Boot驱动的现代医院管理系统
2401_85761003的博客
10-07 1102
6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。2、支持多种操作系统AIX的，FreeBSD下，HP-UX，Linux和Mac OS中，Novell公司的Netware，OpenBSD系统，OS/2裹时，Solaris，Windows等。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
Spring Boot助力医院数据管理
2401_85342379的博客
10-07 1206
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。B/S架构给使用管理系统的用户带来极大的便利。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值