最近接了不少准备毕业设计的同学咨询，发现“SpringBoot+Vue”几乎是当下Java全栈项目的主力阵容，技术栈成熟、资料多、面试也聊得上。而“助农产品采购平台”这个方向很讨巧，既有社会价值，业务模型又清晰，做起来不至于像“图书管理”那么烂大街，也不会像“电商秒杀”那样复杂到收不住。如果你正在准备毕设、课设，或者单纯想找个项目练手把SpringBoot和Vue串起来，这篇文章就把整个项目的设计思路、核心模块、关键代码、部署步骤、答辩准备一次讲透。

1. 项目整体设计与技术选型思路

1.1 为什么“助农采购平台”刚好适合做毕业设计

先说业务背景。传统农产品流通链条很长，货源靠收购商层层转手，到了消费者手里价格翻了几番，但产地农户利润微薄，碰上丰产年份甚至滞销。助农采购平台的初衷就是压缩中间环节，让农户直接入驻开店，采购方（学校食堂、餐饮店、单位采购、普通家庭）在线下单，平台做信息撮合和交易管理。

这个业务做成项目，最大的优势是角色边界清晰。整个系统只需要三类角色：农户（卖家）、采购方（买家）、平台管理员（监管方）。每一类角色能做的事天然分成几个模块，数据库表结构、接口权限、前端页面都能跟着角色划分走，逻辑不会乱。而且“助农”这个切入点有故事可以讲，答辩时既能谈业务价值，又能谈技术实现，不容易被老师问住。

很多同学会纠结要不要加“直播带货”“社区团购”之类的新概念，我的建议是别加。毕设的核心指标是“功能完整、逻辑自洽、能演示”，宁可把商品管理、订单流转、权限控制这些基本功做扎实，也别贪多导致代码失控。

1.2 技术栈选型：SpringBoot + Vue + MySQL是怎么凑齐的

这个组合能成为毕设标配，不是没有原因的。

后端用SpringBoot，核心思路是“约定优于配置”，自动装配机制帮你省掉了大量XML配置，一个SpringBoot工程加一个application.yml就能启动起来。比起传统的SSH（Spring + Struts + Hibernate）那一套，开发效率高出一大截。而且SpringBoot自带内嵌Tomcat，本地起服务不需要单独装服务器，这对新手来说特别友好。

前端用Vue，好处是组件化开发。商品卡片、搜索栏、订单列表这些都是独立组件，前后端通过JSON格式的接口通信。Vue最舒服的地方是数据和视图双向绑定，数据变了页面自动更新，不用像以前jQuery那样手动操作DOM。

数据库用MySQL，没什么争议。免费、轻量、资料多，配合Navicat或者MySQL Workbench可视化操作，建表、导数据都很方便。考虑到毕设场景，数据库没必要上什么大集群，一套单库单表的设计就足够了。

版本选择上，我给个稳妥的组合，都是实测过得比较顺的：

这套组合的另一个好处是，很多公司生产环境还在用类似的版本，做完项目之后的经验在面试聊项目时可以直接用，不至于白做。

2. 核心功能模块与数据库设计要点

2.1 角色划分与权限模型

整个平台的操作都围绕三类角色展开，权限设计是项目的骨架，必须先想清楚。

农户端：入驻审核通过后可以管理自己的店铺，发布商品时填写名称、分类、产地、价格、库存、规格（比如“5斤装”）、图片等信息。商品上架前需要管理员审核，避免出现价格离谱或者图片违规的情况。农户能查看自己商品的订单列表，收到新订单后可以发货更新物流信息。

采购方端：游客可以浏览商品，但下单前必须注册登录。采购方可以搜索商品、按分类筛选、加入购物车、结算下单、查看订单状态，还能在个人中心维护收货地址。采购方下单默认与农户直连，平台不参与仓储物流，这也是助农直采模式的业务设定。

管理后台：负责平台治理，主要功能包括农户入驻审核、商品审核、全平台订单查看、用户管理、数据统计（每日订单量、成交量、成交金额）。数据统计不一定做得很花哨，用后端统计接口加前端图表展示就够了。

权限这块，实际开发用的是JWT + 拦截器的方案。用户登录成功后端返回一个签名后的Token，前端每次请求带上，后端拦截器负责解析Token并确认角色。三个角色需要的接口权限不一样，比如“发布商品”只能农户角色访问，“审核商品”只能管理员访问，这个在拦截器里通过注解或路径匹配来控制。

2.2 数据库表结构设计

数据库设计是答辩时老师必问的环节，建议不要省。下面是这个项目最核心的几张表，照着建基本够用。

用户表（user）

分类表（category）

商品表（product）

购物车表（cart）

订单表（order）

订单明细表（order_item）

订单明细为什么要存商品快照而不直接关联商品表？因为商品价格会调整，名称会改动，如果直接查商品表，历史订单显示的就不是下单时的真实信息了。这个设计细节在答辩时提出来会很加分。

2.3 数据库设计的常见误区

有同学喜欢在订单表里直接存商品信息，或者把商品字段一股脑全放一张表里，这属于设计时没想清楚。数据库表的拆分原则就一条：每个表只存一个“对象”自己的信息，对象之间的关联用ID连接。

另外，“冗余字段”要看场景。订单明细里的product_name、product_image属于有意冗余，是为了保证历史记录不变；而商品表里如果存一个“农户手机号”就显得很怪，因为手机号属于用户信息，应该通过seller_id去user表关联查询。弄清楚“哪些字段该冗余、哪些字段该关联”，后面写SQL才会顺手。

3. 后端SpringBoot实现细节与关键代码

3.1 工程目录结构与统一返回结果封装

后端工程结构建议按“业务分层”来组织，不要让Controller里塞一堆SQL逻辑。我用的是一个标准的四层结构，包名规划如下：

text复制com.example.farm
├── controller       // 接收前端请求
├── service          // 业务逻辑
├── mapper           // 数据访问（MyBatis-Plus的BaseMapper）
├── entity           // 数据库实体类
├── dto              // 接口入参/出参对象
├── config           // 配置类（CORS、拦截器注册等）
├── common           // 统一返回结果、全局异常、工具类
└── FarmApplication.java  // 启动类

项目引入MyBatis-Plus来操作数据库，而不是手写一堆XML。MyBatis-Plus是MyBatis的增强工具，基本的增删改查、分页查询都封装好了，稍微复杂一点的查询用LambdaQueryWrapper就能解决，不用写SQL。对于毕设项目来说，开发效率比纯手写MyBatis高不少，而且代码量少，出了问题好排查。

前端和后端交互，接口返回格式必须统一。我习惯用一个Result类来包装所有接口返回值，结构如下：

java复制public class Result<T> {
    private Integer code;      // 200=成功, 400=业务错误, 401=未登录, 500=系统异常
    private String message;    // 提示信息
    private T data;            // 业务数据

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMessage("操作成功");
        result.setData(data);
        return result;
    }

    public static <T> Result<T> error(String message) {
        Result<T> result = new Result<>();
        result.setCode(400);
        result.setMessage(message);
        return result;
    }
}

有了这个统一包装，前端不需要关心每个接口返回字段是否一致，只要判断code是不是200就能决定下一步操作。代码里千万别每个Controller都自己new一个HashMap往里面塞值，那样前后端联调时绝对要被自己坑到。

3.2 JWT登录认证与拦截器实现

登录认证是后端的核心鉴权方案。流程上，用户提交用户名密码，后端校验通过后生成一个Token返回给前端，前端把Token存到localStorage里，请求时放到Header中。后端写一个拦截器，拦截所有带“/api/”前缀的请求（登录接口和注册接口除外），解析Token并从中取出用户ID和角色。

JWT工具类主要提供三个方法：生成Token、解析Token、校验Token。写一个例子：

java复制@Component
public class JwtUtils {
    // 生产环境不要硬编码，建议放到配置文件中
    private static final String SECRET = "farm-platform-secret-key";
    private static final long EXPIRE_TIME = 72 * 60 * 60 * 1000; // 3天

    public String generateToken(Integer userId, String role) {
        return Jwts.builder()
                .setSubject(String.valueOf(userId))
                .claim("role", role)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE_TIME))
                .signWith(SignatureAlgorithm.HS256, SECRET)
                .compact();
    }

    public Claims parseToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET)
                .parseClaimsJws(token)
                .getBody();
    }
}

这里要注意一个大坑：JWT中不要放敏感信息。JWT的Payload部分默认只是Base64编码，不是加密，谁拿到都能解出来。我只放用户ID和角色，这两个字段不敏感，能确保请求时知道“谁在操作、有没有权限”就够了。

拦截器中的角色校验逻辑，要放到HandlerInterceptor的preHandle方法里：

java复制@Component
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 处理预检请求，否则前端跨域请求会被拦截
        if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
            return true;
        }
        String token = request.getHeader("token");
        if (token == null || token.isEmpty()) {
            response.setStatus(401);
            return false;
        }
        try {
            Claims claims = jwtUtils.parseToken(token);
            Integer userId = Integer.parseInt(claims.getSubject());
            String role = claims.get("role", String.class);
            // 放到ThreadLocal或request attribute中，供Controller使用
            request.setAttribute("userId", userId);
            request.setAttribute("role", role);
            return true;
        } catch (Exception e) {
            response.setStatus(401);
            return false;
        }
    }
}

然后写一个配置类把这个拦截器注册进去，同时配置放行路径：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private AuthInterceptor authInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor)
                .addPathPatterns("/api/**")
                .excludePathPatterns("/api/auth/login", "/api/auth/register");
    }

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOriginPatterns("*")
                .allowedMethods("GET", "POST", "PUT", "DELETE");
    }
}

这里还要单独解释一下Controller里怎么区分角色。最直接的方式是在Controller方法里从request中取出role属性，用if判断。简单，但代码重复高，适合小项目。想做得优雅一点就自定义一个@RequireRole注解，用AOP做切面校验，但这套对新手偏复杂，建议项目里先用if判断，答辩时如果被问到“有没有更好的方案”，你再说出注解+AOP的做法，老师会觉得你思考过扩展性。

3.3 下单流程与库存扣减

整个项目技术难度最高的业务就是下单，把这块理清楚，后端基本就掌握了大半。

下单流程是这样的：前端把购物车商品列表（商品ID和数量）传给后端，后端做以下几步：

1. 校验每个商品的ID是否存在、状态是否为上架。
2. 校验库存是否充足，不充足直接返回提示。
3. 计算订单总金额。
4. 扣减库存，同时在商品表的sales字段累加销量。
5. 创建订单主表记录和订单明细记录。
6. 清空购物车中已下单的商品。

这里要重点提醒：扣库存和创建订单必须在同一个事务里执行。如果先扣了库存、创建订单失败，库存就凭空少了；如果先创建订单、再扣库存失败，就会出现超卖。用Spring的@Transactional注解把整个方法包起来，任何一个环节抛异常，数据库就回滚到方法执行前的状态。

java复制@Transactional(rollbackFor = Exception.class)
public Order createOrder(Long buyerId, List<CartItemDTO> items, AddressDTO address) {
    BigDecimal totalAmount = BigDecimal.ZERO;
    List<OrderItem> orderItems = new ArrayList<>();
    // 第一步：遍历校验商品，计算总额
    for (CartItemDTO item : items) {
        Product product = productMapper.selectById(item.getProductId());
        if (product == null || product.getStatus() != 1) {
            throw new BusinessException("商品不存在或已下架");
        }
        if (product.getStock() < item.getQuantity()) {
            throw new BusinessException("商品【" + product.getName() + "】库存不足");
        }
        // 扣库存
        product.setStock(product.getStock() - item.getQuantity());
        product.setSales(product.getSales() + item.getQuantity());
        productMapper.updateById(product);

        OrderItem orderItem = new OrderItem();
        orderItem.setProductId(product.getId());
        orderItem.setProductName(product.getName());
        orderItem.setProductImage(product.getMainImage());
        orderItem.setPrice(product.getPrice());
        orderItem.setQuantity(item.getQuantity());
        orderItems.add(orderItem);

        totalAmount = totalAmount.add(product.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())));
    }
    // 第二步：创建订单主记录
    Order order = new Order();
    order.setOrderNo(generateOrderNo());
    order.setBuyerId(buyerId);
    // 从第一个商品反查卖家ID（或按卖家拆单，这里按单个卖家处理）
    order.setSellerId(orderItems.get(0).getProductId()); // 注意：这是简化示例，真实逻辑要查商品所属农户
    order.setTotalAmount(totalAmount);
    order.setStatus(0);
    order.setReceiverName(address.getReceiverName());
    order.setReceiverPhone(address.getReceiverPhone());
    order.setReceiverAddress(address.getReceiverAddress());
    orderMapper.insert(order);
    // 第三步：保存订单明细
    for (OrderItem item : orderItems) {
        item.setOrderId(order.getId());
        orderItemMapper.insert(item);
    }
    // 第四步：清空购物车
    cartMapper.deleteByUserIdAndProductIds(buyerId, items.stream().map(CartItemDTO::getProductId).collect(Collectors.toList()));
    return order;
}

如果购物车中有多个农户的商品，一种做法是“按农户拆单”，把同一个农户的商品合在一张订单里，便于农户发货。这个在答辩时如果能主动提出来，会显得你对业务理解很深。

生成订单号这里多说一句，为了保证订单号全局唯一，我用的是“yyyyMMddHHmmss + 6位随机数字”的拼接方式。对于毕设量级，“时间+随机数”已经足够了，不要再搞雪花算法那套，没必要。

4. 前端Vue页面实现与交互细节

4.1 前端工程结构与路由设计

前端工程我用Vue CLI初始化，目录结构如下：

text复制src
├── api                   // 所有请求接口的封装
│   ├── auth.js          // 登录、注册
│   ├── product.js       // 商品相关
│   ├── order.js         // 订单相关
│   └── admin.js         // 管理后台相关
├── views                 // 页面级组件
│   ├── Home.vue         // 首页（商品浏览）
│   ├── Login.vue        // 登录
│   ├── Register.vue     // 注册
│   ├── ProductDetail.vue // 商品详情
│   ├── Cart.vue         // 购物车
│   ├── Checkout.vue     // 结算页
│   ├── user/            // 采购方个人中心
│   │   ├── UserOrders.vue
│   │   └── UserAddress.vue
│   ├── seller/          // 农户工作台
│   │   ├── SellerProducts.vue
│   │   ├── ProductEdit.vue
│   │   └── SellerOrders.vue
│   └── admin/           // 管理后台
│       ├── AdminUser.vue
│       ├── AuditProduct.vue
│       └── Dashboard.vue
├── router/index.js       // 路由配置
├── components/           // 通用组件（分页、商品卡片等）
├── utils/request.js      // axios封装
└── main.js

路由设计要做到“页面权限分离”。不同角色登录后看到的不同菜单，不能靠隐藏按钮这种“假权限”，而是要靠路由守卫在前端拦截。

javascript复制router.beforeEach((to, from, next) => {
    const token = localStorage.getItem('token');
    if (to.meta.requiresAuth && !token) {
        next('/login');
        return;
    }
    if (to.meta.role) {
        const role = localStorage.getItem('role');
        if (role !== to.meta.role) {
            next('/403');
            return;
        }
    }
    next();
});

路由meta配置示例：

javascript复制{
    path: '/seller/products',
    component: SellerProducts,
    meta: { requiresAuth: true, role: '1' }  // 只有农户能访问
}

前端的角色路由守卫只是“用户体验优化”，真正判断权限必须依赖后端接口拦截。因为前端代码在浏览器里是透明的，用户可以绕过路由直接改请求，所以后端权限校验一定要守住。这个在项目答辩的时候非常容易被问到，提前把概念理清楚。

4.2 Axios封装与接口联调的坑

Axios封装我通常放在utils/request.js里，核心就是创建实例、加请求拦截器和响应拦截器。

javascript复制import axios from 'axios';
import { Message } from 'element-ui';
import router from '../router';

const request = axios.create({
    baseURL: '/api',   // 走前端代理，避免跨域
    timeout: 10000
});

// 请求拦截器：自动携带token
request.interceptors.request.use(config => {
    const token = localStorage.getItem('token');
    if (token) {
        config.headers['token'] = token;
    }
    return config;
});

// 响应拦截器：统一处理业务码和网络异常
request.interceptors.response.use(
    response => {
        const res = response.data;
        if (res.code === 200) {
            return res;
        } else if (res.code === 401) {
            Message.error('登录已过期，请重新登录');
            localStorage.clear();
            router.push('/login');
            return Promise.reject(res);
        } else {
            Message.error(res.message || '请求失败');
            return Promise.reject(res);
        }
    },
    error => {
        Message.error('网络异常，请稍后重试');
        return Promise.reject(error);
    }
);

export default request;

baseURL设为/api，然后在vue.config.js里配置代理，把请求转发到后端的8080端口，这样前端开发时就不会遇到跨域问题：

javascript复制module.exports = {
    devServer: {
        port: 3000,
        proxy: {
            '/api': {
                target: 'http://localhost:8080',
                changeOrigin: true
            }
        }
    }
};

这个是关键配置。如果没有代理，前端页面在3000端口，后端在8080端口，浏览器会直接拦截跨域请求，报“Access-Control-Allow-Origin”错误。很多新手第一次联调就死在这一步。我建议前端开发阶段优先用代理方案，后端CORS配置可以保留，双保险。

4.3 移动端卡片式商品页与后台管理界面的实现思考

考虑到大多数毕设演示是在电脑上进行的，前端不用一开始就做响应式适配。首页用“卡片式布局”，一个商品卡片包含图片、名称、产地、价格、销量这几个核心信息，Card组件加一个hover效果就很像样。

商品列表页面要重视搜索和筛选，这些是老师验收时大概率会点到的功能：

• 按关键词搜索（调用后端接口，name like '%关键词%'）
• 按分类筛选（左侧分类菜单，点击后传递categoryId）
• 按价格/销量排序（价格从低到高、销量从高到低）

这些功能在Element UI里都有现成组件，比如el-input、el-menu、el-select，样式不用自己从头写。核心工作量其实在后端的查询接口怎么支持这些参数。

管理后台页面用el-table来展示数据列表，配合el-pagination做分页。产品审核页面放一个“通过/驳回”按钮组，驳回时弹出el-input填写驳回理由，这个交互简单但不幼稚，演示效果也好。

5. 项目部署运行与毕设答辩准备

5.1 从零到一跑通项目的步骤

我把整个环境的搭建过程列一遍，照着做就行。

第一步：安装基础环境

• JDK 1.8，配好JAVA_HOME环境变量
• MySQL 5.7/8.0，装好后设置root密码，记好
• Node.js 14/16，vue cli需要依赖node
• IDE：后端用IntelliJ IDEA，前端用VSCode，两个都免费

第二步：初始化数据库

在Navicat或命令行中创建一个数据库，比如取名farm_platform，字符集选utf8mb4（一定要选utf8mb4，否则商品名里加个emoji表情就报错）。然后把项目里的sql脚本直接导入，脚本里包含了建表语句和测试数据。

测试数据别偷懒，至少要造20个商品、5个分类、3个农户账号、1个管理员账号。不然演示时页面空空荡荡，给老师的印象分很差。同时把测试账号的密码提前告诉老师，比如：

第三步：启动后端

用IDEA打开后端工程，等待Maven下载依赖。修改application.yml里的数据库连接信息：

yaml复制spring:
  datasource:
    url: jdbc:mysql://localhost:3306/farm_platform?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 你的数据库密码
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

然后运行FarmApplication主类，看到“Started FarmApplication in x.xx seconds”就说明启动成功了。可以先在浏览器访问http://localhost:8080/api/auth/login，用POST工具或直接在浏览器地址栏访问，能看到页面提示错误或返回JSON都说明服务是通的。

第四步：启动前端

用VSCode打开前端工程，在终端执行：

bash复制npm install
npm run serve

第一次npm install可能会比较慢，如果卡住，就用淘宝镜像源：

bash复制npm config set registry https://registry.npmmirror.com

前端启动后，浏览器访问http://localhost:3000，能看到首页就算全部跑通了。

5.2 答辩演示脚本怎么设计

答辩的核心是“展示你做了什么、怎么做出来的”。建议的演示路径是：

1. 打开前台首页，介绍整个页面的功能分区，强调“农产品直采”的业务故事。
2. 打开商品搜索和筛选，让老师看到有交互逻辑，不是纯静态页面。
3. 登录农户账号，演示商品上架，特别强调“上架后需要管理员审核”，这是业务设计的亮点。
4. 退出，登录采购方账号，演示加购物车、下单，再演示订单状态从“待发货”到“待收货”的变化——这里要提前准备好演示用订单，不要让老师现场等流程。
5. 登录管理员账号，演示商品审核的通过/驳回操作，再打开数据统计页面展示订单量和成交金额。
6. 如果时间有余，打开数据库表结构，讲一遍订单表和订单明细表的区别，顺手把“为什么存快照”的设计理念讲出来。

答辩的时候老师问到“项目难点”怎么回答？核心是“抓小放大”。不要吹“并发处理”“高可用”这些虚的，把下单事务和JWT权限拦截这两个点讲清楚，说清楚使用了什么技术、解决了什么问题、如果不这样会有什么后果，这就已经是很好的答辩表现了。

6. 常见问题与排查技巧实录

这个项目开发过程中，最容易踩的坑基本集中在环境配置和前后端联调，我把高频问题整理成一张速查表。

有几个值得单独展开的坑，多说几句。

第一个坑：前端跨域问题

这个问题几乎所有人都遇到过。在浏览器中，页面从3000端口访问，后端接口在8080端口，默认会被CORS策略拦截。最通俗的解决办法就是配置proxy代理，让前端请求先发送到3000端口，再由Vue的开发服务器转发到8080。

但如果把前端打包后部署到Nginx上，代理配置就要写在Nginx的配置文件里，原理都不难，就是域名/路径转发的概念，关键坑在于很多人会忘记在后端的CORS配置中暴露自定义Header。比如前端带了token这个自定义Header，后端如果没配置允许暴露这个Header，照样会被拦，我实测中很多同学就是卡在这一步。

第二个坑：Maven依赖下载太慢

SpringBoot项目导入IDEA后，pom.xml里的依赖会自动下载，在国内经常很慢甚至失败。解决办法是配置阿里云Maven镜像：

xml复制<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

这个配置写在Maven的settings.xml里。配好之后重开IDEA，依赖下载会快非常多。

第三个坑：SpringSecurity和JWT的集成

有些同学会选择引入SpringSecurity来管理认证，但SpringSecurity的配置链对新手来说并不友好，默认会拦截所有请求，配置不好连Swagger都访问不了。以毕设的复杂度来说，手动实现JWT工具类 + 拦截器就足够了，不引框架反而更容易控制，也更容易讲清楚原理。如果你确实想在项目中用SpringSecurity，那要额外学习SecurityConfig配置类、UserDetailsService、密码加密这些内容，工作量会大很多，权衡好。

第四个坑：订单状态满天飞

订单有很多状态：待付款、待发货、待收货、已完成、已取消。如果直接在前端用数字去判断，代码可读性会很差，而且容易写错。建议在前后端都维护一个“状态枚举”的映射：

java复制public enum OrderStatusEnum {
    WAIT_PAY(0, "待付款"),
    WAIT_SHIP(1, "待发货"),
    WAIT_RECEIVE(2, "待收货"),
    FINISHED(3, "已完成"),
    CANCELED(4, "已取消");

    private final int code;
    private final String desc;
    // 构造器和getter省略
}

前端同样维护一个statusMap对象，渲染时根据数字映射中文。这样代码里不会出现一堆魔法数字，维护起来会清晰很多。

第五个坑：数据库连接串的serverTimezone参数

在application.yml的jdbc连接串里，如果不加serverTimezone=Asia/Shanghai，用高版本MySQL时经常会报“The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized”这种错误。原因就是时区没对上。这行参数是格式化的时间，直接复制我上面给的那条连接串就好，服务器上部署时也要注意保持。

7. 项目后续还能怎么扩展

跑通一个基础版之后，如果时间充裕，有几个扩展方向可以做，每个都不算复杂但能显著提升项目含金量：

第一个是支付对接。目前的下单流程停留在“生成订单”这一步，可以接入微信支付或者模拟支付流程（比如下单后跳转到一个假支付页面，点击“模拟支付”后把订单状态改为待发货）。很多学校不允许真实支付对接，用模拟支付的方式演示完全可以。

第二个是数据可视化大屏。用ECharts做一个管理后台的数据大屏页，展示近30天订单趋势、商品分类占比、农户销售额排名。ECharts纯前端实现，后端只要给几个统计数据接口就够。虽然是简单的柱状图折线图饼图，但视觉效果好，答辩展示很拉分。

第三个是农产品溯源。既然助农是卖点，可以在商品中添加“产地图片”“种植过程介绍”等内容，甚至给每个商品生成一个溯源码，扫码就能看到产地故事。这个偏业务创新点，技术实现不难，就是新表、新字段、新页面，但讲出来很有故事感。

第四个是即时聊天。采购方想咨询农户，可以用WebSocket做一个会话窗口。这个技术含量稍高，但是WebSocket在SpringBoot的集成其实没那么复杂，核心类是WebSocketHandler和前端WebSocket API，如果时间充裕值得一试，面试时也是很好的项目亮点。

不过还是那句话——如果做这三个扩展方向之前的基础版本还没跑得特别稳，建议先停下扩展的想法，把核心流程打磨稳定。毕设项目比的不是功能多，而是“你能说清楚的功能”，与其做十个说不清的模块，不如做五个能讲透的模块。

我个人在实际跑通这套项目之后的感受是：这类带明确业务的平台型项目，最重要的不是炫技，而是把“角色→功能→表→接口→页面”这条链路理得清清楚楚。当你把一个助农采购平台从数据库设计到前端页面完整走一遍，SpringBoot的自动装配、JWT的认证流程、Vue的组件通信、Axios的请求封装这些知识点就真正内化了，而不是停留在“背八股文”的层面。最后分享一个小技巧：写代码时每完成一个功能就顺手在笔记里记一行“这个模块用了什么技术、解决了什么问题”，等答辩前把这些笔记整理成体系，你的答辩论据就非常扎实了。