FALCULTAD DE CIENCIAS DE LA

COMPUTACIÓN

MATERIA: PROGRAMACIÓN DISTRIBUIDA

PROFESOR: LUZ ADOLFINA SÁNCHEZ

GÁLVEZ

ALUMNOS: KEVIN ALEJANDRO ZENTENO

FLORES, OSCAR RENE SALGADO GUZMAN

TAREA: Servicios Web

29/05/2023
 Introducción
Un Servicio Web es un componente al que podemos acceder
mediante protocolos Web estándar, utilizando XML para el
intercambio de información.
Normalmente nos referimos con Servicio Web a una colección de
procedimientos (métodos) a los que podemos llamar desde
cualquier lugar de Internet o de nuestra intranet, siendo este
mecanismo de invocación totalmente independiente de la
plataforma que utilicemos y del lenguaje de programación en el
que se haya implementado internamente el servicio.
Los servicios Web son componentes de aplicaciones distribuidas
que están disponibles de forma externa. Se pueden utilizar para
integrar aplicaciones escritas en diferentes lenguajes y que se
ejecutan en plataformas diferentes. Los servicios Web son
independientes de lenguaje y de la plataforma gracias a que los
vendedores han admitido estándares comunes de Servicios Web.
Los servicios Web proporcionan una forma estándar de
interoperar entre aplicaciones software que se ejecutan en
diferentes plataformas. A los servicios web se le entiende por un
conjunto de aplicaciones o de tecnologías incluyendo XML, SOAP,
WSDL, UDDI con capacidad para interoperar en la Web.

OBJETIVO

Para esta práctica se Implementa una aplicación distribuida con

una clase IOArchivo con funcionalidades en archivos de texto,
utilizando Servicios Web. La clase debe tener un constructor con
un parámetro de tipo String, que represente el nombre del
archivo en el que operar, y debe tener los siguientes métodos:
int cuentaLineas (String nombrearchivo): que devuelva el número
de líneas del archivo;
int cuentavocales (String nombrearchivo): que devuelva el
número de líneas del archivo;
void escribe (OutputStream os): que escriba el contenido del
archivo a os;
void imprimir () que imprima el contenido del archivo a pantalla;
void respaldar(String nombrearchivo) que respalde el archivo;
void copiar (String nombrearchivodestino): que copie el contenido
de un archivo fuente a un archivo destino nombrearchivodestino;
void renombrar(String nombrearchivo) que renombre el archivo
void eliminar(String nombrearchivo) que elimine el archivo de
almacenamiento masivo.

SUSTENTO TEÓRICO.

Los servicios web son aplicaciones de cliente y servidor que se

comunican a través del Protocolo de transferencia de hipertexto
(HTTP) de la World Wide Web (WWW). Tal como lo describe el
World Wide Web Consortium (W3C), los servicios web
proporcionan un medio estándar de interoperabilidad entre
aplicaciones de software que se ejecutan en una variedad de
plataformas y marcos. Los servicios web se caracterizan por su
gran interoperabilidad y extensibilidad, así como por sus
descripciones procesables por máquina, gracias al uso de XML.
Los servicios web se pueden combinar de forma flexible para
lograr operaciones complejas. La interoperabilidad se consigue
mediante la adopción de estándares abiertos. Las organizaciones
OASIS y W3C son los comités responsables de la arquitectura y
reglamentación de los servicios Web. El WC3 (World Wide Web
Consortium) define un servicio Web como un sistema software
diseñado para soportar interacciones máquina a máquina a través
de la red. REST y SOAP son dos enfoques distintos para la
transmisión de datos en línea. Específicamente, ambas definen
cómo diseñar interfaces de programación de aplicaciones (API),
las cuales permiten la comunicación de datos entre aplicaciones
web. La transferencia de estado representacional (REST) es un
conjunto de principios arquitectónicos; mientras que el protocolo
simple de acceso a objetos (SOAP) es un protocolo oficial, cuyo
mantenimiento está a cargo del Consorcio World Wide Web (W3C).
La principal diferencia es que SOAP es un protocolo, y REST no lo
es. Por lo general, alguno de los dos regirá a las API, según el
caso práctico y las preferencias del desarrollador.
REST es un conjunto de principios arquitectónicos que se ajusta a
las necesidades de las aplicaciones móviles y los servicios web
ligeros. Dado que se trata de un conjunto de pautas, la
implementación de las recomendaciones depende de los
desarrolladores.

Cuando se envía una solicitud de datos a una API de REST, se

suele hacer a través de un protocolo de transferencia de
hipertexto, comúnmente denominado HTTP.
SOAP es un protocolo estándar que se creó originalmente para
posibilitar la comunicación entre las aplicaciones que se
diseñaban con diferentes lenguajes y en distintas plataformas.
Como es un protocolo, impone reglas integradas que aumentan la
complejidad y la sobrecarga, lo cual puede retrasar el tiempo que
tardan las páginas en cargarse. Sin embargo, estos estándares
también ofrecen normas integradas que pueden ser ideales para
el sector empresarial. Los estándares de cumplimiento
integrados incluyen la seguridad, la atomicidad, la uniformidad, el
aislamiento y la durabilidad (ACID), que forman un conjunto de
propiedades que garantizan operaciones confiables de las bases
de datos.
Los grandes servicios web utilizan mensajes XML que siguen el
estándar del Protocolo simple de acceso a objetos (SOAP), un
lenguaje XML que define una arquitectura de mensajes y formatos
de mensajes. Dichos sistemas a menudo contienen una
descripción legible por máquina de las operaciones ofrecidas por
el servicio, escrita en el lenguaje de descripción de servicios web
(WSDL), un lenguaje XML para definir interfaces sintácticamente.
REST es ideal para escenarios de integración ad hoc básicos. Los
servicios web RESTful, a menudo mejor integrados con HTTP que
los servicios basados en SOAP, no requieren mensajes XML ni
definiciones de API de servicio WSDL.
La vista del cliente de un servicio Web es bastante similar a la de
un Enterprise JavaBean. Un cliente de un servicio Web puede ser
otro servicio Web, un componente Java EE (componente web,
componente EJB), incluyendo una aplicación cliente Java EE, o
una aplicación Java arbitraria. Una aplicación no Java o un
servicio Web para una aplicación no Java EE también podrían ser
clientes de un Servicio Web, pero vamos a ceñirnos a la
plataforma Java EE.
El cliente de un servicio Web puede ser remoto (no se requiere
que resida en la misma máquina que el servicio Web) y se
proporciona una total transparencia al respecto (el cliente no
puede distinguir si está accediendo a un servidor local o remoto).
Las especificaciones comunes de los servicios web incluyen lo
siguiente:

• Seguridad de los servicios web (WS-Security):

estandariza la forma de proteger y transferir los
mensajes usando identificadores únicos llamados tokens.
• Mensajería segura de los servicios web (WS-
ReliableMessaging): estandariza el control de errores
entre mensajes que se transfieren en infraestructuras de
TI poco confiables.
• Abordaje de los servicios web (WS-Addressing): paquetes
que enrutan la información como metadatos dentro de los
encabezados SOAP, en lugar de mantener la información
en un lugar más profundo de la red.
• Lenguaje de descripción de los servicios web (WSDL):
describe qué hace un servicio web, así como dónde
comienza y termina.

DESARROLLO

Vamos a ver ahora cómo crear un cliente de servicios web de

forma visual mediante Netbeans. Este entorno utilizará
internamente las librerías y herramientas estándar de Sun para
crear stub del cliente.
Se crean un proyecto y crear una aplicación web:
Tenemos instalado GlassFish server 4.1.1 con Java EE 7 web:

Creamos un nuevo servicio web:

En la sección de las carpetas del proyecto se crean dos

componentes, uno de ellos es el nuevo servicio web en la carpeta
Web Services, dicho archivo contiene un código por defecto. En la
parte del editor encontramos la pestaña design, funciona para
agregar y eliminar los métodos del servicio web:

• @WebMethod – anotación para indicar el nombre de la

función del webservice
• @WebParam – anotación para indicar los parámetros que
recibirá nuestra función

En la pestaña design agregamos las operaciones:

El código queda de la siguiente forma:

@WebMethod(operationName = "countVowelsInFile")
public int countVowelsInFile(@WebParam(name = "file") DataHandler
file) {
try {
InputStream inputStream = file.getInputStream();
int vowelCount;
try (BufferedReader reader = new BufferedReader(new
InputStreamReader(inputStream))) {
String line;
vowelCount = 0;
while ((line = reader.readLine()) != null) {
vowelCount += countVowelsInString(line);
}
}
return vowelCount;
} catch (IOException e) {
return -1; // Valor de retorno para indicar un error
}
}

private int countVowelsInString(String text) {

int count = 0;
text = text.toLowerCase();
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c ==
'u') {
count++;
}
}
return count;
}

@WebMethod(operationName = "copyFile")
public boolean copyFile(@WebParam(name = "file") DataHandler file,
@WebParam(name = "destinationPath") String
destinationPath) {
try {
// Obtener el nombre del archivo original
String originalFileName = getOriginalFileName(file);

// Construir la ruta completa de destino

String destinationFilePath = destinationPath +
File.separator + originalFileName;

// Crear un nuevo archivo en la carpeta de destino

 File destinationFile = new File(destinationFilePath);

// Copiar el archivo
try (FileOutputStream outputStream = new
FileOutputStream(destinationFile)) {
file.writeTo(outputStream);
}

// El archivo se copió exitosamente

return true;
} catch (IOException e) {
// Ocurrió un error al copiar el archivo
e.printStackTrace();
return false;
}
}

private String getOriginalFileName(DataHandler file) {

// Extraer el nombre del archivo original de DataHandler
return file.getName();
}

@WebMethod(operationName = "renameFile")
public boolean renameFile(@WebParam(name = "currentPath") String
currentPath,
@WebParam(name = "newName") String newName) {
try {
Path currentFilePath = Paths.get(currentPath);
Path newFilePath = currentFilePath.resolveSibling(newName);

Files.move(currentFilePath, newFilePath,
StandardCopyOption.REPLACE_EXISTING);

return true; // El archivo se ha renombrado exitosamente

} catch (IOException e) {
e.printStackTrace();
return false; // Ocurrió un error al renombrar el archivo
}
}

@WebMethod(operationName = "deleteFile")
public boolean deleteFile(@WebParam(name = "filePath") String
filePath) {
try {
File file = new File(filePath);
return file.delete();
} catch (Exception e) {
e.printStackTrace();
 return false;
}
}
@WebMethod(operationName = "countLinesInFile")
public int countLinesInFile(@WebParam(name = "filePath") String
filePath) {
try {
File file = new File(filePath);
int lineCount = 0;
try (BufferedReader reader = new BufferedReader(new
FileReader(file))) {
while (reader.readLine() != null) {
lineCount++;
}
}
return lineCount;
} catch (IOException e) {
e.printStackTrace();
return -1; // Valor de retorno para indicar un error
}
}

@WebMethod(operationName = "getFileContent")
public String getFileContent(@WebParam(name = "filePath") String
filePath) {
try {
File file = new File(filePath);
StringBuilder content = new StringBuilder();
try (BufferedReader reader = new BufferedReader(new
FileReader(file))) {
String line;
while ((line = reader.readLine()) != null) {
content.append(line).append("\n");
}
}
return content.toString();
} catch (IOException e) {
e.printStackTrace();
return "Error al leer el archivo.";
}
}

@WebMethod(operationName = "backupFile")
public boolean backupFile(@WebParam(name = "filePath") String filePath,
@WebParam(name = "backupPath") String
backupPath) {
try {
File file = new File(filePath);
 File backupFile = new File(backupPath);

// Verificar si el archivo de backup ya existe

if (backupFile.exists()) {
return false;
}

// Copiar el archivo original al archivo de backup

Files.copy(file.toPath(), backupFile.toPath());

return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}

Lo continuaría seria desplegar el servicio web:

A continuación, lo procede es correr el proyecto:

RESULTADOS

Ejecución:
Ejecución de contador de vocales, copia y renombrar:

Eliminar archivo y contar líneas:

 CONCLUSION

La principal razón para usar servicios Web es que se pueden

utilizar con HTTP sobre Transmission Control Protocol (TCP) en el
puerto de red 80. Dado que las organizaciones protegen sus
redes mediante firewalls (que filtran y bloquean gran parte del
tráfico de Internet), cierran casi todos los puertos TCP salvo el 80,
que es, precisamente, el que usan los navegadores web. Los
servicios Web utilizan este puerto, por la simple razón de que no
resultan bloqueados. Es importante señalar que los servicios web
se pueden utilizar sobre cualquier protocolo, sin embargo, TCP es
el más común.

Otra razón es que, antes de que existiera SOAP, no había buenas

interfaces para acceder a las funcionalidades de otras
computadoras en red. Las que había eran ad hoc y poco
conocidas, tales como Electronic Data Interchange (EDI), Remote
Procedure Call (RPC), u otras API. Es posible que muchos
sistemas heredados sigan rigiéndose por SOAP, aunque REST
haya surgido más tarde y se considere una alternativa más rápida
en los escenarios basados en la Web. REST es un conjunto de
pautas que ofrece una implementación flexible, mientras que
SOAP es un protocolo con requisitos específicos, como en el caso
de la mensajería XML.