下面列出了怎么用com.google.common.io.ByteArrayDataInput的API类实例代码及写法，或者点击链接到github查看源代码。
public void onPluginMessageReceived(String channel, Player player, byte[] bytes){
if (!channel.equalsIgnoreCase(Shared.CHANNEL_NAME)) return;
ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
String subChannel = in.readUTF();
if (subChannel.equalsIgnoreCase("Placeholder")){
String placeholder = in.readUTF();
long start = System.nanoTime();
String output = PluginHooks.PlaceholderAPI_setPlaceholders(player, placeholder);
long time = System.nanoTime() - start;
ByteArrayDataOutput out = ByteStreams.newDataOutput();
out.writeUTF("Placeholder");
out.writeUTF(placeholder);
out.writeUTF(output);
out.writeLong(time);
player.sendPluginMessage(plugin, Shared.CHANNEL_NAME, out.toByteArray());
}
}
@Override
public GT_Packet decode(ByteArrayDataInput dataInput) {
byte[] buffer = new byte[19];
dataInput.readFully(buffer);
this.coords = new Coords(ByteBuffer.wrap(buffer).getInt(0), ByteBuffer.wrap(buffer).getShort(4), ByteBuffer.wrap(buffer).getInt(6), ByteBuffer.wrap(buffer).getInt(10));
int[] rgb = {ByteBuffer.wrap(buffer).get(14) - Byte.MIN_VALUE, ByteBuffer.wrap(buffer).get(15) - Byte.MIN_VALUE, ByteBuffer.wrap(buffer).get(16) - Byte.MIN_VALUE};
this.integer = BW_ColorUtil.getColorFromRGBArray(rgb);
this.removal = ByteBuffer.wrap(buffer).get(17);
byte checksum = (byte) (this.coords.x % 25 + this.coords.y % 25 + this.coords.z % 25 + this.coords.wID % 25 + this.integer % 25 + this.removal);
if (checksum != ByteBuffer.wrap(buffer).get(18)) {
MainMod.LOGGER.error("BW Packet was corrupted or modified!");
return null;
}
return new RendererPacket(this.coords, this.integer, this.removal == 1);
}
@Override
public GT_Packet decode(ByteArrayDataInput byteArrayDataInput) {
byte[] tmp = new byte[16];
byteArrayDataInput.readFully(tmp);
ByteBuffer buff = ByteBuffer.wrap(tmp);
this.x = buff.getInt();
this.z = buff.getInt();
this.y = buff.getShort();
this.meta = buff.getShort();
MetaBlockPacket todecode = new MetaBlockPacket(this.x, this.y, this.z, this.meta);
if (buff.getInt() != MurmurHash3.murmurhash3_x86_32(ByteBuffer.allocate(12).putInt(this.x).putInt(this.z).putShort(this.y).putShort(this.meta).array(), 0, 12, 31)) {
MainMod.LOGGER.error("PACKET HASH DOES NOT MATCH!");
return null;
}
return todecode;
}
/**
* Decodes the given byte array to a {@link SettingMap}.
*
* <p>Operates on the reverse of {@link SettingMap#encode()}.</p>
*
* @param buf the byte array
* @return the decoded map
*/
public SettingMap<S, V> decode(byte[] buf) {
if (buf.length == 0) {
return newMap();
}
ByteArrayDataInput in = ByteStreams.newDataInput(buf);
int n = Byte.toUnsignedInt(in.readByte());
byte[] states = Arrays.copyOf(this.defaultStates, this.defaultStates.length);
for (int i = 0; i < n; i++) {
int settingOrdinal = Byte.toUnsignedInt(in.readByte());
byte stateByte = in.readByte();
states[settingOrdinal] = stateByte;
}
return new SettingMap<>(this, states);
}
public static PartiesPacket read(ADPPlugin plugin, byte[] bytes) {
PartiesPacket ret = null;
try {
ByteArrayDataInput input = ByteStreams.newDataInput(bytes);
String foundVersion = input.readUTF();
if (foundVersion.equals(plugin.getVersion())) {
PartiesPacket packet = new PartiesPacket(foundVersion);
packet.type = PacketType.valueOf(input.readUTF());
packet.partyName = input.readUTF();
packet.playerUuid = UUID.fromString(input.readUTF());
packet.payload = input.readUTF();
ret = packet;
} else {
plugin.getLoggerManager().printError(Constants.DEBUG_LOG_MESSAGING_FAILED_VERSION
.replace("{current}", plugin.getVersion())
.replace("{version}", foundVersion));
}
} catch (Exception ex) {
plugin.getLoggerManager().printError(Constants.DEBUG_LOG_MESSAGING_FAILED_READ
.replace("{message}", ex.getMessage()));
}
return ret;
}
@Subscribe
public void onPluginMessage(PluginMessageEvent e) {
// compare the underlying text representation of the channel
// the namespaced representation is used by legacy servers too, so we
// are able to support both. :)
if (!e.getIdentifier().getId().equals(CHANNEL.getId())) {
return;
}
e.setResult(ForwardResult.handled());
if (e.getSource() instanceof Player) {
return;
}
ByteArrayDataInput in = e.dataAsDataStream();
String msg = in.readUTF();
if (this.consumer.consumeIncomingMessageAsString(msg)) {
// Forward to other servers
this.plugin.getBootstrap().getScheduler().executeAsync(() -> dispatchMessage(e.getData()));
}
}
@Test
public void testSerialization() throws Exception
{
Range<Token> full = new Range<>(tok(-1), tok(-1));
// populate and validate the tree
mt.maxsize(256);
mt.init();
for (TreeRange range : mt.invalids())
range.addAll(new HIterator(range.right));
byte[] initialhash = mt.hash(full);
DataOutputBuffer out = new DataOutputBuffer();
MerkleTree.serializer.serialize(mt, out, MessagingService.current_version);
byte[] serialized = out.toByteArray();
ByteArrayDataInput in = ByteStreams.newDataInput(serialized);
MerkleTree restored = MerkleTree.serializer.deserialize(in, MessagingService.current_version);
assertHashEquals(initialhash, restored.hash(full));
}
@Override
public void onPluginMessageReceived(String channel, Player player, byte[] message) {
if (!channel.equals(BUNGEE_CHANNEL)) {
return;
}
ByteArrayDataInput in = ByteStreams.newDataInput(message);
String subChannel = in.readUTF();
if ("PlayerCount".equals(subChannel)) {
try {
String server = in.readUTF();
int count = in.readInt();
if ("ALL".equals(server)) {
onlinePlayers = count;
}
} catch (Exception eofException) {
//happens if bungeecord doesn't know the server
//ignore the admin should be notified by seeing the -1
}
}
}
@EventHandler
public void pluginMessageReceived(PluginMessageEvent event) {
if(!plugin.isEnabled() || !event.getTag().equals("rp:plugin") || !(event.getSender() instanceof Server))
return;
ByteArrayDataInput in = ByteStreams.newDataInput(event.getData());
String subchannel = in.readUTF();
if("authMeLogin".equals(subchannel)) {
String playerName = in.readUTF();
UUID playerId = UUID.fromString(in.readUTF());
plugin.setAuthenticated(playerId, true);
if(!plugin.hasBackend(playerId) && plugin.getConfig().getBoolean("useauth", false)) {
ProxiedPlayer player = plugin.getProxy().getPlayer(playerId);
if(player != null) {
String serverName = "";
if(player.getServer() != null) {
serverName = player.getServer().getInfo().getName();
}
plugin.getPackManager().applyPack(playerId, serverName);
}
}
}
}
@Override
public void onPluginMessageReceived(final String channel, final Player player, final byte[] data) {
if (!isEnabled) {
return;
}
final ByteArrayDataInput in = ByteStreams.newDataInput(data);
// Check subchannel
final String subChannel = in.readUTF();
if ("AuthMe.v2.Broadcast".equals(subChannel)) {
handleBroadcast(in);
} else if ("AuthMe.v2".equals(subChannel)) {
handle(in);
}
}
@Override
public Tuple getNext() throws IOException {
try {
if (reader.nextKeyValue()) {
Key key = reader.getCurrentKey();
org.apache.accumulo.core.data.Value value = reader.getCurrentValue();
ByteArrayDataInput input = ByteStreams.newDataInput(key.getRow().getBytes());
RyaStatement ryaStatement = ryaContext.deserializeTriple(layout, new TripleRow(key.getRow().getBytes(),
key.getColumnFamily().getBytes(), key.getColumnQualifier().getBytes()));
Tuple tuple = TupleFactory.getInstance().newTuple(7);
tuple.set(0, ryaStatement.getSubject().getData());
tuple.set(1, ryaStatement.getPredicate().getData());
tuple.set(2, ryaStatement.getObject().getData());
tuple.set(3, (ryaStatement.getContext() != null) ? (ryaStatement.getContext().getData()) : (null));
tuple.set(4, ryaStatement.getSubject().getDataType());
tuple.set(5, ryaStatement.getPredicate().getDataType());
tuple.set(6, ryaStatement.getObject().getDataType());
return tuple;
}
} catch (Exception e) {
throw new IOException(e);
}
return null;
}
@EventHandler
public void onPluginMessage(PluginMessageEvent messageEvent) {
String channel = messageEvent.getTag();
if (messageEvent.isCancelled() || !channel.startsWith(plugin.getName().toLowerCase())) {
return;
}
ByteArrayDataInput dataInput = ByteStreams.newDataInput(messageEvent.getData());
ProxiedPlayer invoker = (ProxiedPlayer) messageEvent.getReceiver();
if (channel.equals(permissionResultChannel)) {
PermResultMessage message = new PermResultMessage();
message.readFrom(dataInput);
if (message.isAllowed()) {
onPermissionSuccess(message, invoker);
} else {
plugin.sendMessage(invoker, "no-permission");
}
} else if (channel.equals(forwardCommandChannel)) {
onCommandForward(invoker, dataInput);
}
}
private void onCommandForward(CommandSender invoker, ByteArrayDataInput dataInput) {
ForwardMessage message = new ForwardMessage();
message.readFrom(dataInput);
if (message.isOP() && message.isSource()) {
//bukkit op and it won't run as bungee console
invoker.addGroups(plugin.getName() + "-OP");
}
String line = message.getCommandName() + ' ' + message.getArgs();
if (message.isSource()) {
//the player is the actual invoker other it's the console
ProxyServer.getInstance().getPluginManager().dispatchCommand(invoker, line);
} else {
CommandSender console = ProxyServer.getInstance().getConsole();
ProxyServer.getInstance().getPluginManager().dispatchCommand(console, line);
}
}
@EventHandler
public void on(PluginMessageEvent event){
if (!event.getTag().equalsIgnoreCase(Shared.CHANNEL_NAME)) return;
ByteArrayDataInput in = ByteStreams.newDataInput(event.getData());
String subChannel = in.readUTF();
if (event.getReceiver() instanceof ProxiedPlayer && subChannel.equalsIgnoreCase("Placeholder")){
event.setCancelled(true);
ITabPlayer receiver = Shared.getPlayer(((ProxiedPlayer) event.getReceiver()).getUniqueId());
if (receiver == null) return;
String placeholder = in.readUTF();
String output = in.readUTF();
long cpu = in.readLong();
PlayerPlaceholder pl = (PlayerPlaceholder) Placeholders.getPlaceholder(placeholder); //all bridge placeholders are marked as player
if (pl != null) {
pl.lastValue.put(receiver.getName(), output);
pl.lastValue.put("null", output);
Set<Refreshable> update = PlaceholderManager.getPlaceholderUsage(pl.getIdentifier());
Shared.featureCpu.runTask("refreshing", new Runnable() {
@Override
public void run() {
for (Refreshable r : update) {
long startTime = System.nanoTime();
r.refresh(receiver, false);
Shared.featureCpu.addTime(r.getRefreshCPU(), System.nanoTime()-startTime);
}
}
});
Shared.bukkitBridgePlaceholderCpu.addTime(pl.getIdentifier(), cpu);
} else {
Shared.debug("Received output for unknown placeholder " + placeholder);
}
}
}
@Subscribe
public void on(PluginMessageEvent event){
if (!event.getIdentifier().getId().equalsIgnoreCase(Shared.CHANNEL_NAME)) return;
ByteArrayDataInput in = ByteStreams.newDataInput(event.getData());
String subChannel = in.readUTF();
if (event.getTarget() instanceof Player && subChannel.equalsIgnoreCase("Placeholder")){
event.setResult(ForwardResult.handled());
ITabPlayer receiver = Shared.getPlayer(((Player) event.getTarget()).getUniqueId());
if (receiver == null) return;
String placeholder = in.readUTF();
String output = in.readUTF();
long cpu = in.readLong();
PlayerPlaceholder pl = (PlayerPlaceholder) Placeholders.getPlaceholder(placeholder); //all bridge placeholders are marked as player
if (pl != null) {
pl.lastValue.put(receiver.getName(), output);
pl.lastValue.put("null", output);
Set<Refreshable> update = PlaceholderManager.getPlaceholderUsage(pl.getIdentifier());
Shared.featureCpu.runTask("refreshing", new Runnable() {
@Override
public void run() {
for (Refreshable r : update) {
long startTime = System.nanoTime();
r.refresh(receiver, false);
Shared.featureCpu.addTime(r.getRefreshCPU(), System.nanoTime()-startTime);
}
}
});
Shared.bukkitBridgePlaceholderCpu.addTime(pl.getIdentifier(), cpu);
} else {
Shared.debug("Received output for unknown placeholder " + placeholder);
}
}
}
@Override
public void read(ByteArrayDataInput in) throws ProtocolException
{
type = in.readByte();
world = DimensionManager.getWorld(in.readInt());
x = in.readInt();
y = in.readInt();
z = in.readInt();
fluidID = in.readInt();
amount = in.readInt();
}
@EventHandler
public void handleChannel(PluginMessageEvent pluginMessageEvent) {
if (!(pluginMessageEvent.getReceiver() instanceof ProxiedPlayer)) {
return;
}
if (pluginMessageEvent.getTag().equalsIgnoreCase("cloudnet:main")) {
ByteArrayDataInput byteArrayDataInput = ByteStreams.newDataInput(pluginMessageEvent.getData());
switch (byteArrayDataInput.readUTF().toLowerCase()) {
case "connect":
List<String> servers = CloudProxy.getInstance().getServers(byteArrayDataInput.readUTF());
if (servers.size() == 0) {
return;
}
((ProxiedPlayer) pluginMessageEvent.getReceiver()).connect(ProxyServer.getInstance()
.getServerInfo(servers.get(NetworkUtils.RANDOM.nextInt(
servers.size()))));
break;
case "fallback":
((ProxiedPlayer) pluginMessageEvent.getReceiver()).connect(ProxyServer.getInstance()
.getServerInfo(CloudProxy.getInstance()
.fallback(((ProxiedPlayer) pluginMessageEvent
.getReceiver()))));
break;
case "command":
ProxyServer.getInstance().getPluginManager().dispatchCommand(((ProxiedPlayer) pluginMessageEvent.getReceiver()),
byteArrayDataInput.readUTF());
break;
}
}
}
@Override
public void read(ByteArrayDataInput in) throws ProtocolException
{
world = DimensionManager.getWorld(in.readInt());
x = in.readInt();
y = in.readInt();
z = in.readInt();
filterAmount = in.readLong();
type = in.readInt();
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
String ip = in.readUTF();
int port = in.readInt();
this.callback.supply(Maps.immutableEntry(ip, port));
return true;
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
in.readUTF();
int count = in.readInt();
this.callback.supply(count);
return true;
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
in.readUTF();
String csv = in.readUTF();
if (csv.isEmpty()) {
this.callback.supply(ImmutableList.of());
return true;
}
this.callback.supply(ImmutableList.copyOf(Splitter.on(", ").splitToList(csv)));
return true;
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
String csv = in.readUTF();
if (csv.isEmpty()) {
this.callback.supply(ImmutableList.of());
return true;
}
this.callback.supply(ImmutableList.copyOf(Splitter.on(", ").splitToList(csv)));
return true;
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
in.readUTF();
String uuid = in.readUTF();
this.callback.supply(UUID.fromString(uuid));
return true;
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
in.readUTF();
String ip = in.readUTF();
int port = in.readInt();
this.callback.supply(Maps.immutableEntry(ip, port));
return true;
}
@Override
public boolean acceptResponse(Player receiver, ByteArrayDataInput in) {
short len = in.readShort();
byte[] data = new byte[len];
in.readFully(data);
return this.callback.test(data);
}
@SuppressWarnings("UnstableApiUsage")
private <T extends BinaryTag> T writeRead(final T a, final BinaryTagType<T> type) throws IOException {
final ByteArrayDataOutput output = ByteStreams.newDataOutput();
type.write(a, output);
final ByteArrayDataInput input = ByteStreams.newDataInput(output.toByteArray());
return type.read(input);
}
@Override
public void onPluginMessageReceived(String s, Player player, byte[] bytes) {
if (!bungeecord) { return; }
if (channelIdentifier.equals(s)) {
ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
String sub = in.readUTF();
UUID who = UUID.fromString(in.readUTF());
if ("name".equals(sub)) {
String name = in.readUTF();
if (name == null || "reset".equals(name)) {
getAPI().removeNick(who);
} else {
getAPI().setNick(who, name);
}
} else if ("skin".equals(sub)) {
String skin = in.readUTF();
if (skin == null || "reset".equals(skin)) {
getAPI().removeSkin(who);
} else {
getAPI().setSkin(who, skin);
}
} else if ("data".equals(sub)) {
try {
String owner = in.readUTF();
JsonObject data = new JsonParser().parse(in.readUTF()).getAsJsonObject();
SkinLoaderBridge.getSkinProvider().put(owner, new GameProfileWrapper(data).toJson());
} catch (JsonParseException e) {
e.printStackTrace();
}
} else {
getLogger().warning("Unknown incoming plugin message: " + sub);
}
}
}
@Override
public void onPluginMessageReceived(String s, @NonNull Player player, @NonNull byte[] bytes) {
if (!s.equals(CHANNEL)) {
return;
}
ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
String msg = in.readUTF();
this.consumer.consumeIncomingMessageAsString(msg);
}
/** Reads the CONSTANT_Class_info at the given index. */
public String classInfo(int index) {
ByteArrayDataInput reader = byteReader.seek(constantPool[index - 1]);
byte tag = reader.readByte();
if (tag != CONSTANT_CLASS) {
throw new AssertionError(String.format("bad tag: %x", tag));
}
int nameIndex = reader.readUnsignedShort();
return utf8(nameIndex);
}
/**
* Processes the given data input and attempts to translate it to a message for the "AuthMe.v2.Broadcast" channel.
*
* @param in the input to handle
*/
private void handleBroadcast(final ByteArrayDataInput in) {
// Read data byte array
final short dataLength = in.readShort();
final byte[] dataBytes = new byte[dataLength];
in.readFully(dataBytes);
final ByteArrayDataInput dataIn = ByteStreams.newDataInput(dataBytes);
// Parse type
final String typeId = dataIn.readUTF();
final Optional<MessageType> type = MessageType.fromId(typeId);
if (!type.isPresent()) {
logger.debug("Received unsupported forwarded bungeecord message type! ({0})", typeId);
return;
}
// Parse argument
final String argument;
try {
argument = dataIn.readUTF();
} catch (IllegalStateException e) {
logger.warning("Received invalid forwarded plugin message of type " + type.get().name()
+ ": argument is missing!");
return;
}
// Handle type
switch (type.get()) {
case UNREGISTER:
dataSource.invalidateCache(argument);
break;
case REFRESH_PASSWORD:
case REFRESH_QUITLOC:
case REFRESH_EMAIL:
case REFRESH:
dataSource.refreshCache(argument);
break;
default:
}
}