dao or pl?

я не сплю шестые сутки и виденья у меня.
уже несколько дней бьюсь над вопросом: data access objects vs. generic persistence layer. (в контексте spring + hibernate)
и то и другое такое вкусненькое. точнее у меня три выбора:
1) красивое и аккуратное dao. все как положено, отдельные дао классы для каждой сущности, отдельные дао классы для получения родителей к детям.
2) половина дао. корневые объекты мы получаем через дао классы, а вот привязку детей перекладываем на hibernate (lazy loading), оставляя сессию открытой. но ведь так теряются основные преимущества дао в возможности переноса используемого хранилища объектов.
3) generic persistence layer, привязываемый, скажем, к контроллеру. который будет выполнять с hibernate операции, используемые в контроллере.
4) нельзя не учитывать и вариант что мы будет банально обращаться к hibernate сессии из контроллера, но мне этого не позволяет внутренний перфекционизм.

вроде все раскритиковал, кроме первого варианта. в нем мне не нравится то, что для того получения детей объекта нужен отдельный класс. или даже 2. плюс по интерфейсу на каждый класс.

// например, есть классы, в которых определены методы
class Parent { 
List <Child> children;
public List<Child> getChildren(){
return children;
}
}
class Child {
Parent parent;
public Parent getParent(){
return parent;
}
}
// есть еще маппинги к ним, да.
// если напрямую использовать hibernate session factory (вариант 4),
// то код получения родителя:
Parent parent = (Parent) session.get(Parent.class, parentId);
// а код получения его детей:
List<Child> children = parent.getChildren();

// все остальное за нас сделает hibernate


// если же все делать "по красивому" то получается что-то вроде

interface ParentDao {
public Parent getById(int id);
}
class ParentDaoHibernateImpl implements ParentDao {
SessionFactory sessionFactory;
public Parent getById(int id) {
return (Parent)sessionFactory.getCurrentSession().get(Parent.class,id);
}
}
interface ParentService {
public Parent getById(int id);
}
class ParentServiceDaoImpl implements ParentService {
ParentDao parentDao;
public Parent getById(int id) {
return parentDao.getById(id);
}
}
interface ChildDao {
public Child getById(int id);
}
class ChildDaoHibernateImpl implements ChildDao {
SessionFactory sessionFactory;
public Child getById(int id) {
return (Child)sessionFactory.getCurrentSession().get(Child.class,id);
}
}
interface ChildService {
public Child getById(int id);
}
class ChildServiceDaoImpl implements ChildService {
ChildDao childDao;
public Child getById(int id) {
return childDao.getById(id);
}
}
interface ParnetsChildrenDao {
public List<Child> getByParent(Parent parent);
}
class ParnetsChildrenDaoHibernateImpl implements ParnetsChildrenDao {
public List<Child> getByParent(Parent parent) {
return parent.getChildren();
}
}
interface ParnetsChildrenService {
public List<Child> getByParent(Parent parent);
}
class ParnetsChildrenServiceDaoImpl implements ChildService {
ParnetsChildrenDao parnetsChildrenDao;
public List<Child> getByParent(Parent parent) {
return parnetsChildrenDao.getByParent(parent);
}
}
// плюс в каждом классе геттеры-сеттеры для членов.
// хорошо хоть это все можно описать как beans 
// и объекты сами подставяттся по маппингу
// т.е. sessionFactory будет инициализирован
// и куда надо в интерфейсы будут поставлены нужные реализации
// parentDao --> ParentDaoHibernateImpl
// childDao --> ChildDaoHibernateImpl
// parnetsChildrenDao --> ParnetsChildrenDaoHibernateImpl
// и в контреллере заведутся две инициализированные переменные 
// parentService и parentService


// да, реализация в контреллере оставется в две строчки: 
// да еще и две красивых строчки:

Parent parent = parentService.getById(parentId);

List<Child> children = parnetsChildrenService.getByParentId(parent);

но стоит ли это тех усилий и тех 6 классов и 6 интерфейсов?

скажите мне что я сплю, что все написанное выше -- бред и что все намного проще!

p.s. я, оказывается, не раскритиковал третий вариант. с persistence layer. может зря он мне кажется неправильным?
по большому счету это класс типа

class MyAppPL {
SessionFactory sessionFactory;
public Parent getParentById(int id) {
return (Parent)sessionFactory.getCurrentSession().get(Parent.class,id);
}
public List<Child> getParentsChilren(Parent parent) {
return parent.getChildren();
} 
}

может это и есть то, что назвается "красиво" и зря я это отвергаю?
может dao никто не использует и его изобрели для красоты? =)