2026年6月5日金曜日

SpringBoot + JobRunr で Web アプリとワーカープロセスを分離する方法

SpringBoot + JobRunr で Web アプリとワーカープロセスを分離する方法

概要

これまでは同じプロセス内で Web アプリと JobRunr ワーカーを起動させていました
これだとワーカーだけをスケールアウトさせたい場合に不便です
今回は Web アプリとワーカーを別々のプロセスで起動する方法を紹介します

環境

  • macOS 26.4.1
  • openjdk 26.0.1
  • SpringBoot 4.0.6
    • jasypt-spring-boot 4.0.4
    • jackson-databind 2.21.2
    • jobrunr 8.6.1
  • gradle 9.5.1
  • VSCode 1.121.0
  • MySQL 9.6.0
  • Redis 8.6.3

Web アプリケーション

Web アプリ専用のアプリケーションを作成します
こちらは SpringBoot が必要なので @SpringBootApplication にします

また専用のプロパティ (application.properties と application-web.properties) を読み込むので profiles に web を指定します

  • vim src/main/java/com/example/demo/AccessingDataMysqlApplication.java
package com.example.demo;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;

import com.ulisesbocchio.jasyptspringboot.annotation.EnableEncryptableProperties;

@EnableEncryptableProperties
@ConfigurationPropertiesScan
@SpringBootApplication
public class AccessingDataMysqlApplication {

        public static void main(String[] args) {
                new SpringApplicationBuilder(AccessingDataMysqlApplication.class).profiles("web").run(args);
        }

}

Web アプリケーション用設定ファイル

今回は application.properties だけを読み込むので application-web.properties は作成しなくて OK です

もし Web アプリにだけ必要な設定や application.properties の設定を上書きしたい場合には application-web.properties を作成して設定しましょう

  • vim src/main/resources/application.properties
spring.application.name=demo
# update はアプリケーション起動時に、Entityに対応するテーブルがなければ作成します
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

spring.datasource.url=jdbc:mysql://${MYSQL_HOST:127.0.0.1}:3306/mydatabase
spring.datasource.username=ENC(bFMupckSRHJ/9QmXd1EVTw==)
spring.datasource.password=ENC(QFCt95vHHcJpgm8oKhghkJoEknQv3tF0)

spring.data.redis.host=localhost
spring.data.redis.port=6379

# Web起動時はJobRunrのBackgroundJobServerを無効化（worker jarで有効化）
app.jobrunr.background-job-server.enabled=false

# Jasypt 暗号化キーの設定（環境変数から取得）
jasypt.encryptor.algorithm=PBEWithMD5AndDES
jasypt.encryptor.iv-generator-classname=org.jasypt.iv.NoIvGenerator
jasypt.encryptor.password=${JASYPT_PASSWORD:default_password}

ワーカーアプリケーション

@SpringBootApplication は不要です
JobRunr として動かすために SpringApplicationBuilder を使い定義します
こうすることで SpringBoot の Bean 機能などが使えます

profiles には worker を指定し application-worker.properties を使えるようにします

  • vim src/main/java/com/example/demo/WorkerApplication.java
package com.example.demo;

import org.springframework.boot.builder.SpringApplicationBuilder;
public class WorkerApplication {

        public static void main(String[] args) {
                new SpringApplicationBuilder(AccessingDataMysqlApplication.class).profiles("worker").run(args);
        }
}

ワーカーアプリケーション用設定ファイル

ワーカー専用の設定ファイルを作成します
Web アプリとして動作しないための設定を記載します
application.properties の設定を上書きします

  • vim src/main/resources/application-worker.properties
spring.main.web-application-type=none

app.jobrunr.background-job-server.enabled=true

Bean に設定を注入するためのクラス

application-worker.properties の値は自動的に読み込まれます
しかし Bean には読み込まれないのでプロパティファイルから設定を取得し Bean に注入します

  • vim src/main/java/com/example/demo/config/JobRunrBackgroundJobServerProperties.java
package com.example.demo.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "app.jobrunr.background-job-server")
public class JobRunrBackgroundJobServerProperties {

        private boolean enabled = false;

        public boolean isEnabled() {
                return enabled;
        }

        public void setEnabled(boolean enabled) {
                this.enabled = enabled;
        }
}

そしてこの設定を使って JobRunr の設定 (Bean) を作成します

  • vim src/main/java/com/example/demo/config/JobRunrConfig.java
package com.example.demo.config;

import javax.sql.DataSource;

import org.jobrunr.configuration.JobRunr;
import org.jobrunr.scheduling.JobScheduler;
import org.jobrunr.server.JobActivator;
import org.jobrunr.storage.StorageProvider;
import org.jobrunr.storage.StorageProviderUtils.DatabaseOptions;
import org.jobrunr.storage.sql.mysql.MySqlStorageProvider;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JobRunrConfig {

        @Bean
        StorageProvider storageProvider(DataSource dataSource) {
                return new MySqlStorageProvider(dataSource, DatabaseOptions.CREATE);
        }

        @Bean
        JobActivator jobActivator(ApplicationContext applicationContext) {
                return applicationContext::getBean;
        }

        @Bean
        JobScheduler jobScheduler(StorageProvider storageProvider, JobActivator jobActivator,
                        JobRunrBackgroundJobServerProperties jobRunrBackgroundJobServerProperties) {
                return JobRunr.configure().useStorageProvider(storageProvider).useJobActivator(jobActivator)
                                .useBackgroundJobServerIf(jobRunrBackgroundJobServerProperties.isEnabled()).initialize()
                                .getJobScheduler();
        }
}

サービスなどの設定

これは前回と同様です

build.gradle の修正

以下の設定を追記します
Web アプリケーションだけを起動する設定とビルドする設定、そしてワーカーアプリケーションだけを起動しビルドする設定を追加します

  • vim build.gradle
tasks.named('bootJar') {
       archiveClassifier = 'web'
       mainClass = 'com.example.demo.AccessingDataMysqlApplication'
}

tasks.named('bootRun', org.springframework.boot.gradle.tasks.run.BootRun) {
       mainClass = 'com.example.demo.AccessingDataMysqlApplication'
}

def webBootJar = tasks.named('bootJar', org.springframework.boot.gradle.tasks.bundling.BootJar)

tasks.register('workerBootRun', org.springframework.boot.gradle.tasks.run.BootRun) {
       group = 'application'
       description = 'Runs the worker process (non-web) using WorkerApplication.'
       mainClass = 'com.example.demo.WorkerApplication'
       classpath = sourceSets.main.runtimeClasspath
}

tasks.register('workerBootJar', org.springframework.boot.gradle.tasks.bundling.BootJar) {
       group = 'build'
       description = 'Builds the executable worker jar.'
       archiveClassifier = 'worker'
       mainClass = 'com.example.demo.WorkerApplication'
       classpath = sourceSets.main.runtimeClasspath
       targetJavaVersion = webBootJar.get().targetJavaVersion
       dependsOn tasks.named('classes')
}

tasks.named('assemble') {
       dependsOn tasks.named('workerBootJar')
}

動作確認

  • ./gradlew clean && ./gradlew bootRun --args='--jasypt.encryptor.password=xxx'
  • ./gradlew clean && ./gradlew workerBootRun -Dspring-boot.run.mainClass=com.example.demo.WorkerApplication --args='--jasypt.encryptor.password=xxx'

Web アプリケーション、ワーカーアプリケーションそれぞれのプロセスで立ち上げます
これで curl で動作確認するとワーカー側のロギング処理がワーカー側の起動したターミナルだけに表示されることが確認できます

ビルド

jar を作成するには以下の通りです

  • JASYPT_PASSWORD="xxx" ./gradlew clean build

これで build/libs 配下に各種 jar が作成できます
jar を実行するには以下のようにします

  • JASYPT_PASSWORD=asdfghjkl java -jar build/libs/demo-0.0.1-SNAPSHOT-web.jar
  • JASYPT_PASSWORD=asdfghjkl java -jar build/libs/demo-0.0.1-SNAPSHOT-worker.jar

最後に

JobRunr で Web アプリケーションとワーカーアプリケーションを分離させる方法を紹介しました
もしワーカーを増やしたい場合はワーカーの jar だけ追加で起動すれば OK です

試しに複数起動してみましたが2つのワーカーが処理することはなかったので大丈夫だと思います

時刻: 0 件のコメント:
ラベル: , , , ,

2026年6月4日木曜日

SpringBoot で JobRunr を使って非同期処理する方法

SpringBoot で JobRunr を使って非同期処理する方法

概要

過去にデフォルトの非同期ジョブを使ってみました
ジョブキューには Redis を使いましたが JobRunr では MySQL などいろいろなものをジョブキューに設定できます
また管理画面やスケジュール実行も備えておりジョブキューとして必須の機能を実装しています

今回は SpringBoot のプロジェクトに簡単な JobRunr を使った非同期処理を実装してみます

環境

  • macOS 26.4.1
  • openjdk 26.0.1
  • SpringBoot 4.0.6
    • jasypt-spring-boot 4.0.4
    • jackson-databind 2.21.2
    • jobrunr 8.6.1
  • gradle 9.5.1
  • VSCode 1.121.0
  • MySQL 9.6.0
  • Redis 8.6.3

インストール

  • vim build.gradle
dependencies {
       implementation 'com.fasterxml.jackson.core:jackson-databind:2.21.4'
       implementation 'org.jobrunr:jobrunr:8.6.1'
}

JobRunr 接続設定

設定は @Configuration を使って定義します
SpringApplication 配下であれば定義できるます

storageProvider でジョブキューを保存するストレージを定義します
今回は MySQL を使います
MySQL の接続先は application.properties にあるデータベースをデフォルトでは使用します (参考)

DatabaseOptions.CREATE をオプションに指定することで自動で的にジョブキューに必要なテーブルを作成してくれます

jobrunr_jobs
jobrunr_recurring_jobs
jobrunr_backgroundjobservers
jobrunr_metadata

jobActivator はワーカーがジョブを実行する際に自動的に Bean オブジェクトをワーカーが取得できるようにする設定です

jobScheduler で実際にワーカー処理を登録します
先ほどまでに作成したデータストレージやアクティベータを登録します
useBackgroundJobServer を呼び出すことで非同期ワーカーを登録します

  • vim src/main/java/com/example/demo/config/JobRunrConfig.java
package com.example.demo.config;

import javax.sql.DataSource;

import org.jobrunr.configuration.JobRunr;
import org.jobrunr.scheduling.JobScheduler;
import org.jobrunr.server.JobActivator;
import org.jobrunr.storage.StorageProvider;
import org.jobrunr.storage.StorageProviderUtils.DatabaseOptions;
import org.jobrunr.storage.sql.mysql.MySqlStorageProvider;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JobRunrConfig {

       @Bean
       StorageProvider storageProvider(DataSource dataSource) {
               return new MySqlStorageProvider(dataSource, DatabaseOptions.CREATE);
       }

       @Bean
       JobActivator jobActivator(ApplicationContext applicationContext) {
               return applicationContext::getBean;
       }

       @Bean
       JobScheduler jobScheduler(StorageProvider storageProvider, JobActivator jobActivator) {
               return JobRunr.configure().useStorageProvider(storageProvider).useJobActivator(jobActivator)
                               .useBackgroundJobServer().initialize().getJobScheduler();
       }
}

ワーカーの作成

実際にジョブを受け取ったワーカーが処理する内容を定義します
このあと定義しますがワーカー側ではエンキュー時に登録した引数の情報をそのまま受け取ることができます

package com.example.demo.worker;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class UserCreatedWorker {

       private static final Logger LOGGER = LoggerFactory.getLogger(UserCreatedWorker.class);

       public void processUserCreated(String name, String email) {
               LOGGER.info("Processing user created job - Name: {}, Email: {}", name, email);
       }
}

サービス側の修正

エンキューする処理をサービス側に定義します
基本的にはサービスレイヤーがある場合にはサービスレイヤーでエンキュー処理を行うほうが良いです

今までは StringRedisTemplate を使ってジョブキューを実行していましたがそれを JobRunr を使うように修正します

jobScheduler を使いエンキューし userCreatedWorker を使ってデキュー時のワーカー処理を呼び出してあげるようにします

  • vim src/main/java/com/example/demo/service/UserService.java
package com.example.demo.service;

import java.util.ArrayList;
import java.util.List;

import org.jobrunr.scheduling.JobScheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.dto.UserRequest;
import com.example.demo.dto.UserResponse;
import com.example.demo.entity.User;
import com.example.demo.exception.BusinessException;
import com.example.demo.repository.UserRepository;
import com.example.demo.worker.UserCreatedWorker;

@Service
public class UserService {

        @Autowired
        private UserRepository userRepository;

        @Autowired
        private JobScheduler jobScheduler;

        @Autowired
        private UserCreatedWorker userCreatedWorker;

        public void createUser(UserRequest req) {

                // ビジネスルール
                if (userRepository.existsByEmail(req.getEmail())) {
                        throw new BusinessException("USER_ALREADY_EXISTS", "既に登録されています");
                }

                User user = new User();
                user.setName(req.getName());
                user.setEmail(req.getEmail());

                userRepository.save(user);

                // ユーザー作成後の後続処理をJobRunrで非同期実行
                jobScheduler.enqueue(() -> userCreatedWorker.processUserCreated(req.getName(), req.getEmail()));
        }

        public List<UserResponse> getAllUsers() {
                List<User> users = new ArrayList<>();
                userRepository.findAll().forEach(users::add);

                return users.stream().map(this::toResponse).toList();
        }

        private UserResponse toResponse(User user) {
                UserResponse response = new UserResponse();
                response.setName(user.getName());
                return response;
        }
}

動作確認

アプリを起動し POST リクエストを送信しましょう
ジョブがエンキューされワーカー側のロギング処理が表示されれば OK です

  • ./gradlew bootRun --args='--jasypt.encryptor.password=xxx'
  • curl -XPOST http://localhost:8080/demo/add -d '{"name": "First", "email": "someemail5@someemailprovider.com"}' -H 'content-type: application/json'
2026-06-02T16:43:10.805+09:00  INFO 705817 --- [demo] [roundjob-worker] c.example.demo.worker.UserCreatedWorker  : Processing user created job - Name: First, Email: someemail5@someemailprov

最後に

SpringBoot + JobRunr を試してみました
これだとデフォルトの非同期処理とあまり変わらないので次回は管理画面の導入や別のストレージプロバイダーを使ってみたいと思います

参考サイト

時刻: 0 件のコメント:
ラベル: , , , ,

2026年6月3日水曜日

SpringBoot で Redis を使った非同期処理をやってみる

SpringBoot で Redis を使った非同期処理をやってみる

概要

デフォルトで使用できる Redis クライアントがありこれを使って簡単に非同期処理が実現できるので試してみました
メッセージのやり取りには DTO クラスを使い Json メッセージを DTO に変換してエンキュー/デキュー時に使用するようにしてみます

環境

  • macOS 26.4.1
  • openjdk 26.0.1
  • SpringBoot 4.0.6
    • jasypt-spring-boot 4.0.4
    • jackson-databind 2.21.2
  • gradle 9.5.1
  • VSCode 1.121.0
  • MySQL 9.6.0
  • Redis 8.6.3

build.gradle

SpringBoot から Redis に接続するためのライブラリとメッセージのやり取りをしやすくするための jackson-databind を追加でインストールします

  • org.springframework.boot:spring-boot-starter-json
  • org.springframework.boot:spring-boot-starter-data-redis
  • com.fasterxml.jackson.core:jackson-databind
dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation 'org.springframework.boot:spring-boot-starter-webmvc'
	implementation 'org.springframework.boot:spring-boot-starter-json'
	implementation 'com.fasterxml.jackson.core:jackson-databind'
	implementation 'org.springframework.boot:spring-boot-starter-validation'
	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
	implementation 'com.github.ulisesbocchio:jasypt-spring-boot-starter:4.0.4'
	developmentOnly 'org.springframework.boot:spring-boot-docker-compose'
	runtimeOnly 'com.mysql:mysql-connector-j'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-jpa-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
	testImplementation 'org.springframework.boot:spring-boot-testcontainers'
	testImplementation 'org.testcontainers:testcontainers-junit-jupiter'
	testImplementation 'org.testcontainers:testcontainers-mysql'
	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

ワーカーの作成(デキュー)

まずはワーカーを作成します
Json メッセージを受け取り処理する部分です
今回は Json -> DTO に変換してから使います

  • vim src/main/java/com/example/demo/worker/RedisMessageReceiver.java
package com.example.demo.worker;

import java.util.concurrent.atomic.AtomicInteger;

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

import com.example.demo.dto.RedisMessageRequest;
import com.fasterxml.jackson.databind.ObjectMapper;

public class RedisMessageReceiver {
    private static final Logger LOGGER = LoggerFactory.getLogger(RedisMessageReceiver.class);

    private AtomicInteger counter = new AtomicInteger();
    private ObjectMapper objectMapper;

    public RedisMessageReceiver(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    public void receiveMessage(String message) {
        try {
            // JSON から RedisMessageRequest に変換
            RedisMessageRequest request = objectMapper.readValue(message, RedisMessageRequest.class);

            // ワーカー側でメッセージ情報を使用
            LOGGER.info("Received message - Name: {}, Email: {}", request.getName(), request.getEmail());
            counter.incrementAndGet();
        } catch (Exception e) {
            LOGGER.error("Failed to parse Redis message", e);
        }
    }

    public int getCount() {
        return counter.get();
    }
}

DTO の作成

メッセージ情報管理する DTO クラスです
ビジネスロジックを含まないバリデーションや加工処理が必要な場合はここで行います

  • vim src/main/java/com/example/demo/dto/RedisMessageRequest.java
package com.example.demo.dto;

import jakarta.validation.constraints.NotBlank;

public class RedisMessageRequest {

	@NotBlank
	private String name;

	@NotBlank
	private String email;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}
}

Redis接続設定

SpringBoot では Redis への接続情報は @Bean を使うのが定石です
@Bean の定義は @SpringBootApplication または @Configuration 配下で使えます

@Bean としてオブジェクトを定義しておくと各種クラウで @Autowired できるようになります

送信トピックやワーカーの登録などを行います

  • vim src/main/java/com/example/demo/config/RedisConfig.java
package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

import com.example.demo.worker.RedisMessageReceiver;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisConfig {

	@Bean
	ObjectMapper objectMapper() {
		return new ObjectMapper();
	}

	@Bean
	RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
			MessageListenerAdapter listenerAdapter) {

		RedisMessageListenerContainer container = new RedisMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		container.addMessageListener(listenerAdapter, new PatternTopic("chat"));

		return container;
	}

	@Bean
	MessageListenerAdapter listenerAdapter(RedisMessageReceiver receiver) {
		return new MessageListenerAdapter(receiver, "receiveMessage");
	}

	@Bean
	RedisMessageReceiver receiver(ObjectMapper objectMapper) {
		return new RedisMessageReceiver(objectMapper);
	}
}

application.properties の修正

Redis の接続先情報はここで定義します

  • vim src/main/resources/application.properties
spring.data.redis.host=localhost
spring.data.redis.port=6379

サービス側でエンキュー処理

エンキューはサービス側で行います
StringRedisTemplate を DI するだけで使えます
今回はメッセージをエンキューする際も RedisMessageRequest を使いますが本当はエンキュー時とデキュー時は別の DTO クラスを定義するほうがキレイです

jackson を使って DTO クラスを自動的に Json に形式に変換しエンキューします

  • vim src/main/java/com/example/demo/service/UserService.java
package com.example.demo.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import com.example.demo.dto.RedisMessageRequest;
import com.example.demo.dto.UserRequest;
import com.example.demo.dto.UserResponse;
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import com.fasterxml.jackson.databind.ObjectMapper;

@Service
public class UserService {

	@Autowired
	private UserRepository userRepository;

	@Autowired
	private StringRedisTemplate redisTemplate;

	@Autowired
	private ObjectMapper objectMapper;

	public void createUser(UserRequest req) {

		// 例：ビジネスルール
		if (userRepository.existsByEmail(req.getEmail())) {
			throw new IllegalArgumentException("既に登録されています");
		}

		User user = new User();
		user.setName(req.getName());
		user.setEmail(req.getEmail());

		userRepository.save(user);

		// Redis キューにメッセージを JSON 形式で送信
		try {
			RedisMessageRequest message = new RedisMessageRequest();
			message.setName(req.getName());
			message.setEmail(req.getEmail());

			String jsonMessage = objectMapper.writeValueAsString(message);
			redisTemplate.convertAndSend("chat", jsonMessage);
		} catch (Exception e) {
			throw new RuntimeException("Failed to send Redis message", e);
		}
	}

	public List<UserResponse> getAllUsers() {
		List<User> users = new ArrayList<>();
		userRepository.findAll().forEach(users::add);

		return users.stream().map(this::toResponse).toList();
	}

	private UserResponse toResponse(User user) {
		UserResponse response = new UserResponse();
		response.setName(user.getName());
		return response;
	}
}

動作確認

アプリを起動し curl を実行します
アプリ側のログにワーカーで出力しているメッセージが表示されれば OK です

redis が必要なのでローカルで起動しておきます (もしくは compose.yaml の docker compose plugin でも対応できます)

  • brew services run redis
  • ./gradlew bootRun --args='--jasypt.encryptor.password=xxx'
  • curl -XPOST http://localhost:8080/demo/add -d '{"name": "First", "email": "someemail5@someemailprovider.com"}' -H 'content-type: application/json'
2026-05-25T10:17:20.254+09:00  INFO 34105 --- [demo] [    container-1] c.e.demo.worker.RedisMessageReceiver     : Received message - Name: First, Email: someemail5@someemailprovider.com

おまけ: テストの修正

サービスのテストで Redis 部分 (StringRedisTemplate) をモックするように書き換えます

  • vim src/test/java/com/example/demo/service/UserServiceTest.java
package com.example.demo.service;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.data.redis.core.StringRedisTemplate;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

import java.util.List;

import com.example.demo.dto.UserRequest;
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import com.fasterxml.jackson.databind.ObjectMapper;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

	@Mock
	private UserRepository userRepository;

	@Mock
	private StringRedisTemplate redisTemplate;

	@Mock
	private ObjectMapper objectMapper;

	@InjectMocks
	private UserService userService;

	@Test
	void ユーザー作成できる() throws Exception {
		UserRequest req = new UserRequest();
		req.setName("taro");
		req.setEmail("taro@example.com");

		when(objectMapper.writeValueAsString(any())).thenReturn("{\"name\":\"taro\",\"email\":\"taro@example.com\"}");
		when(redisTemplate.convertAndSend(eq("chat"), anyString())).thenReturn(1L);

		userService.createUser(req);

		verify(userRepository).save(any(User.class));
		verify(redisTemplate).convertAndSend(eq("chat"), anyString());
	}

	@Test
	void findAllメソッドが呼ばれたか() {
		userService.getAllUsers();

		verify(userRepository).findAll();
	}

	@Test
	void ユーザーの一覧が取得できる() {
		User user = new User();
		user.setName("taro");
		user.setEmail("taro@example.com");

		when(userRepository.findAll()).thenReturn(List.of(user));

		var result = userService.getAllUsers();

		assertEquals(1, result.size());
		assertEquals("taro", result.get(0).getName());
	}

	@Test
	void メールが重複している場合はエラー() {
		UserRequest req = new UserRequest();
		req.setName("taro");
		req.setEmail("taro@example.com");

		// モックの振る舞いを定義
		when(userRepository.existsByEmail("taro@example.com")).thenReturn(true);

		// 例外が投げられることを検証
		IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> userService.createUser(req));

		assertEquals("既に登録されています", ex.getMessage());

		// saveが呼ばれていないことも重要
		verify(userRepository, never()).save(any());
	}
}

最後に

SpringBoot で非同期処理を行ってみました
簡単にできますがいくつか課題があります

  • プロセス分離できていない
  • 管理画面がない
  • リトライやデッドレターキューなどがない

などなど非同期処理に欠かせない機能が単純に欠如しています
本当に簡単な非同期処理なら良いですがそうでない場合はやはりデフォルトの機能ではなく外部のライブラリを使う他なさそうです

参考サイト

時刻: 0 件のコメント:
ラベル: , , ,

2026年6月2日火曜日

SpringBoot で Filter を使う方法

SpringBoot で Filter を使う方法

概要

Servlet の Filter は SpringBoot でも使えます

環境

  • macOS 26.4.1
  • openjdk 26.0.1
  • SpringBoot 4.0.6
    • jasypt-spring-boot 4.0.4
    • jackson-databind 2.21.2
  • gradle 9.5.1
  • VSCode 1.121.0
  • MySQL 9.6.0
  • Redis 8.6.3

Filter の作成

Filter クラスを継承し @Component を使用するだけで SpringBoot が自動的に読み込んでくれます

SpringBoot では web.xml を準備して明示的に Filter を定義する必要はありません

  • vim src/main/java/com/example/demo/filter/LoggingFilter.java
package com.example.demo.filter;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class LoggingFilter implements Filter {

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {

		HttpServletRequest req = (HttpServletRequest) request;

		System.out.println(">>> Request: " + req.getMethod() + " " + req.getRequestURI());

		chain.doFilter(request, response);

		System.out.println("<<< Response finished");
	}
}

最後に

フィルタは http 全体に対する共通処理に使います
ロギングや認証、共通ヘッダの操作などにフィルタを使います

同じような機能に Interpretor がありますがこれは複数登録できる他基本的にはコントローラ単位で使用する機能になります

時刻: 0 件のコメント:
ラベル: , , ,
登録: 投稿 (Atom)