Business Scenario Examples
This document provides complete code examples for real business scenarios to help you quickly understand how to use Lovrabet Java OpenSDK in actual projects.
Table of Contents
- Scenario 1: Customer Data Sync Service
- Scenario 2: Sales Funnel Analysis Dashboard
- Scenario 3: Order Management System
- Scenario 4: Scheduled Data Sync Task
- Scenario 5: Spring Boot Integration
Scenario 1: Customer Data Sync Service
Business Requirement
Your Java CRM system needs to sync new customer information to the Lovrabet Platform for data analysis and report generation.
Technical Solution
- Listen to customer creation events in the CRM system
- Convert customer data to Lovrabet data format
- Call OpenSDK to create customer records
- Log sync activities and handle exceptions
Complete Code
package com.example.crm.sync;
import com.lovrabet.runtime.opensdk.client.LovrabetSDKClient;
import com.lovrabet.runtime.opensdk.model.LovrabetRequest;
import com.lovrabet.runtime.opensdk.model.LovrabetResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.Map;
/**
* Customer Data Sync Service
* Syncs customer data from CRM system to Lovrabet Platform
*/
public class CustomerSyncService {
private static final Logger logger = LoggerFactory.getLogger(CustomerSyncService.class);
private final LovrabetSDKClient sdkClient;
private final String appCode = "app-c2dd52a2";
private final String customerDatasetCode = "b460abdbb0fb49e1865110d9dfbbc9b4";
public CustomerSyncService(String accessKey, String baseUrl) {
this.sdkClient = new LovrabetSDKClient(accessKey, baseUrl);
}
/**
* Sync single customer data
*/
public boolean syncCustomer(Customer customer) {
logger.info("Starting customer data sync: {}", customer.getName());
try {
// Build request parameters
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(customerDatasetCode);
// Convert customer data to Lovrabet format
Map<String, Object> paramMap = convertCustomerData(customer);
request.setParamMap(paramMap);
// Call API to create record
LovrabetResult<String> result = sdkClient.create(request);
if (result.isSuccess()) {
String lovrabetId = result.getData();
logger.info("Customer sync successful - Customer: {}, Lovrabet ID: {}",
customer.getName(), lovrabetId);
// Save Lovrabet ID to local database (optional)
updateCustomerLovrabetId(customer.getId(), lovrabetId);
return true;
} else {
logger.error("Customer sync failed - Customer: {}, Error: {}",
customer.getName(), result.getResultMsg());
return false;
}
} catch (Exception e) {
logger.error("Customer sync exception - Customer: {}", customer.getName(), e);
return false;
}
}
/**
* Batch sync customer data
*/
public SyncResult batchSyncCustomers(List<Customer> customers) {
logger.info("Starting batch customer sync, total: {}", customers.size());
int successCount = 0;
int failCount = 0;
List<String> failedCustomers = new ArrayList<>();
for (Customer customer : customers) {
boolean success = syncCustomer(customer);
if (success) {
successCount++;
} else {
failCount++;
failedCustomers.add(customer.getName());
}
}
logger.info("Batch sync completed - Success: {}, Failed: {}", successCount, failCount);
return new SyncResult(successCount, failCount, failedCustomers);
}
/**
* Update customer data
*/
public boolean updateCustomer(Customer customer, String lovrabetId) {
logger.info("Starting customer data update: {}", customer.getName());
try {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(customerDatasetCode);
request.setId(Long.parseLong(lovrabetId));
// Only update changed fields
Map<String, Object> paramMap = convertCustomerData(customer);
request.setParamMap(paramMap);
LovrabetResult<String> result = sdkClient.update(request);
if (result.isSuccess()) {
logger.info("Customer update successful - Customer: {}", customer.getName());
return true;
} else {
logger.error("Customer update failed - Customer: {}, Error: {}",
customer.getName(), result.getResultMsg());
return false;
}
} catch (Exception e) {
logger.error("Customer update exception - Customer: {}", customer.getName(), e);
return false;
}
}
/**
* Convert CRM customer object to Lovrabet data format
*/
private Map<String, Object> convertCustomerData(Customer customer) {
Map<String, Object> paramMap = new HashMap<>();
// Customer name
paramMap.put("TEXT_1", customer.getName());
// Contact phone
if (customer.getPhone() != null) {
paramMap.put("TEXT_2", customer.getPhone());
}
// Email
if (customer.getEmail() != null) {
paramMap.put("TEXT_3", customer.getEmail());
}
// Company name
if (customer.getCompany() != null) {
paramMap.put("TEXT_4", customer.getCompany());
}
// Customer level (1-Regular, 2-Important, 3-VIP)
paramMap.put("SELECT_1", customer.getLevel());
// Customer source
if (customer.getSource() != null) {
paramMap.put("SELECT_2", customer.getSource());
}
// Estimated annual value
if (customer.getEstimatedAnnualValue() != null) {
paramMap.put("NUMBER_1", customer.getEstimatedAnnualValue());
}
// Create time
paramMap.put("DATETIME_1", customer.getCreateTime().getTime());
return paramMap;
}
/**
* Save Lovrabet ID to local database
*/
private void updateCustomerLovrabetId(Long customerId, String lovrabetId) {
// In actual projects, this should update the database
logger.debug("Saving Lovrabet ID for customer {}: {}", customerId, lovrabetId);
}
}
/**
* Customer Entity Class (Example)
*/
class Customer {
private Long id;
private String name;
private String phone;
private String email;
private String company;
private Integer level; // 1-Regular, 2-Important, 3-VIP
private String source; // online, offline, referral
private Double estimatedAnnualValue;
private Date createTime;
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getPhone() { return phone; }
public void setPhone(String phone) { this.phone = phone; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getCompany() { return company; }
public void setCompany(String company) { this.company = company; }
public Integer getLevel() { return level; }
public void setLevel(Integer level) { this.level = level; }
public String getSource() { return source; }
public void setSource(String source) { this.source = source; }
public Double getEstimatedAnnualValue() { return estimatedAnnualValue; }
public void setEstimatedAnnualValue(Double estimatedAnnualValue) {
this.estimatedAnnualValue = estimatedAnnualValue;
}
public Date getCreateTime() { return createTime; }
public void setCreateTime(Date createTime) { this.createTime = createTime; }
}
/**
* Sync Result Class
*/
class SyncResult {
private int successCount;
private int failCount;
private List<String> failedItems;
public SyncResult(int successCount, int failCount, List<String> failedItems) {
this.successCount = successCount;
this.failCount = failCount;
this.failedItems = failedItems;
}
// Getters
public int getSuccessCount() { return successCount; }
public int getFailCount() { return failCount; }
public List<String> getFailedItems() { return failedItems; }
}
Usage Example
public class CustomerSyncDemo {
public static void main(String[] args) {
// Initialize sync service
String accessKey = System.getenv("LOVRABET_ACCESS_KEY");
String baseUrl = "https://runtime.lovrabet.com/openapi";
CustomerSyncService syncService = new CustomerSyncService(accessKey, baseUrl);
// Create customer object
Customer customer = new Customer();
customer.setId(1001L);
customer.setName("Alibaba Technology Co., Ltd.");
customer.setPhone("138-0000-1234");
customer.setEmail("contact@alibaba.com");
customer.setCompany("Alibaba");
customer.setLevel(3); // VIP customer
customer.setSource("referral");
customer.setEstimatedAnnualValue(500000.0);
customer.setCreateTime(new Date());
// Sync single customer
boolean success = syncService.syncCustomer(customer);
if (success) {
System.out.println("Customer sync successful");
}
// Batch sync customers
List<Customer> customers = getCustomersFromDatabase();
SyncResult result = syncService.batchSyncCustomers(customers);
System.out.println("Sync completed - Success: " + result.getSuccessCount()
+ ", Failed: " + result.getFailCount());
}
private static List<Customer> getCustomersFromDatabase() {
// Get customer list from database
return new ArrayList<>();
}
}
Scenario 2: Sales Funnel Analysis Dashboard
Business Requirement
Retrieve sales opportunity data from Lovrabet Platform, aggregate by stage to count quantities and amounts, and generate sales funnel analysis reports.
Technical Solution
- Query all sales opportunity data
- Group and aggregate by sales stage
- Calculate conversion rates and amount summaries
- Generate visualization report data
Complete Code
package com.example.sales.analysis;
import com.lovrabet.runtime.opensdk.client.LovrabetSDKClient;
import com.lovrabet.runtime.opensdk.model.LovrabetRequest;
import com.lovrabet.runtime.opensdk.model.LovrabetResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.stream.Collectors;
/**
* Sales Funnel Analysis Service
* Retrieves sales data from Lovrabet and performs funnel analysis
*/
public class SalesFunnelAnalysisService {
private static final Logger logger = LoggerFactory.getLogger(SalesFunnelAnalysisService.class);
private final LovrabetSDKClient sdkClient;
private final String appCode = "app-c2dd52a2";
private final String opportunityDatasetCode = "32c036010c504757b80d438e3c0ec8b7";
public SalesFunnelAnalysisService(String accessKey, String baseUrl) {
this.sdkClient = new LovrabetSDKClient(accessKey, baseUrl);
}
/**
* Generate sales funnel analysis report
*/
public FunnelReport generateFunnelReport() {
logger.info("Starting sales funnel analysis report generation");
// 1. Get all sales opportunity data
List<Map<String, Object>> opportunities = getAllOpportunities();
if (opportunities.isEmpty()) {
logger.warn("No sales opportunity data found");
return new FunnelReport();
}
logger.info("Found {} sales opportunities", opportunities.size());
// 2. Group and aggregate by stage
Map<String, FunnelStage> stageMap = analyzeByStage(opportunities);
// 3. Calculate overall metrics
FunnelReport report = new FunnelReport();
report.setTotalCount(opportunities.size());
report.setTotalAmount(calculateTotalAmount(opportunities));
report.setStages(sortStages(stageMap));
report.setGenerateTime(new Date());
logger.info("Sales funnel analysis completed - Total opportunities: {}, Total amount: {}",
report.getTotalCount(), report.getTotalAmount());
return report;
}
/**
* Get all sales opportunity data
*/
private List<Map<String, Object>> getAllOpportunities() {
List<Map<String, Object>> allData = new ArrayList<>();
int currentPage = 1;
int pageSize = 100;
boolean hasMore = true;
while (hasMore) {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(opportunityDatasetCode);
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("currentPage", currentPage);
paramMap.put("pageSize", pageSize);
request.setParamMap(paramMap);
LovrabetResult<?> result = sdkClient.getList(request);
if (result.isSuccess()) {
List<Map<String, Object>> pageData =
(List<Map<String, Object>>) result.getData();
if (pageData.isEmpty()) {
hasMore = false;
} else {
allData.addAll(pageData);
if (pageData.size() < pageSize) {
hasMore = false;
} else {
currentPage++;
}
}
} else {
logger.error("Failed to query sales opportunities: {}", result.getResultMsg());
hasMore = false;
}
}
return allData;
}
/**
* Analyze data by sales stage
*/
private Map<String, FunnelStage> analyzeByStage(List<Map<String, Object>> opportunities) {
Map<String, FunnelStage> stageMap = new HashMap<>();
for (Map<String, Object> opportunity : opportunities) {
// Get sales stage (SELECT_4 field)
String stage = (String) opportunity.get("SELECT_4");
if (stage == null) {
stage = "Unknown";
}
// Get amount (NUMBER_3 field)
Number amountObj = (Number) opportunity.get("NUMBER_3");
double amount = amountObj != null ? amountObj.doubleValue() : 0.0;
// Accumulate data for this stage
FunnelStage funnelStage = stageMap.computeIfAbsent(stage, k -> new FunnelStage(k));
funnelStage.addOpportunity(amount);
}
return stageMap;
}
/**
* Calculate total amount
*/
private double calculateTotalAmount(List<Map<String, Object>> opportunities) {
return opportunities.stream()
.map(opp -> (Number) opp.get("NUMBER_3"))
.filter(Objects::nonNull)
.mapToDouble(Number::doubleValue)
.sum();
}
/**
* Sort stages by sales process order
*/
private List<FunnelStage> sortStages(Map<String, FunnelStage> stageMap) {
// Define sales stage order
List<String> stageOrder = Arrays.asList(
"Lead", "Initial Contact", "Needs Analysis", "Proposal",
"Negotiation", "Contract Signing", "Closed Won", "Closed Lost"
);
return stageOrder.stream()
.filter(stageMap::containsKey)
.map(stageMap::get)
.collect(Collectors.toList());
}
/**
* Get performance data for a specific salesperson
*/
public SalesPersonPerformance getSalesPersonPerformance(String salespersonName) {
logger.info("Querying salesperson performance: {}", salespersonName);
List<Map<String, Object>> allOpportunities = getAllOpportunities();
// Filter opportunities for this salesperson (TEXT_1 field stores salesperson name)
List<Map<String, Object>> personOpportunities = allOpportunities.stream()
.filter(opp -> salespersonName.equals(opp.get("TEXT_1")))
.collect(Collectors.toList());
SalesPersonPerformance performance = new SalesPersonPerformance();
performance.setSalespersonName(salespersonName);
performance.setTotalOpportunities(personOpportunities.size());
// Calculate closed amount
double closedAmount = personOpportunities.stream()
.filter(opp -> "Closed Won".equals(opp.get("SELECT_4")))
.map(opp -> (Number) opp.get("NUMBER_3"))
.filter(Objects::nonNull)
.mapToDouble(Number::doubleValue)
.sum();
performance.setClosedAmount(closedAmount);
// Calculate pipeline amount
double pipelineAmount = personOpportunities.stream()
.filter(opp -> {
String stage = (String) opp.get("SELECT_4");
return stage != null && !stage.equals("Closed Won") && !stage.equals("Closed Lost");
})
.map(opp -> (Number) opp.get("NUMBER_3"))
.filter(Objects::nonNull)
.mapToDouble(Number::doubleValue)
.sum();
performance.setPipelineAmount(pipelineAmount);
logger.info("Salesperson {} performance - Total opportunities: {}, Closed amount: {}, Pipeline amount: {}",
salespersonName, performance.getTotalOpportunities(),
closedAmount, pipelineAmount);
return performance;
}
}
/**
* Sales Funnel Stage Data
*/
class FunnelStage {
private String stageName;
private int count;
private double totalAmount;
public FunnelStage(String stageName) {
this.stageName = stageName;
this.count = 0;
this.totalAmount = 0.0;
}
public void addOpportunity(double amount) {
this.count++;
this.totalAmount += amount;
}
// Getters
public String getStageName() { return stageName; }
public int getCount() { return count; }
public double getTotalAmount() { return totalAmount; }
public double getAverageAmount() {
return count > 0 ? totalAmount / count : 0.0;
}
}
/**
* Sales Funnel Report
*/
class FunnelReport {
private int totalCount;
private double totalAmount;
private List<FunnelStage> stages;
private Date generateTime;
public FunnelReport() {
this.stages = new ArrayList<>();
}
// Getters and Setters
public int getTotalCount() { return totalCount; }
public void setTotalCount(int totalCount) { this.totalCount = totalCount; }
public double getTotalAmount() { return totalAmount; }
public void setTotalAmount(double totalAmount) { this.totalAmount = totalAmount; }
public List<FunnelStage> getStages() { return stages; }
public void setStages(List<FunnelStage> stages) { this.stages = stages; }
public Date getGenerateTime() { return generateTime; }
public void setGenerateTime(Date generateTime) { this.generateTime = generateTime; }
}
/**
* Salesperson Performance Data
*/
class SalesPersonPerformance {
private String salespersonName;
private int totalOpportunities;
private double closedAmount;
private double pipelineAmount;
// Getters and Setters
public String getSalespersonName() { return salespersonName; }
public void setSalespersonName(String salespersonName) {
this.salespersonName = salespersonName;
}
public int getTotalOpportunities() { return totalOpportunities; }
public void setTotalOpportunities(int totalOpportunities) {
this.totalOpportunities = totalOpportunities;
}
public double getClosedAmount() { return closedAmount; }
public void setClosedAmount(double closedAmount) {
this.closedAmount = closedAmount;
}
public double getPipelineAmount() { return pipelineAmount; }
public void setPipelineAmount(double pipelineAmount) {
this.pipelineAmount = pipelineAmount;
}
}
Usage Example
public class SalesFunnelDemo {
public static void main(String[] args) {
String accessKey = System.getenv("LOVRABET_ACCESS_KEY");
String baseUrl = "https://runtime.lovrabet.com/openapi";
SalesFunnelAnalysisService analysisService =
new SalesFunnelAnalysisService(accessKey, baseUrl);
// Generate sales funnel report
FunnelReport report = analysisService.generateFunnelReport();
System.out.println("===== Sales Funnel Analysis Report =====");
System.out.println("Generated at: " + report.getGenerateTime());
System.out.println("Total opportunities: " + report.getTotalCount());
System.out.println("Total amount: " + String.format("%.2f", report.getTotalAmount()));
System.out.println("\nStage details:");
for (FunnelStage stage : report.getStages()) {
System.out.println(String.format("%s: %d opportunities, Total %.2f, Average %.2f",
stage.getStageName(),
stage.getCount(),
stage.getTotalAmount(),
stage.getAverageAmount()));
}
// Query specific salesperson performance
SalesPersonPerformance performance =
analysisService.getSalesPersonPerformance("John Smith");
System.out.println("\n===== Salesperson Performance =====");
System.out.println("Salesperson: " + performance.getSalespersonName());
System.out.println("Total opportunities: " + performance.getTotalOpportunities());
System.out.println("Closed amount: " + String.format("%.2f", performance.getClosedAmount()));
System.out.println("Pipeline amount: " + String.format("%.2f", performance.getPipelineAmount()));
}
}
Scenario 3: Order Management System
Business Requirement
E-commerce system needs to sync order data to Lovrabet, supporting order status updates, order detail queries, and more.
Complete Code
package com.example.order;
import com.lovrabet.runtime.opensdk.client.LovrabetSDKClient;
import com.lovrabet.runtime.opensdk.model.LovrabetRequest;
import com.lovrabet.runtime.opensdk.model.LovrabetResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
/**
* Order Management Service
* Syncs e-commerce orders to Lovrabet and manages order status
*/
public class OrderManagementService {
private static final Logger logger = LoggerFactory.getLogger(OrderManagementService.class);
private final LovrabetSDKClient sdkClient;
private final String appCode = "app-c2dd52a2";
private final String orderDatasetCode = "b460abdbb0fb49e1865110d9dfbbc9b4";
public OrderManagementService(String accessKey, String baseUrl) {
this.sdkClient = new LovrabetSDKClient(accessKey, baseUrl);
}
/**
* Create order
*/
public String createOrder(Order order) {
logger.info("Creating order: {}", order.getOrderNo());
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(orderDatasetCode);
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("TEXT_1", order.getOrderNo()); // Order number
paramMap.put("TEXT_2", order.getCustomerName()); // Customer name
paramMap.put("TEXT_3", order.getCustomerPhone()); // Phone
paramMap.put("TEXT_4", order.getShippingAddress()); // Shipping address
paramMap.put("NUMBER_1", order.getTotalAmount()); // Order amount
paramMap.put("NUMBER_2", order.getItemCount()); // Item count
paramMap.put("SELECT_1", order.getStatus()); // Order status
paramMap.put("SELECT_2", order.getPaymentMethod()); // Payment method
paramMap.put("DATETIME_1", order.getCreateTime().getTime()); // Create time
LovrabetResult<String> result = sdkClient.create(request);
if (result.isSuccess()) {
String lovrabetId = result.getData();
logger.info("Order created successfully - Order No: {}, Lovrabet ID: {}",
order.getOrderNo(), lovrabetId);
return lovrabetId;
} else {
logger.error("Order creation failed - Order No: {}, Error: {}",
order.getOrderNo(), result.getResultMsg());
return null;
}
}
/**
* Update order status
*/
public boolean updateOrderStatus(String lovrabetId, String newStatus) {
logger.info("Updating order status - ID: {}, New status: {}", lovrabetId, newStatus);
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(orderDatasetCode);
request.setId(Long.parseLong(lovrabetId));
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("SELECT_1", newStatus); // Update status field
// If shipped status, add shipping time
if ("Shipped".equals(newStatus)) {
paramMap.put("DATETIME_2", System.currentTimeMillis());
}
// If completed status, add completion time
if ("Completed".equals(newStatus)) {
paramMap.put("DATETIME_3", System.currentTimeMillis());
}
request.setParamMap(paramMap);
LovrabetResult<String> result = sdkClient.update(request);
if (result.isSuccess()) {
logger.info("Order status updated successfully - ID: {}", lovrabetId);
return true;
} else {
logger.error("Order status update failed - ID: {}, Error: {}",
lovrabetId, result.getResultMsg());
return false;
}
}
/**
* Query order details
*/
public Map<String, Object> getOrderDetail(String lovrabetId) {
logger.info("Querying order details - ID: {}", lovrabetId);
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(orderDatasetCode);
request.setId(Long.parseLong(lovrabetId));
LovrabetResult<?> result = sdkClient.getOne(request);
if (result.isSuccess()) {
Map<String, Object> orderData = (Map<String, Object>) result.getData();
logger.info("Order query successful - ID: {}, Order No: {}",
lovrabetId, orderData.get("TEXT_1"));
return orderData;
} else {
logger.error("Order query failed - ID: {}, Error: {}",
lovrabetId, result.getResultMsg());
return null;
}
}
/**
* Query orders within a date range
*/
public List<Map<String, Object>> getOrdersByDateRange(Date startDate, Date endDate) {
logger.info("Querying orders by date range - Start: {}, End: {}", startDate, endDate);
List<Map<String, Object>> allOrders = new ArrayList<>();
int currentPage = 1;
int pageSize = 50;
boolean hasMore = true;
while (hasMore) {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(orderDatasetCode);
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("currentPage", currentPage);
paramMap.put("pageSize", pageSize);
request.setParamMap(paramMap);
LovrabetResult<?> result = sdkClient.getList(request);
if (result.isSuccess()) {
List<Map<String, Object>> pageData =
(List<Map<String, Object>>) result.getData();
if (pageData.isEmpty()) {
hasMore = false;
} else {
// Filter orders within date range
for (Map<String, Object> order : pageData) {
Number createTimeMs = (Number) order.get("DATETIME_1");
if (createTimeMs != null) {
Date createTime = new Date(createTimeMs.longValue());
if (!createTime.before(startDate) && !createTime.after(endDate)) {
allOrders.add(order);
}
}
}
if (pageData.size() < pageSize) {
hasMore = false;
} else {
currentPage++;
}
}
} else {
logger.error("Failed to query order list: {}", result.getResultMsg());
hasMore = false;
}
}
logger.info("Date range query completed - Total {} orders", allOrders.size());
return allOrders;
}
/**
* Get order statistics
*/
public OrderStatistics getOrderStatistics() {
logger.info("Starting order statistics");
List<Map<String, Object>> allOrders = getAllOrders();
OrderStatistics stats = new OrderStatistics();
stats.setTotalOrders(allOrders.size());
// Calculate total amount
double totalAmount = allOrders.stream()
.map(order -> (Number) order.get("NUMBER_1"))
.filter(Objects::nonNull)
.mapToDouble(Number::doubleValue)
.sum();
stats.setTotalAmount(totalAmount);
// Count orders by status
Map<String, Long> statusCount = allOrders.stream()
.collect(Collectors.groupingBy(
order -> (String) order.getOrDefault("SELECT_1", "Unknown"),
Collectors.counting()
));
stats.setStatusCount(statusCount);
logger.info("Order statistics completed - Total orders: {}, Total amount: {}",
stats.getTotalOrders(), stats.getTotalAmount());
return stats;
}
/**
* Get all orders
*/
private List<Map<String, Object>> getAllOrders() {
List<Map<String, Object>> allOrders = new ArrayList<>();
int currentPage = 1;
int pageSize = 100;
boolean hasMore = true;
while (hasMore) {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(orderDatasetCode);
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("currentPage", currentPage);
paramMap.put("pageSize", pageSize);
request.setParamMap(paramMap);
LovrabetResult<?> result = sdkClient.getList(request);
if (result.isSuccess()) {
List<Map<String, Object>> pageData =
(List<Map<String, Object>>) result.getData();
if (pageData.isEmpty()) {
hasMore = false;
} else {
allOrders.addAll(pageData);
if (pageData.size() < pageSize) {
hasMore = false;
} else {
currentPage++;
}
}
} else {
logger.error("Failed to query order list: {}", result.getResultMsg());
hasMore = false;
}
}
return allOrders;
}
}
/**
* Order Entity Class
*/
class Order {
private String orderNo;
private String customerName;
private String customerPhone;
private String shippingAddress;
private Double totalAmount;
private Integer itemCount;
private String status; // Pending Payment, Paid, Shipped, Completed, Cancelled
private String paymentMethod; // Alipay, WeChat, Bank Card
private Date createTime;
// Getters and Setters
public String getOrderNo() { return orderNo; }
public void setOrderNo(String orderNo) { this.orderNo = orderNo; }
public String getCustomerName() { return customerName; }
public void setCustomerName(String customerName) { this.customerName = customerName; }
public String getCustomerPhone() { return customerPhone; }
public void setCustomerPhone(String customerPhone) { this.customerPhone = customerPhone; }
public String getShippingAddress() { return shippingAddress; }
public void setShippingAddress(String shippingAddress) {
this.shippingAddress = shippingAddress;
}
public Double getTotalAmount() { return totalAmount; }
public void setTotalAmount(Double totalAmount) { this.totalAmount = totalAmount; }
public Integer getItemCount() { return itemCount; }
public void setItemCount(Integer itemCount) { this.itemCount = itemCount; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public String getPaymentMethod() { return paymentMethod; }
public void setPaymentMethod(String paymentMethod) { this.paymentMethod = paymentMethod; }
public Date getCreateTime() { return createTime; }
public void setCreateTime(Date createTime) { this.createTime = createTime; }
}
/**
* Order Statistics Data
*/
class OrderStatistics {
private int totalOrders;
private double totalAmount;
private Map<String, Long> statusCount;
// Getters and Setters
public int getTotalOrders() { return totalOrders; }
public void setTotalOrders(int totalOrders) { this.totalOrders = totalOrders; }
public double getTotalAmount() { return totalAmount; }
public void setTotalAmount(double totalAmount) { this.totalAmount = totalAmount; }
public Map<String, Long> getStatusCount() { return statusCount; }
public void setStatusCount(Map<String, Long> statusCount) {
this.statusCount = statusCount;
}
}
Usage Example
public class OrderManagementDemo {
public static void main(String[] args) {
String accessKey = System.getenv("LOVRABET_ACCESS_KEY");
String baseUrl = "https://runtime.lovrabet.com/openapi";
OrderManagementService orderService =
new OrderManagementService(accessKey, baseUrl);
// 1. Create order
Order order = new Order();
order.setOrderNo("ORD20250112001");
order.setCustomerName("John Doe");
order.setCustomerPhone("138-1234-5678");
order.setShippingAddress("123 Main St, New York, NY");
order.setTotalAmount(299.00);
order.setItemCount(2);
order.setStatus("Pending Payment");
order.setPaymentMethod("Credit Card");
order.setCreateTime(new Date());
String lovrabetId = orderService.createOrder(order);
System.out.println("Order created, ID: " + lovrabetId);
// 2. Update order status
boolean updated = orderService.updateOrderStatus(lovrabetId, "Paid");
System.out.println("Order status update: " + (updated ? "Success" : "Failed"));
// 3. Query order details
Map<String, Object> orderDetail = orderService.getOrderDetail(lovrabetId);
System.out.println("Order details: " + orderDetail);
// 4. Get order statistics
OrderStatistics stats = orderService.getOrderStatistics();
System.out.println("\n===== Order Statistics =====");
System.out.println("Total orders: " + stats.getTotalOrders());
System.out.println("Total amount: " + String.format("%.2f", stats.getTotalAmount()));
System.out.println("Orders by status:");
stats.getStatusCount().forEach((status, count) ->
System.out.println(" " + status + ": " + count));
}
}
Scenario 4: Scheduled Data Sync Task
Business Requirement
Daily scheduled sync of customer data from local database to Lovrabet to maintain data consistency.
Complete Code
package com.example.scheduler;
import com.lovrabet.runtime.opensdk.client.LovrabetSDKClient;
import com.lovrabet.runtime.opensdk.model.LovrabetRequest;
import com.lovrabet.runtime.opensdk.model.LovrabetResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.concurrent.*;
/**
* Scheduled Data Sync Task
* Daily sync of local data to Lovrabet
*/
public class DataSyncScheduler {
private static final Logger logger = LoggerFactory.getLogger(DataSyncScheduler.class);
private final LovrabetSDKClient sdkClient;
private final ScheduledExecutorService scheduler;
private final String appCode = "app-c2dd52a2";
private final String datasetCode = "b460abdbb0fb49e1865110d9dfbbc9b4";
public DataSyncScheduler(String accessKey, String baseUrl) {
this.sdkClient = new LovrabetSDKClient(accessKey, baseUrl);
this.scheduler = Executors.newScheduledThreadPool(1);
}
/**
* Start scheduled sync task
* Runs daily at 2:00 AM
*/
public void startScheduledSync() {
logger.info("Starting scheduled sync task");
// Calculate delay until next 2:00 AM
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY, 2);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
calendar.add(Calendar.DAY_OF_MONTH, 1);
}
long initialDelay = calendar.getTimeInMillis() - System.currentTimeMillis();
long period = TimeUnit.DAYS.toMillis(1); // 24 hours
scheduler.scheduleAtFixedRate(
this::performSync,
initialDelay,
period,
TimeUnit.MILLISECONDS
);
logger.info("Scheduled sync task started, first run at: {}", calendar.getTime());
}
/**
* Perform sync operation
*/
public void performSync() {
logger.info("========== Starting data sync ==========");
long startTime = System.currentTimeMillis();
try {
// 1. Get data to sync from local database
List<Map<String, Object>> localData = fetchDataFromLocalDatabase();
logger.info("Fetched {} records from local database", localData.size());
if (localData.isEmpty()) {
logger.info("No data to sync, task completed");
return;
}
// 2. Batch sync data
SyncResult result = batchSyncData(localData);
// 3. Log sync results
long duration = System.currentTimeMillis() - startTime;
logger.info("========== Data sync completed ==========");
logger.info("Total records: {}", localData.size());
logger.info("Success: {}, Failed: {}", result.getSuccessCount(), result.getFailCount());
logger.info("Duration: {} seconds", duration / 1000);
// 4. Update sync status in local database
updateSyncStatus(result);
// 5. Send sync report
sendSyncReport(result, duration);
} catch (Exception e) {
logger.error("Exception during data sync", e);
sendErrorAlert(e);
}
}
/**
* Batch sync data
*/
private SyncResult batchSyncData(List<Map<String, Object>> dataList) {
int successCount = 0;
int failCount = 0;
List<String> failedIds = new ArrayList<>();
// Use thread pool for concurrent sync
ExecutorService executor = Executors.newFixedThreadPool(10);
List<Future<Boolean>> futures = new ArrayList<>();
for (Map<String, Object> data : dataList) {
Future<Boolean> future = executor.submit(() -> syncSingleRecord(data));
futures.add(future);
}
// Wait for all tasks and collect results
for (int i = 0; i < futures.size(); i++) {
try {
Boolean success = futures.get(i).get();
if (success) {
successCount++;
} else {
failCount++;
failedIds.add(String.valueOf(dataList.get(i).get("id")));
}
} catch (Exception e) {
failCount++;
failedIds.add(String.valueOf(dataList.get(i).get("id")));
logger.error("Failed to get sync result", e);
}
}
executor.shutdown();
return new SyncResult(successCount, failCount, failedIds);
}
/**
* Sync single record
*/
private boolean syncSingleRecord(Map<String, Object> data) {
try {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(appCode);
request.setModelCode(datasetCode);
// Convert data format
Map<String, Object> paramMap = convertToLovrabetFormat(data);
request.setParamMap(paramMap);
// Check if already exists (via local ID mapping)
String lovrabetId = getExistingLovrabetId(data.get("id"));
LovrabetResult<String> result;
if (lovrabetId != null) {
// Update existing record
request.setId(Long.parseLong(lovrabetId));
result = sdkClient.update(request);
} else {
// Create new record
result = sdkClient.create(request);
if (result.isSuccess()) {
// Save Lovrabet ID for new record
saveIdMapping(data.get("id"), result.getData());
}
}
return result.isSuccess();
} catch (Exception e) {
logger.error("Failed to sync record: {}", data.get("id"), e);
return false;
}
}
/**
* Fetch data to sync from local database
*/
private List<Map<String, Object>> fetchDataFromLocalDatabase() {
// In actual projects, this should query the database
// Here we return sample data
logger.debug("Fetching data from local database...");
return new ArrayList<>();
}
/**
* Convert to Lovrabet data format
*/
private Map<String, Object> convertToLovrabetFormat(Map<String, Object> localData) {
Map<String, Object> lovrabetData = new HashMap<>();
// Convert based on field mappings
lovrabetData.put("TEXT_1", localData.get("name"));
lovrabetData.put("TEXT_2", localData.get("phone"));
lovrabetData.put("NUMBER_1", localData.get("amount"));
lovrabetData.put("DATETIME_1", localData.get("createTime"));
return lovrabetData;
}
/**
* Get existing Lovrabet ID
*/
private String getExistingLovrabetId(Object localId) {
// In actual projects, this should query the mapping table
logger.debug("Looking up Lovrabet ID for local ID {}", localId);
return null;
}
/**
* Save ID mapping
*/
private void saveIdMapping(Object localId, String lovrabetId) {
// In actual projects, this should save to mapping table
logger.debug("Saving ID mapping: {} -> {}", localId, lovrabetId);
}
/**
* Update sync status
*/
private void updateSyncStatus(SyncResult result) {
// Update sync status in local database
logger.debug("Updating sync status");
}
/**
* Send sync report
*/
private void sendSyncReport(SyncResult result, long duration) {
logger.info("Sending sync report");
// In actual projects, can send email or message notification
}
/**
* Send error alert
*/
private void sendErrorAlert(Exception e) {
logger.error("Sending error alert");
// In actual projects, can send alert message
}
/**
* Stop scheduled task
*/
public void shutdown() {
logger.info("Stopping scheduled sync task");
scheduler.shutdown();
try {
if (!scheduler.awaitTermination(60, TimeUnit.SECONDS)) {
scheduler.shutdownNow();
}
} catch (InterruptedException e) {
scheduler.shutdownNow();
Thread.currentThread().interrupt();
}
}
}
Usage Example
public class SchedulerDemo {
public static void main(String[] args) {
String accessKey = System.getenv("LOVRABET_ACCESS_KEY");
String baseUrl = "https://runtime.lovrabet.com/openapi";
DataSyncScheduler scheduler = new DataSyncScheduler(accessKey, baseUrl);
// Start scheduled sync task (daily at 2:00 AM)
scheduler.startScheduledSync();
// Or execute sync immediately
scheduler.performSync();
// Stop scheduler on program exit
Runtime.getRuntime().addShutdownHook(new Thread(scheduler::shutdown));
}
}
Scenario 5: Spring Boot Integration
Business Requirement
Integrate Lovrabet OpenSDK in a Spring Boot application with dependency injection and auto-configuration.
Complete Code
1. Configuration Class
package com.example.config;
import com.lovrabet.runtime.opensdk.client.LovrabetSDKClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Lovrabet SDK Configuration Class
*/
@Configuration
public class LovrabetConfig {
@Bean
@ConfigurationProperties(prefix = "lovrabet")
public LovrabetProperties lovrabetProperties() {
return new LovrabetProperties();
}
@Bean
public LovrabetSDKClient lovrabetSDKClient(LovrabetProperties properties) {
return new LovrabetSDKClient(
properties.getAccessKey(),
properties.getBaseUrl()
);
}
}
/**
* Lovrabet Configuration Properties
*/
class LovrabetProperties {
private String accessKey;
private String baseUrl;
private String appCode;
// Getters and Setters
public String getAccessKey() { return accessKey; }
public void setAccessKey(String accessKey) { this.accessKey = accessKey; }
public String getBaseUrl() { return baseUrl; }
public void setBaseUrl(String baseUrl) { this.baseUrl = baseUrl; }
public String getAppCode() { return appCode; }
public void setAppCode(String appCode) { this.appCode = appCode; }
}
2. Configuration File (application.yml)
lovrabet:
access-key: ${LOVRABET_ACCESS_KEY}
base-url: https://runtime.lovrabet.com/openapi
app-code: app-c2dd52a2
3. Service Layer
package com.example.service;
import com.lovrabet.runtime.opensdk.client.LovrabetSDKClient;
import com.lovrabet.runtime.opensdk.model.LovrabetRequest;
import com.lovrabet.runtime.opensdk.model.LovrabetResult;
import com.example.config.LovrabetProperties;
import org.springframework.stereotype.Service;
import java.util.*;
@Service
public class CustomerDataService {
private final LovrabetSDKClient sdkClient;
private final LovrabetProperties properties;
public CustomerDataService(LovrabetSDKClient sdkClient,
LovrabetProperties properties) {
this.sdkClient = sdkClient;
this.properties = properties;
}
/**
* Get customer list
*/
public List<Map<String, Object>> getCustomers(int page, int size) {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(properties.getAppCode());
request.setModelCode("b460abdbb0fb49e1865110d9dfbbc9b4");
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("currentPage", page);
paramMap.put("pageSize", size);
request.setParamMap(paramMap);
LovrabetResult<?> result = sdkClient.getList(request);
if (result.isSuccess()) {
return (List<Map<String, Object>>) result.getData();
} else {
throw new RuntimeException("Failed to query customer list: " + result.getResultMsg());
}
}
/**
* Create customer
*/
public String createCustomer(Map<String, Object> customerData) {
LovrabetRequest request = new LovrabetRequest();
request.setAppCode(properties.getAppCode());
request.setModelCode("b460abdbb0fb49e1865110d9dfbbc9b4");
request.setParamMap(customerData);
LovrabetResult<String> result = sdkClient.create(request);
if (result.isSuccess()) {
return result.getData();
} else {
throw new RuntimeException("Failed to create customer: " + result.getResultMsg());
}
}
}
4. Controller Layer
package com.example.controller;
import com.example.service.CustomerDataService;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/customers")
public class CustomerController {
private final CustomerDataService customerDataService;
public CustomerController(CustomerDataService customerDataService) {
this.customerDataService = customerDataService;
}
/**
* Get customer list
*/
@GetMapping
public List<Map<String, Object>> getCustomers(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "20") int size
) {
return customerDataService.getCustomers(page, size);
}
/**
* Create customer
*/
@PostMapping
public String createCustomer(@RequestBody Map<String, Object> customerData) {
return customerDataService.createCustomer(customerData);
}
}
Usage Example
After starting the Spring Boot application, you can access via HTTP endpoints:
# Get customer list
curl http://localhost:8080/api/customers?page=1&size=10
# Create customer
curl -X POST http://localhost:8080/api/customers \
-H "Content-Type: application/json" \
-d '{
"TEXT_1": "Customer Name",
"TEXT_2": "138-0000-1234",
"NUMBER_1": 100000
}'
Summary
This document provides complete examples for 5 real business scenarios:
- Customer Data Sync Service - Sync CRM data to Lovrabet
- Sales Funnel Analysis Dashboard - Retrieve data from Lovrabet and perform analysis
- Order Management System - Complete order CRUD operations
- Scheduled Data Sync Task - Use scheduled tasks to maintain data consistency
- Spring Boot Integration - Use SDK in modern Java frameworks
All example code is complete and runnable. You can adjust and extend based on your actual business requirements.
Next Steps
After learning these business scenarios, it's recommended to continue learning in this order:
-
📖 Quick Start Complete your first CRUD program in 5 minutes
-
📚 Core Concepts Deep dive into how the SDK works
-
📋 API Reference Browse the complete interface documentation
-
💡 Business Examples ← Current location Learn 5 real-world scenario implementations
-
🚀 Best Practices ← Recommended next step Master production environment optimization techniques
-
❓ FAQ Resolve questions during usage
Need help? Visit FAQ or contact service@lovrabet.com