Hibernate Use Cases

1)One-To-Many Relationship

public class Cart {
    private int cartId = 0;
    private String cartName = null;
    private Set cartItems = new HashSet();

    public int getCartId() {
        return cartId;
    }

    public void setCartId(int cartId) {
        this.cartId = cartId;
    }

    public String getCartName() {
        return cartName;
    }

    public void setCartName(String cartName) {
        this.cartName = cartName;
    }

    public Set getCartItems() {
        return cartItems;
    }

    public void setCartItems(Set cartItems) {
        this.cartItems = cartItems;
    }


    public void addItemToCart(CartItems ta){
        if (this.cartItems==null){
            this.cartItems = new HashSet();
        }
        this.cartItems.add(ta);
    }
}
            

public class CartItems {
    private int cartItemId = 0;
    private String itemName = null;
    private String itemDesc = null;
    private int itemOrder = 0;
    private Cart cart = null;

    public int getCartItemId() {
        return cartItemId;
    }

    public void setCartItemId(int cartItemId) {
        this.cartItemId = cartItemId;
    }

    public String getItemName() {
        return itemName;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    public String getItemDesc() {
        return itemDesc;
    }

    public void setItemDesc(String itemDesc) {
        this.itemDesc = itemDesc;
    }

    public int getItemOrder() {
        return itemOrder;
    }

    public void setItemOrder(int itemOrder) {
        this.itemOrder = itemOrder;
    }

    public Cart getCart() {
        return cart;
    }

    public void setCart(Cart cart) {
        this.cart = cart;
    }
}
            

<hibernate-mapping auto-import="true" default-lazy="false">
    <class name="com.hms.model.Cart" table="cart">

        <id name="cartId" column="cart_id">
            <generator class="increment"/>
        </id>
        <property name="cartName">
            <column name="cart_name" />
        </property>

        <set name="cartItems"  inverse="true" cascade = "all-delete-orphan" order-by="item_order">
            <key column="cart_id"/>
            <one-to-many class="com.hms.model.CartItems"/>
        </set>
    </class>

    <class name="com.hms.model.CartItems" table="cart_items">
        <id name="cartItemId" column="cart_item_id">
            <generator class="increment"/>
        </id>
        <property name="itemName">
            <column name="item_name" />
        </property>
        <property name="itemDesc">
            <column name="item_desc"  />
        </property>
        <property name="itemOrder">
            <column name="item_order"  />
        </property>
        <many-to-one name="cart" column="cart_id" class="com.hms.model.Cart"/>
    </class>
</hibernate-mapping>
             

    public void saveCart(){
        Cart cart = new Cart();
        cart.setCartName("COMPUTER CART");
        //add cart items to cart
        CartItems citems = new CartItems();
        citems.setItemDesc("keyboard");
        citems.setItemName("logitech keyboard wireless");
        citems.setItemOrder(1);
        citems.setCart(cart);
        cart.addItemToCart(citems);

        citems = new CartItems();
        citems.setItemDesc("mouse");
        citems.setItemName("logitech mouse wireless");
        citems.setItemOrder(2);
        citems.setCart(cart);
        cart.addItemToCart(citems);

        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        session.save(cart);
        tx.commit();
        HibernateUtil.closeSession();
    }

    public void getCart(){
        Session session = HibernateUtil.getSession();
        Cart cart = (Cart)session.load(Cart.class,Integer.valueOf("1"));
        HibernateUtil.closeSession();
    }

    public void addChild(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //load the cart
        Cart cart = (Cart)session.load(Cart.class,Integer.valueOf("1"));
        //add some more items
        CartItems citems = new CartItems();
        citems.setItemName("NEW ITEM");
        citems.setItemDesc("NEW ITEM DESCRIPTION");
        citems.setItemOrder(100);  //calculate this to be the max order
        cart.addItemToCart(citems);
        citems.setCart(cart);
        //session.save(ta); --Note this also works
        session.flush();
        tx.commit();
        HibernateUtil.closeSession();
    }

    public void addChildAfterDetached(){
        Session session = HibernateUtil.getSession();
        Cart cart = (Cart)session.load(Cart.class,Integer.valueOf("1"));
        //close the session
        HibernateUtil.closeSession();
        //Do some changes to the object
        CartItems citems = new CartItems();
        citems.setItemName("NEW ITEM NAME FROM DETACHED OBJECT");
        citems.setItemDesc("DETACH ITEM");
        citems.setItemOrder(100);
        cart.addItemToCart(citems);
        citems.setCart(cart);
        //start a new session  and save the object
        session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        session.save(citems);
        tx.commit();
        HibernateUtil.closeSession();
    }

    public void deleteOneChild(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        Cart cart = (Cart)session.load(Cart.class,Integer.valueOf("1"));
        CartItems  citems = (CartItems)cart.getCartItems().iterator().next();
        cart.getCartItems().remove(citems);
        session.delete(citems);
        session.flush();
        tx.commit();
        HibernateUtil.closeSession();
    }

    public void deleleCart(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        Cart cart = (Cart)session.load(Cart.class,Integer.valueOf("1"));
        session.delete(cart);
        session.flush();
        tx.commit();
        HibernateUtil.closeSession();
    }

             

2) Forieng key use case (Using generator class foreign)

public class User {

    private String userId = null;
    private String userType = null;
    private String password = null;
    private UserDetails userDetails = null;

    /** Creates a new instance of User */
    public User() {
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserType() {
        return userType;
    }

    public void setUserType(String userType) {
        this.userType = userType;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public UserDetails getUserDetails() {
        return userDetails;
    }

    public void setUserDetails(UserDetails userDetails) {
        this.userDetails = userDetails;
    }

}
            

public class UserDetails {
    
    private String userId = null;
    private User user = null;
    
    private String userFirstName = null;
    private String userMiddleName = null;
    private String userLastName = null;
    private String userWorkPhone = null;
    private String userHomePhone = null;
   
    /** Creates a new instance of UserDetails */
    public UserDetails() {
    }

    public String getUserFirstName() {
        return userFirstName;
    }

    public void setUserFirstName(String userFirstName) {
        this.userFirstName = userFirstName;
    }

    public String getUserMiddleName() {
        return userMiddleName;
    }

    public void setUserMiddleName(String userMiddleName) {
        this.userMiddleName = userMiddleName;
    }

    public String getUserLastName() {
        return userLastName;
    }

    public void setUserLastName(String userLastName) {
        this.userLastName = userLastName;
    }

    public String getUserWorkPhone() {
        return userWorkPhone;
    }

    public void setUserWorkPhone(String userWorkPhone) {
        this.userWorkPhone = userWorkPhone;
    }

    public String getUserHomePhone() {
        return userHomePhone;
    }

    public void setUserHomePhone(String userHomePhone) {
        this.userHomePhone = userHomePhone;
    }    
    
    
}
            

<hibernate-mapping auto-import="true" default-lazy="false">
    <class name="com.hms.model.User" table="user">
        <id name="userId" column="user_id">
            <generator class="assigned"/>
        </id>
        <property name="password">
            <column name="password" />
        </property>
        <property name="userType">
            <column name="user_type_id" />
        </property>
        <one-to-one name="userDetails" class="com.hms.model.UserDetails" cascade="all" />
    </class>

    <class name="com.hms.model.UserDetails" table="user_details">
        <id name="userId" column="user_id">
            <generator class="foreign">
                <param name="property">user</param>
            </generator>
        </id>
        <one-to-one name="user" class="com.hms.model.User" constrained="true" />
        <property name="userFirstName">
            <column name="user_first_name" />
        </property>
        <property name="userMiddleName">
            <column name="user_middle_name" />
        </property>
        <property name="userLastName">
            <column name="user_last_name" />
        </property>
        <property name="userWorkPhone">
            <column name="user_work_phone" />
        </property>
        <property name="userHomePhone">
            <column name="user_home_phone" />
        </property>
    </class>
</hibernate-mapping>
             

private void createUser(){
        User user = new User();
        user.setUserId("testuser");
        user.setPassword("testpassword");
        user.setUserType("S");

        UserDetails userDetails = new UserDetails();
        userDetails.setUserFirstName("fname");
        userDetails.setUserMiddleName("middle name");
        userDetails.setUserLastName("lastname");
        userDetails.setUserWorkPhone("55");
        userDetails.setUserHomePhone("55");

        user.setUserDetails(userDetails);
        userDetails.setUser(user);
        Session  session = HibernateUtil.getSession();
        Transaction  tx = session.beginTransaction();
        session.save(user);
        tx.commit();
        HibernateUtil.closeSession();
    }

    public void deleteUser(){
        //load the user first
        Session session = HibernateUtil.getSession();
        User user = (User)session.load(User.class,"testuser");
        Transaction tx = session.beginTransaction();
        session.delete(user);
        tx.commit();
        HibernateUtil.closeSession();
    }

    public void updateUser(){
        //load the user first
        Session session = HibernateUtil.getSession();
        User user = (User)session.load(User.class,"testuser");
        HibernateUtil.closeSession();

        //change some properties and go for update
        user.setUserType("S");
        user.getUserDetails().setUserLastName("new last name");
        user.getUserDetails().setUserFirstName("hehe first name");
        //open a new session
        session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        session.saveOrUpdate(user);
        tx.commit();
        HibernateUtil.closeSession();
    }

             

3) Many-to-Many use case

 public class UserFeed {
     private String userId = null;
     private String password = null;
     private Set feeds = new HashSet();

     public Set getFeeds() {
         return feeds;
     }

     public void setFeeds(Set feeds) {
         this.feeds = feeds;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     public String getUserId() {
         return userId;
     }

     public void setUserId(String userId) {
         this.userId = userId;
     }

     public void addFeeds(Feed fd){
         this.feeds.add(fd);
     }

     public void addFeed(Feed f){
         this.feeds.add(f);
     }
 }
            

public class Feed {
    private int feedId = 0;
    private String feedName = null;


    /** Creates a new instance of Feed */
    public Feed() {
    }

    public int getFeedId() {
        return feedId;
    }

    public void setFeedId(int feedId) {
        this.feedId = feedId;
    }

    public String getFeedName() {
        return feedName;
    }

    public void setFeedName(String feedName) {
        this.feedName = feedName;
    }
}
            

<hibernate-mapping auto-import="true" default-lazy="false">
    <class name="com.mmi.model.UserFeed" table="user_feed">
        <id name="userId" column="user_id">
            <generator class="assigned"/>
        </id>
        <property name="password">
            <column name="password" />
        </property>
        <set name="feeds" table="user_feed_map" cascade = "all">
            <key column="user_id"/>
            <many-to-many column="feed_id" class="com.mmi.model.Feed"/>
        </set>
    </class>
    <class name="com.mmi.model.Feed" table="feed">
        <id name="feedId" column="feed_id">
            <generator class="assigned"/>
        </id>
        <property name="feedName">
            <column name="feed_name" />
        </property>
    </class>
</hibernate-mapping>
             

    /*
    IMPORTANT
    In the below program we insert a new row in the user table with userid as user1
    and also new row in teh feed table and also new row in mapping user_feed_map table
    */
    private void saveFeeds(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        UserFeed user = new UserFeed();
        user.setUserId("user1");
        user.setPassword("password1");

        Feed fd = new Feed();

        fd.setFeedId(1);
        fd.setFeedName("first feed name");
        user.addFeed(fd);

        fd = new Feed();
        fd.setFeedId(2);
        fd.setFeedName("second feed name");
        user.addFeed(fd);

        session.save(user);
        tx.commit();
        HibernateUtil.closeSession();
    }

    /*
    IMPORTANT
    In the below procedure we insret a new row in the user table with userid as user1
    but will not insert any new row in the feed table. we fetch the feed
    with id 1 and 2 and only populate the mapping table. In the below method
    we assume we have feed with id 1 and 2 in the feed table
    */
    private void saveFeedMappingAndUserOnly(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        UserFeed user = new UserFeed();
        user.setUserId("user1");
        user.setPassword("password1");

        Feed fd = (Feed)session.load(Feed.class,Integer.valueOf("1"));
        user.addFeed(fd);
        fd = null;

        fd = (Feed)session.load(Feed.class,Integer.valueOf("2"));
        user.addFeed(fd);

        session.save(user);
        tx.commit();
        HibernateUtil.closeSession();
    }

    private void getUserFeeds(){
        //load the object first
        Session session = HibernateUtil.getSession();
        UserFeed user = (UserFeed)session.load(UserFeed.class,"onlytwo");
        HibernateUtil.closeSession();
    }