VALUE   \r\n
\r\n
VALUE   \r\n
\r\n
END
del

del  [noreply]\r\n

 /**
 * 各種指令
 * 目前支持get，set，delete
 *
 * 以及自定義的
 * error，end
 */
public interface Command {

  /**
   * 執(zhí)行指令
   * @param reader
   * @param writer
   */
  void execute(Reader reader, Writer writer);

  /**
   * 獲取指令的類型
   * @return
   */
  CommandType getType();
}

/**
 * 指令工廠 單一實(shí)例
 */
public class CommandFactory {

  private static CommandFactory commandFactory;
  private static Cache memcache;
  private CommandFactory(){}

  public static CommandFactory getInstance(Cache cache) {
    if (commandFactory == null) {
      commandFactory = new CommandFactory();
      memcache = cache;
    }
    return commandFactory;
  }

  /**
   * 根據(jù)指令的類型獲取Command
   * @param commandLine
   * @return
   */
  public Command getCommand(String commandLine){
    if (commandLine.matches("^set .*$")){
      return new SetCommand(commandLine, memcache);
    }else if (commandLine.matches("^get .*$")){
      return new GetCommand(commandLine, memcache);
    }else if (commandLine.matches("^del .*$")){
      return new DeleteCommand(commandLine, memcache);
    }else if (commandLine.matches("^end$")){
      return new EndCommand(commandLine);
    }else{
      return new ErrorCommand(commandLine, ErrorCommand.ErrorType.ERROR);
    }
  }
}

/**
 * 刪除緩存指令
 */
public class DeleteCommand implements Command{

  private final String command;
  private final Cache cache;

  private String key;
  private boolean noReply;
  public DeleteCommand(final String command, final Cache cache){
    this.command = command;
    this.cache = cache;
    initCommand();
  }

  private void initCommand(){
    if (this.command.contains("noreply")){
      noReply = true;
    }
    String[] info = command.split(" ");
    key = info[1];
  }

  @Override
  public void execute(Reader reader, Writer writer) {
    BufferedWriter bfw = (BufferedWriter) writer;
    Item item = cache.delete(key);
    if (!noReply){
      try {
        if (item == null){
          bfw.write("NOT_FOUND\r\n");
        }else {
          bfw.write("DELETED\r\n");
        }
        bfw.flush();
      } catch (IOException e) {
        try {
          bfw.write("ERROR\r\n");
          bfw.flush();
        } catch (IOException e1) {
          e1.printStackTrace();
        }
        e.printStackTrace();
      }
    }


  }

  @Override
  public CommandType getType() {
    return CommandType.SEARCH;
  }
}

public class Memcache implements Cache{
  private Logger logger = Logger.getLogger(Memcache.class.getName());
  //利用LinkedHashMap實(shí)現(xiàn)LRU
  private static LinkedHashMap cache;
  private final int maxSize;
  //負(fù)載因子
  private final float DEFAULT_LOAD_FACTOR = 0.75f;
  public Memcache(final int maxSize){
    this.maxSize = maxSize;
    //確保cache不會(huì)在達(dá)到maxSize之后自動(dòng)擴(kuò)容
    int capacity = (int) Math.ceil(maxSize / DEFAULT_LOAD_FACTOR) + 1;

    this.cache = new LinkedHashMap(capacity, DEFAULT_LOAD_FACTOR, true){
      @Override
      protected boolean removeEldestEntry(Map.Entry eldest) {
        if (size() > maxSize){
          logger.info("緩存數(shù)量已經(jīng)達(dá)到上限，會(huì)刪除最近最少使用的條目");
        }
        return size() > maxSize;
      }
    };

    //實(shí)現(xiàn)同步訪問
    Collections.synchronizedMap(cache);
  }

  public synchronized boolean isFull(){
    return cache.size() >= maxSize;
  }

  @Override
  public Item get(String key) {
    Item item = cache.get(key);

    if (item == null){
      logger.info("緩存中key:" + key + "不存在");
      return null;
    }else if(item!=null && item.isExpired()){ //如果緩存過期則刪除并返回null
      logger.info("從緩存中讀取key:" + key + " value:" + item.getValue() + "已經(jīng)失效");
      cache.remove(key);
      return null;
    }

    logger.info("從緩存中讀取key:" + key + " value:" + item.getValue() + " 剩余有效時(shí)間" + item.remainTime());
    return item;
  }

  @Override
  public void set(String key, Item value) {
    logger.info("向緩存中寫入key:" + key + " value:" + value);
    cache.put(key, value);
  }

  @Override
  public Item delete(String key) {
    logger.info("從緩存中刪除key:" + key);
    return cache.remove(key);
  }

  @Override
  public int size(){
    return cache.size();
  }

  @Override
  public int capacity() {
    return maxSize;
  }

  @Override
  public Iterator> iterator() {
    return cache.entrySet().iterator();
  }
}

/**
 * 緩存管理器
 * 后臺(tái)線程
 * 將cache中過期的緩存刪除
 */
public class CacheManager implements Runnable {

  private Logger logger = Logger.getLogger(CacheManager.class.getName());

  //緩存
  public Cache cache;

  public CacheManager(Cache cache){
    this.cache = cache;
  }


  @Override
  public void run() {
    while (true){
      Iterator> itemIterator = cache.iterator();
      while (itemIterator.hasNext()){
        Map.Entry entry = itemIterator.next();
        Item item = entry.getValue();
        if(item.isExpired()){
          logger.info("key:" + entry.getKey() + " value" + item.getValue() + " 已經(jīng)過期，從數(shù)據(jù)庫(kù)中刪除");
          itemIterator.remove();
        }
      }

      try {
        //每隔5秒鐘再運(yùn)行該后臺(tái)程序
        TimeUnit.SECONDS.sleep(5);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

    }
  }
}

/**
 * 服務(wù)器
 */
public class IOServer implements Server {
  private boolean stop;
  //端口號(hào)
  private final int port;
  //服務(wù)器線程
  private ServerSocket serverSocket;
  private final Logger logger = Logger.getLogger(IOServer.class.getName());
  //線程池，線程容量為maxConnection
  private final ExecutorService executorService;
  private final Cache cache;
  public IOServer(int port, int maxConnection, Cache cache){
    if (maxConnection<=0) throw new IllegalArgumentException("支持的最大連接數(shù)量必須為正整數(shù)");
    this.port = port;
    executorService = Executors.newFixedThreadPool(maxConnection);
    this.cache = cache;
  }

  @Override
  public void start() {
    try {
      serverSocket = new ServerSocket(port);
      logger.info("服務(wù)器在端口"+port+"上啟動(dòng)");
      while (true){
        try {
          Socket socket = serverSocket.accept();
          logger.info("收到"+socket.getLocalAddress()+"的連接");
          executorService.submit(new SocketHandler(socket, cache));
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    } catch (IOException e) {
      logger.log(Level.WARNING, "服務(wù)器即將關(guān)閉...");
      e.printStackTrace();
    } finally {
      executorService.shutdown();
      shutDown();
    }


  }

  /**
   * 服務(wù)器是否仍在運(yùn)行
   * @return
   */
  public boolean isRunning() {
    return !serverSocket.isClosed();
  }
  /**
   * 停止服務(wù)器
   */
  public void shutDown(){
    try {
      if (serverSocket!=null){
        serverSocket.close();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

/**
 * 處理各個(gè)客戶端的連接
 * 在獲得end指令后關(guān)閉連接s
 */
public class SocketHandler implements Runnable{

  private static Logger logger = Logger.getLogger(SocketHandler.class.getName());

  private final Socket socket;

  private final Cache cache;

  private boolean finish;


  public SocketHandler(Socket s, Cache cache){
    this.socket = s;
    this.cache = cache;
  }

  @Override
  public void run() {
    try {
      //獲取socket輸入流
      final BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      //獲取socket輸出流
      final BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

      CommandFactory commandFactory = CommandFactory.getInstance(cache);

      while (!finish){
        final String commandLine = reader.readLine();
        logger.info("ip:" + socket.getLocalAddress() + " 指令:" + commandLine);

        if (commandLine == null || commandLine.trim().isEmpty()) {
          continue;
        }

        //使用指令工廠獲取指令實(shí)例
        final Command command = commandFactory.getCommand(commandLine);
        command.execute(reader, writer);

        if (command.getType() == CommandType.END){
          logger.info("請(qǐng)求關(guān)閉連接");
          finish = true;
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
      logger.info("關(guān)閉來自" + socket.getLocalAddress() + "的連接");
    } finally {
      try {
        if (socket != null){
          socket.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}