Spring Boot 整合 Java-DB

整合 ActiveRecord 操作关系型数据库

Spring Boot 整合 Java-DB 有两种方式：

1. 方式 1：不使用 Spring Boot，自行创建数据源并配置到 ActiveRecordPlugin 中
2. 方式 2：使用 Spring Boot 的数据源，并将 ActiveRecordPlugin 添加到 Spring 容器中

方式 1：不使用 Spring Boot，自行创建数据源并配置到 ActiveRecordPlugin 中

这种方式适用于需要快速启动和简单配置的场景，例如单元测试或开发环境。通过 dataSourceForDev 方法创建数据源，并使用 configWithoutSpring 方法配置 ActiveRecordPlugin。

方式 2：使用 Spring Boot 的数据源，并将 ActiveRecordPlugin 添加到 Spring 容器中

这种方式适用于生产环境或需要 Spring 容器管理的场景。通过 Spring 的依赖注入机制，将数据源注入到 ActiveRecordPlugin 中，并在 Spring 容器中配置和管理 ActiveRecordPlugin。

这两种方式各有优缺点，可以根据具体需求选择适合的方式进行整合。

配置实例

DbConfig 配置

以下是这两种方式的配置示例：

import com.jfinal.template.Engine;
import com.jfinal.template.source.ClassPathSourceFactory;
import com.litongjava.db.activerecord.ActiveRecordPlugin;
import com.litongjava.db.activerecord.OrderedFieldContainerFactory;
import com.litongjava.db.activerecord.dialect.PostgreSqlDialect;
import com.litongjava.db.hikaricp.DsContainer;
import com.litongjava.jfinal.aop.annotation.AConfiguration;
import com.litongjava.tio.utils.dsn.DbDSNParser;
import com.litongjava.tio.utils.dsn.JdbcInfo;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@AConfiguration
@Configuration
public class DbConfig {

  @Autowired
  @Qualifier("write")
  private DataSource dataSource;

  /*
   * 配置使用 Spring 的 ActiveRecordPlugin
   */
  @Bean(destroyMethod = "stop")
  public ActiveRecordPlugin configWithSpring() {
    ActiveRecordPlugin arpDev = new ActiveRecordPlugin("main", dataSource);
    arpDev.setContainerFactory(new OrderedFieldContainerFactory());
    if (EnvUtils.isDev()) {
      arpDev.setDevMode(true);
    }

    arpDev.setDialect(new PostgreSqlDialect());

    // 配置模板引擎
    Engine engine = arpDev.getEngine();
    engine.setSourceFactory(new ClassPathSourceFactory());
    engine.setCompressorOn(' ');
    engine.setCompressorOn('\n');

    // 添加 SQL 文件
    // arpDev.addSqlTemplate("/sql/all_sqls.sql");

    // 启动
    arpDev.start();
    return arpDev;
  }

  public DataSource dataSourceForDev() {
    String dsn = EnvUtils.get("DATABASE_DSN");
    if (dsn == null) {
      return null;
    }

    JdbcInfo jdbc = new DbDSNParser().parse(dsn);
    int maximumPoolSize = EnvUtils.getInt("jdbc.MaximumPoolSize", 1);
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl(jdbc.getUrl());
    config.setUsername(jdbc.getUser());
    config.setPassword(jdbc.getPswd());
    config.setMaximumPoolSize(maximumPoolSize);
    HikariDataSource hikariDataSource = new HikariDataSource(config);

    // 设置数据源
    DsContainer.setDataSource(hikariDataSource);
    return hikariDataSource;
  }

  public void configWithoutSpring() {
    // 获取数据源
    DataSource dataSource = dataSourceForDev();
    if (dataSource == null) {
      return;
    }

    // 创建 ActiveRecordPlugin
    ActiveRecordPlugin arpDev = new ActiveRecordPlugin("main", dataSource);
    arpDev.setContainerFactory(new OrderedFieldContainerFactory());
    if (EnvUtils.isDev()) {
      arpDev.setDevMode(true);
    }

    arpDev.setDialect(new PostgreSqlDialect());

    // 配置模板引擎
    Engine engine = arpDev.getEngine();
    engine.setSourceFactory(new ClassPathSourceFactory());
    engine.setCompressorOn(' ');
    engine.setCompressorOn('\n');

    // 添加 SQL 文件
    // arpDev.addSqlTemplate("/sql/all_sqls.sql");

    // 启动
    arpDev.start();
  }
}

在测试环境中测试

如果是在测试环境下，可以使用 configWithoutSpring 方法，避免 Spring 的初始化，提高启动速度。

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.tio.utils.environment.EnvUtils;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
class LrbSystemAddressServiceTest {

  @Test
  void getFileServerUrl() {
    EnvUtils.load();
    new DbConfig().configWithoutSpring();
    String fileServerUrl = Aop.get(SystemAddressService.class).getFileServerUrl();
    System.out.println(fileServerUrl);
  }
}

SystemAddressService 的 getFileServerUrl 就是一个简单的 SQL

整合 RedisPlugin 操作 Redis

app.properties

REDIS_URL=redis://default:@127.0.0.1:6379

RedisPluginConfig

import com.litongjava.db.redis.Cache;
import com.litongjava.db.redis.Redis;
import com.litongjava.db.redis.RedisPlugin;
import com.litongjava.jfinal.aop.annotation.AConfiguration;
import com.litongjava.jfinal.aop.annotation.AInitialization;
import com.litongjava.tio.utils.dsn.RedisInfo;
import com.litongjava.tio.utils.dsn.RedisUrlParser;
import com.litongjava.tio.utils.environment.EnvUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;

@AConfiguration
@Slf4j
@Configuration
public class RedisPluginConfig {

  @Initialization
  @Bean(destroyMethod = "stop")
  public RedisPlugin redisPlugin() {
    String redisUrl = EnvUtils.get("REDIS_URL");
    if (redisUrl == null) {
      return null;
    }
    RedisInfo redisInfo = new RedisUrlParser().parse(redisUrl);
    int redistimeout = EnvUtils.getInt("redis.timeout", 60);
    int redisDatabase = EnvUtils.getInt("redis.database", 0);
    String cacheName = EnvUtils.get("redis.cacheName", "main");

    // 创建并启动 Redis 插件
    RedisPlugin mainRedis = new RedisPlugin(cacheName, redisInfo.getHost(), redisInfo.getPort(), redistimeout,
      redisInfo.getPswd(), redisDatabase);

    mainRedis.start();

    // 测试连接
    Cache cache = Redis.use(cacheName);

    Jedis jedis = cache.getJedis();
    try {
      jedis.connect();
      log.info("connect redis successful");
    } catch (Exception e) {
      e.printStackTrace();
    }
    return mainRedis;
  }
}