【！！！！终极 Java 中间件实战课：从 0 到 1 构建亿级流量电商系统全链路解决方案！！！！保姆级教程---超细】

电商系统架构实战教程

1. 系统架构设计

1.1 系统模块划分

电商系统通常包含以下核心模块：

• 用户服务：用户注册、登录、信息管理
• 商品服务：商品管理、库存管理
• 订单服务：订单创建、支付、物流
• 营销服务：优惠券、促销活动
• 支付服务：对接第三方支付
• 网关服务：统一入口、权限校验
• 后台管理：运营管理界面

1.2 技术选型

• 开发语言：Java 11+
• 框架：Spring Boot 2.7+、Spring Cloud
• 注册中心：Nacos
• 配置中心：Nacos
• 网关：Spring Cloud Gateway
• 服务调用：OpenFeign
• 负载均衡：Ribbon
• 熔断限流：Sentinel
• 消息队列：RocketMQ
• 缓存：Redis
• 数据库：MySQL
• 搜索引擎：Elasticsearch
• 分布式事务：Seata

2. 环境搭建

2.1 开发环境准备

1. 安装JDK 11+
2. 安装Maven 3.6+
3. 安装IntelliJ IDEA
4. 安装Docker和Docker Compose

2.2 基础设施部署

使用Docker Compose部署基础中间件：

version: '3'
services:# Nacos服务注册与配置中心nacos:image: nacos/nacos-server:2.0.3container_name: nacosenvironment:MODE: standaloneports:- "8848:8848"- "9848:9848"- "9849:9849"volumes:- ./nacos/logs:/home/nacos/logs- ./nacos/init.d:/home/nacos/init.d# Redis缓存redis:image: redis:6.2.6container_name: redisports:- "6379:6379"volumes:- ./redis/data:/datacommand: redis-server --appendonly yes# MySQL数据库mysql:image: mysql:8.0.26container_name: mysqlenvironment:MYSQL_ROOT_PASSWORD: rootMYSQL_DATABASE: ecom_dbports:- "3306:3306"volumes:- ./mysql/data:/var/lib/mysql- ./mysql/init:/docker-entrypoint-initdb.d# RocketMQ消息队列rocketmq:image: rocketmqinc/rocketmq:4.9.2container_name: rocketmqports:- "9876:9876"- "10909:10909"- "10911:10911"command: sh mqnamesrv && sh mqbroker -n localhost:9876# Elasticsearch搜索引擎elasticsearch:image: elasticsearch:7.17.3container_name: elasticsearchenvironment:- discovery.type=single-node- ES_JAVA_OPTS=-Xms512m -Xmx512mports:- "9200:9200"- "9300:9300"volumes:- ./elasticsearch/data:/usr/share/elasticsearch/data# Kibana可视化工具kibana:image: kibana:7.17.3container_name: kibanaports:- "5601:5601"depends_on:- elasticsearch

3. 用户服务开发

3.1 创建Maven项目

首先创建一个基础的Maven项目作为父工程：

<!-- pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.ecommerce</groupId><artifactId>ecommerce-parent</artifactId><version>1.0.0</version><packaging>pom</packaging><modules><module>user-service</module><module>product-service</module><module>order-service</module><module>gateway-service</module></modules><properties><java.version>11</java.version><spring-boot.version>2.7.10</spring-boot.version><spring-cloud.version>2021.0.5</spring-cloud.version></properties><dependencyManagement><dependencies><!-- Spring Boot依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>${spring-boot.version}</version><type>pom</type><scope>import</scope></dependency><!-- Spring Cloud依赖 --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>${spring-cloud.version}</version><type>pom</type><scope>import</scope></dependency><!-- MyBatis依赖 --><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.3.1</version></dependency><!-- Nacos依赖 --><dependency><groupId>com.alibaba.nacos</groupId><artifactId>nacos-client</artifactId><version>2.0.3</version></dependency></dependencies></dependencyManagement>
</project>

3.2 创建用户服务模块

<!-- user-service/pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.ecommerce</groupId><artifactId>ecommerce-parent</artifactId><version>1.0.0</version></parent><artifactId>user-service</artifactId><dependencies><!-- Spring Boot Starter Web --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- Spring Boot Starter Data JPA --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><!-- MySQL驱动 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><!-- Nacos Discovery --><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId></dependency><!-- Sentinel --><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-sentinel</artifactId></dependency><!-- Lombok --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><!-- Redis --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency></dependencies>
</project>

3.3 配置文件

# user-service/src/main/resources/application.yml
spring:application:name: user-service  # 服务名称cloud:nacos:discovery:server-addr: localhost:8848  # Nacos服务地址datasource:url: jdbc:mysql://localhost:3306/ecom_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTCusername: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driverredis:host: localhostport: 6379server:port: 8081  # 服务端口mybatis:mapper-locations: classpath:mapper/*.xml  # MyBatis映射文件位置type-aliases-package: com.ecommerce.user.entity  # 实体类包路径

3.4 实体类与数据库设计

// user-service/src/main/java/com/ecommerce/user/entity/User.java
package com.ecommerce.user.entity;import lombok.Data;import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;/*** 用户实体类*/
@Data
@Entity
@Table(name = "t_user")
public class User implements Serializable {private static final long serialVersionUID = 1L;@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;  // 用户ID@Column(nullable = false, unique = true)private String username;  // 用户名@Column(nullable = false)private String password;  // 密码（加密存储）@Column(nullable = false)private String phone;  // 手机号private String email;  // 邮箱private Integer status;  // 用户状态：0-禁用，1-正常@Temporal(TemporalType.TIMESTAMP)@Column(nullable = false)private Date createTime;  // 创建时间@Temporal(TemporalType.TIMESTAMP)@Column(nullable = false)private Date updateTime;  // 更新时间
}

3.5 DAO层实现

// user-service/src/main/java/com/ecommerce/user/dao/UserDao.java
package com.ecommerce.user.dao;import com.ecommerce.user.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;/*** 用户DAO接口*/
public interface UserDao extends JpaRepository<User, Long> {/*** 根据用户名查找用户* @param username 用户名* @return 用户实体*/User findByUsername(String username);/*** 根据手机号查找用户* @param phone 手机号* @return 用户实体*/User findByPhone(String phone);
}

3.6 Service层实现

// user-service/src/main/java/com/ecommerce/user/service/UserService.java
package com.ecommerce.user.service;import com.ecommerce.user.entity.User;
import com.ecommerce.user.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;import java.util.Date;
import java.util.Optional;/*** 用户服务实现*/
@Service
public class UserService {@Autowiredprivate UserDao userDao;/*** 用户注册* @param user 用户信息* @return 注册结果*/@Transactionalpublic User register(User user) {// 检查用户名是否已存在User existUser = userDao.findByUsername(user.getUsername());if (existUser != null) {throw new RuntimeException("用户名已存在");}// 检查手机号是否已存在existUser = userDao.findByPhone(user.getPhone());if (existUser != null) {throw new RuntimeException("手机号已注册");}// 设置默认值user.setStatus(1);  // 默认启用user.setCreateTime(new Date());user.setUpdateTime(new Date());// 密码加密（实际项目中应该使用加密算法）user.setPassword("{noop}" + user.getPassword());// 保存用户信息return userDao.save(user);}/*** 用户登录* @param username 用户名* @param password 密码* @return 用户信息*/public User login(String username, String password) {User user = userDao.findByUsername(username);if (user == null) {throw new RuntimeException("用户不存在");}// 验证密码（实际项目中应该使用加密比较）if (!user.getPassword().equals("{noop}" + password)) {throw new RuntimeException("密码错误");}return user;}/*** 根据ID获取用户信息* @param id 用户ID* @return 用户信息*/public User getById(Long id) {Optional<User> userOptional = userDao.findById(id);return userOptional.orElse(null);}
}

3.7 Controller层实现

// user-service/src/main/java/com/ecommerce/user/controller/UserController.java
package com.ecommerce.user.controller;import com.ecommerce.user.entity.User;
import com.ecommerce.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;import java.util.HashMap;
import java.util.Map;/*** 用户控制器*/
@RestController
@RequestMapping("/api/user")
public class UserController {@Autowiredprivate UserService userService;/*** 用户注册接口* @param user 用户信息* @return 注册结果*/@PostMapping("/register")public Map<String, Object> register(@RequestBody User user) {Map<String, Object> result = new HashMap<>();try {User newUser = userService.register(user);result.put("success", true);result.put("message", "注册成功");result.put("data", newUser);} catch (Exception e) {result.put("success", false);result.put("message", e.getMessage());}return result;}/*** 用户登录接口* @param username 用户名* @param password 密码* @return 登录结果*/@PostMapping("/login")public Map<String, Object> login(@RequestParam String username, @RequestParam String password) {Map<String, Object> result = new HashMap<>();try {User user = userService.login(username, password);result.put("success", true);result.put("message", "登录成功");result.put("data", user);// 实际项目中这里应该生成Token返回给客户端// String token = jwtService.generateToken(user);// result.put("token", token);} catch (Exception e) {result.put("success", false);result.put("message", e.getMessage());}return result;}/*** 获取用户信息接口* @param id 用户ID* @return 用户信息*/@GetMapping("/{id}")public Map<String, Object> getById(@PathVariable Long id) {Map<String, Object> result = new HashMap<>();try {User user = userService.getById(id);if (user != null) {result.put("success", true);result.put("data", user);} else {result.put("success", false);result.put("message", "用户不存在");}} catch (Exception e) {result.put("success", false);result.put("message", e.getMessage());}return result;}
}

3.8 主应用类

// user-service/src/main/java/com/ecommerce/user/UserServiceApplication.java
package com.ecommerce.user;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;/*** 用户服务启动类*/
@SpringBootApplication
@EnableDiscoveryClient  // 启用服务发现
public class UserServiceApplication {public static void main(String[] args) {SpringApplication.run(UserServiceApplication.class, args);}
}

4. 商品服务开发

商品服务负责管理商品信息和库存，下面是核心代码实现：

// product-service/src/main/java/com/ecommerce/product/entity/Product.java
package com.ecommerce.product.entity;import lombok.Data;import javax.persistence.*;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;/*** 商品实体类*/
@Data
@Entity
@Table(name = "t_product")
public class Product implements Serializable {private static final long serialVersionUID = 1L;@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;  // 商品ID@Column(nullable = false)private String name;  // 商品名称@Column(nullable = false)private String description;  // 商品描述@Column(nullable = false)private BigDecimal price;  // 商品价格@Column(nullable = false)private Integer stock;  // 库存数量@Column(nullable = false)private Integer status;  // 商品状态：0-下架，1-上架@Column(nullable = false)private String imageUrl;  // 商品图片URL@Temporal(TemporalType.TIMESTAMP)@Column(nullable = false)private Date createTime;  // 创建时间@Temporal(TemporalType.TIMESTAMP)@Column(nullable = false)private Date updateTime;  // 更新时间
}

// product-service/src/main/java/com/ecommerce/product/service/ProductService.java
package com.ecommerce.product.service;import com.ecommerce.product.entity.Product;
import com.ecommerce.product.dao.ProductDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;/*** 商品服务实现*/
@Service
public class ProductService {@Autowiredprivate ProductDao productDao;@Autowiredprivate RedisTemplate<String, Object> redisTemplate;/*** 获取商品列表* @return 商品列表*/public List<Product> listProducts() {// 优先从缓存获取String key = "product:list";List<Product> productList = (List<Product>) redisTemplate.opsForValue().get(key);if (productList == null) {// 缓存未命中，从数据库获取productList = productDao.findAll();// 放入缓存，设置过期时间10分钟redisTemplate.opsForValue().set(key, productList, 10, TimeUnit.MINUTES);}return productList;}/*** 根据ID获取商品* @param id 商品ID* @return 商品信息*/public Product getProductById(Long id) {// 优先从缓存获取String key = "product:" + id;Product product = (Product) redisTemplate.opsForValue().get(key);if (product == null) {// 缓存未命中，从数据库获取Optional<Product> productOptional = productDao.findById(id);if (productOptional.isPresent()) {product = productOptional.get();// 放入缓存，设置过期时间5分钟redisTemplate.opsForValue().set(key, product, 5, TimeUnit.MINUTES);}}return product;}/*** 扣减库存* @param productId 商品ID* @param quantity 扣减数量* @return 扣减结果*/@Transactionalpublic boolean reduceStock(Long productId, Integer quantity) {// 检查库存Product product = getProductById(productId);if (product == null || product.getStock() < quantity) {return false;}// 扣减库存int rows = productDao.reduceStock(productId, quantity);if (rows > 0) {// 库存更新成功，清除缓存redisTemplate.delete("product:" + productId);redisTemplate.delete("product:list");return true;}return false;}
}

5. 订单服务开发

订单服务负责订单的创建、支付和物流跟踪，下面是核心代码：

// order-service/src/main/java/com/ecommerce/order/entity/Order.java
package com.ecommerce.order.entity;import lombok.Data;import javax.persistence.*;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;/*** 订单实体类*/
@Data
@Entity
@Table(name = "t_order")
public class Order implements Serializable {private static final long serialVersionUID = 1L;@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;  // 订单ID@Column(nullable = false, unique = true)private String orderNo;  // 订单编号@Column(nullable = false)private Long userId;  // 用户ID@Column(nullable = false)private BigDecimal totalAmount;  // 订单总金额@Column(nullable = false)private Integer status;  // 订单状态：0-待支付，1-已支付，2-已发货，3-已完成，4-已取消@Column(nullable = false)private String receiverName;  // 收货人姓名@Column(nullable = false)private String receiverPhone;  // 收货人电话@Column(nullable = false)private String receiverAddress;  // 收货地址@Temporal(TemporalType.TIMESTAMP)@Column(nullable = false)private Date createTime;  // 创建时间@Temporal(TemporalType.TIMESTAMP)private Date payTime;  // 支付时间@Temporal(TemporalType.TIMESTAMP)private Date deliveryTime;  // 发货时间@Temporal(TemporalType.TIMESTAMP)private Date completeTime;  // 完成时间@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY)private List<OrderItem> orderItems;  // 订单商品项
}

// order-service/src/main/java/com/ecommerce/order/service/OrderService.java
package com.ecommerce.order.service;import com.ecommerce.order.entity.Order;
import com.ecommerce.order.entity.OrderItem;
import com.ecommerce.order.dao.OrderDao;
import com.ecommerce.product.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.UUID;/*** 订单服务实现*/
@Service
public class OrderService {@Autowiredprivate OrderDao orderDao;@Autowiredprivate ProductService productService;/*** 创建订单* @param userId 用户ID* @param orderItems 订单商品项* @param receiverName 收货人姓名* @param receiverPhone 收货人电话* @param receiverAddress 收货地址* @return 订单ID*/@Transactionalpublic Long createOrder(Long userId, List<OrderItem> orderItems, String receiverName, String receiverPhone, String receiverAddress) {// 计算订单总金额BigDecimal totalAmount = BigDecimal.ZERO;for (OrderItem item : orderItems) {// 检查库存并扣减boolean success = productService.reduceStock(item.getProductId(), item.getQuantity());if (!success) {throw new RuntimeException("商品库存不足");}// 计算商品小计BigDecimal itemAmount = item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()));item.setAmount(itemAmount);totalAmount = totalAmount.add(itemAmount);}// 创建订单Order order = new Order();order.setOrderNo(generateOrderNo());order.setUserId(userId);order.setTotalAmount(totalAmount);order.setStatus(0);  // 待支付order.setReceiverName(receiverName);order.setReceiverPhone(receiverPhone);order.setReceiverAddress(receiverAddress);order.setCreateTime(new Date());order.setOrderItems(orderItems);// 设置订单关联for (OrderItem item : orderItems) {item.setOrder(order);}// 保存订单orderDao.save(order);return order.getId();}/*** 支付订单* @param orderId 订单ID* @return 支付结果*/@Transactionalpublic boolean payOrder(Long orderId) {Order order = orderDao.findById(orderId).orElse(null);if (order == null) {throw new RuntimeException("订单不存在");}if (order.getStatus() != 0) {throw new RuntimeException("订单状态不正确，不能支付");}// 更新订单状态为已支付order.setStatus(1);order.setPayTime(new Date());orderDao.save(order);// 发送支付成功消息（使用RocketMQ）// messageService.sendOrderPaidMessage(order);return true;}/*** 生成订单编号* @return 订单编号*/private String generateOrderNo() {// 实际项目中应该使用更严谨的订单号生成策略return "ORD" + UUID.randomUUID().toString().replace("-", "").substring(0, 15);}
}

6. 网关服务开发

网关服务作为系统统一入口，负责路由、权限校验和限流等功能：

// gateway-service/src/main/java/com/ecommerce/gateway/GatewayApplication.java
package com.ecommerce.gateway;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;/*** 网关服务启动类*/
@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {public static void main(String[] args) {SpringApplication.run(GatewayApplication.class, args);}/*** 跨域配置*/@Beanpublic CorsWebFilter corsFilter() {CorsConfiguration config = new CorsConfiguration();config.addAllowedMethod("*");config.addAllowedOriginPattern("*");config.addAllowedHeader("*");config.setAllowCredentials(true);UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();source.registerCorsConfiguration("/**", config);return new CorsWebFilter(source);}
}

# gateway-service/src/main/resources/application.yml
spring:application:name: gateway-servicecloud:nacos:discovery:server-addr: localhost:8848gateway:routes:- id: user-serviceuri: lb://user-service  # 负载均衡到user-servicepredicates:- Path=/api/user/**filters:- StripPrefix=2  # 去除路径前缀/api/user- id: product-serviceuri: lb://product-service  # 负载均衡到product-servicepredicates:- Path=/api/product/**filters:- StripPrefix=2  # 去除路径前缀/api/product- id: order-serviceuri: lb://order-service  # 负载均衡到order-servicepredicates:- Path=/api/order/**filters:- StripPrefix=2  # 去除路径前缀/api/order- id: admin-serviceuri: lb://admin-service  # 负载均衡到admin-servicepredicates:- Path=/admin/**filters:- StripPrefix=1  # 去除路径前缀/admin# 全局过滤器配置globalcors:cors-configurations:'[/**]':allowedOrigins: "*"allowedMethods: "*"allowedHeaders: "*"server:port: 8080  # 网关端口

7. 服务调用与集成

使用OpenFeign实现服务间调用：

// order-service/src/main/java/com/ecommerce/order/feign/UserServiceClient.java
package com.ecommerce.order.feign;import com.ecommerce.user.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;/*** 用户服务Feign客户端*/
@FeignClient(name = "user-service")  // 服务名称
public interface UserServiceClient {/*** 获取用户信息* @param id 用户ID* @return 用户信息*/@GetMapping("/api/user/{id}")User getById(@PathVariable("id") Long id);
}

在订单服务中使用Feign客户端：

// order-service/src/main/java/com/ecommerce/order/service/OrderServiceImpl.java
@Service
public class OrderServiceImpl implements OrderService {@Autowiredprivate OrderDao orderDao;@Autowiredprivate UserServiceClient userServiceClient;@Overridepublic Order getOrderDetail(Long orderId) {Order order = orderDao.findById(orderId).orElse(null);if (order != null) {// 通过Feign调用用户服务获取用户信息User user = userServiceClient.getById(order.getUserId());order.setUser(user);}return order;}
}

8. 分布式事务处理

使用Seata实现分布式事务：

// order-service/src/main/java/com/ecommerce/order/service/OrderService.java
@Service
public class OrderService {@Autowiredprivate OrderDao orderDao;@Autowiredprivate ProductService productService;@Autowiredprivate AccountService accountService;/*** 创建订单（分布式事务）*/@GlobalTransactional  // 开启全局事务public void createOrder(OrderDTO orderDTO) {// 1. 创建订单Order order = new Order();order.setUserId(orderDTO.getUserId());order.setProductId(orderDTO.getProductId());order.setCount(orderDTO.getCount());order.setMoney(orderDTO.getMoney());order.setStatus(0);  // 订单状态：0-创建中，1-已完成orderDao.save(order);// 2. 扣减库存productService.reduceStock(orderDTO.getProductId(), orderDTO.getCount());// 3. 扣减账户余额accountService.reduceBalance(orderDTO.getUserId(), orderDTO.getMoney());// 4. 更新订单状态为已完成order.setStatus(1);orderDao.updateStatus(order.getId(), 1);}
}

9. 服务监控与熔断

配置Sentinel实现服务熔断和限流：

# application.yml
spring:cloud:sentinel:transport:dashboard: localhost:8080  # Sentinel控制台地址port: 8719  # 与Sentinel控制台通信的端口

添加熔断降级注解：

@Service
public class ProductService {@Autowiredprivate ProductDao productDao;@SentinelResource(value = "getProductById", blockHandler = "handleBlock")public Product getProductById(Long id) {// 业务逻辑}/*** 熔断降级处理方法*/public Product handleBlock(Long id, BlockException ex) {// 降级逻辑return new Product();}
}

10. 日志收集与分析平台

下面是ELK日志收集系统的配置：

# logstash.conf
input {file {path => "/var/log/ecommerce/*.log"start_position => "beginning"codec => json}
}filter {mutate {remove_field => ["path", "host", "@version"]}date {match => ["timestamp", "ISO8601"]target => "@timestamp"}
}output {elasticsearch {hosts => ["localhost:9200"]index => "ecommerce-%{+YYYY.MM.dd}"}
}

Kibana配置：

# kibana.yml
server.port: 5601
server.host: "0.0.0.0"
elasticsearch.hosts: ["http://localhost:9200"]
kibana.index: ".kibana"

11. 系统部署与性能优化

使用Docker打包服务：

# Dockerfile
FROM openjdk:11-jre-slim
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Docker Compose部署整个系统：

version: '3'
services:gateway-service:build: ./gateway-serviceports:- "8080:8080"depends_on:- nacos- redis- mysqlnetworks:- ecommerce-networkuser-service:build: ./user-serviceports:- "8081:8081"depends_on:- nacos- redis- mysqlnetworks:- ecommerce-networkproduct-service:build: ./product-serviceports:- "8082:8082"depends_on:- nacos- redis- mysql- elasticsearchnetworks:- ecommerce-networkorder-service:build: ./order-serviceports:- "8083:8083"depends_on:- nacos- redis- mysql- rocketmqnetworks:- ecommerce-network# 其他服务配置...networks:ecommerce-network:driver: bridge

12. 高级主题实现

服务网格（Istio）配置示例：

# Gateway配置
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:name: ecommerce-gateway
spec:selector:istio: ingressgatewayservers:- port:number: 80name: httpprotocol: HTTPhosts:- "ecommerce.example.com"

分布式缓存配置：

@Configuration
public class CacheConfig extends CachingConfigurerSupport {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(factory);// 设置键的序列化方式template.setKeySerializer(new StringRedisSerializer());// 设置值的序列化方式Jackson2JsonRedisSerializer<Object> jsonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.activateDefaultTyping(om.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);jsonSerializer.setObjectMapper(om);template.setValueSerializer(jsonSerializer);template.afterPropertiesSet();return template;}
}

总结

通过这个电商系统实战项目，主要掌握了以下技能：

1. 微服务架构设计与实现
2. 服务注册与发现
3. 服务间通信与调用
4. 分布式事务处理
5. 消息队列应用
6. 缓存优化
7. API网关开发
8. 服务监控与熔断
9. 日志收集与分析
10. 系统部署与性能优化

这个项目涵盖了电商系统的核心功能，可以在此基础上继续扩展更多功能，如营销活动、支付集成、物流管理等。

---

推荐阅读：《Java小白学习成长之路》