Mapping ResultSet to Pojo Objects

Question

Well that's really embarrassing I have made a standard pojo class and its dao class for data retrieval purpose. I am having a difficulty to understand a basic procedure to how to handle a customized query data to Pojo class.

let's say my User class is

public class User{

private int userId;
private String username;
private int addressId;

}

public class Address{
private int addressId;
private String zip;
}
public class UserDAO{

public void getUserDetails(){

String getSql = select u.userId, u.username, a.zipcode from user u, address a where u.addressId =     a.addressId;

 //no pojo class is now specific to the resultset returned. so we can't map result to pojo object
}

}

now how I should model this with my pojo class as if using String to manage this then concept of object oriented vanishes, also complexity would increase in the future as well. kindly guide!

Update for Further Explanation

We know that we can map same table objects with same pojo class, but when the query is customized and there is a data returned which doesn't map to any specific class then what would be the procedure? i.e. should we make another class? or should we throw that data in a String variable? kindly give some example as well.

Answer 1

For this purpose you can use one of implementation of JPA. But as you want to do it manually I will give you small example.

UPD:

public class User {
   private int userId;
   private String username;
   private Address address; // USE POJO not ID
}

public class Address{
   private int addressId;
   private String zip;
   List<User> users;
}
    public User getUserById(Connection con, long userId) {
        PreparedStatement stmt;
        String query = "select u.user_id, u.user_name, a.id, a.zip from user u, address a where a.address_id = u.id and u.id = ?";
        User user = new User();
        Address address = new Address;
        try {
            stmt = con.prepareStatement(query);
            stmt.setLong(1, userId);
            ResultSet rs = stmt.executeQuery();
            address.setId(rs.getInt("id"));
            address.setZip(rs.getString("zip");
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("user_name"));
            user.setAddressId(rs.getInt("address_id"));
            user.setAddress(address); // look here
        } catch (SQLException e) {
            if (con != null) {
                try {
                    System.err.print("Transaction is being rolled back");
                    con.rollback();
                } catch (SQLException excep) {
                }
            }
        } finally {
            if (stmt != null) {
                stmt.close();
            }
        }
        return user;
    }

You shouldn't do new POJO for that query, you should write normal query. And remember - your object model is main, tables in DB is just a way to save data of your application.

Answer 2

We know that we can map same table objects with same pojo class, but when the query is customized and there is a data returned which doesn't map to any specific class then what would be the procedure? i.e. should we make another class?

JPA dynamic instantiation allows you to define a query with a POJO whose constructor specifies only the fields and types you want from the database.

This will perform a JPA selection which will return a List.
If you need to change the query later and the columns are unchanged, your POJO will still work.
If you change the columns, then also change the POJO accordingly.

NOTE:

You must specify fully qualified package and constructor arguments.

Type User must be a JPA-mapped or JPA-annotated entity class.

The entityManager is in JPA EntityManagerFactory.

TypedQuery<User> q; 
String sql = "select new com.stuff.User(
int u.userId, String u.username, String a.zipcode) 
from User u, Address a where u.addressId = a.addressId";
List<User> list = entityManager.createQuery(sql).getResultList();

for(User u : list) {
  doStuff(u);
}

Dynamic instantiation is also handy when you want to select specified columns, but avoid those columns with large data, such as BLOB types.
For example, maybe you want a list of proxy POJO's which represent the fully populated thing, but are themselves not fully populated.
You present the proxy list, and when the user selects one, then you do another query to get the fully populated object.

Your mileage may vary.

Answer 3

There's many ORM frameworks that can do this including Hibernate, myBatis, JPA and spring-JDBC

spring-jdbc and myBatis give you granular control over the SQL whereas with JPA and Hibernate you are usually abstracted away from the SQL.

I suggest you do some reading and figure out which one you like before rolling your own solution.

Answer 4

Your question:

We know that we can map same table objects with same pojo class,
but when the query is customized and there is a data returned 
which doesn't map to any specific class then what would be the procedure? 

If you have 100 kinds of SQL which returns different combination of columns, could it be to create 100 different POJOs? The answer is "NO, stop using POJO".

This library qood is designed to solve this problem, you can try it.