简单工厂模式

• 使用场景：
  1、 工厂类负责创建的对象比较少
  2、客户端只需要传递工厂类的参数，而无须关心创建对象的逻辑
• 优点：使用户根据参数获取得对应的类实例，避免了直接实例化对象，降低耦合性
• 缺点：可实例化的类型在编译期间已被缺点。如果新增新类型，则需要修改工厂，这是违背了开放封闭原则。简单工厂需要知道所有要成的类型，、其当子类过多或者子类层次过多时不适合使用。

 //抽象产品
    public abstract class Computer {
        /**
         * 产品的抽象方法，有具体的产品类实现
         */
        public abstract void start();
    }

 //具体的产品
    public class LenovoComputer extends Computer {

        @Override
        public void start() {
            System.out.println("联想计算机启动");
        }
    }

    public class HpComputer extends Computer {

        @Override
        public void start() {
            System.out.println("惠普计算机启动");
        }
    }

    public class AsusComputer extends Computer {

        @Override
        public void start() {
            System.out.println("华硕计算机启动");
        }
    }


public  class ComputerFactory {
    //工厂类
    public static Computer createComputer(String type) {
        switch (type) {
            case "lenovo":
                return new LenovoComputer();
            case "hp":
                return new HpComputer();
            case "asus":
                return new AsusComputer();

        }
        return null;
    }
}

测试

 @Test
 public void test(){
 Computer computer = ComputerFactory.createComputer("lenovo");
 computer.start();
}

locat

联想计算机启动

代理模式的简单实现

• 代理模式从编码的角度来说可以分为静态代理和动态代理。

//抽象主题
public interface IShop {
    void buy();
}

//真实的主题
public class Man  implements IShop {

    @Override
    public void buy() {
        System.out.println("购买");
    }
}

//代理类
public class PurchingProxy implements IShop {
    private IShop mShop;
    public PurchingProxy(IShop mShop) {
        this.mShop = mShop;
    }

    @Override
    public void buy() {
        mShop.buy();
    }
}

测试

    @Test
    public void test2(){
        IShop man = new Man();
        IShop proxy = new PurchingProxy(man);
        proxy.buy();
    }

动态代理模式

public class DynamicPurchasing implements InvocationHandler {
    private Object object;

    public DynamicPurchasing(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object resut = method.invoke(object, args);
        if (method.getName().equals("buy")){
            System.out.println("DynamicPurchasing,buy");
        }
        return resut;
    }
}

测试

  @Test
    public void test3(){
        IShop man = new Man();
        DynamicPurchasing dynamicPurchasing = new DynamicPurchasing(man);
        ClassLoader classLoader = man.getClass().getClassLoader();
        IShop purchasing= (IShop) Proxy.newProxyInstance(classLoader, new Class[]{IShop.class}, dynamicPurchasing);
        purchasing.buy();
    }

locat

购买
DynamicPurchasing,buy

观察者模式

• 使用场景：
  1、关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。
  2、事件多级触发场景
  3、跨系统的消息交换场景，如消息队列、事件总线的处理机制。
• 优点：
  1、观察者和被观察者之间是抽象耦合，容易扩展。
  2、方便建立一套触发机制。
• 缺点：
  1、在应用观察者模式时需要考虑一下开发效率和运行效率的问题。程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行的，那么一个观察者卡段，会影响到整体的执行效率，在这种情况下，一般采用异步方式。

//抽象观察者
public interface Observer {
    public void update(String message);
}


//具体的观察者
public class WeixinUser implements Observer {
    private String username;

    public WeixinUser(String username) {
        this.username = username;
    }

    @Override
    public void update(String message) {
        System.out.println(username+ " - "+message);

    }
}


public interface Subject {
    /**
     * 增加订阅者
     * @param observer
     */
    public void attach(Observer observer);

    /**
     * 删除订阅者
     * @param observer
     */
    public void detach(Observer observer);

    /**
     * 通知订阅者更新消息
     * @param message
     */
    public void notify(String message);
}




//具体被观察者
public class SubScriptionSubject implements Subject {

    private List<Observer> weixinUserList = new ArrayList<>();

    @Override
    public void attach(Observer observer) {
        weixinUserList.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        weixinUserList.remove(observer);
    }

    @Override
    public void notify(String message) {
        for (Observer observer : weixinUserList) {
            observer.update(message);
        }
    }
}

测试

    @Test
    public void test4(){
        SubScriptionSubject subScriptionSubject = new SubScriptionSubject();
        //创建用户
        WeixinUser user1 = new WeixinUser("小米");
        WeixinUser user2 = new WeixinUser("小红");
        WeixinUser user3 = new WeixinUser("小胡");
        //订阅公众号
        subScriptionSubject.attach(user1);
        subScriptionSubject.attach(user2);
        subScriptionSubject.attach(user3);
        //公众号跟新发消息给订阅的微信用户
        subScriptionSubject.notify("王炸的专栏更新了");
    }

logcat

小米 - 王炸的专栏更新了
小红 - 王炸的专栏更新了
小胡 - 王炸的专栏更新了