Java Charsets.UTF_8属性代码示例

private void loadStructureDefinitions(FhirContext theContext, Map<String, StructureDefinition> theCodeSystems, String theClasspath) {
  logD("CareConnect Loading structure definitions from classpath: "+ theClasspath);
  InputStream valuesetText = CareConnectProfileValidationSupport.class.getResourceAsStream(theClasspath);
  if (valuesetText != null) {
    InputStreamReader reader = new InputStreamReader(valuesetText, Charsets.UTF_8);

    Bundle bundle = theContext.newXmlParser().parseResource(Bundle.class, reader);
    for (BundleEntryComponent next : bundle.getEntry()) {
      if (next.getResource() instanceof StructureDefinition) {
        StructureDefinition nextSd = (StructureDefinition) next.getResource();
        nextSd.getText().setDivAsString("");
        String system = nextSd.getUrl();
        if (isNotBlank(system)) {
          theCodeSystems.put(system, nextSd);
        }
      }
    }
  } else {
    log.warn("Unable to load resource: {}", theClasspath);
  }
}
 

String extractPassword(String pwFile) {
  if (pwFile.isEmpty()) {
    // If there is no password file defined, we'll assume that we should do
    // an anonymous bind
    return "";
  }

  StringBuilder password = new StringBuilder();
  try (Reader reader = new InputStreamReader(
      new FileInputStream(pwFile), Charsets.UTF_8)) {
    int c = reader.read();
    while (c > -1) {
      password.append((char)c);
      c = reader.read();
    }
    return password.toString().trim();
  } catch (IOException ioe) {
    throw new RuntimeException("Could not read password file: " + pwFile, ioe);
  }
}
 

private void loadStructureDefinitions(FhirContext theContext, Map<String, StructureDefinition> theCodeSystems, String theClasspath) {
  logD("SNOMEDMOCK Loading structure definitions from classpath: "+ theClasspath);
  InputStream valuesetText = SNOMEDUKMockValidationSupport.class.getResourceAsStream(theClasspath);
  if (valuesetText != null) {
    InputStreamReader reader = new InputStreamReader(valuesetText, Charsets.UTF_8);

    Bundle bundle = theContext.newXmlParser().parseResource(Bundle.class, reader);
    for (BundleEntryComponent next : bundle.getEntry()) {
      if (next.getResource() instanceof StructureDefinition) {
        StructureDefinition nextSd = (StructureDefinition) next.getResource();
        nextSd.getText().setDivAsString("");
        String system = nextSd.getUrl();
        if (isNotBlank(system)) {
          theCodeSystems.put(system, nextSd);
        }
      }
    }
  } else {
    log.warn("Unable to load resource: {}", theClasspath);
  }
}
 

private void checkMetrics(List<byte[]> bytearrlist, int expectedCount) {
  boolean[] foundMetrics = new boolean[expectedMetrics.length];
  for (byte[] bytes : bytearrlist) {
    String binaryStr = new String(bytes, Charsets.UTF_8);
    for (int index = 0; index < expectedMetrics.length; index++) {
      if (binaryStr.indexOf(expectedMetrics[index]) >= 0) {
        foundMetrics[index] = true;
        break;
      }
    }
  }

  for (int index = 0; index < foundMetrics.length; index++) {
    if (!foundMetrics[index]) {
      assertTrue("Missing metrics: " + expectedMetrics[index], false);
    }
  }

  assertEquals("Mismatch in record count: ",
      expectedCount, bytearrlist.size());
}
 

protected void pump() throws IOException {
  InputStreamReader inputStreamReader = new InputStreamReader(
      stream, Charsets.UTF_8);
  BufferedReader br = new BufferedReader(inputStreamReader);
  String line = null;
  while ((line = br.readLine()) != null) {
    if (type == StreamType.STDOUT) {
      log.info(logPrefix + ": " + line);
    } else {
      log.warn(logPrefix + ": " + line);          
    }
  }
}
 

private Map<String, String> load() {
  Map<String, String> loadMap = new HashMap<String, String>();
  
  String filename = getConf().get(NET_TOPOLOGY_TABLE_MAPPING_FILE_KEY, null);
  if (StringUtils.isBlank(filename)) {
    LOG.warn(NET_TOPOLOGY_TABLE_MAPPING_FILE_KEY + " not configured. ");
    return null;
  }
  

  try (BufferedReader reader =
           new BufferedReader(new InputStreamReader(
               new FileInputStream(filename), Charsets.UTF_8))) {
    String line = reader.readLine();
    while (line != null) {
      line = line.trim();
      if (line.length() != 0 && line.charAt(0) != '#') {
        String[] columns = line.split("\\s+");
        if (columns.length == 2) {
          loadMap.put(columns[0], columns[1]);
        } else {
          LOG.warn("Line does not have two columns. Ignoring. " + line);
        }
      }
      line = reader.readLine();
    }
  } catch (Exception e) {
    LOG.warn(filename + " cannot be read.", e);
    return null;
  }
  return loadMap;
}
 

/**
 * Serialize the metadata to a set of bytes.
 * @return the serialized bytes
 * @throws IOException
 */
protected byte[] serialize() throws IOException {
  ByteArrayOutputStream buffer = new ByteArrayOutputStream();
  JsonWriter writer = new JsonWriter(
      new OutputStreamWriter(buffer, Charsets.UTF_8));
  try {
    writer.beginObject();
    if (cipher != null) {
      writer.name(CIPHER_FIELD).value(cipher);
    }
    if (bitLength != 0) {
      writer.name(BIT_LENGTH_FIELD).value(bitLength);
    }
    if (created != null) {
      writer.name(CREATED_FIELD).value(created.getTime());
    }
    if (description != null) {
      writer.name(DESCRIPTION_FIELD).value(description);
    }
    if (attributes != null && attributes.size() > 0) {
      writer.name(ATTRIBUTES_FIELD).beginObject();
      for (Map.Entry<String, String> attribute : attributes.entrySet()) {
        writer.name(attribute.getKey()).value(attribute.getValue());
      }
      writer.endObject();
    }
    writer.name(VERSIONS_FIELD).value(versions);
    writer.endObject();
    writer.flush();
  } finally {
    writer.close();
  }
  return buffer.toByteArray();
}
 

@Private
public static void readFileToSetWithFileInputStream(String type,
    String filename, InputStream fileInputStream, Set<String> set)
    throws IOException {
  BufferedReader reader = null;
  try {
    reader = new BufferedReader(
        new InputStreamReader(fileInputStream, Charsets.UTF_8));
    String line;
    while ((line = reader.readLine()) != null) {
      String[] nodes = line.split("[ \t\n\f\r]+");
      if (nodes != null) {
        for (int i = 0; i < nodes.length; i++) {
          nodes[i] = nodes[i].trim();
          if (nodes[i].startsWith("#")) {
            // Everything from now on is a comment
            break;
          }
          if (!nodes[i].isEmpty()) {
            LOG.info("Adding a node \"" + nodes[i] + "\" to the list of "
                + type + " hosts from " + filename);
            set.add(nodes[i]);
          }
        }
      }
    }
  } finally {
    if (reader != null) {
      reader.close();
    }
    fileInputStream.close();
  }
}
 

/**
 * Reads the lines in a file.
 * @param fileName
 * @return lines in a String array; null if the file does not exist or if the
 * file name is null
 * @throws IOException
 */
private static String[] readLines(String fileName) throws IOException {
  try {
    if (fileName != null) {
      File file = new File (fileName);
      if (file.exists()) {
        try (
            Reader fileReader = new InputStreamReader(
                new FileInputStream(file), Charsets.UTF_8);
            BufferedReader bufferedReader = new BufferedReader(fileReader)) {
          List<String> lines = new ArrayList<String>();
          String line = null;
          while ((line = bufferedReader.readLine()) != null) {
            lines.add(line);
          }
          if (LOG.isDebugEnabled()) {
            LOG.debug("Loaded IP list of size = " + lines.size() +
                " from file = " + fileName);
          }
          return (lines.toArray(new String[lines.size()]));
        }
      } else {
        LOG.debug("Missing ip list file : "+ fileName);
      }
    }
  } catch (IOException ioe) {
    LOG.error(ioe);
    throw ioe;
  }
  return null;
}
 

@Override
public String toString(T obj) throws IOException {
  outBuf.reset();
  serializer.serialize(obj);
  byte[] buf = new byte[outBuf.getLength()];
  System.arraycopy(outBuf.getData(), 0, buf, 0, buf.length);
  return new String(Base64.encodeBase64(buf), Charsets.UTF_8);
}
 

private BufferedInputStream readStreamHeader() throws IOException {
  // We are flexible enough to allow the compressed stream not to
  // start with the header of BZ. So it works fine either we have
  // the header or not.
  if (super.in != null) {
    bufferedIn.mark(HEADER_LEN);
    byte[] headerBytes = new byte[HEADER_LEN];
    int actualRead = bufferedIn.read(headerBytes, 0, HEADER_LEN);
    if (actualRead != -1) {
      String header = new String(headerBytes, Charsets.UTF_8);
      if (header.compareTo(HEADER) != 0) {
        bufferedIn.reset();
      } else {
        this.isHeaderStripped = true;
        // In case of BYBLOCK mode, we also want to strip off
        // remaining two character of the header.
        if (this.readMode == READ_MODE.BYBLOCK) {
          actualRead = bufferedIn.read(headerBytes, 0,
              SUB_HEADER_LEN);
          if (actualRead != -1) {
            this.isSubHeaderStripped = true;
          }
        }
      }
    }
  }

  if (bufferedIn == null) {
    throw new IOException("Failed to read bzip2 stream.");
  }

  return bufferedIn;

}
 

private CSVPrinter createCSVPrinter(String[] headers, String delimiter, FileOutputStream outputStream) throws IOException {
    final Writer writer = new BufferedWriter(new OutputStreamWriter(outputStream, Charsets.UTF_8));
    final CSVFormat format = CSVFormat.newFormat(delimiter.charAt(0))
            .withHeader((String[]) headers)
            .withQuote(QUOTE)
            .withRecordSeparator(System.lineSeparator());
    return new CSVPrinter(writer, format);
}
 

/**
 * Returns the hadoop-auth configuration from HttpFSServer's configuration.
 * <p>
 * It returns all HttpFSServer's configuration properties prefixed with
 * <code>httpfs.authentication</code>. The <code>httpfs.authentication</code>
 * prefix is removed from the returned property names.
 *
 * @param configPrefix parameter not used.
 * @param filterConfig parameter not used.
 *
 * @return hadoop-auth configuration read from HttpFSServer's configuration.
 */
@Override
protected Properties getConfiguration(String configPrefix,
    FilterConfig filterConfig) throws ServletException{
  Properties props = new Properties();
  Configuration conf = HttpFSServerWebApp.get().getConfig();

  props.setProperty(AuthenticationFilter.COOKIE_PATH, "/");
  for (Map.Entry<String, String> entry : conf) {
    String name = entry.getKey();
    if (name.startsWith(CONF_PREFIX)) {
      String value = conf.get(name);
      name = name.substring(CONF_PREFIX.length());
      props.setProperty(name, value);
    }
  }

  String signatureSecretFile = props.getProperty(SIGNATURE_SECRET_FILE, null);
  if (signatureSecretFile == null) {
    throw new RuntimeException("Undefined property: " + SIGNATURE_SECRET_FILE);
  }

  try {
    StringBuilder secret = new StringBuilder();
    Reader reader = new InputStreamReader(new FileInputStream(
        signatureSecretFile), Charsets.UTF_8);
    int c = reader.read();
    while (c > -1) {
      secret.append((char)c);
      c = reader.read();
    }
    reader.close();
    props.setProperty(AuthenticationFilter.SIGNATURE_SECRET, secret.toString());
  } catch (IOException ex) {
    throw new RuntimeException("Could not read HttpFS signature secret file: " + signatureSecretFile);
  }
  return props;
}
 

@Override
public void writeTo(Map map, Class<?> aClass, Type type, Annotation[] annotations,
                    MediaType mediaType, MultivaluedMap<String, Object> stringObjectMultivaluedMap,
                    OutputStream outputStream) throws IOException, WebApplicationException {
  Writer writer = new OutputStreamWriter(outputStream,  Charsets.UTF_8);
  JSONObject.writeJSONString(map, writer);
  writer.write(ENTER);
  writer.flush();
}
 

@Override
public void writeTo(JSONStreamAware jsonStreamAware, Class<?> aClass, Type type, Annotation[] annotations,
                    MediaType mediaType, MultivaluedMap<String, Object> stringObjectMultivaluedMap,
                    OutputStream outputStream) throws IOException, WebApplicationException {
  Writer writer = new OutputStreamWriter(outputStream, Charsets.UTF_8);
  jsonStreamAware.writeJSONString(writer);
  writer.write(ENTER);
  writer.flush();
}