Implementatie van een eenvoudige blockchain in Java

1. Overzicht

In deze tutorial leren we de basisconcepten van blockchain-technologie. We zullen ook een basistoepassing in Java implementeren die zich richt op de concepten.

Verder bespreken we enkele geavanceerde concepten en praktische toepassingen van deze technologie.

2. Wat is blockchain?

Laten we dus eerst begrijpen wat blockchain precies is ...

Welnu, het vindt zijn oorsprong terug in de whitepaper die in 2008 door Satoshi Nakamoto over Bitcoin werd gepubliceerd.

Blockchain is een gedecentraliseerd grootboek van informatie. Het bestaat uit gegevensblokken die door middel van cryptografie met elkaar zijn verbonden. Het maakt deel uit van een netwerk van knooppunten die zijn verbonden via het openbare netwerk. We zullen dit beter begrijpen als we later proberen een eenvoudige tutorial te bouwen.

Er zijn enkele belangrijke attributen die we moeten begrijpen, dus laten we ze doornemen:

  • Fraudebestendig: in de eerste plaats gegevens als onderdeel van een blok zijn fraudebestendig. Elk blok wordt verwezen door een cryptografische samenvatting, algemeen bekend als een hash, waardoor het blok fraudebestendig is.
  • Gedecentraliseerd: het hele blockchain is volledig gedecentraliseerd over het netwerk. Dit betekent dat er geen masterknooppunt is en dat elk knooppunt in het netwerk dezelfde kopie heeft.
  • Transparant: elk knooppunt dat deelneemt aan het netwerk valideert en voegt een nieuw blok toe aan zijn keten door middel van consensus met andere knooppunten. Daarom heeft elk knooppunt volledig zicht op de gegevens.

3. Hoe werkt Blockchain?

Laten we nu eens kijken hoe blockchain werkt.

De fundamentele eenheden van een blockchain zijn blokken. Een enkel blok kan verschillende transacties of andere waardevolle gegevens bevatten:

3.1. Mijnbouw van een blok

We vertegenwoordigen een blok met een hash-waarde. Het genereren van de hash-waarde van een blok wordt 'mining' genoemd het blok. Het delven van een blok is doorgaans rekenkundig duur om te doen, aangezien het dient als het "bewijs van werk".

De hash van een blok bestaat doorgaans uit de volgende gegevens:

  • In de eerste plaats bestaat de hash van een blok uit de transacties die erin zijn ingekapseld
  • De hash bestaat ook uit het tijdstempel van het maken van het blok
  • Het bevat ook een nonce, een willekeurig getal dat in cryptografie wordt gebruikt
  • Ten slotte bevat de hash van het huidige blok ook de hash van het vorige blok

Meerdere knooppunten in het netwerk kunnen concurreren met de mijne het blok tegelijkertijd. Afgezien van het genereren van de hash, moeten knooppunten ook verifiëren dat de transacties die in het blok worden toegevoegd, legitiem zijn. De eerste die een blok ontgint, wint de race!

3.2. Een blok toevoegen aan Blockchain

Hoewel het minen van een blok computationeel duur is, controleren of een blokkering legitiem is, is relatief veel eenvoudiger. Alle knooppunten in het netwerk nemen deel aan het verifiëren van een nieuw gedolven blok.

Dus een nieuw gedolven block wordt toegevoegd aan de blockchain op basis van de consensus van de knooppunten.

Nu zijn er verschillende consensusprotocollen beschikbaar die we kunnen gebruiken voor verificatie. De knooppunten in het netwerk gebruiken hetzelfde protocol om een ​​kwaadaardige tak van de keten te detecteren. Daarom zal een kwaadwillende tak, zelfs als deze wordt geïntroduceerd, binnenkort door de meerderheid van de knooppunten worden afgewezen.

4. Basis Blockchain in Java

Nu hebben we genoeg context om een ​​basistoepassing in Java te bouwen.

Onze simpele voorbeeld hier illustreert de basisconcepten we zagen net. Een applicatie van productiekwaliteit brengt veel overwegingen met zich mee die buiten het bestek van deze tutorial vallen. We zullen echter later enkele geavanceerde onderwerpen bespreken.

4.1. Een blok implementeren

Ten eerste moeten we een eenvoudige POJO definiëren die de gegevens voor ons blok zal bevatten:

openbare klasse Block {private String-hash; private String previousHash; privé String-gegevens; privé lange tijdstempel; privé int nonce; public Block (String data, String previousHash, long timeStamp) {this.data = data; this.previousHash = previousHash; this.timeStamp = timeStamp; this.hash = berekenBlockHash (); } // standaard getters en setters}

Laten we begrijpen wat we hier hebben ingepakt:

  • Hash van het vorige blok, een belangrijk onderdeel om de ketting op te bouwen
  • De feitelijke gegevens, alle informatie die waarde heeft, zoals een contract
  • Het tijdstempel van het maken van dit blok
  • Een nonce, een willekeurig getal dat in cryptografie wordt gebruikt
  • Ten slotte de hash van dit blok, berekend op basis van andere gegevens

4.2. Berekenen van de hash

Nu, hoe berekenen we de hash van een blok? We hebben een methode gebruikt berekenenBlockHash maar heb nog geen implementatie gezien. Voordat we deze methode implementeren, is het de moeite waard om wat tijd te besteden om te begrijpen wat een hash precies is.

Een hash is een uitvoer van iets dat bekend staat als een hash-functie. EEN hash-functie wijst invoergegevens van willekeurige grootte toe aan uitvoergegevens van vaste grootte. De hash is vrij gevoelig voor elke verandering in de invoergegevens, hoe klein die ook mag zijn.

Bovendien is het onmogelijk om de invoergegevens alleen uit de hash terug te krijgen. Deze eigenschappen maken de hash-functie erg handig bij cryptografie.

Laten we dus eens kijken hoe we de hash van ons blok in Java kunnen genereren:

openbare String berekenBlockHash () {String dataToHash = previousHash + Long.toString (timeStamp) + Integer.toString (nonce) + data; MessageDigest digest = null; byte [] bytes = null; probeer {digest = MessageDigest.getInstance ("SHA-256"); bytes = digest.digest (dataToHash.getBytes (UTF_8)); } catch (NoSuchAlgorithmException | UnsupportedEncodingException ex) {logger.log (Level.SEVERE, ex.getMessage ()); } StringBuffer buffer = nieuwe StringBuffer (); voor (byte b: bytes) {buffer.append (String.format ("% 02x", b)); } return buffer.toString (); }

Er gebeuren hier nogal wat dingen, laten we ze in detail begrijpen:

  • Eerst voegen we verschillende delen van het blok samen om een ​​hash te genereren
  • Vervolgens krijgen we een instantie van de SHA-256-hashfunctie van MessageDigest
  • Vervolgens genereren we de hash-waarde van onze invoergegevens, wat een byte-array is
  • Ten slotte transformeren we de byte-array in een hexadecimale reeks, een hash wordt meestal weergegeven als een 32-cijferig hexadecimaal getal

4.3. Hebben we het blok al gewonnen?

Alles klinkt tot nu toe eenvoudig en elegant, behalve het feit dat we het blok nog niet hebben gedolven. Dus wat houdt precies het minen van een blok in, dat al een tijdje in de smaak valt van ontwikkelaars!

Goed, het minen van een blok betekent het oplossen van een rekenkundig complexe taak voor het blok. Hoewel het berekenen van de hash van een blok enigszins triviaal is, is het vinden van de hash die begint met vijf nullen dat niet. Nog ingewikkelder zou zijn om een ​​hash te vinden die begint met tien nullen, en we krijgen een algemeen idee.

Dus, hoe kunnen we dit precies doen? Eerlijk gezegd is de oplossing veel minder luxe! Het is met brute kracht dat we proberen dit doel te bereiken. We maken hier gebruik van nonce:

public String mineBlock (int prefix) {String prefixString = new String (new char [prefix]). replace ('\ 0', '0'); while (! hash.substring (0, prefix) .equals (prefixString)) {nonce ++; hash = berekenBlockHash (); } retourneer hash; }

Laten we eens kijken wat we hier proberen te doen, zijn:

  • We beginnen met het definiëren van het voorvoegsel dat we willen vinden
  • Vervolgens kijken we of we de oplossing hebben gevonden
  • Zo niet, dan verhogen we de nonce en berekenen we de hash in een lus
  • De lus gaat door totdat we de jackpot winnen

We beginnen hier met de standaardwaarde nonce en verhogen deze met één. Maar er zijn er meer geavanceerde strategieën om een ​​nonce te starten en te verhogen in real-world applicaties. We verifiëren onze gegevens hier ook niet, wat doorgaans een belangrijk onderdeel is.

4.4. Laten we het voorbeeld nemen

Nu we ons blok hebben gedefinieerd samen met zijn functies, kunnen we dit gebruiken om een ​​eenvoudige blockchain te maken. We slaan dit op in een ArrayList:

Lijst blockchain = nieuwe ArrayList (); int prefix = 4; String prefixString = nieuwe String (nieuwe char [prefix]). Replace ('\ 0', '0');

Bovendien hebben we een voorvoegsel van vier gedefinieerd, wat in feite betekent dat we willen dat onze hash begint met vier nullen.

Laten we eens kijken hoe we hier een blok kunnen toevoegen:

@Test openbare ongeldige gegevenBlockchain_whenNewBlockAdded_thenSuccess () {Block newBlock = nieuw blok ("Het is een nieuw blok.", Blockchain.get (blockchain.size () - 1) .getHash (), nieuwe datum (). GetTime ()); newBlock.mineBlock (voorvoegsel); assertTrue (newBlock.getHash (). substring (0, prefix) .equals (prefixString)); blockchain.add (newBlock); }

4.5. Blockchain-verificatie

Hoe kan een knooppunt valideren dat een blockchain geldig is? Hoewel dit behoorlijk ingewikkeld kan zijn, laten we eens nadenken over een eenvoudige versie:

@Test openbare ongeldige gegevenBlockchain_whenValidated_thenSuccess () {booleaanse vlag = waar; for (int i = 0; i <blockchain.size (); i ++) {String previousHash = i == 0? "0": blockchain.get (i - 1) .getHash (); vlag = blockchain.get (i) .getHash (). is gelijk aan (blockchain.get (i) .calculateBlockHash ()) && previousHash.equals (blockchain.get (i) .getPreviousHash ()) && blockchain.get (i). getHash (). substring (0, prefix) .equals (prefixString); if (! vlag) breken; } assertTrue (vlag); }

Dus hier voeren we drie specifieke controles uit voor elk blok:

  • De opgeslagen hash van het huidige blok is eigenlijk wat het berekent
  • De hash van het vorige blok dat in het huidige blok is opgeslagen, is de hash van het vorige blok
  • Het huidige blok is gedolven

5. Enkele geavanceerde concepten

Hoewel ons basisvoorbeeld de basisconcepten van een blockchain naar voren brengt, is het zeker niet compleet. Om deze technologie praktisch in gebruik te kunnen nemen, moet met een aantal andere overwegingen rekening worden gehouden.

Hoewel het niet mogelijk is om ze allemaal in detail te beschrijven, laten we enkele van de belangrijkste doornemen:

5.1. Transactieverificatie

Het berekenen van de hash van een blok en het vinden van de gewenste hash is slechts een onderdeel van mijnbouw. Een blok bestaat uit data, vaak in de vorm van meerdere transacties. Deze moeten worden geverifieerd voordat ze deel kunnen uitmaken van een blok en gedolven kunnen worden.

Een typische implementatie van blockchain stelt een beperking in voor hoeveel gegevens deel kunnen uitmaken van een blok. Het ook stelt regels op over hoe een transactie kan worden geverifieerd. Meerdere knooppunten in het netwerk nemen deel aan het verificatieproces.

5.2. Alternatief consensusprotocol

We zagen dat een consensusalgoritme zoals "Proof of Work" wordt gebruikt om een ​​blok te minen en te valideren. Dit is echter niet het enige consensusalgoritme dat beschikbaar is voor gebruik.

Er zijn verschillende andere consensusalgoritmen om uit te kiezen, zoals Proof of Stake, Proof of Authority en Proof of Weight. Deze hebben allemaal hun voor- en nadelen. Welke u moet gebruiken, hangt af van het type toepassing dat we willen ontwerpen.

5.3. Mijnbouwbeloning

Een blockchain-netwerk bestaat doorgaans uit vrijwillige knooppunten. Waarom zou iemand willen bijdragen aan dit complexe proces en het legitiem en groeiend willen houden?

Dit is zo omdat knooppunten worden beloond voor het verifiëren van de transacties en het minen van een blok. Deze beloningen zijn meestal in de vorm van munten die bij de aanvraag horen. Maar een applicatie kan besluiten dat de beloning iets waardevols is.

5.4. Knooppunttypen

Een blockchain is volledig afhankelijk van zijn netwerk om te functioneren. In theorie is het netwerk volledig gedecentraliseerd en is elk knooppunt gelijk. In de praktijk bestaat een netwerk echter uit meerdere soorten knooppunten.

Terwijl een volledig knooppunt heeft een volledige lijst met transacties, een lichtknooppunt heeft alleen een gedeeltelijke lijst. Bovendien nemen niet alle knooppunten deel aan verificatie en validatie.

5.5. Veilige communicatie

Een van de kenmerken van blockchain-technologie is de openheid en anonimiteit. Maar hoe biedt het beveiliging voor transacties die binnen worden uitgevoerd? Dit is gebaseerd op cryptografie en openbare sleutelinfrastructuur.

De initiator van een transactie gebruikt zijn privésleutel om deze te beveiligen en te koppelen aan de openbare sleutel van de ontvanger. Nodes kunnen de openbare sleutels van de deelnemers gebruiken om transacties te verifiëren.

6. Praktische toepassingen van Blockchain

Blockchain lijkt dus een opwindende technologie, maar het moet ook nuttig blijken te zijn. Deze technologie bestaat al een tijdje en is - uiteraard - op veel terreinen disruptief gebleken.

De toepassing ervan op veel andere gebieden wordt actief nagestreefd. Laten we de meest populaire applicaties begrijpen:

  • Valuta: Dit is verreweg het oudste en meest bekende gebruik van blockchain, dankzij het succes van Bitcoin. Ze bieden veilig en probleemloos geld aan mensen over de hele wereld zonder enige centrale autoriteit of tussenkomst van de overheid.
  • Identiteit: Digitale identiteit is hard op weg de norm te worden in de huidige wereld. Dit wordt echter verziekt door beveiligingsproblemen en geknoei. Blockchain is onvermijdelijk om een ​​revolutie teweeg te brengen in dit gebied met volledig veilige en fraudebestendige identiteiten.
  • Gezondheidszorg: De zorgsector zit vol met gegevens, meestal afgehandeld door centrale autoriteiten. Dit vermindert de transparantie, veiligheid en efficiëntie bij het omgaan met dergelijke gegevens. Blockchain-technologie kan een systeem bieden zonder dat een derde partij het broodnodige vertrouwen biedt.
  • Regering: Dit is misschien een gebied dat goed openstaat voor verstoring door de blockchain-technologie. De overheid staat typisch centraal in verschillende burgerdiensten, die vaak beladen zijn met inefficiëntie en corruptie. Blockchain kan helpen om veel betere relaties tussen overheid en burger tot stand te brengen.

7. Gereedschap van het vak

Hoewel onze basisimplementatie hier nuttig is om de concepten te ontlokken, is het niet praktisch om vanaf nul een product op blockchain te ontwikkelen. Gelukkig is deze ruimte nu volwassener geworden en hebben we een aantal behoorlijk nuttige hulpmiddelen om mee te beginnen.

Laten we enkele van de populaire tools bekijken om binnen deze ruimte te werken:

  • Soliditeit: Soliditeit is een statisch getypeerde en objectgeoriënteerde programmeertaal ontworpen voor het schrijven van slimme contracten. Het kan worden gebruikt om slimme contracten te schrijven op verschillende blockchain-platforms zoals Ethereum.
  • Remix IDE: Remix is ​​een krachtig open-source tool om slimme contracten te schrijven in soliditeit. Hierdoor kan de gebruiker rechtstreeks vanuit de browser slimme contracten schrijven.
  • Truffle Suite: Truffle biedt een heleboel tools om een ​​ontwikkelaar op weg te helpen bij het ontwikkelen van gedistribueerde apps. Dit omvat truffel, ganache en motregen.
  • Ethlint / Solium: Met Solium kunnen ontwikkelaars ervoor zorgen dat hun slimme contracten geschreven op Solidity zijn vrij van stijl- en beveiligingskwesties. Solium helpt ook bij het oplossen van deze problemen.
  • Pariteit: Pariteit helpt het opzetten van de ontwikkelomgeving voor smart contract op Etherium. Het biedt een snelle en veilige manier om met de blockchain te communiceren.

8. Conclusie

Samenvattend hebben we in deze tutorial de basisconcepten van blockchain-technologie doorgenomen. We begrepen hoe een netwerk mijnen en voeg een nieuw blok toe in de blockchain. Verder hebben we de basisconcepten in Java geïmplementeerd. We hebben ook enkele van de geavanceerde concepten met betrekking tot deze technologie besproken.

Ten slotte hebben we enkele praktische toepassingen van blockchain en beschikbare tools afgerond.

Zoals altijd is de code te vinden op GitHub.


$config[zx-auto] not found$config[zx-overlay] not found