网站首页 - java网站开发教程

《java网站开发教程》学习指南

欢迎访问java网站开发教程官方网站!本教程致力于为初学者及进阶开发者提供系统化、实战化的Java Web开发知识体系,覆盖从基础语法到企业级项目部署的全流程内容。无论您是零基础入门者,还是已有一定经验希望精进的开发者,本教程都将为您提供清晰的学习路径与实用的技术干货。

当前Java Web技术栈以Spring Boot为核心,结合MyBatis、微服务架构、高并发设计与系统安全防护等关键技术模块,构成现代企业级应用开发的标准范式。本教程将通过大量真实代码示例、架构图解、性能调优技巧与常见问题解决方案,帮助您构建完整的知识体系。

本页所有导航均采用锚点跳转方式,无需跳转至二级页面,页面加载快速、交互流畅,同时保证移动端与桌面端的完美适配。所有内容均经过严格校验,确保技术准确性与可操作性。

为什么选择本java网站开发教程?

  • 系统性:从Servlet/JSP到Spring Boot微服务架构,构建完整知识链
  • 实战性:每个技术模块均配带完整可运行的示例项目,支持本地部署
  • 时效性:持续跟进JDK 17+、Spring Boot 3.x、Jakarta EE 9+等最新标准
  • 深度性:不仅讲解“如何做”,更深入剖析“为何如此设计”,提升架构思维

本教程内容严格遵循企业级开发规范,内容涵盖:Java Web基础、Maven项目管理、数据库连接池优化、RESTful API设计、JWT认证授权、分布式会话管理、Redis缓存穿透与击穿防护、Sentinel流量治理、ELK日志分析等核心能力点,助您从“码农”蜕变为“架构师”。

① Java Web基础核心:Servlet与JSP

Servlet生命周期与工作原理

Servlet是Java Web开发的基石,负责处理客户端请求并生成响应。其核心生命周期由容器(如Tomcat)管理,包含三个关键阶段:

  1. 实例化:容器首次收到请求时,调用无参构造方法创建Servlet实例(单例模式)
  2. 初始化:调用init(ServletConfig config)方法,仅执行一次,用于加载配置、建立数据库连接池等
  3. 服务:每次请求调用service(HttpServletRequest req, HttpServletResponse resp),内部根据HTTP方法分发至doGet/doPost等
  4. 销毁:容器关闭或重启时调用destroy(),释放资源(如关闭连接池、文件句柄)

典型代码结构如下:

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import java.io.IOException;
public class HelloServlet extends HttpServlet {
    @Override
    public void init() throws ServletException {
        System.out.println("Servlet初始化完成");
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().println("<h1>Hello Java Web!</h1>");
    }
    @Override
    public void destroy() {
        System.out.println("Servlet资源已释放");
    }
}

注意:从Servlet 3.0起,可使用@WebServlet("/hello")注解替代web.xml配置,极大简化部署流程。但大型项目仍推荐采用web.xml集中管理,便于版本控制与权限审计。

JSP技术详解与最佳实践

JSP(JavaServer Pages)本质是Servlet的简化写法,允许在HTML中嵌入Java代码,实现动态内容生成。其执行流程为:JSP → _jspService()方法 → 转译为Servlet类 → 编译为.class文件 → 由容器执行。

常见JSP脚本元素:

  • <% int count = 0; %>:Java脚本段(不推荐用于业务逻辑)
  • <%= count %>:表达式(输出变量值)
  • <%! int global = 100; %>:声明全局变量/方法(慎用)
  • <%@ page contentType="text/html;charset=UTF-8" %>:页面指令

问题与优化:JSP混合HTML与Java易导致维护困难,现代开发中已逐步被Thymeleaf、Freemarker等模板引擎替代。若必须使用JSP,请遵循以下原则:

  1. 业务逻辑移至Servlet或Service层,JSP仅负责展示
  2. 使用JSTL标签库(如<c:forEach>)替代<% %>脚本
  3. 统一模板布局(header/footer)通过<jsp:include>复用

示例:使用JSTL循环输出用户列表

<c:forEach items="${userList}" var="user">
    <p>用户名:<c:out value="${user.name}"/>,邮箱:<c:out value="${user.email}"/></p>
</c:forEach>

此方式可避免XSS攻击(<c:out>自动转义HTML特殊字符),提升安全性。

HTTP协议与请求处理机制

理解HTTP协议是Web开发的基础。HTTP/1.1默认使用持久连接(Keep-Alive),支持请求/响应复用TCP连接,显著降低延迟。关键概念包括:

  • 请求方法:GET(幂等,用于查询)、POST(非幂等,用于提交)、PUT(更新)、DELETE(删除)
  • 状态码:200(成功)、301/302(重定向)、400(请求错误)、401(未认证)、403(禁止访问)、404(资源不存在)、500(服务器错误)
  • 请求头:Content-Type(如application/json)、Authorization(Bearer Token)、User-Agent
  • 响应头:Set-Cookie、Cache-Control、X-Frame-Options(防CSRF)

在Servlet中获取请求信息的典型方式:

// 获取GET参数
String keyword = req.getParameter("q");
// 获取POST表单数据
req.setCharacterEncoding("UTF-8"); // 防止中文乱码
String username = req.getParameter("username");
// 获取请求头
String userAgent = req.getHeader("User-Agent");
boolean isMobile = userAgent != null && userAgent.contains("Mobile");
// 获取客户端IP
String clientIP = req.getRemoteAddr(); // 注意:代理后需用X-Forwarded-For

安全实践:对用户输入必须进行校验与过滤,防止SQL注入(使用PreparedStatement)、XSS攻击(输出时转义)、CSRF攻击(Token验证)。

② JSP高级技巧与替代方案

JSP自定义标签库(TLD)开发

为提升JSP可维护性,可开发自定义标签库。步骤如下:

  1. 编写标签处理器类(实现Tag/BodyTag接口)
  2. 创建TLD文件(XML描述标签属性与行为)
  3. 在JSP中通过<%@ taglib %>引入

示例:生成分页导航的自定义标签

<!-- PagerTag.java -->
public class PagerTag extends SimpleTagSupport {
    private int currentPage;
    private int totalPage;
    public void setCurrentPage(int cp) { this.currentPage = cp; }
    public void setTotalPage(int tp) { this.totalPage = tp; }
    @Override
    public void doTag() throws JspException {
        JspWriter out = getJspContext().getOut();
        try {
            out.print("<nav><ul class='pagination'>");
            for (int i = 1; i <= totalPage; i++) {
                if (i == currentPage) {
                    out.print("<li class='active'><span>" + i + "</span></li>");
                } else {
                    out.print("<li><a href='?page=" + i + "'>" + i + "</a></li>");
                }
            }
            out.print("</ul></nav>");
        } catch (IOException e) {
            throw new JspException(e);
        }
    }
}

TLD文件(WEB-INF/tags.tld):

<tag>
    <name>pager</name>
    <tag-class>com.example.tags.PagerTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <name>currentPage</name>
        <required>true</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
    <attribute>
        <name>totalPage</name>
        <required>true</required>
    </attribute>
</tag>

使用方式:

<%@ taglib uri="/WEB-INF/tags.tld" prefix="tags" %>
<tags:pager currentPage="${page.current}" totalPage="${page.total}"/>

此方式将展示逻辑与业务逻辑彻底分离,符合MVC设计模式。

JSP与Spring MVC视图解析集成

在Spring MVC中,可通过InternalResourceViewResolver配置JSP视图解析:

@Bean
public ViewResolver viewResolver() {
    InternalResourceViewResolver resolver = new InternalResourceViewResolver();
    resolver.setPrefix("/WEB-INF/views/");
    resolver.setSuffix(".jsp");
    resolver.setViewNames("*");
    return resolver;
}

控制器方法:

@GetMapping("/users")
public String listUsers(Model model) {
    List<User> users = userService.findAll();
    model.addAttribute("userList", users);
    return "user/list"; // 解析为 /WEB-INF/views/user/list.jsp
}

注意事项:

  • JSP文件必须放在/WEB-INF/目录下,防止直接访问
  • 启用JSTL依赖:<dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId></dependency>
  • 禁用JSP脚本:在web.xml中添加<jsp-config><jsp-property-group><url-pattern>*.jsp</url-pattern><scripting-invalid>true</scripting-invalid></jsp-property-group></jsp-config>

EL表达式与JSTL核心标签库

EL(Expression Language)简化了JSP中的数据访问,支持从page、request、session、application作用域自动查找属性。

常用EL表达式:

  • ${user.name}:等价于pageContext.findAttribute("user").getName()
  • ${empty list}:判断集合是否为空
  • ${fn:toUpperCase(name)}:使用JSTL函数(需引入<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>)

JSTL核心标签(c:前缀):

  • <c:if test="${condition}">:条件判断
  • <c:choose><c:when><c:otherwise>:多分支逻辑
  • <c:forEach items="${list}" var="item">:循环遍历
  • <c:url value="/path" var="url" /><a href="${url}">:生成上下文路径

安全示例:防止XSS攻击的输出方式

<c:out value="${user.input}" escapeXml="true"/>

等价于手动转义:&lt;script&gt;alert(1)&lt;/script&gt;,确保用户输入不会执行恶意脚本。

③ Spring框架核心:IoC与AOP

Spring IoC容器与Bean管理

Spring IoC(Inversion of Control)容器是Spring框架的核心,负责对象的创建、配置与生命周期管理。关键组件包括:

  • BeanFactory:基础容器,延迟加载(第一次请求时创建)
  • ApplicationContext:高级容器,启动时预加载单例Bean,支持国际化、事件发布等

配置Bean的方式:

  1. XML配置(传统方式):
<bean id="userService" class="com.example.service.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>
  1. 注解配置(推荐):
@Component
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
}

作用域:

  • @Scope("singleton"):单例(默认)
  • @Scope("prototype"):多例(每次请求新建)
  • @Scope("request"):Web作用域(每个HTTP请求新建)

依赖注入方式:

  • 构造器注入(推荐,确保依赖不可为空)
  • Setter注入
  • 字段注入(不推荐,难测试)

示例:构造器注入与校验

@Service
public class OrderService {
    private final OrderRepository repo;
    private final Validator validator;
    public OrderService(OrderRepository repo, Validator validator) {
        this.repo = repo;
        this.validator = validator;
    }
    public void createOrder(Order order) {
        validator.validate(order); // 确保校验逻辑存在
        repo.save(order);
    }
}

AOP面向切面编程实战

AOP(Aspect-Oriented Programming)将横切关注点(如日志、事务、安全)与业务逻辑分离。核心概念:

  • 切面(Aspect):封装横切逻辑的类
  • 连接点(Join Point):程序执行点(如方法调用)
  • 通知(Advice):切面在连接点上的动作(@Before/@After等)
  • 切点(Pointcut):匹配连接点的表达式

示例:日志切面记录方法执行时间

@Aspect
@Component
public class LoggingAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("方法 " + joinPoint.getSignature() +
                          " 执行耗时: " + (end - start) + "ms");
        return result;
    }
}

通知类型:

  • @Before:前置通知
  • @After:后置通知(无论是否异常均执行)
  • @AfterReturning:返回通知(仅成功时执行)
  • @AfterThrowing:异常通知(抛出异常时执行)
  • @Around:环绕通知(最灵活,可控制是否执行目标方法)

事务管理:通过@Transactional注解实现声明式事务,底层依赖AOP代理。

Spring MVC请求处理流程

Spring MVC采用前端控制器(DispatcherServlet)模式,核心流程如下:

  1. 客户端请求进入DispatcherServlet
  2. HandlerMapping查找匹配的Handler(Controller方法)
  3. HandlerAdapter执行Handler
  4. 返回ModelAndView对象
  5. ViewResolver解析视图
  6. 渲染视图并返回响应

关键组件:

  • DispatcherServlet:前端控制器(入口)
  • HandlerMapping:路由映射(如@RequestMapping)
  • Controller:业务处理器
  • ViewResolver:视图解析器

示例:RESTful API控制器

@RestController
@RequestMapping("/api/users")
public class UserApiController {
    @Autowired
    private UserService userService;
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
        User saved = userService.save(user);
        return ResponseEntity.created(URI.create("/api/users/" + saved.getId())).body(saved);
    }
}

参数绑定:

  • @PathVariable:路径变量
  • @RequestParam:查询参数
  • @RequestBody:JSON/XML请求体(需Jackson依赖)
  • @RequestHeader:请求头

④ Spring Boot快速开发

自动配置与Starter机制

Spring Boot通过“约定大于配置”理念简化开发。其核心机制:

  • 自动配置:基于classpath检测自动加载Bean(如检测到H2则配置内存数据库)
  • Starter依赖:聚合常用库(如spring-boot-starter-web包含Tomcat、Spring MVC、Jackson)

典型POM配置:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

禁用自动配置:

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

条件化配置:

  • @ConditionalOnClass:类存在时生效
  • @ConditionalOnMissingBean:Bean不存在时生效
  • @ConditionalOnProperty:配置项满足时生效

配置管理与Profile环境隔离

Spring Boot支持多环境配置:

  • application.properties:默认配置
  • application-dev.properties:开发环境
  • application-prod.properties:生产环境

激活Profile:

  • 命令行:java -jar app.jar --spring.profiles.active=prod
  • 环境变量:SPRING_PROFILES_ACTIVE=prod
  • IDE配置:Run Configuration中设置

配置优先级(从高到低):

  1. 命令行参数
  2. JNDI属性
  3. JVM系统属性
  4. 操作系统环境变量
  5. jar包外部的application-{profile}.properties
  6. jar包内部的application-{profile}.properties
  7. application.properties

配置随机值:

app.secret=${random.uuid}
app.port=${random.int[8080,8090]}

Actuator监控与健康检查

Spring Boot Actuator提供生产级监控端点:

  • /actuator/health:健康检查(返回UP/DOWN)
  • /actuator/metrics:系统指标(JVM、HTTP请求等)
  • /actuator/env:环境变量
  • /actuator/loggers:日志级别动态调整

配置端点:

management.endpoints.web.exposure.include=health,metrics,info
management.endpoint.health.show-details=always

自定义健康检查:

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    @Autowired
    private DataSource dataSource;
    @Override
    public Health health() {
        try (Connection conn = dataSource.getConnection()) {
            conn.isValid(2);
            return Health.up().withDetail("database", "connected").build();
        } catch (Exception e) {
            return Health.down(e).build();
        }
    }
}

集成Prometheus:

  1. 添加依赖:spring-boot-starter-actuator + micrometer-registry-prometheus
  2. 访问/actuator/prometheus获取指标数据

⑤ MyBatis高效数据访问

MyBatis核心配置与Mapper开发

MyBatis是半自动ORM框架,支持自定义SQL、存储过程及高级映射。核心组件:

  • SqlSessionFactory:创建SqlSession的工厂
  • Mapper接口:定义数据访问方法
  • XML映射文件:编写SQL语句

配置示例:

<!-- mybatis-config.xml -->
<configuration>
    <environments default="dev">
        <environment id="dev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <property name="username" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

Mapper接口与XML:

// UserMapper.java
public interface UserMapper {
    User selectUser(int id);
    void insertUser(User user);
}
<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUser" parameterType="int" resultType="User">
        SELECT * FROM user WHERE id = #{id}
    </select>
    <insert id="insertUser" parameterType="User">
        INSERT INTO user(name, email) VALUES(#{name}, #{email})
    </insert>
</mapper>

动态SQL:

<select id="findUsers" parameterType="map" resultType="User">
    SELECT * FROM user
    <where>
        <if test="name != null">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
        <if test="email != null">
            AND email = #{email}
        </if>
    </where>
</select>

MyBatis Plus快速开发

MyBatis-Plus是MyBatis增强工具,提供CRUD接口、代码生成器、分页插件等功能。核心特性:

  • 无侵入:仅增强,不改变原生用法
  • 强大的CRUD:继承BaseMapper即可操作
  • 条件构造器:Wrapper构建复杂查询
  • 自动分页:Page对象自动处理

配置示例:

@MapperScan("com.example.mapper")
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

Service层使用:

public interface UserService extends IService<User> {}
// Controller中直接调用
List<User> list = userService.list(new QueryWrapper<User>().ge("age", 18));
Page<User> page = userService.page(new Page<>(1, 10),
    new QueryWrapper<User>().like("name", "张"));

代码生成器:

AutoGenerator mpg = new AutoGenerator();
mpg.setGlobalConfig(...);
mpg.setDataSource(...);
mpg.setPackageInfo(...);
mpg.setStrategy(...);
mpg.execute();

⑥ 微服务架构与分布式实战

Spring Cloud核心组件

Spring Cloud提供微服务开发的一站式解决方案,核心组件包括:

  • 服务注册与发现:Eureka/Nacos(服务注册中心)
  • 负载均衡:Ribbon/LoadBalancer(客户端负载均衡)
  • 服务容错:Hystrix/Sentinel(熔断降级)
  • 配置中心:Spring Cloud Config/Nacos
  • API网关:Spring Cloud Gateway
  • 消息总线:Spring Cloud Stream/Kafka

服务注册示例(Nacos):

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

application.yml配置:

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

服务调用:

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;
    public User getUser(Long id) {
        return restTemplate.getForObject("http://user-service/users/" + id, User.class);
    }
}

分布式事务与Seata集成

微服务架构下,跨服务事务需使用分布式事务解决方案。Seata是开源的高性能分布式事务框架,支持AT(自动)、TCC(手动)、SAGA(长事务)模式。

AT模式核心流程:

  1. TM(Transaction Manager)发起全局事务
  2. RM(Resource Manager)注册分支事务
  3. 执行本地事务并生成undo_log
  4. 提交/回滚全局事务

配置示例:

@GlobalTransactional
public void createOrder(Order order) {
    // 调用库存服务
    inventoryFeign.decrease(order.getProductId(), order.getCount());
    // 保存订单
    orderMapper.insert(order);
}

关键配置:

  • undo_log表(每库必备)
  • seata-server配置(file.conf + registry.conf)
  • 数据源代理:new DataSourceProxy(dataSource)

⑦ Web安全防护体系

认证授权与JWT实现

现代Web应用普遍采用JWT(JSON Web Token)实现无状态认证。流程如下:

  1. 用户登录 → 验证凭证 → 生成JWT(含用户ID、角色、过期时间)
  2. 返回JWT至客户端 → 客户端存储(localStorage/cookie)
  3. 后续请求携带JWT → 服务端解析验证 → 放行或拒绝

JWT结构:

  • Header(算法、类型)
  • Payload(声明,如sub、exp、roles)
  • Signature(签名,防止篡改)

代码实现:

@Component
public class JwtTokenProvider {
    private final String SECRET_KEY = "your-256-bit-secret";
    private final long TOKEN_VALIDITY = 3600000; // 1小时
    public String generateToken(UserDetails userDetails) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + TOKEN_VALIDITY);
        return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .claim("roles", userDetails.getAuthorities())
            .setIssuedAt(now)
            .setExpiration(expiryDate)
            .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
            .compact();
    }
    public String getUsernameFromToken(String token) {
        return Jwts.parser()
            .setSigningKey(SECRET_KEY)
            .parseClaimsJws(token)
            .getBody()
            .getSubject();
    }
}

安全实践:

  • Token存储于HttpOnly Cookie防止XSS窃取
  • 设置合理过期时间,配合Refresh Token机制
  • 服务端维护Token黑名单(注销时)

CSRF与XSS攻击防护

CSRF(跨站请求伪造):攻击者诱导用户执行非本意操作。防护措施:

  • 使用Anti-CSRF Token(表单/请求头携带)
  • SameSite Cookie属性(Strict/Lax)
  • 验证Referer头

XSS(跨站脚本):注入恶意脚本。防护措施:

  • 输出时转义(Thymeleaf默认开启)
  • Content-Security-Policy(CSP)
  • HttpOnly Cookie防止JS读取
  • 输入校验(白名单过滤)

Spring Security配置:

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable() // 生产环境建议启用
            .headers().frameOptions().disable()
            .and()
            .authorizeHttpRequests()
            .requestMatchers("/api/**").authenticated()
            .and()
            .formLogin();
        return http.build();
    }
}

⑧ 性能优化实战指南

数据库层优化

索引优化:

  • 遵循最左前缀原则
  • 避免在索引列使用函数/计算
  • 覆盖索引(SELECT字段在索引中)
  • 定期分析索引使用率:ANALYZE TABLE

SQL优化:

  • 避免SELECT *
  • 分页查询优化(避免OFFSET过大)
  • 使用EXPLAIN分析执行计划
  • 批量操作替代循环单条

连接池配置:

spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000

缓存策略与Redis应用

Redis是高性能缓存中间件,典型应用场景:

  • 热点数据缓存(如商品详情)
  • 分布式Session存储
  • 限流(令牌桶算法)
  • 消息队列(Stream)

缓存问题解决方案:

  1. 缓存穿透:查询不存在数据 → 缓存空值(设置短过期)+ 布隆过滤器
  2. 缓存击穿:热点key过期 → 互斥锁 + 永不过期 + 异步刷新
  3. 缓存雪崩:大量key同时过期 → 过期时间随机化 + 互斥锁

代码示例:

@Cacheable(value = "products", key = "#id")
public Product getProduct(Long id) {
    return productMapper.selectById(id);
}

RedisTemplate配置:

@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    return template;
}

⑨ 企业级项目实战:电商平台后台

项目架构与技术选型

技术栈:

  • 前端:Vue3 + Element Plus(可选,本教程以Java后端为主)
  • 后端:Spring Boot 3.x + MyBatis-Plus
  • 缓存:Redis(集群)
  • 消息队列:RocketMQ
  • 搜索引擎:Elasticsearch
  • 分布式配置:Nacos
  • 服务治理:Spring Cloud Alibaba

核心模块:

  1. 用户中心(注册/登录/资料管理)
  2. 商品服务(分类/SPU/SKU管理)
  3. 订单系统(下单/支付/发货)
  4. 库存服务(扣减/回滚)
  5. 优惠券系统

高并发设计:

  • 库存预减 + 异步扣减(防超卖)
  • 订单超时自动取消(Redis过期监听)
  • 支付结果异步通知
  • 热点商品独立缓存

订单超时取消实现方案

方案1:延迟队列(推荐):

  1. 订单创建时 → 发送延迟消息(30分钟)至RocketMQ
  2. 消息到期 → 触发取消订单服务
  3. 检查订单状态(未支付/未发货)→ 执行取消

方案2:Redis过期回调:

// 设置订单过期时间
redisTemplate.opsForValue().set("order:timeout:" + orderId, orderId, 30, TimeUnit.MINUTES);
// 监听过期事件
@Configuration
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
    @Override
    public void onMessage(Message message, byte[] pattern) {
        String expiredKey = message.toString();
        if (expiredKey.startsWith("order:timeout:")) {
            String orderId = expiredKey.replace("order:timeout:", "");
            orderService.cancelOrder(orderId);
        }
    }
}

方案对比:

方案优点缺点
延迟队列可靠、支持大规模依赖MQ中间件
Redis过期简单、轻量精度低、内存压力
定时任务易实现性能差、延迟高

网友们还关心

针对本java网站开发教程,读者常关注以下问题:

学习路径建议

根据学习者背景,推荐路径:

  1. 零基础:Java基础 → HTML/CSS/JS → Servlet/JSP → Spring MVC → Spring Boot → MyBatis
  2. 有经验:直接学习Spring Boot + MyBatis-Plus → Redis → 分布式(Nacos/Sentinel)→ 微服务(Spring Cloud)
  3. 架构师:高并发设计 → 分布式事务 → 系统监控(Prometheus/Grafana)→ 安全加固 → 容器化(Docker/K8s)

项目驱动学习:

  • 初级:实现博客系统(用户管理/文章CRUD)
  • 中级:开发电商后台(订单/库存/优惠券)
  • 高级:构建秒杀系统(库存预减/Redis预热/令牌桶限流)