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);
}
}
}
中介者模式：
如果一个系统中对象之间的联系呈现为网状结构，对象之间存在大量多对多关系，将导致关系及其复杂，这些对象称为“同事对象"，我们可以引入一个中介者对象，使各个同事对象只跟中介者对象打交道，将复杂的网络结构化解为如下的星形结构。
注意：如果对象调用关系简单，一定不要使用中介者模式。反而会变得复杂起来
