java Web Service Local (Java)

[brureisoliveira]

Olá!

Tenho duas classes para validação de CPF. Uma classe solicita o número de CPF e a segunda valida.
 Preciso fazer com que a validação seja por meio de um retorno do servidor web local.
 No caso a classe "ValidaCPF". Ou seja, preciso desenvolver um servidor "classe ValidaCPF"
e um cliente para consumir "Classe Exemplo".Tenho o Apache Axis instalado e rodando no
endereço: http://localhost:8080/axis/

Como faço de forma simples essa conexão?

Segue as classes:

Cliente...

//pacote utilizado para o projeto (APS)
package aps_webservice;

//java.util.Scanner
//Um scanner de texto simples que pode analisar tipos primitivos e strings usando expressões regulares.
//A Scanner quebra sua entrada em tokens usando um padrão delimitador, que por padrão corresponde a espaços em branco.
//Os sinais resultantes podem então ser convertidos em valores de tipos diferentes, usando os vários métodos seguintes.
import java.util.Scanner;
//classe pública para teste da validação do CPF
public class Exemplo {
//método main (utilizado para inicialização da aplicação)
public static void main(String[] args) {
//instanciando a classe Scanner com o nome "lercpf"
Scanner lercpf = new Scanner(System.in);
//variável cpf utilizada para armazenar o valor digitado
String cpf;
//tela para solicitação de um número de CPF
System.out.printf("Informe o número do CPF: ");
//após ler o valor digitado, o mesmo será armazenado na variável "cpf"
cpf = lercpf.next();

System.out.printf("\nResultado da validação: ");
//chamada dos métodos calculocpf e imprimecpf da classe "validacpf"
//se o valor digitado for validado como verdadeiro
//será impresso a mensagem de validação Ok
if (validacpf.calculocpf(cpf) == true)

    
    System.out.printf("%s\n", validacpf.imprimecpf(cpf));
//caso contrário, uma mensagem de erro será impressa
else System.out.printf("CPF inválido!\n");
}
}

Servidor:

//pacote utilizado para o projeto (APS)
package aps_webservice;
//InputMismatchException: indica  se o token recuperado corresponde ao padrão
//para o tipo esperado, ou se o sinal está fora do intervalo para o tipo esperado.
import java.util.InputMismatchException;
//classe pública "validacpf" utilizada para o cáculo de validação do CPF
public class validacpf {
//método booliano utilizado para verificar se os valores digitados estão nos padrões esperado
//será verificado a String digitada
//o método conterá todo o cálculo do CPF

public static boolean calculocpf(String CPF) {
// considera-se erro CPF's formados por uma sequência de numeros iguais
//método equals será utilizado para comparação
 if (CPF.equals("00000000000") || CPF.equals("11111111111") || CPF.equals("22222222222") ||
CPF.equals("33333333333") || CPF.equals("44444444444") || CPF.equals("55555555555") || CPF.equals("66666666666") ||
CPF.equals("77777777777") || CPF.equals("88888888888") || CPF.equals("99999999999") ||
//ou uma sequência menor que onze
(CPF.length() != 11))
//caso o valor digitado seja uma sequência de números iguais ou menor que 11 dígitos,
//será retornado uma mensagem com alerta informado que o valor
//digitado não está correto e/ou esperado
return(false);
//O algoritmo de validação do CPF calcula o primeiro dígito verificador a partir dos 9 primeiros dígitos do CPF,
//e em seguida, calcula o segundo dígito verificador a partir dos 9 (nove) primeiros dígitos do CPF, mais o primeiro
//dígito, obtido na primeira parte.
 
//variáveis para armazenar os dois últimos dígitos do CPF
char d10, d11;

int soma, i, r, num, p;
 // "try" - faz uma proteção em caso de erros na  conversão de tipo (int)

try {
    
//O algoritmo de validação do CPF calcula o primeiro dígito verificador a partir dos 9
//primeiros dígitos do CPF,
//e em seguida, calcula o segundo dígito verificador a partir dos 9 (nove) primeiros dígitos do CPF, mais o primeiro dígito,
//obtido na primeira parte.
//Como exemplo, usarei  o CPF fictício: 524344218-65.

// cálculo do primeiro dígito verificador
    
///--------
//sm: irá somar os resultados da multiplicação dos 9 dígitos informados (524344218) por exemplo
soma = 0;
//irá percorrer de forma decrescente os dígitos (10,9,8,7,6,5,4,3,2)
p = 10;
//estrutura de repetição para verificação do 1º dígito verificador
//a variável i irá repetir até i<9 incrementando de 1 em 1
for (i=0; i<9; i++) {
// converte o i-esimo caractere do CPF em um numero:
// por exemplo, transforma o caractere '0' no inteiro 0

//método charAt: retorna o caracter da posição "n" na string digitada.
num = (int)(CPF.charAt(i) - 48); // (48 é a posição de '0' na tabela ASCII)
//soma os resultado da multiplicação entre o caracter da string e o decremento de "p"
//nesse exemplo: (num * p)=(5*10);(2*9)...(8*2)
soma = soma + (num * p);
//decrementa o valor de "p" (10,9,8,7...)
p = p - 1; }
//após a soma, devemos dividir o resultado por "11"
//Se o resto da divisão for maior ou igual a 2, então o dígito verificador é igual a 11 menos o resto da divisão (11 - r).
r = 11 - (soma % 11);
//se o resto da divisão for 10 ou 11
if ((r == 10) || (r == 11))
//então o 1º dígito verificador será 0
d10 = '0';

else d10 = (char)(r + 48); // converte no respectivo caractere numérico

//cálculo do segundo dígito verificador
//como já sabemos o valor do primeito dígito, a variável "p" recebe o valor "11"
//isso indica que a variável "soma" irá conter o novo dígito localizado
soma = 0;
//irá percorrer de forma decrescente os dígitos (11,10,9,8,7,6,5,4,3,2)
p = 11;
//estrutura de repetição para verificação do 2º dígito verificador
//a variável i irá repetir até i<10 incrementando de 1 em 1
for(i=0; i<10; i++) {
// converte o i-esimo caractere do CPF em um numero:
// por exemplo, transforma o caractere '0' no inteiro 0
//método charAt: retorna o caracter da posição "n" na string digitada.    
num = (int)(CPF.charAt(i) - 48); // (48 é a posição de '0' na tabela ASCII)
////soma os resultado da multiplicação entre o caracter da string e o decremento de "p"
//nesse exemplo: (num * p)=(5*11);(2*10)...(6*2) ---->6:primeiro dígito verificador no exemplo fictício
soma = soma + (num * p);
//decrementa o valor de "p" (11,10,9,8,7...)
p = p - 1; }
//a variável "r" armazena o resta da soma dividido por 11.
//assim, "r" será 11- (soma/11)
r = 11 - (soma % 11);
//se o resto for igual a 10 ou 11
if ((r == 10) || (r == 11))
//o segundo dígito verificador será "0"    
d11 = '0';
//caso contrário, será efetuado uma conversão para o respectivo caractere numérico
else d11 = (char)(r + 48); // (48 é a posição de '0' na tabela ASCII)
 // valida se os dígitos calculados conferem com os dígitos informados.
if ((d10 == CPF.charAt(9)) && (d11 == CPF.charAt(10)))
//caso sim, será retornado true
return(true);
//caso não, será retornado false
else return(false);
//InputMismatchException: indica  se o token recuperado corresponde ao padrão
//para o tipo esperado, ou se o sinal está fora do intervalo para o tipo esperado.
} catch (InputMismatchException erro) { return(false);
}
 }
//método utilizado para imprimir o cpf formatado
//o método substring "divide" uma string em pequenas partes . No exemplo ficará "524.344.218-65"
public static String imprimecpf(String CPF) {
    System.out.println("CPF válido!");
return(CPF.substring(0, 3) + "." + CPF.substring(3, 6) + "." + CPF.substring(6, 9) + "-" + CPF.substring(9, 11));
}
 }