Escolar Documentos
Profissional Documentos
Cultura Documentos
a) Singleton
El patrn Singleton se implementa mediante una clase con un constructor privado.
Existir un mtodo que crear una instancia del objeto llamando al constructor slo
si todava no existe ninguna.
Ejemplo:
// Patrones auxiliares de acceso a datos.
(Singleton)
b) Fachada
Como su propia traduccin indica, este patrn acta de Fachada. Lo que
conseguimos es abstraer una capa de otra, de forma que si una capa cambia no hace
falta cambiar la otra.
Cuando iniciamos nuestra aplicacin se seleccionara la fachada o facade que
queremos con la que funciones nuestra aplicacin un ejemplo de su utilizacin es
cuando una empresa dispone de MySQL y otra en SQL SERVER no se tiene que
cambiar toda la aplicacin sino implementar las fachadas distintas y cargar la que se
quiere utilizar al principio de la ejecucin.
Ejemplo:
// Patrones auxiliares de acceso a datos (Facade).
public class UsersFacade {
public User loginUser(String userName, String password, Integer
company_id) throws Exception {
UsersDAO usersDAO = new UsersDAO();
User user = usersDAO.getUserByLoginPassword(userName,
password, company_id);
return user;
}
public User loadUser(int id) throws Exception{
UsersDAO usersDAO = new UsersDAO();
User user = usersDAO.getUserById(id);
return user;
}
//Uso de la Fachada
UsersFacade uf = new UsersFacade();
uf.loadUser(this.view.getSelectedUser().getUserId());
c) Factory
Este patrn proporciona un objeto factora abstracta de DAOs (Abstract Factory) que puede
construir varios tipos de factoras concretas de DAOs, cada factora soporta un tipo
diferente de implementacin del almacenamiento persistente. Una vez que obtenemos la
factora concreta de DAOs para una implementacin especfica, la utilizamos para producir
los DAOs soportados e implementados en esa implementacin.
Ejemplo:
// Patrones auxiliares de acceso a datos (Factory).
public abstract class DAOFactory {
public static final int CLOUDSCAPE = 1;
public static final int ORACLE = 2;
public static final int SYBASE = 3;
public abstract CustomerDAO getCustomerDAO();
public abstract AccountDAO getAccountDAO();
public abstract OrderDAO getOrderDAO();
public static DAOFactory getDAOFactory(
int whichFactory) {
switch (whichFactory) {
case CLOUDSCAPE:
return new CloudscapeDAOFactory();
case ORACLE
:
return new OracleDAOFactory();
case SYBASE
:
return new SybaseDAOFactory();
default
:
return null;
}
}
}
//Clase CloudscapeDAOFactory
public class CloudscapeDAOFactory extends DAOFactory {
public static final String
DRIVER="COM.cloudscape.core.RmiJdbcDriver";
public static final String
DBURL="jdbc:cloudscape:rmi://localhost:1099/CoreJ2EEDB";
public static Connection createConnection() {
}
public CustomerDAO getCustomerDAO() {
return new CloudscapeCustomerDAO();
}
public AccountDAO getAccountDAO() {
return new CloudscapeAccountDAO();
}
public OrderDAO getOrderDAO() {
return new CloudscapeOrderDAO();
}
}
package activejdbc.examples.simple;
import org.javalite.activejdbc.Base;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SimpleExample {
final static Logger logger =
LoggerFactory.getLogger(SimpleExample.class);
public static void main(String[] args) {
Base.open("com.mysql.jdbc.Driver", "jdbc:mysql://localhost/test",
"root", "p@ssw0rd");
createEmployee();
logger.info("=========>
selectEmployee();
updateEmployee();
logger.info("=========>
selectAllEmployees();
deleteEmployee();
logger.info("=========>
selectAllEmployees();
createEmployee();
logger.info("=========>
selectEmployee();
deleteAllEmployees();
logger.info("=========>
selectAllEmployees();
Created employee:");
Updated employee:");
Deleted employee:");
Created employee:");
Deleted all employees:");
Base.close();
}
private static void createEmployee() {
Employee e = new Employee();
e.set("first_name", "John");
e.set("last_name", "Doe");
e.saveIt();
}
private static void selectEmployee() {
Employee e = Employee.findFirst("first_name = ?", "John");
logger.info(e.toString());
}
private static void updateEmployee() {
Employee e = Employee.findFirst("first_name = ?", "John");
e.set("last_name", "Steinbeck").saveIt();
}
private static void deleteEmployee() {
Employee e = Employee.findFirst("first_name = ?", "John");
e.delete();
}
private static void deleteAllEmployees() {
Employee.deleteAll();
}
subyacente (es decir, ADO.NET) y proporciona una sencilla interfaz de programacin para
recuperar y operar en los datos.
Ejemplo:
public class Customer
{
/* Data members */
private string
m_strConnection = "";
the data accessor object to access database
private System.Data.DataRow drCustomer
= null;
// Used by
/* Constructors */
public Customer()
{
// Acquire the connection string from a connection-string
factory-object
m_strConnection = ConnectionStringFactory.GetConnectionString();
}
/* Data access methods */
public System.Data.DataRow GetCustomer( int nID )
{
// Use data access helper components to retrieve customer data
via a stored procedure
drCustomer = ...
// Return customer information
return drCustomer;
}
public int CreateCustomer( string strName, string DateTime dtDOB )
{
// Use data access helper components to create a new customer
entry in the database
// and return customer ID
}
public void DeleteCustomer( int nCustomerID )
{
// Use data access helper components to delete customer from the
database
}
public void UpdateCustomer( DataRow drCustomer )
{
// Use data access helper components to update customer in the
database
}
/* Properties */
public string
Name
{ get { return
(string)drCustomer["Name"]; }
public DateTime
MemberSince { get { return
(DateTime)drCustomer["RegistrationDate"]; }
public bool
IsActive
{ get { return
(bool)drCustomer["Active"]; } }
c) DAO
Un objeto de acceso a datos (DAO) es un objeto que proporciona una interfaz abstracta a
algn tipo de otro mecanismo de persistencia de base de datos. Por su aplicacin en mapeo,
esta llama a la capa de persistencia, DAO proporciona algunas operaciones de datos
especficos sin exponer a los detalles de la base de datos. Este aislamiento es compatible
con el principio de una sola responsabilidad. Separa qu datos accede a las necesidades de
la aplicacin, en trminos de objetos especficos del dominio y tipos de datos (la interfaz
pblica de la DAO), de cmo estas necesidades pueden ser satisfechas con un DBMS
especfico, esquema de base de datos, etc.
Ejemplo:
Un ejemplo muy comn de DAO se encuentra dentro del marco de trabajo de J2EE que
frecuenta utilizar mucho est Patrn para el acceso a datos. Un ejemplo muy comn en
J2EE es el siguiente Codigo.
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private
private
private
private
int userId;
String name;
String designation;
int age;
Lo siguiente es implementar una clase con la interface creada, el cual nos permitir definir
las operaciones usando DAO
public class UserDAOImpl implements UserDAO {
@Override
public void delete(int userId) {
// delete user from user table
}
@Override
public User[] findAll() {
// get a list of all users from user table
return null;
}
@Override
public User findByKey(int userId) {
// get a user information if we supply unique userid
return null;
}
@Override
public void insert(User user) {
// insert user into user table
}
@Override
public void update(User user) {
// update user information in user table
}
d) Data Accesor
Encapsula acceso a datos fsicos en componentes separados, exponiendo solamente sus
operaciones lgicas. El cdigo de la aplicacin se encuentra desacoplado de las operaciones
de acceso a datos.
sese este patrn cuando:
Ejemplo:
/* IDataAccessor interface declaration. Each logical operation (i.e.,
ExecuteNonQuery) supports single and multiple SQL statements */
public interface IDataAccessor
{
// ExecuteNonQuery
Int32
ExecuteNonQuery(String strCS, CommandType cmdType, String
strCommandText );
Int32[] ExecuteNonQuery(String strCS, CommandType[] acmdType,
String[] astrCommandText );
// ExecuteDataset
DataSet
ExecuteDataset(String strCS, CommandType cmdType, String
strCommandText );
DataSet[] ExecuteDataset(String strCS, CommandType[] acmdType,
String[] astrCommandText );
// ExecuteDataReader
IDataReader
ExecuteDataReader(String strCS, CommandType cmdType,
String strCommandText );
...
Ejemplo en C#
En este ejemplo, el DomainObjectAssembler interactua directamente con la base de datos
usando ADO.NET representa selecciones utilizando la clusula SQL WHERE mientras que
las operaciones de actualizacin se representan utilizando mapas (hashtable) que contienen
los nombres y valores de las columnas para actualizar.
/* When a client initializes a DomainObjectAssember, it is responsible
for plugging in specific factory implementations, a database connection
string, and the name of the table where data resides */
public class Assembler
{
// Data members
private string
strConnection = "";
private string
strTableName = "";
private ISelectionFactory
obSelectionFactory = null;
private IUpdateFactory
obUpdateFactory = null;
private IDomainObjectFactory
obDomainObjectFactory = null;
// Save parameters
public Assembler(string conn, string table, ISelectionFactory sel,
IUpdateFactory upd, IDomainObjectFactory dof)
strConnection
strTableName
obSelectionFactory
obUpdateFactory
obDomainObjectFactory
=
=
=
=
=
conn;
table;
sel;
upd;
dof;
// Public interface
// Read domain objects that correspond to the given identity object
public ArrayList Read(object obIdentity)
{
// Get the selection clause
string strWhereClause =
obSelectionFactory.NewSelection( obIdentity );;
// Execute query against database
string strSQL = "select * from " + strTableName + strWhereClause;
DataTable dt = ExecuteSQL( strSQL );
// Iterate through the result set and create a domain object for
each row
ExecuteSQL( strSQL );
}
// Delete domain objects that correspond to the given identity object
public void Delete(object obIdentity)
{
// Get the selection clause and construct a DELETE statement
string strWhereClause =
obSelectionFactory.NewSelection( obIdentity );
string strSQL = "DELETE from T " + strWhereClause;
// Issue the delete statement
ExecuteSQL( strSQL );
}
// Helper
private DataTable ExecuteSQL( string str ) { ... }
}
Las clases que siguen definir las implementaciones de fbrica que se conectan a una
instancia DomainObjectAssembler para requisitos particulares para mapeo DepositAccount
y DepositAccountKey casos a los contenidos de la tabla [DEPOSIT_ACCOUNT]. En
conjunto, estas tres clases forman una sola extensin de marco de la
DomainObjectAssmbler:
public interface ISelectionFactory
{
string NewSelection ( object obIdentityObject );
}
public interface IUpdateFactory
{
Hashtable NewUpdate ( object obIdentityObject );
}
public interface IDomainObjectFactory
{
ArrayList GetColumnNames();
object NewDomainObject( DataRow row );
}
// This class implements ISelectionFactory and is responsible for
translating a DepositAccountKey
// identity object to a physical selection in the form of a SQL WHERE
clause
public class DepositAccountSelectionFactory : ISelectionFactory
{
// ISelectionFactory implementation
public string NewSelection ( object obIdentityObject )
{
// Get the deposit account key object
DepositAccountKey key = (DepositAccountKey)obIdentityObject;
StringBuilder sb = new StringBuilder();
sb.AppendFormat( " WHERE EMPLOYEE_ID = {0} and ACCOUNT_ID = {1}",
key.EmployeeID, key.AccountID );
return sb.ToString();
}
}
}
return map;
assembler.Delete( ob );
Referencias consultadas