Question

I have an entity named Commercial. I have an Category entity where the list of commercial categories are hold. For each category there is an separate entity extending Commercial(like RestaurantCommercial, PhotoStudioCommercial etc. total up to 20 entities) with JOINED inheritance strategy.

Commercial entity holds up general properties like title, text contactnumber of some company’s commercial, while RestaurantCommercial and PhotoStudioCommercial holds additional specific properties concerned with that category.

The problem is that writing a separate dao and controller for each entity is a bit plenty of work, so I am searching for a neat way to handle this issue.

I need an unified controller and may be the DAO for handling the form control and persisting new instances of the entities that extend Commercial.

Here is approximately what I was thinking about:

@RequestMapping(value={"/vendor/commercial/{categoryName}/new"}, method=RequestMethod.GET)
public String showNewCommercialForm(@PathVariable("categoryName") String categoryName,
                                    Map<String, Object> map) {
    Category category = categoryDAO.getCategoryByServiceName(categoryName);

    Class clazz = Class.forName(category.getClassName()); //here className is smth like domain.commercial.RestaurantCommercial

    map.put("commercialInstance", clazz.newInstance());
    //separate view for each category of commercial
    return "vendor/commercial/"+categoryName+"/new";
}

And I was thinking for a similar controller for saving form data even if I would have to write a sperate binder for this stuff.

So the question is: What would you suggest to handle this issue or what would be the best practice if you had already faced similar need(Generics, Reflection or smth else)? Or if that would be worthy or not and why?
Thanks in advance.

Answer 1

I create a Dao interface for such cases:

public interface Dao<T extends Commercial> {

    T getAll();
}

After that an abstract Dao implementation, for example hibernate based:

public CommonHibernateDao<T extends Commercial> implements Dao<T> 
{
    private final Class<T> entityType;

    protected CommonHibernateDao(Class<T> entityType) {
        this.entityType = entityType;
    }

    public List<T> getAll() {
        // hibernate get all implementation
    }
}

And RestaurantCommercial Dao interface and implementation:

public interface RestaurantCommercialDao extends Dao<RestaurantCommercial> {

}

public class HibernateRestaurantCommercialDao extends CommonHibernateDao<RestaurantCommercial> implements RestaurantCommercialDao {

    public HibernateRestaurantCommercialDao() {
        super(RestaurantCommercial.class);
    }
}

All implementation goto CommonHibernateDao. In it’s subclasses only constructor calling neaded. Basically you can do it with reflection but as for me it is not clear.

For controller (something like RESTfull API):

@Controller
public class YourController() {

    @RequestMapping(value = "/restapi/{entityType}")
    public String postEntity(HttpServletRequest request, @PathVariable(value = "entityType") String entityType) {
        // If enetity name will be packegae + class name
        Object beanInstance = Class.forName(entityName);
        ServletRequestDataBinder binder = new ServletRequestDataBinder(beanInstance);
        binder.bind(request);

        // Here by type of entity you can get DAO and persist
    }
}

If form input names will be same to your bean names – binding will do all automatically.