2024-09-03

Spring Boot 配置加载顺序通常遵循以下优先级规则:

  1. 命令行参数。
  2. 来自 SPRING_APPLICATION_JSON 环境变量的内联JSON配置。
  3. 当前目录下的 application.propertiesapplication.yml 文件。
  4. 外部配置文件,如 application.propertiesapplication.yml 放在配置目录下。
  5. SPRING_CONFIG_LOCATION 环境变量中指定的外部配置文件。
  6. 入口点的 spring.config.location 参数。
  7. 应用程序的 resource 目录中的 application.propertiesapplication.yml 文件。
  8. 应用程序的 resource 目录中的 application.propertiesapplication.yml 文件。
  9. @PropertySource 注解指定的配置。
  10. 默认属性。

这个加载过程是由SpringApplication类中的prepareEnvironment方法来控制的,它会按照上述顺序依次加载配置。

如果要改变默认的配置加载顺序,可以通过编程方式来指定配置文件的位置,例如:




@SpringBootApplication
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MySpringBootApplication.class);
        app.setAdditionalProfiles("dev");
        app.run(args);
    }
}

在这个例子中,我们通过 setAdditionalProfiles 方法添加了一个额外的配置文件后缀名为 dev,Spring Boot 会尝试加载带有 application-dev.propertiesapplication-dev.yml 的配置文件。

另外,你可以通过设置 spring.config.locationspring.config.import 属性来改变配置文件的默认位置。例如,在命令行中启动应用程序时使用:




java -jar myproject.jar --spring.config.location=file:/path/to/config/

这将会让Spring Boot应用程序加载指定路径下的配置文件。

注意,在实际开发中,通常推荐使用 Spring Boot 提供的默认配置加载顺序,这样可以保持配置的灵活性和可维护性。如果需要覆盖或添加特定的配置,可以在 application.propertiesapplication.yml 文件中进行,或者在不同的配置文件中进行分模块管理。

2024-09-03

在Oracle中创建一个定时任务(Job)来执行存储过程,可以通过DBMS\_SCHEDULER或DBMS\_JOB包来完成。以下是创建定时任务执行存储过程的例子:

无参数的存储过程:




CREATE OR REPLACE PROCEDURE my_procedure_no_params
IS
BEGIN
  -- 这里放置你的代码
  NULL; -- 如果没有代码,可以使用NULL占位符
END;
/
 
-- 创建定时任务
BEGIN
  DBMS_SCHEDULER.create_job (
    job_name        => 'my_job_no_params',
    job_type        => 'PLSQL_BLOCK',
    job_action      => 'BEGIN my_procedure_no_params; END;',
    start_date      => SYSTIMESTAMP,
    repeat_interval => 'FREQ=DAILY; BYHOUR=2; BYMINUTE=0; BYSECOND=0', -- 每天凌晨2点执行
    enabled         => TRUE,
    comments        => 'Job to execute my_procedure_no_params daily at 2 AM');
END;
/

带参数的存储过程:




CREATE OR REPLACE PROCEDURE my_procedure(p_param1 IN NUMBER, p_param2 IN VARCHAR2)
IS
BEGIN
  -- 这里放置你的代码,使用参数p_param1和p_param2
  NULL; -- 如果没有代码,可以使用NULL占位符
END;
/
 
-- 创建定时任务
BEGIN
  DBMS_SCHEDULER.create_job (
    job_name        => 'my_job_with_params',
    job_type        => 'PLSQL_BLOCK',
    job_action      => 'BEGIN my_procedure(10, ''example''); END;',
    start_date      => SYSTIMESTAMP,
    repeat_interval => 'FREQ=DAILY; BYHOUR=2; BYMINUTE=0; BYSECOND=0', -- 每天凌晨2点执行
    enabled         => TRUE,
    comments        => 'Job to execute my_procedure with params daily at 2 AM');
END;
/

在上述例子中,my_procedure_no_paramsmy_procedure是存储过程的名称,my_job_no_paramsmy_job_with_params是定时任务的名称。repeat_interval定义了任务的执行频率。这些值可以根据你的具体需求进行调整。

2024-09-03

Spring Boot 配置文件主要有 application.ymlapplication-dev.yml

application.yml 是主配置文件,通常包含共享环境(如数据库连接信息、服务器配置等)的配置。

application-dev.yml 是一个 profile 配置文件,用于开发环境的配置。当设置了 Spring Boot 的 spring.profiles.active 属性为 dev 时,application-dev.yml 中的配置会覆盖 application.yml 中相同的属性。

以下是两个配置文件的简单示例:

application.yml 示例:




server:
  port: 8080
 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: dbuser
    password: dbpass
    driver-class-name: com.mysql.jdbc.Driver

application-dev.yml 示例:




server:
  port: 8081
 
spring:
  profiles: dev
  datasource:
    url: jdbc:mysql://localhost:3306/mydb_dev
    username: dbuser_dev
    password: dbpass_dev
    driver-class-name: com.mysql.jdbc.Driver

在这个例子中,如果你启动应用程序时设置了 spring.profiles.active=dev,那么应用程序将会使用 application-dev.yml 中定义的端口号 8081 和数据库连接信息。这样做可以让开发环境和生产环境有不同的配置,便于开发和调试。

2024-09-03

由于DTS(Data Transmission Service)是阿里云提供的数据传输服务,而Oracle、DM和MySQL是不同的数据库系统,DM是达梦数据库,MySQL是开源数据库,迁移这些数据库到DM系统需要使用DTS进行数据同步。

以下是一个简化的示例,展示如何使用DTS从Oracle迁移数据至DM,以及从MySQL迁移数据至DM:

  1. 从Oracle迁移数据至DM:

首先,需要在源端Oracle数据库和目标端DM数据库之间建立连接,并配置数据同步任务。




{
    "job_id": "oracle_to_dm",
    "database_type": "Oracle",
    "oracle_connection": {
        "host": "源端Oracle服务器IP",
        "port": "1521",
        "user": "oracle用户名",
        "password": "oracle密码"
        // 其他必要的连接参数
    },
    "dm_connection": {
        "host": "目标端DM服务器IP",
        "port": "5236",
        "user": "dm用户名",
        "password": "dm密码"
        // 其他必要的连接参数
    },
    "table_config": [
        {
            "table_name": "需要同步的表名",
            "columns": ["列名列表"]
            // 其他必要的配置
        }
        // 更多表的配置
    ]
    // 其他必要的配置
}
  1. 从MySQL迁移数据至DM:

同样,需要在源端MySQL数据库和目标端DM数据库之间建立连接,并配置数据同步任务。




{
    "job_id": "mysql_to_dm",
    "database_type": "MySQL",
    "mysql_connection": {
        "host": "源端MySQL服务器IP",
        "port": "3306",
        "user": "mysql用户名",
        "password": "mysql密码"
        // 其他必要的连接参数
    },
    "dm_connection": {
        "host": "目标端DM服务器IP",
        "port": "5236",
        "user": "dm用户名",
        "password": "dm密码"
        // 其他必要的连接参数
    },
    "table_config": [
        {
            "table_name": "需要同步的表名",
            "columns": ["列名列表"]
            // 其他必要的配置
        }
        // 更多表的配置
    ]
    // 其他必要的配置
}

注意:以上代码示例是用JSON格式展示的配置信息,实际配置时需要在DTS管理控制台中填写相应的信息。

由于DTS具体使用细节可能涉及到数据库特定的设置和权限,所以需要参考阿里云DTS的官方文档来进行配置和使用。

2024-09-03

在Spring Boot 2.7中整合jetcache进行远程Redis缓存的方案,你可以参考以下步骤和示例代码:

  1. 添加依赖到你的pom.xml



<dependencies>
    <!-- jetcache -->
    <dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-starter-redis</artifactId>
        <version>0.11.0</version>
    </dependency>
    <!-- redis client -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.7.0</version>
    </dependency>
</dependencies>
  1. 配置application.yml文件:



jetcache:
  default:
    type: redis
    host: 你的Redis服务器地址
    port: 6379
    password: 你的Redis密码
    valueDecoder: java.lang.String
    keyEncoder: java.lang.String
    valueEncoder: java.lang.String
    poolConfig:
      maxTotal: 100
      maxIdle: 10
      minIdle: 1
  1. 创建一个配置类,使用@Bean定义Cache实例:



import com.alicp.jetcache.Cache;
import com.alicp.jetcache.anno.CacheConsts;
import com.alicp.jetcache.anno.CreateCache;
import com.alicp.jetcache.anno.config.SpringConfigProvider;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.redis.RedisCacheBuilder;
import com.alicp.jetcache.support.FastjsonKeyConvertor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class CacheConfig {
 
    @Bean
    public SpringConfigProvider springConfigProvider() {
        return new SpringConfigProvider();
    }
 
    @Bean
    public Cache defaultCache() {
        return new RedisCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE)
                .buildCache();
    }
}
  1. 使用jetcache进行缓存操作:



import com.alicp.jetcache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class CacheService {
 
    @Autowired
    private Cache<String, String> cache;
 
    public void put(String key, String value) {
        cache.put(key, value);
    }
 
    public String get(String key) {
        return cache.get(key);
    }
}

确保你的Redis服务器已经启动并可以正常连接,以上代码提供了一个基本的示例,展示了如何在Spring Boot 2.7项目中整合jetcache来使用远程Redis缓存。

2024-09-03

以下是一个使用PL/pgSQL编写的造数脚本示例,该脚本会在PostgreSQL数据库中插入一些示例数据:




DO $$
DECLARE
    i INTEGER;
BEGIN
    -- 创建一个测试表
    EXECUTE 'DROP TABLE IF EXISTS test_table';
    EXECUTE 'CREATE TABLE test_table (id SERIAL PRIMARY KEY, data VARCHAR(50))';
 
    -- 插入100条测试数据
    FOR i IN 1..100 LOOP
        EXECUTE 'INSERT INTO test_table (data) VALUES ($1)';
        PERFORM pg_sleep(0.01); -- 为了演示造数过程,每条记录插入后暂停0.01秒
    END LOOP;
END $$;

这段代码使用了匿名的DO块来执行,它会:

  1. 检查并删除已存在的test_table表。
  2. 创建一个新的test_table表,其中包含一个自增主键id和一个文本字段data
  3. 通过FOR循环,插入100条数据到test_table表中,每条记录之间暂停0.01秒,以便可以看到数据插入的过程。

请注意,在实际应用中,造数脚本可能需要根据实际的数据库结构和需求进行调整。

2024-09-03



命令                    描述
-----------------------  ---------------------------------------------------------
CREATE DATABASE         创建新数据库
CREATE TABLE            创建新表
CREATE INDEX            创建索引
INSERT                  向表中插入数据
SELECT                  查询数据
UPDATE                  更新数据
DELETE                  删除数据
DROP DATABASE           删除数据库
DROP TABLE              删除表
DROP INDEX              删除索引
ALTER TABLE             修改表结构
BEGIN                   开始事务
COMMIT                  提交事务
ROLLBACK                回滚事务
GRANT                   授权
REVOKE                  撤销权限
\q                      退出psql
\c                      切换数据库
\dt                     列出所有表
\di                     列出所有索引
\du                     列出所有角色
\df                     列出所有函数

这个表提供了PostgreSQL中常用的命令和它们的描述,以及一些元命令,它们用于管理数据库会话和查看数据库结构。

2024-09-03

在JDK 11中,引入了一个新的API来创建虚拟线程,这是一个轻量级的线程,可以用于I/O密集型的任务,以减少上下文切换的开销。




import java.lang.invoke.MethodHandles;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.VirtualThread;
 
public class VirtualThreadExample {
    public static void main(String[] args) {
        ThreadFactory factory = VirtualThread.factory();
        VirtualThread virtualThread = factory.newThread(() -> {
            System.out.println("Virtual thread is running.");
            // 执行异步I/O操作
        });
 
        virtualThread.start();
    }
}

在JDK 17中,对虚拟线程进行了进一步的改进,包括对java.util.concurrent.Executors.newVirtualThreadFactory()的支持,以及对VirtualThread的改进,例如提供了更多的控制选项,如最大虚拟线程数等。




import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
 
public class VirtualThreadExample {
    public static void main(String[] args) {
        Executor virtualThreadExecutor = Executors.newVirtualThreadFactory();
 
        virtualThreadExecutor.execute(() -> {
            System.out.println("Virtual thread is running.");
            // 执行异步I/O操作
        });
    }
}

JDK 21中,虚拟线程的功能进一步加强,包括对虚拟线程池的支持,以及对其他并发工具的改进。




import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
 
public class VirtualThreadExample {
    public static void main(String[] args) {
        ExecutorService virtualThreadExecutor = Executors.newVirtualThreadExecutor();
 
        virtualThreadExecutor.submit(() -> {
            System.out.println("Virtual thread is running.");
            // 执行异步I/O操作
        });
 
        // 关闭虚拟线程池
        virtualThreadExecutor.shutdown();
    }
}

Spring Boot 3 的新特性取决于你所使用的JDK版本。如果你使用JDK 17或更高版本,可以开始利用JDK 17的新特性,如文件加密存储、ZGC的改进等。如果你使用JDK 21或更高版本,可以利用JDK 21引入的模式匹配等新特性。

2024-09-03

在Oracle数据库中,LOB(Large Object)数据类型用于存储大型数据对象,如文本、图像、视频等。CLOB(Character Large Object)是一种存储大量字符数据的LOB数据类型。

当LOB数据不再需要时,应当及时清理,以避免占用过多的数据库空间。LOB数据在Oracle中是通过单独的段来存储的,因此清理LOB数据通常涉及删除这些数据和相关的表列。

以下是一个简单的SQL脚本,用于删除CLOB数据列以及相关的LOB存储数据:




DECLARE
  v_clob_col CLOB;
BEGIN
  SELECT clob_column INTO v_clob_col FROM your_table WHERE your_conditions;
  DBMS_LOB.FREE(v_clob_col);
  UPDATE your_table SET clob_column = empty_clob() WHERE your_conditions;
  COMMIT;
END;
/

在这个脚本中,your_table 是包含CLOB列的表名,clob_column 是CLOB列的名称,your_conditions 是用于选择特定行的条件。

如果LOB数据是在某些特定表的行中关联的,那么在删除表行时,LOB数据也会自动被清理。如果LOB数据是通过单独的表来管理的,那么在删除相关行时,LOB数据也应该被删除。

请注意,在执行这些操作之前,应当确保已经备份了所有重要的数据,并且理解这些操作的影响。如果不确定,最好咨询数据库管理员或专业人员。

2024-09-03

在SQL Server中,可以通过压缩数据库日志文件来减少文件的物理大小。以下是如何压缩日志文件的示例代码:




USE [YourDatabase];
GO
-- 检查数据库的当前状态
DBCC SHRINKFILE (YourDatabase_Log, 1);
GO

在这个例子中,YourDatabase 是你想要压缩日志文件的数据库名称,YourDatabase_Log 是日志文件的逻辑名称。DBCC SHRINKFILE 命令用于压缩指定的日志文件,其中的数字参数表示目标大小(以页为单位)或者为压缩操作指定百分比。

请注意,压缩操作可能会影响性能,因为它会移动页面并可能导致碎片生成。在执行压缩操作之前,请确保已经备份了数据库,并且了解压缩操作的影响。