import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
private LdapAuthenticationProvider build() throws Exception {
    BaseLdapPathContextSource contextSource = getContextSource();
    LdapAuthenticator ldapAuthenticator = createLdapAuthenticator(contextSource);

    LdapAuthoritiesPopulator authoritiesPopulator = getLdapAuthoritiesPopulator();

    LdapAuthenticationProvider ldapAuthenticationProvider = new LdapAuthenticationProviderProxy(
            ldapAuthenticator, authoritiesPopulator);
    SimpleAuthorityMapper simpleAuthorityMapper = new SimpleAuthorityMapper();
    simpleAuthorityMapper.setPrefix(rolePrefix);
    simpleAuthorityMapper.afterPropertiesSet();
    ldapAuthenticationProvider.setAuthoritiesMapper(simpleAuthorityMapper);
    if (userDetailsContextMapper != null) {
        ldapAuthenticationProvider
                .setUserDetailsContextMapper(userDetailsContextMapper);
    }
    return ldapAuthenticationProvider;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
/**
 * Creates the {@link LdapAuthenticator} to use
 *
 * @param contextSource the {@link BaseLdapPathContextSource} to use
 * @return the {@link LdapAuthenticator} to use
 */
private LdapAuthenticator createLdapAuthenticator(
        BaseLdapPathContextSource contextSource) {
    AbstractLdapAuthenticator ldapAuthenticator = passwordEncoder == null ? createBindAuthenticator(contextSource)
            : createPasswordCompareAuthenticator(contextSource);
    LdapUserSearch userSearch = createUserSearch();
    if (userSearch != null) {
        ldapAuthenticator.setUserSearch(userSearch);
    }
    if (userDnPatterns != null && userDnPatterns.length > 0) {
        ldapAuthenticator.setUserDnPatterns(userDnPatterns);
    }
    return postProcess(ldapAuthenticator);
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
/**
 * Creates {@link PasswordComparisonAuthenticator}
 *
 * @param contextSource the {@link BaseLdapPathContextSource} to use
 * @return
 */
private PasswordComparisonAuthenticator createPasswordCompareAuthenticator(
        BaseLdapPathContextSource contextSource) {
    PasswordComparisonAuthenticator ldapAuthenticator = new PasswordComparisonAuthenticator(
            contextSource);
    if (passwordAttribute != null) {
        ldapAuthenticator.setPasswordAttributeName(passwordAttribute);
    }
    ldapAuthenticator.setPasswordEncoder(passwordEncoder);
    return ldapAuthenticator;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
@Override
public List<FilterBasedLdapUserSearch> getLdapUserSearches(ContextSource ctx, LdapSetting settings) {
    SearchPattern searchPattern = settings.getSearch();
    String searchBase = searchPattern.getSearchBase();
    if (searchBase == null) {
        searchBase = "";
    }
    ArrayList<FilterBasedLdapUserSearch> result = new ArrayList<>();
    FilterBasedLdapUserSearch userSearch = new FilterBasedLdapUserSearch(searchBase,
            searchPattern.getSearchFilter(), (BaseLdapPathContextSource) ctx);
    userSearch.setSearchSubtree(searchPattern.isSearchSubTree());
    result.add(userSearch);
    return result;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public LdapFullDnSearch(BaseLdapPathContextSource contextSource) {
    super(null, contextSource);
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public UasLdapUserSearch(String searchFilter, BaseLdapPathContextSource contextSource) {
    notNull(contextSource, () -> new BadArgument("contextSource must not be null"));

    this.searchFilter = searchFilter;
    this.contextSource = contextSource;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public KerberosFilterBasedLdapUserSearch(String searchFilter, BaseLdapPathContextSource contextSource) {
    super(searchFilter, contextSource);
    notNull(searchFilter, () -> new BadArgument("searchFilter must not be null."));
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public SemossBindAuthenticator( BaseLdapPathContextSource contextSource ) {
	super( contextSource );
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public DhisBindAuthenticator( BaseLdapPathContextSource contextSource )
{
    super( contextSource );
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
@Bean
public BaseLdapPathContextSource contextSource() {
    return new DefaultSpringSecurityContextSource(url);
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
private BaseLdapPathContextSource getContextSource() throws Exception {
    if (contextSource == null) {
        contextSource = contextSourceBuilder.build();
    }
    return contextSource;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
@Bean
public BaseLdapPathContextSource contextSource() {
    return new DefaultSpringSecurityContextSource(serverUrl);
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public AmbariLdapBindAuthenticator(BaseLdapPathContextSource contextSource,
                                   Configuration configuration) {
  super(contextSource);
  this.configuration = configuration;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public SimpleBindAunthenticator(BaseLdapPathContextSource contextSource, String gizmoGroup) {
    super(contextSource);
    this.gizmoGroup = gizmoGroup;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
@Override
public DirContextOperations authenticate(Authentication authentication) {
    DirContextOperations user = null;
    Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
            "Can only process UsernamePasswordAuthenticationToken objects");

    String username = authentication.getName();
    String password = (String) authentication.getCredentials();

    if (StringUtils.isEmpty(password)) {
        LOG.debug("Rejecting empty password for user " + username);
        throw new BadCredentialsException(messages.getMessage("BindAuthenticator.emptyPassword",
                "Empty Password"));
    }

    // If DN patterns are configured, try authenticating with them directly
    for (String dn : getUserDns(username)) {
        user = bindWithDn(dn, username, password);

        if (user != null) {
            break;
        }
    }

    // Otherwise use the configured search object to find the user and authenticate with the returned DN.
    if (user == null && getUserSearch() != null) {
        DirContextOperations userFromSearch = getUserSearch().searchForUser(username);
        user = bindWithDn(userFromSearch.getDn().toString(), username, password);
    }

    try {
        if (user != null && StringUtils.isNotEmpty(gizmoGroup)) {
            BaseLdapPathContextSource ctxSource = (BaseLdapPathContextSource) getContextSource();
            DirContext ctx = ctxSource.getReadOnlyContext();

            DistinguishedName userDn = new DistinguishedName(user.getDn());
            userDn.prepend(ctxSource.getBaseLdapPath());

            SearchControls controls = new SearchControls();
            controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
            String filter = String.format(GROUP_SEARCH_QUERY, gizmoGroup, userDn.toCompactString());
            NamingEnumeration en = ctx.search("", filter, controls);
            if (!en.hasMore()) {
                throw new BadCredentialsException(
                        messages.getMessage("BindAuthenticator.badCredentials", "Bad credentials"));
            }
        }
    } catch (javax.naming.NamingException ex) {
        throw new BadCredentialsException("Couldn't check group membership");
    }

    if (user == null) {
        throw new BadCredentialsException(
                messages.getMessage("BindAuthenticator.badCredentials", "Bad credentials"));
    }

    return user;
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
public LdapUserManager(BaseLdapPathContextSource contextSource) {
	this.contextSource = contextSource;
	users = new FilterBasedLdapUserSearch("", Constants.LDAP_USER_SEARCH_FILTER, contextSource);
	
}
 

import org.springframework.ldap.core.support.BaseLdapPathContextSource; //导入依赖的package包/类
/**
 * Creates a {@link BindAuthenticator}
 *
 * @param contextSource the {@link BaseLdapPathContextSource} to use
 * @return the {@link BindAuthenticator} to use
 */
private BindAuthenticator createBindAuthenticator(
        BaseLdapPathContextSource contextSource) {
    return new BindAuthenticator(contextSource);
}