streamalism.org

Jeg kunngjorde nettopp det nye Lær våren kurs, med fokus på det grunnleggende i vår 5 og vårstøvel 2:

1. Introduksjon

Denne opplæringen introduserer Web3j, en Java-implementering av det populære Web3-abstraksjonsbiblioteket.

Web3j brukes til å samhandle med Ethereum-nettverket ved å koble til Ethereum-noder ved hjelp av JSON-RPC eller kjente standarder som HTTP, WebSockets, IPC.

Ethereum er et helt tema for seg selv, så la oss først se raskt på hva det er!

2. Ethereum

Ethereum er en (1) kryptovaluta (symbol symbol ETH), (2) distribuert superdatamaskin, (3) blockchain og (4) smart kontrakt nettverk skrevet i Tørrhet.

Med andre ord, Ethereum (the Nettverk) drives av en haug med tilkoblede servere noder som kommuniserer i en slags masketopologi (teknisk sett er dette ikke akkurat sant, men nær nok til å få en mer solid forståelse av hvordan det hele fungerer).

Web3j, og dets overordnede bibliotek Web3, tillater webapplikasjoner å koble til en av dem noder og dermed sende Ethereum transaksjoner, som for all del er samlet Solidity smart kontraktfunksjoner som tidligere har blitt distribuert til Ethereum Nettverk. For mer informasjon om smarte kontrakter, se vår artikkel om å opprette og distribuere dem med Solidity her.

Hver node sender sine endringer til hverandre node slik at konsensus og bekreftelse kan oppnås. Og dermed, Hver node inneholder hele historien til Ethereum blockchain samtidig derved skape en overflødig sikkerhetskopi av alle dataene, på en manipulasjonssikker måte, og via konsensus og verifisering av alle de andre node i Nettverk.\

For mer detaljert informasjon om Ethereum, sjekk ut den offisielle siden.

3. Sett opp

For å bruke den komplette pakke med funksjoner som tilbys av Web3j, må vi gjøre litt mer for å bli satt opp enn vanlig. For det første leveres Web3j i flere frittstående moduler som hver kan valgfritt legges til kjernen pom.xml avhengighet:

 org.web3j kjerne 3.3.1 

Vær oppmerksom på at teamet på Web3j tilbyr en forhåndsbygd Spring Boot Starter med litt konfigurasjon og begrenset funksjonalitet innebygd rett i!

Vi vil begrense vårt fokus til kjernefunksjonalitetene i denne artikkelen (inkludert hvordan du legger til Web3j i et Spring MVC-program, slik at du får kompatibilitet med et bredere utvalg av Spring webapps).

En full liste over disse modulene finner du på Maven Central.

3.1. Kompilering av kontrakter: Truffle eller Solc

Det er to primære måter å kompilere og distribuere smarte Ethereum-kontrakter på (.solc filer):

1. Den offisielle Solidity kompilatoren.
2. Truffle (en abstraksjonssuite for testing, distribusjon og administrering av smarte kontrakter).

Vi vil holde oss til Truffle i denne artikkelen. Truffle forenkler og abstraherer prosessen med å lage smarte kontrakter, migrere dem, og distribuere dem til et nettverk. Den pakker også inn Solc kompilator som lar oss få litt erfaring med begge deler.

Slik setter du opp trøffel:

$ npm install trøffel -g $ trøffelversjon

Fire viktige kommandoer vi vil bruke til å initialisere henholdsvis prosjektet vårt, kompilere appen vår, distribuere appen vår til Blockchain og teste den henholdsvis:

$ trøffel init $ trøffel kompilere $ trøffel migrere $ trøffel test

La oss nå gå gjennom et enkelt eksempel:

pragma soliditet ^ 0.4.17; kontrakteksempel {funksjonseksempel () {// constructor}} 

Hvilket skal gi følgende ABI JSON når det kompileres:

{"contractName": "Eksempel", "abi": [{"inputs": [], "payable": false, "stateMutability": "nonpayable", "type": "constructor"}], "bytecode": "0x60606040523415600e57600080fd5b603580601b6 ...," deployedBytecode ":" 0x6060604052600080fd00a165627a7a72305 ..., // ...}

Vi kan da bruke den medfølgende bytecode og ABI i applikasjonen vår til å samhandle med de distribuerte kontraktene!

3.2. Testkontrakter: Ganache

En av de enkleste måtene å jobbe med et Ethereum testnet er å starte egen Ganache-server. Vi bruker den forhåndsbygde, out-of-the-box løsningen, siden det er enklest å sette opp og konfigurere. Det gir også et grensesnitt og serverskall for Ganache CLI som driver Ganache under panseret.

Vi kan koble til Ganache-serveren vår på den angitte URL-adressen: // localhost: 8545 eller // localhost: 7545.

Det er et par andre populære tilnærminger for å sette opp et testnettverk, inkludert bruk av Meta-Mask, Infura eller Go-Lang og Geth.

Vi vil holde oss til Ganache i denne artikkelen, siden det kan være ganske vanskelig å konfigurere din egen GoLang-forekomst (og konfigurere den som et tilpasset testnett), og siden statusen til Meta-Mask på Chrome for tiden er usikker.

Vi kan bruke Ganache til manuelle testscenarier (når vi feilsøker eller fullfører integrasjonstestingen vår) eller bruke dem til automatiserte testscenarier (som vi må bygge testene våre på, fordi vi under slike omstendigheter kanskje ikke har de tilgjengelige sluttpunktene).

4. Web3 og RPC

Web3 gir en fasade og grensesnitt for enkel interaksjon med Ethereum blockchain og Ethereum servernoder. Med andre ord, Web3 muliggjør interkommunikasjon mellom klienter og Ethereum Blockchain ved hjelp av JSON-RPC. Web3J er den offisielle Java-porten til Web3.

Vi kan initialisere Web3j for bruk i applikasjonen vår ved å sende inn en leverandør (f.eks. Sluttpunktet til en tredjepart eller lokal Ethereum-node):

Web3j web3a = Web3j.build (ny HttpService ()); Web3j web3b = Web3j.build (ny HttpService ("YOUR_PROVIDER_HERE")); Web3j myEtherWallet = Web3j.build (ny HttpService ("// api.myetherapi.com/eth"));

Det tredje alternativet viser hvordan du legger til en tredjepartsleverandør (og dermed kobler til Ethereum-noden). Men vi har også muligheten til å la leverandøralternativet være tomt. I så fall vil standardporten brukes (8545) på lokal vert i stedet.

5. Viktige Web3-metoder

Nå som vi vet hvordan vi kan initialisere appen vår for å kommunisere med Ethereum blockchain, la oss se på noen få, kjernemåter å samhandle med Ethereum blockchain.

Det er en god policy å pakke Web3-metodene dine med en Fullførbar fremtid for å håndtere den asynkrone naturen til JSON-RPC-forespørsler som er gjort til din konfigurerte Ethereum-node.

5.1. Gjeldende blokkeringsnummer

Vi kan for eksempel returner gjeldende blokknummer:

offentlig EthBlockNumber getBlockNumber () {EthBlockNumber resultat = nytt EthBlockNumber (); resultat = this.web3j.ethBlockNumber () .sendAsync () .get (); returresultat; }

5.2. Regnskap

For å få konto for en spesifisert adresse:

offentlige EthAccounts getEthAccounts () {EthAccounts resultat = nye EthAccounts (); resultat = this.web3j.ethAccounts () .sendAsync () .get (); returresultat; }

5.3. Antall kontotransaksjoner

For å få antall transaksjoner av en gitt adresse:

public EthGetTransactionCount getTransactionCount () {EthGetTransactionCount result = new EthGetTransactionCount (); resultat = this.web3j.ethGetTransactionCount (DEFAULT_ADDRESS, DefaultBlockParameter.valueOf ("siste")) .sendAsync () .get (); returresultat; }

5.4. Saldo

Og til slutt, for å få gjeldende saldo på en adresse eller lommebok:

public EthGetBalance getEthBalance () {EthGetBalance result = new EthGetBalance (); this.web3j.ethGetBalance (DEFAULT_ADDRESS, DefaultBlockParameter.valueOf ("siste")) .sendAsync () .get (); returresultat; }

6. Arbeide med kontrakter i Web3j

Når vi har utarbeidet Solidity-kontrakten vår ved hjelp av Truffle, kan vi jobbe med vår utarbeidet Søknads binære grensesnitt (ABI) ved hjelp av det frittstående Web3j-kommandolinjeverktøyet som er tilgjengelig her eller som en frittstående zip her.

6.1. CLI Magic

Vi kan da automatisk generere Java Smart Contract Wrappers (egentlig en POJO som eksponerer den smarte kontrakten ABI) ved hjelp av følgende kommando:

$ web3j trøffel genererer [--javaTypes | --solidityTypes] /path/to/.json -o / path / to / src / main / java -p com.your.organisation.name

Kjører følgende kommando i roten til prosjektet:

web3j trøffel genererer dev_truffle / build / kontrakter / Eksempel.json -o src / main / java / com / baeldung / web3 / contract -p com.baeldung

genererte vår Eksempel klasse:

offentlig klasse Eksempel utvider Kontrakt {privat statisk slutt String BINARY = "0x60606040523415600e576 ..."; // ...}

6.2. Java POJO-er

Nå som vi har vår Smart Contract Wrapper, vi kan lage en lommebok programmatisk og deretter distribuere kontrakten til den adressen:

WalletUtils.generateNewWalletFile ("PASSWORD", ny fil ("/ path / to / destination"), true);

Legitimasjonsopplysninger = WalletUtils.loadCredentials ("PASSWORD", "/ path / to / walletfile");

6.3. Distribuere en kontrakt

Vi kan distribuere kontrakten vår slik:

Eksempel på kontrakt = eksempel.deploy (this.web3j, legitimasjon, ManagedTransaction.GAS_PRICE, Contract.GAS_LIMIT) .send (); 

Og så få adressen:

contractAddress = contract.getContractAddress ();

6.4. Sende transaksjoner

Å sende en Transaksjon bruker Funksjoner av vår Kontrakt vi kan initialisere en Web3j Funksjon med en Liste av inngangsverdier og a Liste av utgangsparametere:

Liste inputParams = ny ArrayList (); Liste outputParams = ny ArrayList (); Funksjonsfunksjon = ny funksjon ("fuksjonsnavn", inputParams, outputParams); Streng kodetFunksjon = FunctionEncoder.encode (funksjon); 

Vi kan deretter initialisere Transaksjon med nødvendig gass (brukes til å utføre Transaksjon) og nonce-parametere:

BigInteger nonce = BigInteger.valueOf (100); BigInteger gasprice = BigInteger.valueOf (100); BigInteger gaslimit = BigInteger.valueOf (100); Transaksjonstransaksjon = Transaksjon .createFunctionCallTransaction ("FROM_ADDRESS", nonce, gasprice, gaslimit, "TO_ADDRESS", encodedFunction); EthSendTransaction transactionResponse = web3j.ethSendTransaction (transaksjon) .sendAsync (). Get (); transactionHash = transactionResponse.getTransactionHash (); 

For en fullstendig liste over smarte kontraktsfunksjoner, se de offisielle dokumentene.

7. Konklusjon

Det er det! Vi har satt opp en Java Spring MVC-app med Web3j - det er Blockchain-tid!

Som alltid er kodeeksemplene som brukes i denne artikkelen tilgjengelig på GitHub.

Jeg kunngjorde nettopp det nye Lær våren kurs, med fokus på det grunnleggende i vår 5 og vårstøvel 2: