The State Pattern
0 likes22 views
The State Pattern helps organize code that handles multiple states. It defines classes for each state that hold the behavior for that state. The context class maintains a reference to the current state object and forwards requests to it. For an SMTP server example, state classes are defined for idle, initial, transaction started, and data transfer states that each handle commands appropriate for that state and transition to new states. This improves maintainability over approaches with flags and long conditional statements.
![class IdleState implements State {
@Override
public String handleCommand(String command, SMTPSessionHandler context) {
if (command.startsWith("HELO")) {
context.setCurrentState(new InitialState());
return "250 smtp.example.com, I am glad to meet you";
} else {
return "500 5.5.1 Invalid command";
}
}
}
class InitialState implements State {
private static final Pattern PATTERN_FOR_EXTRACTING_EMAIL = Pattern.compile("MAIL FROM:<([^>]+)>");
@Override
public String handleCommand(String command, SMTPSessionHandler context) {
Matcher matcher = PATTERN_FOR_EXTRACTING_EMAIL.matcher(command);
if (matcher.find()) {
String from = matcher.group(1);
context.setCurrentState(new TransactionStartedState(from));
return "250 Ok";
} else {
return "500 5.5.1 Invalid command";
}
}
}
6
Implementing an SMTP server with the State Pattern (2/4)](https://image.slidesharecdn.com/state-pattern-210312122603/85/The-State-Pattern-6-320.jpg)
![7
Implementing an SMTP server with the State Pattern (3/4)
class TransactionStartedState implements State {
private static final Pattern PATTERN_FOR_EXTRACTING_EMAIL =Pattern.compile("RCPT TO:<([^>]+)>");
private final String from;
private final List<String> destinations = new ArrayList<>();
TransactionStartedState(String from) { this.from = from; }
@Override
public String handleCommand(String command, SMTPSessionHandler context) {
if (command.equals("DATA")) {
if (destinations.isEmpty()) {
return "500 5.5.1 Invalid command";
} else {
context.setCurrentState(new DataTransferState(from, destinations));
return "354 End data with <CR><LF>.<CR><LF>";
}
}
Matcher matcher = PATTERN_FOR_EXTRACTING_EMAIL.matcher(command);
if (matcher.find()) {
String to = matcher.group(1);
destinations.add(to);
return "250 Ok";
} else {
return "500 5.5.1 Invalid command";
}
}
}](https://image.slidesharecdn.com/state-pattern-210312122603/85/The-State-Pattern-7-320.jpg)
The State Pattern
- 2. What is the State Pattern? • One of the GoF Design Patterns • Helps to organize code that handles multiple states • Suitable for a code base where there are a lot of: • Boolean flags or enum fields used to determine the state • Similar if/switch conditionals based on the state • Unclear state transitions • Giant classes causing maintainability issues 2
- 3. Participants of the State Pattern • Context • Provides the public API of the application • Holds a reference to current state object, forwards API calls to it • State • Defines part of the API whose behavior must be changed depending on the state • ConcreteStates • Exists for each possible state of the application • Handles the API calls according to the state it corresponds to • Triggers a state transition 3
- 4. Case study: the SMTP protocol S: 220 smtp.example.com ESMTP Postfix C: HELO relay.example.com S: 250 smtp.example.com, I am glad to meet you C: MAIL FROM:<bob@example.com> S: 250 Ok C: RCPT TO:<alice@example.com> S: 250 Ok C: RCPT TO:<theboss@example.com> S: 250 Ok C: DATA S: 354 End data with <CR><LF>.<CR><LF> C: From: "Bob Example" <bob@example.com> C: To: Alice Example <alice@example.com> C: Cc: theboss@example.com C: Date: Tue, 15 Jan 2008 16:02:43 -0500 C: Subject: Test message C: C: Hello Alice. C: This is a test message with 5 header fields and 4 lines in the message body. C: Your friend, C: Bob C: . S: 250 Ok: queued as 12345 C: QUIT S: 221 Bye {The server closes the connection} Taken from https://en.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol 4
- 5. Implementing an SMTP server with the State Pattern (1/4) public class SMTPSessionHandler { private State currentState = new IdleState(); public String handleCommand(String command) { return currentState.handleCommand(command, this); } void setCurrentState(State newState) { this.currentState = newState; } } interface State { String handleCommand(String command, SMTPSessionHandler context); } 5
- 6. class IdleState implements State { @Override public String handleCommand(String command, SMTPSessionHandler context) { if (command.startsWith("HELO")) { context.setCurrentState(new InitialState()); return "250 smtp.example.com, I am glad to meet you"; } else { return "500 5.5.1 Invalid command"; } } } class InitialState implements State { private static final Pattern PATTERN_FOR_EXTRACTING_EMAIL = Pattern.compile("MAIL FROM:<([^>]+)>"); @Override public String handleCommand(String command, SMTPSessionHandler context) { Matcher matcher = PATTERN_FOR_EXTRACTING_EMAIL.matcher(command); if (matcher.find()) { String from = matcher.group(1); context.setCurrentState(new TransactionStartedState(from)); return "250 Ok"; } else { return "500 5.5.1 Invalid command"; } } } 6 Implementing an SMTP server with the State Pattern (2/4)
- 7. 7 Implementing an SMTP server with the State Pattern (3/4) class TransactionStartedState implements State { private static final Pattern PATTERN_FOR_EXTRACTING_EMAIL =Pattern.compile("RCPT TO:<([^>]+)>"); private final String from; private final List<String> destinations = new ArrayList<>(); TransactionStartedState(String from) { this.from = from; } @Override public String handleCommand(String command, SMTPSessionHandler context) { if (command.equals("DATA")) { if (destinations.isEmpty()) { return "500 5.5.1 Invalid command"; } else { context.setCurrentState(new DataTransferState(from, destinations)); return "354 End data with <CR><LF>.<CR><LF>"; } } Matcher matcher = PATTERN_FOR_EXTRACTING_EMAIL.matcher(command); if (matcher.find()) { String to = matcher.group(1); destinations.add(to); return "250 Ok"; } else { return "500 5.5.1 Invalid command"; } } }
- 8. class DataTransferState implements State { private final String from; private final List<String> destinations; private final StringBuilder body = new StringBuilder(); static DeliverySystem deliverySystem = (from, destinations, body) -> { // looks up MX records, connects to external SMTP servers and relays the message }; DataTransferState(String from, List<String> destinations) { this.from = from; this.destinations = destinations; } @Override public String handleCommand(String command, SMTPSessionHandler context) { if (command.equals(".")) { deliverySystem.deliver(from, destinations, body.toString()); context.setCurrentState(new InitialState()); return "250 Ok: the email has been delivered"; } else { body.append(command); body.append('n'); return null; } } } 8 Implementing an SMTP server with the State Pattern (4/4)
- 9. Conclusion: benefits of the State Pattern • Concise and short classes with clear responsibility • Clear state transition • Better maintainability • You can write a new concrete state class for a new state • There will be no giant classes 9