Professional Documents
Culture Documents
FACULTAD DE INGENIERIA
ESTRUCTURAS DE DATOS
INVESTIGACION:
INTRODUCCION
Esta investigacin le proporciona la informacion sobre los diferentes tipos de servicios
web mas usados asi como las definiciones correspondientes a estos. Asi tambin la
forma en que PHP y Java aplican el MVC(Modelo, Vista, Controlador) definiciones y
ejemplos.
SERVIDOR WEB
Es una maquina informtica que suministra de informacin a otros ordenadores
llamados clientes. Un ejemplo general es el internet, son computadoras conectadas
entre si que se envan datos una a la otra. La mayora de las paginas como youtube
tiene sus ordenadores, donde alojan toda la informacion que se le enva al cliente, una
persona que entra a la pagina y pide ver un video, el servidor le manda los datos.
En la actualidad existen diferentes tipos de servidores web, cada uno de acuerdo a las
necesidades del cliente. En resumen una mquina servidora que se comunica con
variados clientes, todos demandando algn tipo de informacin. Esta informacin
puede ser desde archivos de texto, video, audio, imgenes, emails, aplicaciones,
programas, consultas a base de datos, etc.
La forma en que funciona es que conserva las pginas web en la cach, para que
cuando un usuario enva una peticin para acceder a una pgina Web que esta
almacenada en la cach, la respuesta y el tiempo de visualizacin sea ms rpido.
Aumentan la seguridad ya que pueden filtrar cierto contenido Web y programas
maliciosos.
DNS: El servicio de DNS permite, una vez configurado, que tu web y tu correo
electrnico sean localizados desde cualquier lugar del mundo mediante tu nombre de
dominio. Domain Name System: Es una base de datos distribuida, con informacin
que se usa para traducir los nombres de dominio, fciles de recordar y usar por las
personas, en nmeros de protocolo de Internet (IP) que es la forma en la que las
mquinas pueden encontrarse en Internet. El servicio de DNS es indispensable para
que un nombre de dominio pueda ser encontrado en Internet.
TIPOS DE SERVIDORES
SERVIDOR DE CORREO: Un servidor de correo es una aplicacin informtica que
tiene como objetivo, enviar, recibir y gestionar mensajes a travs de las redes de
transmisin de datos existentes, con el fin de que los usuarios puedan mantenerse
comunicados con una velocidad muy superior a la que ofrecen otros medios de envo
de documentos.
Los servidores de correo trabajan como una agencia de correo postal, slo que no
envan paquetes, sino, datos digitales e informacin electrnica, la cual llega a su
destino de forma casi inmediata.
SERVIDOR PROXY:
Un Servidor proxy permite a otros equipos conectarse a una red de forma indirecta a
travs de l. Cuando un equipo de la red desea acceder a una informacin o recurso,
es realmente el proxy quien realiza la comunicacin y a continuacin traslada el
resultado al equipo inicial.
Ventajas:
En general, los proxies hacen posibles varias cosas nuevas:
Control: slo el intermediario hace el trabajo real, por tanto se pueden limitar y
restringir los derechos de los usuarios, y dar permisos slo al proxy.
Ahorro. Por tanto, slo uno de los usuarios (el proxy) ha de estar equipado
para hacer el trabajo real.
Velocidad. Si varios clientes van a pedir el mismo recurso, el proxy puede
hacer cach: guardar la respuesta de una peticin para darla directamente
cuando otro usuario la pida. As no tiene que volver a contactar con el destino,
y acaba ms rpido.
Filtrado. El proxy puede negarse a responder algunas peticiones si detecta
que estn prohibidas.
Modificacin. Como intermediario que es, un proxy puede falsificar
informacin, o modificarla siguiendo un algoritmo.
Anonimato. Si todos lo usuarios se identifican como uno slo, es difcil que el
recurso accedido pueda diferenciarlos. Pero esto puede ser malo, por ejemplo
cuando hay que hacer necesariamente la identificacin.
Hay algo de esfuerzo necesario para aprender a utilizar un marco MVC en php. Sin
embargo, para el desarrollador de aplicaciones Web grandes, este esfuerzo debe ser
recompensado por los numerosos beneficios de utilizar un patrn de diseo MVC,
tales como:
Ejemplos:
Vemos un ejemplo para montar un simple listado presentado en una tabla HTML, bajo
el modelo de tres capas.
En primer lugar creamos un index.php que ser la forma de acceder al sistema. En
este caso no realiza otra tarea, slo incluir e iniciar el FrontController.
< ?php
//Incluimos el FrontController
require 'libs/FrontController.php';
//Lo iniciamos con su mtodo esttico main.
FrontController::main();
?>
//Lo mismo sucede con las acciones, si no hay accin, tomamos index como
accin
if(! empty($_GET['accion']))
$actionName = $_GET['accion'];
else
$actionName = "index";
$controllerPath = $config->get('controllersFolder') . $controllerName .
'.php';
//Incluimos el fichero que contiene nuestra clase controladora solicitada
if(is_file($controllerPath))
require $controllerPath;
else
die('El controlador no existe - 404 not found');
//Si no existe la clase que buscamos y su accin, mostramos un error 404
if (is_callable(array($controllerName, $actionName)) == false)
{
trigger_error ($controllerName . '->' . $actionName . '` no existe',
E_USER_NOTICE);
return false;
}
//Si todo esta bien, creamos una instancia del controlador y llamamos a
la accin
$controller = new $controllerName();
$controller->$actionName();
}
}
?>
Conformamos una pequea clase que nos sirva de motor de plantillas. No tiene
muchas funcionalidades, slo las necesarias para incluir una plantilla y asignarle
variables. Para ello creamos libs/View.php .
< ?php
class View
{
function __construct()
{
}
public function show($name, $vars = array())
{
//$name es el nombre de nuestra plantilla, por ej, listado.php
//$vars es el contenedor de nuestras variables, es un arreglo del tipo
llave => valor, opcional.
//Traemos una instancia de nuestra clase de configuracion.
$config = Config::singleton();
//Armamos la ruta a la plantilla
Ahora creamos una clase SPDO (es una clase que extiende de PDO). Su nica
ventaja es que nos permite aplicar el patrn Singleton para mantener una nica
instancia de PDO
< ?php
class SPDO extends PDO
{
private static $instance = null;
public function __construct()
{
$config = Config::singleton();
parent::__construct('mysql:host=' . $config->get('dbhost') . ';dbname=' .
$config->get('dbname'),
$config->get('dbuser'), $config->get('dbpass'));
}
public static function singleton()
{
if( self::$instance == null )
{
self::$instance = new self();
}
return self::$instance;
}
}
?>
Creamos una clase modelo que cubre las necesidades funcionales del desarrollo
mediante una clase. Usamos PDO (esta vez a travs de SPDO) para el acceso a
datos.
< ?php
class ItemsModel
{
protected $db;
public function __construct()
{
//Traemos la nica instancia de PDO
$this->db = SPDO::singleton();
}
public function listadoTotal()
{
//realizamos la consulta de todos los items
$consulta = $this->db->prepare('SELECT * FROM items');
$consulta->execute();
//devolvemos la coleccin para que la vista la presente.
return $consulta;
}
}
?>
Se crean los controladores. Se hace uso de la clase View para asignar variables y
presentar la plantilla.
< ?php
class ItemsController
{
function __construct()
{
//Creamos una instancia de nuestro mini motor de plantillas
$this->view = new View();
}
public function listar()
{
//Incluye el modelo que corresponde
require 'models/ItemsModel.php';
//Creamos una instancia de nuestro "modelo"
$items = new ItemsModel();
//Le pedimos al modelo todos los items
$listado = $items->listadoTotal();
//Pasamos a la vista toda la informacin que se desea representar
$data['listado'] = $listado;
//Finalmente presentamos nuestra plantilla
$this->view->show("listar.php", $data);
}
public function agregar()
{
echo 'Aqu incluiremos nuestro formulario para insertar items';
}
}
?>
< ?php
class Config
{
private $vars;
private static $instance;
private function __construct()
{
$this->vars = array();
}
//Con set vamos guardando nuestras variables.
public function set($name, $value)
{
if(!isset($this->vars[$name]))
{
$this->vars[$name] = $value;
}
}
//Con get('nombre_de_la_variable') recuperamos un valor.
public function get($name)
{
if(isset($this->vars[$name]))
{
return $this->vars[$name];
}
}
public static function singleton()
{
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;
}
return self::$instance;
}
}
/*
Uso:
$config = Config::singleton();
$config->set('nombre', 'Federico');
echo $config->get('nombre');
$config2 = Config::singleton();
echo $config2->get('nombre');
*/
?>
'localhost');
'pruebas');
'root');
'');
MVC EN JAVA
Un ejemplo:
Se solicita desarrollar un sistema de administracin de usuarios con un CRUD(Create,
Read, Update, Delete) bsico nos advierten que la aplicacin es un prototipo inicial el
cual esta propenso a cambios, pues an no se tienen definidas las ventanas con las
que se va a trabajar ni la informacin requerida, por le momento se trabajar con una
BD MySql, pero posiblemente se tenga que migrar a otro sistema gestor.
La solucin.
Se aplica el MVC permitiendo independizar la lgica y la parte visual del sistema
usando para eso un controlador que administra los procesos sirviendo como puente
entre estos.