1. 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

2. Introducción .............................................................................................................................. 3
Presentación del Tema.............................................................................................................. 4
Objetivos....................................................................................................................................... 4
Objetivo general........................................................................................................................ 5
Objetivos específicos de investigación...................................................................................... 5
Objetivos específicos de resolución del problema.................................................................... 5
Justificación................................................................................................................................... 6
CAPITULO II MARCO TEÓRICO REFERENCIAL............................................................................... 7
Spring FRAMEWORK.................................................................................................................. 7
Inyección de dependencias ................................................................................................ 14
Programación orientada a aspectos .................................................................................. 14
Módulos de Spring................................................................................................................... 14
Otras características spring framework ............................................................................ 17
CAPITULO III MARCO PROPOSITIVO (PROPUESTA)................................................................... 21
Estudio de Viabilidad............................................................................................................... 21
Introducción ............................................................................................................................ 21
Descripción de la propuesta .................................................................................................... 22
Alcances de la propuesta......................................................................................................... 23
Recursos necesarios................................................................................................................. 24
Bibliografía ................................................................................................................................. 26
CAPITULO I CONTEXTUALIZACIÓN DE LA INVESTIGACIÓN

3. 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.

4. Presentación del Tema
“DESARROLLO DE UNA APLICACIÓN WEB USANDO SPRING FRAMEWORK PARA
CONOCER SU ENTORNO DE DESARROLLO”
Objetivos

5. 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.

6. 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.

7. 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

8. 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.

9. 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.

10. 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

11. 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

12. 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

13.  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).

14. 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.

15. 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.

16. 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.

17. 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.

18. 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.

19. 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.

20. 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.

21. __
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.

22. __
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.

23. ____
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.

24. __
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

25.  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

26. __
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