diff --git a/filterer/README.md b/filterer/README.md index 09ca7a38e..d9578922b 100644 --- a/filterer/README.md +++ b/filterer/README.md @@ -1,203 +1,192 @@ --- title: Filterer language: en -category: Functional +category: Behavioral tag: - - Extensibility + - Data processing + - Data transformation + - Decoupling + - Performance + - Runtime --- -## Name / classification +## Also known as -Filterer +* Filters +* Pipes and Filters ## Intent -The intent of this design pattern is to introduce a functional interface that will add a -functionality for container-like objects to easily return filtered versions of themselves. +The Filterer pattern aims to apply a series of filters to data objects, where each filter processes the data based on specific rules and criteria, and passes the data to the next filter in the sequence. ## Explanation Real world example -> We are designing a threat (malware) detection software which can analyze target systems for -> threats that are present in it. In the design we have to take into consideration that new -> Threat types can be added later. Additionally, there is a requirement that the threat detection -> system can filter the detected threats based on different criteria (the target system acts as -> container-like object for threats). +> We are designing a threat (malware) detection software which can analyze target systems for threats that are present in it. In the design we have to take into consideration that new Threat types can be added later. Additionally, there is a requirement that the threat detection system can filter the detected threats based on different criteria (the target system acts as container-like object for threats). In plain words -> Filterer pattern is a design pattern that helps container-like objects return filtered versions -> of themselves. +> Filterer pattern is a design pattern that helps container-like objects return filtered versions of themselves. **Programmatic Example** -To model the threat detection example presented above we introduce `Threat` and `ThreatAwareSystem` -interfaces. +To model the threat detection example presented above we introduce `Threat` and `ThreatAwareSystem` interfaces. ```java public interface Threat { - String name(); - int id(); - ThreatType type(); + String name(); + + int id(); + + ThreatType type(); } public interface ThreatAwareSystem { - String systemId(); - List threats(); - Filterer filtered(); + String systemId(); + List threats(); + + Filterer filtered(); } ``` Notice the `filtered` method that returns instance of `Filterer` interface which is defined as: ```java + @FunctionalInterface public interface Filterer { - G by(Predicate predicate); + G by(Predicate predicate); } ``` -It is used to fulfill the requirement for system to be able to filter itself based on threat -properties. The container-like object (`ThreatAwareSystem` in our case) needs to have a method that -returns an instance of `Filterer`. This helper interface gives ability to covariantly specify a -lower bound of contravariant `Predicate` in the subinterfaces of interfaces representing the -container-like objects. +It is used to fulfill the requirement for system to be able to filter itself based on threat properties. The container-like object (`ThreatAwareSystem` in our case) needs to have a method that returns an instance of `Filterer`. This helper interface gives ability to covariantly specify a lower bound of contravariant `Predicate` in the subinterfaces of interfaces representing the container-like objects. -In our example we will be able to pass a predicate that takes `? extends Threat` object and -return `? extends ThreatAwareSystem` from `Filtered::by` method. A simple implementation -of `ThreatAwareSystem`: +In our example we will be able to pass a predicate that takes `? extends Threat` object and return `? extends ThreatAwareSystem` from `Filtered::by` method. A simple implementation of `ThreatAwareSystem`: ```java public class SimpleThreatAwareSystem implements ThreatAwareSystem { - private final String systemId; - private final ImmutableList issues; + private final String systemId; + private final ImmutableList issues; - public SimpleThreatAwareSystem(final String systemId, final List issues) { - this.systemId = systemId; - this.issues = ImmutableList.copyOf(issues); - } - - @Override - public String systemId() { - return systemId; - } - - @Override - public List threats() { - return new ArrayList<>(issues); - } + public SimpleThreatAwareSystem(final String systemId, final List issues) { + this.systemId = systemId; + this.issues = ImmutableList.copyOf(issues); + } - @Override - public Filterer filtered() { - return this::filteredGroup; - } + @Override + public String systemId() { + return systemId; + } - private ThreatAwareSystem filteredGroup(Predicate predicate) { - return new SimpleThreatAwareSystem(this.systemId, filteredItems(predicate)); - } + @Override + public List threats() { + return new ArrayList<>(issues); + } - private List filteredItems(Predicate predicate) { - return this.issues.stream() - .filter(predicate) - .collect(Collectors.toList()); - } + @Override + public Filterer filtered() { + return this::filteredGroup; + } + + private ThreatAwareSystem filteredGroup(Predicate predicate) { + return new SimpleThreatAwareSystem(this.systemId, filteredItems(predicate)); + } + + private List filteredItems(Predicate predicate) { + return this.issues.stream() + .filter(predicate) + .collect(Collectors.toList()); + } } ``` The `filtered` method is overridden to filter the threats list by given predicate. -Now if we introduce a new subtype of `Threat` interface that adds probability with which given -threat can appear: +Now if we introduce a new subtype of `Threat` interface that adds probability with which given threat can appear: ```java public interface ProbableThreat extends Threat { - double probability(); + double probability(); } ``` -We can also introduce a new interface that represents a system that is aware of threats with their -probabilities: +We can also introduce a new interface that represents a system that is aware of threats with their probabilities: ````java public interface ProbabilisticThreatAwareSystem extends ThreatAwareSystem { - @Override - List threats(); + @Override + List threats(); - @Override - Filterer filtered(); + @Override + Filterer filtered(); } ```` -Notice how we override the `filtered` method in `ProbabilisticThreatAwareSystem` and specify -different return covariant type by specifying different generic types. Our interfaces are clean and -not cluttered by default implementations. We we will be able to filter -`ProbabilisticThreatAwareSystem` by `ProbableThreat` properties: +Notice how we override the `filtered` method in `ProbabilisticThreatAwareSystem` and specify different return covariant type by specifying different generic types. Our interfaces are clean and not cluttered by default implementations. We will be able to filter `ProbabilisticThreatAwareSystem` by `ProbableThreat` properties: ```java public class SimpleProbabilisticThreatAwareSystem implements ProbabilisticThreatAwareSystem { - private final String systemId; - private final ImmutableList threats; + private final String systemId; + private final ImmutableList threats; - public SimpleProbabilisticThreatAwareSystem(final String systemId, final List threats) { - this.systemId = systemId; - this.threats = ImmutableList.copyOf(threats); - } + public SimpleProbabilisticThreatAwareSystem(final String systemId, final List threats) { + this.systemId = systemId; + this.threats = ImmutableList.copyOf(threats); + } - @Override - public String systemId() { - return systemId; - } + @Override + public String systemId() { + return systemId; + } - @Override - public List threats() { - return threats; - } + @Override + public List threats() { + return threats; + } - @Override - public Filterer filtered() { - return this::filteredGroup; - } + @Override + public Filterer filtered() { + return this::filteredGroup; + } - private ProbabilisticThreatAwareSystem filteredGroup(final Predicate predicate) { - return new SimpleProbabilisticThreatAwareSystem(this.systemId, filteredItems(predicate)); - } + private ProbabilisticThreatAwareSystem filteredGroup(final Predicate predicate) { + return new SimpleProbabilisticThreatAwareSystem(this.systemId, filteredItems(predicate)); + } - private List filteredItems(final Predicate predicate) { - return this.threats.stream() - .filter(predicate) - .collect(Collectors.toList()); - } + private List filteredItems(final Predicate predicate) { + return this.threats.stream() + .filter(predicate) + .collect(Collectors.toList()); + } } ``` Now if we want filter `ThreatAwareSystem` by threat type we can do: ```java -Threat rootkit = new SimpleThreat(ThreatType.ROOTKIT, 1, "Simple-Rootkit"); -Threat trojan = new SimpleThreat(ThreatType.TROJAN, 2, "Simple-Trojan"); -List threats = List.of(rootkit, trojan); +Threat rootkit=new SimpleThreat(ThreatType.ROOTKIT, 1, "Simple-Rootkit"); +Threat trojan=new SimpleThreat(ThreatType.TROJAN, 2, "Simple-Trojan"); +List threats=List.of(rootkit, trojan); -ThreatAwareSystem threatAwareSystem = new SimpleThreatAwareSystem("System-1", threats); +ThreatAwareSystem threatAwareSystem=new SimpleThreatAwareSystem("System-1", threats); -ThreatAwareSystem rootkitThreatAwareSystem = threatAwareSystem.filtered() - .by(threat -> threat.type() == ThreatType.ROOTKIT); +ThreatAwareSystem rootkitThreatAwareSystem=threatAwareSystem.filtered().by(threat -> threat.type() == ThreatType.ROOTKIT); ``` Or if we want to filter `ProbabilisticThreatAwareSystem`: ```java -ProbableThreat malwareTroyan = new SimpleProbableThreat("Troyan-ArcBomb", 1, ThreatType.TROJAN, 0.99); +ProbableThreat malwareTroyan=new SimpleProbableThreat("Troyan-ArcBomb", 1, ThreatType.TROJAN, 0.99); ProbableThreat rootkit = new SimpleProbableThreat("Rootkit-System", 2, ThreatType.ROOTKIT, 0.8); List probableThreats = List.of(malwareTroyan, rootkit); -ProbabilisticThreatAwareSystem simpleProbabilisticThreatAwareSystem =new SimpleProbabilisticThreatAwareSystem("System-1", probableThreats); +ProbabilisticThreatAwareSystem simpleProbabilisticThreatAwareSystem = new SimpleProbabilisticThreatAwareSystem("System-1", probableThreats); -ProbabilisticThreatAwareSystem filtered = simpleProbabilisticThreatAwareSystem.filtered() - .by(probableThreat -> Double.compare(probableThreat.probability(), 0.99) == 0); +ProbabilisticThreatAwareSystem filtered = simpleProbabilisticThreatAwareSystem.filtered().by(probableThreat -> Double.compare(probableThreat.probability(), 0.99) == 0); ``` ## Class diagram @@ -206,30 +195,38 @@ ProbabilisticThreatAwareSystem filtered = simpleProbabilisticThreatAwareSystem.f ## Applicability -Pattern can be used when working with container-like objects that use subtyping, instead of -parametrizing (generics) for extensible class structure. It enables you to easily extend filtering -ability of container-like objects as business requirements change. +This pattern is useful in scenarios where data needs to be processed in discrete steps, and each step's output is the input for the next step. Common in stream processing, audio/video processing pipelines, or any data processing applications requiring staged transformations. ## Tutorials -* [Article about Filterer pattern posted on it's author's blog](https://blog.tlinkowski.pl/2018/filterer-pattern/) +* [Article about Filterer pattern posted on its author's blog](https://blog.tlinkowski.pl/2018/filterer-pattern/) * [Application of Filterer pattern in domain of text analysis](https://www.javacodegeeks.com/2019/02/filterer-pattern-10-steps.html) -## Known uses +## Known Uses -One of the uses is present on the blog presented in -[this](https://www.javacodegeeks.com/2019/02/filterer-pattern-10-steps.html) link. It presents how -to use `Filterer` pattern to create text issue analyzer with support for test cases used for unit -testing. +* Stream processing libraries in Java, such as Apache Kafka Streams, utilize this pattern to build complex data processing pipelines. +* Image processing software often uses filters to apply effects or transformations to images sequentially. ## Consequences -Pros: - * You can easily introduce new subtypes for container-like objects and subtypes for objects that are contained within them and still be able to filter easily be new properties of those new subtypes. +Benefits: -Cons: - * Covariant return types mixed with generics can be sometimes tricky +* Increases flexibility by allowing different filters to be added or reorganized without affecting other parts of the system. +* Enhances testability, as filters can be tested independently. +* Promotes loose coupling between the stages of data processing. + +## Trade-offs: + +* Potential performance overhead from continuous data passing between filters. +* Complexity can increase with the number of filters, potentially affecting maintainability. + +## Related Patterns + +* Chain of Responsibility: Filters can be seen as a specialized form of the Chain of Responsibility, where each filter decides if and how to process the input data and whether to pass it along the chain. +* Decorator: Similar to Decorator in that both modify behavior dynamically; however, filters focus more on data transformation than on adding responsibilities. ## Credits -* Author of the pattern : [Tomasz Linkowski](https://tlinkowski.pl/) +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3W8sn2W) +* [Kafka: The Definitive Guide: Real-Time Data and Stream Processing at Scale](https://amzn.to/49N3nRU) +* [Java Performance: The Definitive Guide](https://amzn.to/3vRW3qj) diff --git a/filterer/src/main/java/com/iluwatar/filterer/App.java b/filterer/src/main/java/com/iluwatar/filterer/App.java index 3fe22a4b8..30a04d46e 100644 --- a/filterer/src/main/java/com/iluwatar/filterer/App.java +++ b/filterer/src/main/java/com/iluwatar/filterer/App.java @@ -42,7 +42,7 @@ import lombok.extern.slf4j.Slf4j; * objects are systems that are aware of threats that they can be vulnerable to. We would like * to have a way to create copy of different system objects but with filtered threats. * The thing is to keep it simple if we add new subtype of {@link Threat} - * (for example {@link ProbableThreat}) - we still need to be able to filter by it's properties. + * (for example {@link ProbableThreat}) - we still need to be able to filter by its properties. */ @Slf4j public class App { diff --git a/filterer/src/main/java/com/iluwatar/filterer/threat/ProbabilisticThreatAwareSystem.java b/filterer/src/main/java/com/iluwatar/filterer/threat/ProbabilisticThreatAwareSystem.java index 79446d4fe..21609207b 100644 --- a/filterer/src/main/java/com/iluwatar/filterer/threat/ProbabilisticThreatAwareSystem.java +++ b/filterer/src/main/java/com/iluwatar/filterer/threat/ProbabilisticThreatAwareSystem.java @@ -28,7 +28,7 @@ import com.iluwatar.filterer.domain.Filterer; import java.util.List; /** - * Represents system that is aware of it's threats with given probability of their occurrence. + * Represents system that is aware of its threats with given probability of their occurrence. */ public interface ProbabilisticThreatAwareSystem extends ThreatAwareSystem { diff --git a/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleProbabilisticThreatAwareSystem.java b/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleProbabilisticThreatAwareSystem.java index def1918bb..e9161b9f4 100644 --- a/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleProbabilisticThreatAwareSystem.java +++ b/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleProbabilisticThreatAwareSystem.java @@ -27,7 +27,6 @@ package com.iluwatar.filterer.threat; import com.iluwatar.filterer.domain.Filterer; import java.util.List; import java.util.function.Predicate; -import java.util.stream.Collectors; import lombok.EqualsAndHashCode; import lombok.RequiredArgsConstructor; import lombok.ToString; diff --git a/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystem.java b/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystem.java index 7a27e2328..93304b647 100644 --- a/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystem.java +++ b/filterer/src/main/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystem.java @@ -28,7 +28,6 @@ import com.iluwatar.filterer.domain.Filterer; import java.util.ArrayList; import java.util.List; import java.util.function.Predicate; -import java.util.stream.Collectors; import lombok.EqualsAndHashCode; import lombok.RequiredArgsConstructor; import lombok.ToString; diff --git a/filterer/src/test/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystemTest.java b/filterer/src/test/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystemTest.java index 5865b558d..cc0d696f1 100644 --- a/filterer/src/test/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystemTest.java +++ b/filterer/src/test/java/com/iluwatar/filterer/threat/SimpleThreatAwareSystemTest.java @@ -24,10 +24,10 @@ */ package com.iluwatar.filterer.threat; -import org.junit.jupiter.api.Test; -import java.util.List; +import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import org.junit.jupiter.api.Test; class SimpleThreatAwareSystemTest { @Test @@ -47,4 +47,4 @@ class SimpleThreatAwareSystemTest { assertEquals(rootkitThreatAwareSystem.threats().size(), 1); assertEquals(rootkitThreatAwareSystem.threats().get(0), rootkit); } -} \ No newline at end of file +}