Jose Fabricio Rojas - Desarrollo de Aplicaciones .NET, desarrollando de forma ALT.erNETiva: NHibernate: Aplicando Patrones de diseño a una aplicación que utiliza NHibernate

Hola! en este post aplicaremos patrones de diseño para nuestra aplicación, en concreto dos patrones , Abstract Factory y Data Access Object (DAO).

Primero un poco de teoría , a una pequeña definición de:

Patrones de Diseño:

Segun Wikipedia:

“Los patrones de diseño (design patterns) son la base para la búsqueda de soluciones a problemas comunes en el desarrollo de software y otros ámbitos referentes al diseño de interacción o interfaces.”

Entonces como recordarán en el post anterior hicimos un helper, denominado NHelper que usaba el concepto de Generics y Templates, en este post y con su respectivo ejemplo extenderemos un poco más esto haciendo uso de estos patrones:

Abstract Factory, un ejemplo más concreto lo hemos visto usando el Bloque de Acceso de datos de Enterprise Library atravez de DbFactory.

Según Wikipedia:

(Fábrica Abstracta) es un patrón de diseño para el desarrollo de software.

El problema que intenta solucionar este patrón es el de crear diferentes familias de objetos.

Data Access Object (DAO), es un patrón de uso de común en nuestras aplicaciones , generalmente lo identificamos de manera equivocada con nuestra Capa de Datos, A cuyos objetos de “acceso a datos”, le implementados los metodos caracteristicos de mantenimento o tambíen denominados CRUD.

Según Wikipedia:

En software de computadores, un Data Access Object (DAO, Objeto de Acceso a Datos) es un componente de software que suministra una interfaz común entre la aplicación y uno o más dispositivos de almacenamiento de datos, tales como una Base de datos o un archivo.

Diseñando nuestra Arquitectura:

En la denominada Capa 3 (Capa de Datos) implementaremos el patrón DAO y Abstract Factory.

En la denominada Capa 2 ( Capa de Logica de Negocios) implementaremos solo el patrón Abstrac Factory.

Problema:

Sucede que erróneamente se suele implementar un Objeto DAO para entidad y luego implementar un objeto de negocio que hace una llamada directa al objeto DAO, siguiendo esta logica , habrian tantas llamadas desde la capa de negocios hasta la capa de datos como entidades en nuestro modelo, lo cual debe tratar de evitarse. pues sino la aplicación quedaria asi:

Una solución a este problema , es aplicando patrones de diseño, para nuestro caso Abstract factory y DAO , implementandolo en ambas capas podemos redudir el numero de nuestras llamadas,

Como lo hacemos?

GenericDAO , GenericBussiness , implementando estas fabricas abstractas a y haciendo uso de ellas en las llamadas de nuestros objetos de negocios hacia nuestros objetos de datos, entonces cambiaria de esta manera:

Nuestro Diseño de Soluciones y proyectos:

Extendiento nuesto NHelper: De NHelper a NHibernateHelper

Implementando: GenericNHibernateDAO , IGenericDAO, NHibbernateHelper.

Instanciemos graficamente para poder entenderlo rápido:

Primero definimos nuestra interface IGenericDAO:

Esta interfaz tendra cada uno de los metodos que utilizarán nuestras entidades, tales como:

FindAll(): Devuelve todos los elementos.
FindAllOrdered() : Devuelve todos elementos ,bajo un criterio de orden
FindByExample() : Devuelve todos los elementos que coincidan con el objeto de ejemplo enviado como parametro
FindbyId(): devuelve un ojeto a partir de su identificador , sea este un primitivo(string, int, etc.) o un objeto , para el caso de nuestras claves compuestas.
CRUD: Save(), Update(),MakeTransient() (Delete), etc.

using System.Collections; 
using System.Collections.Generic; 
namespace NHDataAccess 
{ 
   public interface IGenericDao<T,ID> 
    { 
        T FindByid(Id id); 
  
        IList<T> FindAll(); 
  
        IList<T> FindAllOrdered(IList<STRING> propertyNames); 
  
        IList<T> FindByExample(T entity); 
  
        IList<T> FindBydExampleOrdered(T entity, IList<STRING> propertyNames); 
  
        IList<T> FindLikeExample(T entity); 
  
        IList<T> FindLikeExampleOrdered(T entity, IList<STRING> propertyNames); 
  
        IList<T> FindLikeExampleIgnoreCase(T entity); 
  
        IList<T> FindLikeExampleIgnoreCaseOrdered(T entity, IList<STRING> propertyNames); 
  
        IList<T> FindByQuery(string query); 
  
        IList<T> FindByQuery(string query, string[] parameters, object[] values); 
  
        IList<T> FindByNamedQuery(string query); 
  
        IList<T> FindByNamedQuery(string query, string[] parameters, object[] values); 
  
        IList FindObjectsByQuery(string query); 
  
        IList FindObjectsByNamedQuery(string query); 
  
        IList FindObjectsByNamedQuery(string query, string[] parameteres, object[] values); 
  
        IList FindObjectsBySQLQuery(string query, string[] parameters, object[] values); 
  
        T Save(T entity); 
  
        T Update(T entity); 
  
        void MakeTransient(T entity); 
  
        Id GetMax(string propertyName); 
  
    } 
}   

Porque en unos casos usar IList<T> y en otros IList:

Para el primer caso cuando utilizamos IList<T> hacemos una consulta sobre una entidad en particular, los metodos que utilizen IList<T> solo devolverán un tipo en particular.

Para el segundo caso , se da cuando deseamos recuperar “Propiedades cruzadas” que quiere decir esto , imaginemos un join entre entidades , osea por ejm:

Class A –> propiedad A1 , propiedad A2

Clase B –> propiedad B1, propiedad B2

y quisieramos recuperar una lista que contenga la Propiedad A1 y propiedad B2, en este caso Nhibernate me devolvera una lista de arrays, en la cual yo podré iterar y recuperar lo que necesito, más adelante implementaremos un ejemplo de este caso.

GenericNHibernateDao:

Esta clase hereda la interfaz IGenericDAO e implementa sus métodos:

La implementación de estos metodos lo hacemos atreves del uso de criteria, si recuerdan en el post anterior para nuestra primera versión de NHelper , usabamos HQL a modo de emular “SQL”, en este Nuevo NHelper, GenericNHibernateDAO , NH genera las consultas SQL a partir de criteria.

(*) Para la presentación configuraremos Log4net para visualizar las consultas SQL generadas por NHibernate.

using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using NHDataAccess; 
using NHibernate; 
using NHibernate.Criterion; 
using NHibernate.Type; 
namespace NHDataAccess 
{ 
    public abstract class GenericNhibernateDao<T,ID> : IGenericDao<T,ID> 
    { 
        public T FindByid(Id id) 
        { 
            return NhibernateHelper.GetCurrentSession().Get<T>(id); 
        } 
  
        public IList<T> FindAll() 
        { 
            return NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).List<T>(); 
        } 
  
        public IList<T> FindAllOrdered(IList<STRING> propertyNames) 
        { 
            var criteria = NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)); 
            foreach (var propertyName in propertyNames) 
            { 
                criteria.AddOrder(Order.Asc(propertyName)); 
            } 
            return criteria.List<T>(); 
        } 
  
        public IList<T> FindByExample(T entity) 
        { 
            return NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).Add(Example.Create(entity)).List<T>(); 
        } 
  
        public IList<T> FindBydExampleOrdered(T entity, IList<STRING> propertyNames) 
        { 
            var criteria = NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).Add(Example.Create(entity)); 
            foreach (var propertyName in propertyNames) 
            { 
                criteria.AddOrder(Order.Asc(propertyName)); 
            } 
            return criteria.List<T>(); 
        } 
  
        public IList<T> FindLikeExample(T entity) 
        { 
            return NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).Add(Example.Create(entity).EnableLike()).List<T>(); 
        } 
  
        public IList<T> FindLikeExampleOrdered(T entity, IList<STRING> propertyNames) 
        { 
            var criteria = NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).Add(Example.Create(entity)); 
            foreach (var propertyName in propertyNames) 
            { 
                criteria.AddOrder(Order.Asc(propertyName)); 
            } 
            return criteria.List<T>(); 
        } 
  
        public IList<T> FindLikeExampleIgnoreCase(T entity) 
        { 
            return
                NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).Add( 
                    Example.Create(entity).EnableLike().IgnoreCase()).List<T>(); 
        } 
  
        public IList<T> FindLikeExampleIgnoreCaseOrdered(T entity, IList<STRING> propertyNames) 
        { 
            var criteria = 
                NhibernateHelper.GetCurrentSession().CreateCriteria(typeof(T)).Add( 
                    Example.Create(entity).EnableLike().IgnoreCase()); 
            foreach (var propertyName in propertyNames) 
            { 
                criteria.AddOrder(Order.Asc(propertyName)); 
            } 
            return criteria.List<T>(); 
        } 
  
        public IList<T> FindByQuery(string query) 
        { 
            return NhibernateHelper.GetCurrentSession().CreateQuery(query).List<T>(); 
        } 
  
        public IList<T> FindByQuery(string myquery, string[] parameters, object[] values) 
        { 
            var query = NhibernateHelper.GetCurrentSession().CreateQuery(myquery); 
            for (var i = 0; i < parameters.Length-1; i++) 
            { 
                query.SetParameter(parameters[i], values[i]); 
            } 
            return query.List<T>(); 
        } 
  
        public IList<T> FindByNamedQuery(string query) 
        { 
            return NhibernateHelper.GetCurrentSession().GetNamedQuery(query).List<T>(); 
        } 
  
        public IList<T> FindByNamedQuery(string myquery, string[] parameters, object[] values) 
        { 
            var query = NhibernateHelper.GetCurrentSession().GetNamedQuery(myquery); 
            for (var i = 0; i < parameters.Length-1; i++) 
            { 
                query.SetParameter(parameters[i], values[i]); 
            } 
            return query.List<T>(); 
        } 
  
        public System.Collections.IList FindObjectsByQuery(string query) 
        { 
            return NhibernateHelper.GetCurrentSession().CreateQuery(query).List(); 
        } 
  
        public System.Collections.IList FindObjectsByNamedQuery(string query) 
        { 
            return NhibernateHelper.GetCurrentSession().GetNamedQuery(query).List(); 
        } 
  
        public System.Collections.IList FindObjectsByNamedQuery(string myquery, string[] parameteres, object[] values) 
        { 
            var query = NhibernateHelper.GetCurrentSession().GetNamedQuery(myquery); 
            for (var i = 0; i < parameteres.Length-1; i++) 
            { 
                query.SetParameter(parameteres[i], values[i]); 
            } 
            return query.List(); 
        } 
  
        public IList FindObjectsBySQLQuery(string query) 
        { 
            return NhibernateHelper.GetCurrentSession().CreateSQLQuery(query).List(); 
        } 
  
        public IList FindObjectsBySQLQuery(string myquery, string[] parameters, object[] values) 
        { 
            var query = NhibernateHelper.GetCurrentSession().CreateSQLQuery(myquery); 
            for (int i = 0; i < parameters.Length-1; i++) 
            { 
                query.SetParameter(parameters[i], values[i]); 
            } 
            return query.List(); 
        } 
  
        public T Save(T entity) 
        { 
            NhibernateHelper.GetCurrentSession().Save(entity); 
            return entity; 
        } 
  
        public T Update(T entity) 
        { 
            NhibernateHelper.GetCurrentSession().Update(entity); 
            return entity; 
        } 
  
        public void MakeTransient(T entity) 
        { 
            NhibernateHelper.GetCurrentSession().Delete(entity); 
        } 
  
        public Id GetMax(string propertyName) 
        { 
            return NhibernateHelper.GetCurrentSession().CreateCriteria(GetType()).SetProjection(Projections.ProjectionList().Add(Projections.Max(propertyName))).UniqueResult<ID>(); 
        } 
        protected void DeleteObjectByQuery(string query, object[] values, IType[] types) 
        { 
            NhibernateHelper.GetCurrentSession().Delete(query, values, types); 
        } 
    } 
}

NhibernateHelper:

Esta clase administra las sessiones de Nhibernate, con esto quiero decir que crea , borra , inicializa transacciones , cierra , commitea y hacer rollback, etc.

Los métodos de esta Clase son estaticos, una vez inicializada la session de NH , la guardan en el session Current del objeto Session de ASP.NET, para poder así mantener la session activa.

using System; 
using System.IO; 
using NHibernate; 
using Configuration=NHibernate.Cfg.Configuration; 
  
namespace NHDataAccess 
{ 
    public class NhibernateHelper 
    { 
        private const string CurrentSessionKey = "nhibernate.current_session"; 
        public static ISessionFactory SessionFactory; 
        static NhibernateHelper() 
        { 
            try
            { 
                log4net.Config.XmlConfigurator.Configure(); 
                var cfg = new Configuration(); 
                var configurationSection = NhibernateConfigurationSection.CurrentConfiguration; 
                cfg.Configure(configurationSection.HibernateFile); 
                var path = new DirectoryInfo(configurationSection.MappingPath); 
                cfg.AddDirectory(path); 
                SessionFactory = cfg.BuildSessionFactory(); 
            } 
            catch (Exception ex) 
            { 
                throw new Exception("Falló Inicialización de Nhibernate",ex); 
            } 
        } 
  
        public static ISession OpenSession() 
        { 
            return SessionFactory.OpenSession(); 
        } 
  
        public static ISession GetCurrentSession() 
        { 
            var context = System.Web.HttpContext.Current; 
            var currentSession = (ISession) (context.Items[CurrentSessionKey]); 
            if(currentSession == null) 
            { 
                currentSession = SessionFactory.OpenSession(); 
                context.Items[CurrentSessionKey] = currentSession; 
            } 
            return currentSession; 
        } 
  
        public static void CloseSession() 
        { 
            var context = System.Web.HttpContext.Current; 
            var currentSession = (ISession) (context.Items[CurrentSessionKey]); 
            if(currentSession == null) 
            { 
                return; 
            } 
            currentSession.Close(); 
            context.Items.Remove(CurrentSessionKey); 
        } 
        public static void CloseSessionFactory() 
        { 
            if(!(SessionFactory == null)) 
            { 
                SessionFactory.Close(); 
            } 
        } 
  
        public static void BeginTransaction() 
        { 
            if(GetCurrentSession().Transaction.IsActive) 
            { 
                GetCurrentSession().BeginTransaction();  
            } 
        } 
        public static void EndTransaction() 
        { 
            GetCurrentSession().Transaction.Commit(); 
        } 
        public static void RollBackTransaction() 
        { 
            GetCurrentSession().Transaction.Rollback(); 
        } 
    } 
}

Nuestras Entidades:

Igual que en nuestro ejemplo anterior utilizaremos solo 3 entidades , Usuario, Rol , y la entidad intermedia , UsuarioRol

La diferencia es en el uso de claves compuestas para el caso de “UsersRoles” esto con el efecto de utilizarla en la demostración

using System; 
using System.Collections; 
namespace NHEntity 
{ 
    [Serializable()] 
    public class RoleEntity : IEquatable<RoleEntity> 
    { 
        public virtual int IdRole{ get; set;} 
  
        public virtual  string RoleName{ get; set;} 
  
        public virtual IList UserRoleList { get; set; } 
  
        #region Miembros de IEquatable<ROLE> 
  
        public virtual bool Equals(RoleEntity other) 
        { 
            return other.IdRole.Equals(IdRole ); 
        } 
        #endregion 
    } 
}

using System; 
namespace NHEntity 
{ 
    [Serializable] 
    public class UserRoleEntity : IEquatable<UserRoleEntity> 
    { 
        private PKUserRole id = new PKUserRole(); 
        public virtual PKUserRole IdUserRole 
        { 
            set
            { 
                id = value; 
            } 
            get
            { 
                return id; 
            } 
        } 
  
        public virtual bool Equals(UserRoleEntity other) 
        { 
            return other.IdUserRole.Equals(this.IdUserRole); 
        } 
    } 
}

using System; 
using System.Collections; 
using System.Collections.Generic; 
namespace NHEntity 
{ 
    [Serializable] 
    public class UserEntity : IEquatable<UserEntity> 
    { 
        private IList userRoleList; 
        public UserEntity() 
        { 
            userRoleList = new List<UserRoleEntity>(); 
        } 
  
        public virtual int IdUser 
        { 
            set; 
            get; 
        } 
  
        public virtual string Login 
        { 
            set; 
            get; 
        } 
  
        public virtual string Password 
        { 
            set; get; 
        } 
  
        public virtual IList UserRoleList 
        { 
            get
            { 
                return userRoleList; 
            } 
            set
            { 
                userRoleList = value; 
            } 
        } 
  
        public virtual bool Equals(UserEntity other) 
        { 
            return other.IdUser.Equals(IdUser); 
        } 
    } 
}

Objetos PK

Para el uso de las claves compuestas, se necesita implementar una clase que denominaremos Objetos PK

using System; 
using System.Collections; 
  
namespace NHEntity.PK 
{ 
    [Serializable] 
    public class PKUserRole : IEquatable<PKUSERROLE> 
    { 
        private UserEntity idUser = new UserEntity(); 
        private RoleEntity idRole = new RoleEntity(); 
        readonly CaseInsensitiveComparer objComparer  = new CaseInsensitiveComparer(); 
        public virtual UserEntity IdUser 
        { 
            set
            { 
                idUser = value; 
            } 
            get
            { 
                return idUser; 
            } 
        } 
        public virtual RoleEntity IdRole 
        { 
            set
            { 
                idRole = value;    
            } 
            get
            { 
                return idRole; 
            } 
        } 
        public bool Equals(PKUserRole obj) 
        { 
            return objComparer.Compare(this, obj) == 0; 
        } 
        public override bool Equals(object obj) 
        { 
            if(obj.Equals(this)) 
            { 
                return true;    
            } 
            return false; 
        } 
        public override int GetHashCode() 
        { 
            return base.ToString().ToLowerInvariant().GetHashCode() + 1; 
        }  
    } 
}

Objetos DAO

UserDao
RoleDao
UserRoleDao

UserDao:

using NHDao.Interfaces; 
using NHDataAccess; 
using NHEntity; 
  
namespace NHDao.Implementations 
{ 
    public class UserDao : GenericNhibernateDao<UserEntity, int>, IUserDao 
    { 
    } 
}

RoleDao:

using NHDao.Interfaces; 
using NHDataAccess; 
using NHEntity; 
  
namespace NHDao.Implementations 
{ 
    public class RoleDao : GenericNhibernateDao<RoleEntity,INT>,IRoleDao 
    { 
    } 
}

UserRoleDao:

using NHDao.Interfaces; 
using NHDataAccess; 
using NHEntity; 
using NHEntity.PK; 
  
namespace NHDao.Implementations 
{ 
    public class UserRoleDao : GenericNhibernateDao<UserRoleEntity, PKUserRole>, IUserRoleDao 
    { 
    } 
}

Interfaces IUserDao:

using NHDataAccess; 
using NHEntity; 
namespace NHDao.Interfaces 
{ 
    public interface IUserDao : IGenericDao<UserEntity, int> 
    { 
    } 
}

IRoleDao:

using NHEntity; 
using NHDataAccess; 
namespace NHDao.Interfaces 
{ 
    public interface IRoleDao : IGenericDao<RoleEntity,INT> 
    { 
    } 
}

UserRoleDao:

using NHDataAccess; 
using NHEntity; 
using NHEntity.PK; 
  
namespace NHDao.Interfaces 
{ 
    public interface IUserRoleDao : IGenericDao<UserRoleEntity, PKUserRole> 
    { 
    } 
}

DAOFactory

Como la clase DAOFactory es una clase abstracta(al ser abstracta no podemos instanciarla)

para poder hacer esto implementamos un metodo estático “Instance()” que me creara una

instancia de un tipo, en este caso de la clase abstracta DAOFactory

using System; 
using NHDao.Interfaces; 
namespace NHDao 
{ 
    public abstract  class DaoFactory 
    { 
        public static Type DAO_FACTORY = typeof (FrameworkDaoFactory); 
        public static DaoFactory Instance(Type factory) 
        { 
            try
            { 
                return (DaoFactory) Activator.CreateInstance(factory); 
                  
            }catch(Exception ex) 
            { 
                throw new Exception("No se crear Factory de DAO:"+factory); 
            } 
        } 
        public abstract IRoleDAO GetRoleDAO(); 
        public abstract IUserDAO GetUserDAO(); 
        public abstract IUserRoleDAO GetUserRoleDAO(); 
    } 
}

FrameworkDaoFactory

using NHDao.Implementations; 
using NHDao.Interfaces; 
namespace NHDao 
{ 
    public class FrameworkDaoFactory : DaoFactory 
    { 
        public override IRoleDAO GetRoleDAO() 
        { 
            return new RoleDAO(); 
        } 
        public override IUserDAO GetUserDAO() 
        { 
            return new UserDAO(); 
        } 
        public override IUserRoleDAO GetUserRoleDAO() 
        { 
            return new UserRoleDAO(); 
        } 
    } 
}

Hasta Aquí su primera parte , en unos dias publícare la segunda parte , y despues la tercera parte.

Espero hasta aportado , si tienen dudas ,no duden en escribirme y trataré de responder en lo más rápido que me sea posible.

(*) Actualización:

Bueno

José Fabricio Rojas

Jose Fabricio Rojas - Desarrollo de Aplicaciones .NET, desarrollando de forma ALT.erNETiva

08/01/08

NHibernate: Aplicando Patrones de diseño a una aplicación que utiliza NHibernate – Parte 1

Diseñando nuestra Arquitectura:

Nuestro Diseño de Soluciones y proyectos:

Extendiento nuesto NHelper: De NHelper a NHibernateHelper

Nuestras Entidades:

Objetos PK

Objetos DAO

DAOFactory

FrameworkDaoFactory

0 post:

Buscar en weblog

¿Quien soy?

en la twittosfera

Un Geek Alt.NET ;)

Perfil

Visitantes:

Nube de Tags

Blogs que leo

Archivo del blog

Perfil en facebook

Jose Fabricio Rojas - Desarrollo de Aplicaciones .NET, desarrollando de forma ALT.erNETiva

08/01/08

NHibernate: Aplicando Patrones de diseño a una aplicación que utiliza NHibernate – Parte 1

Diseñando nuestra Arquitectura:

Nuestro Diseño de Soluciones y proyectos:

Extendiento nuesto NHelper: De NHelper a NHibernateHelper

Nuestras Entidades:

Objetos PK

Objetos DAO

DAOFactory

FrameworkDaoFactory

0 post:

Buscar en weblog

¿Quien soy?

en la twittosfera

Un Geek Alt.NET ;)

Perfil

Suscribete¡¡¡

Visitantes:

Nube de Tags

Blogs que leo

Archivo del blog

Perfil en facebook