Lambda重构设计模式

最新推荐文章于 2023-11-24 16:04:15 发布

yu542771572

最新推荐文章于 2023-11-24 16:04:15 发布

阅读量192

点赞数

文章标签：重构设计模式策略模式

本文链接：https://blog.csdn.net/yu542771572/article/details/126024489

版权

本文探讨了Java 8中策略模式、模板方法、观察者模式和责任链模式的改进，展示了如何通过lambda表达式简化代码并提升效率。从验证策略到业务流程的抽象，每个模式都通过实例和优化后的lambda实现进行对比。

摘要由CSDN通过智能技术生成

一、策略模式

jdk8之前写法

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

public class IsNumeric implements ValidationStrategy {
	public boolean validate(String s){
		if(null == s) return false;
		return s.matches("\\d+");
	}
}

public class Validator{
	private final ValidationStrategy strategy;
	public Validator(ValidationStrategy vs){
		this.strategy = vs;
	}
	public boolean validate(String s){
		return strategy.validate(s);
	}
}

lambda优化

Validator validator = new Validator((String s) -> {
	if(null == s) return false;
	return s.matches("[a-z]+");
	});

二、模板方法

jdk8之前写法

abstract class Template {
	public void execute(Map param){
		MsgTemplate t = loadTemplate();
		t.replace(param)
	}
	abstract MsgTemplate loadTemplate();
}

lambda优化

public class ClassPathTemplate extends Template{
	@Overide
	public MsgTemplate loadTemplate() {
		return MsgTemplateBuilder.build(new File(""));
	}
}

三、观察者模式

jdk8之前写法

interface Observer {
	void notify(String msg);
}


class NewsObserver implements Observer{
	public void notify(String msg) {
		System.out.println("news：" + news);
	}
}

interface Subject{
	void registerObserver(Observer o);
	void notifyObservers(String msg);
}


class News implements Subject{
	private final List<Observer> observers = new ArrayList<>();
	public void registerObserver(Observer o) {
		this.observers.add(o);
	}
	public void notifyObservers(String msg) {
		observers.forEach(o -> o.notify(msg));
	}
}

News n = new News();
n.registerObserver(new NewsObserver());
n.notifyObservers("Today News...");

lambda优化

n.registerObserver((String msg) -> {
	System.out.println("Today News" + msg);
});

四、责任链模式

jdk8之前写法

public abstract class ProcessingChain<T> {
	protected ProcessingChain<T> next;
	public void nextChain(ProcessingChain<T> next){
		this.next = next;
	}
	public T process(T t){
		t = doWork(t);
		if(null != next){
			return next.process(t);
		}
		return r;
	}
	abstract T doWork(T t);
}


public class HeadProcessingChain extends ProcessingChain<String> {
	public String doWork(String s){
		return text + "Hello";
	}
}
public class TailProcessingChain extends ProcessingChain<String> {
	public String doWork(String s){
		return text + " World";
	}
}

ProcessingObject<String> p1 = new HeadProcessingChain();
ProcessingObject<String> p2 = new TailProcessingChain();
p1.nextChain(p2);

String result = p1.process("Console : ");
System.out.println(result);

lambda优化

UnaryOperator<String> headProcessing = (String text) -> text + "Hello";
UnaryOperator<String> tailProcessing = (String text) -> text + " World";
Function<String, String> pipeline = headProcessing.andThen(tailProcessing);
String result = pipeline.apply("Console :");
System.out.println(result);