SpringCloud学习笔记（一、SpringCloud 基础）

目录：

• 概述
• 观察者模式
• 代理模式

概述：

spring系列中使用了大量的设计模式，而最常见的便是这观察者、代理模式，所以在讲解SpringCloud之前我们先学习下这两个最常见的设计模式。

观察者模式：

java实现了自己的观察者模式 >>> java.util.Observable；

1、public synchronized void addObserver(Observer o)；添加一个观察者

2、public synchronized void deleteObserver(Observer o)；删除一个观察者

3、protected synchronized void setChanged()；修改通知标记，使得观察者观察的对象发生变化时能记得得知

4、public void notifyObservers(Object arg) ；通知观察者，被观察这已发生变化

 public class ObserverDemo extends Observable {

     /**
      * 通知观察者被观察者已发生变化
      */
     public void notifyObserver() {
         // 设置变化状态为true >>> 被观察者已发生变化
         this.setChanged();
         // 将这一变化通知观察者
         this.notifyObservers();
     }

     public static void main(String[] args) {
         testAddObserver();
         testDeleteObserver();
     }

     private static void testAddObserver() {
         ObserverDemo observerDemo = new ObserverDemo();
         observerDemo.addObserver((o, arg) -> System.err.println("服务列表发生变化1"));
         observerDemo.notifyObserver();
     }

     private static void testDeleteObserver() {
         ObserverDemo observerDemo = new ObserverDemo();
         Observer observer = (o, arg) -> System.err.println("服务列表发生变化2");

         observerDemo.addObserver(observer);
         observerDemo.notifyObserver();
         observerDemo.deleteObserver(observer);
         observerDemo.notifyObserver();
     }
 }

代理模式：

1、静态代理

代理就是将除了自己本身需要做的核心业务外的任务交给代理人来做，如明星将接广告等事情交给经纪人。

 public interface Agent {

     /**
      * 拍广告
      */
     void advertising();
 }

 public class Celebrity implements Agent {

     @Override
     public void advertising() {
         System.err.println("Celebrity拍广告");
     }
 }

 public class Celebrity2 implements Agent {

     @Override
     public void advertising() {
         System.err.println("Celebrity2拍广告");
     }
 }

 public class ProxyDemo implements Agent {

     private Agent agent;

     public ProxyDemo(Agent agent) {
         this.agent = agent;
     }

     @Override
     public void advertising() {
         before();
         agent.advertising();
         after();
     }

     private void after() {
         System.err.println("after");
     }

     private void before() {
         System.err.println("before");
     }
 }

 class ProxyClient {

     public static void main(String[] args) {
         Agent agent = new ProxyDemo(new Celebrity());
         agent.advertising();

         System.out.println("----------------------------");

         Agent agent2 = new ProxyDemo(new Celebrity2());
         agent2.advertising();
     }
 }

静态代理的缺点是如果代理对象新代理了一个行为，那么委托对象也需要将新的代理行为重实现一遍，这样非常繁琐且重复。

为什么说静态代理繁琐呢，我们来增加一个行为。

 public interface Agent {
     /**
      * 拍广告
      */
     void advertising();

     /**
      * 集资
      */
     void collectMoney();
 }

然后我们修改一下Celebrity、Celebrity2

 public class Celebrity implements Agent {

     @Override
     public void advertising() {
         System.err.println("Celebrity拍广告");
     }

     @Override
     public void collectMoney() {
         System.err.println("Celebrity集资");
     }
 }

 public class Celebrity2 implements Agent {

     @Override
     public void advertising() {
         System.err.println("Celebrity2拍广告");
     }

     @Override
     public void collectMoney() {
         System.err.println("Celebrity2集资");
     }
 }

然后我们看看修改后的ProxyDemo

 public class ProxyDemo implements Agent {

     private Agent agent;

     public ProxyDemo(Agent agent) {
         this.agent = agent;
     }

     @Override
     public void advertising() {
         before();
         agent.advertising();
         after();
     }

     @Override
     public void collectMoney() {
         before();
         agent.collectMoney();
         after();
     }

     private void after() {
         System.err.println("after");
     }

     private void before() {
         System.err.println("before");
     }
 }

 class ProxyClient {

     public static void main(String[] args) {
         Agent agent = new ProxyDemo(new Celebrity());
         agent.advertising();
         agent.collectMoney();

         System.out.println("----------------------------");

         Agent agent2 = new ProxyDemo(new Celebrity2());
         agent2.advertising();
         agent2.collectMoney();
     }
 }

我们发现仅仅增加一个行为委托类也要实现collectMoney，实现时不仅需要调用agent.collectMoney，还需要调用before和after是不是很麻烦，而接下来要讲的动态代理正是为了解决这一问题。

2、动态代理

动态代理的例子还是和静态代理一样，我们首先将委托类写好。

 public class DynamicProxyDemo implements InvocationHandler {

     private Object target;

     public DynamicProxyDemo(Object target) {
         this.target = target;
     }

     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         after();
         Object invoke = method.invoke(target, args);
         before();
         return invoke;
     }

     private void after() {
         System.err.println("after");
     }

     private void before() {
         System.err.println("before");
     }

     public Object getProxy() {
         return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
     }
 }

其中最重要的是InvocationHandler接口和getProxy方法。

此时我们再往Agent增加一个行为，Celebrity、Celebrity2省略

 public interface Agent {
     /**
      * 拍广告
      */
     void advertising();

     /**
      * 集资
      */
     void collectMoney();

     /**
      * 安排行程
      */
     void travelArrangements();
 }

然后我们发现，DynamicProxyDemo不需要再实现新的行为了，这都归功于InvocationHandler !!!∑(ﾟДﾟノ)ノ

 class DynamicProxyClient {

     public static void main(String[] args) {
         DynamicProxyDemo dynamic = new DynamicProxyDemo(new Celebrity());
         Agent agent = (Agent) dynamic.getProxy();
         agent.advertising();
         agent.collectMoney();
         agent.travelArrangements();
     }
 }