发表于 | | 阅读次数:
字数统计: 894 | 阅读时长 ≈ 3min

在23种设计模式中，装饰者模式在游戏开发的过程中，使用的很是频繁。因为这个设计模式，把所有的业务的逻辑封装的对应的实体类中，从而为主流程减负了。首先看下一个应用场景

装饰者模式的应用

我们都知道有一款经典游戏90坦克，这个游戏中，玩家坦克来操作坦克打击AI敌人，在没打死一个红色坦克就会掉下来一个装备，这个装备可以提升移动速度，增加攻击力。

阅读全文 »

发表于 | | 阅读次数:
字数统计: 288 | 阅读时长 ≈ 1min

启动zookeeper

1
2
$ bin/zkServer.sh start conf/zoo.cfg &
$ bin/zkCli.sh

启动Kafka

我们启动两个实例：

1
2
$ bin/kafka-server-start.sh -daemon config/server.properties
$ bin/kafka-server-start.sh -daemon config/server-1.properties

阅读全文 »

发表于 | | 阅读次数:
字数统计: 210 | 阅读时长 ≈ 1min

未选择的路
（罗伯特·弗罗斯特）

黄色的树林里分出两条路
可惜我不能同时去涉足
我在那路口久久伫立
我向着一条路极目望去

阅读全文 »

发表于 | | 阅读次数:
字数统计: 936 | 阅读时长 ≈ 3min

Kafka是基于partition的模型，在消费的时候，消费者会和kafka建立一个绑定的关系。假设有一个topic有3个partition：P1,P2,P3,同时有一个消费group对应有3个消费者:C1，C2，C3，则消费会建立一个P1-C1,P2-C2,P3-C3的关系。

阅读全文 »

发表于 | | 阅读次数:
字数统计: 879 | 阅读时长 ≈ 3min

几个概念

broker：集群中的每一台服务器，称为Broker

topic或者subject:队列名

partition：一个队列中的消息可以存储到多台broker上面，一个broker中的分区，称为partition

阅读全文 »

发表于 | | 阅读次数:
字数统计: 89 | 阅读时长 ≈ 1min

作息助手

早就有想写一个时钟的想法，今天用js实现了一个，功能点如下(点击链接)：

  1. 自动同步客户端时间，1s一次
  2. 工作的时常为90min，自动靠拢整点半点
  3. 休息时间为30min
  4. 可以发送桌面通知和声音，前提是浏览器支持
    阅读全文 »

发表于 | | 阅读次数:
字数统计: 338 | 阅读时长 ≈ 1min

观察者模式

观察者模式是一个消息的派发的模式，是把被观察者的状态能够及时的通知给观察者。

比如一个超市的打折了，需要把消息通知给每一个超市的顾客，这样就可以把超市作为一个被观察者，而顾客是观察者。

实现逻辑

观察者模式实现的类图如下：

观察者模式

实现步骤：

  1. 定义一个Observer接口，约束观察者（顾客）需要实现的方法： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

    public interface Observer {
        void reciveMessage(double price);
    }

    public class CusmtomerObserver1 implements Observer {
        @Override
        public void reciveMessage(double price) {
            
            System.out.println("CusmtomerObserver1 收到了价格消息：" + price);
        }
    }

    public class CusmtomerObserver2 implements Observer {
        @Override
        public void reciveMessage(double price) {
            
            System.out.println("CusmtomerObserver2 收到了价格消息：" + price);
        }
    }

  2. 实现被观察对象的方法 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    public class MarketSubject {
        private double price;
        public double getPrice() {
            return price;
        }

        public void setPrice(double price) {
            this.price = price;
            notifyObserver(price);
        }
        
        private ArrayList<Observer> observerList=new ArrayList<>();
        public void addObserver(Observer observer){
            observerList.add(observer);
        }
        
        public void removeObserver(Observer observer){
            observerList.remove(observer);
        }
        
        public void notifyObserver(double price){
            for (Observer ob : observerList) {
                ob.reciveMessage(price);
            }
        }
    }

  3. 实现方法的注册和通知 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class ObserverMain {
        public static void main(String[] args) {
            MarketSubject marketSubject=new MarketSubject();
            marketSubject.addObserver(new CusmtomerObserver1());
            marketSubject.addObserver(new CusmtomerObserver2());
            marketSubject.setPrice(100d);
        
        }
    }

    运行结果： 

1
2
CusmtomerObserver1 收到了价格消息：100.0
CusmtomerObserver2 收到了价格消息：100.0
阅读全文 »

发表于 | | 阅读次数:
字数统计: 603 | 阅读时长 ≈ 2min

命令模式

命令模式是把对象的操作方法分成一个命令，分别去执行。在分布式环境中，熔断和降级组件使用的设计模式就是命令模式。

为了了解什么是设计模式，可以类比下设计一个万能遥控器的设置，遥控器只负责一个方法的调用，真正的方法实现都在对应的电器上面。

使用的时候，只需要对对应的命令和实体进行注册下就可以了。具体的设计类图如下：

IO

具体实现代码分下面几个步骤：

  1. 定义实体方法的约束，也就是当前类实体有哪些方法，比如控制灯和电视，都有开和关的方法 

    1
    2
    3
    4
    5
    6
    public interface CommandObj {
        
        void on() ;
        
        void off();
    }

  2. 定义对应的类实体具体的实现方法 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class Light implements CommandObj {
        public void on(){
            System.out.println("打开电灯。。。");
        }
        
        public void off(){
            System.out.println("关闭电灯。。。");
        }
    }

    public class TV implements CommandObj{
        public void on(){
            System.out.println("打开电视。。。");
        }
        
        public void off(){
            System.out.println("关闭电视。。。");
        }
        
    }

  3. 定义一个命令执行的约束，来约束所有的Command的执行者需要实现的方法

    此处需要注意，在是实现了同一个CommandObj接口的实体，不需要Command的约束，为了Demo的完整性，把Commad接口加上。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    public interface Command {
        void execute();
    }    

    public class WrapperOffCommand  implements Command {
        CommandObj commandObj;
        
        public WrapperOffCommand(CommandObj commandObj){
            this.commandObj = commandObj;
        }
        
        @Override
        public void execute() {
            commandObj.off();
        }
    }

    public class WrapperOnCommand implements Command {
        CommandObj commandObj;
        
        public WrapperOnCommand(CommandObj commandObj){
            this.commandObj = commandObj;
        }
        
        @Override
        public void execute() {
            commandObj.on();
        }
    }

  4. 实现Controller的方法，即控制器本身 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    public class RemoteController {
        ConcurrentHashMap<String,Command> onCommands;
        ConcurrentHashMap<String,Command> offCommands;
        
        public RemoteController(){
            this.onCommands = new ConcurrentHashMap<>();
            this.offCommands = new ConcurrentHashMap<>();
        }
        
        public void registerCommand(String key, Command onCommand, Command offCommand){
            onCommands.put(key,onCommand);
            offCommands.put(key,offCommand);
        }
        
        // 按下开按钮
        public void onButtonPressed(String key){
            onCommands.get(key).execute();
        }
        
        // 按下关按钮
        public void offButtonPressed(String key){
            offCommands.get(key).execute();
        }
    }

  5. 控制器的使用 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
       public static void main(String[] args) {
    	CommandObj light = new Light();
    	CommandObj tv = new TV();
    	
    	Command lightOn = new WrapperOnCommand(light);
    	Command lightOff = new WrapperOffCommand(light);
    	Command TVOn = new WrapperOnCommand(tv);
    	Command TVOff = new WrapperOffCommand(tv);
    	
    	
    	RemoteController remoteController = new RemoteController();
           //注册对应的命令
    	remoteController.registerCommand(RemoteTypeEnum.Light.toString(), lightOn, lightOff);
           //注册对应的命令
    	remoteController.registerCommand(RemoteTypeEnum.TV.toString(), TVOn, TVOff);
    	
    	
    	remoteController.onButtonPressed(RemoteTypeEnum.Light.toString());
    	remoteController.offButtonPressed(RemoteTypeEnum.Light.toString());
    	remoteController.onButtonPressed(RemoteTypeEnum.TV.toString());
    	remoteController.offButtonPressed(RemoteTypeEnum.TV.toString());
    }
阅读全文 »