java----设计模式--行为型模式（GOF23）

行为型模式关注系统中对象之间的相互交互，研究系统在运行时对象之间的相互通信和协作，进一步明确对象的职责

 责任链模式：

功能：解决if else

应用了责任链模式，相当于我把每一个处理逻辑都看作是一个独立的处理者，然后将他们形成一个处理链，这样当一个请求进来之后，通过遍历这个处理链来处理请求。

场景：例如请假审批，将请求交给班长，班长不行交给辅导员，辅导员不行交给学生办

开发中常见的场景：

• Java中，异常机制就是一种责任链模式。一个try可以对应多个catch，当第一个catch不匹配类型，则自动跳到第二个catch.
• Javascript语言中，事件的冒泡和捕获机制。Java语言中，事件的处理采用观察者模式。
• Servlet开发中，过滤器的链式处理
• Struts2中，拦截器的调用也是典型的责任链模式

示例1

//请假对象
public class LeaveRequest {
    public String name;
    public int day;
    public LeaveRequest(String name, int day) {
        this.name = name;
        this.day = day;
    }
}
abstract class RequestHandle{
    RequestHandle nextRequestHandle;
    abstract void handleRequest(LeaveRequest leaveRequest);
    public void setNextRequestHandle(RequestHandle requestHandle){
        this.nextRequestHandle = requestHandle;
    };
}
class Monitor extends RequestHandle{
    public void handleRequest(LeaveRequest leaveRequest){
        if (leaveRequest.day<3){
            System.out.println("请假成功");
            return;
        }else {
            if (nextRequestHandle!=null){
                nextRequestHandle.handleRequest(leaveRequest);
            }else {
                System.out.println("请假不成功");
            }
        }
    }
}
class Counselor extends RequestHandle {
    public void handleRequest(LeaveRequest leaveRequest){
        if (leaveRequest.day<10){
            System.out.println("请假成功");
            return;
        }else {
            if (nextRequestHandle!=null){
                nextRequestHandle.handleRequest(leaveRequest);
            }else {
                System.out.println("请假不成功");
            }
        }
    }
}
class Demo{
    public static void main(String[] args) {
        Monitor monitor = new Monitor();
        Counselor counselor = new Counselor();
        monitor.setNextRequestHandle(counselor);

        monitor.handleRequest(new LeaveRequest("A",5));
    }
}

示例2

定义处理器

abstract class Handler{
	public Handler nextHandler;
	protected abstract void dealRequest(Integer num);
}
@component("aHandler")
class AHandler extends Handler {
    private final Integer order = 1;
    public final Integer myNum = 10;
    @Override
    public void dealRequest(Integer num) {
        if (myNum.equals(num)) {
            System.out.println("num==10,A责任链处理");
        }else {
        	//交给下一个处理器处理
        	nextHandle();
        }
    }
    public void nextHandle(){
    	if (nextHandler!=null) {
    		nextHandler.dealRequest(myNum);
		}else{
			System.out.println("处理完成");
		}
    }
}
@component("bHandler")
class BHandler extends Handler {
	private final Integer order = 2;
    public final Integer myNum = 20;
    @Override
    public void dealRequest(Integer num) {
        if (myNum.equals(num)) {
            System.out.println("num==20,B责任链处理");
        }else {
        	//交给下一个处理器处理
        	nextHandle();
        }
    }
    public void nextHandle(){
    	if (nextHandler!=null) {
    		nextHandler.dealRequest(myNum);
		}else{
			System.out.println("处理完成");
		}
    }
}

定义枚举

通过枚举获取beanName

//定义所有的处理器
enum HandlerBeanEnum {
	//给Name赋值
    AHandler("aHandler"),
    BHandler("bHandler");
    private String Name;
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	private HandlerBeanEnum(String beanName) {
		this.Name = beanName;
	}
	private HandlerBeanEnum() {
	}	
}

程序的入口

调用责任链的入口

@Component
public class ExecuteHandler {
    @Autowired
    private ApplicationContext context;
    private List<Handler> handlerList = new LinkedList<>();
    
    private Handler handler;

    public Handler getHandler() {
        return handler;
    }

    /**
     * 该方法会在该对象创建之后被调用
     */
    @PostConstruct
    public void afterPostConstruct() throws Exception {
        HandlerBeanEnum[] values = HandlerBeanEnum.values();
        //获取bean，我们也可以采用其他方式获取bean
        for (HandlerBeanEnum value : values) {
            Handler bean = context.getBean(value.getBeanName(), Handler.class);
            handlerList.add(bean);
        }
        if (CollectionUtil.isNotEmpty(handlerList)) {
            for (int i = 1; i < handlerList.size(); i++) {
                //当前处理器
                Handler currentHandler = handlerList.get(i - 1);
                //下一个处理器
                Handler nextHandler = handlerList.get(i);
                //将处理器串成链表
                currentHandler.setNextHandler(nextHandler);
            }
            this.handler = handlerList.get(0);
        }

    }

}

使用

@Autowired
private ExecuteHandler executeHandler;
/**
 * 测试责任链模式
 * @return
 */
@GetMapping("/test/{num}")
public Result testHandler(@PathVariable Integer num){
    Handler handler = executeHandler.getHandler();
    handler.dealRequest(num);
    return Result.success();
}

　　

 迭代器模式：

核心是游标，容器是数组或者集合。

如果使用链表也是可以的（就不需要游标了）

interface MyIterator{
    public boolean hasNext();
    public Object next();
}
public class ConcreteMyAggregate {
    private List<Object> list = new ArrayList<>();

    public void addObject(Object object) {
        list.add(object);
    }
    public void removeObject(Object object) {
        list.remove(object);
    }
    private ConcreteIterator getIterator() {
        return new ConcreteIterator();
    }
    private class ConcreteIterator implements MyIterator{
        private int cursor = 0;
        public boolean hasNext() {
            return cursor < list.size() ? true : false;
        }

        public Object next() {
            Object o = list.get(cursor);
            cursor++;
            return o;
        }
    }

    public static void main(String[] args) {
        ConcreteMyAggregate concreteMyAggregate = new ConcreteMyAggregate();
        concreteMyAggregate.addObject("1");
        concreteMyAggregate.addObject("2");
        concreteMyAggregate.addObject("3");
        ConcreteIterator iterator = concreteMyAggregate.getIterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

 

 中介者模式：

　　如果一个系统中对象之间的联系呈现为网状结构，对象之间存在大量多对多关系，将导致关系及其复杂，这些对象称为“同事对象"，我们可以引入一个中介者对象，使各个同事对象只跟中介者对象打交道，将复杂的网络结构化解为如下的星形结构。

　　注意：如果对象调用关系简单，一定不要使用中介者模式。反而会变得复杂起来