import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
private DefaultConnectionFactory buildDefaultConnectionFactory() {
    return new DefaultConnectionFactory(getOperationQueueLength(), getReadBufferSize(), getHashAlgorithm()) {
        @Override
        public long getOperationTimeout() {
            return getOperationTimeoutMillis();
        }

        @Override
        public boolean isDaemon() {
            return isDaemonMode();
        }

        @Override
        public AuthDescriptor getAuthDescriptor() {
            return createAuthDescriptor();
        }
    };
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
private KetamaConnectionFactory buildKetamaConnectionFactory() {
    return new KetamaConnectionFactory() {
        @Override
        public long getOperationTimeout() {
            return getOperationTimeoutMillis();
        }

        @Override
        public boolean isDaemon() {
            return isDaemonMode();
        }

        @Override
        public AuthDescriptor getAuthDescriptor() {
            return createAuthDescriptor();
        }
    };
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
private BinaryConnectionFactory buildBinaryConnectionFactory() {
    return new BinaryConnectionFactory(getOperationQueueLength(), getReadBufferSize(), getHashAlgorithm()) {
        @Override
        public long getOperationTimeout() {
            return getOperationTimeoutMillis();
        }

        @Override
        public boolean isDaemon() {
            return isDaemonMode();
        }

        @Override
        public AuthDescriptor getAuthDescriptor() {
            return createAuthDescriptor();
        }
    };
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
@Test
public void createConnectionFactoryBuilder() throws Exception {
    Properties props = new Properties();
    props.setProperty(HASH_ALGORITHM_PROPERTY_KEY, DefaultHashAlgorithm.NATIVE_HASH.name());
    props.setProperty(OPERATION_TIMEOUT_MILLIS_PROPERTY_KEY, String.valueOf(13579));
    props.setProperty(TRANSCODER_PROPERTY_KEY, FakeTranscoder.class.getName());
    props.setProperty(AUTH_GENERATOR_PROPERTY_KEY, FakeAuthDescriptorGenerator.class.getName());

    ConnectionFactoryBuilder builder = spyMemcachedAdapter.createConnectionFactoryBuilder(new OverridableReadOnlyPropertiesImpl(props));

    ConnectionFactory connectionFactory = builder.build();
    assertThat(connectionFactory.getHashAlg()).isEqualTo(DefaultHashAlgorithm.NATIVE_HASH);
    assertThat(connectionFactory.getOperationTimeout()).isEqualTo(13579);

    Transcoder<Object> transcoder = connectionFactory.getDefaultTranscoder();
    assertThat(transcoder).isExactlyInstanceOf(FakeTranscoder.class);
    FakeTranscoder fakeTranscoder = (FakeTranscoder) transcoder;
    assertThat(fakeTranscoder.isInitialized()).isTrue();

    AuthDescriptor authDescriptor = connectionFactory.getAuthDescriptor();
    assertThat(authDescriptor.getMechs()).isEqualTo(FakeAuthDescriptorGenerator.FAKE_MECHS);
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
SASLConnectReconnect(String username, String password, String host) {

		AuthDescriptor ad = new AuthDescriptor(new String[] { "PLAIN" },
				new PlainCallbackHandler(username, password));
		try {
			List<InetSocketAddress> addresses = AddrUtil.getAddresses(host);
			mc = new MemcachedClient(
					new ConnectionFactoryBuilder().setProtocol(Protocol.BINARY)
							.setAuthDescriptor(ad).build(), addresses);
		} catch (IOException ex) {
			System.err
					.println("Couldn't create a connection, bailing out: \nIOException "
							+ ex.getMessage());
			if (mc != null) {
				mc.shutdown();
			}
		}

	}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
@Override
public void activateService()
    throws Exception
{
    MemcacheConfiguration config = configuration.get();
    expiration = ( config.expiration().get() == null )
                 ? 3600
                 : config.expiration().get();
    String addresses = ( config.addresses().get() == null )
                       ? "localhost:11211"
                       : config.addresses().get();
    Protocol protocol = ( config.protocol().get() == null )
                        ? Protocol.TEXT
                        : Protocol.valueOf( config.protocol().get().toUpperCase() );
    String username = config.username().get();
    String password = config.password().get();
    String authMech = config.authMechanism().get() == null
                      ? "PLAIN"
                      : config.authMechanism().get();

    ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
    builder.setProtocol( protocol );
    if( username != null && !username.isEmpty() )
    {
        String[] authType = { authMech };
        AuthDescriptor to = new AuthDescriptor( authType, new PlainCallbackHandler( username, password ) );
        builder.setAuthDescriptor( to );
    }

    client = new MemcachedClient( builder.build(), AddrUtil.getAddresses( addresses ) );
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
protected AuthDescriptor createAuthDescriptor() {
    String username = properties.get(PROP_USERNAME);
    String password = properties.get(PROP_PASSWORD);
    if (username == null || password == null) {
        return null;
    }
    return new AuthDescriptor(new String[]{"PLAIN"}, new PlainCallbackHandler(username, password));
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
@Override
public AuthDescriptor generate(OverridableReadOnlyProperties properties) {
    String username = properties.getRequiredProperty(USERNAME_PROPERTY_KEY);
    String password = properties.getRequiredProperty(PASSWORD_PROPERTY_KEY);

    AuthDescriptor authDescriptor = new AuthDescriptor(new String[]{"PLAIN"}, new PlainCallbackHandler(username, password));
    return authDescriptor;
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
@Test
public void generate() throws Exception {
    Properties props = new Properties();
    props.setProperty(PlainAuthDescriptorGenerator.USERNAME_PROPERTY_KEY, "username");
    props.setProperty(PlainAuthDescriptorGenerator.PASSWORD_PROPERTY_KEY, "password");

    AuthDescriptor authDescriptor = generator.generate(new OverridableReadOnlyPropertiesImpl(props));

    assertThat(authDescriptor).isNotNull();
    assertThat(authDescriptor.getMechs()).isEqualTo(new String[]{"PLAIN"});
    assertThat(authDescriptor.getCallback()).isExactlyInstanceOf(PlainCallbackHandler.class);
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
public ApiMemcached() {
	AppConstants ac = AppConstants.getInstance();
	String address = ac.getProperty("etag.cache.server", "localhost:11211");
	String username = ac.getProperty("etag.cache.username", "");
	String password = ac.getProperty("etag.cache.password", "");
	int timeout = ac.getInt("etag.cache.timeout", 10);

	List<InetSocketAddress> addresses = AddrUtil.getAddresses(address);

	ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder()
		.setProtocol(Protocol.BINARY)
		.setOpTimeout(timeout)
		.setInitialObservers(Collections.singleton(obs));

	if(addresses.size()  > 1)
		connectionFactoryBuilder.setFailureMode(FailureMode.Redistribute);
	else
		connectionFactoryBuilder.setFailureMode(FailureMode.Retry);

	if(!username.isEmpty())
		connectionFactoryBuilder.setAuthDescriptor(AuthDescriptor.typical(username, password));

	ConnectionFactory cf = connectionFactoryBuilder.build();

	try {
		client = new MemcachedClient(cf, addresses);
		//Fetching a none-existing key to test the connection
		Future<Object> future = client.asyncGet("test-connection");
		future.get(timeout, TimeUnit.MILLISECONDS);
	} catch (Exception e) {
		ConfigurationWarnings.getInstance().add(log, "Unable to connect to one or more memcached servers.", null, true);
	}
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
public void setAuthDescriptor(final AuthDescriptor to) {
  connectionFactoryBuilder.setAuthDescriptor(to);
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
public AuthDescriptor getAuthDescriptor() {
  return null;
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
/**
 * Set the auth descriptor to enable authentication on new connections.
 */
public ConnectionFactoryBuilder setAuthDescriptor(AuthDescriptor to) {
  authDescriptor = to;
  return this;
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
@Override
public void onActivate( Application application )
    throws ActivationException
{
    // Gather Configuration
    Config config = application.config().atKey( "memcache" );
    Protocol protocol = Protocol.valueOf( config.string( "protocol" ).toUpperCase( Locale.US ) );
    String addresses = config.string( "addresses" );
    String username = config.has( "username" ) ? config.string( "username" ) : null;
    String password = config.has( "password" ) ? config.string( "password" ) : null;
    String authMech = config.string( "authMechanism" );

    // Create Client
    try
    {
        ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
        builder.setProtocol( protocol );
        if( !Strings.isEmpty( username ) )
        {
            builder.setAuthDescriptor(
                new AuthDescriptor(
                    new String[]
                    {
                        authMech
                    },
                    new PlainCallbackHandler( username, password )
                )
            );
        }
        client = new MemcachedClient( builder.build(), AddrUtil.getAddresses( addresses ) );
    }
    catch( IOException ex )
    {
        throw new ActivationException( "Unable to Activate MemcachePlugin: " + ex.getMessage(), ex );
    }

    // Create Cache Instance
    backingCache = config.bool( "metrics" )
                   ? new MemcacheCache( application.plugin( Metrics.class ), client )
                   : new MemcacheCache( client );
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
@Override
public AuthDescriptor generate(OverridableReadOnlyProperties properties) {
    return new AuthDescriptor(FAKE_MECHS, null);
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
public AuthDescriptor getAuthDescriptor() {
	return null;
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
/**
 * Set the auth descriptor to enable authentication on new connections.
 */
public ConnectionFactoryBuilder setAuthDescriptor(AuthDescriptor to) {
	authDescriptor = to;
	return this;
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
public void init() throws Exception {
	client = new MemcachedClient(new ConnectionFactoryBuilder()
			.setProtocol(Protocol.BINARY)
			.setAuthDescriptor(AuthDescriptor.typical(username, password))
			.build(), AddrUtil.getAddresses("localhost:11212"));
}
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
/**
 * Authenticate connections using the given auth descriptor.
 *
 * @return null if no authentication should take place
 */
AuthDescriptor getAuthDescriptor();
 

import net.spy.memcached.auth.AuthDescriptor; //导入依赖的package包/类
AuthDescriptor generate(OverridableReadOnlyProperties properties);