import com.stripe.net.RequestOptions; //导入依赖的package包/类
public void makeCharge2() {
    // see:
    // https://github.com/stripe/stripe-java#usage
    RequestOptions requestOptions = (new RequestOptions.RequestOptionsBuilder())
            .setApiKey("YOUR-SECRET-KEY").build();

    Map<String, Object> chargeMap = new HashMap<String, Object>();
    chargeMap.put("amount", 100);
    chargeMap.put("currency", "usd");

    Map<String, Object> cardMap = new HashMap<String, Object>();
    cardMap.put("number", "4242424242424242");
    cardMap.put("exp_month", 12);
    cardMap.put("exp_year", 2020);

    chargeMap.put("card", cardMap);

    try {
        Charge charge = Charge.create(chargeMap, requestOptions);

        System.out.println(charge);
    } catch (StripeException e) {
        e.printStackTrace();
    }
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
@Override
public void pay(final long cents, final String token, final String email)
    throws IOException {
    final String customer;
    try {
        customer = Customer.create(
            new StickyMap<String, Object>(
                new MapEntry<>("email", email),
                new MapEntry<>("source", token)
            ),
            new RequestOptions.RequestOptionsBuilder().setApiKey(
                Manifests.read("ThreeCopies-StripeSecret")
            ).build()
        ).getId();
    } catch (final APIException | APIConnectionException
        | AuthenticationException | CardException
        | InvalidRequestException ex) {
        throw new IOException(ex);
    }
    this.item().put(
        new AttributeUpdates()
            .with(
                "stripe_cents",
                new AttributeValueUpdate().withValue(
                    new AttributeValue().withN(Long.toString(cents))
                ).withAction(AttributeAction.PUT)
            )
            .with(
                "stripe_customer",
                new AttributeValueUpdate().withValue(
                    new AttributeValue().withS(customer)
                ).withAction(AttributeAction.PUT)
            )
    );
    this.rebill();
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
/**
 * Charge him again.
 * @throws IOException If fails
 */
private void rebill() throws IOException {
    final Item item = this.item();
    final Long cents = Long.parseLong(item.get("stripe_cents").getN());
    final String customer = item.get("stripe_customer").getS();
    try {
        Charge.create(
            new StickyMap<String, Object>(
                new MapEntry<>("amount", cents),
                new MapEntry<>("currency", "usd"),
                new MapEntry<>(
                    "description",
                    String.format("ThreeCopies: %s", this.name)
                ),
                new MapEntry<>("customer", customer)
            ),
            new RequestOptions.RequestOptionsBuilder().setApiKey(
                Manifests.read("ThreeCopies-StripeSecret")
            ).build()
        );
    } catch (final APIException | APIConnectionException
        | AuthenticationException | CardException
        | InvalidRequestException ex) {
        throw new IOException(ex);
    }
    this.item().put(
        "paid",
        new AttributeValueUpdate().withValue(
            new AttributeValue().withN(
                Long.toString(cents * TimeUnit.HOURS.toSeconds(1L))
            )
        ).withAction(AttributeAction.ADD)
    );
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
/**
 * After client side integration with stripe widget, our server receives the stripeToken
 * StripeToken is a single-use token that allows our server to actually charge the credit card and
 * get money on our account.
 * <p>
 * as documented in https://stripe.com/docs/tutorials/charges
 *
 * @return
 * @throws StripeException
 */
Charge chargeCreditCard(String stripeToken, long amountInCent, Event event,
                        String reservationId, String email, String fullName, String billingAddress) throws StripeException {

    int tickets = ticketRepository.countTicketsInReservation(reservationId);
    Map<String, Object> chargeParams = new HashMap<>();
    chargeParams.put("amount", amountInCent);
    FeeCalculator.getCalculator(event, configurationManager).apply(tickets, amountInCent).ifPresent(fee -> chargeParams.put("application_fee", fee));
    chargeParams.put("currency", event.getCurrency());
    chargeParams.put("card", stripeToken);

    chargeParams.put("description", String.format("%d ticket(s) for event %s", tickets, event.getDisplayName()));

    Map<String, String> initialMetadata = new HashMap<>();
    initialMetadata.put("reservationId", reservationId);
    initialMetadata.put("email", email);
    initialMetadata.put("fullName", fullName);
    if (StringUtils.isNotBlank(billingAddress)) {
        initialMetadata.put("billingAddress", billingAddress);
    }
    chargeParams.put("metadata", initialMetadata);
    RequestOptions options = options(event);
    Charge charge = Charge.create(chargeParams, options);
    if(charge.getBalanceTransactionObject() == null) {
        try {
            charge.setBalanceTransactionObject(retrieveBalanceTransaction(charge.getBalanceTransaction(), options));
        } catch(Exception e) {
            log.warn("can't retrieve balance transaction", e);
        }
    }
    return charge;
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
private RequestOptions options(Event event) {
    RequestOptions.RequestOptionsBuilder builder = RequestOptions.builder();
    if(isConnectEnabled(event)) {
        //connected stripe account
        builder.setStripeAccount(configurationManager.getRequiredValue(Configuration.from(event.getOrganizationId(), event.getId(), STRIPE_CONNECTED_ID)));
        return builder.setApiKey(getSystemApiKey()).build();
    }
    return builder.setApiKey(getSecretKey(event)).build();
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
Optional<PaymentInformation> getInfo(Transaction transaction, Event event) {
    try {
        RequestOptions options = options(event);
        Charge charge = Charge.retrieve(transaction.getTransactionId(), options);
        String paidAmount = MonetaryUtil.formatCents(charge.getAmount());
        String refundedAmount = MonetaryUtil.formatCents(charge.getAmountRefunded());
        List<Fee> fees = retrieveBalanceTransaction(charge.getBalanceTransaction(), options).getFeeDetails();
        return Optional.of(new PaymentInformation(paidAmount, refundedAmount, getFeeAmount(fees, "stripe_fee"), getFeeAmount(fees, "application_fee")));
    } catch (StripeException e) {
        return Optional.empty();
    }
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    /* --- request*/
    String requestDataStr = ServletUtils.getAllRequestData(request);

    String responseStr = "{\"paymentData\":" + requestDataStr + ",";

    // Get the credit card details submitted by the form
    String token = request.getParameter("stripeToken");
    @SuppressWarnings("unused")
    String cardHolderName = request.getParameter("cardHolderName");

    /* -- see example on: https://github.com/stripe/stripe-java#usage */
    //
    RequestOptions requestOptions = (new RequestOptions.RequestOptionsBuilder())
            .setApiKey(STRIPE_SECRET_KEY).build();
    //
    // -- Card options:
    // ------------ // Map<String, Object> cardMap = new HashMap<>();
    // cardMap.put("name", cardHolderName);// - "Received both card and source parameters. Please pass in only one."
    /*
    cardMap.put("number", "4242424242424242");
    cardMap.put("exp_month", 12);
    cardMap.put("exp_year", 2020);
    */

    // -- Charge options:
    Map<String, Object> chargeMap = new HashMap<>();
    chargeMap.put("amount", 100); // -- this is ONE dollar
    chargeMap.put("currency", "usd");
    // see: https://stripe.com/docs/charges (Java)
    // chargeParams.put("source", token);
    // chargeParams.put("description", "Example charge");
    chargeMap.put("source", token);
    chargeMap.put("description", "Example charge: " + token);
    //
    // ------------ // chargeMap.put("card", cardMap);
    // -- make charge:
    responseStr += "\"charge\":";
    try {
        Charge charge = Charge.create(chargeMap, requestOptions);
        // System.out.println(charge);
        responseStr += GSON.toJson(charge);
        LOG.warning(GSON.toJson(charge));
        ExternalAccount source = charge.getSource();
        LOG.warning("source: " + GSON.toJson(source));
        charge.getStatus(); // -- "succeeded"
        charge.getPaid(); // - boolean: true or false
        //
        // String customerStr = source.getCustomer();
        // LOG.warning("customerStr: " + customerStr); //
        // responseStr += "," + "\"customerStr\":" + GSON.toJson(charge); // - same as source

    } catch (StripeException e) {
        String errorMessage = e.getMessage();
        responseStr += "\"";
        responseStr += errorMessage;
        responseStr += "\"";
        LOG.warning(errorMessage);
    }

    responseStr += "}";
    ServletUtils.sendJsonResponse(response, responseStr);
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
@Inject
public UserSubscriptionHttpService(WebUserService service, RakamUIConfig config) {
    this.service = service;
    requestOptions = new RequestOptions.RequestOptionsBuilder()
            .setApiKey(config.getStripeKey()).build();
}
 

import com.stripe.net.RequestOptions; //导入依赖的package包/类
private BalanceTransaction retrieveBalanceTransaction(String balanceTransaction, RequestOptions options) throws AuthenticationException, InvalidRequestException, APIConnectionException, CardException, APIException {
    return BalanceTransaction.retrieve(balanceTransaction, options);
}