• Save
♬♪♬..I'm too sexy... ♫♪ catwalk... Como modelar el dominio efectivamente
Upcoming SlideShare
Loading in...5
×
 

♬♪♬..I'm too sexy... ♫♪ catwalk... Como modelar el dominio efectivamente

on

  • 1,171 views

La arquitectura de MVC ofrece al M - Models (no de Manuel) como el primer componente fundamental, pero muchas veces en Rails nos olvidamos de los Modelos y hacemos que los Controllers sean gordos y ...

La arquitectura de MVC ofrece al M - Models (no de Manuel) como el primer componente fundamental, pero muchas veces en Rails nos olvidamos de los Modelos y hacemos que los Controllers sean gordos y pesados que tengan de hecho toda la lógica de negocios y los modelos son meramente un mapa con las tablas en la base de datos. Ese estilo y enfoque es EQUIVOCADO, ERRONEO y NO SUSTENTABLE, por lo que en esta presentación se mostraran técnicas basadas en DDD (Domain-driven design) y principios como SOLID y conacimiento (connascence) para tener un modelaje efectivo y apropiado de la realidad lo que permita tener sistemas mantenibles con intefaces claramente definidas y responsabilidades, colaboraciones y roles de objetos que den verdadero valor a nuestros clientes. Se revisará como se implementa esto en la nueva versión de Rails3 por medio de Active Model y aplicación de patrones de diseño y mejores prácticas de Ruby y de RoR

Statistics

Views

Total Views
1,171
Views on SlideShare
1,167
Embed Views
4

Actions

Likes
1
Downloads
0
Comments
0

3 Embeds 4

http://tv.rails.mx 2
http://pio.la 1
http://www.pio.la 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

♬♪♬..I'm too sexy... ♫♪ catwalk... Como modelar el dominio efectivamente ♬♪♬..I'm too sexy... ♫♪ catwalk... Como modelar el dominio efectivamente Presentation Transcript

  • ♬♪♬..I'm too sexy... ♫♪ catwalk...
    Como modelar el dominioefectivamente
  • ¿Cual es el problema que resuelve?
  • Complex/Long SQL
    QLUserInfo     custom:/userinfosSQLNamedQuery   userinfos FREEFORM "  SELECT     `phpbb`.`pbb_users`.`username` AS 'username',     CONCAT('{MD5}',`mabase`.`ltq_services_accounts`.`lsa_password`) AS 'password',     `ftp`.`ftp_profiles`.`fpf_uid` AS 'uid',     `ftp`.`ftp_profiles`.`fpf_gid` AS 'gid',     `ftp`.`ftp_profiles`.`fpf_home` AS 'homedir',     '/sbin/nologin' AS 'shell'   FROM     `phpbb`.`pbb_users`     INNER JOIN `mabase`.`ltq_users`       ON `phpbb`.`pbb_users`.`user_id`         =`mabase`.`ltq_users`.`lus_forum_id`     INNER JOIN `mabase`.`ltq_services_accounts`       ON `mabase`.`ltq_users`.`lus_id`         =`mabase`.`ltq_services_accounts`.`lsa_users_id`     INNER JOIN `ftp`.`ftp_profiles`       ON `mabase`.`ltq_services_accounts`.`lsa_ftp_profiles_id`         =`ftp`.`ftp_profiles`.`fpf_id`   WHERE     `phpbb`.`pbb_users`.`username`='%U'     AND       `mabase`.`ltq_services_accounts`.`lsa_ftp_activ`='1'     AND       `mabase`.`ltq_users`.`lus_useractiv`='1'     AND       `phpbb`.`pbb_users`.`user_active`='1'   LIMIT 1"
  • aspectosesenciales a tomar en cuenta
  • Data Source Architectural Patterns:
    Active Record. Un objeto que envuelve un registro de una tabla o una vista en una BD, encapsulando su acceso y añadiendo lógica del dominio a esos datos
    Table Data Gateway, Row Data Geteway, Data Mapper
  • Rails 3 - Modelos
    El generador de código de RoR
    rails generate model item thing:stringdone:booleanlist:references -trspec
    • ¿Qué se define en el modelo?:
    Susasociaciones con otrosmodelos
    Susvalidacionesy callbacks
    Susalcances (scopes) e interface de consultas(queries)
    Los métodos de suresponsabilidad
  • App. Conjunto de objetos que interactuan
    Objeto. Una implementación de uno o más roles
    Role. Un conjunto de responsabilidades relacionadas
    Responsabilidad. Obligación de hacer una tarea o conocer una información
    Colaboración. Una interacción de objetos, roles o ambos
    Contrato. Un acuerdo que indica los términos de una colaboración
  • Ma! Mis controladores son gordos y mis modelos flacos
    Definir los roles y respetar el contrato
    Asignar correctamente la responsabilidad
    Establecer las colaboraciones
    El controlador es un orquestador y el servicio pesado lo deben de hacer los modelos y en algunos casos para ayudar a las vistas los helpers
    La lógica del dominio debe de ser modelada en los modelos evitando hacerla en los controladores
  • Las tresLeyes de las interfaces:
    La implementación de una interfaz debe de hacer lo que sus métodos dice que hace
    La implementación de una interfaz no debe de producir daño. Es decir, no debe de interferir con sus colaboraciones y debe de usar recursos de forma eficiente
    Si la implementación de una interfaz no es capaz de realizar sus responsabilidades, debe de notificarlo a quien la llamó.
  • El ciclo de vida de los modelos
    Durante el funcionamiento normal de una appRails, los modelos se pueden crear, actualizar y destruidos. Active Record brinda ganchos (hooks) de modo que se pueda controlar la app y datos.
    Las Validaciones permiten garantizar que sólo los datos válidos se almacena en la BD. Callbacksy observadores permiten activar la lógica antes o después de una alteración del estado de un modelo.
  • Asociaciones
    Definen una colaboración entre Modelos
    Establecen el orden de la colaboración: belongs_to, has_one, has_many, has_many :through, has_one :through, has_and_belongs_to_many
    Pueden ser polimorficas en las que un modelo puede tener con una sola asociación colaboración con más de un modelo. El modelo polimorfico debe de tener dos atributos: uno para el id del modelo asociado y otro para su tipo
    Las asociaciones también pueden especificar callbacks y extensiones
  • Migraciones
    Son unamaneraconvenienteparamodificar la BD de maneraestructuradayorganizada.
    Active Record proporcionamétodosquerealizantareas de definición de datoscomunes en la BD de forma: CREATE_TABLE, change_table, drop_table, add_column, change_column, rename_column, remove_column, add_indexyremove_index
  • Nombres con significado descriptivo, que revelen la intención de forma distinguible y en contexto
    Clases y objetos deben de ser sustantivos o frases sustantivas
    Métodos deben de ser verbos o frases verbales
    Los métodos deben de ser cortos y deben de tener una responsabilidad y sólo una.
    Los métodos deben de hacer algo (commands) ó dar respuestas (query) pero no ambas cosas
  • ¿PorquéutilizarValidaciones?
    Es un DSL que se utilizaparagarantizarquesólo los datosválidos se guarda en su base de datos.
    Se activancuando un objeto se vaya a insertaroactualizar en la BD.
    Pero dado que hay muchasformas de cambiar el estado de un objeto, no todosdisparanlasvalidacionespor lo que se debe de tenercuidado
  • Validation Helpers & Common Validation Options
    Se ofrecen helpers predefinidosquepuedes ser usadosdirectamente en lasdefiniciones de clases.
    Estos helper ofrecenreglas de validaciónque son frecuentementerequeridas
    Adicionalmente, existenopcionescomunes de validación como: allow_nil, allow_blank, message, on
    Pueden ser aplicadas de forma condicional
  • Callbacks – Llamadas de regreso
    Callbacksson métodos que son llamados en ciertos momentos del ciclo de vida de un objeto. Con los callbacks es posible escribir código que se ejecutará cada vez que un objeto de Active Record es creado, salvado, actualizado, eliminado, validado, o cargado desde la base de datos.
    En orden de usarse los callbacks se deben de registrar usando un DSL estilo macro con llamada a un método, es una mejor práctica que dicho método sea privado o protegido
    Adicionalmente los callbackspueden ser relacionales y condicionales
  • Observadores
    Son parecidos a los callbacks pero con la diferencia que son llamadas a código que no es de la responsabilidad directa del modelo.
    Los observadores deben de ser generados y registrados en el config/environment.rb
    Se puedendeclarar de forma explicitacuando un observadorobserva a más de un odelo
  • Interface de Consultas
    Active Record provee un interfaz ORM con métodos finder que permiten pasar argumentos para realizar queries en la base de datos sin necesidad de escribir SQL
    Estos finders son: where, select, group, order, limit, offset, joins, includes, lock, readonly, from. Todosestosmetodos son instancias de ActiveRecord::Relation
  • Interface de Consultas
    Active Record provee un interfaz ORM con métodos finder que permiten pasar argumentos para realizar queries en la base de datos sin necesidad de escribir SQL
    Estos finders son: where, select, group, order, limit, offset, joins, includes, lock, readonly, from. Todosestosmetodos son instancias de ActiveRecord::Relation
  • Consultabásica
    Model.find(options):
    Convertir las opciones suministradas a su equivalente como consulta SQL.
    Disparar la consulta SQL y recuperar los resultados correspondientes de la BD.
    Cree una instancia del objeto Ruby equivalente al modelo correspondiente para cada fila resultante.
    En su caso ejecutar after_findcallbaks
  • ConsultasFrecuentes
    Model.find (primary_key)
    Model.firstModel.last
    Model.find(m,n)
    Finders dinámicos:
    User.find_by_email(“user@ej.com”)
    Item.find_by_done(true)
  • Condiciones
    Client.where(["orders_count = ?", params[:orders]])
    Client.where(["created_at IN (?)", (params[:start_date].to_date)..(params[:end_date].to_date)])
    Client.where({ :locked => true })
  • OrdenyGrupos
    Client.order("created_at")
    Client.order("created_at DESC")
    Client.order("orders_count ASC, created_at DESC")
    Order.group("date(created_at)")
  • FindersDinamicos
    User.find_by_email("user@ex.mx")
    Cada atributo definido en la tabla del modelo puede ser usado para generar un finderdinámico con la sintaxis find_by_
    Existenmásfinders dinámicoscomo: find_all_by_, find_last_by_, find_or_create_by_
  • AREL
    Arel es un álgebra relacional para Ruby:
    Simplifica la generación de consultas SQL
    Se adapta a los diversos RDBMS diferentes.
    Su objetivo es servir de frameworkde frameworks
    Los métodos de Arel son concatenables por lo que se puede definir algo como esto:
    Item.where(:user_id => 3).group("date(created_at)").order("created_at”)
  • Rails3: ActiveRelation – ActiveModel
    ActiveRelation=== AREL
    ActiveModelextraefuncionalidad de ActiveRecordparaquetengauna sola responsabilidad
    ActiveModelpresentauna API que los modelosdeben de cumplir en orden de tenercompatibilidad con los helpers de ActionPack
    ActiveModelpermitequecualquiermodelopuedausar el API de activemodel
  • Scopes (Alcances)
    scope :recent, order("posts.published_at DESC")
    scope :published, lambda {where("posts.published_at IS NOT NULL AND posts.published_at <= ?", Time.zone.now)}
    Paper.recent.published