# 用户画像数据模型
CREATE TABLE fgedu_user_profile (
user_id STRING,
name STRING,
age INT,
gender STRING,
city STRING,
tags ARRAY<STRING>,
update_time BIGINT
)
STORED BY ‘org.apache.hadoop.hive.hbase.HBaseStorageHandler’
WITH SERDEPROPERTIES (
‘hbase.columns.mapping’ = ‘:key,info:name,info:age,info:gender,info:city,profile:tags,profile:update_time’
)
TBLPROPERTIES (‘hbase.table.name’ = ‘fgedu_user_profile’);

# HBase查询实现
public class HBaseTemplate {

private Connection connection;

public UserProfile queryUserProfile(String userId) {
try (Table table = connection.getTable(TableName.valueOf(“fgedu_user_profile”))) {
Get get = new Get(Bytes.toBytes(userId));
Result result = table.get(get);

if (result.isEmpty()) {
return null;
}

UserProfile profile = new UserProfile();
profile.setUserId(userId);
profile.setName(Bytes.toString(result.getValue(Bytes.toBytes(“info”), Bytes.toBytes(“name”))));
profile.setAge(Bytes.toInt(result.getValue(Bytes.toBytes(“info”), Bytes.toBytes(“age”))));
profile.setGender(Bytes.toString(result.getValue(Bytes.toBytes(“info”), Bytes.toBytes(“gender”))));
profile.setCity(Bytes.toString(result.getValue(Bytes.toBytes(“info”), Bytes.toBytes(“city”))));

return profile;
} catch (IOException e) {
throw new RuntimeException(“HBase query error”, e);
}
}
}

# API测试
$ curl -X GET http://api.fgedu.net.cn/api/v1/user/profile/fgedu001 \
-H “Authorization: Bearer your-token-here”

{
“userId”: “fgedu001”,
“name”: “风哥”,
“age”: 28,
“gender”: “男”,
“city”: “北京”,
“tags”: [“大数据”, “Java”, “架构师”],
“updateTime”: 1712345678901
}

# 性能测试
$ ab -n 10000 -c 100 http://api.fgedu.net.cn/api/v1/user/profile/fgedu001

Concurrency Level: 100
Time taken for tests: 10.567 seconds
Complete requests: 10000
Failed requests: 0
Requests per second: 946.34 [#/sec] (mean)
Time per request: 105.670 [ms] (mean)
Time per request: 1.057 [ms] (mean, across all concurrent requests)
Transfer rate: 256.78 [Kbytes/sec] received

# ClickHouse实时指标表
CREATE TABLE fgedu_realtime_metrics (
dt Date,
ts DateTime,
metric_name String,
metric_value Float64,
dimension1 String,
dimension2 String,
dimension3 String
)
ENGINE = MergeTree()
PARTITION BY dt
ORDER BY (metric_name, ts)
SETTINGS index_granularity = 8192;

# 实时指标查询服务
@RestController
@RequestMapping(“/api/v1/metrics”)
public class MetricsController {

@Autowired
private MetricsService metricsService;

@GetMapping(“/query”)
public ResponseEntity<List<MetricData>> queryMetrics(
@RequestParam String metricName,
@RequestParam String startTime,
@RequestParam String endTime,
@RequestParam(required = false) String dimension) {

List<MetricData> data = metricsService.queryMetrics(
metricName, startTime, endTime, dimension);
return ResponseEntity.ok(data);
}
}

@Service
public class MetricsService {

@Autowired
private JdbcTemplate clickHouseJdbcTemplate;

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public List<MetricData> queryMetrics(String metricName,
String startTime, String endTime, String dimension) {

String cacheKey = String.format(“metrics:%s:%s:%s:%s”,
metricName, startTime, endTime, dimension);

@SuppressWarnings(“unchecked”)
List<MetricData> cachedData = (List<MetricData>) redisTemplate.opsForValue().get(cacheKey);
if (cachedData != null) {
return cachedData;
}

String sql = “SELECT ts, metric_value FROM fgedu_realtime_metrics ” +
“WHERE metric_name = ? AND ts >= ? AND ts <= ?”;

if (dimension != null) {
sql += ” AND dimension1 = ?”;
}

List<MetricData> data = clickHouseJdbcTemplate.query(sql,
(rs, rowNum) -> {
MetricData md = new MetricData();
md.setTimestamp(rs.getTimestamp(“ts”).getTime());
md.setValue(rs.getDouble(“metric_value”));
return md;
},
metricName, startTime, endTime);

redisTemplate.opsForValue().set(cacheKey, data, 5, TimeUnit.MINUTES);

return data;
}
}

# 查询示例
$ curl -X GET “http://api.fgedu.net.cn/api/v1/metrics/query?metricName=pv&startTime=2024-04-01%2000:00:00&endTime=2024-04-08%2023:59:59” \
-H “Authorization: Bearer your-token-here”

[
{“timestamp”: 1711929600000, “value”: 1024567},
{“timestamp”: 1712016000000, “value”: 1156789},
{“timestamp”: 1712102400000, “value”: 987654}
]

# 引入Actuator依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

# application.yml配置
management:
endpoints:
web:
exposure:
include: health,info,prometheus,metrics
metrics:
tags:
application: ${spring.application.name}
export:
prometheus:
enabled: true

# Prometheus配置
global:
scrape_interval: 15s
evaluation_interval: 15s

scrape_configs:
– job_name: ‘fgedu-data-service’
metrics_path: ‘/actuator/prometheus’
static_configs:
– targets: [‘192.168.1.100:8080’, ‘192.168.1.101:8080’]
– job_name: ‘redis’
static_configs:
– targets: [‘192.168.1.100:9121’]

# 告警规则
groups:
– name: service_alerts
rules:
– alert: ServiceDown
expr: up == 0
for: 1m
labels:
severity: critical
annotations:
summary: “Instance {{ $labels.instance }} down”
description: “{{ $labels.instance }} of job {{ $labels.job }} has been down for more than 1 minute.”

– alert: HighErrorRate
expr: rate(http_server_requests_seconds_count{status=~”5..”}[5m]) / rate(http_server_requests_seconds_count[5m]) > 0.01
for: 5m
labels:
severity: warning
annotations:
summary: “High error rate on {{ $labels.instance }}”
description: “Error rate is {{ $value | humanizePercentage }} on {{ $labels.instance }}”

– alert: HighResponseTime
expr: histogram_quantile(0.99, rate(http_server_requests_seconds_bucket[5m])) > 1
for: 5m
labels:
severity: warning
annotations:
summary: “High response time on {{ $labels.instance }}”
description: “P99 response time is {{ $value }}s on {{ $labels.instance }}”

# Grafana Dashboard配置
# 导入JVM Micrometer Dashboard
# 导入Spring Boot Statistics Dashboard
# 自定义关键指标面板：QPS、响应时间、错误率、缓存命中率