Design Patterns | Strategy
  1. References
  2. Example
  1. References
    • Definition: (source: http://en.wikipedia.org/wiki/Strategy_pattern)

      The strategy pattern (also known as the policy pattern) enables an algorithm's behavior to be selected at runtime.

      The strategy pattern:
      ► defines a family of algorithms,
      ► encapsulates each algorithm, and
      ► makes the algorithms interchangeable within that family.

      Strategy lets the algorithm vary independently from clients that use it.

    • Class diagram: (source: http://en.wikipedia.org/wiki/Strategy_pattern)

      Strategy Pattern
  2. Example
    • The Subject:

      public class Server {
    private final String id;

    public Server(final String id) {
        this.id = id;
    }

    public void doRequest() {
        System.out.println("Server: " + id);
    }
}

    • The Strategy:

      public interface ProviderStrategy {
    Server getInstance(final List<Server> servers);
}

    • The Concrete Strategy:

      • Implementation 1:

        public class RandomStrategy implements ProviderStrategy {
    private final Random random = new Random();

    public Server getInstance(final List<Server> servers) {
        final int index = random.nextInt(servers.size());

        return servers.get(index);
    }
}

      • Implementation 2:

        public class RoundRobinStrategy implements ProviderStrategy {
    private final AtomicInteger index = new AtomicInteger(0);

    public Server getInstance(final List<Server> servers) {
        final int index = Math.abs(this.index.getAndIncrement());

        return servers.get(index % servers.size());
    }
}

    • The Strategy Context:

      public class ProviderStrategyContext {
    private final ProviderStrategy providerStrategy;

    public ProviderStrategyContext(ProviderStrategy providerStrategy) {
        this.providerStrategy = providerStrategy;
    }

    public void doRequest(final List<Server> servers) {
        providerStrategy.getInstance(servers).doRequest();
    }
}

    • A simple class to test the Strategy design pattern:

      public class StrategyPatternTest {
    public static void main(String[] args) {
        // list of available servers
        final List<Server> servers = new ArrayList<>();
        servers.add(new Server("server1"));
        servers.add(new Server("server2"));
        servers.add(new Server("server3"));

        // Strategies: RoundRobin, Random
        final ProviderStrategyContext providerStrategyContext1 = new ProviderStrategyContext(new RoundRobinStrategy());
        final ProviderStrategyContext providerStrategyContext2 = new ProviderStrategyContext(new RandomStrategy());

        System.out.println("-- RoundRobin Strategy:");
        IntStream.iterate(0, i -> i + 2).limit(6).forEach(i -> providerStrategyContext1.doRequest(servers));

        System.out.println("-- Random Strategy:");
        IntStream.iterate(0, i -> i + 2).limit(6).forEach(i -> providerStrategyContext2.doRequest(servers));
    }
}

© 2025