下面列出了java.nio.charset.StandardCharsets#UTF_8 ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private Checkpoint recoverCheckpoint() {
try {
File checkpointFile = new File(base, CHECKPOINT_FILE);
if(checkpointFile.isFile()) {
byte[] serializedData = new byte[(int) checkpointFile.length()];
try (FileInputStream fis = new FileInputStream(checkpointFile)) {
if (serializedData.length != fis.read(serializedData)) {
throw new IOException("File length not match!");
}
}
String jsonString = new String(serializedData, StandardCharsets.UTF_8);
Checkpoint checkpoint = JSON.parseObject(jsonString, Checkpoint.class);
if(null != checkpoint) {
logger.info("Checkpoint file recovered: {}.", checkpoint);
}
return checkpoint;
} else {
logger.warn("Checkpoint file is NOT found, continue recover...");
}
} catch (Throwable t) {
logger.warn("Recover checkpoint exception, continue recover...", t);
}
return null;
}
@Test
public void testEncodeText_JapaneseTextUtf8DoesntFitCharBuff_BytesDontFitByteBuff() throws Exception {
final StringBuilderEncoder helper = new StringBuilderEncoder(StandardCharsets.UTF_8, 4, 8 * 1024);
final StringBuilder text = new StringBuilder( // 日本語テスト文章
"\u65e5\u672c\u8a9e\u30c6\u30b9\u30c8\u6587\u7ae0");
final SpyByteBufferDestination destination = new SpyByteBufferDestination(3, 50);
helper.encode(text, destination);
assertEquals("drained", 7, destination.drainPoints.size());
destination.drain(destination.getByteBuffer());
final byte[] utf8 = text.toString().getBytes(StandardCharsets.UTF_8);
for (int i = 0; i < utf8.length; i++) {
assertEquals("byte at " + i, utf8[i], destination.drained.get(i));
}
}
private boolean generateTable(TableDesc table) throws IOException {
TableGenConfig config = new TableGenConfig(table, this);
if (!config.needGen)
return false;
ByteArrayOutputStream bout = new ByteArrayOutputStream();
PrintWriter pout = new PrintWriter(new OutputStreamWriter(bout, StandardCharsets.UTF_8));
generateTableInternal(table, config, pout);
pout.close();
bout.close();
saveResource(bout.toByteArray(), path(table));
return true;
}
/**
* Reads an LC style string from a channel, which is a int32 length
* plus a UTF-8 encoded string possibly ends with \0.
* @throws IOException if there is a format error
* @throws BufferUnderflowException if goes beyond the end
*/
private static String readStringWithLength(SeekableByteChannel chan)
throws IOException {
ByteBuffer bb = ByteBuffer.allocate(4);
bb.order(ByteOrder.nativeOrder());
chan.read(bb);
bb.flip();
int len = bb.getInt();
if (len > 1024) {
// Memory attack? The string should be fairly short.
throw new IOException("Invalid string length");
}
bb = ByteBuffer.allocate(len);
if (chan.read(bb) != len) {
throw new IOException("Not enough string");
}
byte[] data = bb.array();
return (data[len-1] == 0)?
new String(data, 0, len-1, StandardCharsets.UTF_8):
new String(data, StandardCharsets.UTF_8);
}
@Override
protected boolean fetchIsDone() {
boolean found = false;
try (InputStream in = this.webResourceFetcher
.getInputStreamForUrl(getBaseUrl() + this.projectName + "-"
+ dateStamp + "-md5sums.txt")) {
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(in, StandardCharsets.UTF_8));
String inputLine;
String filePostfix = WmfDumpFile
.getDumpFilePostfix(this.dumpContentType);
while (!found && (inputLine = bufferedReader.readLine()) != null) {
if (inputLine.endsWith(filePostfix)) {
found = true;
}
}
bufferedReader.close();
} catch (IOException e) {
// file not found or not readable; just return false
}
return found;
}
/**
* Validates the PassTicket in authorization header.
*/
@GetMapping(value = "/api/v1/passticketTest")
@ApiOperation(value = "Validate that the PassTicket in Authorization header is valid", tags = { "Test Operations" })
public void passticketTest(@RequestHeader("authorization") String authorization,
@RequestParam(value = "applId", defaultValue = "", required = false) String applId)
throws IRRPassTicketEvaluationException
{
if (authorization != null && authorization.toLowerCase().startsWith("basic")) {
String base64Credentials = authorization.substring("Basic".length()).trim();
String credentials = new String(Base64.getDecoder().decode(base64Credentials), StandardCharsets.UTF_8);
String[] values = credentials.split(":", 2);
String userId = values[0];
String passTicket = values[1];
if (applId.isEmpty()) {
applId = defaultApplId;
}
passTicketService.evaluate(userId, applId, passTicket);
} else {
throw new IllegalArgumentException("Missing Basic authorization header");
}
}
public List<Record> readAllRecords(InputStream ios, int maxLines) throws IOException, NumberFormatException {
List<Record> records = new ArrayList<>();
BufferedReader dataIS = new BufferedReader(new InputStreamReader(ios, StandardCharsets.UTF_8));
int count = 0;
while ((maxLines < 0) || (count < maxLines)) {
String line = dataIS.readLine();
if (line == null)
break;
if (line.startsWith(comment))
continue;
if (line.trim().isEmpty())
continue;
if (debug)
System.out.printf("%s%n", line);
Record r = Record.make(line, fields);
if (r != null)
records.add(r);
count++;
}
return records;
}
public VersionMeta getVersionMeta() throws IOException {
if(versionMeta == null){
URL url = new URL(this.url);
URLConnection conn = url.openConnection();
try (BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
versionMeta = Utils.GSON.fromJson(reader, VersionMeta.class);
}
}
return versionMeta;
}
public Builder addBase64EncodedTestSelector(String b64Selector) {
String[] selectorParts = b64Selector.split(",");
if (selectorParts.length != 2) {
throw new IllegalArgumentException();
}
String className = selectorParts[0];
String methodName = selectorParts[1];
Base64.Decoder decoder = Base64.getDecoder();
String decodedClassName = new String(decoder.decode(className), StandardCharsets.UTF_8);
String decodedMethodName = new String(decoder.decode(methodName), StandardCharsets.UTF_8);
this.testSelectors.add(new SimpleTestSelector(decodedClassName, decodedMethodName));
return this;
}
private MetadataStatement retrieveMetadataStatement(URI uri, String entryHash, MessageDigest digest, boolean forceUpdate) throws Exception {
String filename = filenameFromURI(uri);
String data = null;
if (!forceUpdate) {
data = storage.loadData(namespace, filename);
}
if (data == null) {
String url = URLDecoder.decode(uri.toString(), StandardCharsets.UTF_8.name());
url = addToken(url);
url = url.replaceAll("#", "%23");
URI realURI = URI.create(url);
ResponseEntity<String> responseEntity = restTemplate.getForEntity(realURI, String.class);
data = responseEntity.getBody();
if(data == null){
logger.severe("Null hash.");
throw new Exception("Null hash");
}
String hash = Base64.getUrlEncoder().withoutPadding().encodeToString(digest.digest(data.getBytes()));
if (!hash.equals(entryHash)) {
logger.log(Level.SEVERE, "Bad hash. {0} != {1} Skipping ", new Object[]{hash, entryHash});
throw new Exception("Bad hash");
}
storage.saveData(namespace, filename, data);
}
String decoded;
try {
decoded = new String(Base64Utils.decodeFromUrlSafeString(data), StandardCharsets.UTF_8);
} catch (Exception e) {
// TODO: known bug: test server does not base64 this info
decoded = data;
}
return objectMapper.readValue(decoded, MetadataStatement.class);
}
/**
* Method to convert one json to yaml file - backup&restore functionality
* <p>
* File will be placed on path /target/test-classes
*/
public String asYaml(String jsonStringFile) throws IOException {
InputStream stream = getClass().getClassLoader().getResourceAsStream(jsonStringFile);
Writer writer = new StringWriter();
char[] buffer = new char[1024];
Reader reader;
if (stream == null) {
this.getLogger().error("File does not exist: {}", jsonStringFile);
throw new FileNotFoundException("ERR! File not found: " + jsonStringFile);
}
try {
reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8));
int n;
while ((n = reader.read(buffer)) != -1) {
writer.write(buffer, 0, n);
}
} catch (Exception readerexception) {
this.getLogger().error(readerexception.getMessage());
} finally {
try {
stream.close();
} catch (Exception closeException) {
this.getLogger().error(closeException.getMessage());
}
}
String text = writer.toString();
String std = text.replace("\r", "").replace("\n", ""); // make sure we have unix style text regardless of the input
// parse JSON
JsonNode jsonNodeTree = new ObjectMapper().readTree(std);
// save it as YAML
String jsonAsYaml = new YAMLMapper().writeValueAsString(jsonNodeTree);
return jsonAsYaml;
}
@Override
public void accept(PubSubMessage message, Context context) {
String name = "World";
if (!message.getData().isEmpty()) {
name = new String(Base64.getDecoder().decode(
message.getData().getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8);
}
String res = String.format("Hello, %s", name);
logger.info(res);
}
@Override
public T deserialize(byte[] bytes) {
if (bytes == null || bytes.length <= 0) {
return null;
}
String str = new String(bytes, StandardCharsets.UTF_8);
return JSON.parseObject(str, clazz);
}
private static String resource(String file) throws IOException {
try (InputStream is = requireNonNull(ActivityTrackingControllerTest.class.getClassLoader().getResourceAsStream(file)) ) {
ByteArrayOutputStream os = new ByteArrayOutputStream();
copy(is, os);
return new String(os.toByteArray(), StandardCharsets.UTF_8);
}
}
public static JSONObject loadJSONObject(String source_url) throws IOException {
byte[] b = load(source_url);
return new JSONObject(new JSONTokener(new String(b, StandardCharsets.UTF_8)));
}
@Override
String getMessage(MirrorConsensusTopicResponse response) {
return new String(response.message, StandardCharsets.UTF_8);
}
/**
<pre>
{ path: '', component: EventListComponent, canActivate: [LanguageGuard] },
{ path: 'event/:eventShortName', component: EventDisplayComponent, canActivate: [EventGuard, LanguageGuard] },
{ path: 'event/:eventShortName/reservation/:reservationId', children: [
{ path: 'book', component: BookingComponent, canActivate: reservationsGuard },
{ path: 'overview', component: OverviewComponent, canActivate: reservationsGuard },
{ path: 'waitingPayment', redirectTo: 'waiting-payment'},
{ path: 'waiting-payment', component: OfflinePaymentComponent, canActivate: reservationsGuard },
{ path: 'processing-payment', component: ProcessingPaymentComponent, canActivate: reservationsGuard },
{ path: 'success', component: SuccessComponent, canActivate: reservationsGuard },
{ path: 'not-found', component: NotFoundComponent, canActivate: reservationsGuard },
{ path: 'error', component: ErrorComponent, canActivate: reservationsGuard }
]},
{ path: 'event/:eventShortName/ticket/:ticketId/view', component: ViewTicketComponent, canActivate: [EventGuard, LanguageGuard] }
</pre>
*/
@GetMapping({
"/",
"/event/{eventShortName}",
"/event/{eventShortName}/reservation/{reservationId}/book",
"/event/{eventShortName}/reservation/{reservationId}/overview",
"/event/{eventShortName}/reservation/{reservationId}/waitingPayment",
"/event/{eventShortName}/reservation/{reservationId}/waiting-payment",
"/event/{eventShortName}/reservation/{reservationId}/deferred-payment",
"/event/{eventShortName}/reservation/{reservationId}/processing-payment",
"/event/{eventShortName}/reservation/{reservationId}/success",
"/event/{eventShortName}/reservation/{reservationId}/not-found",
"/event/{eventShortName}/reservation/{reservationId}/error",
"/event/{eventShortName}/ticket/{ticketId}/view",
"/event/{eventShortName}/ticket/{ticketId}/update"
})
public void replyToIndex(@PathVariable(value = "eventShortName", required = false) String eventShortName,
@RequestHeader(value = "User-Agent", required = false) String userAgent,
@RequestParam(value = "lang", required = false) String lang,
ServletWebRequest request,
HttpServletResponse response,
HttpSession session) throws IOException {
response.setContentType(TEXT_HTML_CHARSET_UTF_8);
response.setCharacterEncoding(UTF_8);
var nonce = addCspHeader(response);
if (eventShortName != null && RequestUtils.isSocialMediaShareUA(userAgent) && eventRepository.existsByShortName(eventShortName)) {
try (var os = response.getOutputStream(); var osw = new OutputStreamWriter(os, StandardCharsets.UTF_8)) {
var res = getOpenGraphPage((Document) OPEN_GRAPH_PAGE.cloneNode(true), eventShortName, request, lang);
JFiveParse.serialize(res, osw);
}
} else {
try (var os = response.getOutputStream(); var osw = new OutputStreamWriter(os, StandardCharsets.UTF_8)) {
var baseCustomCss = configurationManager.getForSystem(BASE_CUSTOM_CSS).getValueOrDefault(null);
var idx = INDEX_PAGE.cloneNode(true);
idx.getElementsByTagName("script").forEach(element -> element.setAttribute("nonce", nonce));
var head = idx.getElementsByTagName("head").get(0);
head.appendChild(buildScripTag(Json.toJson(configurationManager.getInfo(session)), "application/json", "preload-info", null));
head.appendChild(buildScripTag(Json.toJson(messageSourceManager.getBundleAsMap("alfio.i18n.public", true, "en")), "application/json", "preload-bundle", "en"));
if (baseCustomCss != null) {
var style = new Element("style");
style.setAttribute("type", "text/css");
style.appendChild(new Text(baseCustomCss));
head.appendChild(style);
}
if (eventShortName != null) {
eventLoader.loadEventInfo(eventShortName, session).ifPresent(ev -> {
head.appendChild(buildScripTag(Json.toJson(ev), "application/json", "preload-event", eventShortName));
});
}
JFiveParse.serialize(idx, osw);
}
}
}
private String main(String... args) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(baos);
new Bootstrap(getDownloadFolder(), ps).go(args);
return new String(baos.toByteArray(), StandardCharsets.UTF_8);
}
private DeliverCallback conversationCreatedCallback() {
return (consumerTag, delivery) -> {
final long deliveryTag = delivery.getEnvelope().getDeliveryTag();
String receivedMessage = new String(delivery.getBody(), StandardCharsets.UTF_8);
log.trace("Received Raw Conversation Created Message: {}", receivedMessage);
try {
var conversationCreatedEvent = jsonSerialization.deserialize(receivedMessage, ConversationCreatedEvent.class);
if (conversationCreatedEvent.getPayload().getError() != null) {
log.error("ConversationCreated event contained error '{}'", receivedMessage);
differPublisher.positiveDeliveryAck(deliveryTag);
return;
}
var payload = conversationCreatedEvent.getPayload();
var conversationId = payload.getConversation().getId();
var participantIds = payload.getParticipantIds();
// in case there are multiple bots part of the conversation, we need to send this data to all of them
var botUserParticipantIds = filterBotUserParticipantIds(participantIds);
if (botUserParticipantIds.isEmpty()) {
//No bot involved in this conversation
log.debug(logStatementIgnoredEvent, receivedMessage);
differPublisher.positiveDeliveryAck(deliveryTag);
return;
}
log.info(" [x] Received and accepted amqp event: {}", receivedMessage);
var conversationInfo = createDifferConversation(conversationId, participantIds, botUserParticipantIds);
log.debug("Differ Conversation created. {}", conversationInfo);
botUserParticipantIds.forEach(botUserId ->
startConversationWithUser(delivery, botUserId, conversationId, conversationCreatedEvent, conversationInfo));
} catch (Exception e) {
log.error("Error processing delivery {} of conversation.created.eddi with body {}", deliveryTag, receivedMessage);
log.error(e.getLocalizedMessage(), e);
differPublisher.negativeDeliveryAck(delivery);
}
};
}
/**
* Opens a new <code>ZipFile</code> to read from the specified
* <code>File</code> object in the specified mode. The mode argument
* must be either <tt>OPEN_READ</tt> or <tt>OPEN_READ | OPEN_DELETE</tt>.
*
* <p>First, if there is a security manager, its <code>checkRead</code>
* method is called with the <code>name</code> argument as its argument to
* ensure the read is allowed.
*
* <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
* decode the entry names and comments
*
* @param file the ZIP file to be opened for reading
* @param mode the mode in which the file is to be opened
* @throws ZipException if a ZIP format error has occurred
* @throws IOException if an I/O error has occurred
* @throws SecurityException if a security manager exists and
* its <code>checkRead</code> method
* doesn't allow read access to the file,
* or its <code>checkDelete</code> method doesn't allow deleting
* the file when the <tt>OPEN_DELETE</tt> flag is set.
* @throws IllegalArgumentException if the <tt>mode</tt> argument is invalid
* @see SecurityManager#checkRead(java.lang.String)
* @since 1.3
*/
public ZipFile(File file, int mode) throws IOException {
this(file, mode, StandardCharsets.UTF_8);
}