在 Kubernetes 高密度部署场景中，传统 Java 应用面临 “启动慢如龟、内存吃得多” 的致命问题：某电商的商品详情服务（Spring Boot 构建）启动需 12 秒，单实例内存占用超 512MB，导致大促期间需额外扩容 30% 实例应对流量峰值，资源成本激增 40%。而Quarkus+GraalVM的组合彻底颠覆了这一现状 —— 通过提前编译（AOT）将 Java 字节码转换为本地机器码，实现 “毫秒级启动、MB 级内存” 的突破。本文将从技术原理、开发实战、部署优化到成本控制，完整呈现原生 Java 的落地路径，助力企业打造极致性能的云原生应用。

一、原生 Java 核心：Quarkus 与 GraalVM 技术解析

1. 为什么需要原生 Java？传统 Java 的云原生困境

传统 Java 基于 JVM 的 “一次编译，到处运行” 模式，在云原生环境中暴露出三大核心缺陷：

  • 启动性能差：JVM 启动需经历类加载、字节码验证、JIT 编译等流程，简单 Spring Boot 应用启动耗时普遍超过 5 秒，复杂微服务甚至达 30 秒，无法适配 Serverless “按需启动” 场景；
  • 内存占用高：JVM 本身需占用数百 MB 内存，加上应用堆内存，单实例内存成本居高不下，K8s 高密度部署受限；
  • 资源利用率低：JIT 编译的动态优化特性在短生命周期的容器环境中无法充分发挥，反而造成 CPU 浪费。

GraalVM 的Native Image技术通过静态编译解决了这些问题：

  • 构建阶段完成类分析、依赖裁剪与机器码生成，运行时无需 JVM；
  • 启动时间从秒级压缩至毫秒级（通常；
  • 内存占用降低 5-10 倍，单实例可控制在 64MB 以内；
  • 生成独立可执行文件，镜像体积减小 70% 以上。

2. Quarkus：为原生 Java 而生的框架

Quarkus 并非替代 Spring Boot，而是专为云原生与 GraalVM 设计的 “超音速亚原子 Java 框架”，其核心优势体现在：

  • 编译时优化：将传统 Spring Boot 的运行时依赖注入、配置解析等工作前置到构建阶段，减少运行时开销；
  • 原生友好 API：提供 JAX-RS、CDI、Spring 兼容性等丰富扩展，开发者无需重构代码即可迁移；
  • 分层构建支持：同时支持 JVM 模式与 Native 模式，开发期用 JVM 调试，部署期用 Native 镜像；
  • 微镜像适配：生成的 Native 可执行文件可运行于轻量级容器（如 Alpine、Distroless），进一步缩减镜像体积。

3. Native Image 工作原理：从字节码到机器码的蜕变

GraalVM Native Image 的编译过程分为四个关键阶段，全程在构建环境完成，运行时无额外开销：

  1. 静态分析：通过 GraalVM 编译器扫描应用入口（main 方法），递归分析所有可达的类、方法与字段，标记未使用的 “死代码”；
  1. 堆快照：执行应用初始化逻辑（static 代码块、@PostConstruct 等），捕获初始化后的堆状态并序列化；
  1. 代码生成：将可达代码编译为目标平台的机器码（如 x86_64、ARM64），并嵌入堆快照；
  1. 优化与打包：执行死代码消除、方法内联、常量折叠等优化，最终打包为独立可执行文件（含所有依赖库）。

注意：静态分析的局限性导致反射、动态代理等动态特性需显式配置，Quarkus 通过扩展机制自动处理大部分场景，无需开发者手动适配。

二、实战入门：构建第一个 Quarkus 原生应用

1. 环境准备：GraalVM 与 Quarkus 工具链

1.1 安装 GraalVM

推荐使用 SDKMAN 管理 Java 版本，支持快速切换 JVM 与 GraalVM：



# 安装SDKMAN（Linux/macOS）


curl -s "https://get.sdkman.io" | bash


source "$HOME/.sdkman/bin/sdkman-init.sh"


# 安装GraalVM（Java 17版本）


sdk install java 22.3.r17-grl


# 切换至GraalVM


sdk use java 22.3.r17-grl


# 验证安装


java -version # 输出含"GraalVM"标识


# 安装Native Image工具


gu install native-image


1.2 安装 Quarkus CLI（可选）


Quarkus CLI 简化项目创建与构建流程：




# 安装Quarkus CLI


curl -Ls https://sh.jbang.dev | bash -s - app install --fresh --force quarkus@quarkusio


# 验证安装


quarkus --version


2. 创建 Quarkus 项目（商品库存服务）


以电商库存服务为例，实现库存查询、扣减等核心接口，同时支持 JVM 与 Native 模式。


2.1 初始化项目


使用 Maven 或 Quarkus CLI 创建项目，引入 REST、Redis、MySQL 等常用扩展：




# 方式1：Maven创建


mvn io.quarkus:quarkus-maven-plugin:3.14.0:create \


-DprojectGroupId=com.ecommerce \


-DprojectArtifactId=inventory-service \


-DclassName="com.ecommerce.inventory.InventoryResource" \


-Dpath="/inventory" \


-Dextensions="resteasy-reactive, redis-client, quarkus-jdbc-mysql, hibernate-orm-panache"


# 方式2：Quarkus CLI创建


quarkus create app com.ecommerce:inventory-service \


--class-name="com.ecommerce.inventory.InventoryResource" \


--path="/inventory" \


--extensions="resteasy-reactive, redis-client, quarkus-jdbc-mysql, hibernate-orm-panache"


2.2 核心代码实现


2.2.1 实体类与数据访问层


使用 Panache 简化 JPA 操作（Quarkus 对 Hibernate 的增强）：




// 库存实体类


@Entity


@Table(name = "product_inventory")


public class Inventory extends PanacheEntityBase {


@Id


@GeneratedValue(strategy = GenerationType.IDENTITY)


private Long id;


private Long productId; // 商品ID


private Integer quantity; // 库存数量


private LocalDateTime updateTime; // 更新时间


// getter/setter省略


}


// 数据访问接口（无需实现，Panache自动生成）


public interface InventoryRepository extends PanacheRepository<Inventory> {


// 按商品ID查询库存


Optional> findByProductId(Long productId);


}


2.2.2 业务逻辑层


实现库存扣减与缓存更新逻辑，适配高并发场景：




@ApplicationScoped


public class InventoryService {


@Inject


InventoryRepository inventoryRepository;


@Inject


RedisClient redisClient;


// 库存扣减（支持事务）


@Transactional


public boolean deductStock(Long productId, Integer count) {


// 1. 先查数据库（避免缓存穿透）


Optional inventoryOpt = inventoryRepository.findByProductId(productId);


if (inventoryOpt.isEmpty() || inventoryOpt.get().getQuantity() {


return false;


}


// 2. 扣减库存


Inventory inventory = inventoryOpt.get();


inventory.setQuantity(inventory.getQuantity() - count);


inventory.setUpdateTime(LocalDateTime.now());


inventoryRepository.persist(inventory);


// 3. 更新Redis缓存（失效策略）


redisClient.del(Arrays.asList("inventory:" + productId));


return true;


}


// 库存查询（缓存优先）


public Integer getStock(Long productId) {


String cacheKey = "inventory:" + productId;


// 1. 查Redis缓存


List = redisClient.get(Arrays.asList(cacheKey));


if (cacheResult != null && !cacheResult.isEmpty() && cacheResult.get(0) != null) {


return Integer.parseInt(cacheResult.get(0));


}


// 2. 查数据库并更新缓存


Optional<Inventory> inventoryOpt = inventoryRepository.findByProductId(productId);


Integer stock = inventoryOpt.map(Inventory::getQuantity).orElse(0);


redisClient.set(Arrays.asList(cacheKey, stock.toString(), "EX", "300")); // 缓存5分钟


return stock;


}


}


2.2.3 REST 接口层


暴露 HTTP 接口供外部调用：




@Path("/inventory")


public class InventoryResource {


@Inject


InventoryService inventoryService;


// 查询商品库存


@GET


@Path("/{productId}")


@Produces(MediaType.APPLICATION_JSON)


public Response getStock(@PathParam("productId") Long productId) {


Integer stock = inventoryService.getStock(productId);


return Response.ok(Map.of("productId", productId, "stock", stock)).build();


}


// 扣减商品库存


@POST


@Path("/deduct")


@Consumes(MediaType.APPLICATION_JSON)


@Produces(MediaType.APPLICATION_JSON)


public Response deductStock(StockDeductRequest request) {


boolean success = inventoryService.deductStock(request.getProductId(), request.getCount());


return Response.ok(Map.of("success", success)).build();


}


// 请求参数模型


public static class StockDeductRequest {


private Long productId;


private Integer count;


// getter/setter省略


}


}


3. 配置文件（application.properties）


Quarkus 支持多环境配置，通过%profile.前缀区分环境：




# 通用配置


quarkus.application.name=inventory-service


quarkus.http.port=8080


# 数据库配置（生产环境）


%prod.quarkus.datasource.db-kind=mysql


%prod.quarkus.datasource.username=${DB_USER:root}


%prod.quarkus.datasource.password=${DB_PASSWORD:123456}


%prod.quarkus.datasource.jdbc.url=jdbc:mysql://${DB_HOST:localhost}:${DB_PORT:3306}/ecommerce_inventory?useSSL=false&serverTimezone=UTC


# Hibernate配置


quarkus.hibernate-orm.database.generation=validate


quarkus.hibernate-orm.log.sql=true


# Redis配置


quarkus.redis.hosts=${REDIS_HOST:redis://localhost:6379}


quarkus.redis.password=${REDIS_PASSWORD:}


# Native模式配置


quarkus.native.enabled=true


quarkus.native.container-build=true # 支持Docker内构建（跨平台友好）


quarkus.native.native-image-xmx=4G # 分配构建内存（避免OOM）


quarkus.native.builder-image=quay.io/quarkus/ubi-quarkus-native-image:22.3-java17 # 构建镜像


4. 构建与运行：JVM 模式 vs Native 模式


4.1 构建命令




# 构建JVM模式Jar包


./mvnw package -DskipTests


# 构建Native镜像（本地构建，需GraalVM环境）


./mvnw package -Pnative -DskipTests


# 容器内构建（无需本地GraalVM，推荐CI/CD场景）


./mvnw package -Pnative -DskipTests -Dquarkus.native.container-build=true


4.2 运行对比




# JVM模式运行


java -jar target/quarkus-app/quarkus-run.jar


# Native模式运行


./target/inventory-service-1.0.0-runner


4.3 性能对比数据



 
  

   
    
指标

   
    
JVM 模式

   
    
Native 模式

   
    
优化幅度

  

  

   
    
启动时间

   
    
1.8 秒

   
    
0.023 秒

   
    
提升 98.7%

  

  

   
    
内存占用（空闲）

   
    
420MB

   
    
45MB

   
    
降低 89.3%

  

  

   
    
首次请求响应时间

   
    
350ms

   
    
45ms

   
    
降低 87.1%

  

  

   
    
镜像体积（Docker）

   
    
580MB

   
    
85MB

   
    
降低 85.3%

  

 



三、容器化与 K8s 部署：极致优化实战


1. 构建轻量级 Docker 镜像


Quarkus 推荐使用quarkus-micro-image作为基础镜像，体积仅 20MB 左右，比 Alpine 更轻量：




# 多阶段构建：阶段1构建Native镜像


FROM quay.io/quarkus/ubi-quarkus-native-image:22.3-java17 AS builder


WORKDIR /app


COPY pom.xml .


COPY src ./src


# 容器内构建Native镜像


RUN ./mvnw package -Pnative -DskipTests -Dquarkus.native.container-build=true


# 阶段2：运行镜像（使用Quarkus微镜像）


FROM quay.io/quarkus/quarkus-micro-image:2.0


WORKDIR /work


# 复制Native可执行文件


COPY --from=builder /app/target/*-runner /work/application


# 赋予执行权限


RUN chmod 775 /work


# 暴露端口


EXPOSE 8080


# 启动命令（直接运行可执行文件，无需Java）


CMD ["./application", "-Dquarkus.http.host=0.0.0.0"]


构建并推送镜像：




# 构建镜像


docker build -t harbor.ecommerce.com/ecommerce/inventory-service:v1.0 .


# 推送至私有仓库


docker push harbor.ecommerce.com/ecommerce/inventory-service:v1.0


2. K8s 资源配置优化


Native 镜像的低资源特性可实现 K8s 高密度部署，资源配置比传统 Java 应用缩减 80% 以上：


2.1 Deployment 配置（inventory-service-deployment.yaml）




apiVersion: apps/v1


kind: Deployment


metadata:


name: inventory-service


namespace: ecommerce


spec:


replicas: 3


selector:


matchLabels:


app: inventory-service


template:


metadata:


labels:


app: inventory-service


spec:


containers:


- name: inventory-service


image: harbor.ecommerce.com/ecommerce/inventory-service:v1.0


# 资源限制：仅为传统Java的1/5


resources:


requests:


cpu: "50m" # 50毫核（传统Java需200m+）


memory: "64Mi" # 64MB内存（传统Java需512Mi+）


limits:


cpu: "200m"


memory: "128Mi"


ports:


- containerPort: 8080


# 环境变量注入（敏感配置用Secret）


env:


- name: DB_HOST


valueFrom:


secretKeyRef:


name: ecommerce-db


key: host


- name: DB_PASSWORD


valueFrom:


secretKeyRef:


name: ecommerce-db


key: password


- name: REDIS_HOST


valueFrom:


configMapKeyRef:


name: ecommerce-redis


key: host


# 探针配置（Native模式启动快，探针延迟可大幅降低）


livenessProbe:


httpGet:


path: /q/health/live # Quarkus健康检查端点（默认/q/health）


port: 8080


initialDelaySeconds: 5 # 启动5秒后探测（传统Java需60秒+）


periodSeconds: 10


readinessProbe:


httpGet:


path: /q/health/ready


port: 8080


initialDelaySeconds: 3 # 启动3秒后探测


periodSeconds: 5


2.2 HPA 配置：基于请求量的精细化扩缩容


Native 镜像启动快（ms），可实现秒级扩缩容，适配电商大促等突发流量场景：




apiVersion: autoscaling/v2


kind: HorizontalPodAutoscaler


metadata:


name: inventory-service-hpa


namespace: ecommerce


spec:


scaleTargetRef:


apiVersion: apps/v1


kind: Deployment


name: inventory-service


minReplicas: 2


maxReplicas: 20 # 支持快速扩容至20副本


metrics:


- type: Resource


resource:


name: cpu


target:


type: Utilization


averageUtilization: 60 # CPU使用率超60%扩容


- type: Resource


resource:


name: memory


target:


type: Utilization


averageUtilization: 70 # 内存使用率超70%扩容


behavior:


scaleUp:


stabilizationWindowSeconds: 10 # 10秒内多次触发则合并扩容


policies:


- type: Percent


value: 50


periodSeconds: 60 # 每分钟最多扩容50%


3. 部署与验证




# 创建Secret存储数据库密码


kubectl create secret generic ecommerce-db -n ecommerce \


--from-literal=host=mysql-service \


--from-literal=password=123456


# 创建ConfigMap存储Redis地址


kubectl create configmap ecommerce-redis -n ecommerce \


--from-literal=host=redis://redis-service:6379


# 部署服务


kubectl apply -f inventory-service-deployment.yaml


kubectl apply -f inventory-service-hpa.yaml


# 查看Pod状态（启动时间秒）


kubectl get pods -n ecommerce -w


# 测试接口


curl http://inventory-service.ecommerce.svc.cluster.local:8080/inventory/1001


# 输出：{"productId":1001,"stock":250}


四、进阶特性：可观测性与动态配置


1. 可观测性集成：Metrics+Logs+Traces


Quarkus 原生支持 Micrometer、OpenTelemetry 等可观测性工具，配置与 Spring Boot 兼容：


1.1 引入依赖




etheus） -->


>


io.quarkus>


quarkus-micrometer-registry-prometheus>


<!-- 链路追踪（Jaeger） -->


>


io.quarkus>


quarkus-opentelemetry-exporter-otlp</artifactId>


us rye-health


#### 1.2 配置可观测性（application.properties）


```properties


# Metrics配置


quarkus.micrometer.export.prometheus.enabled=true


quarkus.micrometer.export.prometheus.path=/q/metrics


quarkus.micrometer.binder.http-client.enabled=true


quarkus.micrometer.binder.http-server.enabled=true


# 链路追踪配置


quarkus.opentelemetry.tracer.exporter.otlp.endpoint=${JAEGER_ENDPOINT:http://jaeger-collector:4317}


quarkus.opentelemetry.tracer.resource.attributes=service.name=inventory-service


quarkus.opentelemetry.tracer.sampler.parentbased_always_on.enabled=true


# 健康检查配置


quarkus.smallrye-health.root-path=/q/health


quarkus.smallrye-health.liveness-enabled=true


quarkus.smallrye-health.readiness-enabled=true


1.3 验证可观测性


    
 
  • Metrics 端点：curl http://-ip>:8080/q/metrics（可被 Prometheus 抓取）；
    • 



    
 
  • 健康检查：curl http://<pod-ip>:8080/q/health（返回 JSON 格式健康状态）；
    • 



    
 
  • 链路追踪：Jaeger UI 可查看完整调用链路，包含 Redis、MySQL 操作耗时。
    • 



2. 动态配置：适配云原生配置中心


Quarkus 支持 Nacos、Apollo 等配置中心，实现配置动态刷新无需重启服务：


2.1 集成 Nacos 配置中心




引入Nacos扩展 -->


<dependency>


<groupId>io.quarkus</groupId>


<artifactId>quarkus-nacos-config</artifactId>


</dependency>


2.2 配置 Nacos（application.properties）




# Nacos配置


quarkus.nacos.config.server-addr=${NACOS_ADDR:localhost:8848}


quarkus.nacos.config.namespace=prod


quarkus.nacos.config.group=ecommerce


quarkus.nacos.config.data-ids=inventory-service-prod.properties


quarkus.nacos.config.refresh-enabled=true # 开启动态刷新


2.3 注入动态配置




@ApplicationScoped


public class InventoryConfig {


// 注入Nacos中的动态配置，支持自动刷新


@ConfigProperty(name = "inventory.deduct.max-count", defaultValue = "10")


volatile Integer maxDeductCount;


public Integer getMaxDeductCount() {


return maxDeductCount;


}


}


// 业务中使用


@Path("/inventory")


public class InventoryResource {


@Inject


InventoryConfig inventoryConfig;


@POST


@Path("/deduct")


public Response deductStock(StockDeductRequest request) {


// 校验最大扣减数量（配置来自Nacos，动态更新）


if (request.getCount() > inventoryConfig.getMaxDeductCount()) {


return Response.status(400).entity(Map.of("msg", "单次最大扣减" + inventoryConfig.getMaxDeductCount() + "件")).build();


}


// ... 扣减逻辑


}


}


五、生产实践：问题解决与最佳实践


1. 常见问题与解决方案


1.1 反射 / 动态代理导致 Native 构建失败


GraalVM 静态分析无法识别反射调用，Quarkus 通过@RegisterForReflection注解自动处理：




// 对需要反射的类添加注解


@RegisterForReflection


public class OrderEvent {


private Long orderId;


private Long productId;


// getter/setter


}


1.2 第三方依赖不支持 Native 模式


优先选择 Quarkus 官方扩展（如quarkus-redis-client而非 Spring Data Redis），非官方依赖可通过native-image.properties配置：




# src/main/resources/META-INF/native-image/com.ecommerce/inventory-service/native-image.properties


Args = --initialize-at-run-time=com.xxx.thirdparty.UnsupportedClass


1.3 启动时出现 “类未找到” 错误


检查是否遗漏扩展依赖，例如使用 JPA 需引入quarkus-hibernate-orm-panache，而非传统 Hibernate 依赖。


2. 最佳实践总结


2.1 开发阶段


    
 
  • 优先使用 Quarkus 扩展：避免使用 Spring 生态中无 Quarkus 替代的组件（如 Spring Cloud Stream）；
    • 



    
 
  • 减少动态特性：尽量避免反射、动态代理、Class.forName 等动态操作，优先使用编译时注解；
    • 



    
 
  • 本地调试用 JVM 模式：Native 模式编译耗时较长（5-10 分钟），开发期用 JVM 模式加速迭代，上线前验证 Native 模式。
    • 



2.2 构建阶段


    
 
  • 使用容器化构建：CI/CD 流水线中采用quarkus.native.container-build=true，避免本地环境差异；
    • 



    
 
  • 分配足够构建资源：Native 构建需大量 CPU 与内存，建议配置 4 核 8G 以上构建机器；
    • 



    
 
  • 开启构建缓存：Maven/Gradle 缓存构建结果，二次构建可缩短至 1-2 分钟。
    • 



2.3 部署阶段


    
 
  • 采用微镜像部署：优先使用quarkus-micro-image，避免使用臃肿的 Ubuntu/CentOS 基础镜像；
    • 



    
 
  • 关闭不必要功能：禁用 JVM 相关功能（如 JMX），减少内存占用；
    • 



    
 
  • 精细化资源配置：根据压测结果设置资源 limits，避免资源浪费（通常 CPU00m，内存 < 128Mi）。
    • 



3. 成本优化案例：电商大促的资源节省


某电商将 3 个核心服务（库存、商品、支付回调）从 Spring Boot 迁移至 Quarkus Native：


    
 
  • 资源占用：单实例内存从 512MB 降至 45MB，CPU 从 200m 降至 50m；
    • 



    
 
  • 部署密度：K8s 节点单机部署实例数从 8 个提升至 40 个，密度提升 5 倍；
    • 



    
 
  • 大促成本：峰值期间所需节点数从 20 个降至 5 个，资源成本降低 75%；
    • 



    
 
  • 恢复速度：节点故障后服务恢复时间从 12 秒降至 0.5 秒，可用性提升 95%。
    • 



六、未来展望：原生 Java 的演进方向


Quarkus 与 GraalVM 的组合正在重塑 Java 的云原生地位，未来将向三个方向演进：


    
 
  1. Serverless 深度适配：Native 镜像的毫秒级启动特性完美适配 Serverless 场景，AWS Lambda、阿里云函数计算已原生支持 Quarkus；
    2. 



    
 
  1. 多语言融合：GraalVM 支持 Java、Python、JavaScript 等多语言混合编程，Quarkus 可作为多语言微服务的统一框架；
    2. 



    
 
  1. AI 原生集成：Quarkus 正开发 AI 扩展，支持将 TensorFlow 模型编译为 Native 代码，实现 AI 推理服务的极致性能。
    2. 



对于 Java 开发者而言，原生 Java 并非技术颠覆，而是云原生时代的必然选择 —— 它既保留了 Java 的生态优势，又解决了传统 JVM 的性能痛点。随着 Quarkus 4.0、GraalVM 24 的发布，原生 Java 的开发体验与兼容性将进一步提升，成为云原生应用的首选技术栈。


 
  

        # java
      
        # 云原生
      
        # 开发语言
      
  
 
 Logo 
腾讯云开发者社区
 
腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。
 
 
  
更多推荐
  
 
Elasticsearch复杂数据类型终极指南：从入门到精通
 
Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可
 
avatar 腾讯云开发者社区
 
 
终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路
 
Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。
 
avatar 腾讯云开发者社区
 
 
如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南
 
Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git
 
avatar 腾讯云开发者社区