Java8中涉及的几个设计模式

╰半夏微凉° 2023-06-04 08:56 34阅读 0赞

**1.策略模式：**

public class StrategyMain { 
    
        public static void main(String[] args) { 
            // old school
            Validator v1 = new Validator(new IsNumeric());
            System.out.println(v1.validate("aaaa"));
            Validator v2 = new Validator(new IsAllLowerCase ());
            System.out.println(v2.validate("bbbb"));
    
    
            // with lambdas
            Validator v3 = new Validator((String s) -> s.matches("\\d+"));
            System.out.println(v3.validate("aaaa"));
            Validator v4 = new Validator((String s) -> s.matches("[a-z]+"));
            System.out.println(v4.validate("bbbb"));
        }
    
        interface ValidationStrategy { 
            public boolean execute(String s);
        }
    
        static private class IsAllLowerCase implements ValidationStrategy { 
            public boolean execute(String s){ 
                return s.matches("[a-z]+");
            }
        }
        static private class IsNumeric implements ValidationStrategy { 
            public boolean execute(String s){ 
                return s.matches("\\d+");
            }
        }
    
        static private class Validator{ 
            private final ValidationStrategy strategy;
            public Validator(ValidationStrategy v){ 
                this.strategy = v;
            }
            public boolean validate(String s){ 
                return strategy.execute(s); }
        }
    }

策略模式包含三部分内容，如图8-1所示。  
（1） 一个代表某个算法的接口（它是策略模式的接口）。  
（2）一个或多个该接口的具体实现，它们代表了算法的多种实现（比如，实体类Concrete-  
StrategyA或者ConcreteStrategyB）。  
（3）一个或多个使用策略对象的客户。

我们假设你希望验证输入的内容是否根据标准进行了恰当的格式化（比如只包含小写字母或数字）。你可以从定义一个验证文本（以String的形式表示）的接口入手：

public interface ValidationStrategy {  boolean execute(String s);
    }

其次，你定义了该接口的一个或多个具体实现：

public class IsAllLowerCase implements ValidationStrategy {  public boolean execute(String s){ 
    return s.matches("[a-z]+");
    }
    }
    
    public class IsNumeric implements ValidationStrategy {  public boolean execute(String s){ 
    return s.matches("\\d+");
    }
    }

之后，你就可以在你的程序中使用这些略有差异的验证策略了：

public class Validator{ 
    private final ValidationStrategy strategy;
    
    public Validator(ValidationStrategy v){  this.strategy = v;
    }
    
    public boolean validate(String s){  return strategy.execute(s);
    }
    }
    
    Validator numericValidator = new Validator(new IsNumeric()); 
    boolean b1 = numericValidator.validate("aaaa");
    Validator lowerCaseValidator = new Validator(new IsAllLowerCase ()); 
    boolean b2 = lowerCaseValidator.validate("bbbb");

**优化代码：**

Validator numericValidator =
                    new Validator((String s) -> s.matches("[a-z]+"));
            boolean b1 = numericValidator.validate("aaaa");
            Validator lowerCaseValidator =
                    new Validator((String s) -> s.matches("\\d+"));
            boolean b2 = lowerCaseValidator.validate("bbbb");

**2.观察者模式**  
观察者模式是一种比较常见的方案，某些事件发生时（比如状态转变），如果一个对象（通常我们称之为主题）需要自动地通知其他多个对象（称为观察者），就会采用该方案。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70]案例参考代码如下：

package lambdasinaction.chap8;
    
    import java.util.ArrayList;
    import java.util.List;
    
    
    public class ObserverMain { 
    
        public static void main(String[] args) { 
            Feed f = new Feed();
            f.registerObserver(new NYTimes());
            f.registerObserver(new Guardian());
            f.registerObserver(new LeMonde());
            f.notifyObservers("The queen said her favourite book is Java 8 in Action!");
    
    
            Feed feedLambda = new Feed();
    
            feedLambda.registerObserver((String tweet) -> { 
                if(tweet != null && tweet.contains("money")){ 
                    System.out.println("Breaking news in NY! " + tweet); }
            });
            feedLambda.registerObserver((String tweet) -> { 
                if(tweet != null && tweet.contains("queen")){ 
                    System.out.println("Yet another news in London... " + tweet); }
            });
    
            feedLambda.notifyObservers("Money money money, give me money!");
    
        }
    
    
        interface Observer{ 
            void inform(String tweet);
        }
    
        interface Subject{ 
            void registerObserver(Observer o);
            void notifyObservers(String tweet);
        }
    
        static private class NYTimes implements Observer{ 
            @Override
            public void inform(String tweet) { 
                if(tweet != null && tweet.contains("money")){ 
                    System.out.println("Breaking news in NY!" + tweet);
                }
            }
        }
    
        static private class Guardian implements Observer{ 
            @Override
            public void inform(String tweet) { 
                if(tweet != null && tweet.contains("queen")){ 
                    System.out.println("Yet another news in London... " + tweet);
                }
            }
        }
    
        static private class LeMonde implements Observer{ 
            @Override
            public void inform(String tweet) { 
                if(tweet != null && tweet.contains("wine")){ 
                    System.out.println("Today cheese, wine and news! " + tweet);
                }
            }
        }
    
        static private class Feed implements Subject{ 
            private final List<Observer> observers = new ArrayList<>();
            public void registerObserver(Observer o) { 
                this.observers.add(o);
            }
            public void notifyObservers(String tweet) { 
                observers.forEach(o -> o.inform(tweet));
            }
        }
    
    }

**3.责任链模式**  
责任链模式是一种创建处理对象序列（比如操作序列）的通用方案。一个处理对象可能需要在完成一些工作之后，将结果传递给另一个对象，这个对象接着做一些工作，再转交给下一个处理对象，以此类推。

package lambdasinaction.chap8;
    
    import java.util.function.Function;
    import java.util.function.UnaryOperator;
    
    
    public class ChainOfResponsibilityMain { 
    
        public static void main(String[] args) { 
            ProcessingObject<String> p1 = new HeaderTextProcessing();
            ProcessingObject<String> p2 = new SpellCheckerProcessing();
            p1.setSuccessor(p2);
            String result1 = p1.handle("Aren't labdas really sexy?!!");
            System.out.println(result1);
    
    
            UnaryOperator<String> headerProcessing =
                    (String text) -> "From Raoul, Mario and Alan: " + text;
            UnaryOperator<String> spellCheckerProcessing =
                    (String text) -> text.replaceAll("labda", "lambda");
            Function<String, String> pipeline = headerProcessing.andThen(spellCheckerProcessing);
            String result2 = pipeline.apply("Aren't labdas really sexy?!!");
            System.out.println(result2);
        }
    
        static private abstract class ProcessingObject<T> { 
            protected ProcessingObject<T> successor;
    
            public void setSuccessor(ProcessingObject<T> successor) { 
                this.successor = successor;
            }
    
            public T handle(T input) { 
                T r = handleWork(input);
                if (successor != null) { 
                    return successor.handle(r);
                }
                return r;
            }
    
            abstract protected T handleWork(T input);
        }
    
        static private class HeaderTextProcessing
                extends ProcessingObject<String> { 
            public String handleWork(String text) { 
                return "From Raoul, Mario and Alan: " + text;
            }
        }
    
        static private class SpellCheckerProcessing
                extends ProcessingObject<String> { 
            public String handleWork(String text) { 
                return text.replaceAll("labda", "lambda");
            }
        }
    }

**4.工厂模式**  
使用工厂模式，你无需向客户暴露实例化的逻辑就能完成对象的创建

package lambdasinaction.chap8;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.function.Supplier;
    
    
    public class FactoryMain { 
    
        public static void main(String[] args) { 
            Product p1 = ProductFactory.createProduct("loan");
    
            Supplier<Product> loanSupplier = Loan::new;
            Product p2 = loanSupplier.get();
    
            Product p3 = ProductFactory.createProductLambda("loan");
    
        }
    
        static private class ProductFactory { 
            public static Product createProduct(String name){ 
                switch(name){ 
                    case "loan": return new Loan();
                    case "stock": return new Stock();
                    case "bond": return new Bond();
                    default: throw new RuntimeException("No such product " + name);
                }
            }
    
            public static Product createProductLambda(String name){ 
                Supplier<Product> p = map.get(name);
                if(p != null) return p.get();
                throw new RuntimeException("No such product " + name);
            }
        }
    
        static private interface Product { }
        static private class Loan implements Product { }
        static private class Stock implements Product { }
        static private class Bond implements Product { }
    
        final static private Map<String, Supplier<Product>> map = new HashMap<>();
        static { 
            map.put("loan", Loan::new);
            map.put("stock", Stock::new);
            map.put("bond", Bond::new);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70]: /images/20230601/168f27cfd0ac4df8ba37712bc521bc0a.png