Spring Boot チートシート

プロジェクト作成・初期設定

基本的なプロジェクトのセットアップ手順

主要な依存関係

設定ファイル

src/main/resources 配下に配置します。

application.properties

# サーバーポート設定
server.port=8080

# アプリケーション名
spring.application.name=my-spring-boot-app

# データベース接続設定 (例: H2)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# JPA/Hibernate設定
spring.jpa.hibernate.ddl-auto=update # create, create-drop, validate, none など
spring.jpa.show-sql=true # 実行されるSQLをログに出力

# Thymeleaf設定
spring.thymeleaf.cache=false # 開発中はキャッシュ無効化
        

application.yml

Properties形式の代わりにYAML形式も利用可能です。

server:
  port: 8080

spring:
  application:
    name: my-spring-boot-app
  datasource:
    url: jdbc:h2:mem:testdb
    driverClassName: org.h2.Driver
    username: sa
    password: password
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: update
    show-sql: true
  thymeleaf:
    cache: false
        

プロファイル設定

環境ごとに設定を切り替えるためにプロファイルを使用します。

• ファイル名で指定: application-{profile}.properties or application-{profile}.yml (例: application-dev.yml, application-prod.properties)
• YAMLドキュメント区切り: --- で区切り、spring.config.activate.on-profile: {profile} を指定

# デフォルト設定 (共通)
server:
  port: 8080
spring:
  application:
    name: my-app

---

# 開発環境 (dev) プロファイル
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:devdb
  jpa:
    show-sql: true

---

# 本番環境 (prod) プロファイル
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://prod-db.example.com:3306/mydb
    username: prod_user
    password: ${DB_PASSWORD} # 環境変数や外部設定から取得推奨
  jpa:
    hibernate:
      ddl-auto: validate # 本番では validate や none を推奨
        

有効化するプロファイルは、環境変数 SPRING_PROFILES_ACTIVE や JVM引数 -Dspring.profiles.active=dev で指定します。

Web開発 (Spring MVC) 🌐

REST API や Web アプリケーションの構築

コントローラー

リクエストマッピング

リクエストデータの取得

レスポンス

@GetMapping("/users/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
    Optional<User> userOpt = userService.findById(id);
    if (userOpt.isPresent()) {
        return ResponseEntity.ok(userOpt.get()); // 200 OK と User オブジェクト
    } else {
        return ResponseEntity.notFound().build(); // 404 Not Found
    }
}

@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody @Valid User user) {
    User createdUser = userService.createUser(user);
    URI location = URI.create("/users/" + createdUser.getId());
    return ResponseEntity.created(location).body(createdUser); // 201 Created と Location ヘッダー
}
        

エラーハンドリング

• @ExceptionHandler: コントローラー内で特定例外を処理するメソッドに付与。
• @ControllerAdvice / @RestControllerAdvice: グローバルな例外ハンドリングクラスに付与。@ExceptionHandler と組み合わせて使用。
• ResponseStatusException: 例外発生時に特定のHTTPステータスコードとメッセージを返すための例外クラス。

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleResourceNotFound(ResourceNotFoundException ex) {
        ErrorResponse error = new ErrorResponse("RESOURCE_NOT_FOUND", ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationExceptions(MethodArgumentNotValidException ex) {
        // エラー詳細を取得して整形するなど
        String message = ex.getBindingResult().getAllErrors().get(0).getDefaultMessage();
        ErrorResponse error = new ErrorResponse("VALIDATION_ERROR", message);
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) {
        // 予期せぬエラー
        ErrorResponse error = new ErrorResponse("INTERNAL_SERVER_ERROR", "An unexpected error occurred.");
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // ErrorResponse DTO (例)
    record ErrorResponse(String code, String message) {}
}

// カスタム例外 (例)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}
        

CORS (Cross-Origin Resource Sharing) 設定

異なるオリジンからのリクエストを許可するための設定。

• @CrossOrigin アノテーション: コントローラーやメソッド単位で設定。
• グローバル設定: WebMvcConfigurer を実装したクラスで設定。

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**") // 対象パスパターン
                .allowedOrigins("http://localhost:3000", "https://example.com") //許可するオリジン
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") //許可するHTTPメソッド
                .allowedHeaders("*") //許可するヘッダー
                .allowCredentials(true) //クッキー許可
                .maxAge(3600); // pre-flightリクエストのキャッシュ時間(秒)
    }
}
        

データアクセス (Spring Data JPA) 💾

データベース操作の簡略化

エンティティ定義

JPA の標準アノテーションを使用して、Java クラスをデータベーステーブルにマッピングします。

import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity // このクラスがJPAエンティティであることを示す
@Table(name = "users") // 対応するテーブル名を指定 (省略するとクラス名が使われる)
public class User {

    @Id // プライマリキーを示す
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID自動生成戦略 (DB依存)
    private Long id;

    @Column(nullable = false, unique = true, length = 100) // カラム制約
    private String username;

    @Column(nullable = false)
    private String password; // 注意: パスワードはハッシュ化して保存すること

    @Column(unique = true)
    private String email;

    @Column(name = "created_at", updatable = false) // カラム名指定、更新不可
    private LocalDateTime createdAt;

    private LocalDateTime updatedAt;

    // コンストラクタ、Getter/Setter、equals/hashCode など (Lombok を使うと簡潔)

    @PrePersist // 永続化前に実行
    protected void onCreate() {
        createdAt = updatedAt = LocalDateTime.now();
    }

    @PreUpdate // 更新前に実行
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
}
        

リポジトリインターフェース

JpaRepository またはその親インターフェース (CrudRepository, PagingAndSortingRepository) を継承して作成します。

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
import java.util.List;

@Repository // データアクセス層のコンポーネントであることを示す (省略可能)
public interface UserRepository extends JpaRepository<User, Long> { // <エンティティクラス, 主キーの型>

    // メソッド名からクエリを自動生成 (Query Methods)
    Optional<User> findByUsername(String username);

    List<User> findByEmailContainingIgnoreCase(String email);

    List<User> findByCreatedAtAfter(LocalDateTime dateTime);

    // exists クエリ
    boolean existsByEmail(String email);

    // delete クエリ
    long deleteByUsername(String username);
}
        

基本的なCRUD操作

JpaRepository が提供するメソッドを利用します。

カスタムクエリ (`@Query`)

メソッド名だけでは表現できない複雑なクエリは JPQL や ネイティブ SQL で記述します。

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface UserRepository extends JpaRepository<User, Long> {

    // JPQL (Java Persistence Query Language)
    @Query("SELECT u FROM User u WHERE u.email LIKE %:keyword% OR u.username LIKE %:keyword%")
    List<User> searchByKeyword(@Param("keyword") String keyword);

    // ネイティブ SQL (データベース固有のSQL)
    @Query(value = "SELECT * FROM users WHERE YEAR(created_at) = :year", nativeQuery = true)
    List<User> findUsersCreatedInYear(@Param("year") int year);

    // 更新/削除クエリ ( @Modifying と @Transactional が必要になる場合が多い)
    @Modifying
    @Query("UPDATE User u SET u.email = :newEmail WHERE u.id = :id")
    int updateUserEmail(@Param("id") Long id, @Param("newEmail") String newEmail);
}
        

ページングとソート

JpaRepository (または PagingAndSortingRepository) を継承し、メソッドの引数に Pageable を追加します。

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ItemRepository extends JpaRepository<Item, Long> {

    // 全件検索 (ページング・ソート付き)
    Page<Item> findAll(Pageable pageable);

    // 条件付き検索 (ページング・ソート付き)
    Page<Item> findByCategory(String category, Pageable pageable);
}

// サービス層での利用例
@Service
public class ItemService {
    @Autowired
    private ItemRepository itemRepository;

    public Page<Item> findItems(int page, int size, String sortField, String sortDirection) {
        Sort sort = Sort.by(Sort.Direction.fromString(sortDirection), sortField);
        Pageable pageable = PageRequest.of(page, size, sort);
        return itemRepository.findAll(pageable);
    }
}
        

Pageable の作成: PageRequest.of(pageNumber, pageSize, sort)

Page オブジェクトからは、コンテンツリスト (getContent())、総ページ数 (getTotalPages())、総要素数 (getTotalElements()) などを取得できます。

トランザクション管理 (`@Transactional`)

複数のデータ操作を一つの作業単位として扱うためのアノテーション。

• 通常、サービスクラスやそのメソッドに付与します。
• メソッドが正常終了すればコミット、例外が発生すればロールバックされます。
• readOnly = true: 読み取り専用トランザクション (最適化)
• propagation: トランザクションの伝播動作 (REQUIRED, REQUIRES_NEW など)
• isolation: トランザクション分離レベル (READ_COMMITTED, SERIALIZABLE など)
• rollbackFor / noRollbackFor: ロールバック対象/非対象の例外を指定

import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Autowired private OrderRepository orderRepository;
    @Autowired private OrderItemRepository orderItemRepository;
    @Autowired private InventoryService inventoryService; // 在庫管理サービス

    @Transactional // このメソッド全体が1つのトランザクションになる
    public Order placeOrder(OrderRequest request) {
        // 注文情報作成
        Order order = new Order(/* ... */);
        orderRepository.save(order);

        // 注文明細作成 & 在庫引き当て
        for (OrderItemRequest itemRequest : request.getItems()) {
            inventoryService.decreaseStock(itemRequest.getProductId(), itemRequest.getQuantity()); // 在庫がなければ例外発生
            OrderItem item = new OrderItem(order, /* ... */);
            orderItemRepository.save(item);
        }
        // 例外が発生しなければ、ここまでのDB操作がコミットされる
        // 例外が発生すれば、全てのDB操作がロールバックされる
        return order;
    }

    @Transactional(readOnly = true) // 読み取り専用
    public Order getOrderDetails(Long orderId) {
        return orderRepository.findById(orderId)
                .orElseThrow(() -> new ResourceNotFoundException("Order not found"));
    }
}
        

DI (Dependency Injection) 💉

コンポーネント間の依存関係の管理

コンポーネントスキャン

• @SpringBootApplication: このアノテーションが付与されたクラスのパッケージ以下を自動的にスキャンします (@ComponentScan を内包)。
• @ComponentScan: スキャン対象のベースパッケージを明示的に指定する場合に使用。

Bean 定義 (ステレオタイプアノテーション)

Bean のインジェクション (依存性の注入)

@Service
public class MyService {
    private final UserRepository userRepository; // final推奨

    // @Autowired はコンストラクタが1つの場合は省略可能
    public MyService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    // ...
}
                        

@Service
public class MyService {
    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    // ...
}
                        

@Service
public class MyService {
    @Autowired
    private UserRepository userRepository; // 非推奨
    // ...
}
                        

インジェクション候補の限定 (`@Qualifier`)

同じ型の Bean が複数存在する場合、どちらを注入するかを指定します。

// Bean 定義
@Component("emailNotificationService")
public class EmailNotificationService implements NotificationService { ... }

@Component("smsNotificationService")
public class SmsNotificationService implements NotificationService { ... }

// インジェクション
@Service
public class UserRegistrationService {
    private final NotificationService notificationService;

    // "emailNotificationService" という名前の Bean を注入
    public UserRegistrationService(@Qualifier("emailNotificationService") NotificationService notificationService) {
        this.notificationService = notificationService;
    }
    // ...
}
        

プロファイルによる Bean 切り替え (`@Profile`)

特定のプロファイルがアクティブな場合にのみ Bean を有効化します。

// 開発環境用ダミーサービス
@Service
@Profile("dev") // "dev" プロファイルが有効な場合のみ Bean として登録
public class DevMailSender implements MailSender { ... }

// 本番環境用実サービス
@Service
@Profile("prod") // "prod" プロファイルが有効な場合のみ Bean として登録
public class ProdMailSender implements MailSender { ... }

// MailSender を利用するクラス
@Service
public class NotificationService {
    private final MailSender mailSender;

    public NotificationService(MailSender mailSender) { // 実行時のプロファイルに応じて適切な Bean が注入される
        this.mailSender = mailSender;
    }
    // ...
}
        

設定管理 ⚙️

アプリケーション設定値の扱い方

`@Value` アノテーション

設定ファイル (application.properties/.yml) や環境変数から個々のプロパティ値をフィールドにインジェクトします。

@Component
public class AppInfo {

    @Value("${spring.application.name}") // application.properties/yml から値を取得
    private String appName;

    @Value("${server.port}")
    private int port;

    @Value("${myapp.feature.enabled:false}") // デフォルト値付き (プロパティが存在しない場合 false)
    private boolean featureEnabled;

    @Value("${JAVA_HOME}") // 環境変数も取得可能
    private String javaHome;

    // ... Getters or usage
}
        

`@ConfigurationProperties`

関連するプロパティ群を型安全なオブジェクト (POJO) にまとめてバインドします。

• プレフィックスを指定して、そのプレフィックスで始まるプロパティをマッピングします。
• クラスまたは @Bean メソッドに付与します。
• @EnableConfigurationProperties(YourPropertiesClass.class) を設定クラスに追加するか、対象クラスに @Configuration または @Component などを付与します。
• バリデーション (@Validated と Bean Validation アノテーション) も可能です。

myapp:
  api:
    url: https://api.example.com
    timeout-ms: 5000
    retry-count: 3
  feature:
    new-ui:
      enabled: true
        

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Positive;

@ConfigurationProperties(prefix = "myapp") // "myapp" プレフィックスのプロパティをバインド
@Validated // バリデーションを有効化
public class MyAppProperties {

    private final Api api = new Api();
    private final Feature feature = new Feature();

    // Getter が必要
    public Api getApi() { return api; }
    public Feature getFeature() { return feature; }

    // ネストしたプロパティ用の内部クラス
    public static class Api {
        @NotBlank // バリデーションルール
        private String url;
        @Positive
        private int timeoutMs = 3000; // デフォルト値
        @Positive
        private int retryCount = 1; // デフォルト値

        // Getters and Setters が必要
        public String getUrl() { return url; }
        public void setUrl(String url) { this.url = url; }
        public int getTimeoutMs() { return timeoutMs; }
        public void setTimeoutMs(int timeoutMs) { this.timeoutMs = timeoutMs; }
        public int getRetryCount() { return retryCount; }
        public void setRetryCount(int retryCount) { this.retryCount = retryCount; }
    }

    public static class Feature {
        private final NewUi newUi = new NewUi();
        public NewUi getNewUi() { return newUi; }

        public static class NewUi {
            private boolean enabled = false; // デフォルト値
            public boolean isEnabled() { return enabled; }
            public void setEnabled(boolean enabled) { this.enabled = enabled; }
        }
    }
}

// 設定クラスで有効化
@Configuration
@EnableConfigurationProperties(MyAppProperties.class)
public class AppConfig {
    // MyAppProperties Bean が利用可能になる
}

// 利用例
@Service
public class SomeService {
    private final MyAppProperties props;
    public SomeService(MyAppProperties props) {
        this.props = props;
        String apiUrl = props.getApi().getUrl();
        boolean isNewUiEnabled = props.getFeature().getNewUi().isEnabled();
        // ...
    }
}
        

設定の優先順位

Spring Boot は様々な場所から設定を読み込み、以下の順序 (上が高優先) で上書きします。

1. Devtools のグローバル設定 (~/.spring-boot-devtools.properties)
2. テスト中の @TestPropertySource
3. テスト中の properties 属性 (@SpringBootTest など)
4. コマンドライン引数 (--server.port=9000)
5. SPRING_APPLICATION_JSON からのプロパティ (環境変数やシステムプロパティのインラインJSON)
6. ServletConfig 初期化パラメータ
7. ServletContext 初期化パラメータ
8. java:comp/env の JNDI 属性
9. Java システムプロパティ (System.getProperties())
10. OS 環境変数
11. random.* プロパティ (RandomValuePropertySource)
12. jar 外のプロファイル固有 application-{profile}.properties/yml
13. jar 内のプロファイル固有 application-{profile}.properties/yml
14. jar 外の application.properties/yml
15. jar 内の application.properties/yml
16. @Configuration クラスの @PropertySource
17. デフォルトプロパティ (SpringApplication.setDefaultProperties)

セキュリティ (Spring Security) 🛡️

認証と認可の実装

基本的な設定クラス

SecurityFilterChain Bean を定義して、HTTP セキュリティルールを設定します。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

import static org.springframework.security.config.Customizer.withDefaults;

@Configuration
@EnableWebSecurity // Spring Security を有効化
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/public/**", "/h2-console/**").permitAll() // 認証不要なパス
                .requestMatchers("/admin/**").hasRole("ADMIN") // ADMIN ロールが必要なパス
                .anyRequest().authenticated() // その他のリクエストは認証が必要
            )
            .formLogin(withDefaults()) // フォームベースログインを有効化 (デフォルト設定)
            .httpBasic(withDefaults()) // HTTP Basic 認証を有効化 (デフォルト設定)
            .csrf(csrf -> csrf.ignoringRequestMatchers("/h2-console/**")) // H2コンソール用にCSRF無効化 (開発時)
            .headers(headers -> headers.frameOptions(frameOptions -> frameOptions.sameOrigin())); // H2コンソール用にX-Frame-Options設定

        return http.build();
    }

    // パスワードエンコーダーの Bean 定義 (必須)
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // --- 認証方法の選択 (以下のいずれか、またはカスタム実装) ---

    // 1. インメモリ認証 (テスト・開発用)
    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
        UserDetails user = User.builder()
            .username("user")
            .password(passwordEncoder.encode("password")) // パスワードはエンコードする
            .roles("USER")
            .build();
        UserDetails admin = User.builder()
            .username("admin")
            .password(passwordEncoder.encode("admin"))
            .roles("ADMIN", "USER")
            .build();
        return new InMemoryUserDetailsManager(user, admin);
    }

    /*
    // 2. JDBC 認証 (データベースを利用) - application.properties に datasource 設定が必要
    @Bean
    public UserDetailsService jdbcUserDetailsService(DataSource dataSource) {
        // デフォルトのスキーマを利用する場合 (users, authorities テーブル)
        return new JdbcUserDetailsManager(dataSource);

        // カスタムクエリを指定する場合
        // JdbcUserDetailsManager manager = new JdbcUserDetailsManager(dataSource);
        // manager.setUsersByUsernameQuery("SELECT username, password, enabled FROM my_users WHERE username = ?");
        // manager.setAuthoritiesByUsernameQuery("SELECT username, authority FROM my_authorities WHERE username = ?");
        // return manager;
    }
    */

    /*
    // 3. カスタム UserDetailsService (推奨される方法)
    // UserRepository を利用してDBからユーザー情報を取得する実装
    @Bean
    public UserDetailsService customUserDetailsService(UserRepository userRepository) {
        return username -> userRepository.findByUsername(username)
                .map(user -> org.springframework.security.core.userdetails.User.builder()
                        .username(user.getUsername())
                        .password(user.getPassword()) // DBにはエンコード済みパスワードを保存
                        .roles("USER") // DBからロール情報を取得するロジックを追加
                        .build())
                .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username));
    }
    */
}
        

主な設定要素

JWT (JSON Web Token) 認証

ステートレス API で一般的に使用される認証方式。

1. ユーザーがログインすると、サーバーは JWT を生成して返す。
2. クライアントは以降のリクエストで、Authorization ヘッダー (Bearer スキーマ) に JWT を含めて送信する。
3. サーバーはリクエストごとに JWT を検証し、ユーザーを認証する。

実装には以下の要素が必要:

• JWT 生成・検証ライブラリ (例: java-jwt, jjwt)
• JWT の生成ロジック (ログイン成功時)
• JWT 検証フィルター (リクエストごとに実行され、SecurityContextHolder に認証情報を設定)
• Spring Security 設定で、JWT フィルターを適切な位置に追加し、デフォルトのフォームログインなどを無効化。

テスト 🧪

アプリケーションの品質保証

主要なテスト用アノテーション

テスト例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.hamcrest.Matchers.*;

@WebMvcTest(UserController.class) // UserController をテスト対象とする
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc; // MVCリクエストをシミュレート

    @MockBean // UserService をモック化
    private UserService userService;

    @Test
    void shouldGetUserById() throws Exception {
        User user = new User(1L, "testuser", "test@example.com");
        given(userService.findById(1L)).willReturn(Optional.of(user));

        mockMvc.perform(get("/api/users/1"))
               .andExpect(status().isOk())
               .andExpect(content().contentType(MediaType.APPLICATION_JSON))
               .andExpect(jsonPath("$.id", is(1)))
               .andExpect(jsonPath("$.username", is("testuser")));
    }

    @Test
    void shouldReturnNotFoundForMissingUser() throws Exception {
        given(userService.findById(99L)).willReturn(Optional.empty());

        mockMvc.perform(get("/api/users/99"))
               .andExpect(status().isNotFound());
    }

    @Test
    void shouldCreateUser() throws Exception {
        User newUser = new User(null, "newuser", "new@example.com");
        User createdUser = new User(2L, "newuser", "new@example.com");
        given(userService.createUser(any(User.class))).willReturn(createdUser);

        String userJson = "{\"username\":\"newuser\",\"email\":\"new@example.com\"}"; // Jackson などで生成推奨

        mockMvc.perform(post("/api/users")
                       .contentType(MediaType.APPLICATION_JSON)
                       .content(userJson))
               .andExpect(status().isCreated())
               .andExpect(header().string("Location", "/api/users/2"))
               .andExpect(jsonPath("$.id", is(2)))
               .andExpect(jsonPath("$.username", is("newuser")));
    }
}
        

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; // JPA操作用ユーティリティ
import static org.assertj.core.api.Assertions.assertThat;

import java.util.Optional;

@DataJpaTest // JPA関連のコンポーネントのみロード、デフォルトで H2 を使用
public class UserRepositoryTest {

    @Autowired
    private TestEntityManager entityManager; // テストデータの準備や永続化状態の確認

    @Autowired
    private UserRepository userRepository;

    @Test
    void shouldSaveAndFindUser() {
        User user = new User(null, "jpatest", "jpa@test.com");
        User savedUser = entityManager.persistFlushFind(user); // 保存してDBから取得

        Optional<User> foundUserOpt = userRepository.findById(savedUser.getId());

        assertThat(foundUserOpt).isPresent();
        assertThat(foundUserOpt.get().getUsername()).isEqualTo("jpatest");
    }

    @Test
    void shouldFindByUsername() {
        User user1 = new User(null, "findme", "findme@test.com");
        entityManager.persistAndFlush(user1);
        User user2 = new User(null, "another", "another@test.com");
        entityManager.persistAndFlush(user2);

        Optional<User> foundUserOpt = userRepository.findByUsername("findme");

        assertThat(foundUserOpt).isPresent();
        assertThat(foundUserOpt.get().getId()).isEqualTo(user1.getId());
    }

     @Test
    void shouldNotExistForUnknownUsername() {
        Optional<User> foundUserOpt = userRepository.findByUsername("unknown");
        assertThat(foundUserOpt).isNotPresent();
    }
}
        

テストユーティリティ

• MockMvc: Spring MVC コントローラーのテスト用。HTTP リクエストをシミュレートし、レスポンスを検証。
• TestRestTemplate: 実際の HTTP サーバーを起動するテスト (@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)) で、アプリケーションにリクエストを送信。
• TestEntityManager: JPA テストでエンティティの永続化、検索、フラッシュなどを実行。
• AssertJ: 流れるようなインターフェースを持つアサーションライブラリ (assertThat(...))。
• Mockito: モックオブジェクト作成ライブラリ (mock(), when(), verify())。

Actuator (運用監視)

アプリケーションの状態監視と管理

主要なエンドポイント

application.properties または .yml で公開するエンドポイントを設定します。

management:
  endpoints:
    web:
      exposure:
        include: health, info, metrics, env, loggers, threaddump, heapdump # 公開するエンドポイントをカンマ区切りで指定 ( '*' ですべて公開)
        # exclude: heapdump # 特定のエンドポイントを除外することも可能
  endpoint:
    health:
      show-details: when_authorized # /health の詳細表示権限 (always, never, when_authorized)
      # roles: ACTUATOR_ADMIN # 詳細表示に必要なロール (Spring Security連携時)
    info:
      enabled: true # /info エンドポイントの有効化 (デフォルトで有効)
  info: # /info エンドポイントで表示する情報
    app:
      name: ${spring.application.name}
      description: My Awesome Spring Boot Application
      version: @project.version@ # Maven/Gradle プロジェクトのバージョン (ビルド時に置換)
    # git: # git.properties があればGit情報も表示可能 (要 maven/gradle plugin)
    # build: # build-info.properties があればビルド情報も表示可能 (要 maven/gradle plugin)
        

セキュリティ設定

Actuator エンドポイントは機密情報を含む可能性があるため、本番環境では適切に保護する必要があります。

• Spring Security を使用して、エンドポイントへのアクセスを認証・認可する (推奨)。
• 異なるポート (management.server.port) やパス (management.endpoints.web.base-path) で公開し、ネットワークレベルでアクセスを制限する。

// SecurityConfig 内に追加
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    // ... (他の設定)

    @Bean
    @Order(1) // 他のセキュリティ設定より優先度を高くする
    public SecurityFilterChain actuatorSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .securityMatcher("/actuator/**") // /actuator/** パスにのみ適用
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/actuator/health", "/actuator/info").permitAll() // healthとinfoは認証不要
                .anyRequest().hasRole("ACTUATOR_ADMIN") // 他のActuatorエンドポイントは ACTUATOR_ADMIN ロールが必要
            )
            .httpBasic(withDefaults()); // Basic認証を使用 (他の認証方法も可)
        return http.build();
    }

    @Bean
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        // ... アプリケーション本体のセキュリティ設定 ...
        http
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(withDefaults());
        return http.build();
    }

    // ... (PasswordEncoder, UserDetailsService の Bean 定義)
    // ACTUATOR_ADMIN ロールを持つユーザーを作成する必要がある
}
        

非同期処理 ⚡

時間のかかる処理のバックグラウンド実行

有効化と基本設定

1. 設定クラスに @EnableAsync アノテーションを付与。
2. 非同期で実行したいメソッド (public) に @Async アノテーションを付与。

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync // 非同期処理を有効化
public class AsyncConfig {
    // 必要に応じて TaskExecutor のカスタマイズ Bean を定義
    /*
    @Bean(name = "taskExecutor")
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
    */
}
        

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class EmailService {

    @Async // このメソッドは別のスレッドで実行される
    public void sendWelcomeEmail(String toAddress) {
        System.out.println("Sending welcome email to " + toAddress + " on thread: " + Thread.currentThread().getName());
        // 時間のかかるメール送信処理 (例)
        try {
            Thread.sleep(2000); // 2秒待機
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Email sent to " + toAddress);
    }

    @Async("taskExecutor") // 使用する TaskExecutor Bean を指定する場合
    public CompletableFuture<Boolean> checkEmailStatus(String emailId) {
        System.out.println("Checking email status for " + emailId + " on thread: " + Thread.currentThread().getName());
        // 外部API呼び出しなどの時間のかかる処理
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.completedFuture(false);
        }
        boolean success = Math.random() > 0.5; // ダミーの結果
        return CompletableFuture.completedFuture(success);
    }
}

// 呼び出し側
@RestController
public class UserController {
    @Autowired private EmailService emailService;

    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@RequestBody UserRegistrationRequest request) {
        // ... ユーザー登録処理 ...

        // メール送信は非同期で実行 (呼び出し元は待たない)
        emailService.sendWelcomeEmail(request.getEmail());

        // 結果が必要な非同期処理
        CompletableFuture<Boolean> statusFuture = emailService.checkEmailStatus("some-id");
        // 他の処理を進める...
        // ...
        // 結果が必要になったら待機 (または非同期でハンドリング)
        // try {
        //     Boolean status = statusFuture.get(); // 結果を同期的に取得 (ブロックする)
        //     System.out.println("Email status check result: " + status);
        // } catch (InterruptedException | ExecutionException e) {
        //     // エラーハンドリング
        // }

        return ResponseEntity.ok("User registered, welcome email sending started.");
    }
}
        

注意点

• @Async メソッドは public である必要があります。
• 同じクラス内のメソッドから @Async メソッドを呼び出しても非同期にはなりません (プロキシ経由で呼び出される必要がある)。別クラスに切り出すか、自身をインジェクションするなどの工夫が必要です。
• 戻り値が void の場合、例外は呼び出し元に伝播しません。例外ハンドリングには AsyncUncaughtExceptionHandler を実装します。
• 戻り値が Future, CompletableFuture, または ListenableFuture の場合、呼び出し元で結果や例外を取得できます。
• デフォルトでは SimpleAsyncTaskExecutor が使用されますが、スレッドを再利用しないため、本番環境では ThreadPoolTaskExecutor などでスレッドプールを設定することが推奨されます。