import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
/**
 * Modify ldap entry.
 *
 * @param serverCon the server con
 * @param dn        the dn
 * @param attr      the attr
 * @param add       the add
 */
public static void modifyLdapEntry(final LDAPConnection serverCon, final String dn, final LdapAttribute attr,
                                   final AttributeModificationType add) {
    try {
        final String address = "ldap://" + serverCon.getConnectedAddress() + ':' + serverCon.getConnectedPort();
        try (Connection conn = DefaultConnectionFactory.getConnection(address)) {
            try {
                conn.open();
                final ModifyOperation modify = new ModifyOperation(conn);
                modify.execute(new ModifyRequest(dn, new AttributeModification(add, attr)));
            } catch (final Exception e) {
                LOGGER.debug(e.getMessage(), e);
            }
        }
    } finally {
        serverCon.close();
    }
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
/**
 * Creates a new instance of a connection pool. Copied from {@link #connectionPool}.
 *
 * @param ldapURL to connect to
 * @return connection pool
 */
private ConnectionPool newConnectionPool(final String ldapURL) {
    final BlockingConnectionPool pool = new BlockingConnectionPool(
            newPoolConfig(this.connectionPool.getPoolConfig()),
            (DefaultConnectionFactory) super.prepareConnectionFactory(ldapURL));
    pool.setBlockWaitTime(this.connectionPool.getBlockWaitTime());
    pool.setActivator(this.connectionPool.getActivator());
    pool.setPassivator(this.connectionPool.getPassivator());
    pool.setValidator(this.connectionPool.getValidator());
    pool.setConnectOnCreate(this.connectionPool.getConnectOnCreate());
    pool.setFailFastInitialize(this.connectionPool.getFailFastInitialize());
    pool.setName(String.format("x509-crl-%s", ldapURL));
    pool.setPruneStrategy(this.connectionPool.getPruneStrategy());
    pool.initialize();
    return pool;
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
public static void bootstrap() throws Exception {
    initDirectoryServer();
    getDirectory().populateEntries(new ClassPathResource("ldif/users-x509.ldif").getInputStream());

    /**
     * Dynamically set the attribute value to the crl content.
     * Encode it as base64 first. Doing this in the code rather
     * than in the ldif file to ensure the attribute can be populated
     * without dependencies on the classpath and or filesystem.
     */
    final Collection<LdapEntry> col = getDirectory().getLdapEntries();
    for (final LdapEntry ldapEntry : col) {
        if (ldapEntry.getDn().equals(DN)) {
            final LdapAttribute attr = new LdapAttribute(true);

            byte[] value = new byte[1024];
            IOUtils.read(new ClassPathResource("userCA-valid.crl").getInputStream(), value);
            value = CompressionUtils.encodeBase64ToByteArray(value);
            attr.setName("certificateRevocationList");
            attr.addBinaryValue(value);

            final LDAPConnection serverCon = getDirectory().getConnection();
            final String address = "ldap://" + serverCon.getConnectedAddress() + ':' + serverCon.getConnectedPort();
            final Connection conn = DefaultConnectionFactory.getConnection(address);
            conn.open();
            final ModifyOperation modify = new ModifyOperation(conn);
            modify.execute(new ModifyRequest(ldapEntry.getDn(),
                    new AttributeModification(AttributeModificationType.ADD, attr)));
            conn.close();
            serverCon.close();
            return;
        }
    }
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
public static void bootstrap() throws Exception {
    initDirectoryServer();
    getDirectory().populateEntries(new ClassPathResource("ldif/users-x509.ldif").getInputStream());

    /**
     * Dynamically set the attribute value to the crl content.
     * Encode it as base64 first. Doing this in the code rather
     * than in the ldif file to ensure the attribute can be populated
     * without dependencies on the classpath and or filesystem.
     */
    final Collection<LdapEntry> col = getDirectory().getLdapEntries();
    for (final LdapEntry ldapEntry : col) {
        if (ldapEntry.getDn().equals(DN)) {
            final LdapAttribute attr = new LdapAttribute(true);

            byte[] value = new byte[1024];
            IOUtils.read(new ClassPathResource("userCA-valid.crl").getInputStream(), value);
            value = CompressionUtils.encodeBase64ToByteArray(value);
            attr.setName("certificateRevocationList");
            attr.addBinaryValue(value);

            final LDAPConnection serverCon = getDirectory().getConnection();
            final String address = "ldap://" + serverCon.getConnectedAddress() + ":" + serverCon.getConnectedPort();
            final Connection conn = DefaultConnectionFactory.getConnection(address);
            conn.open();
            final ModifyOperation modify = new ModifyOperation(conn);
            modify.execute(new ModifyRequest(ldapEntry.getDn(),
                    new AttributeModification(AttributeModificationType.ADD, attr)));
            conn.close();
            serverCon.close();
            return;
        }
    }
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
/**
 * New connection factory connection factory.
 *
 * @param l the l
 * @return the connection factory
 */
public static DefaultConnectionFactory newLdaptiveConnectionFactory(final AbstractLdapProperties l) {
    LOGGER.debug("Creating LDAP connection factory for [{}]", l.getLdapUrl());
    final ConnectionConfig cc = newLdaptiveConnectionConfig(l);
    final DefaultConnectionFactory bindCf = new DefaultConnectionFactory(cc);
    if (l.getProviderClass() != null) {
        try {
            final Class clazz = ClassUtils.getClass(l.getProviderClass());
            bindCf.setProvider(Provider.class.cast(clazz.newInstance()));
        } catch (final Exception e) {
            LOGGER.error(e.getMessage(), e);
        }
    }
    return bindCf;
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
private DefaultConnectionFactory defaultConnectionFactory(Provider<?> provider) {
    DefaultConnectionFactory factory = new DefaultConnectionFactory();
    factory.setConnectionConfig(connectionConfig());
    if (provider != null) {
        factory.setProvider(provider);
    }
    return factory;
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
/**
 * New blocking connection pool connection pool.
 *
 * @param l the l
 * @return the connection pool
 */
public static ConnectionPool newLdaptiveBlockingConnectionPool(final AbstractLdapProperties l) {
    final DefaultConnectionFactory bindCf = newLdaptiveConnectionFactory(l);
    final PoolConfig pc = newLdaptivePoolConfig(l);
    final BlockingConnectionPool cp = new BlockingConnectionPool(pc, bindCf);

    cp.setBlockWaitTime(newDuration(l.getBlockWaitTime()));
    cp.setPoolConfig(pc);

    final IdlePruneStrategy strategy = new IdlePruneStrategy();
    strategy.setIdleTime(newDuration(l.getIdleTime()));
    strategy.setPrunePeriod(newDuration(l.getPrunePeriod()));

    cp.setPruneStrategy(strategy);

    switch (l.getValidator().getType().trim().toLowerCase()) {
        case "compare":
            final CompareRequest compareRequest = new CompareRequest();
            compareRequest.setDn(l.getValidator().getDn());
            compareRequest.setAttribute(new LdapAttribute(l.getValidator().getAttributeName(),
                    l.getValidator().getAttributeValues().toArray(new String[]{})));
            compareRequest.setReferralHandler(new SearchReferralHandler());
            cp.setValidator(new CompareValidator(compareRequest));
            break;
        case "none":
            LOGGER.debug("No validator is configured for the LDAP connection pool of [{}]", l.getLdapUrl());
            break;
        case "search":
        default:
            final SearchRequest searchRequest = new SearchRequest();
            searchRequest.setBaseDn(l.getValidator().getBaseDn());
            searchRequest.setSearchFilter(new SearchFilter(l.getValidator().getSearchFilter()));
            searchRequest.setReturnAttributes(ReturnAttributes.NONE.value());
            searchRequest.setSearchScope(l.getValidator().getScope());
            searchRequest.setSizeLimit(1L);
            searchRequest.setReferralHandler(new SearchReferralHandler());
            cp.setValidator(new SearchValidator(searchRequest));
            break;
    }

    cp.setFailFastInitialize(l.isFailFast());

    if (StringUtils.isNotBlank(l.getPoolPassivator())) {
        final AbstractLdapProperties.LdapConnectionPoolPassivator pass =
                AbstractLdapProperties.LdapConnectionPoolPassivator.valueOf(l.getPoolPassivator().toUpperCase());
        switch (pass) {
            case CLOSE:
                cp.setPassivator(new ClosePassivator());
                LOGGER.debug("Created [{}] passivator for [{}]", l.getPoolPassivator(), l.getLdapUrl());
                break;
            case BIND:
                if (StringUtils.isNotBlank(l.getBindDn()) && StringUtils.isNoneBlank(l.getBindCredential())) {
                    final BindRequest bindRequest = new BindRequest();
                    bindRequest.setDn(l.getBindDn());
                    bindRequest.setCredential(new Credential(l.getBindCredential()));
                    cp.setPassivator(new BindPassivator(bindRequest));
                    LOGGER.debug("Created [{}] passivator for [{}]", l.getPoolPassivator(), l.getLdapUrl());
                } else {
                    LOGGER.warn("No [{}] passivator could be created for [{}] given bind credentials are not specified",
                            l.getPoolPassivator(), l.getLdapUrl());
                }
                break;
            default:
                break;
        }
    }

    LOGGER.debug("Initializing ldap connection pool for [{}] and bindDn [{}]", l.getLdapUrl(), l.getBindDn());
    cp.initialize();
    return cp;
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
public static Authenticator create() {
    final FormatDnResolver dnResolver = new FormatDnResolver();
    dnResolver.setFormat(LdapServer.CN + "=%s," + LdapServer.BASE_PEOPLE_DN);

    final ConnectionConfig connectionConfig = new ConnectionConfig();
    connectionConfig.setConnectTimeout(500);
    connectionConfig.setResponseTimeout(1000);
    connectionConfig.setLdapUrl("ldap://localhost:" + LdapServer.PORT);

    final DefaultConnectionFactory connectionFactory = new DefaultConnectionFactory();
    connectionFactory.setConnectionConfig(connectionConfig);

    final PoolConfig poolConfig = new PoolConfig();
    poolConfig.setMinPoolSize(1);
    poolConfig.setMaxPoolSize(2);
    poolConfig.setValidateOnCheckOut(true);
    poolConfig.setValidateOnCheckIn(true);
    poolConfig.setValidatePeriodically(false);

    final SearchValidator searchValidator = new SearchValidator();

    final IdlePruneStrategy pruneStrategy = new IdlePruneStrategy();

    final BlockingConnectionPool connectionPool = new BlockingConnectionPool();
    connectionPool.setPoolConfig(poolConfig);
    connectionPool.setBlockWaitTime(1000);
    connectionPool.setValidator(searchValidator);
    connectionPool.setPruneStrategy(pruneStrategy);
    connectionPool.setConnectionFactory(connectionFactory);
    connectionPool.initialize();

    final PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory();
    pooledConnectionFactory.setConnectionPool(connectionPool);

    final PooledBindAuthenticationHandler handler = new PooledBindAuthenticationHandler();
    handler.setConnectionFactory(pooledConnectionFactory);

    final Authenticator authenticator = new Authenticator();
    authenticator.setDnResolver(dnResolver);
    authenticator.setAuthenticationHandler(handler);
    return authenticator;
}
 

import org.ldaptive.DefaultConnectionFactory; //导入依赖的package包/类
/**
 * Prepare a new LDAP connection.
 *
 * @param ldapURL the ldap uRL
 * @return connection factory
 */
protected ConnectionFactory prepareConnectionFactory(final String ldapURL) {
    final ConnectionConfig cc = ConnectionConfig.newConnectionConfig(this.connectionConfig);
    cc.setLdapUrl(ldapURL);
    return new DefaultConnectionFactory(cc);
}