Java CachedData类代码示例

import net.spy.memcached.CachedData; //导入依赖的package包/类
/**
   * Perform a decode.
   */
  public <T> Future<T> decode(final Transcoder<T> tc,
      final CachedData cachedData) {

//    assert !pool.isShutdown() : "Pool has already shut down.";

    TranscodeService.Task<T> task =
        new TranscodeService.Task<T>(new Callable<T>() {
          public T call() {
            return tc.decode(cachedData);
          }
        });

//    if (tc.asyncDecode(cachedData)) {
//      this.pool.execute(task);
//    }
    return task;
  }
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public CachedResponse decode(CachedData d) {
    try {
        byte[] cachedData = d.getData();
        int headerSeparatorIndex = Bytes.indexOf(cachedData, HEADER_SEPARATOR);

        if (headerSeparatorIndex < 0) {
            return null;
        }

        BufferedReader headerReader = new BufferedReader(new InputStreamReader(
                new ByteArrayInputStream(cachedData, 0, headerSeparatorIndex),
                Charsets.US_ASCII)
        );

        int statusCode = readStatusCode(headerReader);
        MultivaluedMap<String, String> headers = readHeaders(headerReader);
        byte[] responseContent = Arrays.copyOfRange(cachedData, headerSeparatorIndex + HEADER_SEPARATOR.length, cachedData.length);

        return new CachedResponse(statusCode, headers, responseContent);
    } catch (IOException ex) {
        throw new RuntimeException("Corrupted cache entry", ex);
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
public CachedData encode(Object o) {
    ResizeableByteBuffer buffer = (ResizeableByteBuffer)o;
    byte[] b;
    int flags = 0;
    int bufferSize = buffer.size();
    int maxPossibleCompressedLength = getMaxCompressedLength(bufferSize);
    if (bufferSize > compressionThreshold && maxPossibleCompressedLength < bufferSize) {
        try {
            b = compress(buffer.getBuf(),0,bufferSize,maxPossibleCompressedLength);
            flags |= COMPRESSED;
        } catch (Exception e) {
            throw new RuntimeException("IO exception compressing data", e);
        }
    } else {
        b = buffer.toByteArray();
    }
    return new CachedData(flags, b, getMaxSize());
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
/**
 * Perform a decode.
 */
public <T> Future<T> decode(final Transcoder<T> tc,
		final CachedData cachedData) {

	assert !pool.isShutdown() : "Pool has already shut down.";

	TranscodeService.Task<T> task = new TranscodeService.Task<T>(
			new Callable<T>() {
				public T call() {
					return tc.decode(cachedData);
				}
			});

	if (tc.asyncDecode(cachedData)) {
		this.pool.execute(task);
	}
	return task;
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public CachedData encode(final Object obj) {
    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    try (Output output = new Output(byteStream)) {
        kryo.writeClassAndObject(output, obj);
        output.flush();
        final byte[] bytes = byteStream.toByteArray();
        return new CachedData(0, bytes, bytes.length);
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public Object decode(final CachedData d) {
    final byte[] bytes = d.getData();
    try (Input input = new Input(new ByteArrayInputStream(bytes))) {
        final Object obj =  kryo.readClassAndObject(input);
        return obj;
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Test
public void verifyEncodeDecodeTGTImpl() throws Exception {
    final Credential userPassCredential = new UsernamePasswordCredential(USERNAME, PASSWORD);
    final AuthenticationBuilder bldr = new DefaultAuthenticationBuilder(
            new DefaultPrincipalFactory()
                    .createPrincipal("user", Collections.unmodifiableMap(this.principalAttributes)));
    bldr.setAttributes(Collections.unmodifiableMap(this.principalAttributes));
    bldr.setAuthenticationDate(new DateTime());
    bldr.addCredential(new BasicCredentialMetaData(userPassCredential));
    bldr.addFailure("error", AccountNotFoundException.class);
    bldr.addSuccess("authn", new DefaultHandlerResult(
            new AcceptUsersAuthenticationHandler(),
            new BasicCredentialMetaData(userPassCredential)));

    final TicketGrantingTicket expectedTGT =
            new TicketGrantingTicketImpl(TGT_ID,
                    org.jasig.cas.services.TestUtils.getService(),
                    null, bldr.build(),
                    new NeverExpiresExpirationPolicy());

    final ServiceTicket ticket = expectedTGT.grantServiceTicket(ST_ID,
            org.jasig.cas.services.TestUtils.getService(),
            new NeverExpiresExpirationPolicy(), false, true);
    CachedData result = transcoder.encode(expectedTGT);
    final TicketGrantingTicket resultTicket = (TicketGrantingTicket) transcoder.decode(result);

    assertEquals(expectedTGT, resultTicket);
    result = transcoder.encode(ticket);
    final ServiceTicket resultStTicket = (ServiceTicket) transcoder.decode(result);
    assertEquals(ticket, resultStTicket);

}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public CachedData encode(final Object obj) {
    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    try (final Output output = new Output(byteStream)) {
        kryo.writeClassAndObject(output, obj);
        output.flush();
        final byte[] bytes = byteStream.toByteArray();
        return new CachedData(0, bytes, bytes.length);
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public Object decode(final CachedData d) {
    final byte[] bytes = d.getData();
    try (final Input input = new Input(new ByteArrayInputStream(bytes))) {
        final Object obj =  kryo.readClassAndObject(input);
        return obj;
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Test
public void verifyEncodeDecodeTGTImpl() throws Exception {
    final Credential userPassCredential = new UsernamePasswordCredential(USERNAME, PASSWORD);
    final AuthenticationBuilder bldr = new DefaultAuthenticationBuilder(
            new DefaultPrincipalFactory()
                    .createPrincipal("user", Collections.unmodifiableMap(this.principalAttributes)));
    bldr.setAttributes(Collections.unmodifiableMap(this.principalAttributes));
    bldr.setAuthenticationDate(new Date());
    bldr.addCredential(new BasicCredentialMetaData(userPassCredential));
    bldr.addFailure("error", AccountNotFoundException.class);
    bldr.addSuccess("authn", new DefaultHandlerResult(
            new AcceptUsersAuthenticationHandler(),
            new BasicCredentialMetaData(userPassCredential)));

    final TicketGrantingTicket parent =
            new TicketGrantingTicketImpl(TGT_ID, TestUtils.getService(), null, bldr.build(),
                    new NeverExpiresExpirationPolicy());

    final TicketGrantingTicket expectedTGT =
            new TicketGrantingTicketImpl(TGT_ID, TestUtils.getService(),
                    null, bldr.build(),
                    new NeverExpiresExpirationPolicy());

    final ServiceTicket ticket = expectedTGT.grantServiceTicket(ST_ID,
            TestUtils.getService(),
            new NeverExpiresExpirationPolicy(), false);
    CachedData result = transcoder.encode(expectedTGT);
    final TicketGrantingTicket resultTicket = (TicketGrantingTicket) transcoder.decode(result);

    assertEquals(expectedTGT, resultTicket);
    result = transcoder.encode(ticket);
    final ServiceTicket resultStTicket = (ServiceTicket) transcoder.decode(result);
    assertEquals(ticket, resultStTicket);

}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public CachedData encode(final Object obj) {
    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    try (Output output = new Output(byteStream)) {
        this.kryo.writeClassAndObject(output, obj);
        output.flush();
        final byte[] bytes = byteStream.toByteArray();
        return new CachedData(0, bytes, bytes.length);
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public Object decode(final CachedData d) {
    final byte[] bytes = d.getData();
    try (Input input = new Input(new ByteArrayInputStream(bytes))) {
        final Object obj = this.kryo.readClassAndObject(input);
        return obj;
    }
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Test
public void verifyEncodeDecodeTGTImpl() throws Exception {
    final Credential userPassCredential = new UsernamePasswordCredential(USERNAME, PASSWORD);
    final AuthenticationBuilder bldr = new DefaultAuthenticationBuilder(
            new DefaultPrincipalFactory()
                    .createPrincipal("user", new HashMap<>(this.principalAttributes)));
    bldr.setAttributes(new HashMap<>(this.principalAttributes));
    bldr.setAuthenticationDate(ZonedDateTime.now());
    bldr.addCredential(new BasicCredentialMetaData(userPassCredential));
    bldr.addFailure("error", AccountNotFoundException.class);
    bldr.addSuccess("authn", new DefaultHandlerResult(
            new AcceptUsersAuthenticationHandler(""),
            new BasicCredentialMetaData(userPassCredential)));

    final TicketGrantingTicket expectedTGT =
            new TicketGrantingTicketImpl(TGT_ID,
                    RegisteredServiceTestUtils.getService(),
                    null, bldr.build(),
                    new NeverExpiresExpirationPolicy());

    final ServiceTicket ticket = expectedTGT.grantServiceTicket(ST_ID,
            RegisteredServiceTestUtils.getService(),
            new NeverExpiresExpirationPolicy(), false, true);
    CachedData result = transcoder.encode(expectedTGT);
    final TicketGrantingTicket resultTicket = (TicketGrantingTicket) transcoder.decode(result);

    assertEquals(expectedTGT, resultTicket);
    result = transcoder.encode(ticket);
    final ServiceTicket resultStTicket = (ServiceTicket) transcoder.decode(result);
    assertEquals(ticket, resultStTicket);

}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public CachedData encode(final Object obj) {
    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    final Output output = new Output(byteStream);
    kryo.writeClassAndObject(output, obj);
    output.flush();
    IOUtils.closeQuietly(output);
    final byte[] bytes = byteStream.toByteArray();
    return new CachedData(0, bytes, bytes.length);
}
 

import net.spy.memcached.CachedData; //导入依赖的package包/类
@Override
public Object decode(final CachedData d) {
    final byte[] bytes = d.getData();
    final Input input = new Input(new ByteArrayInputStream(bytes));
    final Object obj =  kryo.readClassAndObject(input);
    IOUtils.closeQuietly(input);
    return obj;
}