サービスクラスとは – サービスクラスの定義や概要

サービスクラスとは – サービスクラスの定義や概要

サービスクラスとは、アプリケーション内でビジネスロジックをまとめる役割を持つクラスのことを指します。
これにより、コードの再利用性が高まり、メンテナンスが容易になります。
サービスクラスは、通常、データの操作や計算、外部サービスとの連携など、コントローラーやモデルクラスから切り離された処理を担当します。

サービスクラスの基本的な役割と定義

サービスクラスの主な役割は、ビジネスロジックを集中管理することです。
これにより、複雑なロジックを一箇所に集約し、他の部分から独立させることができます。
例えば、ユーザー認証や注文処理などの共通のビジネスロジックは、サービスクラスにまとめて実装されます。

public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User findUserById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

この例では、`UserService`クラスがユーザーのデータ操作を担当しています。

サービスクラスがなぜ重要か

サービスクラスは、コードのモジュール化と分離を促進します。
これにより、異なる開発者が同時に作業することが容易になり、変更が必要な場合にも特定の部分だけを変更すればよいので、システム全体の安定性が向上します。
また、サービスクラスを使用することで、ビジネスロジックのテストが容易になり、アプリケーションの品質向上に寄与します。

サービスクラスの利用シーンと例

サービスクラスは、多くのアプリケーションで利用されます。
例えば、eコマースサイトでは、注文処理、在庫管理、ユーザー管理などのビジネスロジックをサービスクラスにまとめることで、これらの処理を一元管理できます。
以下に、注文処理を担当するサービスクラスの例を示します。

public class OrderService {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;

    public OrderService(OrderRepository orderRepository, InventoryService inventoryService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
    }

    public Order createOrder(Order order) {
        if (inventoryService.checkStock(order)) {
            orderRepository.save(order);
            return order;
        } else {
            throw new OutOfStockException("Product is out of stock");
        }
    }
}

サービスクラスの歴史と進化

サービスクラスの概念は、ソフトウェア開発の歴史とともに進化してきました。
初期のソフトウェア開発では、ビジネスロジックがスパゲッティコードのように分散していましたが、オブジェクト指向プログラミングの普及とともに、コードの分離と再利用性が重要視されるようになりました。
その結果、サービスクラスのような設計パターンが生まれ、現在では多くのフレームワークやライブラリで標準的に採用されています。

サービスクラスの導入方法と初期設定

サービスクラスを導入するには、まず適切なクラス設計が重要です。
クラスの責任を明確にし、必要な依存関係を注入することで、クラスの再利用性とテストの容易さを確保します。
以下に、Springフレームワークを使用したサービスクラスの導入方法を示します。

@Service
public class PaymentService {
    private final PaymentRepository paymentRepository;

    @Autowired
    public PaymentService(PaymentRepository paymentRepository) {
        this.paymentRepository = paymentRepository;
    }

    public Payment processPayment(Payment payment) {
        // ビジネスロジックを実装
        return paymentRepository.save(payment);
    }
}

Springの`@Service`アノテーションを使用することで、このクラスがサービスクラスであることを宣言し、依存性注入（DI）を活用して依存関係を管理します。

ビジネスロジックの書き方 – サービスクラスにおける具体的な実装方法

サービスクラスにおいてビジネスロジックをどのように実装するかは、アプリケーションの成功にとって非常に重要です。
ビジネスロジックは、アプリケーションの機能を実現するための中心的な部分であり、これを効率的かつ効果的に実装することで、アプリケーションの品質と保守性を向上させることができます。

ビジネスロジックの基本概念

ビジネスロジックは、アプリケーションが実行する具体的な業務処理の集合です。
これには、データの検証、計算、データベース操作、外部サービスとの通信などが含まれます。
ビジネスロジックは、プレゼンテーション層やデータアクセス層から独立して実装されるべきであり、そのためにサービスクラスが利用されます。

public class ProductService {
    public boolean isProductAvailable(Product product) {
        return product.getStock() > 0;
    }
}

この例では、`ProductService`クラスが商品の在庫確認というビジネスロジックを実装しています。

サービスクラスにおけるビジネスロジックの書き方

サービスクラスにビジネスロジックを実装する際は、以下のポイントに注意することが重要です：

– 単一責任原則（SRP）を守る
– コードの再利用性を考慮する
– 依存関係を適切に管理する

以下に、ユーザー登録を行うサービスクラスの例を示します。

public class RegistrationService {
    private final UserRepository userRepository;
    private final EmailService emailService;

    public RegistrationService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }

    public User registerUser(User user) {
        if (userRepository.existsByEmail(user.getEmail())) {
            throw new UserAlreadyExistsException("User already exists");
        }
        User newUser = userRepository.save(user);
        emailService.sendWelcomeEmail(newUser);
        return newUser;
    }
}

ビジネスロジックの例とその応用

ビジネスロジックの応用例として、注文処理や在庫管理、支払い処理などが挙げられます。
以下に、注文処理を行うサービスクラスの詳細な例を示します。

public class OrderProcessingService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;

    public OrderProcessingService(OrderRepository orderRepository, PaymentService paymentService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
    }

    public Order processOrder(Order order) {
        if (paymentService.processPayment(order.getPayment())) {
            return orderRepository.save(order);
        } else {
            throw new PaymentFailedException("Payment processing failed");
        }
    }
}

サービスクラスでのエラーハンドリング

サービスクラスでは、ビジネスロジックの実行中に発生するエラーを適切に処理することが求められます。
エラーハンドリングを正しく実装することで、システムの安定性と信頼性が向上します。
以下に、例を示します。

public class InventoryService {
    public void checkAndReduceStock(Product product, int quantity) {
        if (product.getStock() < quantity) {
            throw new InsufficientStockException("Insufficient stock for product: " + product.getName());
        }
        product.reduceStock(quantity);
    }
}

リファクタリングとベストプラクティス

ビジネスロジックを実装した後も、継続的にコードをリファクタリングすることが重要です。
これにより、コードの品質と可読性が向上し、長期的な保守が容易になります。
また、設計パターンやベストプラクティスを活用することで、より堅牢で拡張性の高いコードを実現できます。

コントローラーとの関係 – 依存性注入とその役割

サービスクラスは、コントローラーと密接に連携して動作します。
コントローラーはユーザーからの入力を受け取り、その入力を基にサービスクラスのメソッドを呼び出してビジネスロジックを実行します。
この連携により、コントローラーの責務を軽減し、コードの保守性と再利用性を向上させます。

コントローラーとサービスクラスの連携

コントローラーは、サービスクラスを利用してビジネスロジックを実行します。
例えば、ユーザー登録の処理はコントローラーからサービスクラスに委譲されます。

@RestController
public class UserController {
    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping("/register")
    public ResponseEntity<User> registerUser(@RequestBody User user) {
        User registeredUser = userService.registerUser(user);
        return new ResponseEntity<>(registeredUser, HttpStatus.CREATED);
    }
}

依存性注入の基本概念とその利点

依存性注入（Dependency Injection, DI）は、オブジェクトの生成とその依存関係を外部から注入するデザインパターンです。
これにより、コードの結合度が低下し、テストが容易になります。
DIの利点には、コードのモジュール化、依存関係の明示化、テストの容易さなどが挙げられます。

@Service
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User registerUser(User user) {
        // ビジネスロジック
    }
}

DIコンテナの設定と使用方法

DIコンテナは、依存性注入を管理するためのフレームワークです。
Spring Frameworkは、その代表例です。
Springでは、アノテーションを使って簡単にDIを実装できます。

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

コントローラーでのサービスクラスの利用例

コントローラーでサービスクラスを利用することで、ビジネスロジックをコントローラーから分離し、コードの可読性と再利用性を向上させます。
以下にその例を示します。

@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderService orderService;

    @Autowired
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        Order createdOrder = orderService.createOrder(order);
        return new ResponseEntity<>(createdOrder, HttpStatus.CREATED);
    }
}

依存性注入によるテストの容易さ

依存性注入により、サービスクラスのテストが容易になります。
モックオブジェクトを使用して依存関係を注入することで、サービスクラスのユニットテストを簡単に実行できます。

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    public void testRegisterUser() {
        User user = new User("test@example.com");
        when(userRepository.save(user)).thenReturn(user);

        User registeredUser = userService.registerUser(user);

        assertEquals("test@example.com", registeredUser.getEmail());
    }
}

サービスクラスのメリット – サービスクラスの利点と利便性

サービスクラスの利用には多くのメリットがあります。
これらのメリットにより、アプリケーションの開発、保守、拡張が容易になり、開発チーム全体の生産性が向上します。

コードの再利用性とメンテナンス性の向上

サービスクラスを使用することで、ビジネスロジックを一箇所に集約できます。
これにより、コードの再利用性が向上し、同じロジックを複数の場所で重複して実装する必要がなくなります。
また、変更が必要な場合も、サービスクラスだけを修正すればよいため、メンテナンス性が大幅に向上します。

public class ProductService {
    public boolean isProductAvailable(Product product) {
        return product.getStock() > 0;
    }
}

ビジネスロジックの分離とその利点

ビジネスロジックをサービスクラスに分離することで、コントローラーやモデルクラスの責務を明確に分けることができます。
これにより、各クラスの役割が明確になり、コードの理解と保守が容易になります。

@RestController
public class ProductController {
    private final ProductService productService;

    @Autowired
    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping("/products/{id}")
    public ResponseEntity<Product> getProduct(@PathVariable Long id) {
        Product product = productService.findProductById(id);
        return new ResponseEntity<>(product, HttpStatus.OK);
    }
}

テストの容易さとその重要性

サービスクラスを使用することで、ビジネスロジックのテストが容易になります。
モックを使用して依存関係を注入することで、各メソッドの動作を個別にテストできます。
これにより、バグの早期発見と修正が可能になり、アプリケーションの品質が向上します。

@RunWith(MockitoJUnitRunner.class)
public class ProductServiceTest {
    @Mock
    private ProductRepository productRepository;

    @InjectMocks
    private ProductService productService;

    @Test
    public void testIsProductAvailable() {
        Product product = new Product("Test Product", 10);
        when(productRepository.findById(anyLong())).thenReturn(Optional.of(product));

        boolean isAvailable = productService.isProductAvailable(product);

        assertTrue(isAvailable);
    }
}

アプリケーションのスケーラビリティ

サービスクラスを利用することで、アプリケーションのスケーラビリティが向上します。
ビジネスロジックを一箇所に集約することで、処理の最適化が容易になり、負荷分散や分散処理が可能になります。
これにより、大規模なシステムでも高いパフォーマンスを維持できます。

パフォーマンス向上のための最適化

サービスクラスを利用することで、ビジネスロジックの最適化が容易になります。
複数のクラスやメソッドに分散しているロジックを一箇所に集約することで、処理の効率化が可能になります。
また、キャッシュの導入やデータベースアクセスの最適化など、パフォーマンス向上のための対策も実施しやすくなります。

@Service
public class ProductService {
    private final ProductRepository productRepository;
    private final CacheManager cacheManager;

    @Autowired
    public ProductService(ProductRepository productRepository, CacheManager cacheManager) {
        this.productRepository = productRepository;
        this.cacheManager = cacheManager;
    }

    public Product findProductById(Long id) {
        Cache cache = cacheManager.getCache("products");
        Product product = cache.get(id, Product.class);
        if (product == null) {
            product = productRepository.findById(id).orElseThrow(() -> new ProductNotFoundException("Product not found"));
            cache.put(id, product);
        }
        return product;
    }
}

サービスクラスの実装例 – 実際のコードサンプルと説明

サービスクラスの実装例を通じて、具体的なコードの書き方とその活用方法を学びます。
ここでは、基本的なサービスクラスの実装から、CRUD操作、トランザクション管理、依存性注入を利用した高度な実装例までを紹介します。

基本的なサービスクラスの実装例

基本的なサービスクラスの実装は、単純なビジネスロジックをカプセル化することから始めます。
以下の例では、ユーザーを管理するための基本的なサービスクラスを示します。

@Service
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User findUserById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new UserNotFoundException("User not found"));
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }
}

この例では、`UserService`クラスがユーザーの検索と保存を担当しています。

CRUD操作を行うサービスクラスの例

CRUD操作（作成、読み取り、更新、削除）は、ほとんどのアプリケーションで必要とされる基本的な操作です。
以下に、これらの操作を行うサービスクラスの例を示します。

@Service
public class ProductService {
    private final ProductRepository productRepository;

    @Autowired
    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public Product createProduct(Product product) {
        return productRepository.save(product);
    }

    public Product getProductById(Long id) {
        return productRepository.findById(id).orElseThrow(() -> new ProductNotFoundException("Product not found"));
    }

    public Product updateProduct(Long id, Product productDetails) {
        Product product = getProductById(id);
        product.setName(productDetails.getName());
        product.setPrice(productDetails.getPrice());
        return productRepository.save(product);
    }

    public void deleteProduct(Long id) {
        Product product = getProductById(id);
        productRepository.delete(product);
    }
}

この例では、`ProductService`クラスが商品に対するCRUD操作を実装しています。

トランザクション管理を含むサービスクラスの例

トランザクション管理は、データの一貫性を保つために重要です。
Springでは、`@Transactional`アノテーションを使用して簡単にトランザクション管理を行うことができます。

@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;

    @Autowired
    public OrderService(OrderRepository orderRepository, InventoryService inventoryService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
    }

    @Transactional
    public Order createOrder(Order order) {
        inventoryService.reduceStock(order.getProduct(), order.getQuantity());
        return orderRepository.save(order);
    }
}

この例では、`OrderService`クラスが注文作成時に在庫を減らす処理をトランザクション管理下で実行しています。

依存性注入を使用したサービスクラスの実装

依存性注入を使用することで、サービスクラスは他のクラスに依存することなく、独立してテストが可能になります。
以下にその例を示します。

@Service
public class PaymentService {
    private final PaymentRepository paymentRepository;
    private final NotificationService notificationService;

    @Autowired
    public PaymentService(PaymentRepository paymentRepository, NotificationService notificationService) {
        this.paymentRepository = paymentRepository;
        this.notificationService = notificationService;
    }

    public Payment processPayment(Payment payment) {
        Payment processedPayment = paymentRepository.save(payment);
        notificationService.sendPaymentConfirmation(payment);
        return processedPayment;
    }
}

この例では、`PaymentService`クラスが支払い処理と通知送信を担当しています。

実運用でのサービスクラスの使用例

実運用環境でサービスクラスを使用する際には、パフォーマンスやスケーラビリティの観点も考慮する必要があります。
以下に、キャッシュを利用したサービスクラスの例を示します。

@Service
public class ProductService {
    private final ProductRepository productRepository;
    private final CacheManager cacheManager;

    @Autowired
    public ProductService(ProductRepository productRepository, CacheManager cacheManager) {
        this.productRepository = productRepository;
        this.cacheManager = cacheManager;
    }

    public Product findProductById(Long id) {
        Cache cache = cacheManager.getCache("products");
        Product product = cache.get(id, Product.class);
        if (product == null) {
            product = productRepository.findById(id).orElseThrow(() -> new ProductNotFoundException("Product not found"));
            cache.put(id, product);
        }
        return product;
    }
}

この例では、`ProductService`クラスがキャッシュを利用して商品データの取得を効率化しています。

サービスクラスとモデルクラス – それぞれの役割と違い

サービスクラスとモデルクラスは、それぞれ異なる役割を担っています。
サービスクラスはビジネスロジックを担当し、モデルクラスはデータの表現を担当します。
このセクションでは、両者の役割とその違いについて詳しく説明します。

サービスクラスとモデルクラスの基本的な違い

サービスクラスはビジネスロジックを実装するためのクラスであり、モデルクラスはデータの構造を定義するためのクラスです。
サービスクラスは、ビジネスルールや操作の実行を担当し、モデルクラスはデータベースのテーブルと1対1で対応することが多いです。

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Double price;

    // Getters and setters
}

この例では、`Product`クラスがモデルクラスとして、データベースのテーブルを表現しています。

モデルクラスの役割とその重要性

モデルクラスは、アプリケーションのデータ構造を表現するために使用されます。
これにより、データベース操作が容易になり、データの一貫性が保たれます。
また、モデルクラスはバリデーションやデータ変換の責任を持つことができます。

public class Product {
    private Long id;
    private String name;
    private Double price;

    // コンストラクタ、ゲッター、セッター、バリデーションメソッドなど
}

サービスクラスとモデルクラスの連携方法

サービスクラスは、モデルクラスを利用してビジネスロジックを実行します。
以下の例では、サービスクラスがモデルクラスを利用してデータベース操作を行っています。

@Service
public class ProductService {
    private final ProductRepository productRepository;

    @Autowired
    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public Product createProduct(Product product) {
        return productRepository.save(product);
    }
}

データ操作の責任分担

サービスクラスとモデルクラスの間でデータ操作の責任を明確に分担することが重要です。
サービスクラスはビジネスロジックを担当し、モデルクラスはデータの保存や取得を担当します。
この分担により、コードの可読性と保守性が向上します。

設計上のベストプラクティス

サービスクラスとモデルクラスを適切に設計することで、アプリケーションの品質を高めることができます。
以下のベストプラクティスを参考にしてください。

– 単一責任原則（SRP）を守る
– コードの再利用性を考慮する
– 適切な抽象化レベルを維持する

サービスクラスのテスト方法 – 効率的なテスト手法と手順

サービスクラスのテストは、アプリケーションの品質を確保するために重要です。
効率的なテスト手法と手順を用いることで、バグの早期発見と修正が可能になり、開発効率が向上します。

サービスクラスのユニットテスト

ユニットテストは、サービスクラスの各メソッドが正しく動作することを確認するための基本的なテスト手法です。
以下に、JUnitを使用したユニットテストの例を示します。

@RunWith(MockitoJUnitRunner.class)
public class ProductServiceTest {
    @Mock
    private ProductRepository productRepository;

    @InjectMocks
    private ProductService productService;

    @Test
    public void testCreateProduct() {
        Product product = new Product("Test Product", 100.0);
        when(productRepository.save(product)).thenReturn(product);

        Product createdProduct = productService.createProduct(product);

        assertEquals("Test Product", createdProduct.getName());
        assertEquals(100.0, createdProduct.getPrice(), 0.01);
    }
}

モックを使用したテスト方法

モックを使用することで、依存関係をシミュレートし、サービスクラスのテストを容易に行うことができます。
Mockitoを使用することで、簡単にモックオブジェクトを作成できます。

@RunWith(MockitoJUnitRunner.class)
public class OrderServiceTest {
    @Mock
    private OrderRepository orderRepository;

    @Mock
    private InventoryService inventoryService;

    @InjectMocks
    private OrderService orderService;

    @Test
    public void testCreateOrder() {
        Order order = new Order(new Product("Test Product", 100.0), 1);
        when(inventoryService.checkStock(order.getProduct())).thenReturn(true);
        when(orderRepository.save(order)).thenReturn(order);

        Order createdOrder = orderService.createOrder(order);

        assertNotNull(createdOrder);
        verify(inventoryService, times(1)).checkStock(order.getProduct());
        verify(orderRepository, times(1)).save(order);
    }
}

統合テストの実施方法

統合テストは、複数のコンポーネントが連携して正しく動作することを確認するためのテストです。
Spring Bootを使用することで、簡単に統合テストを実施できます。

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {
    @Autowired
    private ProductService productService;

    @Test
    public void contextLoads() {
        assertNotNull(productService);
    }
}

テストケースの設計とその実例

テストケースを設計する際は、正常系だけでなく、異常系も考慮する必要があります。
以下に、異常系のテストケースの例を示します。

@Test(expected = ProductNotFoundException.class)
public void testGetProductByIdNotFound() {
    when(productRepository.findById(anyLong())).thenReturn(Optional.empty());

    productService.getProductById(1L);
}

テスト自動化のベストプラクティス

テスト自動化を導入することで、テストの実行が効率化され、継続的インテグレーション（CI）の一環として品質保証が可能になります。
以下のベストプラクティスを参考にしてください。

– テストのカバレッジを広げる
– 定期的にテストを実行する
– テストの結果を可視化するツールを導入する

サービスクラスのデザインパターン – 適用されるデザインパターンとベストプラクティス

サービスクラスには、さまざまなデザインパターンが適用されます。
これにより、コードの再利用性、拡張性、保守性が向上します。
このセクションでは、サービスクラスに適用される主要なデザインパターンを紹介します。

サービスクラスに適用される主要なデザインパターン

サービスクラスには、以下のようなデザインパターンが適用されます。

– シングルトンパターン
– ファクトリーパターン
– デコレーターパターン

それぞれのパターンの適用例を以下に示します。

シングルトンパターンの適用例

シングルトンパターンは、クラスのインスタンスが一つだけであることを保証するデザインパターンです。
以下に、シングルトンパターンを適用したサービスクラスの例を示します。

public class SingletonService {
    private static SingletonService instance;

    private SingletonService() {
        // コンストラクタは非公開
    }

    public static SingletonService getInstance() {
        if (instance == null) {
            instance = new SingletonService();
        }
        return instance;
    }

    public void performService() {
        // サービスの実行
    }
}

ファクトリーパターンの利用シーン

ファクトリーパターンは、オブジェクトの生成を専門に行うクラスを作成するデザインパターンです。
以下に、ファクトリーパターンを利用した例を示します。

public class ServiceFactory {
    public static UserService createUserService() {
        return new UserService(new UserRepository());
    }
}

デコレーターパターンの応用方法

デコレーターパターンは、既存のクラスに新しい機能を追加するデザインパターンです。
以下に、デコレーターパターンを応用した例を示します。

public interface UserService {
    User findUserById(Long id);
}

public class UserServiceImpl implements UserService {
    public User findUserById(Long id) {
        // ユーザーの検索
    }
}

public class UserServiceDecorator implements UserService {
    private final UserService userService;

    public UserServiceDecorator(UserService userService) {
        this.userService = userService;
    }

    public User findUserById(Long id) {
        // 追加の機能
        return userService.findUserById(id);
    }
}

デザインパターンを使ったコードの最適化

デザインパターンを使用することで、コードの再利用性と拡張性が向上します。
例えば、ストラテジーパターンを使用することで、アルゴリズムの実装を柔軟に変更することができます。

public interface PaymentStrategy {
    void pay(int amount);
}

public class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        // クレジットカードでの支払い処理
    }
}

public class PaypalPayment implements PaymentStrategy {
    public void pay(int amount) {
        // Paypalでの支払い処理
    }
}

public class PaymentService {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void processPayment(int amount) {
        paymentStrategy.pay(amount);
    }
}