UnboundID LDAP SDK for Java

import com.unboundid.ldap.sdk.LDAPConnection;
import com.unboundid.ldap.sdk.LDAPConnectionPool;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.Attribute;
import com.unboundid.ldap.sdk.DN;
import com.unboundid.ldap.sdk.Filter;
import com.unboundid.ldap.sdk.SearchRequest;
import com.unboundid.ldap.sdk.SearchResult;
import com.unboundid.ldap.sdk.SearchResultEntry;

import com.unboundid.ldap.sdk.*;

// Establish connection
LDAPConnection connection = new LDAPConnection("ldap.example.com", 389);

try {
    // Bind (authenticate)
    connection.bind("cn=admin,dc=example,dc=com", "password");
    
    // Search for entries
    SearchResult searchResult = connection.search(
        "dc=example,dc=com",           // base DN
        SearchScope.SUB,               // scope
        "(objectClass=person)",        // filter
        "cn", "mail"                   // attributes to return
    );
    
    // Process results
    for (SearchResultEntry entry : searchResult.getSearchEntries()) {
        System.out.println("DN: " + entry.getDN());
        System.out.println("CN: " + entry.getAttributeValue("cn"));
        System.out.println("Mail: " + entry.getAttributeValue("mail"));
    }
    
    // Add new entry
    Entry newEntry = new Entry(
        "cn=John Doe,ou=people,dc=example,dc=com",
        new Attribute("objectClass", "inetOrgPerson"),
        new Attribute("cn", "John Doe"),
        new Attribute("sn", "Doe"),
        new Attribute("mail", "john.doe@example.com")
    );
    connection.add(newEntry);
    
} finally {
    connection.close();
}

// Primary connection class
public final class LDAPConnection implements FullLDAPInterface, LDAPConnectionInfo, ReferralConnector, Closeable {
    public LDAPConnection(String host, int port) throws LDAPException;
    public LDAPResult bind(String bindDN, String password) throws LDAPException;
    public LDAPResult add(Entry entry) throws LDAPException;
    public SearchResult search(String baseDN, SearchScope scope, String filter, String... attributes) throws LDAPException;
    public LDAPResult modify(String dn, Modification... modifications) throws LDAPException;
    public LDAPResult delete(String dn) throws LDAPException;
    public void close();
}

// Connection pooling for high-performance applications
public final class LDAPConnectionPool extends AbstractConnectionPool {
    public LDAPConnectionPool(LDAPConnection connection, int initialConnections, int maxConnections) throws LDAPException;
    public LDAPConnectionPoolStatistics getConnectionPoolStatistics();
    public void close();
}

// Simple authentication
public class SimpleBindRequest extends BindRequest {
    public SimpleBindRequest(String bindDN, String password);
}

// SASL authentication mechanisms
public abstract class SASLBindRequest extends BindRequest {
    // Base class for SASL mechanisms
}

public class CRAMMD5BindRequest extends SASLBindRequest {
    public CRAMMD5BindRequest(String authenticationID, String password);
}

public class GSSAPIBindRequest extends SASLBindRequest {
    public GSSAPIBindRequest(String authenticationID, String authorizationID);
}

// LDAP entry representation
public class Entry {
    public Entry(String dn, Attribute... attributes);
    public Entry(DN dn, Collection<Attribute> attributes);
    public String getDN();
    public Attribute getAttribute(String name);
    public String getAttributeValue(String name);
    public Collection<Attribute> getAttributes();
}

// LDAP attribute with values
public class Attribute {
    public Attribute(String name, String... values);
    public Attribute(String name, byte[]... values);
    public String getName();
    public String[] getValues();
    public byte[][] getValueByteArrays();
}

// Distinguished Name parsing and manipulation
public class DN {
    public DN(String dnString) throws LDAPException;
    public RDN[] getRDNs();
    public DN getParent();
    public boolean isAncestorOf(DN dn, boolean strict);
}

// Search request construction
public class SearchRequest extends UpdatableLDAPRequest {
    public SearchRequest(String baseDN, SearchScope scope, String filter, String... attributes);
    public SearchRequest(String baseDN, SearchScope scope, Filter filter, String... attributes);
    public void setControls(Control... controls);
    public void setSizeLimit(int sizeLimit);
    public void setTimeLimit(int timeLimitSeconds);
}

// LDAP filter construction and parsing
public class Filter {
    public static Filter createEqualityFilter(String attributeName, String assertionValue);
    public static Filter createSubstringFilter(String attributeName, String subInitial, String[] subAny, String subFinal);
    public static Filter createANDFilter(Filter... filters);
    public static Filter createORFilter(Filter... filters);
    public static Filter create(String filterString) throws LDAPException;
}

// Complete schema representation
public class Schema {
    public static Schema getSchema(LDAPConnection connection) throws LDAPException;
    public static Schema getSchema(LDAPConnection connection, String subschemaSubentryDN) throws LDAPException;
    public Set<AttributeTypeDefinition> getAttributeTypes();
    public Set<ObjectClassDefinition> getObjectClasses();
    public EntryValidator getEntryValidator();
}

// Schema validation
public class EntryValidator {
    public List<String> validateEntry(Entry entry);
    public List<String> validateEntry(Entry entry, boolean checkMissingAttributes);
}

// Main persister class
public class LDAPPersister<T> {
    public LDAPPersister(Class<T> type, LDAPInterface ldapInterface) throws LDAPPersistException;
    public T get(String dn) throws LDAPPersistException;
    public PersistedObjects<T> search(String baseDN, SearchScope scope, Filter filter) throws LDAPPersistException;
    public void add(T object) throws LDAPPersistException;
    public void modify(T object) throws LDAPPersistException;
    public void delete(T object) throws LDAPPersistException;
}

// Key annotations for object mapping
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface LDAPObject {
    String[] objectClass();
    String structuralClass() default "";
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface LDAPField {
    String attribute() default "";
    boolean inRDN() default false;
}

// LDIF reading capabilities
public class LDIFReader implements Closeable {
    public LDIFReader(String filePath) throws IOException;
    public LDIFReader(InputStream inputStream);
    public LDIFRecord readLDIFRecord() throws IOException, LDIFException;
    public Entry readEntry() throws IOException, LDIFException;
    public LDIFChangeRecord readChangeRecord() throws IOException, LDIFException;
}

// LDIF writing capabilities  
public class LDIFWriter implements Closeable {
    public LDIFWriter(String filePath) throws IOException;
    public LDIFWriter(OutputStream outputStream);
    public void writeEntry(Entry entry) throws IOException;
    public void writeChangeRecord(LDIFChangeRecord changeRecord) throws IOException;
}

// Standard LDAP controls
public class PagedResultsRequestControl extends Control {
    public PagedResultsRequestControl(int pageSize, ASN1OctetString cookie);
}

public class ServerSideSortRequestControl extends Control {
    public ServerSideSortRequestControl(SortKey... sortKeys);
}

// Extended operations
public class PasswordModifyExtendedRequest extends ExtendedRequest {
    public PasswordModifyExtendedRequest(String userIdentity, String oldPassword, String newPassword);
}

public class WhoAmIExtendedRequest extends ExtendedRequest {
    public WhoAmIExtendedRequest();
}

// Create connection pool for high-performance applications
LDAPConnection connection = new LDAPConnection("ldap.example.com", 389);
connection.bind("cn=admin,dc=example,dc=com", "password");

LDAPConnectionPool pool = new LDAPConnectionPool(connection, 10, 20);
// Use pool for operations
// pool automatically manages connections
pool.close();

try {
    LDAPResult result = connection.add(entry);
    if (result.getResultCode() == ResultCode.SUCCESS) {
        System.out.println("Entry added successfully");
    }
} catch (LDAPException e) {
    System.err.println("LDAP operation failed: " + e.getMessage());
    System.err.println("Result code: " + e.getResultCode());
}

// Asynchronous search
AsyncRequestID requestID = connection.asyncSearch(
    searchRequest,
    new AsyncSearchResultListener() {
        public void searchEntryReturned(SearchResultEntry entry) {
            // Process each entry as it arrives
        }
        public void searchResultReceived(AsyncRequestID requestID, SearchResult result) {
            // Handle final result
        }
    }
);