Binding a subtree using custom State- and ObjectFactory

Question

Hi,
first of all a very short example to illustrate my idea. I know that it would be complete rubbish to store the kind of data in the example in multiple classes and ldap entries. Currently I'm working with much larger objects that must be written according to special schema definitions. This example is really only for illustration!
LDAP-Schema:
objectclass ( 1.3.6.1.4.1... NAME 'myperson'
              SUP top STRUCTURAL
              MUST ( cn $ sn ) MAY ( email ) )
objectclass ( 1.3.6.1.4.1... NAME 'myphoto'
              SUP top STRUCTURAL
              MUST ( cn $ jpegPhoto ) )
Java-Classes:
class MyPhoto {
    byte[] photo;
class MyPerson {
    String cn;
    String sn;
    String email;
    MyPhoto photo; // This is the really relevant line :)
}Now to the question:
Is it possible to bind multiple java objects with one call to bind and to get a subtree by using custom State- and ObjectFactory-Classes?
Structure of the LDAP-Database
dn: cn=John Doe
{  cn=John Doe
   sn=Doe
   [email protected]   }
dn: cn=TheLogo, cn=John Doe    // Child of cn=John Doe
{ cn=TheLogo              // The cn is the same for all MyPhoto entries
                          // its only use is for building the dn
  jpegPhoto=[some binary data]   }I tried to solve the problem with a kind of recursion. When my StateFactory is called to bind an Object of Class MyPerson it builds the appropriate AttributeList. Before it returns, it calls bind for the Object of class MyPhoto with the dn: "cn=TheLogo,cn=John Doe".
Of course this doesn't work because the entry for cn="John Doe" doesn't exist at this time. Now I don't know what to do. A possible solution would be to create everything by hand, but then I wouldn't have to use custom StateFactories at all. But if there is a simple solution to my problem I would like to use my own StateFactory instead of having to implement a persistance manager on my own.
I hope you understand what I want to do and why it doesn't work out. If you don't please ask and I will try to clarify.

Answer 1

Hello,
A provisional solution is to use an external controller. For this approach to work, each class has to provide the list of objects being part of its properties. I have prepared two interfaces for this purpose:
public interface HasSubordinates {
Enumeration getSubordinates();
boolean hasSubordinates();
public interface Storable extends HasSubordinates {
String getIdentifier();
Then, you can use the controller to recursively get the object "tree" and store it in the directory (either using objects that implement the DirContext interface or using StateFactories - the last one is the one I have used)
The code for the Controller is the following:
import javax.naming.*;
import javax.naming.directory.*;
import javax.naming.spi.*;
import java.util.*;
import java.io.IOException;
public class DatabaseAccessController {
// Constants
final static String ldapServerName = "localhost";
final static String rootdn = "cn=juanluis, o=niaf";
final static String rootpass = "secret";
final static String rootContext = "o=niaf";
private DirContext initialContext;
private static Properties env = new Properties();
static {
env.put( Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory" );
env.put( Context.STATE_FACTORIES, "database.PersonStateFactory:database.AddressStateFactory");
env.put( Context.PROVIDER_URL, "ldap://"+ ldapServerName+"/"+rootContext);
env.put( Context.SECURITY_PRINCIPAL, rootdn );
env.put( Context.SECURITY_CREDENTIALS, rootpass );
public DatabaseAccessController() {
try {
initialContext = new InitialDirContext( env );
} catch( Exception e ) {
e.printStackTrace();
public void store( Storable object ) {   
try {
store( object, initialContext );
} catch( NamingException ne ) {
ne.printStackTrace();
private void store( Storable object, DirContext ctx ) throws NamingException{
DirStateFactory.Result result = DirectoryManager.getStateToBind( object, null, null, env, null );
Attributes attributes = result.getAttributes();
DirContext new_ctx = ctx.createSubcontext( dn(object), attributes );
if( object.hasSubordinates() ) {
Enumeration subordinates = object.getSubordinates();
while( subordinates.hasMoreElements() ) {
try {
store( (Storable)subordinates.nextElement(), new_ctx );
} catch( Exception e ) {
e.printStackTrace();
private String dn( Storable object ) {
return "cn="+object.getIdentifier();
This is an example of how it should work on two objects:
public class Person implements Storable{
String name;
String surname;
Address address;
public Person(String n, String sn, Address addr) {
name = n;
surname = sn;
address = addr;
public boolean hasSubordinates() {
return true;
public Enumeration getSubordinates() {
Hashtable h = new Hashtable();
h.put("address", address );
return h.elements();
public String getIdentifier() {
return name + " "+ surname;
public class Address implements Storable {
String street;
int number;
Attributes attrs;
public Address( String s, int n) {
street = s;
number = n;
public boolean hasSubordinates() {
return false;
public Enumeration getSubordinates() {
return null;
public String getIdentifier() {
return street + number;
And here it is the program that access to the directory:
public class TestLDAP {
public TestLDAP() {
public static void main(String[] args) {
try {
System.out.println("Creating controller...");
DatabaseAccessController controller = new DatabaseAccessController();
System.out.println("Controller created");
Person person = new Person("Juan Luis", "Manas", new Address("Street in Madrid", 33 ));
System.out.println("Storing object in the directory...");
controller.store(person);
System.out.println("object stored successfully!");
} catch( Exception e ) {
e.printStackTrace();
}���
If you find a better way of performing the storage of complex objects in the directory, please, let me know.
Regards,
Juan Luis