streamalism.org

1. Oversikt

Stripe er en skybasert tjeneste som gjør det mulig for bedrifter og enkeltpersoner å motta betalinger over internett og tilbyr både klientside-biblioteker (JavaScript og native mobile) og server-side-biblioteker (Java, Ruby, Node.js, etc.).

Stripe gir et abstraksjonslag som reduserer kompleksiteten ved å motta betalinger. Som et resultat, vi trenger ikke å håndtere kredittkortopplysninger direkte - i stedet håndterer vi et token som symboliserer en autorisasjon til å belaste.

I denne opplæringen vil vi lage et eksempel på Spring Boot-prosjekt som lar brukerne legge inn et kredittkort og senere belaste kortet for et visst beløp ved hjelp av Stripe API for Java.

2. Avhengigheter

For å gjøre bruk av Stripe API for Java i prosjektet, legger vi til den tilsvarende avhengigheten til vår pom.xml:

 com.stripe stripe-java 4.2.0 

Vi finner den nyeste versjonen i Maven Central repository.

For vårt prøveprosjekt vil vi utnytte spring-boot-starter-parent:

 org.springframework.boot spring-boot-starter-parent 2.2.6.RELEASE 

Vi vil også bruke Lombok for å redusere kjeleplatekoden, og Thymeleaf vil være malmotoren for levering av dynamiske websider.

Siden vi bruker spring-boot-starter-parent for å administrere versjonene av disse bibliotekene, trenger vi ikke å inkludere versjonene i pom.xml:

 org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-thymeleaf org.projectlombok lombok 

Noter det hvis du bruker NetBeans, kan det være lurt å bruke Lombok eksplisitt med versjon 1.16.16, siden en feil i versjonen av Lombok levert med Spring Boot 1.5.2, får NetBeans til å generere mange feil.

3. API-nøkler

Før vi kan kommunisere med Stripe og utføre kredittkortgebyrer, må vi registrer en Stripe-konto og skaff hemmelige / offentlige Stripe API-nøkler.

Etter å ha bekreftet kontoen, vil vi logge på for å få tilgang til Stripe-dashbordet. Vi velger deretter “API-nøkler” på menyen til venstre:

Det vil være to par hemmelige / offentlige nøkler - en for test og en for live. La oss la denne fanen være åpen slik at vi kan bruke disse tastene senere.

4. Generell flyt

Belastningen av kredittkortet vil bli gjort i fem enkle trinn, som involverer frontend (kjøres i en nettleser), back-end (vår Spring Boot-applikasjon) og Stripe:

1. En bruker går til kassen og klikker på "Betal med kort".
2. En bruker blir presentert med dialogboksen Stripe Checkout, der den fyller kredittkortopplysningene.
3. En bruker bekrefter med “Betal” som vil:
   • Send kredittkortet til Stripe
   • Få et token i svaret som blir lagt til det eksisterende skjemaet
   • Send inn skjemaet med beløpet, den offentlige API-nøkkelen, e-postadressen og tokenet til vår back-end
4. Våre back-end-kontakter Stripe med token, mengden og den hemmelige API-nøkkelen.
5. Back-end sjekker Stripe respons og gi brukeren tilbakemelding om operasjonen.

Vi vil dekke hvert trinn mer detaljert i de følgende avsnittene.

5. Utskriftsskjema

Stripe Checkout er en tilpassbar, mobil klar og lokaliserbar widget som gjengir et skjema for å introdusere kredittkortdetaljer. Gjennom inkludering og konfigurering av “checkout.js“, Det er ansvarlig for:

• Gjengivelse av knappen "Betal med kort"

  

• Gjengivelse av betalingsoverleggsdialog (utløst etter å ha klikket på "Betal med kort")

  

• Validering av kredittkort
• "Husk meg" -funksjonen (knytter kortet til et mobilnummer)
• Sende kredittkortet til Stripe og erstatte det med et token i vedlagte skjema (utløst etter å ha klikket "Betal")

Hvis vi trenger å utøve mer kontroll over utsjekkingsskjemaet enn det som er gitt av Stripe Checkout, kan vi bruke Stripe Elements.

Deretter vil vi analysere kontrolleren som forbereder skjemaet og deretter selve skjemaet.

5.1. Kontroller

La oss starte med å lage en kontroller til utarbeide modellen med nødvendig informasjon som kassen trenger.

Først må vi kopier testversjonen av den offentlige nøkkelen fra Stripe-dashbordet og bruk den til å definere STRIPE_PUBLIC_KEY som en miljøvariabel. Vi bruker deretter denne verdien i stripePublicKey felt.

Vi setter også inn valuta og beløp (uttrykt i cent) manuelt her bare for demonstrasjonsformål, men i en reell applikasjon kan vi angi et produkt / salgs-ID som kan brukes til å hente de faktiske verdiene.

Deretter sender vi til kassevisningen som inneholder kassaskjemaet:

@Controller offentlig klasse CheckoutController {@Value ("$ {STRIPE_PUBLIC_KEY}") privat streng stripePublicKey; @RequestMapping ("/ checkout") offentlig strengkasse (modellmodell) {model.addAttribute ("beløp", 50 * 100); // in cents model.addAttribute ("stripePublicKey", stripePublicKey); model.addAttribute ("valuta", ChargeRequest.Currency.EUR); returner "kassa"; }}

Når det gjelder Stripe API-nøklene, kan du definere dem som miljøvariabler per applikasjon (test vs. live).

Som det er tilfelle med passord eller sensitiv informasjon, er det best å holde den hemmelige nøkkelen utenfor versjonskontrollsystemet.

5.2. Skjema

Knappen "Betal med kort" og utsjekkingsdialogen inngår ved å legge til et skjema med et skript inni, riktig konfigurert med dataattributter:

  Pris: 

“checkout.js”Skript utløser automatisk en forespørsel om Stripe rett før innsending, som deretter legger til Stripe-token og Stripe-brukerens e-post som de skjulte feltene“stripeToken”Og”stripeE-post“.

Disse vil bli sendt til vår back-end sammen med de andre skjemafeltene. Skriptdataattributtene sendes ikke inn.

Vi bruker Thymeleaf for å gjengi attributtene “datanøkkel“, “datamengde“, Og“data-valuta“.

Mengden ("datamengde“) Brukes kun til visningsformål (sammen med“data-valuta“). Enheten er cent av den brukte valutaen, så vi deler den med 100 for å vise den.

Stripes offentlige nøkkel blir sendt til Stripe etter at brukeren ber om å betale. Ikke bruk den hemmelige nøkkelen her, da denne sendes til nettleseren.

6. Ladeoperasjon

For behandling på serversiden, må vi definere POST-forespørselsbehandleren som brukes av kassen. La oss ta en titt på klassene vi trenger for ladeoperasjonen.

6.1. ChargeRequest Entity

La oss definere ChargeRequest POJO som vi vil bruke som en forretningsenhet under belastningsoperasjonen:

@Data public class ChargeRequest {public enum Currency {EUR, USD; } privat strengbeskrivelse; privat int beløp; privat valuta; privat streng stripeE-post; private String stripeToken; }

6.2. Service

La oss skrive en StripeService klasse til kommunisere den faktiske ladningsoperasjonen til Stripe:

@Service offentlig klasse StripeService {@Value ("$ {STRIPE_SECRET_KEY}") privat streng secretKey; @PostConstruct public void init () {Stripe.apiKey = secretKey; } public Charge charge (ChargeRequest chargeRequest) kaster AuthenticationException, InvalidRequestException, APIConnectionException, CardException, APIException {Map chargeParams = new HashMap (); chargeParams.put ("beløp", chargeRequest.getAmount ()); chargeParams.put ("valuta", chargeRequest.getCurrency ()); chargeParams.put ("beskrivelse", chargeRequest.getDescription ()); chargeParams.put ("kilde", chargeRequest.getStripeToken ()); retur Charge.create (chargeParams); }}

Som det ble vist i CheckoutController, de secretKey feltet er fylt ut fra miljøvariabelen STRIPE_SECRET_KEY som vi kopierte fra Stripe-dashbordet.

Når tjenesten er initialisert, brukes denne nøkkelen i alle påfølgende stripeoperasjoner.

Objektet som returneres av Stripe-biblioteket representerer ladeoperasjonen og inneholder nyttige data som operasjons-ID.

6.3. Kontroller

Til slutt, la oss skrive kontroller som vil motta POST-forespørselen fra utsjekkingsskjemaet og sende kostnaden til Stripe via vår StripeService.

Merk at “ChargeRequest”-Parameteren initialiseres automatisk med forespørselsparametrene“beløp“, “stripeE-post“, Og“stripeToken”Inkludert i skjemaet:

@Controller offentlig klasse ChargeController {@Autowired private StripeService paymentsService; @PostMapping ("/ charge") offentlig strenggebyr (ChargeRequest chargeRequest, modellmodell) kaster StripeException {chargeRequest.setDescription ("Eksempel på avgift"); chargeRequest.setCurrency (Currency.EUR); Charge charge = paymentsService.charge (chargeRequest); model.addAttribute ("id", charge.getId ()); model.addAttribute ("status", charge.getStatus ()); model.addAttribute ("chargeId", charge.getId ()); model.addAttribute ("balance_transaction", charge.getBalanceTransaction ()); returner "resultat"; } @ExceptionHandler (StripeException.class) public String handleError (Model model, StripeException ex) {model.addAttribute ("error", ex.getMessage ()); returner "resultat"; }}

Når vi lykkes, legger vi til status, operasjons-ID, ladnings-ID og saldo-transaksjon-ID til modellen slik at vi senere kan vise dem til brukeren (seksjon 7). Dette gjøres for å illustrere noe av innholdet i ladeobjektet.

Våre ExceptionHandler vil håndtere unntak av typen StripeException som kastes under ladingen.

Hvis vi trenger mer finkornet feilhåndtering, kan vi legge til separate håndterere for underklassene til StripeException, som for eksempel CardException, RateLimitException, eller AuthenticationException.

“resultat”-Visningen gjengir resultatet av ladeoperasjonen.

7. Viser resultatet

HTML-en som brukes til å vise resultatet, er en grunnleggende Thymeleaf-mal som viser resultatet av en ladeoperasjon. Brukeren sendes hit av ChargeController om ladningen var vellykket eller ikke:

   Resultat 
Suksess!
 Id .: Status: Charge id .: Balance transaction id .: Checkout again 

Når det lykkes, vil brukeren se noen detaljer om ladningsoperasjonen:

Ved feil, vil brukeren bli presentert for feilmeldingen som returneres av Stripe:

8. Konklusjon

I denne opplæringen har vi vist hvordan du bruker Stripe Java API for å belaste et kredittkort. I fremtiden kan vi bruke koden på serversiden vår til å betjene en innfødt mobilapp.

For å teste hele ladestrømmen trenger vi ikke bruke et ekte kredittkort (selv i testmodus). Vi kan stole på Stripe-testkort i stedet.

Ladningsoperasjonen er en av mange muligheter som Stripe Java API tilbyr. Den offisielle API-referansen vil lede oss gjennom hele operasjonssettet.

Eksempelkoden som brukes i denne opplæringen, finner du i GitHub-prosjektet.