import com.paypal.sdk.profiles.ProfileFactory; //导入依赖的package包/类
private static NVPDecoder sendNVPRequest(GenericValue payPalConfig, NVPEncoder encoder) throws PayPalException {
    NVPCallerServices caller = new NVPCallerServices();
    try {
        APIProfile profile = ProfileFactory.createSignatureAPIProfile();
        profile.setAPIUsername(payPalConfig.getString("apiUserName"));
        profile.setAPIPassword(payPalConfig.getString("apiPassword"));
        profile.setSignature(payPalConfig.getString("apiSignature"));
        profile.setEnvironment(payPalConfig.getString("apiEnvironment"));
        caller.setAPIProfile(profile);
    } catch (PayPalException e) {
        Debug.logError(e.getMessage(), module);
    }

    String requestMessage = encoder.encode();
    String responseMessage = caller.call(requestMessage);

    NVPDecoder decoder = new NVPDecoder();
    decoder.decode(responseMessage);
    if (!"Success".equals(decoder.get("ACK"))) {
        Debug.logError("A response other than success was received from PayPal: " + responseMessage, module);
    }

    return decoder;
}
 

import com.paypal.sdk.profiles.ProfileFactory; //导入依赖的package包/类
private NVPCallerServices initPayPalService() throws PayPalException {
    apiProfile = ProfileFactory.createSignatureAPIProfile();
    apiProfile.setAPIUsername(apiUserName);
    apiProfile.setAPIPassword(apiUserPassword);
    apiProfile.setSignature(apiSignature);
    apiProfile.setEnvironment(environment);
    apiProfile.setSubject("");

    payPalService = new NVPCallerServices();
    payPalService.setAPIProfile(apiProfile);

    return payPalService;
}
 

import com.paypal.sdk.profiles.ProfileFactory; //导入依赖的package包/类
public PaypalApi(String userId, String password, String signature,
                 String environment, String subject, int timeout)
        throws PayPalException {

    profile = ProfileFactory.createSignatureAPIProfile();
    profile.setAPIUsername(userId);
    profile.setAPIPassword(password);
    profile.setSignature(signature);
    profile.setEnvironment(environment);
    profile.setSubject(subject);
    profile.setTimeout(timeout);
}
 

import com.paypal.sdk.profiles.ProfileFactory; //导入依赖的package包/类
/**
     * Import all transactions that are not yet in the account.
     * @see #myAccount
     */
    public void synchronizeAllTransactions() {
//
        try {
            CallerServices caller = new CallerServices();

            /*
             WARNING: Do not embed plaintext credentials in your application code.
             Doing so is insecure and against best practices.
             Your API credentials must be handled securely. Please consider
             encrypting them for use in any production environment, and ensure
             that only authorized individuals may view or modify them.
             */
            APIProfile profile = ProfileFactory.createSSLAPIProfile();
            profile.setAPIUsername(getMyProperties().getProperty(PaypalImporter.SETTINGS_APIUSER));
            profile.setAPIPassword(getMyProperties().getProperty(PaypalImporter.SETTINGS_APIPASSWD));
            profile.setCertificateFile(getMyProperties().getProperty(PaypalImporter.SETTINGS_CERTFILE));
            profile.setPrivateKeyPassword(getMyProperties().getProperty(PaypalImporter.SETTINGS_CERTPASSWD));
//            profile.setEnvironment("beta-sandbox");
            profile.setEnvironment("live");
            caller.setAPIProfile(profile);


            TransactionSearchRequestType request = new TransactionSearchRequestType();
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.DAY_OF_MONTH, 1);

            // Paypal is limited to 100 transactions per result.
            // thus we:
            // * start with the current day,
            // *then go back one day at a time
            // * until we reached 10 consecutive days
            //   with no transaction that needed importing.
            StringBuilder finalMessage = new StringBuilder();
            int daysWithNoImportCountdown = MAXDAYSWITHNOIMPORT;
            while (daysWithNoImportCountdown > 0) {
                request.setEndDate((Calendar)calendar.clone());
                calendar.add(Calendar.DAY_OF_MONTH, -1);
                request.setStartDate(calendar);

                TransactionSearchResponseType response =
                    (TransactionSearchResponseType) caller.call("TransactionSearch", request);
                if (response.getAck().getValue() != AckCodeType._Success) {
                    LOG.log(Level.SEVERE, "Paypal-search with start-date " + calendar.getTime().toString() + " failed");
                    return;
                }

                PaymentTransactionSearchResultType[] ts = response.getPaymentTransactions();
                if (ts == null) {
                    LOG.log(Level.INFO, "Paypal-search  with start-date " + calendar.getTime().toString() + " had no result");
                    daysWithNoImportCountdown--;
                    continue;
                }
                LOG.log(Level.INFO, "Found " + ts.length + " records at all for day " + calendar.getTime().toString());

                int importedCount = importDay(ts, finalMessage, calendar.getTime());
                if (importedCount == 0) {
                    daysWithNoImportCountdown--;
                }
                else {
                    daysWithNoImportCountdown = MAXDAYSWITHNOIMPORT;
                }
            }
            if (finalMessage.length() > 0) {
                JOptionPane.showMessageDialog(null,
                        "Imorted Transactions:\n"
                        + finalMessage.toString());
            }
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Error synchronizing transactions from Paypal.", e);
        }
    }