Java SearchResult类代码示例

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private Set<String> rolesFromDN(String userDN) throws LDAPException, GeneralSecurityException {
  SearchRequest searchRequest = new SearchRequest(config.getRoleBaseDN(),
      SearchScope.SUB, Filter.createEqualityFilter("uniqueMember", userDN));
  Set<String> roles = Sets.newLinkedHashSet();

  LDAPConnection connection = connectionFactory.getLDAPConnection();
  try {
    SearchResult sr = connection.search(searchRequest);

    for (SearchResultEntry sre : sr.getSearchEntries()) {
      X500Name x500Name = new X500Name(sre.getDN());
      RDN[] rdns = x500Name.getRDNs(BCStyle.CN);
      if (rdns.length == 0) {
        logger.error("Could not create X500 Name for role:" + sre.getDN());
      } else {
        String commonName = IETFUtils.valueToString(rdns[0].getFirst().getValue());
        roles.add(commonName);
      }
    }
  } finally {
    connection.close();
  }

  return roles;
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private SearchResultEntry getEntryByMail(String mail) {
  try {
    for (String ou : allOUs()) {
      String dn = ldapUserBaseDN.replace("{}", ou);
      SearchRequest ldapRequest = new SearchRequest(dn, SearchScope.SUB, "(mail=" + mail + ")");
      SearchResult ldapResult = ldapConnection.search(ldapRequest);

      if (ldapResult.getEntryCount() > 0) {
        return ldapResult.getSearchEntries().get(0);
      }
    }

    return null;
  } catch (LDAPException e) {
    return null;
  }
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private SearchResultEntry getEntryById(String id) {
  try {
    for (String ou : allOUs()) {
      String dn = ldapUserBaseDN.replace("{}", ou);
      SearchRequest ldapRequest = new SearchRequest(dn, SearchScope.SUB, "(uid=" + id + ")");
      SearchResult ldapResult = ldapConnection.search(ldapRequest);

      if (ldapResult.getEntryCount() > 0) {
        return ldapResult.getSearchEntries().get(0);
      }
    }
    return null;
  } catch (LDAPException e) {
    return null;
  }
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private List<LoadBalancingAlgorithmStatus> getLoadBalancingAlgorithmStatuses()
        throws LDAPException
{
  List<LoadBalancingAlgorithmStatus> lbaStatuses = new ArrayList<>();
  SearchResult result =
          findMonitorEntries("ds-load-balancing-algorithm-monitor-entry", "*");
  for (SearchResultEntry entry : result.getSearchEntries())
  {
    lbaStatuses.add(new LoadBalancingAlgorithmStatus(
            entry.getAttributeValue("algorithm-name"),
            parseAvailabilityString(entry.getAttributeValue("health-check-state")),
            entry.getAttributeValueAsInteger("num-available-servers"),
            entry.getAttributeValueAsInteger("num-degraded-servers"),
            entry.getAttributeValueAsInteger("num-unavailable-servers")));
  }
  return lbaStatuses;
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private SearchResult doSearch(LDAPConnection ldapConnection, String base, boolean dereferenceAliases, String filter, List<String> attributes) {
    try {
        SearchRequest searchRequest = new SearchRequest(base, SearchScope.SUB, filter);
        if (dereferenceAliases) {
            searchRequest.setDerefPolicy(DereferencePolicy.SEARCHING);
        }
        if (attributes != null) {
            searchRequest.setAttributes(attributes);
        }
        return ldapConnection.search(searchRequest);

    } catch (LDAPException e) {
        if (!Strings.isNullOrEmpty(e.getDiagnosticMessage())) {
            log.error(e.getDiagnosticMessage());
        } else {
            log.error("Problem searching LDAP", e);
        }
        return null;
    }
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private void setAccountRoles(LDAPConnection ldapConnection, SearchResultEntry accountSearchResult, Account account) {
    String accountDN = accountSearchResult.getDN();

    String groupMemberPattern = this.groupMemberPattern.replace("${dn}", escapeLDAPSearchFilter(accountDN));
    groupMemberPattern = groupMemberPattern.replace("${username}", escapeLDAPSearchFilter(account.getUsername()));

    // Fill in attributes into groupMemberPattern
    for (Attribute attribute : accountSearchResult.getAttributes()) {
        groupMemberPattern = groupMemberPattern.replace("${" + attribute.getName() + "}", escapeLDAPSearchFilter(attribute.getValue()));
    }

    SearchResult groupsSearchResult = doSearch(ldapConnection, groupBase, true, groupMemberPattern, Arrays.asList("cn"));
    if (groupsSearchResult != null && groupsSearchResult.getEntryCount() > 0) {
        for (int i = 0; i < groupsSearchResult.getEntryCount(); i++) {
            SearchResultEntry groupEntry = groupsSearchResult.getSearchEntries().get(i);
            String roleName = groupEntry.getAttribute("cn").getValue();

            account.getAuthorizations().addRole(roleName);
        }
    }
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
@Override
public Set<String> getUserRoles(String username) throws Exception {
    LOGGER.debug("getRoles("+username+")");

    Objects.requireNonNull(username);

    Set<String> roles = new HashSet<>();

    String filter = "(uid=" + username + ")";

    SearchRequest searchRequest = new SearchRequest(searchBase, SearchScope.SUB, filter);
    SearchResult searchResult = connectionPool.search(searchRequest);
    List<SearchResultEntry> searchResultEntries = searchResult.getSearchEntries();

    if(searchResultEntries.isEmpty()) {
        LOGGER.warn("No result found roles for user: " + username);
        return new HashSet<String>();
    } else if (searchResultEntries.size() > 1) {
        LOGGER.error("Multiples users found and only one was expected for user: " + username);
        return new HashSet<String>();
    } else {
        for(SearchResultEntry searchResultEntry : searchResultEntries) {
            String[] groups = searchResultEntry.getAttributeValues("memberOf");
            if(null != groups) {
                for(String group : groups) {
                    for (RDN rdn : new DN(group).getRDNs()) {
                        if (rdn.hasAttribute("cn")) {
                            roles.addAll(Arrays.asList(rdn.getAttributeValues()));
                            break;
                        }
                    }
                }
            }
        }
    }

    return roles;
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private void removeSubtreeThroughIteration(String dn) {
   	SearchResult searchResult = null;
   	try {
   		searchResult = this.ldapOperationService.search(dn, toLdapFilter(Filter.createPresenceFilter("objectClass")), 0, 0, null, "dn");
		if (!ResultCode.SUCCESS.equals(searchResult.getResultCode())) {
			throw new EntryPersistenceException(String.format("Failed to find sub-entries of entry '%s' for removal", dn));
		}
	} catch (SearchException ex) {
           throw new EntryPersistenceException(String.format("Failed to find sub-entries of entry '%s' for removal", dn), ex);
	}

   	List<String> removeEntriesDn = new ArrayList<String>(searchResult.getEntryCount());
   	for (SearchResultEntry searchResultEntry : searchResult.getSearchEntries()) {
   		removeEntriesDn.add(searchResultEntry.getDN());
   	}
   	
   	Collections.sort(removeEntriesDn, LINE_LENGHT_COMPARATOR);

   	for (String removeEntryDn : removeEntriesDn) {
   		remove(removeEntryDn);
   	}
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
@Override
public List<String[]> getLDIF(String dn, String[] attributes) {
	SearchResult searchResult;
	try {
		searchResult = this.ldapOperationService.search(dn, toLdapFilter(Filter.create("objectclass=*")), toLdapSearchScope(SearchScope.BASE), -1, 0, null, attributes);
		if (!ResultCode.SUCCESS.equals(searchResult.getResultCode())) {
			throw new EntryPersistenceException(String.format("Failed to find entries with baseDN: %s", dn));
		}
	} catch (Exception ex) {
		throw new EntryPersistenceException(String.format("Failed to find entries with baseDN: %s, filter: %s", dn, null), ex);
	}

	List<String[]> result = new ArrayList<String[]>();

	if (searchResult.getEntryCount() == 0) {
		return result;
	}

	for (SearchResultEntry searchResultEntry : searchResult.getSearchEntries()) {
		result.add(searchResultEntry.toLDIF());
	}

	return result;
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
@Override
public List<String[]> getLDIFTree(String baseDN, Filter searchFilter, String... attributes) {
	SearchResult searchResult;
	try {
		searchResult = this.ldapOperationService.search(baseDN, toLdapFilter(searchFilter), -1, 0, null, attributes);
		if (!ResultCode.SUCCESS.equals(searchResult.getResultCode())) {
			throw new EntryPersistenceException(String.format("Failed to find entries with baseDN: %s, filter: %s", baseDN, searchFilter));
		}
	} catch (Exception ex) {
		throw new EntryPersistenceException(String.format("Failed to find entries with baseDN: %s, filter: %s", baseDN, searchFilter),
				ex);
	}

	List<String[]> result = new ArrayList<String[]>();

	if (searchResult.getEntryCount() == 0) {
		return result;
	}

	for (SearchResultEntry searchResultEntry : searchResult.getSearchEntries()) {
		result.add(searchResultEntry.toLDIF());
	}

	return result;
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private void runSearch(LDAPConnection connection, SearchRequest searchRequest, CRUDOperationContext ctx, SearchResultProcessor searchRunner) {
    execute(ctx, new ExecutionHandler() {

        @Override
        void onSuccess(LDAPResult searchResult) {
            for (SearchResultEntry entry : ((SearchResult) searchResult).getSearchEntries()) {
                searchRunner.process(entry);
            }
        }

        @Override
        SearchResult execute() throws LDAPException {
            return connection.search(searchRequest);
        }
    });
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
@Override
public List<org.geomajas.security.UserInfo> getUsers(UserFilter userFilter) {
	List<org.geomajas.security.UserInfo> users = new ArrayList<org.geomajas.security.UserInfo>();
	if (allUsersDn == null) {
		log.warn("Getting users from LDAP requires configuration of allUsersDn property");
	} else {
		SearchRequest request = createSearchRequest(allUsersDn);
		LdapFilterVisitor visitor = new LdapFilterVisitor();
		Filter ldapFilter = (Filter) userFilter.accept(visitor, null);
		if (ldapFilter != null) {
			Filter f = request.getFilter();
			request.setFilter(Filter.createANDFilter(f, ldapFilter));
		}
		SearchResult result = execute(request, null, null);
		if (result != null) {
			for (SearchResultEntry entry : result.getSearchEntries()) {
				users.add(getUserInfo(entry));
			}
		}
	}
	return users;
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
@Override
public void search(SearchScope scope, String filter, String[] attributes,
    Handler<AsyncResult<SearchResult>> resultHandler) {
  
  if(attributes == null) attributes = new String[] {};

  try {

    SearchRequest request = new SearchRequest(config.getSearchBase(), scope, filter,
        attributes);
    resultHandler.handle(Future.<SearchResult>succeededFuture(getConnection().search(request)));
  } catch (Throwable t) {

    resultHandler.handle(Future.failedFuture(t));
  }
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private ServerStatus getServerStatus() throws Exception
{
  SearchResult result =
          findMonitorEntries("ds-general-monitor-entry");
  if (result.getEntryCount() != 1)
  {
    throw new Exception(String.format(
            "Expected one and only one general monitor entry; " +
                    "actual number was %d", result.getEntryCount()));
  }
  SearchResultEntry entry = result.getSearchEntries().get(0);
  return new ServerStatus(
          entry.getAttributeValues("unavailable-alert-type"),
          entry.getAttributeValues("degraded-alert-type"));
}
 

import com.unboundid.ldap.sdk.SearchResult; //导入依赖的package包/类
private List<ServletStatus> getServletStatuses() throws Exception
{
  List<String> enabledServlets = new ArrayList<>();
  List<ServletStatus> servletStatuses = new ArrayList<>();
  if (!servletsToCheck.isEmpty())
  {
    SearchResult result =
            findMonitorEntries("ds-http-servlet-config-monitor-entry",
                               "enabled-servlet-and-path");
    if (result.getEntryCount() != 1)
    {
      throw new Exception(String.format(
              "Expected one and only one HTTP servlet config monitor entry; " +
                      "actual number was %d", result.getEntryCount()));
    }
    SearchResultEntry entry = result.getSearchEntries().get(0);
    for (String servletAndPath : entry.getAttributeValues("enabled-servlet-and-path"))
    {
      final String parsedServletName = parseServletName(servletAndPath);
      if (parsedServletName != null)
      {
        enabledServlets.add(parsedServletName);
      }
    }
    for (String servletToCheck : servletsToCheck)
    {
      if (enabledServlets.contains(servletToCheck))
      {
        servletStatuses.add(new ServletStatus(servletToCheck, true));
      }
      else
      {
        servletStatuses.add(new ServletStatus(servletToCheck, false));
      }
    }
  }
  return servletStatuses;
}