@Override
    public CExternalSetting[] getExternalSettings() {
      IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(fProjName);
      if (project.isAccessible()) {
        ICProjectDescription des =
            CProjectDescriptionManager.getInstance().getProjectDescription(project, false);
        if (des != null) {
          ICConfigurationDescription cfg =
              fCfgId.length() != 0
                  ? des.getConfigurationById(fCfgId)
                  : des.getActiveConfiguration();

          if (cfg != null) {
            CExternalSetting[] es;
            ICExternalSetting[] ies = cfg.getExternalSettings();
            if (ies instanceof CExternalSetting[]) es = (CExternalSetting[]) ies;
            else {
              es = new CExternalSetting[ies.length];
              System.arraycopy(ies, 0, es, 0, es.length);
            }
            // Update the cache with the real settings this configuration is exporting
            cachedSettings.put(fId, es);
            return es;
          }
        }
      }
      // If project not yet accessible, just return the previous settings
      // for the moment. We'll update again when the referenced project reappears
      if (!cachedSettings.containsKey(fId) && prevSettings.length > 0)
        cachedSettings.putIfAbsent(fId, prevSettings);
      if (prevSettings.length == 0 && cachedSettings.containsKey(fId))
        return cachedSettings.get(fId);
      return prevSettings;
    }
  /*
   * Returns all nearby terrain that is walkable.
   * Used for calculating what nearby squares a unit can go to.
   */
  public void getWalkableTerrain() {
    walkable = new ArrayList<Coordinate>(IMMEDIATE_WALKABLE);
    Unit selUnit = unitMap.get(selectedTile);
    int moveRnge = selUnit.getMoveRange();
    int x = selectedTile.getX();
    // transform coords to tile coords, which is flipped about the x axis (y invert)
    int y = terrain.length - selectedTile.getY() - 1;

    Coordinate unitCoord = new Coordinate(-1, -1);
    // look at all 8 adjacent squares
    for (int i = x - moveRnge; i <= x + moveRnge; i++) {
      int r = Math.abs(Math.abs(i - x) - moveRnge);
      for (int j = y - r; j <= y + r; j++) {
        // skip over self
        if (i == x && j == y) continue;
        // make sure we don't go out of bounds
        if (i >= 0 && i < terrain[0].length && j >= 0 && j < terrain.length) {
          unitCoord.setX(i);
          unitCoord.setY(terrain.length - j - 1);
          // 1 is passable, 0 impassable terrain for now
          // also check to see if a unit isn't there -- stacking not allowed
          if ((terrain[j][i] == 1 && !unitMap.containsKey(unitCoord))
              || ((terrain[j][i] == 0 || terrain[j][i] == 2)
                  && selUnit.isMntnClimber()
                  && !unitMap.containsKey(unitCoord))) {
            // transform coordinate back
            walkable.add(new Coordinate(i, terrain.length - j - 1));
          }
        }
      }
    }
  }
  @Override
  public Iterable<Message> getNewMessages(String remoteNodeId) throws RemoteException {
    logger.debug("Requesting the new messages from node [" + remoteNodeId + "]");

    LinkedBlockingQueue<Message> newMessages = new LinkedBlockingQueue<Message>();

    for (MessageContainer messageContainer : broadcastedMessagesQueue) {
      if (!synchronizationTime.containsKey(remoteNodeId)
          || synchronizationTime.get(remoteNodeId) < messageContainer.getTimeStamp()) {
        newMessages.add(messageContainer.getMessage());
        logger.debug(
            "Message [" + messageContainer.getMessage() + "] added to the new messages to send");
      }
    }

    // set the synchronization time of the node
    long timeStamp = new DateTime().getMillis();
    if (synchronizationTime.containsKey(remoteNodeId)) {
      synchronizationTime.replace(remoteNodeId, timeStamp);
      logger.debug("Synchronization time replaced by new one");
    } else {
      synchronizationTime.put(remoteNodeId, timeStamp);
      logger.debug("Synchronization time setted by first time");
    }
    logger.debug("Node [" + remoteNodeId + "] synchronized at [" + timeStamp + "]");

    return newMessages;
  }
Example #4
0
 public FireJet(Player player) {
   if (instances.containsKey(player)) {
     // player.setAllowFlight(canfly);
     instances.remove(player);
     return;
   }
   if (timers.containsKey(player)) {
     if (System.currentTimeMillis()
         < timers.get(player)
             + (long) ((double) cooldown / Tools.getFirebendingDayAugment(player.getWorld()))) {
       return;
     }
   }
   factor = Tools.firebendingDayAugment(defaultfactor, player.getWorld());
   Block block = player.getLocation().getBlock();
   if (FireStream.isIgnitable(player, block)
       || block.getType() == Material.AIR
       || AvatarState.isAvatarState(player)) {
     player.setVelocity(
         player.getEyeLocation().getDirection().clone().normalize().multiply(factor));
     block.setType(Material.FIRE);
     this.player = player;
     // canfly = player.getAllowFlight();
     player.setAllowFlight(true);
     time = System.currentTimeMillis();
     timers.put(player, time);
     instances.put(player, this);
   }
 }
  /** 解析Intent */
  private void parseIntent(final Intent intent) {
    final Bundle arguments = intent.getExtras();
    if (arguments != null) {
      if (arguments.containsKey(EXTRA_DIRECTORY)) {
        String directory = arguments.getString(EXTRA_DIRECTORY);
        Logger.i("onStartCommand:" + directory);
        // 扫描文件夹
        if (!mScanMap.containsKey(directory)) mScanMap.put(directory, "");
      } else if (arguments.containsKey(EXTRA_FILE_PATH)) {
        // 单文件
        String filePath = arguments.getString(EXTRA_FILE_PATH);
        Logger.i("onStartCommand:" + filePath);
        if (!StringUtils.isEmpty(filePath)) {
          if (!mScanMap.containsKey(filePath))
            mScanMap.put(filePath, arguments.getString(EXTRA_MIME_TYPE));
          //					scanFile(filePath, arguments.getString(EXTRA_MIME_TYPE));
        }
      }
    }

    if (mServiceStatus == SCAN_STATUS_NORMAL || mServiceStatus == SCAN_STATUS_END) {
      new Thread(this).start();
      // scan();
    }
  }
  @Override
  public void notifyResult(AuctionItem item) {
    if (registeredUsers.containsKey(item.getCreator_id())) {
      RMIClientIntf creator = registeredUsers.get(item.getCreator_id());
      try {
        creator.callBack("Your Auction has produced the following results :\n ");
        creator.callBack(item.getResult());
      } catch (RemoteException e) {
        System.out.println("Creator no longer online\n");
      }
    } else {
      System.out.println("Creator id does not exist\n");
    } // Normally an auction with no creator registered should not exist but since this is a
    // simplified implementation
    // We allow bids on auctions with no creator (usually the initialised ones) for testing
    // purposes.
    if (item.numberOfBids() != 0) {
      System.out.println("Notifying bidders");
      Iterator<Bid> it = item.getBidders();
      while (it.hasNext()) {
        Bid bidder = it.next();
        if (registeredUsers.containsKey(bidder.getUserId())) {
          RMIClientIntf client = registeredUsers.get(bidder.getUserId());
          try {
            client.callBack(item.getResult());
          } catch (RemoteException e) {
            System.out.println("Bidder with id " + bidder.getUserId() + " no longer online\n");
          }

        } else {
          System.out.println("User id does not exist\n");
        }
      }
    }
  }
Example #7
0
  /** Process WAMP messages coming from the background reader. */
  protected void processAppMessage(Object message) {

    if (message instanceof WampMessage.CallResult) {

      WampMessage.CallResult callresult = (WampMessage.CallResult) message;

      if (mCalls.containsKey(callresult.mCallId)) {
        CallMeta meta = mCalls.get(callresult.mCallId);
        if (meta.mResultHandler != null) {
          meta.mResultHandler.onResult(callresult.mResult);
        }
        mCalls.remove(callresult.mCallId);
      }

    } else if (message instanceof WampMessage.CallError) {

      WampMessage.CallError callerror = (WampMessage.CallError) message;

      if (mCalls.containsKey(callerror.mCallId)) {
        CallMeta meta = mCalls.get(callerror.mCallId);
        if (meta.mResultHandler != null) {
          meta.mResultHandler.onError(callerror.mErrorUri, callerror.mErrorDesc);
        }
        mCalls.remove(callerror.mCallId);
      }
    } else if (message instanceof WampMessage.Event) {

      WampMessage.Event event = (WampMessage.Event) message;

      if (mSubs.containsKey(event.mTopicUri)) {
        SubMeta meta = mSubs.get(event.mTopicUri);
        if (meta != null && meta.mEventHandler != null) {
          meta.mEventHandler.onEvent(event.mTopicUri, event.mEvent);
        }
      }
    } else if (message instanceof WampMessage.Welcome) {

      WampMessage.Welcome welcome = (WampMessage.Welcome) message;

      // FIXME: safe session ID / fire session opened hook
      if (DEBUG)
        Log.d(
            TAG,
            "WAMP session "
                + welcome.mSessionId
                + " established (protocol version "
                + welcome.mProtocolVersion
                + ", server "
                + welcome.mServerIdent
                + ")");

    } else {

      if (DEBUG) Log.d(TAG, "unknown WAMP message in AutobahnConnection.processAppMessage");
    }
  }
 private void checkTopic2(
     final ConcurrentHashMap<String, ConcurrentHashMap<Partition, TopicPartitionRegInfo>>
         topicRegistry) {
   final ConcurrentHashMap<Partition, TopicPartitionRegInfo> partMap2 =
       topicRegistry.get("topic2");
   assertNotNull(partMap2);
   assertEquals(1, partMap2.size());
   assertTrue(partMap2.containsKey(new Partition("0-0")));
   assertFalse(partMap2.containsKey(new Partition("1-0")));
 }
 private static void finalRemoveLava(Block block) {
   if (AFFECTED_BLOCKS.containsKey(block)) {
     TempBlock.revertBlock(block, Material.AIR);
     AFFECTED_BLOCKS.remove(block);
   }
   if (WALL_BLOCKS.containsKey(block)) {
     TempBlock.revertBlock(block, Material.AIR);
     WALL_BLOCKS.remove(block);
   }
 }
 private void checkTopic1(
     final ConcurrentHashMap<String, ConcurrentHashMap<Partition, TopicPartitionRegInfo>>
         topicRegistry) {
   final ConcurrentHashMap<Partition, TopicPartitionRegInfo> partMap1 =
       topicRegistry.get("topic1");
   assertNotNull(partMap1);
   assertEquals(3, partMap1.size());
   assertTrue(partMap1.containsKey(new Partition("0-0")));
   assertTrue(partMap1.containsKey(new Partition("0-1")));
   assertTrue(partMap1.containsKey(new Partition("0-2")));
 }
  @Override
  public void process(Request request) {
    String name = getRouteName(request);

    if (name == null || name.isEmpty()) return;

    if (!ROUTE_TIMERS.containsKey(name)) {
      ROUTE_TIMERS.putIfAbsent(name, metrics.timer(getTimerName(name)));
    }

    if (!EXCEPTION_COUNTERS_BY_ROUTE.containsKey(name)) {
      EXCEPTION_COUNTERS_BY_ROUTE.putIfAbsent(name, metrics.counter(getExceptionCounterName(name)));
    }
  }
Example #12
0
 @SuppressWarnings("deprecation")
 public static void remove(Block block) {
   if (ignitedblocks.containsKey(block)) {
     ignitedblocks.remove(block);
   }
   if (ignitedtimes.containsKey(block)) {
     ignitedtimes.remove(block);
   }
   if (replacedBlocks.containsKey(block.getLocation())) {
     block.setType(replacedBlocks.get(block.getLocation()).getItemType());
     block.setData(replacedBlocks.get(block.getLocation()).getData());
     replacedBlocks.remove(block.getLocation());
   }
 }
 public boolean hasAccount(String name) {
   if (hc.useExternalEconomy()) {
     if (hc.getEconomy().hasAccount(name)) {
       if (!hyperPlayers.containsKey(fixpN(name))) {
         addPlayer(name);
       }
       return true;
     } else {
       return false;
     }
   } else {
     return hyperPlayers.containsKey(fixpN(name));
   }
 }
Example #14
0
 public FileConfiguration gFC(String fileConfiguration) {
   if (configs.containsKey(fileConfiguration)) {
     return configs.get(fileConfiguration);
   } else {
     return null;
   }
 }
Example #15
0
 public boolean joinTournament(
     UUID userId, UUID tableId, String name, String playerType, int skill) throws GameException {
   if (controllers.containsKey(tableId)) {
     return controllers.get(tableId).joinTournament(userId, name, playerType, skill);
   }
   return false;
 }
 // TODO
 @GET
 @Path("/jobQueue/{jobID}")
 // @Produces(MediaType.TEXT_XML)
 public Response checkJobQueue(@PathParam("jobID") String jobID) {
   // does job exist?
   System.out.println("[checkJobQueue] queue length = " + jobqueue.size());
   System.out.println("[checkJobQueue] jobID = " + jobID);
   if (jobqueue.containsKey(UUID.fromString(jobID))) {
     System.out.println("Found job ID");
     // if job is not finished yet return 200
     if (jobqueue.get(UUID.fromString(jobID)).getStatus() == SFPGenJob.PROCESSING)
       return Response.status(Status.OK)
           .entity("Still processing - please check back later.")
           .build();
     // if job is finished and SFP has been created
     else {
       // return path to SFP resource
       URI sfp_uri;
       try {
         sfp_uri = new URI("SFP/sfplist/" + jobID);
         // update jobQueue
         SFPGenJob currjob = jobqueue.get(UUID.fromString(jobID));
         currjob.updateStatus(SFPGenJob.GONE);
         jobqueue.put(UUID.fromString(jobID), currjob);
         return Response.status(Status.SEE_OTHER).location(sfp_uri).build();
       } catch (URISyntaxException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
       }
       return Response.serverError().build();
     }
   } else return Response.serverError().entity("No such job ID").build();
 }
Example #17
0
 /**
  * Get the selected GameCharacter object
  *
  * @param entityID Of the object
  * @return GameCharacter object or null if it doesn't exists
  */
 public GameCharacter getEntity(int entityID) {
   if (mapCharacterEntities.containsKey(entityID)) {
     return mapCharacterEntities.get(entityID);
   } else {
     return null;
   }
 }
Example #18
0
 public String getServiceOfferedFromRegMap(String serviceName) {
   if (serviceRegistrationMap.containsKey(serviceName)) {
     return serviceRegistrationMap.get(serviceName).getServiceOffered();
   } else {
     return null;
   }
 }
Example #19
0
 public synchronized boolean doesClientNameExits(String clientName) {
   if (clientList.containsKey(clientName)) {
     return true;
   } else {
     return false;
   }
 }
  @Override
  public boolean updateQuitLoc(final PlayerAuth auth) {
    if (!cache.containsKey(auth.getNickname())) {
      return false;
    }
    final PlayerAuth cachedAuth = cache.get(auth.getNickname());
    final double oldX = cachedAuth.getQuitLocX();
    final double oldY = cachedAuth.getQuitLocY();
    final double oldZ = cachedAuth.getQuitLocZ();
    final String oldWorld = cachedAuth.getWorld();

    cachedAuth.setQuitLocX(auth.getQuitLocX());
    cachedAuth.setQuitLocY(auth.getQuitLocY());
    cachedAuth.setQuitLocZ(auth.getQuitLocZ());
    cachedAuth.setWorld(auth.getWorld());
    exec.execute(
        new Runnable() {
          @Override
          public void run() {
            if (!source.updateQuitLoc(auth)) {
              if (cache.containsKey(auth.getNickname())) {
                PlayerAuth cachedAuth = cache.get(auth.getNickname());
                cachedAuth.setQuitLocX(oldX);
                cachedAuth.setQuitLocY(oldY);
                cachedAuth.setQuitLocZ(oldZ);
                cachedAuth.setWorld(oldWorld);
              }
            }
          }
        });
    return true;
  }
  @Override
  public boolean updateSession(final PlayerAuth auth) {
    if (!cache.containsKey(auth.getNickname())) {
      return false;
    }
    PlayerAuth cachedAuth = cache.get(auth.getNickname());
    final String oldIp = cachedAuth.getIp();
    final long oldLastLogin = cachedAuth.getLastLogin();
    final String oldRealName = cachedAuth.getRealName();

    cachedAuth.setIp(auth.getIp());
    cachedAuth.setLastLogin(auth.getLastLogin());
    cachedAuth.setRealName(auth.getRealName());
    exec.execute(
        new Runnable() {
          @Override
          public void run() {
            if (!source.updateSession(auth)) {
              if (cache.containsKey(auth.getNickname())) {
                PlayerAuth cachedAuth = cache.get(auth.getNickname());
                cachedAuth.setIp(oldIp);
                cachedAuth.setLastLogin(oldLastLogin);
                cachedAuth.setRealName(oldRealName);
              }
            }
          }
        });
    return true;
  }
Example #22
0
 public int readCurrentServiceIndexAndIncrement(String serviceOffered) throws Exception {
   if (currentServiceIndexMap.containsKey(serviceOffered)) {
     return currentServiceIndexMap.get(serviceOffered).incrementAndGet();
   } else {
     throw new Exception("No Service for " + serviceOffered + " Available");
   }
 }
Example #23
0
 public void endGame(UUID tableId) {
   if (controllers.containsKey(tableId)) {
     if (controllers.get(tableId).endGameAndStartNextGame()) {
       removeTable(tableId);
     }
   }
 }
Example #24
0
 public boolean submitDeck(UUID userId, UUID tableId, DeckCardLists deckList)
     throws MageException {
   if (controllers.containsKey(tableId)) {
     return controllers.get(tableId).submitDeck(userId, deckList);
   }
   return false;
 }
Example #25
0
  private void readAllChunks(boolean readPagePositions) {
    String[] files = new File(btreeStorageName).list();
    if (files != null && files.length > 0) {
      for (String f : files) {
        int chunkId =
            Integer.parseInt(f.substring(0, f.length() - AOStorage.SUFFIX_AO_FILE_LENGTH));
        if (!chunks.containsKey(chunkId)) {
          readChunkHeader(chunkId);
        }
      }

      if (readPagePositions) {
        for (BTreeChunk c : chunks.values()) {
          if (c.pagePositions == null) {
            ByteBuffer pagePositions =
                c.fileStorage.readFully(
                    c.pagePositionsOffset + CHUNK_HEADER_SIZE, c.pageCount * 2 * 8);

            int size = c.pageCount * 2;
            c.pagePositions = new ArrayList<Long>();
            for (int i = 0; i < size; i++) {
              c.pagePositions.add(pagePositions.getLong());
            }
          }
        }
      }
    }
  }
Example #26
0
  public void addChair(Player player, Block block) {

    if (disabled) return;
    try {
      PacketContainer entitymeta = ProtocolLibrary.getProtocolManager().createPacket(40);
      entitymeta.getSpecificModifier(int.class).write(0, player.getEntityId());
      WrappedDataWatcher watcher = new WrappedDataWatcher();
      watcher.setObject(0, (byte) 4);
      entitymeta.getWatchableCollectionModifier().write(0, watcher.getWatchableObjects());
      for (Player play : plugin.getServer().getOnlinePlayers()) {
        if (play.getWorld().equals(player.getPlayer().getWorld())) {
          try {
            ProtocolLibrary.getProtocolManager().sendServerPacket(play, entitymeta);
          } catch (InvocationTargetException e) {
            BukkitUtil.printStacktrace(e);
          }
        }
      }
    } catch (Error e) {
      Bukkit.getLogger().severe("Chairs do not work without ProtocolLib!");
      disabled = true;
      return;
    }
    if (chairs.containsKey(player.getName())) return;
    plugin.wrapPlayer(player).print(ChatColor.YELLOW + "You are now sitting.");
    chairs.put(player.getName(), block);
  }
Example #27
0
 /**
  * Starts the Match from a non tournament table
  *
  * @param userId table owner
  * @param roomId
  * @param tableId
  */
 public void startMatch(UUID userId, UUID roomId, UUID tableId) {
   if (controllers.containsKey(tableId)) {
     controllers.get(tableId).startMatch(userId);
     // chat of start dialog can be killed
     ChatManager.getInstance().destroyChatSession(controllers.get(tableId).getChatId());
   }
 }
 private void caughtException(Invoker<?> invoker, Invocation invocation, Exception e) {
   String interfaceName = invoker.getUrl().getParameter(Constants.INTERFACE_KEY);
   String method = invocation.getMethodName();
   StringBuffer interfaceConfig = new StringBuffer(Config.DUBBO_REFERENCE_PREFIX);
   interfaceConfig.append(interfaceName);
   StringBuffer methodConfig = new StringBuffer(interfaceConfig.toString());
   methodConfig.append(".").append(method);
   String methodKey = methodConfig.toString();
   int timeout =
       invoker
           .getUrl()
           .getMethodParameter(
               invocation.getMethodName(), Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
   int limit = Config.getBreakLimit(invoker, invocation);
   // 一个异常的有效期,是通过连续出现异常数量乘以每个调用的超时时间,比如你配置连续出现10次异常之后进行服务降级,并且每次服务调用的超时时间是2000ms的话,同时
   // 每个服务重试次数是为2次,那么就是在(2+1)*2000*10
   ExceptionMarker breakMarker =
       new ExceptionMarker(System.currentTimeMillis(), limit * timeout, e);
   if (!breakCounterMap.containsKey(methodKey)) {
     BreakCounter oldValue = breakCounterMap.putIfAbsent(methodKey, new BreakCounter(methodKey));
     // 返回的oldValue为空,表示之前没有创建了赌赢的异常计数器,则需要对它分配一个loop
     if (oldValue == null) {
       nextLoop().register(breakCounterMap.get(methodKey));
     }
   }
   BreakCounter counter = breakCounterMap.get(methodKey);
   counter.addExceptionMarker(breakMarker);
   logger.info(
       "[{}] caught exception for rpc invoke [{}.{}],current exception count [{}]",
       localHost,
       interfaceName,
       method,
       counter.getCurrentExceptionCount());
 }
 private <T extends Object> Result doCircuitBreak(Invoker<?> invoker, Invocation invocation)
     throws RpcException {
   String interfaceName = invoker.getUrl().getParameter(Constants.INTERFACE_KEY);
   String circuitBreaker = interfaceName + "CircuitBreak";
   incrementBreakCount(invoker, invocation);
   try {
     logger.info("[{}] check has class [{}] to handle circuit break", localHost, circuitBreaker);
     Invoker<?> breakerInvoker = null;
     if (CIRCUIT_BREAKER_INVOKER_CACHE.containsKey(circuitBreaker)) {
       breakerInvoker = CIRCUIT_BREAKER_INVOKER_CACHE.get(circuitBreaker);
     } else {
       Class<T> breakerType = (Class<T>) Class.forName(circuitBreaker);
       Class<T> interfaceType = (Class<T>) Class.forName(interfaceName);
       if (interfaceType.isAssignableFrom(breakerType)) {
         logger.info("[{}] handle circuit break by class [{}]", localHost, circuitBreaker);
         T breaker = breakerType.newInstance();
         breakerInvoker = proxyFactory.getInvoker(breaker, interfaceType, invoker.getUrl());
         Invoker<?> oldInvoker =
             CIRCUIT_BREAKER_INVOKER_CACHE.putIfAbsent(circuitBreaker, breakerInvoker);
         if (oldInvoker != null) {
           breakerInvoker = oldInvoker;
         }
       }
     }
     if (breakerInvoker != null) {
       return breakerInvoker.invoke(invocation);
     }
   } catch (Exception e) {
     logger.error("failed to invoke circuit breaker", e);
   }
   logger.info("[{}] handle circuit break by exception", localHost);
   CircuitBreakerException baseBusinessException =
       new CircuitBreakerException(interfaceName, invocation.getMethodName());
   throw baseBusinessException;
 }
Example #30
0
  public WxClient with(AppSetting appSetting) {
    if (!wxClients.containsKey(key(appSetting))) {
      String url = WxEndpoint.get("url.token.get");
      String clazz = appSetting.getTokenHolderClass();

      AccessTokenHolder accessTokenHolder = null;
      if (clazz == null || "".equals(clazz)) {
        try {
          accessTokenHolder = (AccessTokenHolder) Class.forName(clazz).newInstance();
          accessTokenHolder.setClientId(appSetting.getAppId());
          accessTokenHolder.setClientSecret(appSetting.getSecret());
          accessTokenHolder.setTokenUrl(url);
        } catch (Exception e) {
          accessTokenHolder =
              new DefaultAccessTokenHolder(url, appSetting.getAppId(), appSetting.getSecret());
        }
      } else {
        accessTokenHolder =
            new DefaultAccessTokenHolder(url, appSetting.getAppId(), appSetting.getSecret());
      }

      WxClient wxClient =
          new WxClient(appSetting.getAppId(), appSetting.getSecret(), accessTokenHolder);
      wxClients.putIfAbsent(key(appSetting), wxClient);
    }

    return wxClients.get(key(appSetting));
  }