java的常用设计模式

策略模式

// 先定义一个最基本的接口
public interface BaseInterface {
	// 用于业务处理的方法
    public void toDoService();

	// 用于返回当前业务名字的方法
    public String returnServiceName();
}

// 在定义上面接口的子类
@Service
public class ServiceOne implements BaseInterface{
    @Override
    public void toDoService() {
        System.out.println("serviceOne的业务处理");
    }

    @Override
    public String returnServiceName() {
        return "serviceOne";
    }
}

@Service
public class ServiceTwo implements BaseInterface{
    @Override
    public void toDoService() {
        System.out.println("serviceTwo的业务处理");
    }

    @Override
    public String returnServiceName() {
        return "serviceTwo";
    }
}

// 创建一个工厂对象
@Service
public class TestFactory {
    // 这里注入接口会将所有实现该接口的实现类注入到list
    @Autowired
    private List<BaseInterface> list;

    public void doNameService(String name){
    /*这里将list里面所有的子类都装在进map键就是子类的名字
    值就是子类*/
        Map<String, BaseInterface> collect = list.stream()
        .collect(Collectors.toMap(BaseInterface::returnServiceName,
        										 item -> item));
        // 这里通过传递过来的name进行获取到对应的子类然后执行方法
        collect.get(name).toDoService();
    }
}

如果有扩张的类只需要实现BaseInterface接口即可,如果你的代码里面有大量的if else且内部处理复杂那么完全就可以通过这种方式去解决,这样就做到 “开放封闭”

观察者模式

public interface Gcperson {
    public void doSomething(boolean flag);
}

// 所有观察者的实现类
class OneGcPerson implements Gcperson{

    @Override
    public void doSomething(boolean flag) {
        if(flag){
            // 当前观察者是否满足本次条件
            System.out.println("这是第一个观察者");
        }
    }
}

// 所有观察者的实现类
class TwoGcPerson implements Gcperson{

    @Override
    public void doSomething(boolean flag) {
        if(flag){
            // 当前观察者是否满足本次条件
            System.out.println("这是第二个观察者");
        }
    }
}

// 被观察者
class BgcPerson{
    // 被观察者所有注册的观察者实例
    List<Gcperson> listEvent = new ArrayList<>();

    public void deleteGcPerson(Gcperson gcperson){
        // 删除注册的某个观察者实例
        listEvent.remove(gcperson);
    }

    public void addGcPerson(Gcperson gcperson){
        // 添加注册的某个观察者实例
        listEvent.add(gcperson);
    }

    public void wantToDo(boolean flag){
        // 被观察者即将有动作 触发所有的观察者
        System.out.println("被观察者动了 准备实时驱动观察者们");
        for (Gcperson gcperson : listEvent) {
            gcperson.doSomething(flag);
        }
    }

    public static void main(String[] args) {
        // 创建被观察对象
        BgcPerson bgcPerson = new BgcPerson();
        // 创建并且注册观察对象
        OneGcPerson oneGcPerson = new OneGcPerson();
        TwoGcPerson twoGcPerson = new TwoGcPerson();
        bgcPerson.addGcPerson(oneGcPerson);
        bgcPerson.addGcPerson(twoGcPerson);

        // 被观察者准备开始有操作
        // 实际使用的时候这里的参数根据实际场景去编写这里简单写一下
        bgcPerson.wantToDo(true);
    }
}
运行结果:
被观察者动了 准备实时驱动观察者们
这是第一个观察者
这是第二个观察者

观察者模式经常会有需要用到项目里面,这种模式很好的解决了用户在某个动作上面去实时驱动想要做的事情且和代码解耦合.

责任链模式

先编写一个抽象的处理器,两个方法一个是判断当前处理器是否能处理器当前参数,另一个是当前处理器的具体实现

public abstract class AbstractHandler {
    public abstract boolean support(Object request);

    public void toDoHandler(Object request){}
}

之后编写不同的处理器去继承上面的抽象类

@Service
    class HandlerOne extends AbstractHandler{


        /**
         * 当前处理器是否能支持当前处理当前参数
         *
         * @param request 请求对象
         * @return 返回当前处理器是否支持当前参数
         */
        @Override
        public boolean support(Object request) {

            return false;
        }

        /**
         * 当前处理器只支持处理请求对象是boolean类型
         *
         * @param request 请求过来的请求对象
         */
        @Override
        public void toDoHandler(Object request) {
            System.out.println("处理器1进行处理"+request);
        }
    }

    @Service
    class HandlerTwo extends AbstractHandler{

        /**
         * 当前处理器只支持处理请求对象是String类型
         *
         * @param request 请求对象
         * @return 返回true / false
         */
        @Override
        public boolean support(Object request) {
            return request.getClass().isAssignableFrom(String.class);
        }

        /**
         * 处理器里面的具体方法
         *
         * @param request 请求对象
         */
        @Override
        public void toDoHandler(Object request) {
            System.out.println("处理器2进行处理"+request);
        }
    }

之后调用

    /**
     * 注入所有抽象处理器的实现类
     */
    @Autowired
    private List<AbstractHandler> abstractHandlers;

    @GetMapping("/interceptor/responsibility")
    public void responsibility(){
    // 这里使用String类型的请求对象
        String request = "哈哈哈";

		// 循环所有的处理器判断那个处理器能够处理String类型的请求参数然后执行
        for (AbstractHandler abstractHandler : abstractHandlers) {
            if(abstractHandler.support(request)){
                abstractHandler.toDoHandler(request);
            }
        }
    }
结果:
处理器2进行处理哈哈哈