import net.spy.memcached.auth.PlainCallbackHandler; //导入依赖的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.PlainCallbackHandler; //导入依赖的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.PlainCallbackHandler; //导入依赖的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.PlainCallbackHandler; //导入依赖的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.PlainCallbackHandler; //导入依赖的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.PlainCallbackHandler; //导入依赖的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 );
}