See: Description
| Interface | Description |
|---|---|
| AsyncCompareResultListener |
This interface provides a mechanism for notifying a client when the result
for an asynchronous compare operation has been received.
|
| AsyncResultListener |
This interface provides a mechanism for notifying a client when the result
for an asynchronous operation has been received.
|
| AsyncSearchResultListener |
This interface provides a mechanism for notifying a client when the search
result done message for an asynchronous search operation has been received.
|
| DecodeableControl |
This interface defines a method that may be implemented by controls that may
be included in the response from a directory server.
|
| DisconnectHandler |
This interface defines an API that may be implemented by a class that should
be notified whenever an LDAP connection is closed for any reason.
|
| FullLDAPInterface |
This interface defines a set of methods that are available for objects that
may be used to communicate with an LDAP directory server (or something that
simulates an LDAP directory server).
|
| IntermediateResponseListener |
This interface defines a method that may be used to process intermediate
response messages that are returned to the client while processing an
operation.
|
| LDAPConnectionInfo |
This interface defines a number of methods that may be used to obtain
information about an LDAP connection.
|
| LDAPInterface |
This interface defines a set of methods that are available for objects that
may be used to communicate with an LDAP directory server.
|
| PostConnectProcessor |
This interface provides the ability to perform custom processing immediately
after creating an LDAP connection for use in a connection pool.
|
| ReadOnlyAddRequest |
This interface defines a set of methods that may be safely called in an LDAP
add request without altering its contents.
|
| ReadOnlyCompareRequest |
This interface defines a set of methods that may be safely called in an LDAP
compare request without altering its contents.
|
| ReadOnlyDeleteRequest |
This interface defines a set of methods that may be safely called in an LDAP
delete request without altering its contents.
|
| ReadOnlyLDAPRequest |
This interface defines a set of methods that may be safely called in an LDAP
request without altering its contents.
|
| ReadOnlyModifyDNRequest |
This interface defines a set of methods that may be safely called in an LDAP
modify DN request without altering its contents.
|
| ReadOnlyModifyRequest |
This interface defines a set of methods that may be safely called in an LDAP
modify request without altering its contents.
|
| ReadOnlySearchRequest |
This interface defines a set of methods that may be safely called in an LDAP
search request without altering its contents.
|
| ReferralConnector |
This interface defines an API that may be used to establish a connection
(and perform authentication if appropriate) to a remote server when following
a referral.
|
| ReusableReferralConnector |
This interface defines an API that may be used to obtain a
FullLDAPInterface (e.g., a connection pool) that may be used for the
purpose of following a referral. |
| SearchResultListener |
This interface defines a set of methods that provide search result entries
and references to a requester as they are returned from the server.
|
| UnsolicitedNotificationHandler |
This interface defines a method that may be invoked if an unsolicited
notification is received from the directory server.
|
| Class | Description |
|---|---|
| AbstractConnectionPool |
This class provides the base class for LDAP connection pool implementations
provided by the LDAP SDK for Java.
|
| AddRequest |
This class implements the processing necessary to perform an LDAPv3 add
operation, which creates a new entry in the directory.
|
| AggregateLDAPConnectionPoolHealthCheck |
This class provides an
LDAPConnectionPoolHealthCheck implementation
that may be used to invoke a series of subordinate health checks and ensure
that all of them consider a connection valid before indicating that the
connection is valid. |
| AggregatePostConnectProcessor |
This class provides an implementation of a post-connect processor that makes
it possible to invoke multiple post-connect processors as a single unit.
|
| ANONYMOUSBindRequest |
This class provides a SASL ANONYMOUS bind request implementation as described
in RFC 4505.
|
| AsyncRequestID |
This class defines an object that provides information about a request that
was initiated asynchronously.
|
| Attribute |
This class provides a data structure for holding information about an LDAP
attribute, which includes an attribute name (which may include a set of
attribute options) and zero or more values.
|
| BasicAsyncCompareResultListener |
This class provides a basic implementation of the
AsyncCompareResultListener interface that will merely set the
result object to a local variable that can be accessed through a getter
method. |
| BasicAsyncResultListener |
This class provides a basic implementation of the
AsyncResultListener
interface that will merely set the result object to a local variable that can
be accessed through a getter method. |
| BasicAsyncSearchResultListener |
This class provides a basic implementation of the
AsyncSearchResultListener interface that will merely set the
result object to a local variable that can be accessed through a getter
method. |
| BindRequest |
This class provides an API that is used to represent an LDAP bind request.
|
| BindResult |
This class provides a data structure for holding information about the result
of processing a bind operation.
|
| CachingNameResolver |
This class provides an implementation of a
NameResolver that will
cache lookups to potentially improve performance and provide a degree of
resiliency against name service outages. |
| ChangeLogEntry |
This class provides a data structure for representing a changelog entry as
described in draft-good-ldap-changelog.
|
| CompactEntry |
This class provides a data structure that represents a compact version of an
entry.
|
| CompareRequest |
This class implements the processing necessary to perform an LDAPv3 compare
operation, which may be used to determine whether a specified entry contains
a given attribute value.
|
| CompareResult |
This class provides a data structure for holding information about the result
of processing a compare operation.
|
| Control |
This class provides a data structure that represents an LDAP control.
|
| CRAMMD5BindRequest |
This class provides a SASL CRAM-MD5 bind request implementation as described
in draft-ietf-sasl-crammd5.
|
| DefaultNameResolver |
This class provides a default implementation of a
NameResolver that
simply uses the JVM-default name resolution functionality. |
| DeleteRequest |
This class implements the processing necessary to perform an LDAPv3 delete
operation, which removes an entry from the directory.
|
| DereferencePolicy |
This class defines a data type for dereference policy values.
|
| DIGESTMD5BindRequest |
This class provides a SASL DIGEST-MD5 bind request implementation as
described in RFC 2831.
|
| DIGESTMD5BindRequestProperties |
This class provides a data structure that may be used to hold a number of
properties that may be used during processing for a SASL DIGEST-MD5 bind
operation.
|
| DN |
This class provides a data structure for holding information about an LDAP
distinguished name (DN).
|
| DNEntrySource |
This class provides an
EntrySource that will retrieve entries
referenced by a provided set of DNs. |
| DNEscapingStrategy |
This class defines a set of properties that can be used to indicate which
types of optional escaping should be performed by the LDAP SDK when
constructing the string representation of DNs and RDNs.
|
| DNSSRVRecordServerSet |
This class provides a server set implementation that can discover information
about available directory servers through DNS SRV records as described in
RFC 2782.
|
| Entry |
This class provides a data structure for holding information about an LDAP
entry.
|
| EntrySorter |
This class provides a mechanism for client-side entry sorting.
|
| EntrySource |
This class defines an API that may be implemented by a class that provides
access to a sequence of entries, one entry at a time (e.g., entries read from
an LDIF file, or returned as part of an LDAP search).
|
| ExtendedRequest |
This class implements the processing necessary to perform an LDAPv3 extended
operation, which provides a way to request actions not included in the core
LDAP protocol.
|
| ExtendedResult |
This class provides a data structure for holding information about the result
of processing an extended operation.
|
| EXTERNALBindRequest |
This class provides a SASL EXTERNAL bind request implementation as described
in RFC 4422.
|
| FailoverServerSet |
This class provides a server set implementation that will attempt to
establish connections to servers in the order they are provided.
|
| FastestConnectServerSet |
This class provides a server set implementation that will attempt to
establish connections to all associated servers in parallel, keeping the one
that was first to be successfully established and closing all others.
|
| FewestConnectionsServerSet |
This class provides a server set implementation that will establish a
connection to the server with the fewest established connections previously
created by the same server set instance.
|
| Filter |
This class provides a data structure that represents an LDAP search filter.
|
| GenericSASLBindRequest |
This class provides a mechanism for performing SASL authentication in a
generic manner.
|
| GetEntryLDAPConnectionPoolHealthCheck |
This class provides an LDAP connection pool health check implementation that
may be used to check the health of the associated server by verifying that a
specified entry can be retrieved in an acceptable period of time.
|
| GSSAPIBindRequest |
This class provides a SASL GSSAPI bind request implementation as described in
RFC 4752.
|
| GSSAPIBindRequestProperties |
This class provides a data structure that may be used to hold a number of
properties that may be used during processing for a SASL GSSAPI bind
operation.
|
| IntermediateResponse |
This class provides a data structure for holding information about an LDAP
intermediate response, which provides the ability for the directory server to
return multiple messages in response to operations that would not otherwise
support it.
|
| JSONLDAPConnectionLogger |
This class provides an implementation of an LDAP connection access logger
that records messages as JSON objects.
|
| JSONLDAPConnectionLoggerProperties |
This class provides a data structure that can be used to define the
properties to use when creating a
JSONLDAPConnectionLogger. |
| LDAPConnection |
This class provides a facility for interacting with an LDAPv3 directory
server.
|
| LDAPConnectionLogger |
This class defines an API that may be used to log operations processed on an
LDAP connection.
|
| LDAPConnectionOptions |
This class provides a data structure that may be used to configure a number
of connection-related properties.
|
| LDAPConnectionPool |
This class provides an implementation of an LDAP connection pool, which is a
structure that can hold multiple connections established to a given server
that can be reused for multiple operations rather than creating and
destroying connections for each operation.
|
| LDAPConnectionPoolHealthCheck |
This class provides an API that may be used to determine whether connections
associated with a connection pool are valid and suitable for use.
|
| LDAPConnectionPoolHealthCheckResult |
This class provides a data structure that holds information about the result
of an LDAP connection pool health check.
|
| LDAPConnectionPoolStatistics |
This class provides a data structure with information about usage of an LDAP
connection pool.
|
| LDAPConnectionStatistics |
This class provides a data structure with information about operations
performed on an associated LDAP connection.
|
| LDAPEntrySource |
This class provides an
EntrySource that will read entries matching a
given set of search criteria from an LDAP directory server. |
| LDAPReadWriteConnectionPool |
This class provides an implementation of a special type of LDAP connection
pool which maintains two separate sets of connections: one for read
operations and the other for write operations.
|
| LDAPRequest |
This class provides a framework that should be extended by all types of LDAP
requests.
|
| LDAPResult |
This class provides a data structure for holding the elements that are common
to most types of LDAP responses.
|
| LDAPThreadLocalConnectionPool |
This class provides an implementation of an LDAP connection pool which
maintains a dedicated connection for each thread using the connection pool.
|
| LDAPURL |
This class provides a data structure for interacting with LDAP URLs.
|
| MaximumIdleDurationLDAPConnectionPoolHealthCheck |
This class provides an implementation of an LDAP connection pool health check
that will cause the associated connection pool to consider a connection
invalid after it has remained idle (as determined using the
LDAPConnection.getLastCommunicationTime() method) for more than a
specified length of time. |
| MockableLDAPConnection |
This class provides an implementation of an
FullLDAPInterface that
provides a basic means of mocking an LDAPConnection (which itself is
not easily mockable because it is final, as a commonly recognized best
practice for APIs). |
| Modification |
This class provides a data structure for holding information about an LDAP
modification, which describes a change to apply to an attribute.
|
| ModificationType |
This class defines a data type for modification type values.
|
| ModifyDNRequest |
This class implements the processing necessary to perform an LDAPv3 modify DN
operation, which can be used to rename and/or move an entry or subtree in the
directory.
|
| ModifyRequest |
This class implements the processing necessary to perform an LDAPv3 modify
operation, which can be used to update an entry in the directory server.
|
| NameResolver |
This class defines an API that the LDAP SDK can use to resolve host names to
IP addresses, and vice versa.
|
| OAUTHBEARERBindRequest |
This class provides an implementation of a SASL bind request that uses the
OAUTHBEARER SASL mechanism described in
RFC 7628 to allow a user
to authenticate with an OAuth 2.0 bearer token.
|
| OAUTHBEARERBindRequestProperties |
This class provides a data structure that may be used to hold a number of
properties used during processing for a OAUTHBEARER SASL bind operation.
|
| OAUTHBEARERBindResult |
This class provides a bind result that can provide access to the details of
a failed OAUTHBEARER SASL bind attempt.
|
| PasswordExpirationLDAPConnectionPoolHealthCheck |
This class provides an
LDAPConnectionPoolHealthCheck implementation
that may be used to output a warning message about a password expiration that
has occurred or is about to occur. |
| PasswordProvider |
This class defines an API that may be used to obtain a clear-text password
that may be used for authentication or other purposes.
|
| PLAINBindRequest |
This class provides a SASL PLAIN bind request implementation as described in
RFC 4616.
|
| PooledReferralConnector |
This class provides an implementation of a reusable referral connector that
maintains pools of connections to each of the servers accessed in the course
of following referrals.
|
| PooledReferralConnectorProperties |
This class defines a set of properties for use when creating a
PooledReferralConnector. |
| PruneUnneededConnectionsLDAPConnectionPoolHealthCheck |
This class provides an implementation of an LDAP connection pool health check
that periodically monitors the number of available connections in the pool.
|
| RDN |
This class provides a data structure for holding information about an LDAP
relative distinguished name (RDN).
|
| RDNNameValuePair |
This class provides a data structure that represents a single name-value pair
that may appear in a relative distinguished name.
|
| ReadFromFilePasswordProvider |
This class provides an implementation of a password provider that will obtain
the password from a specified file.
|
| ReadOnlyEntry |
This class defines an
Entry subclass in which the contents of the
entry cannot be modified. |
| ResultCode |
This class defines a number of constants associated with LDAP result codes.
|
| RetainConnectExceptionReferralConnector |
This class provides an implementation of a referral connector that will
retain the exception encountered on the last attempt to establish a
connection for the purpose of following a referral.
|
| RootDSE |
This class provides a data structure for representing the directory server
root DSE.
|
| RoundRobinDNSServerSet |
This class provides a server set implementation that handles the case in
which a given host name may resolve to multiple IP addresses.
|
| RoundRobinServerSet |
This class provides a server set implementation that will use a round-robin
algorithm to select the server to which the connection should be established.
|
| SASLBindRequest |
This class provides an API that should be used to represent an LDAPv3 SASL
bind request.
|
| SASLClientBindHandler |
This class provides a mechanism for performing a SASL bind operation (or set
of operations) using a Java
SaslClient to perform all of the
SASL-related processing. |
| SCRAMBindRequest | |
| SCRAMSHA1BindRequest |
This class provides an implementation of the SCRAM-SHA-1 SASL mechanism as
described in RFC 5802.
|
| SCRAMSHA256BindRequest |
This class provides an implementation of the SCRAM-SHA-256 SASL mechanism as
described in RFC 7677.
|
| SCRAMSHA512BindRequest |
This class provides an implementation of the SCRAM-SHA-512 SASL mechanism,
which is an SCRAM mechanism that uses a SHA-512 digest algorithm and an
HmacSHA512 MAC algorithm.
|
| SearchRequest |
This class implements the processing necessary to perform an LDAPv3 search
operation, which can be used to retrieve entries that match a given set of
criteria.
|
| SearchResult |
This class provides a data structure for holding information about the result
of processing a search request.
|
| SearchResultEntry |
This class provides a data structure for representing an LDAP search result
entry.
|
| SearchResultReference |
This class provides a data structure for representing an LDAP search result
reference.
|
| SearchScope |
This class defines a data type for search scope values.
|
| ServerSet |
This class defines an API that can be used to select between multiple
directory servers when establishing a connection.
|
| ServerSetBlacklistManager |
This class provides a mechanism for maintaining a blacklist of servers that
have recently been found to be unacceptable for use by a server set.
|
| SimpleBindRequest |
This class implements the processing necessary to perform an LDAPv3 simple
bind operation, which authenticates using a bind DN and password.
|
| SingleServerSet |
This class provides a server set implementation that only provides the
ability to connect to a single server.
|
| StartTLSPostConnectProcessor |
This class provides an implementation of a post-connect processor that can
be used to perform StartTLS negotiation on an LDAP connection that is
intended to be used in a connection pool.
|
| UpdatableLDAPRequest |
This class is the superclass of all types of LDAP requests that can be
altered.
|
| Version |
This class provides information about the current version of the UnboundID
LDAP SDK for Java.
|
| Enum | Description |
|---|---|
| ChangeType |
This enum defines a set of change types that are associated with operations
that may be processed in an LDAP directory server.
|
| DisconnectType |
This enum defines a set of disconnect types that may be used to provide
general information about the reason that an
LDAPConnection was
disconnected. |
| GSSAPIChannelBindingType |
This enum defines the types of channel binding that may be used in
conjunction with the GSSAPI SASL mechanism.
|
| OperationType |
This enum defines the set of LDAP operation types.
|
| PooledReferralConnectorLDAPURLSecurityType |
This enum defines the type of communication security that the
PooledReferralConnector will use when following LDAP URLs that have
a scheme of "ldap" rather than "ldaps". |
| RoundRobinDNSServerSet.AddressSelectionMode |
An enum that defines the modes that may be used to select the order in
which addresses should be used in attempts to establish connections.
|
| SASLQualityOfProtection |
This enum defines the set of supported SASL quality of protection values.
|
| Exception | Description |
|---|---|
| EntrySourceException |
This class defines an exception that may be thrown if a problem occurs while
trying to access an entry in an entry source (e.g., because the entry source
is no longer available, because an entry could not be parsed, or because the
next element returned was a search result reference rather than a search
result entry).
|
| LDAPBindException |
This class defines an exception that can be thrown if the server sends a bind
response with a result code other than
ResultCode.SUCCESS, which
indicates that the bind operation did not complete successfully. |
| LDAPException |
This class defines an exception that can be thrown if a problem occurs while
performing LDAP-related processing.
|
| LDAPExtendedOperationException |
This class defines an exception that can be thrown if the server returns an
extended response that indicates that the operation did not complete
successfully.
|
| LDAPRuntimeException |
This class defines a version of the
LDAPException class that may be
thrown as a RuntimeException without the need for it to have been
explicitly declared in the method's throws list. |
| LDAPSearchException |
This class defines an exception that can be thrown if a problem occurs while
performing LDAP-related processing.
|
| SASLBindInProgressException |
This class defines an exception that can be thrown if the server sends a bind
response with a result code of
ResultCode.SASL_BIND_IN_PROGRESS,
which indicates that SASL bind processing has not yet completed. |
| SearchResultReferenceEntrySourceException |
This class defines an exception that may be thrown if a search result
reference is received from the directory server while using the
EntrySource API (e.g., an LDAPEntrySource object). |
LDAPConnection and LDAPConnectionPool
classes provide the primary means for interacting with directory servers, and
both implement the LDAPInterface interface which can be used to allow
connections and connection pools to be used interchangeably for most types of
operations. Other classes in this package provide data structures to assist
in LDAP communication. Most request types are mutable, so that they can be
altered and re-used.