notas clase java ii

INDRA | Programación java II

1

Contenido Contenidos 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 ................................................................................................................................ 30


2

Lunes 14 Junio

Contenidos del curso Dos 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

http://formanntt.blogspot.com/


3

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


4

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

capaz de entenderla.

Operaciones con JDBC Los 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]

Conectar

Supongamos 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:


5

jdbc:derby://localhost:1527/curso

usuario

clave

Desconectar

Se 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:


6

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

Nos hemos asegurado que tenemos BD en el ordenador.


7

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);

}


8

Martes 15 Junio

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


9

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 sentencia

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


10

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);





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);


11

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 valores

3. No leer más de dos veces cada línea

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

ml

http://java.sun.com/javase/6/docs/technotes/guides/jdbc/getstart/GettingStartedTOC.fm.html

http://java.sun.com/javase/6/docs/technotes/guides/jdbc/getstart/GettingStartedTOC.fm.html


12

Sentencias preparadas

[ver 3.4] ACADEMIA

El ejercicio es : ejemplo 3.1


13

Miércoles 16 Junio

Procedimientos 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”);


14

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 programador

S1----

S2-----

S3----


15

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 excepciones

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


16

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


17

Jueves 17 Junio

No asistí a clase .

Se tocaron temas de persistencia *Ver …+

Comenzaron con JPA (Java persistence api)


18

Lunes 21 Junio

…Continuación del Jueves JPA…

EntityManager Se 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

existente Si en un proyecto ya existe un modelo de Datos pero no existen las clases.

Ver ejemplo: JavaApplication23


19

Creo una clase nueva para nosotros: JavaApplication23

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


20

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:


21

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:


22

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


23

Martes 22 Junio

Patrones de diseño. DAO Si 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


24

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:


25

@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)


26

Miércoles 23 Junio

Ejemplo 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) SingleTabe

2) Joined

3) Table per class

Veámoslo en un ejemplo:

id x y DTYPE

1 8 null A

2 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:int id

@ hereda

B

y:int

@

2) Joined: crea una tabla por cada clase A B id x

id y

FK

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

id y x


27

El modelo 1) es el más “feo” peor el más eficiente, por eso es el que URM elige por defecto

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


28

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

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


29

Jueves 24 Junio

[Continuación de servlets..]

Servlets Ejemplo 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,


30

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

notas clase java ii

Education