Sunteți pe pagina 1din 5

Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatica și Micorelectronică

Departamentul Ingineria Software si Automatica

Raport
Lucrarea de laborator nr. 3
La disciplina: Aplicatii Distribuite Avansate

Tema: Aplicarea şablonului arhitectural EventSourcing. Serializarea mesajelor cu


serializatoarele JSON, Protobuf.

A efectuat:

A verificat: lect., univ.

Torica Eugeniu

Chișinău 2020
Sarcina:
1) Scrieţi un prototip de back-end al unei aplicaţii de task management. Operaţiunile de creare şi
modificare a unui sau mai mutle cîmpuri ale unui task asupra task-ului trebuie să se păstreze într-un tabel
care permite doar operaţiune de adăugare a înregistrărilor. Operaţiunile de ştergere/modificare a
înregistrărilor nu sunt permite.

Entităţile minim necesare în aplicaţie: Task, Task Comment, User.

Cîmpurile entităţilor

Task: id, version, title, description, status_id, user_id, created_at

TaskComment: id, version, content, created_at

User: id, name

2) Serializaţi înregistrările cu un serializator JSON. Generaţi 1000 de evenimente. Comparaţi


mărimea datelor stocate. Schimbaţi serliazatorul pe Protobuf şi rulaţi acelaşi experiment. Comentaţi
rezultatele obţinute.

Noțiuni Teoretice
Serializarea este procesul de traducere a structurilor de date sau a stării obiectului într-un format
care poate fi stocat sau transmis (de exemplu, printr-o legătură de conexiune la rețea) și reconstruit. mai
târziu (posibil într-un mediu computerizat diferit). Când seria de biți rezultată este recitită în funcție de
formatul de serializare, acesta poate fi utilizat pentru a crea o clonă semantic identică a obiectului inițial.
Pentru multe obiecte complexe, cum ar fi cele care utilizează pe scară largă referințele, acest proces nu
este simplu. Serializarea obiectelor orientate pe obiect nu include nici una dintre metodele asociate cu
care acestea au fost anterior legate.
Pentru ca unele dintre aceste caracteristici să fie utile, independența arhitecturii trebuie menținută.
De exemplu, pentru utilizarea maximă a distribuției, un computer care rulează pe o arhitectură hardware
diferită ar trebui să poată reconstrui în mod fiabil un flux de date serializat, indiferent de endianness.
Aceasta înseamnă că procedura mai simplă și mai rapidă de copiere directă a dispunerii memoriei
structurii de date nu poate funcționa în mod fiabil pentru toate arhitecturile. Serializarea structurii datelor
într-un format independent de arhitectură înseamnă prevenirea problemelor de ordonare a octeților,
dispunere de memorie sau pur și simplu diferite moduri de reprezentare a structurilor de date în diferite
limbaje de programare. Inerentă oricărei scheme de serializare este aceea, deoarece codificarea datelor
este prin definiție serială, extragerea unei părți din structura de date serializate necesită ca întregul obiect
să fie citit de la început până la sfârșit și reconstruit. În multe aplicații, această liniaritate este un atu,
deoarece permite utilizarea interfețelor I / O simple, comune pentru a reține și transmite starea unui
obiect. În aplicațiile în care o performanță mai mare este o problemă, poate avea sens să depui mai mult
efort pentru a face față unei organizații de stocare mai complexe, neliniare. Chiar și pe o singură mașină,
obiectele indicatoare primitive sunt prea fragile pentru a fi salvate, deoarece obiectele către care se
îndreaptă pot fi reîncărcate într-o altă locație din memorie. Pentru a face față acestui lucru, procesul de
serializare include o etapă numită unswizzling sau unswizzling pointer, în care referințele directe pointer
sunt convertite în referințe bazate pe nume sau poziție. Procesul de deserializare include o etapă inversă
numită indicatorul care se întinde. Deoarece atât serializarea cât și deserializarea pot fi conduse de la
codul comun (de exemplu, funcția Serialize din clasele Microsoft Foundation), este posibil ca codul
comun să le facă ambele în același timp și, astfel, 1) să detecteze diferențele dintre obiectele fiind
serializate și copiile lor anterioare și 2) furnizează intrarea pentru următoarea detectare. Nu este necesar
să se construiască efectiv copia anterioară, deoarece se pot detecta diferențe din mers. Tehnica se numește
execuție diferențială. Acest lucru este util în programarea interfețelor utilizatorului al căror conținut
variază în timp - obiectele grafice pot fi create, eliminate, modificate sau făcute pentru a gestiona
evenimentele de intrare fără a fi neapărat necesar să scrie cod separat pentru a face aceste lucruri.
Protocol Buffers (Protobuf) este o metodă de serializare a datelor structurate. Este util în
dezvoltarea de programe pentru a comunica între ele printr-un fir sau pentru stocarea datelor. Metoda
implică un limbaj de descriere a interfeței care descrie structura unor date și un program care generează
cod sursă din acea descriere pentru generarea sau analizarea unui flux de octeți care reprezintă datele
structurate. Google a dezvoltat buffere de protocol pentru uz intern și a furnizat un generator de cod
pentru mai multe limbi sub licență open source (a se vedea mai jos) Obiectivele de proiectare pentru
Protocolul Buffers au subliniat simplitatea și performanța. În special, a fost proiectat să fie mai mic și mai
rapid decât XML. Protecțiile tampon de protocol sunt utilizate pe scară largă la Google pentru stocarea și
schimbul de tipuri de informații structurate. Metoda servește ca bază pentru un apel de procedură
personalizată de la distanță (RPC), care este utilizat pentru aproape toate comunicările între mașini la
Google.Protecțiile tampon de protocol sunt similare cu protocoalele Apache Thrift (utilizate de Facebook)
sau protocoalele Microsoft Bond, oferind, de asemenea, o stivă de protocol RPC concretă pentru a fi
utilizate pentru servicii definite numite gRPC. Structurile de date (numite mesaje) și serviciile sunt
descrise într-un fișier de definire proto (.proto) și compilate cu protoc. Această compilare generează cod
care poate fi invocat de către expeditor sau destinatar al acestor structuri de date. De exemplu,
example.pb.cc și example.pb.h sunt generate de la example.proto. Ei definesc clase C ++ pentru fiecare
mesaj și serviciu de exemplu.proto. Canonic, mesajele sunt serializate într-un format de sârmă binară
compatibilă, compatibilă înainte și înapoi, dar nu auto-descrizătoare (adică nu există nicio modalitate de a
spune numele, sensul sau tipurile de date complete ale câmpurilor fără o specificație externă) ). Nu există
o modalitate definită de a include sau de a face referire la o astfel de specificație externă (schemă) într-un
fișier tampon de protocol. Implementarea acceptată oficial include un format de serializare ASCII, dar
acest format - deși auto-descriind - pierde comportamentul de compatibilitate înainte și înapoi și, prin
urmare, nu este o alegere bună pentru alte aplicații decât depanarea. Deși scopul principal al Protecțiilor
tampoanelor este acela de a facilita comunicarea în rețea, simplitatea și rapiditatea acesteia fac din
Protecția Protocolului o alternativă la clasele și structurile C ++ centrate pe date, în special în cazul în
care ar putea fi nevoie de interoperabilitate cu alte limbi sau sisteme în viitor.

var fs = require('fs');
var protocolBuffers = require('protocol-buffers');

var Schema = protocolBuffers(fs.readFileSync('./user.proto'));

module.exports = {
init: function() {
},
encode: function(obj) {
return Schema.User.encode(obj);
},
decode: function(data) {
return Schema.User.decode(data);
},
};

var protobufjs = require('protobufjs');

var builder = protobufjs.loadProtoFile('./user.proto');


var User = builder.build('User');

module.exports = {
init: function() {},
encode: function(obj) {
var user = new User();
for (var k in obj) {
user[k] = obj[k];
}
return user.encode().toBuffer();
},
decode: function(data) {
return User.decode(data);
},
};

module.exports = {
init: function() {
},
encode: function(obj) {
return JSON.stringify(obj);
},
decode: function(data) {
return JSON.parse(data);
},
};
var express = require('express');
var router = express.Router();
var fs = require('fs');
var path = require('path');

var taskEvents = require('../task-events');

/* GET home page. */


router.get('/', getTasks, function(req, res) {
console.log('Tasks: %s', JSON.stringify(req.tasks.tasks));
res.render('index', { title: 'Task manager', tasks: req.tasks.tasks });
});

router.get('/start-task', function(req, res) {


taskEvents.emit('startTimer', res);
});

function getTasks(req, res, next) {


var filePath = path.join(__dirname, '../tasks.json');
var fileContent = fs.readFileSync(filePath);
req.tasks = JSON.parse(fileContent);
next();
}

function load(dir) {
var codecs = [];
var files = fs.readdirSync(dir);
for (var i in files) {
var basename = path.basename(files[i], '.js');
var modname = dir + '/' + basename;
codecs.push({
name: basename,
impl: require(modname),
});
}
return codecs;
}

function main() {
var codecs = load('../codecs');
var n = 10000;
var input = require('../tasks.json');
var rawSize = JSON.stringify(input).length;
var i;
var j;

for (i = 0; i < codecs.length; ++i) {


var codec = codecs[i];
var label = codec.name + ' encode';

var encodedData = codec.impl.encode(input);


var encodedSize = encodedData.length;

var percent = Math.round(((rawSize - encodedSize) / rawSize) * 100);


console.log(label + ' compress percent: ' + percent + '%');
console.time(label);
for (j = 0; j < n; ++j) {
codec.impl.encode(input);
}
console.timeEnd(label);

label = codec.name + ' decode';


console.time(label, '\t\t\t');
for (j = 0; j < n; ++j) {
codec.impl.decode(encodedData);
}
console.timeEnd(label);

console.log('-----------------------');
}
}

main(process.argv);

module.exports = router;

S-ar putea să vă placă și

  • 5555
    5555
    Document7 pagini
    5555
    VicuPopusoi
    100% (1)
  • 1234 Asd
    1234 Asd
    Document4 pagini
    1234 Asd
    VicuPopusoi
    Încă nu există evaluări
  • 123 Asdf
    123 Asdf
    Document9 pagini
    123 Asdf
    VicuPopusoi
    Încă nu există evaluări
  • Fegal 8 Finegal 23 Finterv (4-12) : A0 A1 A2 A3 A4 Fint
    Fegal 8 Finegal 23 Finterv (4-12) : A0 A1 A2 A3 A4 Fint
    Document4 pagini
    Fegal 8 Finegal 23 Finterv (4-12) : A0 A1 A2 A3 A4 Fint
    VicuPopusoi
    Încă nu există evaluări
  • Desfăşurarea Lucrării
    Desfăşurarea Lucrării
    Document6 pagini
    Desfăşurarea Lucrării
    VicuPopusoi
    Încă nu există evaluări
  • 8888
    8888
    Document1 pagină
    8888
    VicuPopusoi
    Încă nu există evaluări
  • Modeme Inteligente
    Modeme Inteligente
    Document12 pagini
    Modeme Inteligente
    VicuPopusoi
    Încă nu există evaluări
  • 1111
    1111
    Document5 pagini
    1111
    VicuPopusoi
    Încă nu există evaluări
  • Subiecte Examen ARC2018
    Subiecte Examen ARC2018
    Document2 pagini
    Subiecte Examen ARC2018
    VicuPopusoi
    Încă nu există evaluări
  • 123 Asdf
    123 Asdf
    Document5 pagini
    123 Asdf
    VicuPopusoi
    Încă nu există evaluări
  • Rezolvarea Lucrării:: Tabelul de Adevăr Al Comparatorului
    Rezolvarea Lucrării:: Tabelul de Adevăr Al Comparatorului
    Document2 pagini
    Rezolvarea Lucrării:: Tabelul de Adevăr Al Comparatorului
    VicuPopusoi
    Încă nu există evaluări
  • 1234 Asdf
    1234 Asdf
    Document5 pagini
    1234 Asdf
    VicuPopusoi
    Încă nu există evaluări
  • Si 1
    Si 1
    Document7 pagini
    Si 1
    VicuPopusoi
    Încă nu există evaluări
  • Fituici Pentru Examen La Retele de Calculatoare. (Conspecte - MD)
    Fituici Pentru Examen La Retele de Calculatoare. (Conspecte - MD)
    Document25 pagini
    Fituici Pentru Examen La Retele de Calculatoare. (Conspecte - MD)
    VicuPopusoi
    Încă nu există evaluări
  • Exam
    Exam
    Document10 pagini
    Exam
    VicuPopusoi
    Încă nu există evaluări
  • Lab 1
    Lab 1
    Document7 pagini
    Lab 1
    Ramzes CRIS
    Încă nu există evaluări
  • Laborator 2 ASDN
    Laborator 2 ASDN
    Document7 pagini
    Laborator 2 ASDN
    Iulian Decuseara
    Încă nu există evaluări
  • L4n DV
    L4n DV
    Document5 pagini
    L4n DV
    UnFGB
    Încă nu există evaluări
  • Laborator 4 ASDN
    Laborator 4 ASDN
    Document7 pagini
    Laborator 4 ASDN
    RoscaFlorin
    Încă nu există evaluări
  • Fituici Pentru Examen La Retele de Calculatoare. (Conspecte - MD)
    Fituici Pentru Examen La Retele de Calculatoare. (Conspecte - MD)
    Document25 pagini
    Fituici Pentru Examen La Retele de Calculatoare. (Conspecte - MD)
    VicuPopusoi
    Încă nu există evaluări
  • SDA
    SDA
    Document1 pagină
    SDA
    danpk1999
    Încă nu există evaluări
  • SDAlab 2 Si 3
    SDAlab 2 Si 3
    Document2 pagini
    SDAlab 2 Si 3
    VicuPopusoi
    Încă nu există evaluări
  • Laborator 3 ASDN
    Laborator 3 ASDN
    Document8 pagini
    Laborator 3 ASDN
    Iulian Decuseara
    Încă nu există evaluări
  • L4n DV
    L4n DV
    Document5 pagini
    L4n DV
    UnFGB
    Încă nu există evaluări
  • Asdn 4
    Asdn 4
    Document7 pagini
    Asdn 4
    VicuPopusoi
    Încă nu există evaluări
  • L4n DV
    L4n DV
    Document5 pagini
    L4n DV
    UnFGB
    Încă nu există evaluări
  • SDAlab 4 Si 5
    SDAlab 4 Si 5
    Document1 pagină
    SDAlab 4 Si 5
    VicuPopusoi
    Încă nu există evaluări
  • STAT
    STAT
    Document7 pagini
    STAT
    VicuPopusoi
    Încă nu există evaluări
  • Lucrare
    Lucrare
    Document6 pagini
    Lucrare
    VicuPopusoi
    Încă nu există evaluări
  • SDAlab 6
    SDAlab 6
    Document1 pagină
    SDAlab 6
    VicuPopusoi
    Încă nu există evaluări