Perfecto. Bueno, empezamos otra vez, ¿vale? Comentando un poco por
encima. Lo que estuvimos hablando el día anterior, como ya he comentado
antes, era uno de los inicios de Java RMI y en este caso lo que hicimos fue
un chat básico, ¿no? En el que había un objeto remoto que era un
servidor de chat y los clientes se conectaban a él e invocaban sus
métodos a través de la interfaz remota. Bueno, en este caso lo que vamos
a hacer es, para edición vuestra, que contasteis que necesitabais, que
venía bien conocer el tema de los callbacks por el tema de la práctica
que tenéis que realizar, pues he añadido eso a este proyecto, ¿no? A
este proyecto básico que habéis visto. Entonces, en este caso, lo que
hemos hecho es ampliar la opción que tenía la prioridad, que tenía en
este caso la aplicación de chat, en este caso introduciendo el acuse de
recibo, es decir, cuando se lea los mensajes de un determinado usuario. Se
notificará al usuario emisor que se ha leído por tal persona a tal hora
el mensaje. Entonces, bueno, en este caso los servicios que va a ofrecer el
servidor son similares, la única cosa que introducimos en este caso. el
nombre como un parámetro como un argumento en el caso de que cuando yo lea
los mensajes y ahora mi nombre también para que lo tenga servidor y pueda
modificar a los emisores que lo que he leído ya en los mensajes vamos a
ver en primer lugar las modificaciones principales vamos a numerar la lo
que decimos que introducir el mensaje en este caso incluida un método para
realizar el combate antes era un medio contenedor en la clase mensaje y
ahora la clase mensaje pasa a ser un objeto un objeto remoto que tiene
interfaz remota y un método que permite realizar un combate vamos a ver
este caso de arquitectura arquitecto rm y que vamos a entrenar entendemos
lo que es el cambio funcional que hemos incorporado al sistema que
teníamos de la sesión anterior alguna duda respecto que queremos hacer no
todo perfecto vamos a ver entonces es como cómo hacemos ese cambio lo
primero comentar un poco aquí actuar reme y del aplicar en el sistema de
aplicación que tenemos por un lado la interfaz remota del servidor
análoga a la misma que también prácticamente diferentes ahora respecto a
lo que teníamos en la sesión anterior la interfaz remota del mensaje ya
que en este caso el mensaje también va a ser un objeto remoto y el
servidor que implementas inventas inventa que implementará en este caso su
interfaz remota y usará la interfaz del mensaje para invocar un método de
mensaje el cliente que usa usará también la interfaz y luego veremos
cómo es como ejecutar el proyecto en este caso la lectura de nuestra
aplicación es muy similar a la que vimos en el caso anterior en el
anterior en este caso las clases comunes tiene un proyecto que será una
dependencia para otros proyectos en este caso proyecto común en el puesto
servidor vamos a tener en este caso la implementación de la interfaz
remota y una clase que inicie el servidor en este caso como sabéis es
crear el objeto remoto en este caso podemos podemos enlace con el lanzador
y pasar y exportar el objeto o que incluso como hemos visto ya en el foro
no está comentando pues podemos arrancar el propio lanzador desde el
código Y lanzar y poner en ejecución el servidor. En el cliente lo único
que tendremos es una clase inicio de cliente, que conectará con el
servidor y tendrá una interfaz que permitirá al usuario enviar y recibir
mensajes. Y la parte común tendrá las interfaces tanto del servidor como
del mensaje, las interfaces de acceso remoto, la clase mensaje y las clases
auxiliares. En este caso, aquí veis un poco en el código cuál es la
diferencia, el cambio, en este caso, en la interfaz remota del servidor.
Veis que lo fundamental en este caso es que hemos añadido, hemos
modificado el tipo de argumento que pasamos, tanto en este caso ya no es el
mensaje, sino la interfaz del mensaje. Y hemos añadido un método en este
caso, un argumento, perdón, que es el nombre del cliente. Al cliente. Son
los dos cambios que hemos introducido respecto al proyecto anterior en la
interfaz remota del servidor, en este caso el que hemos denominado y
servidor. recordáis un poco que la interfaz remota tiene que extender de
remote y todos los métodos que declaramos en la interfaz deben lanzar
remotes es importante que no recalquemos esto básico remarcado en todas
las acciones seguiremos rematando los aspectos continuación vamos a verla
la interfaz remota en este caso el mensaje remoto de mensajes si veis si
recordáis la estructura del mensaje anterior era exactamente igual que
ésta solamente que tenía una diferencia que era la introducción de este
método y en este caso tendría extensión de entonces veis que los
métodos de los dos son métodos que dice que el método en este caso
leído tiene que lanzar unas ramas de texto tiene que tener también un
terremoto igual que la interfaz y poco más destacada aquí veis en este
caso la implementación de la clase mensaje que veis que simplemente es un
método que dice de emisor y texto y lo único que tiene la implementación
aquí de este caso del método leído que es el método de colbar que en
este caso lo que va a hacer es imprimir un texto podríamos haber hecho
algo mucho más complejo pero no hago siempre imprimir un texto en este
caso ya veréis cómo se trabaja en este caso en esta clase recordar un
poco cada aspecto importante de esta clase de implementación de la
interfaz remota primero hemos heredado la única remota obvio para que para
no tener que exportar de forma explícita el objeto de la creación
automáticamente al extender tenemos que en el constructor llamada llamada
constructor de esta clase y lanzar remota este posible hubiera cualquier
error es un plan que se lanza el método que tiene que lanzar remota
efectivamente es este método del método leído que es el método de
invocación remota y el cual va a recibir un texto y lo va alguna duda
respecto a al método a la interfaz remota mensaje y en la implementación
de esta entidad no tenemos la clase servidor que era que era la
implementación de la interfaz remota que hemos decidido un momento como
también el caso de la implementación de la interfaz remota del mensaje
también era la única remota de hoy e implementa la interfaz luego
también tenemos que llamar al constructor del padre y este método
también tiene que lanzar los siguientes que tenemos que destacar esta
seguida implementación que tiene una estructura de mensajes que en este
caso es un map de 20 que tiene ordenado numéricamente y los métodos que
ahora veremos que son escribir y leer mensajes como tenemos un método
serial que es ahora simplemente para qué se vuelva formateada la hora en
que estamos. El método de escribir no tiene ninguna diferencia con el
anterior, lo único que hacía era recibir una diferencia, en este caso el
argumento es y mensaje en vez de ser la interfaz del mensaje, y lo único
que hacía este método era recibir un mensaje, comprobar si estaba vacío
o no la estructura para inicializarla y una vez que es inicializada lo que
va haciendo es introduciendo los mensajes en la estructura, luego escribe
por pantalla que tal emisora ha mandado un mensaje con un tarjeta. Este
mensaje como sabéis se ejecuta en el servidor y por lo tanto aparecerá en
la consola del servidor, este mensaje que está viendo aquí aparecerá en
la consola del servidor, aunque se ejecute invocado por el cliente se
ejecutará en el servidor, por lo tanto la consola en la que se escribe es
la del servidor. Luego en el caso de leer devuelve este método de envío,
devuelve una lista de mensajes y la diferencia que con el anterior era como
recordáis que tiene que pasamos el nombre del cliente que quiere leer
estos mensajes. Entonces, igual que como estaba anteriormente, se mantiene
el funcionamiento de comprobar que en este vacío la lista de mensajes, o
que el índice que nos piden sea superior al tamaño. En este caso habrá
un error porque el índice es superior al número de mensajes que piden.
Esto es un control del tamaño de la estructura de mensajes. Luego a partir
de ahí lo que tenemos es una lista de mensajes pendientes y vamos
recorriendo los mensajes. Estos mensajes, vemos, recogemos el mensaje en
una variedad de mensajes y a continuación llamamos, aquí es donde
llamamos ahora al método, vamos a marcarlo así para que te veas, aquí.
Aquí lo que estamos haciendo es haciendo la promesa, estamos invocando a
un método remoto, en este caso el mensaje, y escribiendo en este caso
mandando un texto que es el mensaje con tal texto se ha leído por el
cliente tal a la hora tal. ¿Vale? Este mensaje, ¿dónde se imprimirá?
¿Me contestáis? ¿Alguien? Muy evidente, claro. porque es un objeto
remoto, es un objeto del cliente que está en el servidor, estamos haciendo
una llamada en el servidor a ese objeto del cliente, estamos haciendo el
callback ese sería el callback que hemos introducido como cambio o
ampliación por último lo que hacemos es introducir en la lista de
pendientes el mensaje y finalmente para recorrer todos los mensajes
pendientes devolvérselos a PID ¿Vale? ¿Alguna duda respecto a esto? que
es prácticamente lo fundamental de este ejemplo vale, pues seguimos en
este caso bueno, esto si es un poco repetido anterior, este sería el
inicio, necesitaríamos una sabéis que el objeto remoto no se crea de
forma, o sea no se crea el objeto de forma como instanciación del cliente
sino que tenemos que desde el servidor crearlo ¿Vale? como llevando al
constructor de ese objeto, entonces en este caso es una clase auxiliar que
se administra en el servidor que lo que hace en primer lugar es establecer
la ruta code base a partir de después y a partir de la ruta de la interfaz
distancia esa propiedad lo que hacemos es crear objetos remotos lo tenemos
aquí y a continuación estamos enlazando con el mando de la palabra y el
puerto en este puerto y registrando en este caso el objeto remoto como
nunca me nombre chat dejaríamos parado del servidor esperando en este caso
no estamos haciendo ni carga dinámica de clase por tanto realmente lo que
es el efecto de seguridad de que cuando termine o termine de ejecución
ahora se registrará el objeto y ahora más poder en el caso del cliente
también muy parecido al anterior lo que hacemos es en este caso tenemos un
lugar buscamos estamos con este caso con el enlazador que está en esta
máquina los cajones tras las mismas en el puerto que la tenemos arrancado
pidiendo el objeto chat una vez que lo tenemos es de tipo y servidor del
tipo de interfaz del servidor lo que hacemos a continuación a nivel de
consola pedimos el nombre del usuario y planteamos unas opciones de
escribir o salir de este caso de aplicación enviar de querer enviar un
mensaje lo que haremos es en el método enviar recogemos el texto y creamos
un mensaje y lo llamamos al método remoto aquí estamos haciendo la rmi
llamando al objeto remoto al método escribir sería la rm y que haríamos
del cliente celular y por otro lado si quisiéramos cuando reciba un
mensaje en este caso es aquí mismo aquí también hacemos una rmi
pasándole el índice por el que vamos leyendo tenemos contador de los
mensajes que hemos leído ya y en nuestro nombre a continuación
imprimiremos todos los mensajes y incrementaremos el índice A la vez que
estamos leyendo este mensaje, trabajando en el servidor pidiendo unos
mensajes, sabemos que ya que el servidor a la vez que está leyendo va a
estar haciendo invocaciones remotas también a los clientes que han sido
los emisores de los mensajes que estamos recibiendo. ¿Vale? Que están
pudiendo colgar a la vez que tú estás leyendo, recibiendo mensajes
leídos, los emisores están recibiendo sus ajustes de recibo. Luego esto
es la clase auxiliar codebase que teníamos, que os comenté antes, que a
partir de donde se ubique la clase que le pasamos como parámetro, pues
obtiene la ruta y la añade al codebase, la añade o en caso de que esté
vacío la creemos de la vez. ¿Vale? La ejecución. Bueno, pues aquí
planteamos varias opciones. Planteamos utilizar un plugin. De Chris en este
caso, utilizar el abrir de la consola de RMI Registry y otra posibilidad
que no comentábamos aquí era abrir el enlazador, crear el enlazador desde
el propio servidor. y destruirlo en un momento determinado. Eso lo
haríamos con ver hacer un localizar el registro, haríamos un create
registry, crear registro, y al final haríamos un unspored del objeto
remoto que al final trataríamos en este caso el registro como si fuera un
propio objeto remoto y haríamos un unspored de ese objeto enlazador. Esto
sería a la hora de iniciar, bueno, he visto que alguno ha dado errores a
la hora de iniciar el servidor en el ejemplo anterior, o sea, en la sesión
anterior, al probarlo, pues todo este error es muy típico que nos da y
sobre todo es cuando arrancamos el enlazador desde consola que no tenga
acceso, no tiene claspa a las clases que necesita o porque está ubicado en
un sitio distinto a donde está la clase que necesita. Si no tiene ni una
cosa ni otra, no va a encontrar las clases que necesita y va a dar errores,
que es el caso que veis ahí. Y también el caso de que, lo comentaba
antes, el caso de que tengamos corriente, ya el registro en el puerto al
que estamos atacando, pues nos da este tipo de errores. Aquí veis un
poco... la diferencia a nivel de interfaz de la aplicación que hemos hecho
aquí veis que en este caso yo escribí un mensaje mensaje 1 y otro usuario
se llama david en este caso lo que ha hecho el mensaje y al leerlo aquí
está el mensaje que ha leído automáticamente se ha hecho el callback y
se llama y se muestra mostrado en la interfaz del otro cliente en la
interfaz que el mensaje está contenido por la vida para lograr esta dieta
este sería sería el ejemplo que hemos ampliado alguna duda respecto a
esto recomendar algo nos parece interesante parece que es muy básico
realmente lo que era introducir en el callback en lo que estábamos en lo
que estábamos anterior en este caso sencillo seguramente la práctica de
la práctica pero pero seguramente será más complejo vamos a ver otro la
sesión que tenía preparada para hoy que es introducir en la carga
dinámica de códigos en este caso vamos a hacer este ejemplo también
basado en la página de oracle está puede encontrar un proyecto muy
similar a este mismo prácticamente modificado un poco y lo que tenéis en
este caso es un calculador de tareas de cualquier tipo tenemos un servidor
que lo que va a hacer es tener la posibilidad de recibir una tarea
modificada y ejecutarla esa es la idea de lo que vamos a hacer el uso en
este caso servidor como veis ofrece un método remoto que se llama ejecutar
tareas y que va a recibir una tarea y va a devolver luego un resultado y el
cliente que va a hacer pues va a definir una tarea, va a tener codificada
una tarea a realizar va a obtener objetos remotos calculadoras y va a
realizar la RMI a objetos remotos pasándole a la tarea de forma que el
servidor en la calculadora ejecutará la tarea que le estamos pidiendo es
decir, tú defines el trabajo que quieres que se realice, se lo pasas al
servidor y el servidor lo ejecuta, esa sería la idea de lo que queremos
hacer ¿Entendemos lo que queremos hacer? ¿Una duda de lo que queremos
hacer? Perfecto, pues bueno aquí tenéis un poquito un gráfico de lo que
en este caso las tareas lo que vamos a hacer en este caso, ¿no? Vamos a
limitarnos de las tareas van a ser cálculo de superficie, ¿vale? De
áreas, en este caso tenemos, vamos a hacer una serie de clientes podemos
tener un cliente rectángulo, un cliente triángulo, un cliente cuadrado y
cada uno tiene una forma de calcular su superficie y lo que va a hacer cada
uno de esos clientes es primero obtener el objeto remoto calculador y ya
hacer una RMI enviándole la tarea que quieren que se calcule y el servidor
una vez que ha realizado la tarea mandará el resultado al cliente sería
un poco la transparencia sino que no pasamos a calcular las normas
numéricas y cada uno de notar específica y ese vídeo se va a calcular la
calculada según la modificación que establece aquí entonces la
arquitectura rm y que vamos a contemplar en este caso tenemos una interfaz
remota de la calculadora un servidor que implementará esa interfaz remota
calculadora un cliente que sea la interfaz remota invocando al método
remoto que se van a ejecutar y las clases es el dictable que se enviarán
como argumento o resultado de remedio muy importante esto recordar que todo
lo que se pase entre a través de rm y debe ser serializable debe ser clase
simplemente en la que sería aquí tenéis un poco la estructura del
proyecto que tengo todo este proyecto ya sabéis que lo tenéis colgado en
el foro tenéis tanto las transparencias que estoy postulando como el
código asociado a los dos ejemplos tenéis en el propio mensaje del foro
denunciamos que hoy era la hora que era esta sesión pero como comentaba
que haremos cuatro proyectos en este caso uno será el proyecto común para
un servidor de cálculo que se llamará en este caso rena y seguidor que
tendrá la implementación de la interfaz remota calculadora y una clase
que será la que iniciará los clientes tendrán una clase que se inicia
cálculo o el nombre de la forma después del ángulo sea el nombre que
tenga después la forma y una clase seríaizable que implementará la tarea
que se quiere como el proyecto común vamos a pasar lo que contiene
contendrá la interfaz remota del cálculo la interfaz que empaqueta la
tarea que es que en este caso la interfaz remota cálculo es la interfaz de
la calculadora y la interfaz que empaqueta la tarea es simplemente una
clase que sería estable donde va a ir nada donde va a ir nada la clase
abstracta para arrancar una clase auxiliar donde se va a traer toda la
parte propia de remeis en esa clase Y una clase de auxiliar para la carga
política de seguridad que ya vimos en el ejemplo anterior. Aquí podéis
ver toda la estructura del proyecto. ¿Alguna duda respecto a esto? Bueno,
pues seguimos. Lo primero que vamos a hacer es definir la interfaz remota
cálculo.java, que es la interfaz remota del servidor, de la calculadora.
En este caso introducimos un detalle que no lo habíamos hecho hasta ahora,
que es que el nombre del servicio, del objeto, al fin y al cabo, remoto, lo
vamos a introducir como una variable, una constante. En este caso se llama
nombre de servicio, calculadora. Y luego definimos el método remoto. En
este caso vamos a utilizar los títulos. Los títulos son los títulos
genéricos para permitir que las tareas sean de cualquier tipo. Entonces,
en este caso lo que estamos haciendo es ejecutar una tarea del tipo T y que
devolverá un resultado del tipo T. Ya veremos luego simplemente cómo va a
funcionar. luego tenemos la interfaz remota que implementamos en el
servidor esta interfaz que hay aquí simplemente es una interfaz normal que
es la que vamos a implementar en cada una de las tareas que realizamos los
clientes y cuando definamos la tarea de los clientes implementaremos la
interfaz que veis que tienen un tipo genérico porque no sabemos la
respuesta en este caso la superficie podrá ser si lo limitamos al contexto
de las noticias estamos contando yo he puesto en un caso que siempre como
son enteros las medidas que estamos tomando que el resultado en el caso de
un cuadrado siempre va a ser un entero pero el caso un triángulo al tener
que dividir entre dos la fórmula pues puede ser ahí está la diferencia
en que te podrá ser entero o no pero en este caso es una interfaz normal
que implementaremos en cada en cada cliente para definir para implementar
definir cada uno del cálculo de su usuario cómo sé cómo se realiza
entonces vamos a no sé si hay alguna duda respecto a esto Bueno, vamos a
ver el primer cliente. Cada forma geométrica decimos que tiene codificada
su propia tarea de cálculo, ¿vale? Entonces implementaremos la interfaz
por un lado, tarea T, que es el tipo genérico y sería visible porque lo
vamos a enviar a un RNI. Entonces aquí veis que estamos implementando
estas dos interfaces. Tarea doble, en este caso yo lo pongo porque es un
triángulo y el triángulo al tener el cálculo introducir decimales pues
lo pongo como doble, ¿vale? Por eso en este caso implementamos tareas
dobles. El triángulo tendrá dos propiedades, la altura y la base, que se
le pasarán al constructor y aquí estamos implementando el método que
tiene la interfaz tarea. Y también... Tenemos que, en este caso lo
implementamos llamando a otro método que se llama calcula de triángulo,
le pasamos la base y la altura y te hace el cálculo. Y te devuelve un
doble con el cálculo que ha realizado. ¿Vale? Entonces esta tarea, vamos
a repasar un poquito lo que estamos haciendo, esta tarea la está
definiendo el cliente, pero es un objeto remoto que se pasará al servidor
y que será el servidor que lo objetiva. vale entonces vemos que ahora
vamos a ver cómo arrancamos esa tarea en el cliente en este caso hemos
hecho un cambio y lo que hemos hecho es extender de una de en este caso una
clase abstracta que se llama iniciar en iniciar en ahí tenemos una serie
de métodos que vamos a reutilizar y tenemos un método que hay que
construir que hay que implementar que sea una operación y cada uno que
extiende esa casa exacta tendrá que implementar esa operación rmi es
realmente lo que va a hacer la invocación de remedio acerca de cada cada
una de las clases simplemente esta casa está mal entonces en este caso
tenemos en la clase tenemos un inicio un constructor que inicia que inicia
él esta clase y a continuación en la operación de remedio que hará es
localizar porque era estático el método anterior este método pues no me
acuerda probar el foro igual no es necesario pero probarlo bueno pues
seguimos entonces en este caso lo que estamos viendo en el cliente es como
dicho enganchar con el lanzador recoger objetos remotos a través del
nombre que tiene definida por el propio objeto remoto tiene su nombre en la
interfaz entonces lo recogemos y creamos la continuación un objeto
triángulo la tarea de los triángulos que es la que vamos a pasar y
estamos creando la tarea triángulo pasándole los valores y estamos y se
la pasamos hacemos la rmi la llamada remota pasándole esa tarea y se
ejecutará en el servidor y nos devolverá la cantidad de doble en este
caso que proporciona el cálculo del área en este caso la base por altura
para ti o por no en este caso luego cosa destacar aquí en esta en los
fundamentales que tenemos la clase de rmi que compone todo lo básico
necesario para rm y bueno pasar la tarea una rmi al método remoto y luego
por la consola luego tenemos vamos a ver ahora en la calculadora que es el
objeto remota en la clase que implementa la interés remota cálculo
Entonces, los métodos que tienen que lanzar, tienen que lanzar remote
exception, perdón, y recibe la tarea como un argumento y la ejecuta de
forma local en el servidor. Devolverá el resultado del tipo genérico T.
Aquí veis la implementación, lo que estamos haciendo en la
implementación es súper simple. Veis que el tipo genérico es la
particularidad que tiene específica, veis que implementa la interfaz
remota, veis que lanza remote exception y veis que escoge una tarea de tipo
genérico T, informa en consola para que se sepa que estamos recibiendo una
petición de ejecutar algo y lo que hacemos es llamar al método ejecuta de
este objeto tarea T, que es una tarea definida en el código que tiene el
cliente. Esta es la clase que inicia el servidor. La clase que inicia el
servidor, en este caso, es... ¿Sabéis? Bueno, como lo hemos dicho en el
ejemplo anterior, el objeto remoto tiene que crearlo, en este caso, otra
clase auxiliar, que está, en este caso, creando... Estamos haciendo lo de
creando el registro de la forma que hemos comentado hoy, es decir...
creando el registro desde aquí, no tendríamos que lanzar en este caso
desde la consola ni desde Eclipse el RMI Registry de Java sino que ya lo
estamos arrancando desde ahí, lo estamos creando desde ahí en el puerto
en este caso, como nada me la gana, que es el 8.8.9 y creamos el objeto
remoto exportamos el objeto remoto a ese mismo puerto esto que está
comentado aquí sería lo que haríamos en el caso de que no hubiéramos
hecho la creación del RMI Registry de código, sino que lo hubiéramos
hecho en consola, eliminaríamos la primera línea subrayada y
utilizaríamos la segunda a continuación, como hemos comentado una vez que
tenemos ya el objeto exportable hacemos un rebind en este caso con el
nombre que lo define en la propia interfaz y dejamos la calculadora
preparada para recibir peticiones de cálculo. Cuando termine cuando le dé
a intro, ok, una tecla que esté en la consola del servidor, terminará la
ejecución de registrará el objeto hará un export del objeto también y
veis aquí que hace un export del Registry, aquí lo que estaríamos es
cortando la ejecución en el enlazador, vale, en esta última línea Esta
es la clase auxiliar que hemos utilizado, que se llama IniciarRMI, que es
una clase abstracta, y ahí esta clase lo que hace es recibir una clase
para obtener de ella la localización de las clases. Lo mismo que hacíamos
en el ejemplo anterior, para obtener el path donde están las clases que
tenemos que acceder para la propiedad code base, distanciarla, las tenemos
de aquí, de esta clase que nos pasa como argumento. Y luego definimos la
política de seguridad a partir de un fichero que teníamos en el proyecto
común, y de aquí creamos el gestor de seguridad en caso de que no
estuviera creado. Y lo último que hacemos es llamar a OperaciónRMI, que
veis que OperaciónRMI es el método abstracto que tenemos que implementar
en la clase que haya heredado de IniciarRMI. Vemos que he comentado eso,
invocamos al método abstracto OperaciónRMI, que será el que
implementará cada clase. esta es la clase política de seguridad que
también vimos anteriormente para lo que nos sirve para coger el contenido
del fichero en este caso que veis aquí el fichero permite una seguridad un
poco de coña porque sería una seguridad entendemos todo abierto dejamos
hacerle todo a al invasor entonces realmente cuando hay una producción de
este tipo de política de seguridad pero en este caso estamos haciendo
problemas esta política de esa política la cargaremos en el sector de
seguridad tras esta clase y por último ya veríamos la ejecución como en
este caso no tendríamos que lanzar el lanzador porque ya no hemos lanzado
lo hemos arrancado desde la clase que inicia el servicio desde ahí hemos
arrancado el lanzador por tanto no tendríamos que hacer ninguna de las
cosas que viene ni utilizar un plugin para abrirlo ni desde consolas con el
que las paredes en este caso lanzando de consola desde la paz desde la ruta
donde estén nuestros nuestras clases los típicos errores que hemos visto
anteriormente, que hemos comentado anteriormente, que está bien que
tengamos en cuenta. Y por último vamos a ver las consolas, cómo quedaría
el posible resultado, en este caso, para distintos clientes. En este caso,
al ejecutar, primero ejecutaríamos el servidor, en el orden está el
revento, primero ejecutaríamos el servidor, se quedaría esperando aquí y
a continuación empezaríamos a hacer decisiones de cliente o de cuadrado o
triángulo, que eso lo hemos implementado. En el caso de ese un cuadrado es
un entero lo que devuelve, como veis por eso no aparece un punto decimal, y
en el caso del triángulo devuelve un doble, que por eso aparece un punto
decimal. Y con esto hemos terminado. Aquí tenéis en la tarjeta de línea
el enlace de donde se ha sacado este tutorial, este ejemplo que hemos visto
de carga de código dinámico. Y con esto pues más o menos tenemos lista
la sesión de hoy. El próximo día haremos otro pequeño proyecto, con
otros temillas ampliaremos un poquillo más estos temas. Y nada, si tenéis
cualquier duda comentádmela ahora y si no, nos vemos en el próximo video.
Pues por el foro intentaremos comentarla. Si no se descarga el código, si
se descarga el código. Está viendo, si se descarga el código. esto se
está cargando el código del cliente en el servidor en este caso no sé si
ha entendido eso en el caso de descargarlo de hecho si veis en los ejemplos
anteriores en él tanto en el 6 como nación 6 como la primera sesión que
la política que hemos hecho antes en esos casos estaba descargando y no
era necesario crear una política de seguridad un puesto de seguridad
porque porque realmente no está pasando por el código de un servidor
sólo está invocando un método alguna pregunta pues si no tenemos
preguntas nos vemos la semana que viene a la misma hora y nada si tenéis
se podía realizar un ejemplo o alguna dirección web para concesiones un
ejemplo de una dirección web para confesiones seguramente lo que me estás
preguntando es algo relacionado con la práctica como te he dicho antes no
he mirado el contenido exactamente a qué te refieres o te refieres a
confesiones a LIS, ¿te refieres a utilizar LIS? ¿te refieres a utilizar
LIS? ah, vale, sí, sí, vale bueno, intentaré mirarlo tengo preparada ya
la sesión si me da tiempo introduzco algún concepto pero no sé si
tendré si me da tiempo prepararlo yo le he hecho mi casillo a ver si puedo
ampliar lo que tengo y introducir ese concepto muy bien, pues me voy a
intentar echar los mis casillos nada un saludo y nada, que vaya todo muy
bien que vaya la semana bien y que siga ahí trabajando un abrazo