Java DAO classes for many-to-one relationship

Question

I have a problem regarding how to save the objects in the Database in Java when having many-to-one relationship.

Basically I have 2 classes - UserVO and GroupVO, that look like this:

public class UserVO extends ValueObject implements Serializable {

    /**
     * The default serial version ID
     */ 
    private static final long serialVersionUID = 1L;

    private String  login;
    private String  password;
    private Long    groupId;

    public UserVO() {
        super();

        this.setLogin("");
        this.setPassword("");
        this.setGroupId(0L);
    }

        // all the getters and setters
        // ...
}

and

public final class GroupVO extends ValueObject implements Serializable {

    /**
     * The default serial version ID
     */ 
    private static final long serialVersionUID = 1L;

    private String      description;    
    private Set<UserVO> users = new HashSet<UserVO>();

    public GroupVO() {
        super();

        this.setDescription("");
    }

        // all the getters and setters
        // ...
}

Their super-class is a very simple abstract class:

public abstract class ValueObject {

    private Long    id;
    private String  name;

    public ValueObject() {
        super();

        // the ID is auto-generated
//      this.setId(0L);
        this.setName("");
    }

        // all the getters and setters
        // ...
}

Now I have to create the DAO classes for them. In the UserDAO I something like this for creating and inserting a user in the DB:

@Override
    public Long create(UserVO user) throws IllegalArgumentException, DAOException {
        if (user.getId() != null) {
            throw new IllegalArgumentException("User may already be created, the user ID is not null.");
        }

        Object[] values = { user.getName(), user.getLogin(), user.getPassword(), user.getGroupId() };

        Connection          connection          = null;
        PreparedStatement   preparedStatement   = null;
        ResultSet           generatedKeys       = null;

        try {
            connection = daoFactory.getConnection();
            preparedStatement = DAOUtil.prepareStatement(connection, SQL_CREATE_USER, true, values);

            int affectedRows = preparedStatement.executeUpdate();

            if (affectedRows == 0) {
                throw new DAOException("Creating user failed, no rows affected.");
            }

            generatedKeys = preparedStatement.getGeneratedKeys();

            if (generatedKeys.next()) {
                user.setId(generatedKeys.getLong(1));
            } else {
                throw new DAOException("Creating user failed, no generated key obtained.");
            }
        } catch (SQLException e) {
            throw new DAOException(e);
        } finally {
            DAOUtil.close(connection, preparedStatement, generatedKeys);
        }

        return user.getId();
    }

There are also some helper Classes, but I guess you understand my code :).

And this is the GroupDAO create method:

@Override
    public Long create(GroupVO group) throws IllegalArgumentException, DAOException {
        if (group.getId() != null) {
            throw new IllegalArgumentException("Group may already be created, the group ID is not null.");
        }

        Object[] values = { group.getName(), group.getDescription() };

        Connection          connection          = null;
        PreparedStatement   preparedStatement   = null;
        ResultSet           generatedKeys       = null;

        try {
            connection = daoFactory.getConnection();
            preparedStatement = DAOUtil.prepareStatement(connection, SQL_CREATE_GROUP, true, values);

            int affectedRows = preparedStatement.executeUpdate();

            if (affectedRows == 0) {
                throw new DAOException("Creating group failed, no rows affected.");
            }

            generatedKeys = preparedStatement.getGeneratedKeys();

            if (generatedKeys.next()) {
                group.setId(generatedKeys.getLong(1));
            } else {
                throw new DAOException("Creating group failed, no generated key obtained.");
            }

        } catch (SQLException e) {
            throw new DAOException(e);
        } finally {
            DAOUtil.close(connection, preparedStatement, generatedKeys);
        }

        return group.getId();
    }

Now, if I make a small test in the main function, for creating a group and saving in the DB, everything goes well:

DAOFactory usersGroupsRolesFactory = DAOFactory.getInstance("UsersGroupsRolesDB.jdbc");
System.out.println("DAOFactory successfully obtained: " + usersGroupsRolesFactory);

// Create an instance of the GroupDAO class
GroupDAO dao = usersGroupsRolesFactory.getGroupDAO();

// Create some GroupVO objects
GroupVO group1 = new GroupVO();
group1.setName("Administrators");
group1.setDescription("These users have all the right in the application");

dao.create(group1);

As GroupVO class has a set of UserVO objects, and in the main function if I also type:

UserVO user1 = new UserVO();
user1.setName("Palancica Pavel");
user1.setLogin("login_pavel");
user1.setPassword("password_pavel");

group1.getUsers().add(user1); // I may also add some more users

and say I am first time calling: dao.create(group1);

Normally, this shouldn't only save the Group info, but also all the associated UserVO objects.

For me that means that in the "create" function of the GroupDAO, after the group ID is successfully generated, I need to do a lot of other code.

I wonder is this is the correct way of saving those users in the DB, as I think I have to make the GroupDAO class to communicate with the UserDAO class, and also with the DAOFactory, which in my case, can give us an UserDAO, or GroupDAO object. Or I can do all the DB interection for saving those users without using the UserDAO class.

That code that I'm thinking seem very long, messy/spaghetti, and I am not quite sure if this is the correct approach :(.

Note that I am note using any ORM Framework.

Please let me know guys, what do you think about that?! If you need more details, I can send you my Project, it's not commercial :D

Thanks in advance

Answer 1

I would use a GroupDAO to only create the group, a UserDAO to only create a user, and a functional service delegating to these two DAOs to create a group with all its users. Its code would look like the following:

Long groupId = groupDao.createGroup(groupVO);
for (UserVO userVO : groupVO.getUsers()) {
    userDao.createUser(userVO, groupId);
}