Java 8实战-观察者/责任链模式之Lambda表达

1、观察者模式：

观察者模式是一种比较常见的方案，某些事件发生时（比如状态转变），如果一个对象（通常我们称之为主题）需要自动地通知其他多个对象（称为观察者），就会采用该方案。

Lambda实现(无需定义 观察者实现类)

package com.csdn.test.Observer;

/**
 * 观察者 
 */
public interface Observer
{
    void notify(String subject);
}

//============================================

package com.csdn.test.Observer;

/**
 * 观察对象
 */
public interface Subject
{

    /**
     * 注册观察者
     */
    void resgistryObserver(Observer o);
    
    /**
     * 通知观察者
     */
    void notifyObservers(String subject);
    
}

//============================================

package com.csdn.test.Observer;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/*
 * 观察者模式是一种比较常见的方案，某些事件发生时（比如状态转变），
 * 如果一个对象（通常我们称之为主题）需要自动地通知其他多个对象（称为观察者），就会采用该方案。 
 */
public class TestObserverMode implements Subject
{
    // 观察者列表
    private List<Observer> observerList = new CopyOnWriteArrayList<>();

    // 注册
    @Override
    public void resgistryObserver(Observer o)
    {
        this.observerList.add(o);
    }

    // 通知
    @Override
    public void notifyObservers(String subject)
    {
        this.observerList.forEach(o -> o.notify(subject));    
    }
    
    // 使用Lambda表达式实例化Observer
    public static void main(String args[])
    {
        TestObserverMode mode = new TestObserverMode();
        // 注册
        mode.resgistryObserver((String sub) -> {
            if ("test".equals(sub))
            {
                System.out.println("Observer1 accept subject(test)");
            }
            if ("".equals(sub))
            {
                System.out.println("Observer1 accept subject(empty)");
            }
        });
        mode.resgistryObserver((String sub) -> {
            if ("test".equals(sub))
            {
                System.out.println("Observer2 accept subject(test)");
            }
        });
        // 通知
        mode.notifyObservers("test");
        mode.notifyObservers("");
    }
    
}

输出：

Observer1 accept subject(test)
Observer2 accept subject(test)
Observer1 accept subject(empty)

 

2、责任链模式

这是一种创建处理对象序列（比如操作序列）的通用方案。一个处理对象可能需要
在完成一些工作之后，将结果传递给另一个对象，这个对象接着做一些工作，再转交给下一个处
理对象，以此类推。
通常，这种模式是通过定义一个代表处理对象的抽象类来实现的，在抽象类中会定义一个字
段来记录后续对象。一旦对象完成它的工作，处理对象就会将它的工作转交给它的后继。

传统实现 VS Lamdba实现

package com.csdn.test.processobj;

/*
 * 责任链模式 
 */
public abstract class ProcessingObject<T>
{
    protected ProcessingObject<T> successor;
    
    public void setSuccessor(ProcessingObject<T> successor)
    {
        this.successor = successor;
    }
    
    public T handle(T t)
    {
        T r = handleWork(t);
        if (successor != null)
        {
            return successor.handle(r);
        }
        return r;
    }
    
    protected abstract T handleWork(T t);
}


// =========================================================


package com.csdn.test.processobj;

import java.util.function.Function;
import java.util.function.UnaryOperator;

public class TestLinkProcess
{

    public static void main(String[] args)
    {
        ProcessingObject<String> aPro = new ProcessingObject<String>()
        {
            @Override
            protected String handleWork(String t)
            {
                return "From Raoul, Mario and Alan: " + t;
            }
        };
        
        ProcessingObject<String> bPro = new ProcessingObject<String>()
        {
            @Override
            protected String handleWork(String t)
            {
                return t.replaceAll("labda", "lambda");
            }
        };
        
        bPro.setSuccessor(aPro);
        
        // 调用链处理
        System.out.println(bPro.handle("Aren't labdas really sexy?!!"));
 
    }

}


//==================================================================
//                      Lamdba
//==================================================================


package com.csdn.test.processobj;

import java.util.function.Function;
import java.util.function.UnaryOperator;

public class TestLinkProcessLamdba
{

    public static void main(String[] args)
    {
        // Function<String, String>  <-> UnaryOperator<String>
        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);
        System.out.println(pipeline.apply("Aren't labdas really sexy?!!"));
    }

}

输出 ：

From Raoul, Mario and Alan: Aren't lambdas really sexy?!!

 

参考文献：《Java8实战》