Desenvolvimento de uma ferramenta para comunicação em rede

Prévia do material em texto

UNIVERSIDADE PAULISTA - UNIP 
 CIÊNCIA DA COMPUTAÇÃO 
 
 
 
 
 
 
 
 
 
 
 
APLICABILIDADE DA COMUNICAÇÃO NO SETOR AMBIENTAL 
Desenvolvimento de uma ferramenta para comunicação em rede 
 
 
 
 
 
 
 
 
 
 
SÃO PAULO – SP 
2020 
 
 
 
 
 
 
 
 
 
APLICABILIDADE DA COMUNICAÇÃO NO SETOR AMBIENTAL 
Desenvolvimento de uma ferramenta para comunicação em rede 
 
 
 
 
Trabalho semestral apresentado à 
Universidade Paulista como parte dos 
requisitos para aprovação de semestre do 
curso Bacharel em Ciência Da 
Computação. 
 
Orientador: Msc. Arthur Battaglia 
 
 
 
 
 
 
 
 
 
 
 
SÃO PAULO – SP 
2020 
 
 
Sumário 
 
1. INTRODUÇÃO ...................................................................................................... 5 
2. OBJETIVO ............................................................................................................ 9 
3. REDES DE COMPUTADORES: O QUE É? ....................................................... 10 
4. FUNDAMENTOS DA COMUNICAÇÃO DE DADOS EM REDE ......................... 13 
4.1. Pilares da comunicação de dados ............................................................... 13 
4.2. Componentes fundamentais ........................................................................ 13 
4.3. Transmissões de dados ............................................................................... 14 
4.3.1. Sentido das trocas de transmissões ......................................................... 14 
4.3.2. Modo de transmissão ................................................................................ 14 
4.4. Sincronização ............................................................................................... 15 
4.5. Tipos de redes ............................................................................................. 16 
4.5.1. Redes locais ............................................................................................. 17 
4.5.2. Redes metropolitanas ............................................................................... 18 
4.5.3. Redes geograficamente distribuídas ......................................................... 18 
4.5.4. Redes sem fios ......................................................................................... 18 
4.5.5. Inter-redes ................................................................................................. 19 
4.6. Sockets de Berkeley..................................................................................... 19 
5. O CONTROLE DE QUEIMADAS NO TERRITÓRIO AMAZÔNICO .................... 21 
5.1. Metodologia de pesquisa utilizada ............................................................... 22 
5.1.1. Resultados da metodologia de pesquisa utilizada .................................... 23 
5.1.2. Como proceder? ....................................................................................... 28 
6. O PROJETO ....................................................................................................... 29 
6.1.1. O projeto ................................................................................................... 29 
6.2. Classe cliente ............................................................................................... 30 
6.2.1. Classe home ............................................................................................. 32 
6.2.2. Classe login .............................................................................................. 34 
6.2.3. Classe utils ................................................................................................ 37 
6.2.4. Classe cliente listener ............................................................................... 38 
6.2.5. Classe server ............................................................................................ 39 
6.3. Como o programa deve ser .......................................................................... 41 
6.4. Diagrama de caso de uso e o diagrama de classe da aplicação ................. 44 
7. PLANO DE DESENVOLVIMENTO DO PROJETO ............................................. 45 
7.1. Conceitos básicos: linguagem de programação Java .................................. 45 
 
 
7.2. Interface gráfica da aplicação ...................................................................... 48 
7.3. O chat ........................................................................................................... 58 
7.4. Cliente .......................................................................................................... 61 
7.5. Servidor ........................................................................................................ 63 
7.6. Conceitos básicos: banco de dados ............................................................. 66 
7.6.1. SQLite ....................................................................................................... 67 
7.7. Caso de uso: o que cada usuário pode fazer na aplicação? ........................ 68 
8. LINHAS DE CÓDIGO DO PROGRAMA ............................................................. 69 
9. REFERÊNCIAS BIBLIOGRÁFICAS ................................................................... 76 
 
 
5 
 
 
1. INTRODUÇÃO 
 
No mundo contemporâneo, a comunicação tornou-se umas das 
necessidades fundamentais da sociedade humana desde o início de sua existência. 
A medida em que as civilizações se expandiam, ocupando locais cada vez mais 
longínquos geograficamente, a comunicação a distância tornava-se, 
consequentemente, uma grande necessidade. Alguns Modi operandi de 
comunicação de nossos antepassados, por exemplo, eram através de sinalização de 
fumaça, ou, a utilização de pombos-correios para tentar diminuir a distância entre as 
comunidades. 
Nós, seres humanos, sempre fomos ávidos por meios de comunicações 
mais instantâneas, ágeis. Seja através de um simples e-mail entre prestadores de 
serviço de uma mesma empresa ou até mesmo em um chat entre dois 
representantes de grandes indústrias distintas. 
À época, Samuel F. B. Morse, no ano de 1838, estabeleceu uma nova era 
em se tratando de comunicações, sendo o inventor do telégrafo. Os telégrafos 
iniciais utilizados no século XIX tinham suas mensagens encriptadas em cadeias de 
símbolos binários, conhecido como código Morse, e eram enviadas manualmente 
por meio de um operador através de um dispositivo que emitiam impulsos elétricos. 
A partir deste ponto, a comunicação por meio de impulsos elétricos passou por uma 
grande evolução, originando uma grande parte dos sistemas de comunicação que 
conhecemos atualmente, como, por exemplo, o rádio, a televisão e o telefone. 
Uma das ferramentas primárias para chat a ser documentada, foi a 
Internet Relay Chat (IRC). Desde então, melhorias foram sendo feitas em 
ferramentas de chat em tempo real, visando uma melhor performance em quesito 
velocidade e segurança. 
Em dias atuais, chats em tempo real se fazem presentes em escala 
mundial, desde ferramentas em computadores a aplicações em dispositivos mobiles. 
Diferente dos chats iniciais, por sua vez, esses entregam uma performance melhor 
em velocidade e possuem criptografia, priorizando a integridade de seus usuários. 
6 
 
O tratamento de informações, após evoluções, não ocorreu de forma 
isolada na área da comunicação. Ferramentas para processamento e armazenagem 
de dados tornaram-se também alvo de invenções ao passo em que nós fomos nos 
desenvolvendo. A inserção de sistemas computacionais no ano de 1950 foi, 
possivelmente, um dos grandes avanços do século neste quesito. 
A princípio, os computadores eram máquinas extremamente caras que 
concentravam em um só ponto o processamento das aplicações de inúmeros 
usuários e, grande parte das vezes, de uma organização inteira. Com a diminuição 
de custos do hardware e a inserção dos micros no âmbito da informática, aestrutura 
centralizada deu lugar a uma outra estrutura, na qual diferencia-se por ser 
amplamente distribuída, onde o aporte tecnológico de inúmeros portes variados 
processam dados de maneira isoladas, acarretando, consequentemente, alguns 
contratempos, como, por exemplo, a duplicação sem necessidade de recursos de 
hardware e de software. 
A sintetização dos computadores e das comunicações teve uma grande 
influência no modo como organizavam-se os sistemas computacionais. Encontra-se 
completamente em desuso, obsoleto, o conceito de um ‘centro computacional’, na 
qual os usuários levavam os programas a serem processados. O exemplo arcaico 
de um computador que atende todas as necessidades relacionadas à computação 
organizacional foi trocado por redes de computadores, onde realizam-se trabalhos 
por uma série de computadores interligados. 
Uma rede, é um grupo de, pelo menos, dois computadores que são 
interligados entre si, de modo que consiga haver comunicação uns com os outros 
compartilhando recursos e dados com maior agilidade e uma melhor logística. 
Uma rede, segundo (FOROUZAN, 2007), é um conjunto de dispositivos 
(normalmente conhecido como nós) conectados por links de comunicação. Um nó 
pode ser um computador, uma impressora ou outro dispositivo de envio e/ou 
recepção de dados, que estejam conectados a outros nós da rede. 
Uma rede computacional permite ao usuário realizar o compartilhamento 
de uma grande quantidade de dados e envio de mensagens uns aos outros, 
inclusive textos, imagens e vídeos. 
7 
 
Não dependendo do tamanho e do grau de sua complexidade, o objetivo 
de uma rede é assegurar que os recursos de dados a serem compartilhado, tenha 
um compartilhamento ágil, seguro e de maneira confiável. Para que isso ocorra, a 
rede em questão deve ter um aporte eficiente propiciando o ensejo, através de 
transmissões eficientes, normativas básicas (chamada de protocolos) e de 
mecanismos que sejam capazes de assegurar envio de informação entre os 
elementos que os compõem. 
Tendo como base o tempo de estudo e absorção dos conteúdos 
transmitidos em aulas, acreditamos que uma aplicação construída na linguagem de 
programação JAVA, pode, de maneira satisfatória, ajudar na elaboração de uma 
ferramenta para a comunicação em rede via chat e, juntamente utilizando-se das 
premissas dos Sockets de Berkeley, desenvolver uma ferramenta simples para a 
elaboração de um correio de voz. 
Através de pesquisas e análises, o vigente trabalho ambiciona descrever 
a metodologia de desenvolvimento de uma ferramenta de comunicação em rede, 
desde sua idealização até seu processo de finalização. 
Por fim, torna-se também um objetivo da ferramenta atender às 
necessidades do IPAM (INSTITUTO DE PESQUISA AMBIENTAL DA AMAZÔNIA), 
que tem interesse em ficar a par das atividades de queimadas, e, por consequência, 
o desmate por queimada e focos de incêndios, sendo ele criminoso ou não, a fim de 
combater casos que ocasionem poluição do ar nas adjacências do território 
amazônico, com ênfase nos municípios dos estados do Amazonas, Pará, Rondônia, 
Roraima e Mato Grosso. 
Para que haja acuracidade no repasse das informações, a equipe precisa 
trocar mensagens instantâneas com a central, que fiscaliza, via satélite, possíveis 
focos de incêndios e/ou desmate do solo que envolvam queimadas. 
O Instituto de Pesquisa Ambiental da Amazônia (IPAM) é uma 
organização científica, não governamental, apartidária e sem fins lucrativos que 
desde 1995 trabalha pelo desenvolvimento sustentável da Amazônia. O objetivo do 
IPAM é consolidar, até 2035, o modelo de desenvolvimento tropical da Amazônia, 
por meio da produção de conhecimento, implementação de iniciativas locais e 
8 
 
influência em políticas públicas, de forma a impactar o desenvolvimento econômico, 
a igualdade social e a preservação do meio ambiente. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9 
 
2. OBJETIVO 
 
As Atividades Práticas Supervisionadas do 5º Semestre de 2020 do Curso 
de Ciência da Computação, tem por seu objetivo a pesquisa bibliográfica e a 
elaboração de uma ferramenta para uma aplicação de comunicação em rede. Para 
tal, a apresentação do desenvolvimento de uma aplicação desse nível contempla o 
uso da seguinte linguagem de programação JAVA juntamente com o auxílio do 
SQLite, em linguagem SQL, para que possa ser desenvolvido um local de 
armazenamento de informações. 
No intuito de satisfazer e cumprir o que foi proposto para o trabalho 
acadêmico semestral vigente, desenvolver um software baseado nas premissas dos 
sockets de Berkeley tornou-se nossa base para atingir o objetivo principal, que visa 
a criação de uma ferramenta de comunicação em rede via chat. Não menos 
importante, é, compreender os conceitos, a utilização e aplicação das redes de 
computadores, buscando os benefícios que o estudo da técnica selecionada 
proporciona. 
Visa-se, também, entender como o processo de desmatamento por 
queimadas no solo do território amazônico ocorre, com uma breve abordagem do 
assunto, tentando encontrar uma solução para um equilíbrio ambiental resultando na 
boa qualidade do ar, no bom funcionamento da fauna e da flora. 
10 
 
 
 
3. REDES DE COMPUTADORES: O QUE É? 
 
Denomina-se rede computadores um determinado grupo de sistemas de 
computação e alguns outros dispositivos de hardware, que, entre si, estão conectados 
por meio de canais de comunicação e compartilhamento de informações entre 
usuários, a fim de facilitar esse compartilhamento. Basicamente falando, toda vez que 
houver um conjunto de máquinas interligadas entre si, ali se estabelecerá uma rede. 
Tomando como exemplo, as iniciais redes de computadores foi a que 
existia no exército norte-americano, que funcionava como parte do sistema de radar. 
No ano de 1969, três universidades deram início a um projeto redes de computadores, 
sendo elas: Universidade da Califórnia, em Los Angeles, o Stanford research Institute, 
uma outra Universidade da Califórnia situada em Santa Barbara e, por último, a 
Universidade de Utah, localizada na cidade de Salt Lake. O projeto propiciou o aporte 
necessário para que houvesse conexão entre os três centros de ensino, que ficou 
conhecido como Projects Agency Network (ARPANET). 
Ao término da década, no ano de 1970, a Fundação Nacional de Ciência 
(ou NSF - National Science Foundation), tomou conhecimento que o projeto elaborado 
pela ARPANET teve um impacto relevante nas pesquisas acadêmicas nos U.S.A, 
permitindo, assim, que cientistas de todo o país fizessem compartilhamento de dados 
e trabalhassem juntamente em projetos voltados para pesquisa. Entretanto, para que 
fosse possível que uma universidade ingressasse no projeto da ARPANET, ela 
necessitava ter uma espécie de acordo de pesquisa com o Departamento de Defesa 
dos U.S.A, algo que muitas universidades não possuíam. Sendo assim, a NSF optou 
por patrocinar, em 1981, a Computer Science Network (CSNET), que passou a 
conectar os departamentos de Ciência da Computação e laboratórios de pesquisas 
industriais à ARPANET, por meio de linhas privadas. Ao término da década de 1980, 
a National Science Foundation alçou voos maiores decidindo elaborar uma "herdeira" 
para a ARPANET, que seria acessível a todos os grupos de pesquisas universitárias. 
No ano de 1972, Vint Cerf e Bob Kahn, ambos participantes do grupo 
principal da ARPANET, trabalharam juntos no projeto que eles denominaram 
11 
 
Internetting Project. Tal feito histórico de Cerf e Kahn, que fora registrado em num 
artigo no ano de 1973, descrevia, em protocolos, como era possível a entrega de 
pacotes de um ponto a outro. Este artigo, como atualmente conhecemos como 
Transmission Control Protocol (ou TCP) continha conceitos como encapsulamento, 
datagramas e funções de gateway. Após isso, as autoridades optaram compartilhar o 
TCP em dois protocolos, sendo eles: o TCPe o IP (Internetworking Protocol). O IP 
ficaria responsável por trazer o roteamento de datagramas, ao passo que o TCP ficara 
responsável pelas funções de mais altos níveis, sendo elas: segmentação, 
remontagem e detecção de erros. Sendo assim, a partir de então, o protocolo de 
interligação de redes teve passou a ser reconhecido como TCP/IP. 
No ano de 1980, novas redes, em específico as LANs, passaram a ser 
conectadas à ARPANET. Ao passo que a escala aumentou, tornava-se cada vez mais 
inviável monetariamente localizar os hosts, por isso foi elaborado o sistema de nomes 
de domínios, ou, DNS (Domain Name System), para que houvesse a organização de 
maquinas em domínios e que fosse possível relacionar os nomes de hosts com 
endereçamento de IP. Desde então, o Domain Name System se transformou em 
sistema generalizado de bancos de dados distribuídos, armazenando inúmeras 
informações referentes à nomes de endereçamento de IP. 
Em 1983, as autoridades decidiram abolir os protocolos originais da 
ARPANET, e o TCP/IP se tornou o protocolo oficial da ARANET. Ou seja, quem 
desejasse utilizar um computador para ter acesso à Internet em uma rede distinta tinha 
de estar utilizando o TCP/IP. 
Na década de 90, outros países e regiões conseguiram redes nacionais de 
pesquisa, geralmente moldadas conforme a ARPANET e a NSFNET. No continente 
Europeu, essas redes incluíram Europa NET e EBONE, que começaram com linhas 
de 2Mbps e posteriormente aumentaram a capacidade das linhas para 34Mbps. Mais 
tarde, a infraestrutura de rede no continente europeu foi entregue à indústria. 
No ano de 1990, a ARPANET foi oficialmente substituída e aposentada pela 
NSFNET. Em 1995, a NSFNET regressou ao seu conceito original de uma rede 
pesquisa. 
Em 1991, o governo dos U.S.A decidiu que a NSFNET não era competente 
o suficiente para suportar o tráfego da Internet que vinha aumentando 
12 
 
exponencialmente rápido. A partir daí a IBM, Merit e Verizon, preencheram este 
"buraco" ao formar uma organização sem fins lucrativos conhecidos como Advanced 
Network & Service, ou Serviços & Redes avançados, a fim de construir um novo 
backbone de Internet extremamente rápido chamado de Advanced Network Services 
Network (ASNET). 
Sendo assim, no ano de 1990 as pessoas testemunharam a explosão de 
aplicações de Internet devido ao surgimento da World Wide Web (ou WWW), que fora 
criada no CERN por Tim Berners-Lee e foi adicionada às aplicações comerciais 
desenvolvidas para a Internet. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
13 
 
4. FUNDAMENTOS DA COMUNICAÇÃO DE DADOS EM REDE 
 
A Comunicação de Dados encontra-se na área da Ciência da Computação, 
e trata das transferências de informações entre os sistemas de computadores e 
dispositivos distintos através de um meio transmissor. As transferências de 
informações implicam-se na passagem de estímulos (ou sinais) pelos meios físicos 
da intercomunicação que completam as redes (SANTOS, 2020). 
4.1. Pilares da comunicação de dados 
 
Para que se estabeleça uma comunicação de dados, necessita-se manter 
as três bases fundamentais dela em perfeito estado e sintonia, sendo elas: 
Entrega: Apenas o dispositivo do usuário pode ter acesso e permissão no 
recebimento dos dados (SANTOS, 2020). 
Confiabilidade: Dados corrompidos não possuem de fato uma utilidade para o 
destinatário, logo, o sistema tem de assegurar que toda e qualquer informação que for 
enviada, tenha sua integridade “intacta” (SANTOS, 2020). 
Tempo de atraso: Em determinadas situações, o atraso é tolerado por um 
determinado tempo, em outras, deve-se evitar ao extremo o “delay” (tempo de 
resposta). Dados que são recebidos com demora não possuem uma utilidade 
específica, por exemplo, em chamadas de vídeo, onde a imagem necessita ser 
entregue, quase que instantaneamente, no momento em que foi produzida (SANTOS, 
2020). 
 
4.2. Componentes fundamentais 
 
Para lograr êxito em uma comunicação a ser realizada, o procedimento é 
composto por cinco (05) elementos básicos, sendo eles (SANTOS, 2020): 
Mensagem: Informação a ser recebida, desde números, textos, até arquivos de áudio 
e vídeo 
Transmissor (TX): Dispositivo emissor de dados. Por exemplo: computador, terminal 
de trabalho, telefone, etc (SANTOS, 2020). 
Receptor (RX): Dispositivo que atua como remetente do dado à ser entregue pelo 
Transmissor. Exemplo: terminal de trabalho, um telefone, uma câmera de vídeo 
Meio de transmissão: Caminho físico pelo qual passa a mensagem destinada ao 
Receptor (SANTOS, 2020). 
14 
 
Protocolo: Normativas que estabelece uma comunicação de dados entre dispositivos 
(SANTOS, 2020). 
 
4.3. Transmissões de dados 
 
Para que uma transmissão ocorra numa via de comunicação mediante dois 
terminais, pode-se realizá-las de formas distintas, definindo-se por: simples, half-
duplex e full – duplex (SANTOS, 2020). 
Meios de transmissões: Se trata da quantidade de bits transmitidos 
simultaneamente, sendo elas: paralela; serial (SANTOS, 2020). 
 
4.3.1. Sentido das trocas de transmissões 
 
As transmissões entre dispositivos em redes dão-se em três maneiras 
distintas, que são elas: Simplex, Half-duplex ou Full-duplex. 
Simplex: Somente um único emissor e receptor. A intercomunicação possui uma via 
única, logo, de maneira exclusiva, um dos dispositivos terá a capacidade de emitir a 
informação, enquanto o outro apenas a receberá (SANTOS, 2020). 
Half-duplex: Cada estação poderá efetuar a transmissão, e, também, recebê-la, 
entretanto, jamais de maneira simultânea. Se, no caso, um dispositivo estiver 
efetuando uma transmissão, o outro necessariamente está recebendo. Na 
transmissão half-duplex, a prioridade é delegada sempre para quem está a transmitir 
os dados. Um exemplo claro disso seria a comunicação por um HT (Hand Talk), assim 
como o rádio Nextel (SANTOS, 2020). 
Full-duplex: Neste caso os dispositivos podem tanto emitir, quanto receber dados 
simultaneamente. Sinais em sentidos contrários dividem a capacidade do link ou 
canal, por exemplo, a comunicação por meio de um celular, onde temos a 
possibilidade de falar e ouvir, de maneira instantânea (SANTOS, 2020). 
 
 
4.3.2. Modo de transmissão 
 
Indica a quantidade de bits que poderão ser transferidos por meio do canal 
de intercomunicação, simultaneamente (SANTOS, 2020). 
15 
 
Transmissão em modo Paralelo: Nas transmissões em modos paralelos, os bits que 
compõem o carácter são transmitidos simultaneamente, por meio de inúmeras vias de 
dados. Uma via pode ser um fio, um cabo ou qualquer outro meio de suporte físico. A 
ligação paralela dos computadores do tipo PC necessita, aproximadamente, de 10 fios 
(SANTOS, 2020). 
Transmissão em modo Série: Neste tipo de transmissão, os bits que compõem a 
informação são transmitidos um a um, por meio de uma única via de dados (SANTOS, 
2020). 
 
4.4. Sincronização 
 
Transmissão Assíncrona: Na transmissão Assíncrona, os dados são transmitidos 
um a um sem que haja um monitoramento de tempo entre ambos. Agora, pense que 
somente um bit é emitido durante um extenso momento de silêncio, no qual o receptor, 
em hipótese alguma, deve saber que trata-se de 00010000, ou 10000000. No intuito 
de amenizar esse contratempo, cada um dos dados são antecedidos de uma 
informação que remete à inicialização da transmissão (denominada bit START) 
encerrando-se com o envio de um aviso de fim de transmissão (denominada bit 
STOP). Comumente usada quando não se estabelece, no receptor, nenhum 
maquinismo de sincronização em relação ao emissor (SANTOS, 2020). 
Características: rendimento não alto; implementação não complexa; baixa 
velocidade 
Transmissão Síncrona: Informações que são enviadas de maneira agrupada e em 
determinadas lacunas de tempo. Dados de sincronismo são emitidos ao longo da 
transmissão, mantendo assim, a sincronicidade entre as máquinas. O RX (Receptor), 
incessantemente (mesmona ausência da transmissão de bit), recebe os dados à 
medida em que o emissor as envia. E, por isso, faz-se imprescindível que o TX 
(Transmissor) e RX encontrem-se em harmonia e na mesma velocidade. Além do 
mais, informações adicionais são introduzidas para assegurar a ausência de erros na 
transmissão (SANTOS, 2020). 
Características: Transmissão de boa qualidade; custo mais elevado de transmissão; 
equipamento mais sofisticado; ideal para envios de impulsos sensíveis a atraso; 
transmissão com maior credibilidade; adequado para aplicações multimidia; 
 
 
 
 
 
16 
 
4.5. Tipos de redes 
 
Não existe uma classificação ao certo para generalizar todas as redes de 
computadores, podendo, assim, classificá-las. Entretanto, duas técnicas de 
dimensões se sobrepõem às outras: tecnologia de transmissão e a escala 
No mundo contemporâneo, encontra-se dois tipos de tecnologias de 
transmissão sendo utilizadas, sendo elas: Links de difusão e Links ponto a ponto. 
Segundo (TANENBAUM, 2003) as redes de difusão têm apenas um canal 
de comunicação, compartilhadas por todas as máquinas da rede. Mensagens curtas, 
que em determinados contextos são chamados pacotes, enviadas por qualquer 
máquina, são recebidas por todas as outras. Um campo de endereço dentro do pacote 
especifica o destinatário pretendido. Quando recebe um pacote, uma máquina verifica 
o campo de endereço. Se o pacote se destinar à máquina receptora, ela o processará; 
se for destinado a alguma outra máquina, o pacote será simplesmente ignorado. 
Por outro lado, referente às redes ponto a ponto, Tanenbaum diz que estas, 
consistem em muitas conexões entre pares de máquinas individuais. Para ir da origem 
ao destino, um pacote nesse tipo de rede talvez tenha de visitar primeiro uma ou mais 
máquinas intermediárias. Como normalmente é possível haver várias rotas com 
diferentes tamanhos, encontrar boas rotas é algo importante em redes ponto a ponto. 
Como regra geral (embora existam muitas exceções), redes menores 
geograficamente localizadas tendem a usar difusão, enquanto redes maiores em geral 
são redes ponto a ponto (TANENBAUM, 2003) 
Uma maneira alternativa para classificar as redes é sua escala. A figura 
abaixo exibe uma classificação. Na parte superior, ficam as redes pessoais, que são 
as redes que se destinam a uma única pessoa, como, por exemplo, uma rede sem 
fios, conectando um desktop com o mouse, o teclado e impressora é uma rede 
pessoal. Além disso, um PDA que controla o aparelho de audição ou o marca-passo 
de um usuário se enquadra nessa categoria. Além das redes pessoais, encontramos 
redes de maior abrangência. Essas redes podem ser divididas em redes locais, 
metropolitanas e geograficamente distribuídas (ou remotas). Finalmente, a conexão 
de duas ou mais redes é chamada inter-rede. A Internet mundial é um exemplo 
bastante conhecido de inter-rede. A distância é importante como uma métrica de 
17 
 
classificação, porque são empregadas diferentes técnicas em escalas distintas 
(TANENBAUM, 2003). 
 
Figura 1 - Classificação de redes 
 
Fonte: http://www.vazzi.com.br/arquivos_moodle/Redes%20de%20Computadores%20-%20Tanenbaum.pdf 
 
 
 
4.5.1. Redes locais 
Uma rede local, geralmente, é uma rede privada que acaba por conectar 
alguns hosts num único escritório, edifício, campus. A depender da necessidade da 
organização, a Local Area Network (LAN) pode simplesmente conter em sua rede 
apenas dois computadores e uma impressora no escritório da residência de alguém, 
ou, pode estender-se por toda uma empresa fazendo a inclusão de dispositivos de 
áudio/vídeo. Cada host presente em uma LAN tem seu próprio identificador, isso é, 
um endereço que define de forma única na LAN (TANENBAUM, 2003). 
 
 
 
 
http://www.vazzi.com.br/arquivos_moodle/Redes%20de%20Computadores%20-%20Tanenbaum.pdf
18 
 
4.5.2. Redes metropolitanas 
 
Uma rede metropolitana (MAN), abrange uma cidade. O exemplo mais 
conhecido de uma MAN é a rede de televisão a cabo disponível em muitas cidades. 
Esse sistema cresceu a partir de antigos sistemas de antenas comunitárias usadas 
em áreas com fraca recepção do sinal de televisão pelo ar. Nesses primeiros sistemas, 
uma grande antena era colocada no alto de colina próxima e o sinal era então conduz 
ido até a casa dos assinantes (TANENBAUM, 2003). 
As redes MANs ofertam um competente meio de conexão entre redes LANs 
e WANs. A princípio, essas redes foram desenvolvidas para que houvesse a 
transmissão de dados, entretanto, atualmente, seus serviços sofreram uma expansão 
de amplitude (TANENBAUM, 2003). 
 
4.5.3. Redes geograficamente distribuídas 
 
Segundo (referência), uma rede geograficamente distribuída, ou WAN 
(wide área network), abrange uma grande área geográfica, com frequência um país 
ou continente. Nela contém um conjunto de máquinas cuja finalidade é executar os 
programas do usuário (TANENBAUM, 2003). 
 
4.5.4. Redes sem fios 
 
Em uma primeira aproximação, redes sem fios podem ser divididas em três 
principais categorias, sendo elas: interconexão de sistemas, LANs sem fios e WANs 
sem fios (TANENBAUM, 2003). 
Interconexão de sistemas: a interconexão de sistemas significa interconectar os 
componentes de um computador usando rádio de alcance limitado. 
LANs sem fios: são sistemas em que todo computador tem um modem de rádio e 
uma antena por meio dos quais pode se comunicar com outros sistemas. 
WANs sem fios: é usada em sistemas geograficamente distribuídos. 
 
 
19 
 
4.5.5. Inter-redes 
 
Dá-se uma inter-rede quando a mesma é formada por diferentes redes que 
estão sendo interconectadas. Existem muitas redes no mundo, com frequência 
apresentando diferentes tipos de hardware e software. É comum as pessoas estarem 
conectadas a redes diferentes e precisando se comunicar entre si. Para que isso seja 
possível, é necessário que se estabeleçam conexões entre redes quase sempre 
incompatíveis, às vezes por meio de máquinas chamadas de gateways, que 
estabelecem a conexão e fazem a conversão que precisa, tanto em termos de 
hardware quanto de software. Um conjunto de redes interconectadas é chamado de 
inter-rede ou internet. Esses termos serão usados em um sentido genérico, em 
contraste a internet mundial (uma inter-rede específica), que sempre será 
representada com inicial maiúscula (TANENBAUM, 2003). 
 
4.6. Sockets de Berkeley 
 
Essa interface (socket) teve aparição no início do ano de 1980, na 
Universidade de Berkeley, como parte do ambiente UNIX de Berkeley, para o TCP. 
Suas primitivas, geralmente, são utilizadas em programação para a Internet, ofertando 
maiores recursos e sendo mais flexíveis. 
Suas primitivas, ou, ao menos, suas quatros primitivas na lista (figura 
abaixo) são executadas pelos servidores nessa exata ordem. A primitiva Socket cria 
um ponto final e aloca o espaço de tabela para ele na entidade de transporte. Os 
parâmetros da chamada especificam o formato de endereçamento a ser usado, o tipo 
de serviço desejado e o protocolo. Uma chamada Socket bem sucedida retorna um 
descritor de arquivo comum que será usado nas chamadas subsequentes, 
exatamente como uma chamada OPEN (TANENBAUM, 2003). 
 
20 
 
Figura 2 - Primitivas de sockets para TCP 
 
 Fonte: http://www.vazzi.com.br/arquivos_moodle/Redes%20de%20Computadores%20-%20Tanenbaum.pdf 
 
O conceito de sockets permite-nos utilizar o conjunto de instruções que já 
foram projetadas em uma linguagem e programação para outros dispositivos de 
entrada e saída. Por exemplo, em grande maioria, nas linguagens de programação, 
têm inúmeras instruções para fazer a leitura e/ou a gravação d dados nos dispositivos 
de entrada e saída. Podemos utilizar as mesmas instruções para efetuar a leitura ou 
escrever em sockets, isto é, adicionar novas entidades de input/output à linguagem 
de programação sem que seja alterado a forma de enviar ou receber os dados.http://www.vazzi.com.br/arquivos_moodle/Redes%20de%20Computadores%20-%20Tanenbaum.pdf
21 
 
5. O CONTROLE DE QUEIMADAS NO TERRITÓRIO AMAZÔNICO 
 
Pesquisadores do IPAM (INSTITUTO DE PESQUISA AMBIENTAL DA 
AMAZÔNIA), tiveram interesse em ficar a par das atividades de queimadas, e, por 
consequência, o desmate por queimada e focos de incêndios, sendo ele criminoso ou 
não, a fim de combater casos que ocasionem poluição do ar nas adjacências do 
território amazônico, com ênfase nos municípios dos estados do Amazonas, Pará, 
Rondônia, Roraima e Mato Grosso. A partir de então originou-se uma pesquisa para 
tentar reduzir ou combater as queimadas em território amazônico. 
Sabe-se que o fogo é um subterfugio químico no panorama rural brasileiro. 
Utilizado para efetuar a limpeza de espaços recém-desmatados e outros tipos de solo, 
como por exemplo, o pasto, que, com frequência, foge do controle e acaba queimando 
o que não deveria queimar. Com a Amazônia não ocorre diferente. Sua incidência na 
região está estritamente ligada à intervenção do homem e as chamas tendem a seguir 
o rastro do desmatamento: quanto maior o número de derrubada, maior será o número 
de focos de calor. 
O cenário agrava-se ainda mais em épocas de rígidas de estiagem. Secas 
mais severas, intensas e de longa duração diminuem a umidade no solo da flora 
amazônica, alastrando-se com extrema facilidade, elevando as possibilidades de 
grandes incêndios florestais. Em 2007 e 2010, por exemplo, quando a época seca, no 
Sul da Amazônia, foi mais severa que o habitual, largas áreas de florestas entraram 
em chamas ocasionando uma alta taxa de mortalidade de árvores. Em anos onde 
ocorreram uma taxa menor de desmatamento, como houve nos últimos anos, a 
intensidade da estação seca foi determinante para que houvesse casos de incêndio 
florestal. 
Nos últimos 20 anos, as secas severas na Amazônia foram-se tornando 
mais corriqueiras. Vinculadas à uma taxa crescente de desmatamento, elas (as secas) 
podem favorecer casos de incêndios florestais de proporções avassaladoras, com 
impactos negativos para a população, dentre elas o aumento exponencial de 
complicações de caráter respiratório, ameaça a plantios, infraestrutura e a diminuição 
da resiliência da floresta, que torna-se mais adepta a novos casos de queimadas e a 
danos causados por tempestades e patógenos. Por consequência, os impactos 
22 
 
econômicos provocado pelos incêndios florestais nos levam a números nada 
agradáveis. As queimadas do ano de 1998, por exemplo, resultou em um estrago 
financeiro que ultrapassam mais de US$ 5 bilhões. Da parte do Sistema Único de 
Saúde, o SUS, para tratar de complicações respiratórias do povo amazônida, foram 
destinado cerca de US$ 11 milhões. 
 
Com a baixa do desmatamento entre 2005 e 2012, as queimadas florestais, 
por consequência, também sofreram uma diminuição. Entretanto, a retomada do 
desmatamento em anos passados ocasionou a volta das chamas, impactando na vida 
da população campestre e urbana. No ano de 2019, a relação entre o desmate e fogo 
mostrou-se, particularmente, fora. Os habitantes das cidades na Amazônia, e até os 
de fora dela, passaram a consumir um ar mais “sujo”, mais poluído do que o 
encontrado em grandes cidades, como São Paulo. E isso pode ser extremamente 
desastroso à saúde. 
Foi a partir de então que o Instituto de Pesquisa Ambiental da Amazônia 
(IPAM) decidiu avaliar a dinâmica dos focos de calor (queimadas e incêndios 
florestais) que foram capturados via satélite em relação aos registrados em anos 
anteriores; buscando entender a ligação de incêndios com a rígida época de estiagem 
e com o desmatamento. 
 
5.1. Metodologia de pesquisa utilizada 
 
Para que se possa ser feita uma avaliação da dinâmica e a ligação entre o 
desmatamento, focos de calor e a rígida época de estiagem, foi necessário utilizar 3 
tipos de dados, sendo eles: focos de incêndio, número seguidos de dias sem chover 
e desmatamento em 2019. Para focos de incêndios, foram utilizados dados de um 
sistema de detecção de focos de calor do satélite AQUA (que é considerado um 
satélite referência pelo INPE) acumulados para o bioma Amazônia entre 01/01 e 14/08 
de cada ano, de 2016 a 2019. A matemática usada para calcular a quantidade de 
números de dias sem chover foi feita com embasamento no Climate Hazards Group 
InfraRed with Stations (CHIRPS), que contém dados diários de chuva com resolução 
de 5 km. O maior número de dias seguidos sem chuva (onde houve menor 
23 
 
precipitação, abaixo de 1mm) foi calculado, levando em consideração, o período entre 
01/01 e 14/08 de cada ano, de 2016 a 2019. Já para a análise do desmatamento foi 
utilizado dados do SAD (Sistema de Alerta de Desmatamento) acumulados entre 
janeiro e julho de 2019. Finalmente, então, foi relacionado o número de dias seguidos 
sem chover com os dados de focos de queimadas e incêndio e área desmatada, ta 
para os estados, quanto por municípios. 
 
5.1.1. Resultados da metodologia de pesquisa utilizada 
 
A Amazônia vem sofrendo com mais queimadas no ano de 2019, e a época 
seca, somente ela, não elucida essa crescente (observar figuras 3 e 4). O número dos 
focos de incêndios para grande parte dos estados da região, já é o maior que houve 
dos quatros últimos anos. Este é um índice espantoso, porque a estiagem do ano de 
2019 foi mais amena em comparação as dos anos anteriores (observar figura 4). Até 
14/08, foram contabilizados 32.728 focos, cerca de 60% a mais à média dos 3 anos 
anteriores para a mesma época (média de 20,4 mil focos de incêndio, tendo variância 
entre 15 e 25,5 mil; (observar figura 4). A média de dias seguidos sem chover até 14 
de agosto de 2019 teve variação de 11 dias no Amazonas e 29 dias no estado 
Roraima. 
Os casos de incêndio em grande número, no ano de estiagem mais 
tranquilas, aponta que o desmatamento possa ser um fator que impulsione às chamas, 
hipótese levada a teste aqui com resultado positivo: a ligação entre focos de incêndio 
e o desmatamento observado no início do ano até o mês 07 exibe-se de maneira bem 
acentuada. Forte (observar figura 3). Os 10 municípios amazônicos que mais 
concentraram registros de focos de incêndio foram, por sua vez, os que obtiveram 
taxas altas de desmatamento (figuras 3 e 6). Os municípios em questão são 
responsáveis por 37% de focos de calor no ano de 2019 e por 43% do desmate notado 
até o mês 07 (figura 6). Esse agrupamento de incêndios florestais nas áreas recém-
desmatadas e com estiagem amena representa um contundente indicativo do caráter 
intencional dos incêndios: limpeza de áreas recém-desmatadas. 
 
 
24 
 
 
Nota-se que os registros de incêndios no ano de 2019 são claramente 
maiores nos estados do Acre, Amazonas, mato Grosso, Rondônia e Roraima, se 
comparadas aos incêndios dos quatros últimos anos. No Pará, o número de incêndios 
atual é de apenas 7% menor que o observado no ano de 2017, época em que a 
estiagem foi severamente crítica em relação ao ano de 2019 (figura 5). 
 
 
Figura 3 - Relação entre o número de focos de incêndios acumulados até 19 de agosto e área desmatada 
(esquerda) e número seguidos de dias sem chuva (direita) para municípios do bioma Amazônia em 2019. Os 
municípios identificados no gráfico são aqueles onde se registrou um número particularmente elevado de focos de 
incêndios. Fonte: IPAM 
 
 
 
 
 
 
25 
 
 
 
Figura 4 - Número médio de focos de incêndios cumulativo de dias sem chuva para o bioma Amazônia em 2019, 
comparado com a média de focos registrado para o período entre 2016 e 2018. Fonte: IPAM 
 
 
26 
 
 
Figura 5 - Número de focos de incêndios acumulados para o período de janeiro a 14 de agosto para os anos de 
2016 a 2019 em seis estados amazônicos. As diferenças nas cores dentro do mesmo estado indicam o número 
cumulativo de dias com precipitação menor que 1 mm. Dados de Mato Grosso incluem somente informações paraa porção do bioma Amazônia. Fonte: IPAM. 
 
 
27 
 
 
Figura 6 - Os 10 municípios da Amazônia com maior número de focos de incêndio em 2019 e a área desmatada 
entre o período de janeiro a julho de 2019. Fonte: IPAM, com dados do INPE e SAD/Imazon 
 
No Acre, um fator que preocupa em relação aos incêndios e queimadas, é 
o comprometimento da boa qualidade do ar. Nas três últimas semanas, as cidades do 
Acre vêm passando deparando-se com muita poluição pela fumaça, com situação em 
estado grave nos municípios Assis Brasil, Sena Madureira, Manoel Urbano e Rio 
Branco. Em todos, os apontamentos de contração de material particulado estão 
deveras acima do que recomenda a OMS. O governo do Estado decretou situação de 
alerta referente às queimadas no dia 09, em agosto de 2019. 
No ano de 2019 foram contabilizados para o estado do Acre, até 14 de 
agosto, 1.790 focos de calor. Esses números representam um aumento de 57% a mais 
que o registrado em 2018 e 23% a mais que o registrado em 2016, ano onde a seca 
foi extrema, ocasionado pelo fenômeno El niño, um dos mais fortes dos últimos 10 
anos. 
Vale lembrar que o registro dos focos de calor que foram usados como 
referência pelo INPE (dados do satélite AQUA) podem ser postos à dúvidas. Uma 
análise que foi realizada a partir de alertas de incêndios usando multissensores 
(imagens do satélite Sentinel, Landsat e Cbers) (figura 7) já somam mais de 19 mil 
hectares de queimadas no estado. 
28 
 
 
Figura 7 - Relação cartográfica entre registro de focos de calor do INPE (pontos em amarelo) e queimadas 
baseadas no satélite Sentinel (áreas em vermelho). Fonte: Universidade Federal do Acre. 
 
5.1.2. Como proceder? 
 
Como uma das principais recomendações contra o desmatamento, é 
preciso que haja a intensificação de combate às derrubadas ilegais na floresta e apoio 
aos agricultores para que deixem de utilizar o fogo no preparo do solo. Promover a 
diminuição do fogo acarreta impactos positivos no bem-estar da população das 
cidades e do campo, resultando em menores gastos com saúde ou até mesmo com 
reposição de perdas agroflorestais. 
Torna-se imperioso a retomada as de campanhas de prevenção de 
queimadas, combate aos incêndios florestais e o uso de técnicas controladas do fogo. 
Deve-se estimular os proprietários rurais a aplicar técnicas de manuseio correto, por 
exemplo, uso de aceiros, a fim de evitar uma propagação por acidente das chamas. 
Sendo assim, cabe a ressalva de que o atual cenário, com número elevado 
de focos de incêndios no rastro do desmatamento, poderá se tornar “lugar comum” na 
Amazônia, onde, futuramente, a floresta acabe cedendo lugar para outros meios de 
utilizar a terra. Torna-se fundamental compreender o conceito de que, sem as largas 
extensões de florestas atuando como barreira contra a propagação do fogo, os danos 
futuros para a saúde das pessoas e da agricultura podem ser inestimáveis. 
29 
 
6. O PROJETO 
 
Para que haja acuracidade no repasse das informações, a equipe precisa 
trocar mensagens instantâneas com a central, que fiscaliza, via satélite, possíveis 
focos de incêndios e/ou desmate do solo que envolvam queimadas e afins. 
Para tal, admitiremos que os profissionais (treinandos e capacitados), em 
um ambiente interno, estejam apurando os dados que foram capturados e recebidos, 
via satélite, e estejam com a necessidade de repassar as informações de maneira 
instantânea e pragmática, a fim de compartilhar os resultados obtidos. 
Sendo assim, pensou-se na elaboração de um chat, contando com a 
arquitetura cliente-servidor, que estabelece conexão entre os usuários por meio de 
inserção de credenciais (nome e número de porta para conexão) e com o 
armazenamento de informações em um Banco de Dados. 
 
6.1.1. O projeto 
 
Para a elaboração da arquitetura do projeto que foi idealizado, foram 
criadas as seguintes classes, sendo elas: classe Cliente, Home, Login, Utils, Listener 
e Server. Aqui, nesta etapa, serão demonstrados o passo a passo de como cada 
classe (com sua respectiva função) foi desenvolvida, e, ao final, o protótipo de como 
a aplicação deve ser. 
 
 
 
 
30 
 
6.2. Classe cliente 
 
Figura 8 - Além de ser responsável pela interação da interface gráfica com o usuário, ela tem a função de promover 
a conexão do cliente no servidor de mensagens e áudio. Basicamente ela é constituída pelos botões de envio (e 
captação) de áudio, mensagem; conta também com uma barra de rolagem (JScrollPane) para uma melhor 
visualização dos textos que vão sendo inseridos no campo de texto (JTextField). 
 
 
Figura 9 - Constitui-se pelo cabeçalho do chat onde será a pessoa com quem estarei conversando; contém um 
JEditorPane que irá exibir as mensagens e um JScrollPane onde há um painel de rolamento das mensagens; Mais 
abaixo há um JTextField, onde as mensagens serão introduzidas e um JButton que é responsável pela ação de 
enviar a mensagem contida no JtextField, que é o campo de texto; há também um outro JButton, que é responsável 
por fazer a gravação de áudio e enviar ao destinatário. 
 
 
 
31 
 
 
Figura 10 - Define-se, aqui, as dimensões das bordas do frame; a área destinada a inserção de mensagens não 
será editável; uma barra (JScrollPane.VERTICAL_SCROOLBAR_AS NEEDED) ficará posicionada verticalmente; 
a barra (JScrollPane.HORIZONTAL_SCROOLBAR_AS NEEDED) ficará posicionada horizontalmente, ambas com 
uma simples exibição. Sobre a questão “HORIZONTAL_SCROLLBAR_AS_NEEDED” significa que aparecerá a 
barra de rolagem apenas quando necessário. 
 
Figura 11 - O cabeçalho (JLabel_titulo, BorderLayout.NORTH) irá ficar posicionado ao norte; a barra de rolagem 
(rolar, BorderLayout.CENTER) ficará centralizada; o painel (painel, BorderLayout.SOUTH) irá ficar localizado ao 
sul da interface; o JT_mensagens, BorderLayout.CENTER ficará responsável por capturar toda a entrada de 
mensagens, pois, tudo que se encontra no centro ocupa todo o espaço; o botão de enviar mensagem 
(JB_mensagem, BorderLayout.EAST) ficará localizado à direita da interface; o botão responsável por enviar áudio 
(Jb_audio, BorderLayout.WEST) ficará localizado a oeste. O jd_mensagem.addActionListener(event -> 
enviar_mensagem()) é responsável pelo disparo de evento do envio de mensagem; acrescentar mensagens(String 
recebido) fica responsável por atualizar a área de mensagem quando enviarmos ou recebermos alguma 
mensagem. 
 
 
Figura 12 - Se o campo de mensagem conter alguma mensagem, logo assim que o usuário fizer o envio da mesma, 
ele será identificado como “Eu” (em negrito), seguido das informações de horas, minutos e segundos em que a 
mensagem foi enviada. Criei um método “main” para fins empíricos, apenas. Essa classe funcionaria com o método 
“start”, sem a necessidade do método principal. 
32 
 
6.2.1. Classe home 
 
 
Figura 13 - Inicialização das variáveis (jl_titulo; jb_capt_conectados; jb_start_talk; jl_usuarios; JScrollPane) 
promovendo a conexão das mesmas dando o aporte necessário para a conexão. Foi acrescentado um cabeçalho 
“Chat – Home” apenas para tornar o programa o mais intuitivo possível, a fim de fazer com que a experiência do 
usuário seja agradável. 
 
Figura 14 - O título conterá o nome do usuário e a porta em que ele se encontra através do jl_titulo; usuários 
conectados serão atribuídos a variável jb_capt_conectados, onde ocorrerá uma atualização da lista de contatos; 
através do jb_star_talk será possível abrir uma conversa; o JScrollPane permite-nos exibir a lista de usuários; 
define-se aqui também a dimensão do tamanho do cabeçalho, cor de fundo, e coloração da borda do cabeçalho. 
Todo o layout do programa foi inserido em um método “config_componentes”. 
 
33 
 
 
 
Figura 15 - O comando jb_capt_conectados.setFocusable (false) desabilita o foco do botão em questão, fazendo 
com que o mesmo não fique “focado” ao passar por ele; o botão de “Abrir conversa” (jb_start_talk) também foi 
implementado com omesmo comando (jb_start_talk.setFocusable (false)), para que o mesmo também não fique 
“focado” ao passar por ele. Apenas uma particularidade para tornar o programa mais “limpo”. O 
jl_usuarios_setSelectionMode(ListeSelectionModel.SINGLE_SELECTION) permite ao usuário escolher iniciar 
apenas uma conversa por vez; o usuário poderá verificar seus contatos online, através do comando 
jl_usuarios.setBorder(BorderFactory.createTitleBorder (“Usuários Online”) que fará o contorno da borda, 
entretanto, no canto superior esquerdo do cabeçalho irá aparecer “Usuários Online”; se caso necessário, uma 
barra de rolagem horizontal 
(rolar.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)) e uma barra de 
rolagem vertical (rolar.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED)) irão ser 
exibidas para o usuário. Será de suma importância essas rolagens quando o nome do usuário for extenso e não 
couber na tela. 
 
 
Figura 16 - O método “inserc_acões” para caso ocorra um imprevisto, e perceba que estaria repetindo o código, 
portanto, é um “local seguro” para testes. O método “start” serve para aparecer a tela principal (Home), já o método 
“main” tem como objetivo testar suas funcionalidades e averiguar se está tudo de acordo. 
34 
 
 
6.2.2. Classe login 
 
 
Figura 17 - Construída através de um JFrame, a classe Login destina-se ao usuário. Ela é composta pelo botão 
auxiliar de “entrar” (Jb_login); seus JLabels, são: jl_usuario, onde o usuário insere sua identificação (ou apelido) a 
fim de que o outro usuário o identifique; jl_porta, onde é informado o numeral da porta que o usuário entrou; 
jt_usuario onde o texto de identificação inserido, identifica o nome ou apelido do usuário; jl_cabecalho serve para 
definir o design da tela de login; inseri também uma imagem para deixar com um visual mais agradável. No método 
“Login” inseri os demais métodos que servirão como o esqueleto do programa em si. 
 
 
 
 
 
 
 
 
 
 
 
35 
 
 
Figura 18 - São os métodos de auxílio de inicialização da classe: Jb_login, jl_usuario, jl_porta, jl_cabecalho, , 
jt_usuario e , jt_porta; pode-se definir aqui o tamanho da tela através da linha de comando this.setMinimunSize(new 
Dimension (400,300)); através do comando this.getContenPane().setBackGroung(Color.WHITE) pôde-se definir o 
parâmetro de cor de fundo, sendo ela branca; através do comando ImageIcon icone_imagem = new 
ImageIcon("../logo_chat.png) foi definido a imagem do cabeçalho; através do comando jl_cabecalho.setIcon(new 
ImageIcon(icone_imagem.getImage().getScaledInstance(375,100, Image.SCALE_SMOOTH))) foi definido o 
tamnho do ícone; através do comando jb_login.setBounds(10, 220, 375, 40) foram definidos a distância à esquerda, 
distância em reação ao topo, a altura e largura do botão "Iniciar"; através do comando 
jl_usuario.setBorder(BorderFactory.createLineBorder(color.gray)) foi definido a cor cinza. 
 
 
Figura 19 - Através do comando jl_porta.setBorder(BorderFactory.createLineBorder(color.gray)) foi definido o 
parâmetro de cor da borda, a qual é cinza; através do comando jt_usuario.setBounds(120, 120, 265, 40) foram 
definidos a distância à esquerda, distância em relação ao topo, a altura e largura do campo de texto onde será 
inserido o “apelido” (nome) do usuário; o comando jt_porta.setBounds(120, 170, 265, 40), assim como o comando 
anterior, tem a finalidade de definir o layout do campo de texto onde será inserido o número da porta em que o 
usuário se encontra. Criei um método “inserc_Componentes” que insere na tela do programa, todas as variáveis 
criadas: jb_login, jl_usuario, jl_porta, jl_cabecalho, jt_usuario, jt_porta. 
 
36 
 
 
Figura 20 - Seus botões de ações, como por exemplo, o botão de login (jb_login), irá atribuir a variável “apelido” 
ao campo de texto do usuário e a variável porta irá converter o campo string em inteiro; String apelido receberá 
jt_usuario.getText() onde apelido terá a variável usuário à ela; após a atribuição da variável “apelido” 
jt_usuario.setText(“ “) deixará em branco o textField; através do comando int porta = 
Integer.paseInte(jt_porta.getText()) a variável porta terá a variável jt_porta atribuída à mesma e como dito 
anteriormente, terá seu valor convertido para inteiro; o comando jt_porta.setText(“ “) fará com que fique em branco 
textField após ser atribuída à variável “porta”; Logo abaixo, o usuário insere algumas informações como, por 
exemplo, nome (apelido) e o numeral da porta; se tudo ocorrer bem, se a conexão através do socket for 
concretizada, uma mensagem de “SUCESSO” será exibida ao usuário e sendo assim, a tela principal onde se 
encontra pessoas online será aberta, caso contrário, serão exibidos JOptionPane’s, sendo, que, o primeiro 
JOptionPane irá informar se algum outro usuário já encontra-se usando o mesmo apelido ou host, e porta; o 
segundo JOptionPane irá informar um erro referente a não conexão, com a seguinte mensagem “Erro ao tentar 
conectar. Por favor, verifique se o servidor está em execução.”. 
 
 
Figura 21 - O método “start” foi criado para exibir a tela de login. O método “main” tem a finalidade de testar a tela 
de Login de forma individual e averiguar se possui algum erro de execução. 
 
 
37 
 
6.2.3. Classe utils 
 
 
Figura 22 - A leitura da mensagem que saiu é feita através do comando ObjectOutPutStream saída = new 
ObjectOutPutStram(conexão.getOutStream()); o comando saida.flush() força agravação dos arquivos que se 
encontrão no buffer; saída.writeObject(mensagem) escreve a mensagem; – Uma mensagem de [ERROR: 
enviarMensagem] será exibida caso a tentativa de envio da mensagem seja mal sucedida. 
 
 
Figura 23 - A mensagem recebida é lida através do comando ObjectInputStream entrada = new 
ObjectInputStream(connection.getInputStream()); será lido o que foi escrito no método “writeObeject’, na linha 13, 
através do comando resposta = (String) entrada.readObeject() e retornará o conteúdo que estiver na variável 
“resposta”. Será feito também um tratamento de erro, aparecerá o erro na tela informando em qual método ocorreu: 
receberMensagem() ou enviar_Mensagem(). 
 
 
 
 
 
 
 
 
 
 
38 
 
6.2.4. Classe cliente listener 
 
 
Figura 24 - inicialização de variáveis para que haja conexão, algo diferente disso será retornado um boolean 
informado o estado da conexão; o comando boolean running continua sendo executada mesmo com a paralização 
da thread (a classe cliente listener seria para fazer uma linha de gravação para com o usuário). O método 
“esta_executando”, como o nome já diz, informa o estado da execução: verdadeiro ou falso. O método 
“set_Running” inicializa o parâmetro “running” dentro do mesmo. 
 
 
Figura 25 - O retorno do boolean sendo verdadeiro (true), a execução será feita normalmente; enquanto ocorre a 
execução o servidor recebe mensagens; para encerrar a conexão basta o usuário inserir a mensagem “Quit”, que 
a conexão se encerrará. 
 
Figura 26 - O método “run” servirá para deixar em execução a classe ClienteListener. 
39 
 
6.2.5. Classe server 
 
 
Figura 27 - As linhas de código 12 e 13 indicam os numerais do host e a porta do servidor; inicia-se a variável 
“Clientes”; através de Socket conexão = servidor.accept() ocorre a conexão de uma outra pessoa. Criei um 
HashMap contendo como parâmetro o ClienteListener e variável “clientes”; Essa classe “Server” terá como 
finalidade, a conexão do usuário com o programa. Criei uma variável “conexão_info” com o tipo String, e em 
seguida inicializei a variável “clientes”. Criei uma variável “servidor” que aceitará a conexão, e um HashMap que 
fará uma varredura e armazenando os usuários dentro de um ArrayList. Criei um loop que enquanto o servidor 
estiver conectado, aceitará a conexão de outra pessoa, e poderá receber mensagens do usuário. 
 
 
Figura 28 - Caso a conexão seja bem sucedida, uma mensagem de “SUCESSO” será exibida, e caso contrário, a 
mensagem de “ERRO” será exibida;através do comando ClienteListener cl = new ClienteListener(conexão, this) 
será possível validar o login, e se isso ocorrer a classe ClienteListener será referenciada com as variáveis 
“conexão_info”, “conexão” e o server em que se encontra. Em seguida uma linha de gravação (thread) será inciada 
com o comando new Thread(cl).start(). Caso nada disso ocorra, uma mensagem de erro deve aparecer na tela. 
 
 
Figura 29 - Uma mensagem de [ERROR: Server] será exibida caso a tentativa de conexão com o servidor seja mal 
sucedida; o comando public MapcString. ClienteListener> getClientes() indica o método que assegura a conexão 
de todos os usuários. 
 
40 
 
 
Figura 30 - Aqui ocorre a checagem do login, através do comando private boolean checa_o_Login(string 
conexão_info); para separar a string usa-se o comando String[ ] splited = conexão_info.split( “:” ); através do 
comando for(Map .Entry<String. ClienteListener> pair: clientes.entrySet()) não permitirá que um usuário tenha o 
mesmo nome e/ou apelido e mesmo numeral de porta de rede; irá retornar valores “false” se o nome da chave for 
igual a variável “Splited”, e se host e porta forem iguais ao host e a porta “Splited”. 
 
 
Figura 31 - Caso haja sucesso na tentativa de login, será retornado “true”. O método “main” foi criado à fim de 
iniciar o servidor. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
41 
 
6.3. Como o programa deve ser 
 
 
Figura 32 – Tela de login com campos para as inserções das credenciais preenchidas pelo usuário, a fim de 
estabelecer conexão. 
 
 
 Figura 33 – Tela “Chat – Home”, após a conexão do usuário na aplicação. 
42 
 
 
Figura 34 – Teste do usuário para envio de mensagem. 
 
 
 
43 
 
 
 Figura 35 – Mensagem enviada após o teste feito pelo usuário. 
 
 
44 
 
6.4. Diagrama de caso de uso e o diagrama de classe da aplicação 
 
 
 Figura 36 – Diagrama de caso de uso, ilustrando a função que cada componente exerce na aplicação. 
 
 
 Figura 37 – Diagrama de classe, ilustrando a função das mesmas na aplicação. 
 
 
45 
 
7. PLANO DE DESENVOLVIMENTO DO PROJETO 
 
Para o desenvolvimento da aplicação do chat, constituído em linguagem 
Java, foi utilizado um MacBook Air (Mid 2009), da fabricante Apple, com processador 
Intel® Core™ 2 Duo 13 GHz, memória de 2GB 1067 MHz DDR3, de 120GB. Para 
auxiliar no desenvolvimento do chat, também foram usados os softwares Microsoft 
Word, SQLite e Microsoft Visual Studio. 
 
7.1. Conceitos básicos: linguagem de programação Java 
 
A linguagem de programação Java é uma das linguagens mais difundida 
entre os programadores e entusiastas da tecnologia, e ganhou mais força ao decorrer 
das últimas duas décadas. Por isso, existem inúmeras razões pelas quais um 
aspirante à programador, ou, quem está pensando em desenvolver uma aplicação, 
deve adquirir conhecimentos a fim de aprender a programar em Java. 
Sua linguagem de programação foi desenvolvida na década de 90 por um 
grupo de programadores chefiada por James Gosling, na empresa Sun Microsystems. 
Diferente das outras linguagens, que são compiladas para código nativo, a linguagem 
de programação Java é compilada para bytecode, que é executado por uma VM (ou 
máquina virtual). Atualmente, a linguagem Java serve de base de quase todos os tipos 
de desenvolvimentos em rede e, definiu-se, por padrão, sua eficiência para 
desenvolvimento e implementações de aplicações mobiles, games, conteúdo on-line 
e softwares corporativos. Por sua fácil compreensão de sintaxe, mesmo que ainda em 
inglês, a linguagem em questão possui mínima quantidade de caracteres especiais, o 
que simplifica a leitura e compreensão da linguagem, tornado mais fácil a elaboração 
das linhas de código. 
Por ser orientada a objetos, as implementações tornam-se mais fácil, 
permitindo, assim, manter o sistema flexível. Absorvendo os conceitos básicos, como 
por exemplo, Abstração, Encapsulamento, Polimorfismo, Hereditariedade etc., a 
elaboração de uma aplicação se torna mais dinâmica. 
Uma aplicação desenvolvida na linguagem Java constitui-se de alguns 
itens, sendo eles: 
46 
 
POO – Programação Orientada a Objetos: Trata os elementos da 
linguagem de maneira similar aos objetos reais. 
Packages – Ao pé da letra, package, transliterado do inglês para o 
português, significa “pacote”. Assemelha-se ao conceito de biblioteca de funções, 
sendo que um pacote (packge) é um conjunto de classes, alocadas em um diretório 
com o nome do respectivo pacote. O pacote padrão, ou, package default é o 
java.lang.*; pacote esse que é adicionado a todo arquivo java mesmo que o seu 
criador não o faça referência. O .* (ponto e asterisco) informa ao Java para incluir 
todas as classes do pacote. 
Classes – São um conjunto de objetos com características comuns. A 
classe serve como modelo para a elaboração de objetos, que possuem as mesmas 
características da classe à qual é pertencente. 
Objetos – Os objetos são os elementos da classe. Por exemplo: temos uma 
classe “carros” que é formada pelos objetos denominados “carros”. Os objetos têm 
em comum o fato de serem carros (dispõem da mesma mecânica), entretanto, “carros” 
podem conter características diferentes entre si. Vale ressaltar que objetos possuem 
variáveis e métodos como também classes. 
Instância – O conceito de instância baseia-se em uma classe onde um novo 
objeto é criado dessa classe, ou seja, é criar um objeto do mesmo tipo da classe. 
Métodos – São os estados e ações dos objetos e classes, ou seja, são 
funções, sub-rotinas ou procedimentos. 
Variáveis – Representam as características do objeto. 
Superclasse – As classes são criadas tendo outra como alicerce. A classe 
que originou a outra é denominada superclasse, e a classe gerada chama-se de 
subclasse. Logo, toda classe tem uma subclasse. 
Construtores – Usa-se os construtores para realizar a inicialização dos 
objetos. Esse é método possui o mesmo nome de sua classe, onde não há qualquer 
tipo de retorno. 
Polimorfismo – Denomina-se polimorfismo a capacidade que o método tem 
de executar a ação apropriada a depender do tipo de objeto. 
47 
 
Threads – As threads tem por sua função a execução de seus fluxos em 
paralelo. 
Herança – Ocorre quando a subclasse herda as características da 
superclasse. 
Encapsulamento – Serve para “esconder” do usuário a implementação, 
ocultando-a. 
Feita a abordagem de algumas funcionalidades da linguagem a fim de 
esclarecê-la, exibir seus benefícios, dinamismo e robustez, vale ressaltar que o Java, 
atualmente, também possui um tempo acelerado de updates de versões. Estima-se 
que uma versão atualizada é lançada a cada 06 meses, ratificando o quão elevado é 
o seu aceleramento em relação a inovação e atualização da linguagem. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
48 
 
 
 
7.2. Interface gráfica da aplicação 
 
Para o desenvolvimento da aplicação do chat, constituído em linguagem 
Java, foi utilizado um MacBook Air (Mid 2009), da fabricante Apple, com processador 
Intel® Core™ 2 Duo 13 GHz, memória de 2GB 1067 MHz DDR3, de 120GB. Para 
auxiliar no desenvolvimento do chat, também foram usados os softwares Microsoft 
Word, SQLite e Microsoft Visual Studio. 
Com seu desenvolvimento gráfico voltado para uma utilização intuitiva, sua 
interface foi elaborada através do software Microsoft Visual Studio, proporcionando ao 
usuário uma fácil compreensão da utilização da aplicação. 
O ambiente direcionado ao login do usuário conta com os campos de 
inserção das credenciais “Apelido”, onde o mesmo irá introduzir seu nome para que 
haja identificação, conta com o campo “Porta”, onde deve ser informado o numeral da 
porta, pelo usuário, sendo requisito necessário que o usuário execute a fim de que 
uma conexão possa ser estabelecida. Por fim, após todos os passos, o botão “Entrar” 
deve ser acionado para que o uso da aplicação logre êxito. 
 Logo abaixo, contém o protótipoda tela ilustrando sua interface, 
elaborada no Microsoft Visual Studio. 
 
 Figura 38 - Protótipo da tela de Login elaborada no Microsoft Visual Studio. 
49 
 
 
Não permitindo o recurso de arrastar/soltar, a elaboração do protótipo de 
tela supracitado, no Microsoft Visual Studio, gerou linhas de códigos para que se 
atingisse o resultado do protótipo que foi exibido acima. Abaixo, as linhas do código 
da elaboração da tela de Login. 
 
Figura 39 - Código da elaboração da tela de Login. 
 
50 
 
 
Logo assim que o usuário fizer as inserções de suas credenciais, 
conseguindo estabelecer conexão, ele será redirecionado a uma outra tela, a tela Chat 
– Home. Essa tela, Chat - Home, conta com os botões de ações “Atualizar Contatos” 
e “Abrir Conversa”. A classe “Home” foi criada e, contida nela, se encontram suas 
respectivas variáveis a fim de que se possa ser feita suas inicializações. Suas 
variáveis são: jl_titulo, jb_capt_conectados, jb_start_talk, jl_usuarios e JScrollPane). 
O título irá conter o nome e a porta do usuário na qual ele se encontra, que será 
atribuída através da variável jl_titulo. Já aos usuários conectados, será atribuído a eles 
a variável jb_capt_conectados. Essa variável é responsável por dar um refresh na lista 
de contatos, fazendo com que ocorra uma atualização desta lista. 
Para iniciar uma conversa, foi criada uma variável jb_star_talk, que, através 
dela, será possível abrir uma conversa, e, com a variável JScrollPane nos é permitido 
a exibição da lista de usuários. 
Suas especificações de interface gráficas foram definidas através de 
definição de tamanho do cabeçalho, cor de fundo e coloração da borda do cabeçalho. 
Para uma fácil administração, todo o layout da aplicação foi inserido em um método, 
sendo esse: config_componentes. 
A fim de propiciar um layout limpo e de fácil compreensão, aos botões 
“Atualizar contatos” (jb_capt_conectados) e “Abrir Conversa” (jb_star_talk), foram 
ordenados os seguintes comandos: jb_capt_conectados.setFocusable (false) e 
(jb_start_talk.setFocusable (false)). Ambos os comandos fazem com que os botões 
não fiquem “focados” ao passar sobre eles. Uma outra ação que foi implementada, foi 
a de que, através do comando 
jl_usuarios_setSelectionMode(ListeSelectionModel.SINGLE_SELECTION), o 
usuário poderá somente abrir uma conversa por vez. 
Para a visualização dos usuários online na aplicação, foi implementado o 
comando jl_usuarios.setBorder(BorderFactory.createTitleBorder, onde irá aparecer 
“Usuários Online”. A posição desse título, “Usuários Online”, será no canto superior 
esquerdo, e ele fará parte do contorno da borda. Se houver necessidade, barras 
laterais e horizontais foram implementadas para que, se caso o conteúdo de alguma 
51 
 
mensagem for extenso, o usuário faça uso das barras de rolagens para ler a 
mensagem em questão. 
Foram criados dois métodos, sendo eles: “inserc_acoes” e “main”. O 
método inser_acoes é para caso ocorra algum imprevisto e perceber que estaria 
havendo a repetição de código. O método main tem como função testar suas 
funcionalidades e averiguar se tudo está de acordo na aplicação. Abaixo, o protótipo 
da tela Chat – Home e suas linhas de código. 
 
 
Figura 40 - Protótipo da tela "Chat - Home", após o usuário ter feito a inserções de suas credenciais. 
 
52 
 
 
 Figura 41 - Linhas de código do protótipo da tela "Chat - Home". 
 
 Figura 42 - Linhas de código do protótipo da tela "Chat - Home". 
 
 
 
 
53 
 
 
 Figura 43 - Linhas de código do protótipo da tela "Chat - Home". 
 
 
 Figura 44 - Linhas de código do protótipo da tela "Chat - Home". 
 
 
 
 
 
 
 
 
54 
 
Após selecionar um usuário on-line, em sua lista de usuários, para dar 
início a uma comunicação, a respectiva tela que deve ser apresentada ao usuário é 
a da conversa com quem o mesmo está interagindo. Essa tela ela é constituída 
pelos botões de “Áudio” e “Enviar”. Possui também uma barra de rolagem 
(JScrollPane), para uma melhor visualização dos textos que vão sendo inseridos no 
campo de texto (JTextField). Abaixo, a imagem mostra a tela da conversa com o 
usuário selecionado. 
 
 Figura 45 - Protótipo da tela de conversa com o usuário selecionado. 
 
 
 
 
55 
 
 
Após o passo anterior, o usuário deve inserir o conteúdo de sua mensagem 
dentro do campo de texto, sendo atribuído a ele a variável JTextField. Abaixo, a 
imagem mostra o conteúdo da mensagem, inserida no campo destinado à ela. 
 
 
 Figura 46 - Protótipo da tela de envio de mensagem ao usuário selecionado. 
 
 
 
 
56 
 
 
Feito isso, o passo seguinte que o usuário deve executar é o evento de 
enviar o conteúdo de sua mensagem para o contato selecionado, implementado 
através do comando jd_mensagem.addActionListener(event-> enviar_mensagem()) 
que é responsável pelo disparo da mensagem. Nesse quesito, foi adicionado um 
detalhe: logo após que o usuário fizer o envio da mensagem, algumas informações, 
como por exemplo, seu nome (identificado como “Eu”) e horas, irão aparecer em 
negrito. Abaixo, a imagem mostra o resultado do envio da mensagem juntamente com 
todas suas linhas de códigos que foram necessárias. 
 
 
 Figura 47 - Protótipo de tela com mensagem enviada pelo usuário. 
57 
 
 
 Figura 48 – Linhas de código do protótipo da tela de envio de mensagem ao usuário 
 
 
 Figura 49 - Linhas de código do protótipo da tela de envio de mensagem ao usuário. 
 
 
 
58 
 
7.3. O chat 
 
Para o chat foi elaborado as seguintes especificações: pensou-se em um 
painel de rolamento de mensagens, que foi implementado através de um JScrollPane, 
e um local das exibições de mensagens, que pôde ser construído por meio de um 
JEditorPane. Além disso, foi idealizado também o local onde as mensagens a serem 
enviadas poderiam ser inseridas e, a forma mais simples e convencional, foi a 
elaboração de um campo de texto (JTextField). 
Visando identificar o outro usuário, que, por sua vez, é fundamental para 
que ocorra a comunicação, foi elaborado um espaço simples de identificação do 
mesmo. Optou-se que, no cabeçalho da janela de comunicação, seria a melhor opção 
para uma fácil e ágil identificação do usuário secundário que estivesse se 
comunicando em tempo real, através da aplicação. Há botões auxiliares, como por 
exemplo, o botão de “Áudio” e o botão “Enviar”, construídos através de um JButton. 
 
 Figura 50 - Protótipo da tela de identificação de quem o usuário está a conversar. O usuário Victor, está 
no chat conversando com sua mãe. 
 
59 
 
 
 
Figura 51 – Linhas de código gerada do protótipo de tela acima. 
 
Para que seja uma aplicação cômoda, agradável e dinâmica ao usuário, 
foram introduzidas barras de rolamentos (lateral e horizontal) que serão ativadas 
somente quando houver a necessidade, em casos de textos extensos, possibilitando, 
assim, a fácil leitura do conteúdo. 
O envio da mensagem, então, tornou-se algo a ser mais bem detalhado 
referente à suas informações. Por isso, foram acrescidas não somente a identificação 
do usuário (com seu nome destacado em negrito) bem como a hora (minutos e 
segundos) em que a mensagem em questão fora enviada. 
Funcionará da seguinte maneira: se no campo de mensagem estiver 
contido qualquer conteúdo de texto, logo assim que o usuário fizer o envio da mesma, 
ele será identificado como “Eu” (em negrito), seguido das informações de horas, 
minutos e segundos em que a mensagem foi enviada. 
60 
 
Abaixo, segue o protótipo da elaboração citada contando com a linha de 
código para a formataçãodas informações de ênfase no nome do usuário, e de hora. 
 
Figura 52 - Protótipo de tela com ênfase no nome do usuário juntamente com a identificação da hora do envio da 
mensagem. 
 
 
61 
 
 
Figura 53 - Linhas de código com ênfase no nome do usuário e com horas de envio de mensagem. 
 
7.4. Cliente 
 
A classe ClienteListener, tem como função estabelecer a conexão do 
cliente no servidor. Nela, ocorre a inicialização de variáveis para que seja possível a 
conexão. Um boolean foi inserido para que, se algo oposto disso ocorra, o estado da 
conexão será informado. Através da criação do método esta_executando, é possível 
saber, se, realmente está executando, informando o real estado dessa conexão, 
sendo ela: verdadeiro ou falso. Umm outro método também foi criado, que é o e do 
método run (que serve para deixar a classe CienteListener em execução). 
Caso o retorno do boolean seja verdadeiro, a execução ocorrerá sem 
quaisquer problemas e, enquanto ocorre a execução, o servidor recebe as 
mensagens. Se necessário, a fim de encerrar a execução, o usuário pode inserir a 
mensagem “Quit” que a conexão se dará por encerrada. Abaixo, seguem as linhas do 
código. 
 
 
62 
 
 
 Figura 54 - Linhas de código da classe ClienteListener. 
 
 
 Figura 55 - Linhas de código da classe ClienteListener. 
 
 
63 
 
 
 Figura 56 - Linhas de código da classe ClienteListener. 
 
 
7.5. Servidor 
 
A classe Server foi criada e projetada para servir como um modelo de 
servidor de mensagens e estabelecer a conexão do usuário com a aplicação. Para 
isso, é necessário que se indique os numerais de host e porta, do servidor. Nela, na 
classe Server, inicializa-se a variável Clientes, e através do socket de conexão 
conexão = servidor.accept(); é possível estabelecer a conexão de uma outra pessoa. 
Um HashMap foi criado, e nele contém o parâmetro CLienteListener e a variável 
Clientes. Uma outra variável, “conexão_info”, do tipo String, foi criada e em seguida 
uma outra variável, “servidor”, foi criada, também, para que haja a aceitação de 
conexão. Um HashMap ficará responsável por executar a varredura e 
armazenamentos dos usuários dentro de um ArrayList e um loop foi criado para que, 
enquanto o servidor estiver conectado, seja possível estabelecer a conexão de outra 
pessoa e receber mensagens do usuário. 
Caso a conexão logre êxito uma mensagem será exibida, e caso contrário, 
não havendo a conexão, será exibida da mesma forma uma mensagem informando 
que não foi possível estabelecê-la. Não sendo possível efetuar a validação de login 
através do comando ClienteListener cl = new ClienteListener(conexão, this), não 
ocorrendo a devida referência às variáveis “conexão_info” e “conexão” por meio da 
classe ClienteListener, no server que se encontra e nem iniciando o comando new 
Thread(cl).start(), uma mensagem de erro deve ser exibida. 
A mensagem de erro que deve ser exibida caso a tentativa de conexão com 
servidor não ocorra é [ERROR: Server]. Foi implementado um comando que assegura 
a conexão de todos os usuários, sendo ele: ClienteListener cl = new 
ClienteListener(conexão, this). Pensou-se também em um jeito onde a checagem do 
64 
 
login fosse feita, e através do comando “private boolean checa_o_Login(string 
conexão_info)” foi possível isso. Além disso, um comando de checagem de usuários 
foi inserido a fim de que os usuários não possuam o mesmo nome (ou apelido) e o 
mesmo número de porta de rede. Será retornado o valor “false” se caso o nome da 
chave for igual a variável Splited, e se o host e porta forem iguais ao host e a porta 
Splited. Havendo êxito no login, será retornado “tru”. O método main foi criado para 
que seja iniciado o servidor. Abaixo, as linhas de código. 
 
 Figura 57 - Linhas de código usadas para o Servidor. 
 
 Figura 58 - Linhas de código usadas para o Servidor. 
 
65 
 
 
Figura 59 - Linhas de código usadas para o Servidor. 
 
 
 
 
Figura 60 - Linhas de códigos usadas para o Servidor. 
 
 
 
Figura 61 - Linhas de código usadas para o Servidor. 
 
 
66 
 
7.6. Conceitos básicos: banco de dados 
 
Bancos de dados ou bases de dados são conjuntos de arquivos 
relacionados entre si com registros sobre pessoas, lugares ou até mesmo coisas. 
Como o nome sugestivo, um banco de dados é um local onde se pode armazenar 
dados de uma forma organizada, dando origem a conjuntos de arquivos. Um BD 
permite o agrupamento de informações que, depois, podem ser retiradas para outras 
funções. 
O elemento imperioso de um Banco de Dados é a tabela. Nela é possível 
fazer a relação entre tabelas que consiste num conjunto de dados dispostos em forma 
de linhas com conjuntos idênticos de propriedades, que são os registros. 
Um registro (ou tupla) é uma linha da tabela que representa todas as 
informações de uma entidade. 
Um campo é uma coluna da tabela, onde essa representa uma das 
informações do registro. 
 
 
 
 
 
 
 
 
 
 
 
 
67 
 
 
7.6.1. SQLite 
 
É uma biblioteca em linguagem C que implementa um banco de dados SQL 
embutido. A partir dele foi possível criar as seguintes tabelas: Login e Servidor. 
A tabela Login, é constituída por nome e senha. A tabela Servidor, é 
constituída por mensagem e nome 
Na tabela Login, os campos Nome e Senha não podem ficar em branco, 
tem de obrigatoriamente ser preenchidos. Devido a isso, suas especificações são 
dadas como NOT NULL e o campo Nome é sinalizado com uma chave, indicando ser 
uma chave primária. Abaixo, imagem da tabela Login 
 
 Figura 62 - Tabela Login para armazenar o Nome e Senha do usuário. 
 
 
 
A tabela Servidor, é constituída pelos campos Mensagem e nome, sendo 
“Nome” identificada com uma chave estrangeira, relacionada com a tabela Login. 
Abaixo, imagem da tabela Servidor. 
 
Figura 63 - Tabela Servidor com os campos Mensagem e Nome. 
 
 
68 
 
 
 
7.7. Caso de uso: o que cada usuário pode fazer na aplicação? 
 
O servidor faz com que haja a conexão, estabelecendo-a. Os usuários 
podem efetuar login, atualizar contatos, acessar conversas e enviar mensagens. 
Abaixo, as imagens que ilustram o diagrama de caso de uso, e o diagrama de classe. 
 
 
 Figura 64 - Digrama de caso de uso. 
 
Figura 65 - Diagrama de classes. 
69 
 
8. LINHAS DE CÓDIGO DO PROGRAMA 
 
 
 
 
 
 
70 
 
 
 
 
 
71 
 
 
 
72 
 
 
 
 
 
73 
 
 
 
 
 
74 
 
 
 
 
 
75 
 
 
 
 
 
 
 
 
76 
 
 
9. REFERÊNCIAS BIBLIOGRÁFICAS 
 
ALENCAR, A. IPAM Amazonia. ipam.org, 2019. Disponivel em: 
<https://ipam.org.br/wp-content/uploads/2019/08/NT-Fogo-Amazônia-2019.pdf>. 
Acesso em: 20 abr. 2020. 
FOROUZAN, B. A. Comucations and Networking. 5. ed. New York: The MacGraw 
Hill-Companies, Inc, v. 1, 2007. 
MOUTINHO, P. IPAM Amazonia. ipam.org, 2019. Disponivel em: 
<https://ipam.org.br/wp-content/uploads/2019/08/NT-Fogo-Amazônia-2019.pdf>. 
Acesso em: 20 abr. 2020. 
SANTOS, A. H. O. uniaogeek.com.br. União Geek, 17 mar. 2020. Disponivel em: 
<https://www.uniaogeek.com.br/redes-de-comunicacao-de-dados-principais-
conceitos/>. 
SILVA, S. IPAM Amazonia. ipam.org, 2019. Disponivel em: <https://ipam.org.br/wp-
content/uploads/2019/08/NT-Fogo-Amazônia-2019.pdf>. Acesso em: 20 abr. 2020. 
SILVÉRIO, D. IPAM Amazonia. ipam.org, 2019. Disponivel em: 
<https://ipam.org.br/wp-content/uploads/2019/08/NT-Fogo-Amazônia-2019.pdf>. 
Acesso em: 20 abr. 2020. 
TANENBAUM, A. S. Computer Networks. Amsterdam: Campus, 2003. Disponivel 
em: 
<http://www.vazzi.com.br/arquivos_moodle/Redes%20de%20Computadores%20-
%20Tanenbaum.pdf>. 
 
 
 
 
 
 
 
 
 
 
 
 
77