JAVA 实现 委托（事件）暂时只有无参的

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author 乔占江 qq:59663479
 * @Data 2021/1/23 20:37
 * @Description 委托实现，无参数版本，未考虑多线程安全
 * @Version 1.0
 */
public class Event {

    // 管理所有的 委托事件
    private static Map<String, List<EventDefine>> events = new HashMap<>();

    public static void init() {
        // 暂时在这里 写发布逻辑，以后考虑写一个A接口
        // 想发布委托，就实现这个接口；
        // 建议一个 模块仅仅一个类实现，将所有注册写在其中，方便他人查看
        // 这个init会 查看所有实现A接口的方法，然后调用 发布方法；

        // 发布一个 demo 委托
        Event.release("demo");

    }

    /**
     * 发布一个委托
     *
     * @param eventName 委托的名字
     */
    public static void release(String eventName) {
        List<EventDefine> eventDefines = events.get(eventName);
        if (eventDefines != null) {
            throw new RuntimeException("已存在的委托");
        }
        System.out.println("发布了一个委托，eventName为" + eventName);
        // 这里不创建 List,因为不一定有人 关注
        events.put(eventName, null);
    }

    /**
     * 注册（关注） 一个 委托
     *
     * @param object     关注这个委托的对象 （A对象要关注 XX事件，这里就传A）
     * @param methodName 当事件被触发，通知A对象的哪个方法
     * @return 返回false表示 没有这个 委托
     */
    public static boolean register(Object object, String eventName, String methodName) {
        if (!events.containsKey(eventName)) {
            return false;
        }

        List<EventDefine> defines = events.get(eventName);
        if (defines == null) {
            defines = new ArrayList<>();
            events.put(eventName, defines);
        }
        defines.add(new EventDefine(object, methodName));
        return true;
    }

    /**
     * 不再关注 eventName
     *
     * @param object    哪个对象不想关注了
     * @param eventName
     */
    public static void remove(Object object, String eventName) {
        List<EventDefine> defines = events.get(eventName);
        if (defines == null || object == null) {
            return;
        }

        for (int i = 0; i < defines.size(); i++) {
            if (object.equals(defines.get(i).object)) {
                System.out.println(object + "不再关注 " + eventName);
                defines.remove(i);
                return;
            }
        }
    }


    // 触发事件
    public static void invoke(String eventName) {
        List<EventDefine> defines = events.get(eventName);
        if (defines == null || defines.size() == 0) {
            return;
        }

        try {

            for (EventDefine define : defines) {
                Method method = define.object.getClass().getMethod(define.methodName, null);
                if (method != null) {
                    method.invoke(define.object);
                }
            }

        } catch (Exception e) {
            System.out.println("eventName为：" + eventName + "的调用发生了错误");
            e.printStackTrace();
        }
    }

    private static class EventDefine {
        // 关注 委托的对象
        private Object object;
        // 关注 委托的方法名
        private String methodName;

        public EventDefine(Object object, String methodName) {
            this.object = object;
            this.methodName = methodName;
        }
    }

}

import com.card.event.Event;

public class EventDemo {

    public static void main(String[] args) {
        Event.init();
        EventDemo eventDemo1 = new EventDemo();
        System.out.println(eventDemo1 + " 关注了 demo 的事件");
        Event.register(eventDemo1,"demo","demo");


        EventDemo eventDemo2 = new EventDemo();
        System.out.println(eventDemo2 + " 关注了 demo 的事件");
        Event.register(eventDemo2,"demo","demo");



        EventDemo eventDemo3 = new EventDemo();
        System.out.println(eventDemo3 + " 关注了 demo 的事件");
        Event.register(eventDemo3,"demo","demo");


        // eventDemo2 不再关注
        Event.remove(eventDemo2,"demo");

        // 触发demo 事件
        Event.invoke("demo");

    }

    public void demo(){
        System.out.println(this + " 收到通知");
    }

}

标签：无参,JAVA,委托,demo,object,Event,eventName,public,defines
来源： https://blog.csdn.net/qq_43081517/article/details/113061617