设计模式-观察者模式

观察者模式：

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。具体如以下案例：

一、使用原生方法

1．在com.cyb包下建立springboot启动类：

@SpringBootApplication
public class AppObServer {
    public static void main(String[] args) {
        SpringApplication.run(AppObServer.class);
    }
}

2．在com.cyb.observice包下建立观察者接口

/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:29
 *  @Description:观察者接口
 */
public interface ObServer {

    void sendMsg(JSONObject jsonObject);
}

3．在com.cyb.observer.impl包下建立观察者实行类

/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:28
 *  @Description:邮件观察者
 */
@Component
@Slf4j
public class EmailObServer implements ObServer {
    @Override
    public void sendMsg(JSONObject jsonObject) {
        log.info("使用观察者发送邮件");
    }
}
/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:28
 *  @Description:短信观察者
 */
@Component
@Slf4j
public class SMSObServer implements ObServer {
    @Override
    public void sendMsg(JSONObject jsonObject) {
        log.info("使用观察者发送短信");
    }
}

4．在com.cyb.observer包下建立观察者主题类，供调用

/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:28
 *  @Description:自定义观察者主题
 */
@Component
public class CybSubject {

    /**
     * 类型 ObServer
     */
    private List<ObServer> listObServer = new ArrayList<>();
    /**
     * 线程池
     */
    private ExecutorService executorService;


    public CybSubject() {
        executorService = Executors.newFixedThreadPool(10);
    }

    /**
     * 新增ObServer
     *
     * @param obServer
     */
    public void addObServer(ObServer obServer) {
        listObServer.add(obServer);
    }

    /**
     * 通知给所有的观察者
     *每分发一个观察者就开启一个线程
     * @param jsonObject
     */
    public void notifyObServer(JSONObject jsonObject) {
        for (ObServer obServer :
                listObServer) {
            // 单独开启线程异步通知
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    obServer.sendMsg(jsonObject);
                }
            });
        }
    }

5．在com.cyb.start包下建立项目启动成功后自动执行方法

/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:30
 *  @Description:设置项目启动成功后自动加载类，把SMSObServer和EmailObServer等对象放置该类启动的原因是防止在调用时由于加载问题，
 *  执行时还未加载，特放此避免该问题的发生，但是在添加是使用了动态添加，我们不需要手动注入对象，具体如下代码
 *   Map<String, ObServer> map = applicationContext.getBeansOfType(ObServer.class);
 */
@Component
public class StartService implements ApplicationRunner, ApplicationContextAware {
    /***
     * 被：Map<String, ObServer> map = applicationContext.getBeansOfType(ObServer.class);方法替代
     */
    @Autowired
    private SMSObServer smsObServer;
    /***
     * 被：Map<String, ObServer> map = applicationContext.getBeansOfType(ObServer.class);方法替代
     */
    @Autowired
    private EmailObServer emailObServer;
    @Autowired
    private CybSubject cybSubject;


    private ApplicationContext applicationContext;

    /**
     * 当我们的SpringBoot启动成功的时候，注册我们的SMSObServer
     * 皮卡丘
     *
     * @param args
     * @throws Exception
     */
    @Override
    public void run(ApplicationArguments args) throws Exception {
        /**
         * 自动注册我们观察者
         *
         * 1.使用Spring获取该ObServer下有那些bean对象
         * 2.直接注添加到集合中
         *
         */
        //根据接口类型返回相应的所有bean
        Map<String, ObServer> map = applicationContext.getBeansOfType(ObServer.class);
        for (String key : map.keySet()) {
            ObServer obServer = map.get(key);
            cybSubject.addObServer(obServer);
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

二、使用spring提供的观察者模式： 

1、在com.cyb.utils包下建立spring工具类

/**
 * SpringUtils 工具类
 */
@Component
public class SpringUtils implements ApplicationContextAware {


    private static ApplicationContext applicationContext = null;

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }


    public static <T> T getBean(String beanId) {
        return (T) applicationContext.getBean(beanId);
    }

    public static <T> T getBean(Class<T> requiredType) {
        return (T) applicationContext.getBean(requiredType);
    }


    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtils.applicationContext = applicationContext;
    }

}

2、在com.cyb.entity包下建立实体

/*
使用spring观察者，需要继承ApplicationEvent
 */
public class UserMessageEntity extends ApplicationEvent {
    private String email;
    private String phone;
    private String userId;

    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public UserMessageEntity(Object source) {
        super(source);
    }

    public UserMessageEntity(Object source, String email, String phone) {
        super(source);
        this.email = email;
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "email:" + email + ",phone:" + phone;
    }
}

3、在com.cyb.listener包下建立对应的观察者对象

/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:26
 *  @Description:使用spring观察者-邮件监听
 */
@Component
public class EmailListener implements ApplicationListener<UserMessageEntity> {
    /**
     * 监听的方法
     *
     * @param event
     */
    @Override
    @Async
    public void onApplicationEvent(UserMessageEntity event) {
        System.out.println(Thread.currentThread().getName()+"邮件:" + event.toString());
    }
}
/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:27
 *  @Description:使用spring观察者-短信监听
 */
@Component
public class SmSListener implements ApplicationListener<UserMessageEntity> {
    /**
     * 监听的方法
     *
     * @param event
     */
    @Override
    public void onApplicationEvent(UserMessageEntity event) {
        System.out.println("短信:" + event.toString());
    }
}

在com.cyb.service包下建立控制层

/**
 *  @author: cyb
 *  @Date: 2020-05-24 11:29
 *  @Description:接口层
 */
@RestController
@Slf4j
public class OrderService {


    @Autowired
    private CybSubject cybSubject;
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;
    @RequestMapping("/addOrder")
    public String addOrder() {
        log.info("1.调用数据库下单订单代码:");
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("sms", "1865891111");
        jsonObject.put("email", "963859193@qq.com");
        cybSubject.notifyObServer(jsonObject);
        return "success";
    }

    @RequestMapping("/addOrder2")
    public String addOrder2() {
        log.info("1.调用数据库下单订单代码:");
        UserMessageEntity userMessageEntity = new UserMessageEntity(
                this, "963859193@qq.com", "1865891111");
        applicationEventPublisher.publishEvent(userMessageEntity);
        return "success";
    }
}

以上则为观察模式的两种写法，该以上内容参照于余胜军，对其感兴趣的请点击链接进行了解，转发该篇博客时请大家说明出处。

技术在于沟通！