SpringBoot集成环境配置

最新推荐文章于 2024-10-16 23:28:29 发布
最新推荐文章于 2024-10-16 23:28:29 发布
阅读量238 收藏 1
点赞数
分类专栏： 文档 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50189163/article/details/112759915
版权

多环境配置

yml

server:
 port: 8080
 servlet:
  context-path: /weichuang
spring:
  profiles:
    active: test # 环境选择

---
server:
  port: 8080
  servlet:
    context-path: /weichuang
spring:
  profiles: dev # 环境名

---
server:
  port: 8081
spring:
  profiles: test # 环境名

MySQL

Maven依赖

<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<!--jdbc-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--Druid德鲁伊数据源-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.19</version>
</dependency>

application

yml

spring:
#  MySQL
  datasource:
    username: root
    password: ROOT
    #加入时区报错，就增加一个时区的配置就ok了===serverTimezone=UTC
    url: jdbc:mysql://localhost:3306/spring?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    #com.mysql.jdbc.Driver===5版本的数据库
    #com.mysql.cj.jdbc.Driver===8版本以上的数据库
    driver-class-name: com.mysql.cj.jdbc.Driver
    #指定druid德鲁伊数据源
    type: com.alibaba.druid.pool.DruidDataSource

测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import javax.sql.DataSource;
import java.sql.SQLException;

@SpringBootTest
class Springboot05MybatisApplicationTests {

    @Autowired
    private DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }
}

Mybatis

Maven依赖

<!--springboot整合mybatis-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>

application

yml

# mybatis配置
mybatis:
  mapper-locations: classpath:mybatis/mapper/*.xml    # mapper映射文件位置
  type-aliases-package: com.kgc.pojo    # 实体类所在的位置
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl   #用于控制台打印sql语句

Redis

Maven依赖

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

application

yml

spring:
# Redis
  redis:
  	database: 13 #选库
    host: 192.168.25.110
    port: 6379
    password:
    jedis:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 500
        min-idle: 0
    lettuce:
      shutdown-timeout: 0ms

Config

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
    @Bean @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

RedisUtils==可选

package com.chuang.qywxweichuang.util;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil{

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
    /**
     * 指定缓存失效时间
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key,Long time){
        try {
            if(time > 0){
                redisTemplate.expire(key,time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e1){
            e1.printStackTrace();
            return false;
        }
    }
    /**
     * 获取key的过期时间
     * @param key
     * @return
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key);
    }
    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public boolean hashKey(String key){
        try {
            return redisTemplate.hasKey(key);
        }catch (Exception e2){
            e2.printStackTrace();
            return false;
        }
    }
    /**
     * 删除缓存
     * @param key
     */
    public void del(String... key){
        if (key != null && key.length > 0) {
            if(key.length == 1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                //redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }
//=====================================String========================================
    /**
     * 普通缓存获取
     * @param key
     * @return
     */
    public Object get(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    /**
     * 普通放入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key,Object value){
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        }catch (Exception e3){
            e3.printStackTrace();
            return false;
        }
    }
    /**
     * 普通放入缓存并设置时效
     * @param key
     * @param value
     * @param time  time > 0 设置时效, time < 0 设置无限期
     * @return
     */
    public boolean set(String key,Object value,long time){
        try{
            if (time > 0) {
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else{
                redisTemplate.opsForValue().set(key,value);
            }
            return true;
        }catch (Exception e4){
            e4.printStackTrace();
            return false;
        }
    }
    /**
     * 递增
     * @param key
     * @param data
     * @return
     */
    public long incr(String key,long data){
        if(data < 0){
            throw  new RuntimeException("递增因子 不能小于0");
        }
        return  redisTemplate.opsForValue().increment(key,data);
    }

    public long decr(String key,long data){
        if(data < 0){
            throw  new RuntimeException("递减因子,不能小于0");
        }
        return redisTemplate.opsForValue().increment(key,-data);
    }
    //===================================Hash==================================

    /**
     * hashKey
     * @param key
     * @param keyItem
     * @return
     */
    public Object getHash(String key,String keyItem){
        return redisTemplate.opsForHash().get(key,keyItem);
    }

    /**
     * 获取hashkey所有的键值
     * @param key
     * @return
     */
    public Map<Object, Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * hashSet
     * @param key
     * @param map
     * @return
     */
    public boolean hsset(String key,Map<Object,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            return true;
        }catch (Exception e4){
            e4.printStackTrace();
            return false;
        }
    }

    /**
     * hashSet 设置时效
     * @param key
     * @param map
     * @param time
     * @return
     */
    public boolean hsset(String key,Map<Object,Object> map, Long time){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            if (time > 0) {
                expire(key,time);
            }
            return true;
        }catch (Exception e5){
            e5.printStackTrace();
            return false;
        }
    }

    /**
     * 向hash表中插入键值
     * @param key
     * @param itemKey
     * @param value
     * @return
     */
    public boolean hset(String key,String itemKey,Object value){
        try {
            redisTemplate.opsForHash().put(key,itemKey,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向hash表中插入键值,设置时效
     * @param key
     * @param itemKey
     * @param value
     * @param time
     * @return
     */
    public boolean hset(String key,String itemKey,Object value,long time){
        try {
            redisTemplate.opsForHash().put(key,itemKey,value);
            if(time > 0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的项
     * @param key 不能为null
     * @param item 不能为null,可以是多个
     */
    public void hdel(String key,Object...item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判断hash表中有没有键,项
     * @param key
     * @param item
     * @return
     */
    public boolean hHashKey(String key,Object item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }

    /**
     * 递增,值如果不存在就会创建一个,并把创建的值返回
     * @param key
     * @param item
     * @param by
     * @return
     */
    public double haIncr(String key,Object item,double by){
        if(by < 0){
            throw  new RuntimeException("递增因子不能小于0");
        }
        return redisTemplate.opsForHash().increment(key,item,by);
    }

    /**
     * 递减,值如果不存在就会创建一个,并把创建的值返回
     * @param key
     * @param item
     * @param by
     * @return
     */
    public double haDenr(String key,Object item,double by){
        return redisTemplate.opsForHash().increment(key,item,-by);
    }
//===================================set============================================

    /**
     * 根据key获取set
     * @param key
     * @return
     */
    public Set<Object> sGet(String key){
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 从一个set中查询value是否存在
     * @param key
     * @param value
     * @return
     */
    public boolean sHashKey(String key,Object value){
        return redisTemplate.opsForSet().isMember(key,value);
    }

    /**
     * 将set数据放入缓存
     * @param key
     * @param values
     * @return 成功的个数
     */
    public long sSet(String key,Object...values){
        try {
            return redisTemplate.opsForSet().add(key,values);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存并给key设置时效
     * @param key 键
     * @param time key 时效
     * @param values 值,可以是多个
     * @return 成功的个数
     */
    public long sSet(String key, Long time, Object... values){
        try {
            Long count = redisTemplate.opsForSet().add(key,values);
            if (time > 0) {
                expire(key,time);
            }
            return count;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存长度
     * @param key
     * @return
     */
    public long sSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除set缓存中的值
     * @param key 键
     * @param values 值可以是多个
     * @return 移除的个数
     */
    public long sRemove(String key,Object... values){
        try {
            return redisTemplate.opsForSet().remove(key,values);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
//======================================list=========================

    /**
     * 获取list缓存中的值
     * @param key 键
     * @param start 开始
     * @param end 结束  从0到-1显示所有的值
     * @return
     */
    public List<Object> lGet(String key,long start,long end){
        try {
            return redisTemplate.opsForList().range(key,start,end);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存长度
     * @param key
     * @return
     */
    public long lSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }

    /**
     * 根据index获取list缓存的值
     * @param key 键
     * @param index -1代表表尾,-2代表倒数第二个元素 以此类推
     * @return
     */
    public Object lIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key,index);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 把list放入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean lSet(String key,Object value){
        try {
            redisTemplate.opsForList().leftPush(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 把list放入缓存,设置key的时效
     * @param key
     * @param time
     * @param value
     * @return
     */
    public boolean lSet(String key,long time,Object value){
        try {
            redisTemplate.opsForList().leftPush(key,value);
            if(time > 0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list缓存中具体值
     * @param key
     * @param index
     * @param value
     * @return
     */
    public boolean lUpdate(String key,Long index,Object value){
        try {
            redisTemplate.opsForList().set(key,index,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key
     * @param count
     * @param value
     * @return
     */
    public long lRomve(String key,Long count,Object value){
        try {
            long remove = redisTemplate.opsForList().remove(key,count,value);
            return remove;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
}

测试类

查看更多命令

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import javax.sql.DataSource;
import java.sql.SQLException;

@SpringBootTest
class Springboot05MybatisApplicationTests {


    @Autowired
    private RedisTemplate<String,String> redisTemplate;

  
    @Test
    void test(){
        redisTemplate.opsForValue().set("mykey","myvalue");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }
}

Nutz

Maven依赖

<!--Springboot整合Nutz-->
<dependency>
    <groupId>org.nutz</groupId>
    <artifactId>nutz-plugins-spring-boot-starter</artifactId>
    <version>1.r.66</version>
</dependency>
<!--阿里的数据连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>
<!--数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

application

yml

spring:
  datasource:
    username: root
    password: ROOT
    #加入时区报错，就增加一个时区的配置就ok了===serverTimezone=UTC
    url: jdbc:mysql://localhost:3306/nutzdemo?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    #com.mysql.jdbc.Driver===5版本的数据库
    #com.mysql.cj.jdbc.Driver===8版本以上的数据库
    driver-class-name: com.mysql.cj.jdbc.Driver
    #指定druid德鲁伊数据源
    type: com.alibaba.druid.pool.DruidDataSource
nutz:
  json:
    auto-unicode: false
    quote-name: true
    ignore-null: true
    null-as-emtry: true
    enabled: true
    mode: compact
  dao:
    runtime:
      create: true #自动创建表
      migration: false #根据bena自动更新表结构
      basepackage: com.chuang.qywxweichuang.pojo  #扫描bean
    sqlmanager:
      paths:

Config

import org.nutz.dao.Dao;
import org.nutz.dao.impl.NutDao;
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 DaoConfiguration {

    @Bean
    @Primary
    public Dao getDao(DataSource dataSource) {
        // 创建一个NutDao实例,在真实项目中, NutDao通常由ioc托管, 使用注入的方式获得.
        Dao dao = new NutDao(dataSource);
        return dao;
    }
}

实体类==创建表

import org.nutz.dao.entity.annotation.*;

@Table("t_person")   // 声明了Person对象的数据表
public class Person { // 不会强制要求继承某个类
    @Id       // 表示该字段为一个自增长的Id,注意,是数据库表中自增!!
    private int id; // @Id与属性名称id没有对应关系.

    @Name    // 表示该字段可以用来标识此对象，或者是字符型主键，或者是唯一性约束
    private String name;

    @Column      // 表示该对象属性可以映射到数据库里作为一个字段
    private int age;
    //省略get、set

测试类

查看更多命令

import com.chuang.qywxweichuang.pojo.Person;
import org.junit.jupiter.api.Test;
import org.nutz.dao.Dao;
import org.nutz.dao.impl.NutDao;
import org.nutz.dao.impl.SimpleDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class QywxweichuangApplicationTests {
    // 创建一个NutDao实例,在真实项目中, NutDao通常由ioc托管, 使用注入的方式获得.
    @Autowired
    private Dao dao;
    @Test
    void contextLoads() {
        // 创建表
        dao.create(Person.class,false);// false的含义是,如果表已经存在,就不要删除重建了.
        Person person = new Person();
        person.setName("ABC");
        person.setAge(20);
        dao.insert(person);
        System.out.println(person.getId());
    }
}

Thymeleaf

Maven依赖

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

application

yml

spring:
 # thymeleaf
 thymeleaf:
   prefix: classpath:/templates/
   suffix: .html
   mode: HTML5
   encoding: UTF-8
   servlet:
     content-type: text/html
   cache: false

Config

import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

public class WebMvcConfig implements WebMvcConfigurer{
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
    }
}

Swgeer2

Maven依赖

application

yml

Config

Controller

我也不想摸鱼
关注
专栏目录
springboot环境配置
leaf_leaf__的博客
09-06 1640
spring-boot配置
springboot集成普罗米修斯(Prometheus)的方法
08-18
SpringBoot集成普罗米修斯(Prometheus)的方法 SpringBoot集成普罗米修斯(Prometheus)的方法主要介绍了如何将普罗米修斯集成到SpringBoot项目中，实现metrics的收集和监控。普罗米修斯是一套开源的系统监控报警框架...
SpringBoot配置环境
qq1803291168
08-15 5139
typora-copy-images-to: upload 微服务架构 第一个Spring Boot程序 jdk 1.8 maven 3.6.1 springboot 最新版 IDEA 修改端口号、banner banner在线制作网站 Spring Boot banner在线生成工具，制作下载banner.txt，修改替换banner.txt文字实现自定义，个性化启动banner-bootschool.net 原理 自动配置 pom.xml spring-boot-depe.
Spring Boot环境配置
最新发布
xiongmao2436的博客
10-16 1389
确保你的计算机已经安装了Java Development Kit（JDK）。建议使用JDK 17，可以从Oracle官方网站上下载并安装。
springboot集成impala(包含yml、impala配置类、pom.xml、impala jar)
09-18
以上就是关于SpringBoot集成Impala的基本概念和配置步骤。通过这种方式，开发者可以轻松地在SpringBoot应用中利用Impala的强大分析能力处理大数据任务。在实际项目中，还需要考虑错误处理、事务管理、性能优化等更多...
SpringBoot集成TDengine程序Demo
08-24
总结，这个"SpringBoot集成TDengine程序Demo"是一个实用的教学资源，它演示了如何在SpringBoot环境中使用TDengine数据库进行数据处理，对于想要涉足IoT领域的开发者，或是希望提升时序数据库应用能力的程序员，都是...
SpringBoot集成ocr功能demo
04-01
通过这个SpringBoot集成OCR功能的示例项目，开发者可以学习到如何将OCR技术融入到Spring Boot应用中，提升应用的智能化程度，从而提高工作效率和用户体验。同时，这也是一个了解和实践Java Web开发、RESTful API调用...
Spring Boot_配置文件-多环境配置
10-28
Spring Boot_配置文件-多环境配置
SpringBoot环境配置
gaozhen666的博客
05-21 332
SpringBoot环境配置总结 1. pom文件配置 <!-- SpringBoot的父级依赖。只有设置了parent标签，项目才是SpringBoot项目 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.2.RELEAS
SpringBoot环境配置教程
qq_35055027的博客
05-17 762
1. 安装前准备 在安装SpringBoot前,要先检查需要的基础软件是否配置好. 本文介绍IDEA下的SpringBoot的环境配置, 因此检查jdk, maven, idea就可以了. 我用的环境分别是: jdk 1.8.0_231 maven Apache Maven 3.6.1 IDEA 2019.3.4 SpringBoot 2.2.2.RELEASE 2. Maven设置 在maven安装目录下 ->conf ->settings.xml中的Profiles标签添加 <prof
springboot基本配置环境
m0_64081550的博客
06-02 355
springboot配置环境包括了邮件发送，文件上传，解决表单post上传，redis，mysql数据库，云服务，
9.springboot整合开发环境
西瓜咬人啦
07-22 118
九.整合 1.开发环境 开发工具 IntelliJ IDEA 2018.2 x64 MySQL Server 5.6 涉及框架 Spring SpringMVC MyBatis Maven MyBatis-Generator SpringBoot Thymeleaf 2.创建工程 创建一个SpringBoot工程 选择对应的组件 Web --> Spring Web Template Engines --> Thymeleaf SQL --> MyBatis Fram
springboot环境配置和运行
oyeah_up的博客
07-28 835
springboot环境配置
springboot多环境配置
墨染秦时的博客
01-29 252
因为现在一个项目有很多环境，比如说生产环境，测试环境，开发环境等，每个环境的配置也不一样，如果每次都去修改的话，很容易出错也繁琐。所以我们把每个环境的配置文件写在不同的yml文件中，这样在想用哪个环境就去调用哪个配置文件就很方便。我们只要在主配置文件中将要用的配置文件写上就行了。 spring： profiles: active: dev 这行配置就是说我们要用的是ap
SpringBoot多环境配置
sdgfafg_25的博客
04-01 1130
在实际项目的开发过程中，我们程序往往需要在不同环境中运行。例如：开发环境、测试环境和生产环境。每个环境中的配置参数可能都会有所不同，例如数据库连接信息、文件服务器等等。Spring Boot 提供了非常方便的方式来管理这些不同环境的配置。是Spring框架用于处理不同环境配置的解决方案。Profile可以帮助我们在不改变应用代码的情况下，根据当前环境动态地激活或者切换不同的配置。为每个Profile提供了一个独立的（或）配置文件。默认情况下，使用的是文件。当你激活一个特定的Profile时，
【Spring Boot】SpringBoot中系统多环境配置
Black_Customer的博客
04-18 9928
文章目录系统多环境配置1.创建多环境配置文件2. 修改配置文件3. 多环境的切换 系统多环境配置 在实际项目中，需要面对不同的运行环境，比如开发环境、测试环境、生产环境等，每个运行环境的数据库、Redis服务器等配置都不相同，每次发布测试、更新生产都需要手动修改相关系统配置。这种方式特别麻烦，费时费力，而且出错概率大。 Spring Boot为我们提供了更加简单方便的配置方案来解决多环境的配置问题。 1.创建多环境配置文件 创建多环境配置文件时，需要遵循Spring Boot允许的命名约定来命令，格式为
Springboot项目环境配置与部署指南
完成上述环境配置后，开发者就可以在IDEA中创建Springboot项目，导入所需依赖，编写代码并进行调试。部署时，通常会将Springboot应用打包成jar文件，通过命令行或者集成在其他容器如Docker中运行。对于分布式系统，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我也不想摸鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值