UNIVERSIDAD LAICA ELOY ALFARO DE MANABÍ

FACULTAD DE CIENCIAS INFORMÁTICAS

ASIGNATURA:

INGENIERIA DE SOFTWARE II

TEMA/TITULO DEL TRABAJO:

“DESARROLLO DE UNA APLICACIÓN WEB USANDO SPRING FRAMEWORK PARA CONOCER SU ENTORNO DE DESARROLLO”

INTEGRANTES EQUIPO:

ALCIVAR ARAY ROSA ANDREA

MERA GUARANDA YANDRY JAVIER

ORTEGA RODRIGUEZ ALEXIS

PALMA GUALE IRVING JOSE

SAMANIEGO MONCAYO ISABEL PATRICIA

VERA BURGOS ELSA PATRICIA

CURSO:

5° NIVEL “B”

PROFESOR:

ING. JORGE PINCAY

MANTA-MANABÍ-ECUADOR

Contenido

CAPITULO I CONTEXTUALIZACIÓN DE LA INVESTIGACIÓN.........................................................2

Introducción.............................................................................................................................2

Presentación del Tema.............................................................................................................2

Objetivos......................................................................................................................................2

Objetivo general.......................................................................................................................2

Objetivos específicos de investigación.....................................................................................2

Objetivos específicos de resolución del problema...................................................................2

Justificación.................................................................................................................................2

CAPITULO II MARCO TEÓRICO REFERENCIAL..............................................................................2

Spring FRAMEWORK.................................................................................................................2

Inyección de dependencias.................................................................................................2

Programación orientada a aspectos....................................................................................2

Módulos de Spring....................................................................................................................2

Otras características spring framework..............................................................................2

CAPITULO III MARCO PROPOSITIVO (PROPUESTA).....................................................................2

Estudio de Viabilidad................................................................................................................2

Introducción.............................................................................................................................2

Descripción de la propuesta.....................................................................................................2

Alcances de la propuesta..........................................................................................................2

Recursos necesarios..................................................................................................................2

Bibliografía..................................................................................................................................2

CAPITULO I CONTEXTUALIZACIÓN DE LA INVESTIGACIÓN

Introducción

La creciente demande de aplicaciones para facilitar la comodidad del usuario a

hecho que diseñadores, ingenieros, fanáticos de la programación y otros profesionales

estén creando aplicaciones para la mejora del trabajo cotidiano de toda clase de

personas.

En la actualidad hay muchas aplicaciones que van desde un pequeño reloj

despertador hasta las aplicaciones que ayudan a las personas preocupadas por su

bienestar incluidos pacientes y médicos.

Muchas aplicaciones actualmente ayudan a médicos a hacer diagnósticos

tempranos, análisis de laboratorio, revisar listados de medicamentos, analizar

imágenes, buscar artículos médicos, y gracias a que estas aplicaciones muchas veces

son fáciles de utilizar por su lenguaje y servicios que ofrecen hacen que cualquier

persona o paciente pueda consultar.

Presentación del Tema

“DESARROLLO DE UNA APLICACIÓN WEB USANDO SPRING FRAMEWORK PARA

CONOCER SU ENTORNO DE DESARROLLO”

Objetivos

Objetivo general

Desarrollo de una aplicación web usando spring framework para

conocer su entorno de desarrollo

Objetivos específicos de investigación Analizar las principales características del Spring Framework.

Conocer las principales características de Spring Framework.

Estudiar los entornos de desarrollo del Framework.

Objetivos específicos de resolución del problema Seleccionar la interface que conformará nuestra aplicación.

Desarrollar la app que permita conocer el uso Spring Framework.

Justificación

Este proyecto está enfocado en proporcionar una aplicación para proporcionar el

conocimiento del desarrollo del Framework, para así saber o conocer sus diferentes entornos

de desarrollo

Utilizaremos tecnología web, brindando así un sistema con tecnología de punta que

permitirá al usuario, al profesional usar sus portales.

El intercambio de información de las páginas web, valiéndose de la tecnología de

internet, ha demostrado tener una movilidad real, lo cual ha dado paso al denominado

internet móvil.

CAPITULO II MARCO TEÓRICO REFERENCIAL

Spring FRAMEWORK

Los framework son soluciones completas que contemplan herramientas de apoyo a la

construcción (ambiente de trabajo o desarrollo) y motores de ejecución (ambiente de

ejecución).

Son conjuntos de librerías (API’s) para desarrollar aplicaciones Web, más librerías para

su ejecución (o motor), y más un conjunto de herramientas para facilitar esta tarea

(debuggers, ambientes de desarrollo como Eclipse, etc).

Por otro lado son tecnologías abiertas, es decir. Funcionan prácticamente sobre

cualquiera HW y Sistema Operativo, y en esta caso si hablamos de aplicaciones Web,

funcionan sobre cualquier Servidor de Aplicaciones conocido (IBM WebSphere, BEA WebLogic,

o JBoss). Y en cuanto a costos prácticamente no hay costos de licencias: Spring, Struts, y

Eclipse no tienen costos de licencias.

En la actualidad el desarrollo de aplicaciones empresariales, aunque es más sencillo ya

que hay muchas herramientas, APIs, y Frameworks; los cuales aunque son opcionales, el

aprender a usarlos nos ayudará a desarrollar nuestras aplicaciones en menos tiempo y a que

estas sean más robustas y contengan menos errores.

También se vuelve un poco más complicado porque nuestras aplicaciones deben ser

capaces de conectarse con otras aplicaciones y servicios. Además, como desarrolladores,

somos los responsables de coordinar cada una de las partes de nuestra aplicación para que

todo funcione correctamente.

Por si no fuera suficiente, debemos tomar en cuenta que debemos darle

mantenimiento a nuestras aplicaciones, y que en algunos casos será necesario que cambiemos

módulos o capas enteras de la misma para mejorarla; como por ejemplo sustituir nuestras

consultas JDBC con Hibernate en los casos en los que sea prudente.

Afortunadamente existen super-frameworks que nos ayudan haciéndose cargo de

todas o casi todas las “complicaciones” mencionadas anteriormente. Spring es el más popular

de estos super-frameworks Java. Nos proporciona varios módulos los cuales abarcan la mayor

parte de las cosas que debemos hacer en cualquiera de las capas de nuestras aplicaciones,

desde plantillas para trabajar con JDBC o invocación de Web Services y JMS, pasando por sus

propias soluciones, ORM o MVC (web), hasta integración con otros frameworks, como Struts 2,

Hibernate, JSF, etc. Todo esto de una forma elegante y haciendo uso de muchos buenos

principios de programación. Además Spring maneja la infraestructura de la aplicación, por lo

que nosotros solo deberemos preocuparnos de la lógica de la misma (y de la configuración de

Spring).

Spring es, como lo definen sus autores, un framework ligero para construir

aplicaciones empresariales. Aunque Spring se encuentra dividido en distintos módulos, cada

uno de los cuales se encarga de partes diferentes de nuestra aplicación, no deja de ser un

monstruo, ya que es tan grande que alguien podría nunca usar todos estos módulos en

aplicaciones pequeñas o medianas; pero en aplicaciones grandes o realmente grandes puede

ahorrarnos mucho trabajo ya que puede coordinar todas las partes de la aplicación. Esta

separación en módulos nos permite usar solo las partes que necesitamos, sin tener la carga de

los que no usemos.

Spring está diseñado para no ser intrusivo, esto significa que no es necesario que

nuestra aplicación extienda o implemente alguna clase o interface de Spring (si no lo

queremos), por lo que nuestro código de lógica quedará libre y completamente reutilizable

para un proyecto sin Spring, o por si debemos quitarlo de una aplicación que ya lo esté usando.

Gracias a esto es posible usar un POJO o un objeto Java para hacer cosas que antes solo podían

hacerse con EJBs. Sin embargo la utilidad de Spring no es solo para el desarrollo de

aplicaciones web, o no solo en el servidor. Cualquier aplicación Java puede beneficiarse del uso

de Spring.

Además, si usamos Spring de la forma correcta (lo cual no es difícil) nuestra aplicación

quedará dividida en capas bien delimitadas, y con buenas prácticas de programación.

El núcleo de Spring está basado en un principio o patrón de diseño llamado Inversión

de Control (IoC por sus siglas en inglés). Las aplicaciones que usan el principio de IoC se basan

en su configuración (que en este caso puede ser en archivos XML o con anotaciones como en

Hibernate) para describir las dependencias entre sus componentes, esto es, los otros objetos

con los que interactúa. En este caso “inversión” significa que la aplicación no controla su

estructura; permite que sea el framework de IoC (en este caso Spring) quien lo haga.

Por ejemplo, supongamos que tenemos una clase “AlmacenUsuario”, que depende de

una instancia de una clase “UsuariosDAO” para realizar su tarea. “AlmacenUsuario” crea una

instancia de “UsuariosDAO” usando el operador “new” u obtiene una de algún tipo de Fabrica.

Usando la técnica de IoC, una instancia de “UsuariosDAO”, o una subclase de esta, es

proporcionada a “AlmacenUsuario” en tiempo de ejecución por el motor de Spring. En este

caso “UsuariosDAO” también podría ser una interface y Spring se encargará de

proporcionarnos una instancia de una clase que implemente esa interface. Esta inyección de

dependencia en tiempo de ejecución ha hecho que a este tipo de IoC se le dé el nombre más

descriptivo de inyección de dependencia (DI por sus siglas en inglés). El concepto importante

es que los componentes no saben cuál implementación concreta de otros componentes están

usando; solo ven sus interfaces.

El uso de interfaces y DI son mutuamente benéficos, ya que hace más flexible y

robusta nuestra aplicación y es mucho más fácil realizar pruebas unitarias. Pero la complejidad

de escribir código que maneje las dependencias entre los componentes de una aplicación

diseñada para usar interfaces puede llegar a ser mucho y esto, además, hace que los

desarrolladores tengamos que escribir aún más código.

Afortunadamente, usando DI reducimos la cantidad de código extra que debemos

escribir, para un diseño basado en interfaces, casi a cero.

En el contexto de DI, Spring actúa como un contenedor que proporciona las instancias

de las clases de nuestra aplicación todas las dependencias que necesita, pero en una forma no

intrusiva y automática. Todo lo que debemos hacer es crear un archivo de configuración que

describa las dependencias; Spring se hará cargo del resto.

Spring es un contenedor ya que no solo crea los componentes de nuestra aplicación,

sino porque contiene y maneja al ciclo de vida y configuración de estos componentes. En

Spring, podemos declarar cómo debe ser creado cada uno de los objetos de nuestra aplicación,

cómo deben ser configurados, y cómo deben asociarse con los demás.

La implementación de DI de Spring se enfoca en el acoplamiento débil: los

componentes de nuestra aplicación deben asumir lo menos posible acerca de otros

componentes. La forma más fácil de lograr este bajo acoplamiento en Java es mediante el uso

de Interfaces. Como cada componente de la aplicación solo está consciente de la interface de

otros componentes, podemos cambiar la implementación del componente sin afectar a los

componentes que usan el nuevo componente.

El uso de DI tiene como beneficios, además de lo que ya he mencionado arriba, los siguientes:

Reduce el código pegamento: Esto quiere decir que reduce dramáticamente la

cantidad de código que debemos escribir para unir los distintos componentes. Aunque

algunas veces esté código puede ser tan simple como usar el operador “new” para

instanciar un nuevo objeto, otras puede ser más complejo, como realizar una

búsqueda de dicha dependencia en un repositorio a través de JNDI, como en el caso de

los recursos remotos. En esto caso, el uso de DI puede reducir de forma dramática la

cantidad de código pegamento (o glue code) proporcionando búsquedas automáticas.

Externaliza dependencias: Como es posible colocar la configuración de dependencias

en archivos XML podemos realizar una reconfiguración fácilmente, sin necesidad de

recompilar nuestro código. Gracias a esto es posible realizar el cambio de la

implementación de una dependencia a otra (como en el ejemplo de Hibernate que

mencioné antes)

Las dependencias se manejan en un solo lugar: Toda la información de dependencias

es responsabilidad de un solo componente, el contenedor de IoC de Spring, haciendo

que este manejo de dependencias más simple y menos propenso a errores.

Hace que las pruebas sean más fáciles: Nuevamente, como nuestras clases serán

diseñadas para que sea fácil el reemplazo de dependencias, podemos proporcionar

mocks o dummies, que regresen datos de prueba, de servicios o cualquier

dependencia que necesite el componente que estamos probando.

Como podemos ver, el uso de DI nos proporciona muchos beneficios, pero no sin sus

correspondientes desventajas. En particular, es difícil ver qué implementación particular de

una dependencia está siendo usada para qué objeto, especialmente para alguien que no está

familiarizado con esta forma de trabajo.

¿Y por qué tanto hablar de DI? Pues porque estos dos conceptos (IoC y DI) son los puntos

centrales alrededor del cual gira todo en Spring, así que es mejor entenderlos desde el

principio.

Spring está dividido en alrededor de 20 módulos y colocados en los siguientes grupos:

Contenedor Central (Core Container)

Acceso a Datos / Integración

WEB

AOP (Programación Orientada a Aspectos)

Instrumentación

Pruebas

Estos grupos se muestran en la siguiente imagen:

En general, estas son algunas de las características de Spring:

Simplificación de la programación orientada a aspectos.

Simplificación del acceso a datos.

Simplificación e integración con JEE

Soporte para planificación de trabajos.

Soporte para envió de mail.

Interacción con lenguajes dinámicos (como BeanShell, JRuby, y Groovy).

Soporte para acceso a componentes remotos.

Manejo de Transacciones.

Su propio framework MVC.

Su propio Web Flow.

Manejo simplificado de excepciones.

La versión 3 de Spring es una versión revisada y mejorada de la versión estable anterior

(2.5), que incluye nuevas características, entre las que se incluyen:

Soporte para Java 5: Proporciona configuración basada en anotaciones y soporta

características como varargs ygenerics, además la parte web es compatible con las

versiones 1.4 y 5 de Java EE. Debido a esta nueva característica, ahora es necesario

tener el JRE versión 5 o superior.

Lenguaje de Expresiones (SpEL): En esta nueva versión se incluye un lenguaje de

expresiones que puede ser usando cuando se definen beans, tanto en XML como con

anotaciones y también da soporte a través de todos los módulos de Spring.

Soporte para Servicios Web REST: Ahora Spring soporte servicios web de tipo REST.

Soporte para Java EE6: Ofrece soporte de características como JPA 2.0, JSF 2.0 y JRS

303 (validaciones de Beans).

Soporte para bases de datos embebidas: Un soporte conveniente para bases de datos

embebidas como HSQL, H2 y Derby.

Soporte para formateo de datos mediante anotaciones: Ahora los campos de fecha,

divisas, etc., serán formateados automáticamente y convertidos usando anotaciones.

Nueva organización de los módulos: Los módulos han sido revisados y separados en

diferentes paquetes, mas organizados, de acuerdo a su funcionalidad. Para que se den

una idea, estos son los nuevos paquetes:

org.springframework.aop

org.springframework.beans

org.springframework.context

org.springframework.context.support

org.springframework.expression

org.springframework.instrument

org.springframework.jdbc

org.springframework.jms

org.springframework.orm

org.springframework.oxm

org.springframework.test

org.springframework.transaction

org.springframework.web

org.springframework.web.portlet

org.springframework.web.servlet

org.springframework.web.struts

Spring es el marco de desarrollo de aplicaciones más populares de la empresa Java ™.

Millones de desarrolladores utilizan la primavera para crear alto rendimiento, fácilmente

comprobable, código reutilizable sin lock-in.

Spring Framework es una plataforma que nos proporciona una infrastuctura que actúa

de soporte para desarrollar aplicaciones Java. Spring maneja toda la infrastructura y así te

puedes centrar en tu aplicación. Diciendolo mas coloquialmente, Spring es el “pegamento” que

une todos los componentes de la aplicación, maneja su ciclo de vida y la interacción entre

ellos.

Spring es un framework para el desarrollo de aplicaciones y contenedor de inversión

de control, de código abierto para la plataforma Java.

Actualmente es muy popular, siendo tomado en cuenta como alternativa o reemplazo

de los Enterprise JavaBean (EJB).

La primera versión fue escrita por Rod Johnson. Fue lanzado inicialmente bajo la

licencia Apache 2.0 en junio de 2003. El primer gran lanzamiento fue la versión 1.0, que

apareció en marzo de 2004.

Si bien las características fundamentales de Spring Framework pueden ser usadas en

cualquier aplicación desarrollada en Java, existen variadas extensiones para la construcción de

aplicaciones web sobre la plataforma Java EE. A pesar que no impone ningún modelo de

programación en particular, este framework se ha vuelto popular en la comunidad al ser

considerado una alternativa, sustituto, e incluso un complemento al modelo EJB (Enterprise

JavaBean).

Spring es un framework liviano y no intrusivo: generalmente los objetos que

programamos no tienen dependencias en clases específicas de Spring. Sus características

principales son inyección de dependencias y programación orientada a aspectos.

Inyección de dependencias

El objetivo es lograr un bajo acoplamiento entre los objetos de nuestra aplicación. Con

este patrón de diseño, los objetos no crean o buscan sus dependencias (objetos con los cuales

colabora) sino que éstas son dadas al objeto. El contenedor (la entidad que coordina cada

objeto en el sistema) es el encargado de realizar este trabajo al momento de instanciar el

objeto. Se invierte la responsabilidad en cuanto a la manera en que un objeto obtiene la

referencia a otro objeto.

De esta manera, los objetos conocen sus dependencias por su interfaz. Así la

dependencia puede ser intercambiada por distintas implementaciones a través del

contenedor. En resumen, programaremos orientado a interfaces e inyectaremos las

implementaciones a través del contenedor.

Programación orientada a aspectos

Se trata de un paradigma de programación que intenta separar las funcionalidades

secundarias de la lógica de negocios. En inglés denominan a estas funcionalidades “cross-

cutting concerns” algo que se traduciría como “preocupaciones transversales”. Por ejemplo los

loggers, la seguridad, el manejo de transacciones, etc., son funcionalidades que atraviesan

nuestro programa en varias abstracciones de éste. Por lo tanto corremos el riesgo de caer en la

repetición de código y el acoplamiento entre nuestra lógica de negocios y la implementación

de los cross-cutting concerns.

La AOP (Aspect-Oriented Programming) busca modularizar estos servicios y aplicarlos

de manera declarativa a los componentes que deban afectar.

Módulos de Spring

Spring Framework comprende diversos módulos que proveen un rango de servicios:

Contenedor de inversión de control : permite la configuración de los componentes de

aplicación y la administración del ciclo de vida de los objetos Java, se lleva a cabo

principalmente a través de la inyección de dependencias.

Programación orientada a aspectos : habilita la implementación de rutinas transversales.

Acceso a datos: se trabaja con RDBMS en la plataforma java, usando Java Database

Connectivity y herramientas de Mapeo objeto relacional con bases de datos NoSQL.

Gestión de transacciones: unifica distintas APIs de gestión y coordina las transacciones

para los objetos Java.

Modelo vista controlador : Un framework basado en HTTP y servlets, que provee

herramientas para la extensión y personalización de aplicaciones web y servicios

web REST.

Framework de acceso remoto: Permite la importación y exportación estilo RPC, de objetos

Java a través de redes que soporten RMI, CORBA y protocolos basados

en HTTP incluyendoservicios web (SOAP).

Convención sobre configuración : el módulo Spring Roo ofrece una solución rápida para el

desarrollo de aplicacionesa basadas en Spring Framework, privilegiando la simplicidad sin

perder flexibilidad.

Procesamiento por lotes : a framework for high-volume processing featuring reusable

functions including registro/trazado, transaction management, job processing statistics,

job restart, skip, and resource management.

Autenticación and Autorización : procesos de seguridad configurables que soportan un

rango de estándares, protocolos, herramientas y prácticas a través del subproyecto Spring

Security (formalmente Acegi Security System for Spring).

Administración Remota : Configuración de visibilidad y gestión de objetos Java para la

configuración local o remota vía JMX.

Mensajes: Registro configurable de objetos receptores de mensajes, para el consumo

transparente desde la a través de JMS, una mejora del envío de mensajes sobre las API

JMS estándar.

Testing : Soporte de clases para desarrollo de unidades de prueba e integración.

El diagrama muestra los módulos con los que cuenta Spring (hasta la versión 2.5). En su

núcleo (Core) se encuentra el BeanFactory – el contenedor fundamental de Spring y quien se

encarga de la inyección de dependencias. El contenedor ApplicationContext se basa en

BeanFactory y extiende su funcionalidad con soporte para i18n, eventos de ciclo de vida,

validación y mejor integración con AOP.

AOP – provee la implementación de AOP, permitiéndonos desarrollar interceptores de

método y puntos de corte para desacoplar el código de las funcionalidades transversales.

DAO - Provee una capa de abstracción sobre JDBC, abstrae el código de acceso a datos

de una manera simple y limpia. Tiene una capa de expeciones sobre los mensajes de error

provistos por cada servidor específico de base de datos. Además cuenta con manejo de

transacciones a través de AOP.

ORM – Provee la integración para las distintas APIs de mapeo objeto-relacional

incluyendo JPA, JDO, Hibernate e iBatis.

JEE – Provee integración con aplicaciones Java Enterprise Edition así como servicios

JMX, JMS, EJB, etc.

Web – Módulo que aporta clases especiales orientadas al desarrollo web e integración

con tecnologías como Struts y JSF. Cuenta con el paquete Spring MVC, una implementación del

conocido patrón de diseño aplicando los principios de Spring.

Otras características spring framework

El Spring Framework ayuda a construir aplicaciones Java más rápido, ya que le permite

centrarse en su problema de negocio en lugar del código de plomería que se conecta

componentes y sistemas. Las características incluyen:

WEB MODERNO

Aplicaciones Web desempeñan un papel crucial en la mayoría de las estrategias de

aplicación hoy en día: una aplicación web es una de las más grandes y mejores vías por las que

la gente consume su aplicación, y una aplicación web es el punto de extensión natural de

vincular clientes móviles o rico para su aplicación. Si Java es el lenguaje de la Web, a

continuación, la primavera es sin duda su marco.

SENCILLEZ

Spring MVC, que es parte del framework Spring core, es la tecnología líder para la

creación de aplicaciones web. Spring MVC proporciona un modelo de componentes limpia que

hace que la construcción escalables y aplicaciones web que son comprobables, y basado en las

mejores prácticas de una brisa. Al adoptar convención sobre configuración, consiguiendo un

Spring MVC aplicación en ejecución puede ser tan simple como un par anotaciones y el registro

de la MVC servlet primavera.

FLEXIBILIDAD

Mientras que es súper simple para empezar, Spring MVC es también muy flexible con

probado y verdadero soporte para todo tipo de casos de uso de la seguridad de la

administración de sesiones, la manipulación formulario y validación de la gestión de diseño.

Spring MVC también sirve como base para el Flujo de la primavera Web , que proporciona una

forma limpia para gestionar la navegación del mago-estilo en una aplicación web, y la

primavera de Flex , que proporciona la forma más fácil y más potente para crear aplicaciones

RIA basadas en Flex de Adobe.

DATA ACCESS

Spring proporciona apoyo declarativo, anotación impulsada por preocupaciones

transversales como las transacciones y almacenamiento en caché. Spring también proporciona

objetos convenientes de la plantilla que reducen las interacciones API con la mayoría de los

almacenes de datos de una sola línea. Estos objetos de la plantilla le permiten centrarse en la

tarea a mano y de forma transparente a cuidar de las tareas típicas de código repetitivo de las

tecnologías de acceso a datos, como la adquisición de la conexión, la creación de sesiones y las

preocupaciones de concurrencia.

Spring también proporciona una API unificada que desacopla el almacenamiento en

caché de la elección de la tecnología de persistencia (en comparación con otras soluciones de

persistencia que apoyan la tecnología específica para los idiomas caché común como escritura

simultánea y la lectura a través).

INTEGRACIÓN

Spring ofrece un amplio soporte para la integración exige a las aplicaciones de hoy en

día, proporcionando un modelo simple para la construcción de soluciones de integración

empresarial, manteniendo la separación de intereses que es esencial para producir

mantenible, código comprobable.

Soluciones de integración de Spring ligeros, probadas en el campo incluyen:

Integración de Spring para la construcción asíncronos, aplicaciones orientadas a eventos (y

para la integración con los marcos de RPC si eso es más su estilo), Spring Batch para la lectura y

escritura de forma fiable grandes cantidades de datos, y Spring Web Servicios para interoperar

con los servicios web basados en SOAP, contrato a primera.

MOBILE

El mundo está cambiando. Más personas consumen Internet a través de sus

dispositivos móviles de hoy en día que a través de sus navegadores de escritorio. Su negocio

no puede permitirse el lujo de ignorar este nuevo mundo, móvil y con el framework Spring.

Soporte móvil de Spring es de múltiples facetas. Spring MVC y Spring Mobile hacen entrega

condicional vistas móviles específicas del cliente en un instante. Este enfoque es muy potente

y es la forma más fácil de mobile-habilitación mayoría de las aplicaciones web construidas

sobre Spring MVC.

Sin embargo, usted puede (y debe) dar un paso más allá: Spring MVC proporciona

soporte REST rico, que puede ser utilizado como la unión entre un cliente móvil puro y la

aplicación de fondo desplegado en el servidor. Todos los clientes móviles - ya sea J2ME,

Windows Phone 7, Blackberry, Android o iOS - apoyo a la comunicación RESTful. Además, las

plataformas que proporcionan una plataforma de aplicaciones centradas en HTML 5 pueden

aprovechar estos servicios REST con facilidad directamente desde HTML5 y el Ajax. Si usted

está construyendo las aplicaciones de Android, en particular, el proyecto Android Spring

proporciona una versión compatible con Android ligero del cliente de REST, la RestTemplate ,

que se incluye con el framework Spring core.

SOCIAL

El Spring Social Proyect proporciona la conectividad y el marco de la autorización para

interactuar con todo tipo de API de proveedor de servicios, como Facebook, Twitter, Google+,

LinkedIn, y muchos, muchos más. Spring Social puede ayudarle a conectar su solicitud si usted

está construyendo una aplicación de escritorio, un Android o aplicaciones móviles o una

aplicación web.

Los proveedores de servicios de hoy por lo general exponen su API que utilizan OAuth.

OAuth a su vez cuenta con dos versiones, versión 1 y 2, y cada versión tiene varios proyectos

de especificaciones que se adhieren libremente de varias APIs. Spring Social ofrece la más

suave, paseo más constante posible para los desarrolladores que buscan aprovechar estas API,

a pesar de todas estas especificaciones inconsistente.

SEGURIDAD

Spring Security proporciona el marco de seguridad más robusta disponible para los

desarrolladores de Java de la empresa hoy en día. Spring Security proporciona SPI enchufables

para gestionar la autorización y la autenticación con numerosas implementaciones prácticas

previstas fuera de la caja. Spring Security integra sistemáticamente con todas las tecnologías

de primavera, incluyendo Spring MVC, Integración Spring, Web Spring Services, y la Spring de

Flex. Ya sea que usted está tratando de auditar los mensajes a medida que viajan a través de

un flujo de integración, acordonar parte de la aplicación web de los visitantes no deseados, o

impiden la invocación de métodos de la API de hilos no autorizados, Spring Security, sin duda,

tiene algo que ofrecer.

CLOUD READY

Spring elimina la costra repetitiva en el típico Java empresarial, y una nube utilidad

tiene el potencial de eliminar el mismo peso muerto de su infraestructura.

Spring funciona de forma fiable y consistente en todos los proveedores de la

plataforma-como-un-servicio, incluyendo el líder de la industria Cloud Foundry , Beanstalk

Amazon Web Services, y App Engine de Google, entre muchos otros. La mayoría de ofertas de

PaaS varían en las tecnologías compatibles, pero tienen siempre un servidor de aplicaciones

ligeras como Apache Tomcat o embarcadero en el centro de sus tiempos de ejecución. Al

generar la aplicación en primavera, puede aprovechar la modularidad y la agilidad que estas

ofertas de PaaS ofrecen.

Mientras que las aplicaciones de Spring se pueden hacer fácilmente para trabajar con

casi cualquier PaaS por ahí (incluso en Google App Engine, que ofrece un subconjunto muy

restrictiva de la típica JDK!), Goza de un lugar en el sol en Cloud Foundry. Una aplicación típica

Spring requerirá ningún cambio en empezar a trabajar en CloudFoundry y, una vez allí,

pueden aprovechar los almacenes de datos best-of-breed como PostgreSQL, MySQL, MongoDB

o Redis y RabbitMQ, el intermediario de mensajes de liderazgo en la nube.

__

CAPITULO III MARCO PROPOSITIVO (PROPUESTA)

Estudio de Viabilidad

Introducción

Analizando el ritmo laboral de los profesionales en nuestro medio, pudimos identificar

que el medico requiere coordinar de una manera su tiempo, para lo cual necesita la

información de pacientes y de sus citas médicas, por esta razón nuestra propuesta está

orientada para las personas involucradas en el área de salud.

Los médicos están en constante actividad y con agendas ocupadas, con el afán de

desarrollar una aplicación con el framework Spring pensamos en un sistema que les facilite la

comunicación con los puntos médicos, consultorios u hospitales y de esta manera el medico

pueda gestionar de mejor manera sus actividades laborales.

Actualmente las personas que administran la atención médica recurren a los mensajes

a redes sociales, correo electrónico, SMS o llamadas a celular, para esto con un teléfono

convencional o celular a la mano para poder comunicarse con el médico.

__

Descripción de la propuesta

Hoy por hoy vivimos en una era donde es importante tener el acceso oportuno y veraz

de la información, la misma que nos permite alcanzar la eficiencia en el servicio a nuestros

clientes. Nuestro producto se enfoca en satisfacer esa necesidad al profesional médico, que le

permite la facilidad en la administración de su jornada laboral.

El profesional médico puede tener acceso a sus citas programadas, observaciones,

fichas médicas, alergias, etc. Pero lo más importante es que nuestra aplicación le permite

visualizar esta información desde cualquier lugar que se encuentre, en el momento oportuno

en que la requiere.

Supongamos que muy temprano por la mañana un paciente llama a su médico tratante

y le dice que se siente mal, que no soporta el dolor de cabeza, que no puede esperar a la cita

que tiene en la tarde, entonces el medico (que no recuerda los antecedentes del paciente y

además que se encuentra fuera de la ciudad) consulta la ficha clínica del paciente, lo cual le

ayuda a prescribir la medicina apropiada para disminuir el dolor hasta la tarde que le toca la

consulta.

Esta aplicación ha sido desarrollada bajo una arquitectura orientada a la web,

multiusuario, framework Spring, el entorno Eclipse, con una interfaz muy amigable y sencilla.

____

Alcances de la propuesta

Nuestra aplicación está enfocada en proporcionar una administración de citas médicas

y la consulta del historial médico de un paciente utilizando la tecnología de Internet, para así

disponer de información veraz y oportuna, sobre las citas y fichas medicas de los pacientes

desde cualquier lado que se encuentre el médico, con la ayuda de una secretaria o asistente

que pueda gestionar eficientemente la información vía Web.

Utilizaremos una conexión vía web desarrollado con un framework Spring en el

entorno Eclipse, brindando así un sistema con tecnología de punta que permita al profesional

utilizar sus equipos portátiles.

El uso de web incrementa la posibilidad de intercambiar información, pero también

aumenta la posibilidad de ataques a la misma, por lo que el proteger los datos es una

necesidad prioritaria, ya que al ser el aire el medio por el cual viaja la información cualquier

persona está en posibilidad de alterarla y/o robarla, por lo que es necesario proveer seguridad

que permita proteger la información y así satisfacer las demandas de seguridad de los

usuarios.

__

Recursos necesarios

Mantenemos bien en claro que estos recursos son un conjunto de personas, bienes

materiales, financiero y técnico con que cuenta y utiliza una dependencia, entidad, u

organización para alcanzar sus objetivos y producir los bienes o servicios que son de su

competencia.

Humanos

Para nuestro proyecto contamos con el recurso humano de los interesados en llevar a

cabo esta investigación, es decir, los Integrantes y los Naturales:

Integrantes:

Mera Guaranda Yandry Xavier

Ortega Rodríguez Alexis Iván

Palma Guale Irving José

Samaniego Moncayo Isabel

Vera Burgos Elsa Patricia

Naturales:

Ing. Jorge Pincay Docente de la Materia

Médicos

Materiales

Los materiales a considerarlos útiles para esta investigación son los siguientes:

Hojas, Esferos, lápices, calculadora, borrador, etc.

Computadora de escritorio, laptop.

Impresora

Cámara fotográfica

Tecnológicos

Uso del computador

Uso de impresora

Flash Memory

Herramientas para el desarrollo de aplicaciones en Android

o Eclipse IDE

o Android SDK

o JDK

o ADT-20.0.3

Equipamiento

Los equipamientos son los que nos van a permitir realizar reuniones grupales con el fin

de recopilar información.

Transporte

Internet

Teléfono

Luz

__

Bibliografía

Información y definiciones.

http://www.enter.co/saluddigital/5-aplicaciones-moviles-para-monitorear-y-mejorar-su-salud/

http://es.wikipedia.org/wiki/Factibilidad http://prezi.com/cn49srobn9dy/factibilidad-operacional-economica-tecnica-y-legal-

de-los-sistemas/

http://www.trabajo.com.mx/factibilidad_tecnica_economica_y_financiera.htm