Java LdapConnectionConfig类代码示例

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
@Override
protected void useBundleClasses() throws Exception
{
    new LdapNetworkConnection().close();
    new SaslGssApiRequest();
    new Krb5LoginConfiguration();
    new AddFuture( new LdapNetworkConnection(), 2 );
    new LdapConnectionTemplate( new LdapConnectionPool( new DefaultPoolableLdapConnectionFactory(
        new LdapConnectionConfig() ) ) );
    FilterBuilder.and( FilterBuilder.not( FilterBuilder.contains( "cn", "a", "b" ) ) ).toString();

    // Test for DIRAPI-239
    PoolableObjectFactory<LdapConnection> factory = new DefaultPoolableLdapConnectionFactory(
        new LdapConnectionConfig() );
    Config config = new Config();
    LdapConnectionPool ldapConnectionPool = new LdapConnectionPool( factory, config );
    ldapConnectionPool.getLdapApiService();
    ldapConnectionPool.getTestOnBorrow();
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
public static String formatConnectionInfo(LdapNetworkConnection connection) {
	StringBuilder sb = new StringBuilder();
	LdapConnectionConfig config = connection.getConfig();
	Integer port = null;
	if (config.isUseSsl()) {
		sb.append("ldaps://");
		if (config.getLdapPort() != 636) {
			port = config.getLdapPort();
		}
	} else {
		sb.append("ldap://");
		if (config.getLdapPort() != 389) {
			port = config.getLdapPort();
		}
	}
	sb.append(config.getLdapHost());
	if (port != null) {
		sb.append(":").append(port);
	}
	sb.append("/ ");
	return sb.toString();
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
@Before
  public void setup() throws Exception {
  	LdapConnectionConfig config = new LdapConnectionConfig();
      config.setLdapHost( "localhost" );
      config.setLdapPort( ldapServer.getPort() );
      config.setName(ADMIN_DN);
      config.setCredentials(ADMIN_PASSWORD);
  	connection = new LdapNetworkConnection( config);
  	connection.bind(ADMIN_DN, ADMIN_PASSWORD);
connection.add(
  	        new DefaultEntry(
  	        	USER_DN,
  	            "ObjectClass: top",
  	            "ObjectClass: person",
  	            "userPassword", USER_PASSWORD,
  	            "cn", "testUser",
  	            "sn", "test"
  	            ) );
connection.unBind();
  }
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
private static LdapConnectionPool createConnectionPool(LDAPConfiguration configuration) throws IOException {
  final LdapConnectionConfig config = new LdapConnectionConfig();
  config.setLdapHost(configuration.getHostname());
  config.setLdapPort(configuration.getPort());
  config.setName(configuration.getBindDn());
  config.setCredentials(configuration.getBindPassword());

  final DefaultPoolableLdapConnectionFactory factory = new DefaultPoolableLdapConnectionFactory(config);

  final LdapConnectionPool pool = new LdapConnectionPool(factory);
  pool.setTestOnBorrow(configuration.isPoolTestOnBorrow());
  pool.setTestOnReturn(configuration.isPoolTestOnReturn());
  pool.setTestWhileIdle(configuration.isPoolTestWhileIdle());

  pool.setMaxActive(configuration.getPoolMaxActive());
  pool.setMaxIdle(configuration.getPoolMaxIdle());
  pool.setMinIdle(configuration.getPoolMinIdle());
  pool.setMaxWait(configuration.getPoolMaxWait());

  switch (configuration.getPoolWhenExhaustedAction()) {
    case BLOCK:
      pool.setWhenExhaustedAction(LdapConnectionPool.WHEN_EXHAUSTED_BLOCK);
      break;
    case FAIL:
      pool.setWhenExhaustedAction(LdapConnectionPool.WHEN_EXHAUSTED_FAIL);
      break;
    case GROW:
      pool.setWhenExhaustedAction(LdapConnectionPool.WHEN_EXHAUSTED_GROW);
      break;
    default:
      pool.setWhenExhaustedAction(LdapConnectionPool.DEFAULT_WHEN_EXHAUSTED_ACTION);
  }

  return pool;
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
public void init() throws Exception {

		LdapConnectionConfig lconfig = new LdapConnectionConfig();
		lconfig.setLdapHost(configurationService.getLdapServer());
		lconfig.setLdapPort(Integer.parseInt(configurationService.getLdapPort()));
		lconfig.setName(configurationService.getLdapUsername());
		lconfig.setCredentials(configurationService.getLdapPassword());
		
		
		if (configurationService.getLdapUseSsl()) {
			lconfig.setUseSsl(true);
			if (configurationService.getLdapAllowSelfSignedCert()) {
				lconfig.setKeyManagers(createCustomKeyManagers());
				lconfig.setTrustManagers(createCustomTrustManager());
			}
		} else {
			lconfig.setUseSsl(false);
		}
		
		// Create connection pool
		PoolableLdapConnectionFactory factory = new PoolableLdapConnectionFactory(lconfig);
		pool = new LdapConnectionPool(factory);
		pool.setTestOnBorrow(true);
		pool.setMaxActive(100);
		pool.setMaxWait(3000);
		pool.setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_BLOCK);


		logger.debug(this.toString());
	}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
public LdapUtils(String host, int port, String username, String password, boolean useSsl) {
	// Configure
	LdapConnectionConfig config = new LdapConnectionConfig();
	config.setLdapHost(host);
	config.setLdapPort(port);
	config.setName(username);
	config.setCredentials(password);
	config.setUseSsl(useSsl);
	// Create connection factory
	DefaultPoolableLdapConnectionFactory factory = new DefaultPoolableLdapConnectionFactory(config);
	pool = new LdapConnectionPool(factory);
	pool.setTestOnBorrow(true);
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
private LdapConnectionConfig createLdapConnectionConfig(ServerDefinition serverDefinition) {
	LdapConnectionConfig connectionConfig = new LdapConnectionConfig();
	connectionConfig.setLdapHost(serverDefinition.getHost());
	connectionConfig.setLdapPort(serverDefinition.getPort());
	connectionConfig.setTimeout(serverDefinition.getConnectTimeout());
	
	String connectionSecurity = serverDefinition.getConnectionSecurity();
   	if (connectionSecurity == null || LdapConfiguration.CONNECTION_SECURITY_NONE.equals(connectionSecurity)) {
   		// Nothing to do
   	} else if (LdapConfiguration.CONNECTION_SECURITY_SSL.equals(connectionSecurity)) {
   		connectionConfig.setUseSsl(true);
   	} else if (LdapConfiguration.CONNECTION_SECURITY_STARTTLS.equals(connectionSecurity)) {
   		connectionConfig.setUseTls(true);
   	} else {
   		throw new ConfigurationException("Unknown value for connectionSecurity: "+connectionSecurity);
   	}
   	
   	String[] enabledSecurityProtocols = configuration.getEnabledSecurityProtocols();
	if (enabledSecurityProtocols != null) {
		connectionConfig.setEnabledProtocols(enabledSecurityProtocols);
	}
	
	String[] enabledCipherSuites = configuration.getEnabledCipherSuites();
	if (enabledCipherSuites != null) {
		connectionConfig.setEnabledCipherSuites(enabledCipherSuites);
	}
	
	String sslProtocol = configuration.getSslProtocol();
	if (sslProtocol != null) {
		connectionConfig.setSslProtocol(sslProtocol);
	}
	
   	connectionConfig.setBinaryAttributeDetector(binaryAttributeDetector);

	return connectionConfig;
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
private LdapNetworkConnection connectConnection(LdapConnectionConfig connectionConfig) {
	LOG.ok("Creating connection object");
	LdapNetworkConnection connection = new LdapNetworkConnection(connectionConfig);
	try {
		LOG.info("Connecting to {0}:{1} as {2}", connectionConfig.getLdapHost(), connectionConfig.getLdapPort(), configuration.getBindDn());
		if (LOG.isOk()) {
			String connectionSecurity = "none";
			if (connectionConfig.isUseSsl()) {
				connectionSecurity = "ssl";
			} else if (connectionConfig.isUseTls()) {
				connectionSecurity = "tls";
			}
			LOG.ok("Connection security: {0} (sslProtocol={1}, enabledSecurityProtocols={2}, enabledCipherSuites={3}",
					connectionSecurity, connectionConfig.getSslProtocol(),
					connectionConfig.getEnabledProtocols(), connectionConfig.getEnabledCipherSuites());
		}
		boolean connected = connection.connect();
		LOG.ok("Connected ({0})", connected);
		if (!connected) {
			throw new ConnectionFailedException("Unable to connect to LDAP server "+configuration.getHost()+":"+configuration.getPort()+" due to unknown reasons");
		}
	} catch (LdapException e) {
		try {
			connection.close();
		} catch (IOException e1) {
			LOG.error("Error closing conection (handling error during creation of a new connection): {1}", e.getMessage(), e);
		}
		throw LdapUtil.processLdapException("Unable to connect to LDAP server "+configuration.getHost()+":"+configuration.getPort(), e);
	}
	
	return connection;
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
private LdapConnection connection(String username, String password) throws LdapException {
	// Manually build the configuration since the convenience constructor in 
	// the LdapNetworkConnection doesn't let us specify a TLS setting			
	LdapConnectionConfig config = new LdapConnectionConfig();
	config.setLdapHost(host);
	config.setLdapPort(port);
	config.setUseTls(useTls);
	config.setUseSsl(useSsl);
       LdapNetworkConnection conn = new LdapNetworkConnection(config);
	
	conn.bind(username, password);
	return conn;
}
 

import org.apache.directory.ldap.client.api.LdapConnectionConfig; //导入依赖的package包/类
@Before
  public void setup() throws Exception {
LdapConnectionConfig config = new LdapConnectionConfig();
      config.setLdapHost( "localhost" );
      config.setLdapPort( ldapServer.getPort() );
      config.setName(ADMIN_DN);
      config.setCredentials(ADMIN_PASSWORD);
      connection = new LdapNetworkConnection( config);
  }