Java后端-JavaEE-Jakarta EE 9+ 现代化与云原生转型-11

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

<!-- Jakarta EE 10 依赖（Tomcat 10+ / WildFly 27+） -->
<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.0.0</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>jakarta.persistence</groupId>
    <artifactId>jakarta.persistence-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import org.eclipse.microprofile.config.Config;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import jakarta.inject.Inject;

@ApplicationScoped
public class ProductService {
    
    // 方式1：字段注入
    @Inject
    @ConfigProperty(name = "products.cache.enabled", defaultValue = "true")
    private boolean cacheEnabled;
    
    // 方式2：构造方法注入
    @Inject
    public ProductService(@ConfigProperty(name = "products.max.size") int maxSize) {
        this.maxSize = maxSize;
    }
    
    // 方式3：通过 Config API 获取
    @Inject
    private Config config;
    
    public String getDatabaseUrl() {
        return config.getValue("db.url", String.class);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

mp:
  config:
    profile: dev

products:
  cacheEnabled: true
  maxSize: 100

db:
  url: jdbc:mysql://localhost:3306/mydb

health:
  liveness:
    path: /health/live
  readiness:
    path: /health/ready

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import org.eclipse.microprofile.health.HealthCheck;
import org.eclipse.microprofile.health.HealthCheckResponse;
import org.eclipse.microprofile.health.Liveness;
import org.eclipse.microprofile.health.Readiness;
import jakarta.enterprise.context.ApplicationScoped;

// 存活检查：应用是否还在运行
@Liveness
@ApplicationScoped
public class LivenessCheck implements HealthCheck {
    
    @Override
    public HealthCheckResponse call() {
        return HealthCheckResponse.named("app-liveness")
                .up()  // 正常运行
                .build();
    }
}

// 就绪检查：应用是否可以接收请求
@Readiness
@ApplicationScoped
public class ReadinessCheck implements HealthCheck {
    
    @Inject
    private DatabaseService dbService;
    
    @Override
    public HealthCheckResponse call() {
        boolean dbReady = dbService.isConnected();
        return HealthCheckResponse.named("db-readiness")
                .status(dbReady)
                .withData("db.connected", dbReady)
                .build();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import org.eclipse.microprofile.faulttolerance.Retry;
import org.eclipse.microprofile.faulttolerance.Timeout;
import org.eclipse.microprofile.faulttolerance.Fallback;
import org.eclipse.microprofile.faulttolerance.CircuitBreaker;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.List;

@ApplicationScoped
public class ProductService {
    
    // 1. 重试 + 超时 + 回退
    @Retry(maxRetries = 3, delay = 1000, maxDuration = 5000)
    @Timeout(2000)
    @Fallback(fallbackMethod = "fallbackProducts")
    public List<Product> getAllProducts() {
        return fetchFromDatabase();
    }
    
    public List<Product> fallbackProducts() {
        return List.of(new Product("default", "Fallback product"));
    }
    
    // 2. 熔断器
    @CircuitBreaker(
        requestVolumeThreshold = 10,   // 10次请求后开始统计
        failureRatio = 0.5,            // 失败率超过50%则打开
        delay = 5000,                  // 5秒后尝试半开
        successThreshold = 2           // 连续成功2次则关闭
    )
    public Product getProductById(Long id) {
        return externalService.fetchProduct(id);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// 1. 定义 REST 客户端接口
import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/api/users")
@RegisterRestClient(configKey = "user-service")
public interface UserServiceClient {
    
    @GET
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    User getUser(@PathParam("id") Long id);
    
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    List<User> getAllUsers();
}

// 2. 注入并使用客户端
@ApplicationScoped
public class OrderService {
    
    @Inject
    @RestClient
    private UserServiceClient userClient;
    
    public void processOrder(Order order) {
        User user = userClient.getUser(order.getUserId());
        // 处理订单...
    }
}

// 3. 配置文件（application.yaml）
user-service:
  mp-rest:
    url: http://user-service:8080
    connectTimeout: 5000
    readTimeout: 3000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import org.eclipse.microprofile.telemetry.Telemetry;
import jakarta.inject.Inject;

@ApplicationScoped
public class OrderProcessor {
    
    @Inject
    private Telemetry telemetry;
    
    public void process(Order order) {
        // Telemetry 自动注入追踪上下文
        // 所有下游调用自动关联追踪信息
        // ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;

@Path("/products")
public class ProductResource {
    
    @GET
    @Operation(summary = "获取所有产品", description = "返回产品列表")
    @APIResponse(responseCode = "200", description = "成功返回产品列表")
    public List<Product> listProducts() {
        // ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 使用 WildFly 基础镜像
FROM quay.io/wildfly/wildfly:latest

# 设置环境变量
ENV WILDFLY_USER=admin
ENV WILDFLY_PASS=admin123

# 复制部署包
COPY target/myapp.war /opt/jboss/wildfly/standalone/deployments/

# 复制自定义配置
COPY standalone.xml /opt/jboss/wildfly/standalone/configuration/

# 暴露端口
EXPOSE 8080 9990

# 启动 WildFly
CMD ["/opt/jboss/wildfly/bin/standalone.sh", "-b", "0.0.0.0", "-bmanagement", "0.0.0.0"]

1
2
3

docker build -t myapp:1.0.0 .
docker tag myapp:1.0.0 myregistry/myapp:1.0.0
docker push myregistry/myapp:1.0.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  labels:
    app: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myregistry/myapp:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: DB_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: username
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        # 存活探针（使用 MicroProfile Health 端点）
        livenessProbe:
          httpGet:
            path: /health/live
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        # 就绪探针
        readinessProbe:
          httpGet:
            path: /health/ready
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# ConfigMap（非敏感配置）
apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  application.yaml: |
    products:
      cacheEnabled: true
      maxSize: 100
    health:
      liveness:
        path: /health/live    

# Secret（敏感配置）
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  url: amRiYzpteXNxbDovL2RiOjMzMDYvbXlkYg==  # base64 编码
  username: cm9vdA==
  password: cGFzc3dvcmQ=

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

┌─────────────────────────────────────────────────────────────┐
│                    客户端（浏览器/API调用）                  │
└──────────────────────────┬──────────────────────────────────┘
                           │ HTTP/REST
                           ▼
┌─────────────────────────────────────────────────────────────┐
│              JAX-RS（资源层——REST API）                     │
│              @Path、@GET、@POST、@Produces                  │
└──────────────────────────┬──────────────────────────────────┘
                           │ @Inject
                           ▼
┌─────────────────────────────────────────────────────────────┐
│              CDI（业务层——依赖注入）                        │
│              @ApplicationScoped、@Inject、@Named            │
└──────────────────────────┬──────────────────────────────────┘
                           │ JPA
                           ▼
┌─────────────────────────────────────────────────────────────┐
│              JPA（持久化层——数据访问）                      │
│              @Entity、EntityManager、JPQL                   │
└──────────────────────────┬──────────────────────────────────┘
                           │ JDBC
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                      数据库（MySQL/PostgreSQL）              │
└─────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import jakarta.persistence.*;
import java.math.BigDecimal;

@Entity
@Table(name = "t_product")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    private BigDecimal price;
    
    private Integer stock;
    
    // getter/setter 省略
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import java.util.List;

@ApplicationScoped
public class ProductRepository {
    
    @PersistenceContext
    private EntityManager em;
    
    public List<Product> findAll() {
        return em.createQuery("SELECT p FROM Product p", Product.class)
                 .getResultList();
    }
    
    public Product findById(Long id) {
        return em.find(Product.class, id);
    }
    
    public Product save(Product product) {
        if (product.getId() == null) {
            em.persist(product);
            return product;
        }
        return em.merge(product);
    }
    
    public void delete(Long id) {
        Product product = findById(id);
        if (product != null) {
            em.remove(product);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import org.eclipse.microprofile.faulttolerance.Retry;
import org.eclipse.microprofile.faulttolerance.Timeout;
import org.eclipse.microprofile.faulttolerance.Fallback;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.List;

@ApplicationScoped
public class ProductService {
    
    @Inject
    private ProductRepository repository;
    
    @Inject
    @ConfigProperty(name = "products.cache.enabled", defaultValue = "true")
    private boolean cacheEnabled;
    
    @Retry(maxRetries = 3, delay = 1000)
    @Timeout(2000)
    @Fallback(fallbackMethod = "getDefaultProducts")
    public List<Product> getAllProducts() {
        return repository.findAll();
    }
    
    public List<Product> getDefaultProducts() {
        return List.of();
    }
    
    public Product getProduct(Long id) {
        return repository.findById(id);
    }
    
    public Product createProduct(Product product) {
        return repository.save(product);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
import java.util.List;

@Path("/api/products")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ProductResource {
    
    @Inject
    private ProductService productService;
    
    @GET
    @Operation(summary = "获取所有产品")
    public List<Product> listProducts() {
        return productService.getAllProducts();
    }
    
    @GET
    @Path("/{id}")
    @Operation(summary = "根据ID获取产品")
    @APIResponse(responseCode = "404", description = "产品不存在")
    public Response getProduct(@PathParam("id") Long id) {
        Product product = productService.getProduct(id);
        if (product == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        return Response.ok(product).build();
    }
    
    @POST
    @Operation(summary = "创建产品")
    @APIResponse(responseCode = "201", description = "创建成功")
    public Response createProduct(Product product) {
        Product created = productService.createProduct(product);
        return Response.status(Response.Status.CREATED)
                       .entity(created)
                       .build();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>product-service</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>
    
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <!-- Jakarta EE 10 Core -->
        <dependency>
            <groupId>jakarta.platform</groupId>
            <artifactId>jakarta.jakartaee-api</artifactId>
            <version>10.0.0</version>
            <scope>provided</scope>
        </dependency>
        
        <!-- MicroProfile 7.1 -->
        <dependency>
            <groupId>org.eclipse.microprofile</groupId>
            <artifactId>microprofile</artifactId>
            <version>7.1</version>
            <type>pom</type>
            <scope>provided</scope>
        </dependency>
        
        <!-- JPA 实现（Hibernate） -->
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.4.0.Final</version>
        </dependency>
        
        <!-- MySQL 驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.2.0</version>
        </dependency>
    </dependencies>
    
    <build>
        <finalName>product-service</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.4.0</version>
            </plugin>
        </plugins>
    </build>
</project>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

mp:
  config:
    profile: dev

products:
  cacheEnabled: true
  maxSize: 100

db:
  url: jdbc:mysql://db:3306/productdb
  username: product_user
  password: product_pass
  pool:
    maxSize: 10
    minIdle: 5

health:
  liveness:
    path: /health/live
  readiness:
    path: /health/ready

user-service:
  mp-rest:
    url: http://user-service:8080
    connectTimeout: 5000
    readTimeout: 3000

1
2
3
4
5
6
7

import jakarta.ws.rs.ApplicationPath;
import jakarta.ws.rs.core.Application;

@ApplicationPath("/api")
public class ProductApplication extends Application {
    // 自动扫描所有 @Path 资源
}

1

mvn clean package

1

docker build -t product-service:1.0.0 .

1
2
3

kubectl apply -f kubernetes/configmap.yaml
kubectl apply -f kubernetes/deployment.yaml
kubectl apply -f kubernetes/service.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 查看 Pod 状态
kubectl get pods

# 查看健康检查端点
kubectl port-forward pod/product-service-xxx 8080:8080
curl http://localhost:8080/health/live
curl http://localhost:8080/health/ready

# 调用 API
curl http://localhost:8080/api/products

1
2
3
4
5
6
7

传统 Java EE（单体 + 应用服务器）
    ↓
Jakarta EE（标准化 + 模块化）
    ↓
Jakarta EE + MicroProfile（微服务 + 云原生）
    ↓
Quarkus / Spring Boot（轻量级云原生运行时）