Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatica si
Microelectronica Departamentul Ingineria
Software si Automatica

RAPORT
Lucrarea de laborator nr.3
Disciplina: Programare în rețea
Tema: Client HTTP

A efectuat: Bolgari Vasile

st. gr. TI-171

A verificat: Buldumac Oleg

Chișinău 2020
Mersul lucrării:
Aplicația mea este conectată cu Facebook, de aceea aceasta începe cu interfața de logare a
utilizatorului:

Figura 1. Interfața de logare

La apăsarea butonului de logare se primește loginul și parola, pe lângă acestea mai sunt
înscrise în cod și id-ul aplicației prin care facebook ne oferă date și domainul pe care se face
redirect(eu folosesc “google.com”) pentru a înscrie datele în URL. Pentru început se crează un
FacebookClient și se formează URL pentru OAuth. Eu am ales să fac logarea prin WebDriver și
de aceea deschid Chrome și mă loghez prin el. După redirect primesc URL și din el extrag Acces
Token.
private void LoginButtonMouseClicked(java.awt.event.MouseEvent evt) {
String username = UsernameTextField.getText();
String password = new String(PasswordField.getPassword());

// Facebook application data

String appID = "35445440545405476";
String domain = "https://google.com/";

// Url to get access tocken

ScopeBuilder permissions = new ScopeBuilder();
permissions.addPermission(FacebookPermissions.PUBLIC_PROFILE);
permissions.addPermission(FacebookPermissions.PAGES_SHOW_LIST);

//permissions.addPermission(FacebookPermissions.PAGES_READ_USER_CONTENT)
;
 FacebookClient facebookClient = new
DefaultFacebookClient(Version.VERSION_7_0);
String oauthUrl = facebookClient.getLoginDialogUrl(appID,
domain, permissions);

// Webdriver
//--------------------------------------------------------------
------------------------------------
System.setProperty("webdriver.Chrome.driver",
System.getProperty("user.dir") + "/chromedriver.exe");

WebDriver driver = new ChromeDriver();

driver.get(oauthUrl+ "&response_type=token");

// Fiend fields by id
WebElement usernameField = driver.findElement(By.id("email"));
WebElement passwordField = driver.findElement(By.id("pass"));
WebElement loginButton =
driver.findElement(By.id("loginbutton"));

// Send keys
usernameField.sendKeys(username);
passwordField.sendKeys(password);
loginButton.click();

String accessTockenPattern = "^(https?:\\/\\/)?(www\\.)?

google.com\\/#access_token=.*";

// If we are at login page then stay in while loop

while (!driver.getCurrentUrl().matches(accessTockenPattern)) {}

// Get response url

String responseUrl = driver.getCurrentUrl();

// Get access token

String accessToken =
responseUrl.substring(responseUrl.indexOf("=") + 1,
responseUrl.indexOf("&"));

// Close driver
driver.close();
//--------------------------------------------------------------
------------------------------------

// Create new window

MainForm mainWindow = new MainForm(accessToken);
centerTheWindow(mainWindow);
mainWindow.setVisible(true);

// Dispose login window

this.dispose();
}
 Ar mai trebui de spus și despre permisiunile care le întroduc pentru ca utilizatorul să le
accepte. Apoi formez o nouă interfață ce primește Acces Token-ul.

Figura 2. Redirect pe google.com și primirea acces_tocken

Pentru verificarea URL la conținerea access tocken se formează un regex și se verifică până
când nu se validează:
String accessTockenPattern = "^(https?:\\/\\/)?(www\\.)?
google.com\\/#access_token=.*";

// If we are at login page then stay in while loop

while (!driver.getCurrentUrl().matches(accessTockenPattern)) {}

Pentru primirea datelor despite utilizator formez un nou FacebookClient și deja extrag datele
de bază(ID, NUME, POZA). Extrag paginile create de către utilizator și deja le înscriu într-un
ArrayList de clase AccountPages, ce conține date de bază despre pagini.
ArrayList<AccountPages> listOfPages = new ArrayList<>();

Clase AccountPages:
public class AccountPages {
private String tocken;
 private String name;
private String id;
private String category;

public AccountPages(String tocken, String name, String id, String

category) {
this.tocken = tocken;
this.name = name;
this.id = id;
this.category = category;
}

public String getTocken() {

return tocken;
}

public String getName() {

return name;
}

public String getId() {

return id;
}

public String getCategory() {

return category;
}
}

Primirea datelor generale despre utilizator:

void getProfileGeneral() {

IDLabel.setText(userID);
NameLabel.setText(user.getName());
}

void getprofileImage() {
JsonObject picture
= facebookClient.fetchObject("me/picture",
JsonObject.class, Parameter.with("redirect",
"false"));

var pictureUrl = picture.get("data").asObject().get("url");

try {
URL imageUrl = new URL(pictureUrl.asString());

Image image = ImageIO.read(imageUrl);

BufferedImage resizedImage = resizeImage(image, 100, 100,
true);

ImageIcon icon = new ImageIcon(resizedImage);

PhotoLabel.setText("");
PhotoLabel.setIcon(icon);
} catch (Exception ex) {
 Logger.getLogger(MainForm.class.getName()).log(Level.SEVERE,
null, ex);
}
}

Figura 3. Datele generale despre utilizator

Primirea datelor generale depre Pagini:
void getAccountConnections() {
Connection<Account> pages =
facebookClient.fetchConnection("me/accounts", Account.class);
List<Account> accounts = pages.getData();

DefaultListModel listModel = new DefaultListModel();

for (Account account : accounts) {

listOfPages.add(new AccountPages(account.getAccessToken(),
account.getName(),
account.getId(),
account.getCategory()));

listModel.addElement(" " + account.getName());

}
 Border emptyBorder = BorderFactory.createEmptyBorder();
jList.setBorder(emptyBorder);
jList.setModel(listModel);
}

Pentru postarea mesajelor în grupuri se creează un nou thread cu o singură sarcină – postarea
mesajelor:
private void PostButtonMousePressed(java.awt.event.MouseEvent evt) {
String message = PostTextField.getText();

// Create new thread

new Thread("Post") {
@Override
public void run() {
facebookClient.publish(pageID + "/feed",
GraphResponse.class, Parameter.with("message", message));
}
}.start();
}

Codul sursă: https://github.com/Alonyaik/PR1

Concluzii:
Primirea datelor prin aplicația creată este un lucru mult mai complex decât poate arăta, în
primul rând Facebook oferă foarte puține permisiuni default pentru aplicație, chiar și dacă ești
admin sau de pe test account. Pentru restul permisiunilor trebuie să justifici prin prezentare video
cum va fi folosită permisiunea. Pentru laborator au fost necesare cunoștințe mai aprofundate
despre http, plus a fost necesară studierea librăriei restfb și API pentru Facebook. Cea mai
plăcută parte este că Java are librării ce pot simplifica lucrul cu HTTP.

Acest laborator a fost unul de repetare a așa momente ca liste, comenzi și eventuri, dar spre
sfârșit a devenit un unic ansamblu al proiectului.
Întrebări la apărarea laboratorului:
- Cum este formatat corpul unei cereri HTTP pentru o cerere HTTP de tip POST ?
Valorile sunt trimise în corpul cererii, în formatul de tipul application/x-www-form-
urlencoded.

- De unde știe un client HTTP ce tip de conținut trimite serverul HTTP ?

Serverul specifică tipul conținutului în header-ului Content-Type, însă clientul poate cere
un anumit tip: text/html, application/json, application/xml.

- Cum decide un client dacă ar trebui să aibă încredere în certificatul unui server ?
Pentru o anumită încredere clientul trebuie să se asigure că Certification Authority al unui
server este transparent si are o compatibilitate semnificativă cu browsere și dispozitivele
mobile mai vechi.

- Care este problema principală cu certificatele autosemnate ?

Certificatele autosemnate pot fi comparate cu actele reale falsificate; problema de bază
este că pot fi furate datele confidentiale ale utilizatorului.

- Conexiunea persistentă HTTP – care sunt principalele beneficii ?

Modelul de conexiune persistentă – menține deschise conexiunile între cererile succesive,
reducând timpul necesar pentru a deschide conexiuni noi. Modelul de canalizare HTTP
merge cu un pas mai departe, prin trimiterea mai multor solicitări succesive, fără să aștepte
răspuns, reducând o mare parte din latența din rețea.

- Ce este negocierea conținutului în HTTP și cum are loc ?

În HTTP, negocierea conținutului este mecanismul utilizat pentru difuzarea diferitelor
reprezentări ale unei resurse la același URI, astfel încât agentul utilizator poate specifica care
este cel mai potrivit pentru utilizator.

- Care sunt tipurile de negociere a conținutului HTTP ?

În negocierea conținutului bazată pe server, browserul (sau orice alt tip de user-agent)
trimite mai multe anteturi HTTP împreună cu adresa URL. Aceste anteturi descriu alegerea
preferată a utilizatorului. Serverul le folosește ca indicii, iar un algoritm intern alege cel mai
bun conținut pentru a-l servi clientului.
 În negocierea bazată pe agent, atunci când se ajunge la o solicitare ambiguă, serverul
trimite înapoi o pagină care conține legături către resursele alternative disponibile.
Utilizatorului i se prezintă resursele și îl alege pe cel pe care să-l folosească.

- Ce este un ETag în HTTP și cum funcționează ?

Antetul de răspuns ETag (entitate etichetă) oferă un mecanism pentru a memora în cache
resursele neschimbate. Valoarea acestuia este un identificator care reprezintă o versiune
specifică a resursei.

- Diferența dintre protocoalele fără stare și cele cu stare. Cărui tip îi aparține HTTP ?
Protocoalele fără stare sunt tipul de protocoale de rețea în care clientul trimite o cerere
către server, iar serverul răspunde înapoi în funcție de starea curentă. Serverul nu reține
informații de sesiune sau stări despre fiecare partener în comunicarea multiplă.
Protocolul cu stare, dacă clientul trimite o solicitare către server, atunci se așteaptă la un
fel de răspuns, dacă nu primește niciun răspuns, atunci va retrimite cererea.
Protocolul HTTP face parte din protocoale fără stare.

- Avantajele cheie ale HTTP/2 în comparație cu HTTP/1.1

Cele mai semnificative avantaje ale HTTP/2 în comparație cu HTTP/1.1 sunt:
 viteze de încărcare a paginii web (mare repede până la 2x)
 site-uri adaptive cu dispozitive mobile
 securizarea mai sigură
 compatibilitate cu HTTP/1.1

- Ce este un tip MIME, din ce constă și pentru ce se folosește ?

Un tip media (MIME) este un standard care indică formatul unui document, fișier sau
resursă. Structura acestui tip este urmatoare: tip/subtip. Tipul reprezinta categoria generală în
care intră tipul de date, cum ar fi video sau text. Subtipul identifică tipul exact de date de
tipul specificat pe care îl reprezintă tipul MIME. Cele mai populare sunt: text/plain,
text/html, multipart/form-data, application/json, application/x-www-form-urlencoded etc.

- Care este diferența dintre GET și POST ?

GET: Datele sunt solicitate de la o resursă
POST: Datele sunt trimise către o resursă

- Care este diferența dintre PUT și POST ?

 PUT: atribuie o resursă la un anumit URI. Dacă există resursă la același URI, PUT
înlocuiește această resursă.
POST: Datele sunt transmise pentru a fi procesate către o anumită resursă

- Care sunt metodele idempotente în HTTP și care sunt scopul lor.

Metodele Idempotent sunt metode HTTP care la apelarea multiplă produce același
rezultat. Sunt considerate opțiunea sigură pentru a actualiza o resursă pe server. Unele
exemple de metode HTTP idempotente sunt GET, PUT și PATCH.

- Cum sunt identificate resursele în protocolul HTTP ?

În HTTP se folosește un URI special pentru identificarea resurselor. Identitatea și locația
resurselor de pe Web sunt date în mare parte de o singură adresă URL.

- Care sunt metodele sigure și nesigure în HTTP ?

Metode sigure:
 OPTIONS
 GET
 HEAD

Metode nesigure:
 PUT
 POST
 DELETE
 PATCH

- Pentru ce este nevoie de cURL ?

Curl este un instrument de linie de comandă și utilizează sintaxa URL pentru a transfera
date către și de pe server. cURL este utilizată pe larg, datorită capacității sale flexibile și
rezolvarea sarcinilor complexe. Poate fi utilizat pentru autentificarea utilizatorului, postare
HTTP, conexiuni SSL, încărcări FTP, etc.

- Pentru ce este nevoie de HTTP Proxy?

 Confidențialitate
 Web Scraping
 Activități anonime
 Gestionarea multiplă a conturilor
- Diferența dintre autentificare și autorizare.
Principala diferență dintre acestea este întrebările la care răspund: autentificare răspunde
la întrebarea ”Cine este utilizatorul?” iar autorizare – ”Ce drepturi are utilizatorul”.

- Care sunt metodele de autentificare HTTP ?

 HTTP Basic Authentification
 Cookies
 Tokens
 One-Time Password

- Modalități de identificare a utilizatorilor în HTTP

 Antetul HTTP
 Adresa IP
 URL
 Cookie
 Datele de logare

- HTTP cookies – pentru ce se folosește ?

HTTP cookies – este informația transmisă de către server browser-ului utilizatorului
pentru utilizarea acesteia la viitoarea apelare. Aceasta de obicei se folosește pentru a menține
utilizatorul conectat la solicitarea a două sesiuni, de pe același browser, concomitent. De
obicei se folosește pentru: managementul sesiunii, personalizare și analiza comportamentului
utilizatorului.