private void serializeBillingDetails(BillingResult billingResult,
        BillingDetailsType billingDetails) {

    try {
        final JAXBContext context = JAXBContext
                .newInstance(BillingdataType.class);
        final ByteArrayOutputStream out = new ByteArrayOutputStream();
        final Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty("jaxb.formatted.output", Boolean.FALSE);
        final BillingdataType billingdataType = new BillingdataType();
        billingdataType.getBillingDetails().add(billingDetails);
        marshaller.marshal(factory.createBillingdata(billingdataType), out);
        final String xml = new String(out.toByteArray(), "UTF-8");
        billingResult.setResultXML(xml.substring(
                xml.indexOf("<Billingdata>") + 13,
                xml.indexOf("</Billingdata>")).trim());
        billingResult.setGrossAmount(billingDetails.getOverallCosts()
                .getGrossAmount());
        billingResult.setNetAmount(billingDetails.getOverallCosts()
                .getNetAmount());
    } catch (JAXBException | UnsupportedEncodingException ex) {
        throw new BillingRunFailed(ex);
    }
}
 

@GetMapping("/boot/{serverId}")
@ApiOperation("跳转至OAuth2.0服务授权页面")
public RedirectView boot(@PathVariable String serverId,
                         @RequestParam(defaultValue = "/") String redirect,
                         HttpServletRequest request,
                         HttpSession session) throws UnsupportedEncodingException {
    OAuth2ServerConfigEntity entity = oAuth2ServerConfigService.selectByPk(serverId);
    if (entity == null) {
        return new RedirectView("/401.html");
    }
    String callback = WebUtil.getBasePath(request)
            .concat("oauth2/callback/")
            .concat(serverId).concat("/?redirect=")
            .concat(URLEncoder.encode(redirect, "UTF-8"));
    RedirectView view = new RedirectView(entity.getRealUrl(entity.getAuthUrl()));
    view.addStaticAttribute(OAuth2Constants.response_type, "code");
    view.addStaticAttribute(OAuth2Constants.state, requestState(session).getResult());
    view.addStaticAttribute(OAuth2Constants.client_id, entity.getClientId());
    view.addStaticAttribute(OAuth2Constants.redirect_uri, callback);
    return view;
}
 

@Test
public void testMessageShortcutPayload() throws UnsupportedEncodingException {
    MessageShortcutPayload payload = new MessageShortcutPayload();
    MessageShortcutPayload.Team team = new MessageShortcutPayload.Team();
    team.setId("T123");
    payload.setTeam(team);
    MessageShortcutPayload.User user = new MessageShortcutPayload.User();
    user.setId("U123");
    payload.setUser(user);
    SlackRequestParser.HttpRequest request = SlackRequestParser.HttpRequest.builder()
            .requestBody("payload=" + URLEncoder.encode(gson.toJson(payload), "UTF-8"))
            .headers(new RequestHeaders(new HashMap<>()))
            .build();

    Request<?> slackRequest = parser.parse(request);
    assertNotNull(slackRequest);
}
 

public void rename(DockerContainer container, String name) throws DockerException {
    Parameters.notNull("name", name);

    try {
        doPostRequest("/containers/" + container.getId() + "/rename?name=" + HttpUtils.encodeParameter(name),
                false, Collections.singleton(HttpURLConnection.HTTP_NO_CONTENT));

        long time = System.currentTimeMillis() / 1000;
        // XXX we send it as older API does not have the commit event
        if (emitEvents) {
            instance.getEventBus().sendEvent(
                    new DockerEvent(instance, DockerEvent.Status.RENAME,
                            container.getId(), container.getId(), time));
        }
    } catch (UnsupportedEncodingException ex) {
        throw new DockerException(ex);
    }
}
 

public static Bundle decodeUrl(String s) {
    Bundle params = new Bundle();
    if (s != null) {
        String array[] = s.split("&");
        for (String parameter : array) {
            String v[] = parameter.split("=");
            try {
                params.putString(URLDecoder.decode(v[0], "UTF-8"), URLDecoder.decode(v[1], "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();

            }
        }
    }
    return params;
}
 

public Map<String, Object> convertFileDataMap(Map<String, Object> map, Charset charset, boolean isUnicodeServer) {

		if (map != null) {
			String dataString = null;
			byte[] dataBytes = null;

			try {
				dataBytes = (byte[]) map.get(RpcFunctionMapKey.DATA);
			} catch (Throwable thr) {
				Log.exception(thr);
			}
			
			if (dataBytes != null) {
				try {
					dataString = new String(dataBytes, charset == null ?
							RpcConnection.NON_UNICODE_SERVER_CHARSET_NAME :
									(isUnicodeServer ? CharsetDefs.UTF8_NAME : charset.name()));
					map.put(RpcFunctionMapKey.DATA, dataString);
				} catch (UnsupportedEncodingException e) {
					Log.exception(e);
				}
			}
		}

		return map;
	}
 

@Override public boolean shouldOverrideUrlLoading(WebView view, String url) {
    String decode;
    try {
        decode = URLDecoder.decode(url, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        // No handling
        return false;
    }

    if (TextUtils.indexOf(url, CALLBACK_SCHEME) == 0) {
        callback(decode);
        return true;
    } else if (TextUtils.indexOf(url, STATE_SCHEME) == 0) {
        stateCheck(decode);
        return true;
    }

    return super.shouldOverrideUrlLoading(view, url);
}
 

private static boolean isOnlyDoubleByteKanji(String content) {
  byte[] bytes;
  try {
    bytes = content.getBytes("Shift_JIS");
  } catch (UnsupportedEncodingException ignored) {
    return false;
  }
  int length = bytes.length;
  if (length % 2 != 0) {
    return false;
  }
  for (int i = 0; i < length; i += 2) {
    int byte1 = bytes[i] & 0xFF;
    if ((byte1 < 0x81 || byte1 > 0x9F) && (byte1 < 0xE0 || byte1 > 0xEB)) {
      return false;
    }
  }
  return true;
}
 

Map<String, String> parse(String serialized) {
	final StringTokenizer pairTokenizer = new StringTokenizer(serialized.trim(), ",");
	final Map<String, String> context = new HashMap<>();
	while (pairTokenizer.hasMoreTokens()) {
		final String pairStr = pairTokenizer.nextToken();
		final String[] keyValuePair = pairStr.split("=");
		if (keyValuePair.length != 2) {
			continue;
		}
		try {
			final String key = URLDecoder.decode(keyValuePair[0], ENCODING_CHARSET);
			final String value = URLDecoder.decode(keyValuePair[1], ENCODING_CHARSET);
			context.put(key, value);
		} catch (UnsupportedEncodingException e) {
			LOGGER.error("Charset not found", e);
		}
	}

	return context;
}
 

public String decrypt(String ciphertext) throws GeneralSecurityException {
	checkEnabled();
	
    if (StringUtils.isBlank(ciphertext)) {
        return "";
    }

    // Initialize the same cipher for decryption
    Cipher cipher = Cipher.getInstance(ALGORITHM);
    cipher.init(Cipher.DECRYPT_MODE, desKey);

    try {
        // un-Base64 encode the encrypted data
        byte[] encryptedData = Base64.decodeBase64(ciphertext.getBytes(CHARSET));

        // Decrypt the ciphertext
        byte[] cleartext1 = cipher.doFinal(encryptedData);
        return new String(cleartext1, CHARSET);
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
}
 

static String toUrlString(String host, int port, String dn, boolean useSsl)
    {

    try {
        String h = (host != null) ? host : "";
        if ((h.indexOf(':') != -1) && (h.charAt(0) != '[')) {
            h = "[" + h + "]";          // IPv6 literal
        }
        String p = (port != -1) ? (":" + port) : "";
        String d = (dn != null) ? ("/" + UrlUtil.encode(dn, "UTF8")) : "";

        return useSsl ? "ldaps://" + h + p + d : "ldap://" + h + p + d;
    } catch (UnsupportedEncodingException e) {
        // UTF8 should always be supported
        throw new IllegalStateException("UTF-8 encoding unavailable");
    }
}
 

/**
 * Encrypts a given string based on a shared secret.
 *
 * @param text
 *            the text to encrypt
 * @return the iv and encrypted text as Base64 separated with ':'.
 * @throws GeneralSecurityException
 *             on any problem during encryption
 */
public static String encrypt(String text) throws GeneralSecurityException {

    if (text == null) {
        return null;
    }

    byte[] decrypted;
    try {
        decrypted = text.getBytes("UTF-8");
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }

    byte[] iv = new byte[IV_BYTES];
    new SecureRandom().nextBytes(iv);
    IvParameterSpec ivSpec = new IvParameterSpec(iv);

    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
    cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);

    byte[] encrypted = cipher.doFinal(decrypted);
    return new String(Base64.encodeBase64(iv)) + ":"
            + new String(Base64.encodeBase64(encrypted));
}
 

private static UrlLinkFrame decodeUrlLinkFrame(ParsableByteArray id3Data, int frameSize,
    String id) throws UnsupportedEncodingException {
  byte[] data = new byte[frameSize];
  id3Data.readBytes(data, 0, frameSize);

  int urlEndIndex = indexOfZeroByte(data, 0);
  String url = new String(data, 0, urlEndIndex, "ISO-8859-1");

  return new UrlLinkFrame(id, null, url);
}
 

/**
 * convert string to an array of UTF-8 bytes
 */
private static byte[] getBytes(String s)
{
    byte[] bytes = null;

    try {
        bytes = s.getBytes("UTF-8");
    }
    catch (UnsupportedEncodingException e) {
        // ignore, UTF-8 encoding is always known
    }

    return bytes;
}
 

@Override
public ByteBuffer encode(Object source) {
    String line = (String) source;
    try {
        ByteBuffer buffer = ByteBuffer.wrap(line.getBytes(Constant.CHARSET_UTF8));
        
        return buffer;
    } catch (UnsupportedEncodingException e) {
        logger.log(Level.SEVERE, "将响应数据转换成ByteBuffer出错", e);
    }
    
    return null;
}
 

/**
 * set up form based authentication method for the created context
 * @param listener the listener to display log during the job execution in jenkins
 * @param zapClientAPI the client API to use ZAP API methods
 * @param loggedInIdicator indication for know its logged in
 * @param usernameParameter parameter define in passing username
 * @param passwordParameter parameter that define in passing password for the user
 * @param extraPostData other post data than credentials
 * @param contextId id of the creted context
 * @param loginUrl login page url
 * @throws ClientApiException
 * @throws UnsupportedEncodingException
 */
private void setUpFormBasedAuthenticationMethod(BuildListener listener, ClientApi zapClientAPI, 
			String loggedInIndicator, String usernameParameter, String passwordParameter,String extraPostData,
			String contextId, String loginUrl) 
			throws ClientApiException, UnsupportedEncodingException{

	String loginRequestData = usernameParameter+"={%username%}&"+passwordParameter+"={%password%}&"+extraPostData;

	// set form based authentication method 		
	// Prepare the configuration in a format similar to how URL parameters are formed. This
	// means that any value we add for the configuration values has to be URL encoded.
	StringBuilder formBasedConfig = new StringBuilder();
	formBasedConfig.append("loginUrl=").append(URLEncoder.encode(loginUrl, "UTF-8"));
	formBasedConfig.append("&loginRequestData=").append(URLEncoder.encode(loginRequestData, "UTF-8"));

	zapClientAPI.authentication.setAuthenticationMethod(API_KEY, contextId, "formBasedAuthentication",formBasedConfig.toString());
	
	listener.getLogger().println("Authentication config: " + zapClientAPI.authentication.getAuthenticationMethod(contextId).toString(0));
	
	//end set auth method
	listener.getLogger().println("Form Based Authentication added to context");

	//add logged in idicator
	if (!loggedInIndicator.equals("")) {
	zapClientAPI.authentication.setLoggedInIndicator(API_KEY, contextId, loggedInIndicator);
	listener.getLogger().println("Logged in indicator "+loggedInIndicator+" added to context ");
	}

}
 

private PerfDataType(String name, String c, int size) {
    this.name = name;
    this.size = size;
    try {
        byte[] b = c.getBytes("UTF-8");
        this.value = b[0];
    } catch (UnsupportedEncodingException e) {
        // ignore, "UTF-8" is always a known encoding
        throw new InternalError("Unknown encoding", e);
    }
}
 

/**
 * Escapes all invalid url characters and strips the maximum length to 127 to be used as a file name
 *
 * @param s the string to be escaped
 * @return url-encoded string or the original string if UTF-8 is not supported on the system
 */
protected String urlEscapeUnwantedChars(String s) {
    String result;
    try {
        result = URLEncoder.encode(s, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        logger.warn("Encoding UTF-8 is not supported, might generate invalid filenames.");
        result = s;
    }
    int length = Math.min(result.length(), MAX_FILENAME_LENGTH);
    return result.substring(0, length);
}
 

/**
 * Initialize the serializer with the specified output stream and output
 * format. Must be called before calling any of the serialize methods.
 *
 * @param output The output stream to use
 * @param format The output format
 * @throws UnsupportedEncodingException The encoding specified   in the
 * output format is not supported
 */
protected synchronized void init(OutputStream output, Properties format)
    throws UnsupportedEncodingException
{
    if (null == format)
    {
        format = OutputPropertiesFactory.getDefaultMethodProperties(Method.HTML);
     }
    super.init(output,format, false);
}
 

static WebTarget addParts(WebTarget target, String[] parts) {
    if (parts != null && parts.length > 0) {
        for (String part : parts) {
            String encode;
            try {
                encode = URLEncoder.encode(part, StandardCharsets.UTF_8.toString());
            } catch (UnsupportedEncodingException e) {
                log.error("{} is Unknown exception - [{}]", StandardCharsets.UTF_8.toString(), e);
                encode = part;
            }
            target = target.path(encode);
        }
    }
    return target;
}
 

public static HttpPost getPostRequest(URI uri, List<NameValuePair> postData) throws IllegalArgumentException {
    try {
        HttpPost post = new HttpPost(uri);
        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(postData, "UTF-8");
        post.setEntity(entity);
        return post;
    } catch (UnsupportedEncodingException e) {
        throw new IllegalArgumentException(e);
    }
}
 

/**
 * device unbinding (/v1/devices/{identifier}/unbinding)
 * @param context
 * @param accessToken
 * @param responseHandler
 */
public static void deviceUnbinding(Context context, String accessToken, String identifier, AsyncHttpResponseHandler responseHandler) {
	List<Header> headerList = new ArrayList<Header>();
	headerList.add(new BasicHeader(ApiKey.HeadKey.ACCESS_TOKEN, accessToken));
	try {
		post(context, String.format(getApiServerUrl() + DEVICE_UNBINDING, identifier), headerList, null, responseHandler);
	}  catch (UnsupportedEncodingException e) {
		e.printStackTrace();
		responseHandler.onFailure(INNER_ERROR_CODE, null, null, e);
	}
}
 

/**
 * Utility for loading lines from a UTF8 file.
 * @param result The result of the appended lines.
 * @param inputStream The input stream.
 * @param encoding if null, then UTF-8
 * @return filled list
 * @throws IOException  If there were problems opening the input stream for reading.
 */
public static List<String> appendLines(List<String> result, InputStream inputStream, String encoding)
        throws UnsupportedEncodingException, IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, encoding == null ? "UTF-8" : encoding));
    while (true) {
        String line = in.readLine();
        if (line == null) break;
        result.add(line);
    }
    return result;
}
 

private String read(InputStream inStream) throws IOException, UnsupportedEncodingException {
	List<Byte> byteList = new ArrayList<Byte>();
	int streamBuf = inStream.read();
	while(streamBuf != -1) {
		byteList.add(new Byte((byte) streamBuf));
		streamBuf = inStream.read();
	}
	byte [] byteArr = new byte[byteList.size()];
	for(int i = 0; i < byteList.size(); i++) {
		byteArr[i] = byteList.get(i).byteValue();
	}

	return new String(byteArr, "UTF-8");
}
 

public void setFileName(String fileName) {
	 try {  
            fileName = new String(fileName.getBytes("ISO-8859-1"),"UTF-8");  
        } catch (UnsupportedEncodingException e) {  
            e.printStackTrace();  
        }  
        //System.out.println("----"+fileName);  
        this.fileName = fileName;  
}
 

@Override
public PathComponent encode(String encoding) throws UnsupportedEncodingException {
	List<String> pathSegments = getPathSegments();
	List<String> encodedPathSegments = new ArrayList<String>(pathSegments.size());
	for (String pathSegment : pathSegments) {
		String encodedPathSegment = encodeUriComponent(pathSegment, encoding, Type.PATH_SEGMENT);
		encodedPathSegments.add(encodedPathSegment);
	}
	return new PathSegmentComponent(encodedPathSegments);
}
 

/**
 * URL encodes the provided path using the given encoding.
 *
 * @param path      The path to encode
 * @param encoding  The encoding to use to convert the path to bytes
 *
 * @return The encoded path
 *
 * @deprecated This will be removed in Tomcat 9.0.x
 */
@Deprecated
public String encode(String path, String encoding) {
    Charset charset;
    try {
        charset = B2CConverter.getCharset(encoding);
    } catch (UnsupportedEncodingException e) {
        charset = Charset.defaultCharset();
    }
    return encode(path, charset);
}
 

/**
 * Get client id and its ephemeral owner.
 *
 * @param zkClient
 *          zookeeper client
 * @param lockPath
 *          lock path
 * @param nodeName
 *          node name
 * @return client id and its ephemeral owner.
 */
static Future<Pair<String, Long>> asyncParseClientID(ZooKeeper zkClient, String lockPath, String nodeName) {
    String[] parts = nodeName.split("_");
    // member_<clientid>_s<owner_session>_
    if (4 == parts.length && parts[2].startsWith("s")) {
        long sessionOwner = Long.parseLong(parts[2].substring(1));
        String clientId;
        try {
            clientId = URLDecoder.decode(parts[1], UTF_8.name());
            return Future.value(Pair.of(clientId, sessionOwner));
        } catch (UnsupportedEncodingException e) {
            // if failed to parse client id, we have to get client id by zookeeper#getData.
        }
    }
    final Promise<Pair<String, Long>> promise = new Promise<Pair<String, Long>>();
    zkClient.getData(lockPath + "/" + nodeName, false, new AsyncCallback.DataCallback() {
        @Override
        public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
            if (KeeperException.Code.OK.intValue() != rc) {
                promise.setException(KeeperException.create(KeeperException.Code.get(rc)));
            } else {
                promise.setValue(Pair.of(deserializeClientId(data), stat.getEphemeralOwner()));
            }
        }
    }, null);
    return promise;
}
 

/**
 * Converts a string to a UTF-8 byte array.
 *
 */
public static byte[] toBytes(String s)
{
    try
    {
        return s.getBytes("UTF-8");
    }
    catch (UnsupportedEncodingException e)
    {
        return null;
    }
}
 

/**
 * Converts an arbitrary string into a format that can be stored safely on the filesystem.
 *
 * @param str the string to encode
 * @return the encoded string
 */
public static String toFilenameFriendlyString(String str) {
  byte[] bytes;
  try {
    bytes = str.getBytes("UTF-8");
  } catch (UnsupportedEncodingException e) {
    // This should never happen.
    throw new IllegalStateException("UTF-8 not supported", e);
  }

  return new String(Hex.encodeHex(bytes));
}