Java Bytes.wrap方法代码示例

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldOnlyIterateOverSegmentsInRange() throws Exception {
    iterator = new SegmentIterator(Arrays.asList(segmentOne, segmentTwo).iterator(),
            hasNextCondition,
            Bytes.wrap("a".getBytes()),
            Bytes.wrap("b".getBytes()));

    assertTrue(iterator.hasNext());
    assertEquals("a", new String(iterator.peekNextKey().get()));
    assertEquals(KeyValue.pair("a", "1"), toStringKeyValue(iterator.next()));

    assertTrue(iterator.hasNext());
    assertEquals("b", new String(iterator.peekNextKey().get()));
    assertEquals(KeyValue.pair("b", "2"), toStringKeyValue(iterator.next()));

    assertFalse(iterator.hasNext());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
static Bytes lowerRange(Bytes key, byte[] minSuffix) {
    final byte[] bytes = key.get();
    ByteBuffer rangeStart = ByteBuffer.allocate(bytes.length + minSuffix.length);
    // any key in the range would start at least with the given prefix to be
    // in the range, and have at least SUFFIX_SIZE number of trailing zero bytes.

    // unless there is a maximum key length, you can keep appending more zero bytes
    // to keyFrom to create a key that will match the range, yet that would precede
    // WindowStoreUtils.toBinaryKey(keyFrom, from, 0) in byte order
    return Bytes.wrap(
        rangeStart
            .put(bytes)
            .put(minSuffix)
            .array()
    );
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldIterateOverAllSegments() throws Exception {
    iterator = new SegmentIterator(Arrays.asList(segmentOne, segmentTwo).iterator(),
            hasNextCondition,
            Bytes.wrap("a".getBytes()),
            Bytes.wrap("z".getBytes()));

    assertTrue(iterator.hasNext());
    assertEquals("a", new String(iterator.peekNextKey().get()));
    assertEquals(KeyValue.pair("a", "1"), toStringKeyValue(iterator.next()));

    assertTrue(iterator.hasNext());
    assertEquals("b", new String(iterator.peekNextKey().get()));
    assertEquals(KeyValue.pair("b", "2"), toStringKeyValue(iterator.next()));

    assertTrue(iterator.hasNext());
    assertEquals("c", new String(iterator.peekNextKey().get()));
    assertEquals(KeyValue.pair("c", "3"), toStringKeyValue(iterator.next()));

    assertTrue(iterator.hasNext());
    assertEquals("d", new String(iterator.peekNextKey().get()));
    assertEquals(KeyValue.pair("d", "4"), toStringKeyValue(iterator.next()));

    assertFalse(iterator.hasNext());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Override
public synchronized WindowStoreIterator<V> fetch(final K key, final long timeFrom, final long timeTo) {
    // since this function may not access the underlying inner store, we need to validate
    // if store is open outside as well.
    validateStoreOpen();

    final Bytes keyBytes = Bytes.wrap(serdes.rawKey(key));
    final WindowStoreIterator<byte[]> underlyingIterator = underlying.fetch(keyBytes, timeFrom, timeTo);

    final Bytes cacheKeyFrom = cacheFunction.cacheKey(keySchema.lowerRangeFixedSize(keyBytes, timeFrom));
    final Bytes cacheKeyTo = cacheFunction.cacheKey(keySchema.upperRangeFixedSize(keyBytes, timeTo));
    final ThreadCache.MemoryLRUCacheBytesIterator cacheIterator = cache.range(name, cacheKeyFrom, cacheKeyTo);

    final HasNextCondition hasNextCondition = keySchema.hasNextCondition(keyBytes,
                                                                         keyBytes,
                                                                         timeFrom,
                                                                         timeTo);
    final PeekingKeyValueIterator<Bytes, LRUCacheEntry> filteredCacheIterator = new FilteredCacheIterator(
        cacheIterator, hasNextCondition, cacheFunction
    );

    return new MergedSortedCacheWindowStoreIterator<>(filteredCacheIterator,
                                                      underlyingIterator,
                                                      new StateSerdes<>(serdes.topic(), Serdes.Long(), serdes.valueSerde()));
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
public KeyValueIterator<Windowed<K>, AGG> findSessions(final K key,
                                                       final long earliestSessionEndTime,
                                                       final long latestSessionStartTime) {
    validateStoreOpen();
    final Bytes binarySessionId = Bytes.wrap(serdes.rawKey(key));

    final Bytes cacheKeyFrom = cacheFunction.cacheKey(keySchema.lowerRangeFixedSize(binarySessionId, earliestSessionEndTime));
    final Bytes cacheKeyTo = cacheFunction.cacheKey(keySchema.upperRangeFixedSize(binarySessionId, latestSessionStartTime));
    final ThreadCache.MemoryLRUCacheBytesIterator cacheIterator = cache.range(cacheName, cacheKeyFrom, cacheKeyTo);

    final KeyValueIterator<Windowed<Bytes>, byte[]> storeIterator = bytesStore.findSessions(
        binarySessionId, earliestSessionEndTime, latestSessionStartTime
    );
    final HasNextCondition hasNextCondition = keySchema.hasNextCondition(binarySessionId,
                                                                         binarySessionId,
                                                                         earliestSessionEndTime,
                                                                         latestSessionStartTime);
    final PeekingKeyValueIterator<Bytes, LRUCacheEntry> filteredCacheIterator = new FilteredCacheIterator(cacheIterator, hasNextCondition, cacheFunction);
    return new MergedSortedCacheSessionStoreIterator<>(filteredCacheIterator, storeIterator, serdes, cacheFunction);
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldIterateOverRange() throws Exception {
    final byte[][] bytes = {{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}};
    for (int i = 0; i < bytes.length; i += 2) {
        store.put(Bytes.wrap(bytes[i]), bytes[i]);
        cache.put(namespace, Bytes.wrap(bytes[i + 1]), new LRUCacheEntry(bytes[i + 1]));
    }

    final Bytes from = Bytes.wrap(new byte[]{2});
    final Bytes to = Bytes.wrap(new byte[]{9});
    final KeyValueIterator<Bytes, byte[]> storeIterator = new DelegatingPeekingKeyValueIterator<>("store", store.range(from, to));
    final ThreadCache.MemoryLRUCacheBytesIterator cacheIterator = cache.range(namespace, from, to);

    final MergedSortedCacheKeyValueStoreIterator<byte[], byte[]> iterator = new MergedSortedCacheKeyValueStoreIterator<>(cacheIterator, storeIterator, serdes);
    byte[][] values = new byte[8][];
    int index = 0;
    int bytesIndex = 2;
    while (iterator.hasNext()) {
        final byte[] value = iterator.next().value;
        values[index++] = value;
        assertArrayEquals(bytes[bytesIndex++], value);
    }
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldIterateCacheAndStoreKeyRange() throws Exception {
    final Bytes key = Bytes.wrap("1" .getBytes());
    underlying.put(WindowStoreUtils.toBinaryKey(key, DEFAULT_TIMESTAMP, 0, WindowStoreUtils.getInnerStateSerde("app-id")), "a".getBytes());
    cachingStore.put("1", "b", DEFAULT_TIMESTAMP + WINDOW_SIZE);

    final KeyValueIterator<Windowed<String>, String> fetchRange =
        cachingStore.fetch("1", "2", DEFAULT_TIMESTAMP, DEFAULT_TIMESTAMP + WINDOW_SIZE);
    assertEquals(KeyValue.pair(new Windowed<>("1", new TimeWindow(DEFAULT_TIMESTAMP, DEFAULT_TIMESTAMP + WINDOW_SIZE)), "a"), fetchRange.next());
    assertEquals(KeyValue.pair(new Windowed<>("1", new TimeWindow(DEFAULT_TIMESTAMP + WINDOW_SIZE, DEFAULT_TIMESTAMP + WINDOW_SIZE + WINDOW_SIZE)), "b"), fetchRange.next());
    assertFalse(fetchRange.hasNext());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Override
public Bytes cacheKey(Bytes key) {
    final byte[] keyBytes = key.get();
    ByteBuffer buf = ByteBuffer.allocate(SEGMENT_ID_BYTES + keyBytes.length);
    buf.putLong(segmentId(key)).put(keyBytes);
    return Bytes.wrap(buf.array());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
static Bytes toBinaryKey(byte[] serializedKey, final long timestamp, final int seqnum) {
    ByteBuffer buf = ByteBuffer.allocate(serializedKey.length + TIMESTAMP_SIZE + SEQNUM_SIZE);
    buf.put(serializedKey);
    buf.putLong(timestamp);
    buf.putInt(seqnum);

    return Bytes.wrap(buf.array());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void shouldFetchAndIterateOverExactBinaryKeys() throws Exception {
    final RocksDBWindowStoreSupplier<Bytes, String> supplier =
            new RocksDBWindowStoreSupplier<>(
                    "window",
                    60000, 2,
                    true,
                    Serdes.Bytes(),
                    Serdes.String(),
                    60000,
                    true,
                    Collections.<String, String>emptyMap(),
                    false);

    windowStore = supplier.get();
    windowStore.init(context, windowStore);

    final Bytes key1 = Bytes.wrap(new byte[]{0});
    final Bytes key2 = Bytes.wrap(new byte[]{0, 0});
    final Bytes key3 = Bytes.wrap(new byte[]{0, 0, 0});
    windowStore.put(key1, "1", 0);
    windowStore.put(key2, "2", 0);
    windowStore.put(key3, "3", 0);
    windowStore.put(key1, "4", 1);
    windowStore.put(key2, "5", 1);
    windowStore.put(key3, "6", 59999);
    windowStore.put(key1, "7", 59999);
    windowStore.put(key2, "8", 59999);
    windowStore.put(key3, "9", 59999);

    final List expectedKey1 = Utils.mkList("1", "4", "7");
    assertThat(toList(windowStore.fetch(key1, 0, Long.MAX_VALUE)), equalTo(expectedKey1));
    final List expectedKey2 = Utils.mkList("2", "5", "8");
    assertThat(toList(windowStore.fetch(key2, 0, Long.MAX_VALUE)), equalTo(expectedKey2));
    final List expectedKey3 = Utils.mkList("3", "6", "9");
    assertThat(toList(windowStore.fetch(key3, 0, Long.MAX_VALUE)), equalTo(expectedKey3));
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldIterateCacheAndStore() throws Exception {
    final Bytes key = Bytes.wrap("1" .getBytes());
    underlying.put(WindowStoreUtils.toBinaryKey(key, DEFAULT_TIMESTAMP, 0, WindowStoreUtils.getInnerStateSerde("app-id")), "a".getBytes());
    cachingStore.put("1", "b", DEFAULT_TIMESTAMP + WINDOW_SIZE);
    final WindowStoreIterator<String> fetch = cachingStore.fetch("1", DEFAULT_TIMESTAMP, DEFAULT_TIMESTAMP + WINDOW_SIZE);
    assertEquals(KeyValue.pair(DEFAULT_TIMESTAMP, "a"), fetch.next());
    assertEquals(KeyValue.pair(DEFAULT_TIMESTAMP + WINDOW_SIZE, "b"), fetch.next());
    assertFalse(fetch.hasNext());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldNotClashWithOverlappingNames() throws Exception {
    final ThreadCache cache = new ThreadCache("testCache", 10000L, new MockStreamsMetrics(new Metrics()));
    final Bytes nameByte = Bytes.wrap(new byte[]{0});
    final Bytes name1Byte = Bytes.wrap(new byte[]{1});
    cache.put("name", nameByte, dirtyEntry(nameByte.get()));
    cache.put("name1", nameByte, dirtyEntry(name1Byte.get()));

    assertArrayEquals(nameByte.get(), cache.get("name", nameByte).value);
    assertArrayEquals(name1Byte.get(), cache.get("name1", nameByte).value);
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Override
public KeyValueIterator<K, V> range(final K from, final K to) {
    validateStoreOpen();
    final Bytes origFrom = Bytes.wrap(serdes.rawKey(from));
    final Bytes origTo = Bytes.wrap(serdes.rawKey(to));
    final KeyValueIterator<Bytes, byte[]> storeIterator = underlying.range(origFrom, origTo);
    final ThreadCache.MemoryLRUCacheBytesIterator cacheIterator = cache.range(cacheName, origFrom, origTo);
    return new MergedSortedCacheKeyValueStoreIterator<>(cacheIterator, storeIterator, serdes);
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test
public void shouldPeekNextKey() throws Exception {
    final ThreadCache cache = new ThreadCache("testCache", 10000L, new MockStreamsMetrics(new Metrics()));
    final Bytes theByte = Bytes.wrap(new byte[]{0});
    final String namespace = "streams";
    cache.put(namespace, theByte, dirtyEntry(theByte.get()));
    final ThreadCache.MemoryLRUCacheBytesIterator iterator = cache.range(namespace, theByte, Bytes.wrap(new byte[]{1}));
    assertEquals(theByte, iterator.peekNextKey());
    assertEquals(theByte, iterator.peekNextKey());
}
 

import org.apache.kafka.common.utils.Bytes; //导入方法依赖的package包/类
@Test(expected = NoSuchElementException.class)
public void shouldThrowNoSuchElementOnPeekNextKeyIfNoNext() throws Exception {
    iterator = new SegmentIterator(Arrays.asList(segmentOne, segmentTwo).iterator(),
            hasNextCondition,
            Bytes.wrap("f".getBytes()),
            Bytes.wrap("h".getBytes()));

    iterator.peekNextKey();
}