JavaのServiceが肥大化した時にクラスを分ける基準を解説する記事のアイキャッチ。Java道場風の学習空間で若手エンジニアが設計を考えるイラスト。

設計・テスト・レビュー

SpringのServiceが肥大化したらどこで分ける?計算・保存・通知の分割例

Serviceを分けるときは、計算や通知を独立した担当へ移し、注文処理の順序とトランザクションの入口をServiceに残します。クラスの数を増やすことより、割引変更ならどこを直し、メール変更ならどこを直すかを説明できることが目的です。

この記事では、動いている注文登録を分割します。割引計算だけを変えたいのに保存や在庫更新まで読む必要がある場面を題材に、分割前と分割後へ同じ入力を渡し、結果と副作用を比較します。架空の学習用コードであり、実際の業務システムの再現ではありません。

この記事でわかること
  • Serviceに残す処理と、計算・通知クラスへ移す処理
  • 分割で保存・在庫・監査ログを落とさないための比較方法
  • メール送信はDBのロールバックでは取り消せないこと

分割前・分割後・テストの全文はこちら

Java 17、Maven 3.9.5で確認。Spring Framework 6.2.19、JUnit 5.12.2、H2 2.3.232を使います。ZIPには実装6ファイル、テスト、pom.xml、README、LICENSEを含めます。通知は記録する偽実装です。実際のメールは送りません。

GitHubで全文を見る 実行用ZIPをダウンロード

初回実行には依存ライブラリの取得が必要です。既存キャッシュでのオフライン実行を確認しています。ZIPを展開し、pom.xmlのある場所で mvn test を実行してください。

分ける前に、変えてはいけない動作を決める

注文処理は「計算結果が同じ」だけで同じ動作にはなりません。監査ログが消えたり、在庫が減る前にメールを送ったりすれば、分割と一緒に仕様まで変わっています。まず固定するのは、次の契約です。

  1. 顧客を取得し、指定された順に商品を取得する。
  2. 商品価格を合計し、プレミアム会員なら小計の10%を整数除算で割り引く。
  3. 商品ごとに在庫を確認し、1個ずつ減らす。
  4. 注文を1回保存する。
  5. 受付メールを1回送り、その後にORDER_CREATEDの監査記録を1回保存する。
  6. 注文IDを返す。途中でRuntimeExceptionが外へ出たら、同じトランザクション内のDB変更を戻す。

サンプルでは存在する顧客1人と、重複しない商品IDを指定順に渡します。商品は1種類につき1個、価格は非負で合計がintに収まる前提です。未存在顧客・未存在商品・重複ID・並行注文は扱いません。実案件ではこれらの仕様を先に決めます。この前提を黙って分割の途中へ足すと、何を直したのか分からなくなります。

1,000円と2,000円の商品なら、小計3,000円、割引300円、請求2,700円です。一般会員なら3,000円です。テストでは、この固定した値を使います。分割前の計算結果をそのまま「正解」として分割後に渡すだけの比較にはしません。

Before:注文処理に、計算と通知の具体的な手順が混ざっている

BeforeOrderService.javaの全文です。OrderPortsは取得・保存・外部送信の呼出し口です。テストでは、その先を実DBへの操作と送信記録へ接続します。

package info.syachiku.sample;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import info.syachiku.sample.OrderData.*;
@Service
public class BeforeOrderService {
    private final OrderPorts ports;
    public BeforeOrderService(OrderPorts ports) { this.ports = ports; }
    @Transactional
    public long placeOrder(Request request) {
        Customer customer = ports.findCustomer(request.customerId());
        var products = ports.findProducts(request.productIds());
        int subtotal = products.stream().mapToInt(Product::price).sum();
        int discount = customer.premium() ? subtotal / 10 : 0;
        int total = subtotal - discount;
        for (Product product : products) {
            if (product.stock() <= 0) throw new IllegalStateException("out-of-stock:" + product.id());
            ports.decreaseStock(product);
        }
        long orderId = ports.save(customer.id(), total);
        ports.sendOrderAccepted(customer.email(), orderId);
        ports.writeAudit("ORDER_CREATED", orderId);
        return orderId;
    }
}

この処理を「長いから10行ずつ切る」と考えると、subtotalやdiscountなど途中の値を引数で受け渡すだけのメソッドが増えます。ここでは、金額を求める仕事は顧客と商品一覧から料金内訳を返すと説明できます。受付通知は顧客と注文IDから通知を送るです。それぞれを名前と入出力で区切ります。

反対に、在庫を減らし、注文を保存し、通知し、監査を残すという進行は、この注文ユースケースの約束です。個々のクラスへ散らして順序が追えなくなるような分割は避けます。

割引の変更を閉じ込める:料金計算は値を返す

プレミアム割引を変更する要求は、メール文面の変更とは別に起きます。料金計算をOrderPriceCalculatorへ移し、途中のsubtotal・discount・totalをPriceとして返します。ここでDB保存や通知を行わないため、計算だけを入力と出力で検証できます。

package info.syachiku.sample;
import java.util.List;
import org.springframework.stereotype.Component;
import info.syachiku.sample.OrderData.*;
@Component
public class OrderPriceCalculator {
    public Price calculate(Customer customer, List<Product> products) {
        int subtotal = products.stream().mapToInt(Product::price).sum();
        int discount = customer.premium() ? subtotal / 10 : 0;
        return new Price(subtotal, discount, subtotal - discount);
    }
}

Priceは料金内訳をまとめるrecordです。OrderData.javaに定義しています。計算クラスを呼んだ後にServiceが合計を再計算すると、どちらが請求額を決めるのか曖昧になります。Serviceでは戻されたtotalを保存へ渡します。

入力と料金内訳の型を全文で見る
package info.syachiku.sample;
import java.util.List;
public final class OrderData {
    private OrderData() {}
    public record Customer(long id, boolean premium, String email) {}
    public record Product(long id, int price, int stock) {}
    public record Request(long customerId, List<Long> productIds) {}
    public record Price(int subtotal, int discount, int total) {}
}

「将来どこでも使える計算基盤」を先に作る必要はありません。今回は、割引の規則を変更するときに開く場所を一つにするだけです。画面の表示形式やRepositoryをこのクラスへ足すと、分けた変更理由が再び混ざります。

通知は別クラスへ移しても、呼ぶ位置は変えない

通知の担当をOrderNotifierにします。今回の目的は通知先の具体的な呼出しをServiceから外すことです。タイミングを保存前へ移したり、別スレッドへ送ったり、失敗を握りつぶしたりはしません。それらは別の仕様変更です。

package info.syachiku.sample;
import org.springframework.stereotype.Component;
import info.syachiku.sample.OrderData.Customer;
@Component
public class OrderNotifier {
    private final OrderPorts ports;
    public OrderNotifier(OrderPorts ports) { this.ports = ports; }
    public void notifyAccepted(Customer customer, long orderId) {
        ports.sendOrderAccepted(customer.email(), orderId);
    }
}

小さいクラスでも、メール文面や送信窓口を変更する担当として名前が付くなら意味があります。一方、今のprivateメソッドで十分追えるコードまで、すべて別クラスにする必要はありません。判断は行数ではなく、他の処理と独立して変わる規則かどうかです。

関連記事Javaのメソッド分割の基準|privateに切るか、別クラスにするか Springを使う前の分割判断を確認するなら。privateメソッドに止めるか、別クラスにするかを同じJavaコードで比べます。 記事を読む

After:Serviceには順序とトランザクションの入口を残す

AfterOrderService.javaの全文です。Beforeと見比べる点は、計算の呼出しと通知の呼出しだけです。在庫の判定・更新、注文保存、監査ログは消していません。

package info.syachiku.sample;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import info.syachiku.sample.OrderData.*;
@Service
public class AfterOrderService {
    private final OrderPorts ports;
    private final OrderPriceCalculator calculator;
    private final OrderNotifier notifier;
    public AfterOrderService(OrderPorts ports, OrderPriceCalculator calculator, OrderNotifier notifier) {
        this.ports = ports; this.calculator = calculator; this.notifier = notifier;
    }
    @Transactional
    public long placeOrder(Request request) {
        Customer customer = ports.findCustomer(request.customerId());
        var products = ports.findProducts(request.productIds());
        Price price = calculator.calculate(customer, products);
        for (Product product : products) {
            if (product.stock() <= 0) throw new IllegalStateException("out-of-stock:" + product.id());
            ports.decreaseStock(product);
        }
        long orderId = ports.save(customer.id(), price.total());
        notifier.notifyAccepted(customer, orderId);
        ports.writeAudit("ORDER_CREATED", orderId);
        return orderId;
    }
}

Serviceの役割は「料金を計算しない」ことだけではありません。計算を依頼した後に在庫を確認し、保存した注文IDで通知し、監査を残すという進行を保持します。@Transactionalも、外から呼ばれるplaceOrderに残します。

この例ではSpringが生成したプロキシを通してplaceOrderを呼びます。new AfterOrderService(...)だけで作ったオブジェクトでは、アノテーションを書いてもトランザクションは始まりません。同じクラス内からの自己呼出しにも注意が必要です。この記事ではアノテーションを付けたコードだけを見せて「戻るはず」とせず、実際のSpringコンテナとH2で確かめます。

分割後に依存先が増えること自体は費用です。小さい注文処理で変更理由も一つなら、privateメソッドへの抽出で止める選択があります。割引と通知の変更が別にあり、テストや担当を独立させたいから分ける、と説明できる範囲でクラスを増やします。

DBが戻っても、送ったメールは戻らない

保存の後で通知すると、失敗時の振る舞いまで理解する必要があります。サンプルのメール失敗は「送信記録を付ける前に失敗する」条件です。実ネットワークの「送れたが応答だけ不明」を再現していません。

条件DB終了後送信記録
通常成功在庫減少・注文1件・監査1件1件
2個目が在庫不足1個目の在庫更新も戻る。注文・監査0件0件
注文保存で失敗在庫更新が戻る。注文・監査0件0件
メール送信前に失敗在庫・注文が戻る。監査0件0件
メール成功後、監査で失敗在庫・注文が戻る。監査0件1件残る

最後の行は「分割後に新しく起きたバグ」ではなく、Beforeから持っていた契約です。分割で保つ動作と、業務として望ましい動作を分けて評価します。メールとDBを一つの原子的処理として扱いたい場合、このクラス分割だけでは解決しません。

実案件では、通知をいつ確定するか、失敗後にどう再送するか、重複送信をどう扱うかを別途設計します。AFTER_COMMITへの移動やoutbox導入を、動作を保つ分割に紛れ込ませないことが重要です。今回はどちらも実装していません。H2で成功しても、本番DBのロックや分離レベル、並行時の在庫競合までは保証しません。

利用者に500が返ったら、再送の前に注文と通知の結果を別々に確認します。 注文番号や受付IDで注文を照合し、保存済みなら通知の送信記録を見て、通知だけをやり直せるか判断します。注文が0件でも、この章の監査失敗のように送信記録が残ることがあります。

別のHTTP実習では、通知処理を失敗させ、POSTが500で返った後に別のGETで注文を読みます。保存を先にコミットした経路は1件、保存と通知を同じトランザクションで実行した経路は0件です。同じ X-Request-Id で個別コミットのPOSTをもう一度送ると、注文は2件になります。再送するときは、業務上の受付IDで同じ注文の二重登録を防ぐ仕様があるか確認します。

実践|500と再送Spring Bootで500エラーが出たら|再実行する前にログと更新結果を確認する 同じ500を返す2つの経路を、別GETで照合します。通知に失敗しても注文が残る条件を、HTTP応答と保存件数で確認できます。 記事を読む

結果だけでなく、順番・回数・終了後のDBを比べる

テストはBeforeとAfterへ同じ条件を与えます。ただし片方をもう片方の正解にせず、上の契約から書いた期待値にそれぞれ照合します。正常なプレミアム会員、一般会員、在庫不足、保存失敗、メール失敗、監査失敗の6条件を2版で実行し12件、料金内訳の検証2件を加え、計14件です。

呼出しの記録では、通常のプレミアム会員は customer → products → stock:10 → stock:20 → save:2700 → mail:100 → audit:100 です。ID100はDB採番の仕様ではなく、このサンプルの固定値です。採番値の連続性やロールバック後の再利用は検証していません。

テスト自身には@Transactionalを付けません。SpringのServiceプロキシから戻った後、新しい読み取りでH2の在庫、注文、監査を調べます。テスト全体を一つのトランザクションで囲むと、Serviceが本当にコミット/ロールバックしたかの確認にならないためです。

14件を実行するテスト・H2設定・呼出し記録の全文
package info.syachiku.sample;
import java.util.*;
import java.util.function.Function;
import javax.sql.DataSource;
import org.h2.jdbcx.JdbcDataSource;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.springframework.context.annotation.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import info.syachiku.sample.OrderData.*;
import static org.junit.jupiter.api.Assertions.*;
class ServiceSplittingTest {
    @Configuration @EnableTransactionManagement
    static class Config {
        @Bean DataSource dataSource() {
            var ds = new JdbcDataSource();
            ds.setURL("jdbc:h2:mem:" + UUID.randomUUID() + ";DB_CLOSE_DELAY=-1");
            return ds;
        }
        @Bean JdbcTemplate jdbc(DataSource ds) { return new JdbcTemplate(ds); }
        @Bean PlatformTransactionManager transactionManager(DataSource ds) { return new DataSourceTransactionManager(ds); }
        @Bean LabPorts ports(JdbcTemplate jdbc) { return new LabPorts(jdbc); }
        @Bean BeforeOrderService before(LabPorts p) { return new BeforeOrderService(p); }
        @Bean OrderPriceCalculator calculator() { return new OrderPriceCalculator(); }
        @Bean OrderNotifier notifier(LabPorts p) { return new OrderNotifier(p); }
        @Bean AfterOrderService after(LabPorts p, OrderPriceCalculator c, OrderNotifier n) { return new AfterOrderService(p,c,n); }
    }
    static class LabPorts implements OrderPorts {
        final JdbcTemplate db;
        final List<String> calls = new ArrayList<>();
        final List<Long> sent = new ArrayList<>();
        String failure = "none";
        LabPorts(JdbcTemplate db) { this.db=db; }
        public Customer findCustomer(long id) {
            calls.add("customer");
            return db.queryForObject("select id,premium,email from customers where id=?", (r,n)->new Customer(r.getLong(1),r.getBoolean(2),r.getString(3)),id);
        }
        public List<Product> findProducts(List<Long> ids) {
            calls.add("products");
            return ids.stream().map(id->db.queryForObject("select id,price,stock from products where id=?",(r,n)->new Product(r.getLong(1),r.getInt(2),r.getInt(3)),id)).toList();
        }
        public void decreaseStock(Product p) { calls.add("stock:"+p.id()); db.update("update products set stock=stock-1 where id=?",p.id()); }
        public long save(long id,int total) {
            calls.add("save:"+total);
            if (failure.equals("save")) throw new IllegalStateException("save failed");
            db.update("insert into orders values(100,?,?)",id,total); return 100;
        }
        public void sendOrderAccepted(String email,long id) {
            calls.add("mail:"+id);
            if (failure.equals("mail")) throw new IllegalStateException("mail failed");
            sent.add(id);
        }
        public void writeAudit(String event,long id) {
            calls.add("audit:"+id);
            if (failure.equals("audit")) throw new IllegalStateException("audit failed");
            db.update("insert into audit_log values(?,?)",event,id);
        }
    }
    @ParameterizedTest
    @CsvSource({"before,none,true,2,2700", "after,none,true,2,2700", "before,none,false,2,3000", "after,none,false,2,3000", "before,stock,true,0,2700", "after,stock,true,0,2700", "before,save,true,2,2700", "after,save,true,2,2700", "before,mail,true,2,2700", "after,mail,true,2,2700", "before,audit,true,2,2700", "after,audit,true,2,2700"})
    void preservesContract(String version,String failure,boolean premium,int secondStock,int total) {
        try (var ctx=new AnnotationConfigApplicationContext(Config.class)) {
            var db=ctx.getBean(JdbcTemplate.class); var p=ctx.getBean(LabPorts.class);
            db.execute("create table customers(id bigint primary key,premium boolean,email varchar(100))");
            db.execute("create table products(id bigint primary key,price int,stock int)");
            db.execute("create table orders(id bigint primary key,customer_id bigint,total int)");
            db.execute("create table audit_log(event varchar(40),order_id bigint)");
            db.update("insert into customers values(1,?,'sample@example.test')",premium);
            db.update("insert into products values(10,1000,2),(20,2000,?)",secondStock);
            p.failure=failure;
            Function<Request,Long> operation=version.equals("before")?ctx.getBean(BeforeOrderService.class)::placeOrder:ctx.getBean(AfterOrderService.class)::placeOrder;
            var request=new Request(1,List.of(10L,20L));
            if (failure.equals("none")) assertEquals(100L,operation.apply(request));
            else assertEquals(failure.equals("stock")?"out-of-stock:20":failure+" failed",assertThrows(IllegalStateException.class,()->operation.apply(request)).getMessage());
            var expected=new ArrayList<>(List.of("customer","products","stock:10"));
            if (!failure.equals("stock")) {
                expected.add("stock:20"); expected.add("save:"+total);
                if (!failure.equals("save")) {
                    expected.add("mail:100");
                    if (!failure.equals("mail")) expected.add("audit:100");
                }
            }
            assertEquals(expected,p.calls,"fixed call order and count");
            boolean ok=failure.equals("none");
            assertEquals(ok?1:2,db.queryForObject("select stock from products where id=10",Integer.class));
            assertEquals(ok?secondStock-1:secondStock,db.queryForObject("select stock from products where id=20",Integer.class));
            assertEquals(ok?1:0,db.queryForObject("select count(*) from orders",Integer.class));
            assertEquals(ok?1:0,db.queryForObject("select count(*) from audit_log",Integer.class));
            assertEquals(ok||failure.equals("audit")?List.of(100L):List.of(),p.sent,"external mail is not rolled back");
            if (ok) assertEquals(total,db.queryForObject("select total from orders where id=100",Integer.class));
        }
    }
    @Test void calculatorReturnsBreakdown() {
        assertEquals(new Price(3000,300,2700),new OrderPriceCalculator().calculate(new Customer(1,true,"x"),List.of(new Product(10,1000,2),new Product(20,2000,2))));
    }
    @Test void discountIsTruncatedBeforeSubtracting() {
        assertEquals(new Price(1001,100,901),new OrderPriceCalculator().calculate(new Customer(1,true,"x"),List.of(new Product(10,1001,2))));
    }
}
取得・保存・通知の呼出し口の全文
package info.syachiku.sample;
import java.util.List;
import info.syachiku.sample.OrderData.*;
public interface OrderPorts {
    Customer findCustomer(long id);
    List<Product> findProducts(List<Long> ids);
    void decreaseStock(Product product);
    long save(long customerId, int total);
    void sendOrderAccepted(String email, long orderId);
    void writeAudit(String event, long orderId);
}

実行結果は Tests run: 14, Failures: 0, Errors: 0, Skipped: 0 です。さらにAfterの監査呼出しを一時的に削除して、テストが失敗することを確認しました。監査を消したままでも通るテストを「分割の安全確認」にしないためです。元へ戻した後、14件すべての成功を再確認しています。小計1,001円なら割引は100円、請求は901円です。先に総額へ90%を掛けると900円となり、整数除算の位置で結果が変わります。この誤変更もテストで失敗することを確認しました。

レビューでは「何を移し、何を保ったか」を説明する

「Serviceが長いので分けました」だけでは、変更の妥当性が伝わりません。今回なら次のように説明できます。

割引変更と通知変更を別々に扱えるように、計算をOrderPriceCalculator、通知をOrderNotifierへ移しました。注文保存の前後関係、在庫更新、監査ログ、トランザクションの入口は維持しています。通常・失敗時を両版で検証しました。通知とDBの原子性は、この変更では解決していません。

これなら、レビューする人は「料金だけ変えたいときにどこを見るか」と「今回どの振る舞いが変わっていないか」を確認できます。変更していないことを主張するだけでなく、監査失敗後の送信記録まで、コードとテストで根拠を残します。

  • 計算や通知を移す理由を、一文で説明できるか。
  • 入力・料金・例外条件を、分割ついでに変えていないか。
  • 在庫・保存・通知・監査の順番と回数が揃っているか。
  • 実際のプロキシ経由で呼び、終了後のDBを調べたか。
  • 外部副作用までロールバックされたと誤解させていないか。
学習ガイド|クラス設計Javaのクラス設計は何から学ぶ?最初の1冊と「どこに書くか」の考え方 送料無料の条件とレシートの文言を別々に変え、どのクラスを直すかを比べます。何が別々に変わるかを手がかりに、クラスを分ける理由を整理できます。 記事を読む

クラスへ仕事を任せる考え方をさらに整理したい場合は、次の設計入門書が補助になります。この記事の分割例を説明できるようになってから、他のコードでも「そのクラスへ置く理由」を考えてみてください。

書籍「改訂新版 良いコード/悪いコードで学ぶ設計入門」の表紙
商品画像:Amazon.co.jp
PR Java新人・若手向け

改訂新版 良いコード/悪いコードで学ぶ設計入門

仙塲 大也 (著)

レビューで直される理由を、Javaの具体例から理解する。

命名、責務、クラス設計、不変性などを良い例と悪い例で比較できます。現場のコードレビューと結びつけやすい一冊です。

  • 設計の悪さを具体例から学びたい
  • レビュー指摘の判断軸を増やしたい

当サイトはAmazonアソシエイト・プログラムの参加者です。価格・在庫・配送条件はAmazonでご確認ください。

関連記事Spring Bootの@Transactionalはどこに付ける? 保存と在庫更新を同じ範囲で戻したいときに。トランザクションを置く場所と、自己呼出しの注意を確認できます。 記事を読む 関連記事Spring BootのServiceをJUnit・Mockitoでテストする方法|Repositoryをモックする基本 Serviceの依存先を置き換えるテストを学ぶなら。Repositoryをモックし、戻り値と呼出しを確かめます。 記事を読む

Service分割は、変更理由を分けながら注文の約束を保つ

料金の規則と通知の具体処理を別クラスへ移すと、それぞれの変更場所を説明しやすくなります。Serviceには、注文処理の進行とトランザクションの入口を残します。保存や監査を落とさず、通常時だけでなく途中失敗の結果も比較してから、動作を保った分割と判断します。

-設計・テスト・レビュー
-, ,