import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
/**
 * Creates LDAP User search
 * @param properties Properties POJO
 * @return LDAP User search
 */
public static LdapUserSearch createUserSearch(LdapProperties properties, LdapContextSource source) {
    UserProperties userProperties = properties.getUser();

    switch (userProperties.getType()) {
        case kerberos:
            return ldapKerberosUserSearch(userProperties, source);
        case filter:
            return ldapFilteredUserSearch(userProperties, source);
        case dn:
            return ldapFullDnUserSearch(source);
        default:
            log.warn("Failed to create LDAP User search with type {}.", userProperties.getType());
            return null;
    }
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
private static LdapUserSearch ldapKerberosUserSearch(UserProperties properties, LdapContextSource source) {
    KerberosFilterBasedLdapUserSearch search = new KerberosFilterBasedLdapUserSearch(
            properties.getFilter(), source
    );

    search.setSearchScope(SearchControls.SUBTREE_SCOPE);
    return search;
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的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.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
private LdapUserSearch createUserSearch() {
    if (userSearchFilter == null) {
        return null;
    }
    return new FilterBasedLdapUserSearch(userSearchBase, userSearchFilter,
            contextSource);
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
/**
 * Default constructor.
 * @param ldapSettings LDAP config map for an app
 */
public LDAPAuthenticator(Map<String, String> ldapSettings) {
	if (ldapSettings != null && ldapSettings.containsKey("security.ldap.server_url")) {
		String serverUrl = ldapSettings.get("security.ldap.server_url");
		String baseDN = ldapSettings.get("security.ldap.base_dn");
		String bindDN = ldapSettings.get("security.ldap.bind_dn");
		String basePass = ldapSettings.get("security.ldap.bind_pass");
		String searchBase = ldapSettings.get("security.ldap.user_search_base");
		String searchFilter = ldapSettings.get("security.ldap.user_search_filter");
		String dnPattern = ldapSettings.get("security.ldap.user_dn_pattern");
		String passAttribute = ldapSettings.get("security.ldap.password_attribute");
		boolean usePasswordComparison = ldapSettings.containsKey("security.ldap.compare_passwords");

		DefaultSpringSecurityContextSource contextSource =
				new DefaultSpringSecurityContextSource(Arrays.asList(serverUrl), baseDN);
		contextSource.setAuthenticationSource(new SpringSecurityAuthenticationSource());
		contextSource.setCacheEnvironmentProperties(false);
		if (!bindDN.isEmpty()) {
			contextSource.setUserDn(bindDN);
		}
		if (!basePass.isEmpty()) {
			contextSource.setPassword(basePass);
		}
		LdapUserSearch userSearch = new FilterBasedLdapUserSearch(searchBase, searchFilter, contextSource);

		if (usePasswordComparison) {
			PasswordComparisonAuthenticator p = new PasswordComparisonAuthenticator(contextSource);
			p.setPasswordAttributeName(passAttribute);
			p.setPasswordEncoder(new LdapShaPasswordEncoder());
			p.setUserDnPatterns(new String[]{dnPattern});
			p.setUserSearch(userSearch);
			authenticator = p;
		} else {
			BindAuthenticator b = new BindAuthenticator(contextSource);
			b.setUserDnPatterns(new String[]{dnPattern});
			b.setUserSearch(userSearch);
			authenticator = b;
		}
	}
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
private static LdapUserSearch ldapFilteredUserSearch(UserProperties properties, LdapContextSource source) {
    return new FilterBasedLdapUserSearch(
            properties.getSearchBase(), properties.getFilter(), source
    );
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
private static LdapUserSearch ldapFullDnUserSearch(LdapContextSource source) {
    LdapFullDnSearch search = new LdapFullDnSearch(source);
    search.setSearchScope(SearchControls.OBJECT_SCOPE);
    return search;
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
@ConditionalOnProperty(prefix = "security.ldap.user", name = "type")
@Bean
public LdapUserSearch userSearch() {
    return LdapFactory.createUserSearch(properties, contextSource());
}
 

import org.springframework.security.ldap.search.LdapUserSearch; //导入依赖的package包/类
@Bean
public LdapUserSearch userSearch() {
    return new FilterBasedLdapUserSearch(
            configuration.getUserSearchBase(), configuration.getUserSearchFilter(),
            contextSource());
}