Download Tema II. Programacion Java. Presentación

Tema II
Desarrollo con Java
(Parte 1)
Temas Selectos de Computo
Cibernetica 912
Agosto-Noviembre 2005
Repaso de Programacion orientada
a objetos
• Encapsulamiento. Permite generar modulos
autonomos de software con funcionalidad y
ocultando los detalles de implantacion.
• Herencia. Permite basar una clase nueva en la
definicion de una clase existente.
• Polimorfismo. Permite que un solo nombre de
clase o de metodo represente diferente codigo
seleccionado mediante un mecanismo
automatico.
Programacion orientada a
objetos con Java
Encapsulamiento
public class Bean {
private String mensaje;
public String getMensaje(){
return mensaje;
}
public void setMensaje(String
unMensaje){
mensaje=unMensaje;
}
public String duplicar(){
return mensaje + mensaje;
}
}
Polimorfismo
Herencia
public class SubmitBikeAction extends BaseAction {
public ActionForward execute(
ActionMapping mapping,ActionForm form,
HttpServletRequest request, HttpServletResponse
response)
throws java.lang.Exception {
EditBikeForm editBikeForm = (EditBikeForm) form;
Bike bike = new Bike( );
bike.setManufacturer(editBikeForm.getManufacturer());
bike.setModel(editBikeForm.getModel( ));
bike.setFrame(editBikeForm.getFrame( ));
bike.setSerialNo(editBikeForm.getSerialNo( ));
bike.setWeight(editBikeForm.getWeight( ));
}
}
public class SubmitBikeController implements Controller {
public ModelAndView handleRequest(HttpServletRequest
request,HttpServletResponse response) throws Exception {
return new ModelAndView("bikes.jsp", "rentaBike",facade);
}
}
Dependencia
•
•
•
•
El objeto fachada
RentaBicicleta crea a
las bicicletas de la
tienda. Cuando una
nueva bicicleta llegue,
se tiene que modificar
al codigo.
La clase
VistaLineaComando y
RentaBicicleta estan
fuertemente
acoplados.
La clase RentaBicicleta
se identifica como un
servicio.
El servicio es
invocado por los
componentes de la
interfase de usuario
0...*
Bicicleta
bicicletas
1
RentaBicicleta
+getBicicletas(): List
1
1
VistaLineaComando
:VistaLineaComando
:RentaBicicleta
:Bicicleta
main
new
getBicicletas
new
Desacoplamiento
Para lograr el desacoplamiento se debe realizar lo siguiente:
•Declarar al servicio en una interfase
•Relacionar a los clientes con la interfase del servicio
•Implantar al servicio en una clase concreta, e instanciarlo con un patron
de construccion de objetos
•Una clase tercera, ensambla al cliente con el servicio. Esto se conoce
como inyeccion de la dependencia
<<interface>>
IRentaBicicleta
+getBicicletas(): List
+getBicicleta(noSerie:String): Bicicleta
1
0...*
Bicicleta
bicicletas
1
ListaArregloRentaBicicleta rentaBicicleta
RentaBicicletaEnsamblado
1
1
VistaLineaComando2
+setRentaBicicleta(unaRenta:IRentaBicicleta): void
+printAllBikes(): void
1
Inyeccion de la dependencia
unaFabrica
1
Fabrica
Ensamblado 1
1
unCliente
1
propiedades
unServicio
1
<<interface>>
IServicio
1
Cliente
crear
+servir()
+setServicio(unServicio:IServicio): void
unServicio
1
1
Servicio
f:Fabrica
cl:Cliente
Ensamblado
main
new
ser:Servicio
crear
new
ser:IServicio
setServicio(ser)
trabajar
servir
Objetos Java en el viejo estilo plano
•Java tiene una decada de edad, nacio en 1995. Sus primeros pasos fueron
dados en aplicaciones enriquecidas de Web, llamadas applets.
•Sin embargo, Java a sus 2 años se uso para implantar tecnologia
cliente/servidor y componentes de Software (JavaBeans)
•A sus 3 años, se establecio el concepto de un servidor de aplicaciones y
surgieron multiples soluciones como Enterprise Java Beans, Servlets.
•Para el año 2000, la industria Java se fortalecio con la aplicación de la
tecnologia a servidores de alto rendimiento. Surgieron multiples opciones de
herramientas de desarrollo.
•Conforme fue avanzando, la tecnologia se volvio cada vez mas elaborada.
•Existe un principio basico al construir cualquier sistema, Mantenlo Simple
(Keep It Simple o KIS). Java estaba empenzando a violar este principio. Cada
vez se requiere de gente mas especializada.
•Pero varios programadores se dieron cuenta que la programacion se puede
hacer de manera mas ligera y sin complicar el modelo, tal como cuando
empezo Java.
•Al estilo de programar las clases con lo minimo indispensable y sin acoplarse
fuertemente a la infraestructura, se les conoce como Objetos Java en el Viejo
estilo Plano o Plain Old Java Objects (POJO)
El decalogo de la programacion
Java
•
•
•
•
•
•
•
•
•
•
Manten simple tu codificacion, piensa en POJOs
Prueba antes de codificar, y despues, tambien.Todo codigo debe ser probado
facilmente.
Desacopla tus clases por medio de interfases, por medio de la inyeccion de la
dependencia
Se independiente de herramientas y ambientes de desarrollo complicados. No
siempre un asistente grafico es lo mas poderoso
Piensa las clases como servicios que encapsulen funcionalidad. Separa la
funcionalidad de tu clase de la infraestructura tecnologica.
Usa UML como herramienta de comunicación con tu equipo, pero no temas
en romper las reglas y hasta tirar los diagramas a la basura. No cambies el
analisis y diseño por la programacion. Un buen programador es aquel que
codifica claramente y correctamente.
Rodeate de bibliotecas y frameworks ligeros
No siempre JavaSoft tiene la razon
Evita a los EJBs
No te olvides del mundo .NET, puedes aprender de el.
Herramientas Java
• Pruebas unitarias – JUnit
• Automatizacion de rutinas para el desarrollo –
Ant, Maven
• Framework Ligero – Spring
• Mapeador de Objetos a Relaciones - Hibernate
• Contenedor de componentes Web – TomCat
• Contenedor de componentes J2EE – JBoss
• Herramienta IDE – Eclipse
• Control de Versiones - CVS
Estandares de Programacion Java
• Nombre de los paquetes –
mx.edu.ulsa.cib9132005
• Estructura de directorios –
src – Codigo fuente
test – Codigo fuente de pruebas unitarias
lib - Bibliotecas auxiliares
bin – Codigo compilado
Pruebas Unitarias
•
•
•
•
•
•
Una prueba unitarias es la unidad
elemental en el ciclo de pruebas.
Una prueba unitaria envia un mensaje
a un objeto y a continuacion verifica
que se reciba el mensaje esperado por
parte del objeto. Una prueba unitaria
ejercita las caracteristicas de un objeto
Para escribir unitarias, se puede utilizar
un marco de trabajo denominado JUnit;
que proporciona clases para escribir
pruebas unitarias, validar resultados y
ejecutar las pruebas en un entorno
grafico o de linea de comando
Cualquier clase que se considera
prueba unitaria, debe hacer herencia
de la clase junit.framework.TestCase.
Cada metodo que invoque a una
prueba unitaria, debe llamarse con el
prefijo test
Los metodos setup y tearDown sirven
para crear y liberar al objeto de prueba
junit.framework
Assert
+assertEquals()
+assertFalse()
+assertNotNull()
+assertNotSame()
+assertNull()
+assertSame()
+assertTrue()
+fail()
TestCase
#setUp()
#tearDown()
XYZTest
XYZ
+testMetodo1()
+testMetodo2()
#setUp()
#tearDown()
+metodo1()
+metodo2()
Interfase grafica de JUnit
•
Automatizacion de
tareas del desarrollo
Las tareas comunes en cualquier
desarrollo Java son:
–
–
–
–
–
•
•
•
•
Crear la estructura de directorios del
proyecto
Compilar el codigo fuente
Compilar las pruebas unitarias
Ejecutar pruebas unitarias
Empaquetar las clases en un archivo
Jar.
La herramienta Ant es software Java
que automatiza las tareas anteriores y
adicionales.
Consiste en programas Java que
cargan un archivo XML, que contiene la
declaracion de propiedades y tareas a
ejecutar.
El archivo XML se denomina build.xml
Con dicha herramienta, se faculta a los
desarrolladores de un proyecto, a tener
un metodo estandar para realizar las
tareas de desarrollo, de manera
independiente a la herramienta IDE
<?xml version="1.0" ?>
+ <!-- -->
- <project name="configurar" default="iniciar" basedir=".">
<description>Script Ant que permite gestionar a un proyecto Java</description> <!-- propiedades del
proyecto -->
<property name="src.dir" value="${basedir}/src" />
<property name="bin.dir" value="${basedir}/bin" />
<property name="lib.dir" value="${basedir}/lib" />
<property name="test.dir" value="${basedir}/test" />
<property name="jar.nombre" value="proyecto.jar" />
- <path id="master.classpath"> <!-- incluir todos los archivos jar que se situen bajo el directorio lib -->
- <fileset dir="${lib.dir}">
<include name="*.jar" />
</fileset> <!-- incluir en el classpath al codigo binario del proyecto -->
<pathelement path="${bin.dir}" />
</path>
- <!-- ================================= target: iniciar
================================= -->
- <target name="iniciar" description="Crear directorios">
<mkdir dir="${src.dir}" />
<mkdir dir="${bin.dir}" />
<mkdir dir="${lib.dir}" />
<mkdir dir="${test.dir}" />
</target>
- <!-- ================================= target: compilar codigo fuente
================================= -->
- <target name="compilar" depends="iniciar" description="Compilar codigo Java">
- <javac srcdir="${src.dir}" destdir="${bin.dir}" classpath="$">
<classpath refid="master.classpath" />
</javac>
</target>
- <!-- ================================= target: compialar pruebas unitarias
================================= -->
- <target name="compilar.pruebas" depends="compilar" description="Compilar pruebas unitarias
Java">
- <javac srcdir="${test.dir}" destdir="${bin.dir}" classpath="$">
<classpath refid="master.classpath" />
</javac>
</target>
- <!-- ================================= target: ejecutar pruebas unitarias con Herramienta
grafica ================================= -->
- <target name="ejecutar.pruebas" depends="compilar.pruebas" description="Ejecutar pruebas
unitarias modulo grafico">
- <java classname="junit.swingui.TestRunner" fork="yes">
<classpath refid="master.classpath" />
</java>
</target>
- <!-- ================================= target: empaquetar en un archivo jar el codigo java, sin
incluir a las pruebas unitarias ================================= -->
- <target name="empaquetar.libreria" depends="compilar" description="Generar al archivo jar">
- <jar destfile="${lib.dir}/${jar.nombre}">
<fileset dir="${bin.dir}" excludes="test/** **/*Test.class" />
</jar>
</target>
- <target name="limpiar" description="Limpiar clases Java">
<delete dir="${bin.dir}" />
<delete file="${lib.dir}/${jar.nombre}" />
</target>
</project>
Conclusiones
• Escribir el sistema como POJOs.
• Detectar aquellas clases Java que son
candidatas a realizar servicios y aplicarles
el principo de inyeccion de la dependencia
• Automatizar el desarrollo con
herramientas como Ant y JUnit
Ejercicio
•
•
•
•
•
•
•
•
Diseñar un sistema usando UML
Traducir el diseño a POJOs
Usar el script Ant proporcionado para realizar un proyecto Java
Usar Eclipse como IDE (opcional)
Detectar las clases que son servicios
Aplicar el principio de inyeccion de dependencia
Escribir pruebas unitarias para los servicios detectados
Correr el script Ant para compilar, pruebas unitarias y empaquetamiento