ContenidoContenidos del curso....................................................................................................................2

JDBC.............................................................................................................................................3

Drivers......................................................................................................................................3

Operaciones con JDBC..............................................................................................................4

Carga de drivers...................................................................................................................4

Conectar/desconectar a BD..................................................................................................4

Enviar órdenes a la BD. Sentencias.......................................................................................8

Sentencias preparadas......................................................................................................12

Procedimientos almacenados............................................................................................13

Tansaciones........................................................................................................................14

Optimizaciones y otras mejoras.................................................................................................15

Porcentaje de carga:...............................................................................................................15

Actualizaciones en modo bach...............................................................................................15

Nuevos tipos de resultSet.......................................................................................................16

No asistí a clase .................................................................................................................17

EntityManager........................................................................................................................18

Creacción de las clases URM en un proyecto con un modelo de datos existente..................18

Queryes con nombre. Anotaciones........................................................................................22

Patrones de diseño. DAO...........................................................................................................23

Persistencia de relaciones entre clases......................................................................................24

Aplicaciones WEB.......................................................................................................................28

Curiosidades...............................................................................................................................29

|

Lunes 14 Junio

Contenidos del cursoDos bloques claramente distinguidos: JDBC (acceso a base d edatos) y URM (mapeadores de objeto relación)

JDBC APLICACIÓN WEB

AD (acceso datos) A Web (aplicación web)

Clásica (desktop) Orientación objetos JSP Servlet

Libro: “Web development with Java” que cubre la parte de aplicaciones Web

El blog del profe: http://formanntt.blogspot.com/

Sobre la tecnología del curso:

La herramienta sobre la que trabajaremos es NetBeans 6.8, que es la versión estable. Guía de referencia rápida de JDBC: C:\MCSE\Lunes 14 de junio de 2010\

Documentación\Manual Jdbc.htm El directorio de los ejemplos se guardarán en: C:\MCSE\Lunes 14 de junio de 2010\

Ejemplos Necesitamos una base de datos que puede ser cualquiera por ejemplo: Derby,

MySQL…Para nosotros será MySQL que la encontramos en: Inicio> Progarmas > MySQL

Clave: root

|

Cuanto más actualizada este la versión que utilicemos de java podremos hacer el mismo trabajo pero trabajando menos. (JSE v6.0 Edición Standard java, JEE v.6.0 versión Enterprice de java y JME tecnología de móviles en java)

La primera tecnología que veremos en el curso que forma parte de la edición Estándar es la JDBC (Conectividad para bases de datos en java) y por tanto es aplicable a cualquier aplicación java.

JDBC es un API (interface para la creación de aplicaciones, biblioteca de clases para facilitarnos los accesos a datos), i.e, es una especificación de cómo se debe acceder a la base de datos y además es una implementación.

JDBC[ver 2.1]

La arquitectura de esta herramienta sigue el siguiente esquema:

Este primer nivel es el código que nosotros escribimos JBDC para el Acceso a datos Los drivers son los únicos que saben que están “hablando” con una BD. Son los que

nos van a dar la conexión a la BD. Son las BD a las que se accede

Drivers[ver 2.3]

Para funcionar únicamente necesita java. Todas las aplicaciones que actualmente existen en java tiene los drivers para ejecutarlos de tipo 4.

Un driver es una clase java con la diferencia que el driver debe implementar la interface, DRIVER, para que java reconozca que es un driver.

|

n

ap

JDBC

Drivers 1 Drivers 2

BDOracle BD2

Los drivers traducen cualquier sentencia SQl de forma que la BD a la que vaya a acceder sea capaz de entenderla.

Operaciones con JDBCLos JBDC nos permite conectar/desconectar a la base de datos, obtener los datos y procesar los resultados que nos devuelva. [ver 3. Clases del API JDBC.]

Se utiliza la clase “Class” que es una metaclase, la diferencia entre una clase y una metaclase es que las instancias de esta metaclae definen o representan las características de otras clases

Carga de drivers[Ver 3.1]

Para acceder la BD lo primero que se ha de hacer es cargar el driver en memoria con el que vamos a acceder a la BD.

Para ello, la forma más útil y que se usa en el día a día es usar el método de la metaclase llamado: forName. Se invocaría como class.forName y este método nos permite cargar en memoria el driver que indiquemos.

Por ejemplo:

Class.forName(“uno.A”); buscara en el disco duro la clase “A” que estará en el paquete “uno”, si no encuentra la clase “A” lanzará una excepción si la encuentra ya tendremos cargado el driver en memoria para su utilización.

Para encontrar la clase debe estar en el classpath (variable de entorno que contiene una serie de directorios donde hay clases java compiladas) del sistema.

Conectar/desconectar a BD[Ver 3.2]

ConectarSupongamos ya tenemos cargado el driver y ahora nos queremos conectar a la BD.

Debemos recurrir a la clase DriverManager, que se encarga de gestionar los driver que tenemos en memoria.

Definiremos un objeto de la clase : Connection con = new Conecction();

y después hay que utilizar el método getConection() que nos devolverá un objeto que implementará la clase DriverManager.

Este método necesita tres parámetros, todos ellos de tipo “string”:

url (localizador uniforme de parámetros). Tiene el siguiente formato:protocolo : nombredriver : localización de la BD indicando máquina y puerto(opcional)

Ejemplo: para conectarme a la base de datos de “derby” escribiría la url:

|

jdbc:derby://localhost:1527/curso usuario clave

DesconectarSe coge la clase con la que trabajemos y llamamos al método close().

Ejemplo: con.close();

Es importantísimo llamar al método close() porque si no se cierra explícitamente se podría quedar conectado al servidor remoto de la BD.

EJERCICIO 1: UN programa que nos conecte y desconecte de una Base de Datos

Conexiones con BD en NetBeans

Desplegamos APP:

|

Esto que obtenemos es un intérprete de la BD.

Nos hemos asegurado que tenemos BD en el ordenador.

|

Ese check nos permitirá importar tbn las librerías para que si arrancamos esta nueva clase en otro lugar no nos de error de no encontrar las librerías.

El código de programa es:

// Clase que conecta y desconecta de la base de datos

try { System.out.println("Invocamos al método forName"); Class.forName("org.apache.derby.jdbc.ClientDriver");

System.out.println("Creamos la conexión"); Connection con = DriverManager.getConnection("jdbc:derby://localhost:1527/curso", "app", "app");

System.out.println("Cerramos la conexión"); con.close(); } catch (SQLException ex) { Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex); }

|

Martes 15 JunioAntes de ejecutar un programa debo conectarme a la base de datos para lo cual:

Enviar órdenes a la BD. Sentencias[Ver 3.3]

Para crear una sentencia debemos crear una variable de tipo Statement, y escribir el código:

Statement stmt = con.createStatement(); con es la conexión que he abierto anteriormente

Y a continuación decirle la orden de SQL que queremos que ejecute.

|

Java distingue entre dos tipos de órdenes para ejecutar:

Queryes mediante la sentencia “select” stmt.executeQuery (“SELECT …”); Todo lo demás: insert, delete, update,… stmt.executeUpdate (“INSERT | UPDATE |

DELETE | CREATE | …”);

Todo lo que no sea sentenciaDonde stmt es la variable de tipo Statement que hemos declarado con anterioridad.Estos métodos nos devuelven un número que será el número de filas que han sido “modificadas” con esta sentencia. No será obligatorio capturar este valor que devuelve salvo que lo queramos usar para algo.Cuando se termina de trabajar con un Statement se debe cerrar con la instrucción:

Stmt.close();

Ej:

String x=”insert into…..”

stmt.executeUpdate(x);

stmt.close();

EJERCICIO: Creamos tabla en BD para poder realizar consultas a través de java.

|

Los Strings desde java los haremos con simples comillas simples.La clase se llama Primera_1:

try { System.out.println("Invocamos al método forName"); Class.forName("org.apache.derby.jdbc.ClientDriver");

System.out.println("Creamos la conexión"); Connection con = DriverManager.getConnection("jdbc:derby://localhost:1527/curso", "app", "app");

java.sql.Statement stmt = con.createStatement(); System.out.println("Insert en la BD"); String i1 = "INSERT into personas (id,nombre) values (1,'nombre1')"; stmt.executeUpdate(i1); String i2 = "INSERT into personas (id,nombre) values (2,'nombre2')"; stmt.executeUpdate(i2); String i3 = "INSERT into personas (id,nombre) values (3,'nombre3')"; stmt.executeUpdate(i3);

System.out.println("Update en la BD"); String u2 = "UPDATE personas set nombre= 'nombreActualizado' where id=2"; stmt.executeUpdate(u2);

System.out.println("Delete en la BD"); String d3 = "DELETE from personas where id in(1,2,3)"; stmt.executeUpdate(d3);

System.out.println("Cerramos la conexión"); con.close(); } catch (SQLException ex) { Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);

}

Sentencias

Para ejecutar sentencias utilizaríamos la sentencia:

String consulta= “Select….from…”

stmt.executeQuery (consulta);

Esto nos devolverá una colección de filas. EN java tenemos una colección (metaclase) especial para guardar las filas de una consulta:

ResultSet rs = stmt.executeQuery (consulta);

|

Supongamos que la consulta nos va a devolver un número enorme de resultados…entonces el servidor se quedará “frito” para ello y JDBC hace lo siguiente:

resultSet Jdbc BD

jdbc le dice a la BD que le devuelva un número adecuado de filas y esas son las que mete en el resultSet, entonces cuando vayamos recorriendo este resultSet las primeras N filas nos las devuelve del servidor de cliente y cuando se vayan acabando irá a la BD a buscar la otras N filas, de este modo nos aseguramos que se pueden obtener todas las filas sin dejar “colgado” el servidor. Lógicamente durante todo este proceso la conexión con la BD debe estar abierta, en cuanto se cierre el resultSet se invalida.

La relación entre los objetos … es jerárquica:

Connection puede tener cualquier número de St abiertos

Statement puede tener cualquier número de rs abiertos

resultSet

De forma que si cierro al “padre” de cualquiera de ellos invalidaré al que esté por debajo.

Entonces para abrir las connection, Sattement o resultSet, lo haré de arriba abajo y para cerrarlos de abajo a arriba.

Nota: Se deben crear siempre para programar bien el número mínimo de conexiones necesarias.

Para recorrer el rs utilizaríamos por ejemplo un bucle while, cuya sintaxis será:

While (rs.next()) se ejecutará mientras haya filas que devolver.

Las columnas se numeran de izquierda a derecha de forma consecutiva comenzando por 1.

También se pueden recuperar indicando el nombre de la columna.

OJO algunos drivers no me permiten acceder por parémetro posicional para obtener los valores

Los pasos imprportantesson:

1. Se debe llamar al método next()2. Acceder por parámetro posicional para obtener los valores3. No leer más de dos veces cada línea4. 4…..cual es??

EJERCICIO: La clase se llama Ejercicio_2

Documentación para esto: http://java.sun.com/javase/6/docs/technotes/guides/jdbc/getstart/GettingStartedTOC.fm.html

|

Sentencias preparadas

[ver 3.4] ACADEMIA

El ejercicio es : ejemplo 3.1

|

Miércoles 16 JunioProcedimientos almacenados[Ver 3.5]

Para la ejecución en remoto de un procedimiento almacenado.

Debo definirme una variable de tipo:

CallableStatement cstmt = con.prepareCall (“{call ProcAlmacenado (?,?,?, …, ?)}”);

Donde “procAlmacenado” es el nombre del procedimiento almacenado que exista en la base de datos.

OJO HAY UN ERRRO EN LA SINTAXIS DE LOS APUNTES, LA CORRECTA LA INDICO AQUÍ.

La sintaxis correcta para llamar a PROC y a FUNC es:

Para PROC: {call f(?,?)}

Para FUNC: {? = call CrearPersona(?,?)}

Si el PROC tiene parámetros hay que definirlos. En BD tenemos para los PROC tres tipos de parámetros:

IN el servidor solo puede leer, no escribir el parámetro OUT el servidor solo puede escribir, no leer el parámetro IN/OUT el servidor puede leer y escribir el parámetro

Cuando un parámetro es de salida hay que decírselo a java y esto se hace mediante la el método:

Para PROC: cstmt.registerOutParameter (Types.INTEGER);

Para FUNC: cstmt.registerOutParameter (1, Types.INTEGER);

en el que se indica el parámetro que es de salida y el tipo de datos al que pertenece el parámetro de salida.

A continuación se dan valor a los parámetros al igual que ocn las sentencias predefinidas con los métodos ser.

Y finalmente se ejecutará el procedimiento teniendo en cuenta que si el PROC almacenado ejecuta a una sentencia o select se llamará al método “cstmt.executeUpdate();” y si no es una sentencia o select se utilizará: cstmt.executeQuery();

Ejemplo:

CallableStatement cstmt = con.prepareCall (“? = call CrearPersona (?,?)”);

cstmt.registerOutParameter (1, Types.INTEGER);

cstmt.setInt (2, 13456789);

cstmt.setString (3, “Bart”);

|

cstmt.execute();

int n = cstmt.getInt(1);

OBSERVACIÓN: Con la BD de “ApacheDerby” todo esto no funciona, es decir, no se pueden manejar de este modo los PROC ni FUNC

El método: Execute(); se utiliza para ejecutar procedimientos mixtos, es decir, si en el PROC almacenado existen sentencias select peor tbn tiene otras instrcciones insert, update, delete… entonces debemos usar este método y no el executeQuery o executeUpdate.

Ejercicio: abrimos el proyecto “UsoJdbcMySql “ que está en la careta de apuntes del profesor del lunes 14 de Junio.

Recordemos que como vamos a utilizar la base de datos MYSQL, con lo que deben esar instalados los drivers de MySQL en el path de la máquina.

Este ejemplo nos da la sintaxis para crear un modelo de datos a través de un programa java.

No es lo más útil peor si nos da una herramienta o una ayuda por si alguna vez y por temas de portabilidad nos interesa crear así el modelo.

Tansaciones[ver 3.7]

El objetivo de una transacione es agrupar un conjunto de sentencias SQl en un mismo “paraguas”, es decir, que en el momento que una de ellas falle se desharán todas las acciones realizadas hasta entonces en la BD.

Si todas las sentencias han ido bien se realiza un commit(); y si falla se hace un rollback();.

Jdbc cada vez que se lanza una sentencia con éxito hace automáticamente un commit(),pero hay que indicarle que lo haga.

Para ello usamos el método: con.setAutoCommit (false);

False las transacciones serán controladas manualmente por el programador. En este caso tras la realización de la ssentencias de debe llamar además la método con.commit();

True las transacciones las hace automáticamente jdbc.

Ej:

Try{Con.setautoCommit(false); //toma el control el programadorS1----S2-----S3----

|

Con.commit(); // todo ha ido bien}catch (SQLException e){Con.rollback(); //algo ha fallado}finally{//el código dentro de un finally se ejecuta siempre salten o no excepcionesCon.setAutocommit(true); //toma el control jdbc}

Un nivel de aislamiento o de transacción bloquea procesos sobre una sentencia hasta que la transacción correspondiente haya terminado.

Hay varios niveles de aislamientos, que se consultan en la API´s de java mejor.

Optimizaciones y otras mejoras[ver 5]

Existen varias optimizaciones para la marcha de las aplicaciones:

1.- Sentencias preparadas que ya las conocemos

2.- Uso de PROC almacenados

Vamos a ver otras que se han comentado de pasada y ahora detallaremos.

Porcentaje de carga: [ver 5.1]

setFechtSize() permite cambiar le procentaje de carga a nivel de resultSet o a nivel de Statement (en este caso todos los resulSet herdarán estas porcentaje de carga)

getFechtSize() nos dice el porcentaje de carga del que disponemos.

Se aconseja que el porcentaje de carga no se modifique, hasta que no sepamos a quién se la debemos aplicar, es decir, saber de “en que” gasta el tiempo la aplicación y “que hacen los usuarios finales” con la aplicación.

Actualizaciones en modo bach[ver 5.2]

Lo que se hará es minimizar el tráfico cliente-servidor d elas aplicaciones.

Se tiene el método addBatch(), cuando se lanzan sentencias teniendo un addBatch() jdbc no envía la sentencia a BD sino que las guarda en un “cajón” hasta que encuentra el método executeBatch() que lanzará todas las sentencias en un mismo “round”, de una vez todas juntas y no con un round por cada sentencia.

|

Así en vez de tener N rounds tendré 1 round con todas las sentencias, con lo que habremos disminuido sustancialmente el tráfico.

Este modo no aumenta la carga en el servido en ningún caso, por lo que no se conocen “efectos negativos”.

Nuevos tipos de resultSet[ver 5.3]

Con los nuevos tipo de result set podemos hacer:

Recorrerlo en ambos sentidos Movimiento absoluto: xEj:“vete a la fila 14” Movimiento relativo: xEj: “desde donde estas sube 5 filas, -5, y luego baja 14 filas, +14” Insertar/borra/actualizar filas desde dentro del rs: xEj: “si me encuentro el valor 2 en el

rs insertar una nueva fila en la tabla MiTabla..”

Para crearlos:

Statement st = con.createStatement(parametro1,prametro2)

A tener en cuenta:

1. Cuanto más nuevo sea un rs más lento será. Todo lo que se haga con los nuevos rs se puede hacer con los rs más simples de todos que son los que hemos expliacdo estos días atrás, puesto que todo será más rápido.

2. La mayoría de las operaciones de nuevos rs no las soportan muchas BD. Si el Apartado[6] nos lo deja como ejercicio para nosotros y no lo haremos aquí.

EJERCICIO: Prácticas del epígrafe 8. Están resueltas en el paquete UsoJdbcMySql “ que está en la careta de apuntes del profesor del lunes 14 de Junio.

Vamos a revisar el código

|

Jueves 17 JunioNo asistí a clase .Se tocaron temas de persistencia [Ver …]

Comenzaron con JPA (Java persistence api)

|

Lunes 21 Junio…Continuación del Jueves JPA…

EntityManagerSe crea un EntityManager por cada conexión a una base de datos que desee.

Intentar usar un único EntityManager por cada método.

Después abriré una transacción de forma obligatoria.

Ver ejemplo Miércoles 16 Junio del proyecto “JpaUnaClase0000” la clase Principal.

EL método merge():

//Nota: la llamada al método merge es innecesaria

Se usa para actualizar versiones. Pero no es necesario pues cuando se opera con un objeto de tipo “EntityManager” al hacer el commit() se actualiza de forma automática todas las versiones.

El EntityManager debe estar abierto y debe conocer los objetos.

Sin embargo si le hago persistente al hacer el el commit() los actualizará de forma automática.

Si utilizase más de un entityManager y lo cierro cuando no lo utilice todas las actualizaciones se harán de forma automática. Si utilizase uno al pripio d elcódgio que siempre sestuviese abierto tendrái que controlar “su crecimiento” a través d elos métodos:

Flush: hará una actualización de tofo clear: Borrar el caché de la BD

Por eso se aconseja utilizar solo uno.

Para crear un objeto EntityManager debo llamar al Método CreateEntityManager.

Creacción de las clases URM en un proyecto con un modelo de datos existenteSi en un proyecto ya existe un modelo de Datos pero no existen las clases.

Ver ejemplo: JavaApplication23

|

Creo una clase nueva para nosotros: JavaApplication23

Botón derecho para hacer “ingeniería Inversa”. Y selecciono opción: Entity Classes for database

|

Añado la tabla PERSONA sobre la que haremos IngenieriaInversa:

Este check tiene que estar marcado, porque si hay relaciones entre muchas tablas al hacer ingenieria inversa habrá que hacer a mano muchas cosas para dejarlo bien.

La ingeniería inversa por tanto con tablas aisladas o tablas relacionadas de 1 a n, si trabajan bien.

Al llegar a la pantalla:

|

Nos informa queno hay unidad de persistencia y nos indica si queremos que la herramienta nos ayude, para ello pulsamos el botón: Create persistence unit…

Sleccionamos como proveedor a Hibernate:

|

Lo aceptamos y seguimos el proceso llegando a esta pantalla, en la que marcamos los checks.

Nos crea en la carpeta META-INF el xml de persistence. (Que explicaron el jueves) y nos crea el código de java de las clase correspondiente a la tabla de la BD. Que justo es d elo que se trataba la Ingeniería Inversa.

Queryes con nombre. Anotaciones[ver clase Personadel proyecto nuevo creado: JavaApplication23]

@Temporal:

@Lob: LargeObject

@NamedQuery (name= “Persona.findByNombre”, query = “SELECT P FROM PERSONA P”)

PRACTICA: montra un proyecto que tenga persistencia

Ver Ejemplo miércoles 16 : JpaUnaClase0002

|

Martes 22 Junio

Patrones de diseño. DAOSi el código esta bajo JPA y cambiamos a hibérnate el código puede ser que no compile..

Para resolver esto existen los “Design Pattens” o patrones de diseño.

Los patrones de diseño, es una estrategia que se sabe que va a funcionar para resolver un escenario determinado, es decir, una solución estándar que se sabe por anticipado que va a funcionar para un escenario problemático determinado. Pero ojo no tiene por qué ser la solución óptima.

Los patrones de diseño más utilizados en la tecnología java son los GoF (Gangs of four).

Nota Si queremos información sobre esto solicitarla al profe por el foro

Nota: Recapitulando lo visto hasta hoy en curso tendremos la estructura: Jpa > ORM > Jdbc > BD.

El patrón de diseño más simple que hay es el DAO (objeto de acceso a datos).

Cliente (cliente ) DAO (interface que ve el cliente) JpaDaO (implementación de la interface DAO)

Si el día d emañana quiero utilizar Hibernate en vez de JPA bastará implementar una nueva interface en hibérnate y para el cliente será totalmente trasparente. Y lo mismo si nuevamente quisiera vambiar de tecnología y utilizar otra como por ejemplo Jdbc t tendría que implementar jdbcDAO.

Ejemplo: JpaUnaClase0002

El patrón DAO nos sirve para enumerar todos los métodos de una clase persistente de una sola “atacada” en el ejemplo será la clase PersonaDAO. Esta interface es publica peor su implementación no lo será.

Luego tendremos que tener una clase que nos implemente el DAO. En el ejemplo es la clase PersonaDAOImple.

En el ejemplo el main está en un paquete distinto a en el que está la implementación del DAO, para que se puedan utilizar se ha creado otro patrón de diseño llamado Singleton, y que en el ejemplo es la clase: PersonaManager.

En el escenario siguiente:

Solo una instancia de una clase: para o cual se llama Que sea instanciada desde cualquier sitio: para ello el constructor se define como

privado y los atributos se define como privado y estático

|

Es donde se suele utilizar justamente este patrón de diseño llamado singleton.

El método getInstance() es el que nos asegura que únicamente se va a instanciar el Personamanager una única vez puesto que el “if” del código tras haberlo instanciado mñas de una vez siempre nos devolverá el mismo objeto.

Si ahora quiero trabajar con los métodos del DAO, me creo el método getPersonaDao() que nos devolverá un objeto de tipo implementación de la clase PersonaDao.

Si quiero cambiar de tecnología lo que cambiaré es justamente este método:

En el ejemplo tenemos:

public PersonaDao getPersonaDao() {

return new PersonaDaoImpl();

}

Si quiero usar jdbc haré:

public PersonaDao getPersonaDao() {

return new PersonajdbcImpl();

}

Nota: En un escenario real de PROD cuanto menos nos “cueste” (rápido, fácil y barato) introducir cambios será un indicador de que la aplicación está bien programada, tal y como es el objetivo de la programación orientada a objetos.

Ver también ejemplo jueves 17 junio : JpaDosClases0001

Persistencia de relaciones entre clases[Carpeta jueves 17 Junio. Ejemplo: JpaDosClases0001]

La relaciones que hay entre clase en java son muy similares a las que hay en UML.

Ejemplo:

La relación entre una Persona y su Afición puede tener distintas relaciones:

1----- 1 ( de una a una): Aficion A; Perosna p;

1 ---- * (de una a muchas): Persona p; List<Aficion> l;

*----*(de muchas a muchas) List<Persona> pl ; List<Aficion> la;

En JPA esto se representa con las anotaciones:

|

@OneToOne

@ManyToMany

@OneToMany

@ManyToOne

En relaciones de 1 a muchos (1 *) necesitamos que se haga persistencia en objetos declarados en cascada. Podemos mandar a JPA que haga la persistencia en cascada. Una operación en cascada en JPA significa que cuando se le dice al urm que haga persistencia sobre un objeto también lo hará sobre todos los objetos que cuelguen de él.

En JPA se hace con el comando “cascade”.

Academia (18:00h 19:30h)

|

Miércoles 23 JunioEjemplo de persistencia carpeta del jueves 17Junio: EjemplosPersistencia y en la clase EjemplosPersistencia-ejb existen ejemplos de cómo hacer mapeos de relaciones de todos los tipos]

Cualquier clase que compile el URM las hará persistente, y podrá elegir entre tres estrategias distintas para realizarlo:

1) SingleTabe2) Joined3) Table per class

Veámoslo en un ejemplo:

id

x y DTYPE

1 8 null A2 5 3 B

1)Modelo singleTable: Es el que emplea URM por defecto. Crea una tabla para todas las clases y un campo discriminador que nos dice a que clase pertenece cada línea

A

A X:intid

@

hereda

2) Joined: crea una tabla por cada clase

A B

FK

|

id x

id y

@

3)Table per Clae: crea una tabla por clase en la que repite todos os atributos de cada tabla.

A B

El modelo 1) es el más “feo” peor el más eficiente, por eso es el que URM elige por defectoPor tanto por defetco usa la estrategia 1) peor si quiero que use otra d ela sestrategias

hay que indicárselo.

El código es:

1º caso Modelo 1@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

2º caso Modelo 2@Inheritance(strategy=InheritanceType.JOINED)

3º caso Modelo 3@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)

Ejemplo: EjemploHerencia del día Martes 21.

|

By:int

id x

id y x

Aplicaciones WEB

Lo que nos interesarán son las : www: World wide web

Servidor Cliente Servidor Web

Para comunicar el cliente con la web se necesita un protocolo de comunicación que para nosotros será HTTP :

Lo que se manda a un servidor web es una “request” y lo que el servidor responde se llama “response”

Ej:

http://www.google.es/index.html

El dominio de una url es lo que identifica un ordenador concreto. Ej: google.es

Una dirección IP tiene el formato: 127.0.0.1 y representa al localhost desde el que se realiza la llamada.

Cuando se teclea una url lo primero que hará explorer es preguntarle al DNS(Servicio de nombre de dominio).

ACADEMIA

|

Jueves 24 Junio[Continuación de servlets..]

ServletsEjemplo Jueves 24 Jnio : WebApplication1

Un servlet es una clase java con unas determinadas características entre ella que tiene que ser “hija” de HttServlet.

Responde a un patrón de diseño llamado inversión de Control, que como su nombre indica invierte el control ya que es API quien nos llama a nosotros y no nosotros al él.

Un servlet en java se representa con un pentágono,

|

Curiosidades http: protocolo trasferencia de hipertexto www: worl wile web Ley no escrita de la informática: “Todo programa se tira el 90% de su tiempo en el 10%

del código.” url: Localizador uniforme de resursos ftp: potocolo de transporte de archivos. Otro modo de que dos ordenadores

intercambien información. TCP/IP: protocolo de transporte / protocolo de internet

|