# EJB与声明式编程：Java企业级开发的演进沉思

在Java企业级开发的技术演进长河中，EJB（Enterprise JavaBeans）作为早期企业级应用的核心架构，其声明式编程理念对后世产生了深远影响。本文将回顾EJB的声明式编程模型，探讨其设计思想及其在现代Java开发中的遗产。

## EJB声明式编程的核心思想

### 编程范式的转变

EJB代表了从命令式编程向声明式编程的重要转变。开发者不再需要编写冗长的基础设施代码，而是通过声明来表达业务逻辑的语义需求。

```java

// EJB 2.x 时代的会话Bean示例

@Stateless

public class BankServiceBean implements BankService {

    

    @EJB

    private AccountDAO accountDAO;

    

    @Resource

    private SessionContext sessionContext;

    

    // 声明式事务管理

    @TransactionAttribute(TransactionAttributeType.REQUIRED)

    public void transferFunds(String fromAccount, String toAccount, BigDecimal amount) {

        try {

            Account from = accountDAO.findByNumber(fromAccount);

            Account to = accountDAO.findByNumber(toAccount);

            

            from.debit(amount);

            to.credit(amount);

            

            accountDAO.update(from);

            accountDAO.update(to);

            

        } catch (InsufficientFundsException e) {

            sessionContext.setRollbackOnly();

            throw new BankingException("转账失败: 余额不足", e);

        }

    }

    

    // 声明式安全检查

    @RolesAllowed({"TELLER", "MANAGER"})

<"fbtv.jiebaobifen.com">

<"cwmd.nbazhib.com">

<"vanu.nbazhib.com">

    public Account getAccountDetails(String accountNumber) {

        return accountDAO.findByNumber(accountNumber);

    }

}

```

## EJB架构的声明式特性

### 1. 声明式事务管理

EJB通过元数据声明事务边界，将开发者从复杂的事务API中解放出来。

```java

// EJB 3.x 声明式事务示例

@Stateless

@TransactionManagement(TransactionManagementType.CONTAINER)

public class OrderProcessingBean implements OrderProcessing {

    

    @PersistenceContext

    private EntityManager entityManager;

    

    // 容器管理的事务

    @TransactionAttribute(TransactionAttributeType.REQUIRED)

    public void processOrder(Order order) {

        // 在现有事务中执行

        entityManager.persist(order);

        updateInventory(order.getItems());

        processPayment(order);

    }

    

    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)

    public void updateInventory(List<OrderItem> items) {

        // 在新事务中执行

        for (OrderItem item : items) {

            Inventory inventory = entityManager.find(Inventory.class, item.getProductId());

            inventory.reduceStock(item.getQuantity());

            entityManager.merge(inventory);

        }

    }

    

    @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)

    public OrderStatus checkOrderStatus(Long orderId) {

<"ztqc.nbazhib.com">

<"jpsv.nbazhib.com">

<"cftp.nbazhib.com">

        // 不在事务中执行

        return entityManager.find(Order.class, orderId).getStatus();

    }

    

    // 声明式超时设置

    @AccessTimeout(value = 30, unit = TimeUnit.MINUTES)

    public void batchProcessOrders(List<Order> orders) {

        for (Order order : orders) {

            processOrder(order);

        }

    }

}

```

### 2. 声明式安全控制

EJB通过注解声明安全约束，将安全逻辑与业务逻辑解耦。

```java

@Stateless

public class HRServiceBean implements HRService {

    

    // 基于角色的访问控制

    @RolesAllowed("HR_MANAGER")

    public void hireEmployee(Employee employee) {

        // 只有HR经理可以调用此方法

        persistEmployee(employee);

        setupBenefits(employee);

        notifyDepartment(employee);

    }

    

    @PermitAll

    public Employee getEmployeeInfo(Long employeeId) {

        // 所有认证用户都可以访问

        return findEmployee(employeeId);

    }

    

    @DenyAll

    public void internalAudit() {

        // 禁止所有访问

        // 只能通过内部机制调用

    }

    

    @RunAs("SYSTEM_ADMIN")

    public void systemMaintenance() {

        // 以系统管理员身份运行

        performMaintenanceTasks();

    }

    

    // 自定义安全检查

    public void updateSalary(@AllowedParameter("MANAGER") Long employeeId, 

                           BigDecimal newSalary) {

        // 参数级别的安全检查

        Employee employee = findEmployee(employeeId);

        employee.setSalary(newSalary);

        updateEmployee(employee);

<"lulz.nbazhib.com">

<"uzek.nbazhib.com">

<"hdwp.nbazhib.com">

    }

}

```

## EJB到Spring的演进

### 设计理念的传承与革新

EJB的声明式编程思想在Spring框架中得到了继承和发展，但实现方式更加轻量级和灵活。

```java

// Spring的声明式事务管理 - 继承EJB理念但更简洁

@Service

@Transactional

public class BankService {

    

    @Autowired

    private AccountRepository accountRepository;

    

    @Transactional(propagation = Propagation.REQUIRED)

    public void transferFunds(String fromAccount, String toAccount, BigDecimal amount) {

        Account from = accountRepository.findByAccountNumber(fromAccount);

        Account to = accountRepository.findByAccountNumber(toAccount);

        

        from.debit(amount);

        to.credit(amount);

        

        accountRepository.save(from);

        accountRepository.save(to);

    }

    

    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)

    public Account getAccountDetails(String accountNumber) {

        return accountRepository.findByAccountNumber(accountNumber);

    }

    

    // Spring的声明式重试机制

    @Retryable(value = {OptimisticLockingFailureException.class}, 

               maxAttempts = 3, 

               backoff = @Backoff(delay = 1000))

    public void processWithRetry(Order order) {

        // 在乐观锁异常时自动重试

        processOrder(order);

    }

    

    // 声明式缓存

<"atnt.nbazhib.com">

<"ldut.nbazhib.com">

<"vomd.nbazhib.com">

    @Cacheable(value = "accounts", key = "#accountNumber")

    public Account getAccount(String accountNumber) {

        return accountRepository.findByAccountNumber(accountNumber);

    }

}

```

## 现代声明式编程实践

### 1. 响应式编程中的声明式风格

```java

// 现代响应式编程延续了声明式思想

@Service

public class ReactiveOrderService {

    

    @Autowired

    private ReactiveOrderRepository orderRepository;

    

    // 声明式响应式流处理

    @Transactional

    public Mono<Order> processOrderReactive(Order order) {

        return orderRepository.save(order)

            .doOnNext(this::validateOrder)

            .flatMap(this::reserveInventory)

            .flatMap(this::processPayment)

            .doOnSuccess(this::sendConfirmation)

            .doOnError(error -> log.error("订单处理失败", error))

            .retryWhen(Retry.backoff(3, Duration.ofSeconds(1)));

    }

    

    // 声明式背压控制

    @BackpressureBuffer(size = 1000, strategy = BufferOverflowStrategy.DROP_OLDEST)

    public Flux<Order> streamOrders(LocalDateTime fromDate) {

        return orderRepository.findByCreatedDateAfter(fromDate)

            .delayElements(Duration.ofMillis(100)) // 控制流速

            .onBackpressureDrop(order -> 

                log.warn("订单被丢弃: {}", order.getId()));

    }

}

```

### 2. 注解驱动的声明式配置

```java

// 现代Java中的声明式配置

@Configuration

@EnableTransactionManagement

@EnableCaching

@EnableAsync

@EnableRetry

<"vymx.nbazhib.com">

<"nrch.nbazhib.com">

<"jwgo.nbazhib.com">

public class AppConfig {

    

    @Bean

    @ConfigurationProperties(prefix = "datasource")

    public DataSource dataSource() {

        return DataSourceBuilder.create().build();

    }

    

    @Bean

    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();

        em.setDataSource(dataSource());

        em.setPackagesToScan("com.example.entity");

        return em;

    }

}

// 声明式REST客户端

@FeignClient(name = "inventory-service", 

             url = "${inventory.service.url}",

             configuration = FeignConfig.class)

public interface InventoryServiceClient {

    

    @PostMapping("/api/inventory/reserve")

    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))

    ResponseEntity<InventoryReservation> reserveItem(

        @RequestBody ReserveRequest request);

    

    @GetMapping("/api/inventory/{productId}")

    @Cacheable("inventory")

    ResponseEntity<InventoryInfo> getInventory(@PathVariable String productId);

}

// 声明式API文档

@RestController

@RequestMapping("/api/orders")

@Tag(name = "订单 管理", description = "订单相关操作")

public class OrderController {

    

    @PostMapping

    @Operation(summary = "创建订单", description = "创建新的客户订单")

    @ApiResponse(responseCode = "201", description = "订单创建成功")

    @ApiResponse(responseCode = "400", description = "请求参数无效")

    public ResponseEntity<Order> createOrder(

            @RequestBody @Valid CreateOrderRequest request) {

        Order order = orderService.createOrder(request);

        return ResponseEntity.status(201).body(order);

    }

}

```

## 声明式编程的哲学思考

### 关注点分离的实现

```java

// 业务逻辑与横切关注点的分离

@Service

// 声明式事务边界

@Transactional

// 声明式安全控制  

@PreAuthorize("hasRole('USER')")

// 声明式日志记录

@Slf4j

// 声明式性能监控

@Timed(value = "order.service", description = "订单服务指标")

public class OrderService {

<"lqfx.nbazhib.com">

<"cvur.nbazhib.com">

<"gjyj.nbazhib.com">

    

    // 纯业务逻辑 - 无需关心事务、安全、日志等基础设施

    public Order createOrder(OrderRequest request) {

        Customer customer = findCustomer(request.getCustomerId());

        validateCustomer(customer);

        

        Order order = buildOrder(request, customer);

        calculateTotals(order);

        applyDiscounts(order);

        

        return saveOrder(order);

    }

    

    // 声明式异常处理

    @ExceptionHandler(InventoryException.class)

    @ResponseStatus(HttpStatus.CONFLICT)

    public ErrorResponse handleInventoryError(InventoryException ex) {

        return new ErrorResponse("INVENTORY_ERROR", ex.getMessage());

    }

}

```

### 领域特定语言（DSL）的声明式表达

```java

// 现代声明式DSL示例

@Component

public class BusinessRuleEngine {

    

    // 声明式业务规则

    @Rule(name = "高风险订单检查")

    @Priority(1)

    @Condition("order.amount > 10000 && customer.riskLevel == 'HIGH'")

    @Action("order.setStatus('REQUIRES_MANAGER_APPROVAL')")

    public void checkHighRiskOrder(Order order, Customer customer) {

        // 规则逻辑由框架自动执行

    }

    

    @Rule(name = "VIP客户折扣")

    @Condition("customer.type == 'VIP' && order.amount > 5000")

    @Action("order.applyDiscount(0.1)")

    public void applyVipDiscount(Order order, Customer customer) {

        // 声明式折扣应用

    }

}

// 声明式工作流定义

@Workflow(name = "订单处理流程", version = "1.0")

public class OrderProcessingWorkflow {

    

    @Step(name = "验证订单", order = 1)

    @Retryable(maxAttempts = 3)

    public ValidationResult validateOrder(Order order) {

        return validator.validate(order);

    }

    

    @Step(name = "库存预留", order = 2)

    @Async

    @Timeout(duration = 30, unit = TimeUnit.SECONDS)

    public ReservationResult reserveInventory(Order order) {

        return inventoryService.reserve(order.getItems());

    }

    

    @Step(name = "支付处理", order = 3)

    @Compensatable(compensationMethod = "cancelPayment")

    public PaymentResult processPayment(Order order) {

        return paymentService.process(order);

<"fnif.nbazhib.com">

<"lffv.nbazhib.com">

<"rjhy.nbazhib.com">

    }

    

    // 声明式补偿操作

    public void cancelPayment(PaymentResult result) {

        paymentService.cancel(result.getTransactionId());

    }

}

```

## 技术演进的启示

### EJB遗产的现代价值

EJB的声明式编程理念虽然在具体实现上已被更轻量级的技术取代，但其核心思想——通过声明来表达意图而非控制过程——在现代Java开发中依然具有重要价值。

```java

// 现代微服务中的声明式模式

@RestController

@RefreshScope  // 声明式配置更新

@CircuitBreaker(name = "inventoryService", fallbackMethod = "fallbackInventory")

@RateLimiter(name = "orderService")

@Bulkhead(name = "orderProcessing")

public class OrderController {

    

    @PostMapping("/orders")

    @DistributedLock(lockName = "order_#{#request.customerId}")

    public ResponseEntity<Order> createOrder(@RequestBody @Valid OrderRequest request) {

        // 方法体专注于业务逻辑

        // 横切关注点通过声明处理

        Order order = orderService.createOrder(request);

        return ResponseEntity.ok(order);

    }

    

    // 声明式降级处理

    public ResponseEntity<Order> fallbackInventory(OrderRequest request, Exception ex) {

        log.warn("库存服务降级: {}", ex.getMessage());

        return ResponseEntity.status(503)

            .body(Order.fallbackOrder(request));

    }

}

```

## 总结

从EJB到现代Java框架，声明式编程的演进体现了软件开发范式的深刻变迁：

1. **关注点分离**：将业务逻辑与基础设施关注点解耦

2. **意图导向**：通过声明表达"做什么"而非"怎么做"

3. **架构演进**：从重量级容器到轻量级框架，理念得以传承

4. **现代实践**：在云原生、微服务时代继续发挥价值

EJB的声明式编程思想为Java企业级开发奠定了重要基础，其核心理念在现代技术栈中得以延续和发展。理解这一技术演进历程，有助于我们更好地把握现代Java开发的设计哲学和发展方向。