备案控制台
探索云世界
开发者社区 数据库 文章 正文

基于springboot心理树洞管理系统(分前后台springboot+mybatis+mysql+maven+vue+echarts)

2024-01-04 49
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL Serverless，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
简介： 基于springboot心理树洞管理系统(分前后台springboot+mybatis+mysql+maven+vue+echarts)

一、项目简介

本项目是一套基于springboot心理树洞管理系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。

包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。

项目都经过严格调试，eclipse或者idea 确保可以运行！

该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值

二、技术实现

springboot+mybatis+mysql+maven+vue+echarts

三、开发运行环境

jdk1.8

Mysql

maven

idea或者eclipse

四、系统功能

系统登录用户角色分为：管理员，学生，心理老师

前台包括：

用户登录

用户注册

首页

文章信息

个人资料

帖子信息

心理资讯

点我收藏

取消收藏

评论

个人中心

我的收藏

留言等

后台包括：

系统首页

注册心理老师

个人中心

学生管理

心理老师管理

文章分类管理

文章信息管理

个人资料管理

预约信息管理

在线咨询管理

分区管理

帖子信息管理

留言信息管理

系统管理

轮播图管理

心理资讯

关于我们

系统简介等

五、页面功能

前台

后台

六、数据库表

一共19张表

七、项目结构

八、部分代码

登录相关

package com.controller;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UsersEntity;
import com.service.TokenService;
import com.service.UsersService;
import com.utils.CommonUtil;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
/**
 * 登录相关
 */
@RequestMapping("users")
@RestController
public class UsersController{
  @Autowired
  private UsersService userService;
  @Autowired
  private TokenService tokenService;
  /**
   * 登录
   */
  @IgnoreAuth
  @PostMapping(value = "/login")
  public R login(String username, String password, String captcha, HttpServletRequest request) {
    UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
    if(user==null || !user.getPassword().equals(password)) {
      return R.error("账号或密码不正确");
    }
    String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
    return R.ok().put("token", token);
  }
  /**
   * 注册
   */
  @IgnoreAuth
  @PostMapping(value = "/register")
  public R register(@RequestBody UsersEntity user){
//      ValidatorUtils.validateEntity(user);
      if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
        return R.error("用户已存在");
      }
        userService.insert(user);
        return R.ok();
    }
  /**
   * 退出
   */
  @GetMapping(value = "logout")
  public R logout(HttpServletRequest request) {
    request.getSession().invalidate();
    return R.ok("退出成功");
  }
  /**
     * 密码重置
     */
    @IgnoreAuth
  @RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
      UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
      if(user==null) {
        return R.error("账号不存在");
      }
      user.setPassword("123456");
        userService.update(user,null);
        return R.ok("密码已重置为：123456");
    }
  /**
     * 列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,UsersEntity user){
        EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
      PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
        return R.ok().put("data", page);
    }
  /**
     * 列表
     */
    @RequestMapping("/list")
    public R list( UsersEntity user){
        EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
        ew.allEq(MPUtil.allEQMapPre( user, "user")); 
        return R.ok().put("data", userService.selectListView(ew));
    }
    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        UsersEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }
    /**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
      Long id = (Long)request.getSession().getAttribute("userId");
        UsersEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }
    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody UsersEntity user){
//      ValidatorUtils.validateEntity(user);
      if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
        return R.error("用户已存在");
      }
        userService.insert(user);
        return R.ok();
    }
    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody UsersEntity user){
//        ValidatorUtils.validateEntity(user);
      UsersEntity u = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername()));
      if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) {
        return R.error("用户名已存在。");
      }
        userService.updateById(user);//全部更新
        return R.ok();
    }
    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        userService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}

留言信息

package com.controller;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.LiuyanxinxiEntity;
import com.entity.view.LiuyanxinxiView;
import com.service.LiuyanxinxiService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
import java.io.IOException;
/**
 * 留言信息
 * 后端接口
 * @author 
 * @email 
 * @date 2023-03-26 12:44:42
 */
@RestController
@RequestMapping("/liuyanxinxi")
public class LiuyanxinxiController {
    @Autowired
    private LiuyanxinxiService liuyanxinxiService;
    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,LiuyanxinxiEntity liuyanxinxi,
    HttpServletRequest request){
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
        String tableName = request.getSession().getAttribute("tableName").toString();
        ew.andNew();
        if(tableName.equals("xuesheng")) {
            ew.eq("xuehao", (String)request.getSession().getAttribute("username"));
        }
        if(tableName.equals("xuesheng")) {
            ew.or();
            ew.eq("liuyanxuehao", (String)request.getSession().getAttribute("username"));
        }
    PageUtils page = liuyanxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, liuyanxinxi), params), params));
        return R.ok().put("data", page);
    }
    /**
     * 前端列表
     */
  @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params,LiuyanxinxiEntity liuyanxinxi, 
    HttpServletRequest request){
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
    PageUtils page = liuyanxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, liuyanxinxi), params), params));
        return R.ok().put("data", page);
    }
  /**
     * 列表
     */
    @RequestMapping("/lists")
    public R list( LiuyanxinxiEntity liuyanxinxi){
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
        ew.allEq(MPUtil.allEQMapPre( liuyanxinxi, "liuyanxinxi")); 
        return R.ok().put("data", liuyanxinxiService.selectListView(ew));
    }
   /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(LiuyanxinxiEntity liuyanxinxi){
        EntityWrapper< LiuyanxinxiEntity> ew = new EntityWrapper< LiuyanxinxiEntity>();
    ew.allEq(MPUtil.allEQMapPre( liuyanxinxi, "liuyanxinxi")); 
    LiuyanxinxiView liuyanxinxiView =  liuyanxinxiService.selectView(ew);
    return R.ok("查询留言信息成功").put("data", liuyanxinxiView);
    }
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        LiuyanxinxiEntity liuyanxinxi = liuyanxinxiService.selectById(id);
        return R.ok().put("data", liuyanxinxi);
    }
    /**
     * 前端详情
     */
  @IgnoreAuth
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        LiuyanxinxiEntity liuyanxinxi = liuyanxinxiService.selectById(id);
        return R.ok().put("data", liuyanxinxi);
    }
    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody LiuyanxinxiEntity liuyanxinxi, HttpServletRequest request){
      liuyanxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
      //ValidatorUtils.validateEntity(liuyanxinxi);
        liuyanxinxiService.insert(liuyanxinxi);
        return R.ok();
    }
    /**
     * 前端保存
     */
    @RequestMapping("/add")
    public R add(@RequestBody LiuyanxinxiEntity liuyanxinxi, HttpServletRequest request){
      liuyanxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
      //ValidatorUtils.validateEntity(liuyanxinxi);
        liuyanxinxiService.insert(liuyanxinxi);
        return R.ok();
    }
    /**
     * 修改
     */
    @RequestMapping("/update")
    @Transactional
    public R update(@RequestBody LiuyanxinxiEntity liuyanxinxi, HttpServletRequest request){
        //ValidatorUtils.validateEntity(liuyanxinxi);
        liuyanxinxiService.updateById(liuyanxinxi);//全部更新
        return R.ok();
    }
    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        liuyanxinxiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    /**
     * 提醒接口
     */
  @RequestMapping("/remind/{columnName}/{type}")
  public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
             @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
    map.put("column", columnName);
    map.put("type", type);
    if(type.equals("2")) {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      Calendar c = Calendar.getInstance();
      Date remindStartDate = null;
      Date remindEndDate = null;
      if(map.get("remindstart")!=null) {
        Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
        c.setTime(new Date()); 
        c.add(Calendar.DAY_OF_MONTH,remindStart);
        remindStartDate = c.getTime();
        map.put("remindstart", sdf.format(remindStartDate));
      }
      if(map.get("remindend")!=null) {
        Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
        c.setTime(new Date());
        c.add(Calendar.DAY_OF_MONTH,remindEnd);
        remindEndDate = c.getTime();
        map.put("remindend", sdf.format(remindEndDate));
      }
    }
    Wrapper<LiuyanxinxiEntity> wrapper = new EntityWrapper<LiuyanxinxiEntity>();
    if(map.get("remindstart")!=null) {
      wrapper.ge(columnName, map.get("remindstart"));
    }
    if(map.get("remindend")!=null) {
      wrapper.le(columnName, map.get("remindend"));
    }
    int count = liuyanxinxiService.selectCount(wrapper);
    return R.ok().put("count", count);
  }
    /**
     * （按值统计）
     */
    @RequestMapping("/value/{xColumnName}/{yColumnName}")
    public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("xColumn", xColumnName);
        params.put("yColumn", yColumnName);
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
        List<Map<String, Object>> result = liuyanxinxiService.selectValue(params, ew);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for(Map<String, Object> m : result) {
            for(String k : m.keySet()) {
                if(m.get(k) instanceof Date) {
                    m.put(k, sdf.format((Date)m.get(k)));
                }
            }
        }
        return R.ok().put("data", result);
    }
    /**
     * （按值统计）时间统计类型
     */
    @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
    public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("xColumn", xColumnName);
        params.put("yColumn", yColumnName);
        params.put("timeStatType", timeStatType);
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
        List<Map<String, Object>> result = liuyanxinxiService.selectTimeStatValue(params, ew);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for(Map<String, Object> m : result) {
            for(String k : m.keySet()) {
                if(m.get(k) instanceof Date) {
                    m.put(k, sdf.format((Date)m.get(k)));
                }
            }
        }
        return R.ok().put("data", result);
    }
    /**
     * 分组统计
     */
    @RequestMapping("/group/{columnName}")
    public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("column", columnName);
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
        List<Map<String, Object>> result = liuyanxinxiService.selectGroup(params, ew);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for(Map<String, Object> m : result) {
            for(String k : m.keySet()) {
                if(m.get(k) instanceof Date) {
                    m.put(k, sdf.format((Date)m.get(k)));
                }
            }
        }
        return R.ok().put("data", result);
    }
    /**
     * 总数量
     */
    @RequestMapping("/count")
    public R count(@RequestParam Map<String, Object> params,LiuyanxinxiEntity liuyanxinxi, HttpServletRequest request){
        EntityWrapper<LiuyanxinxiEntity> ew = new EntityWrapper<LiuyanxinxiEntity>();
        int count = liuyanxinxiService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, liuyanxinxi), params), params));
        return R.ok().put("data", count);
    }
}

九、源码地址

https://download.csdn.net/download/weixin_43860634/87814276


文章标签：
云数据库 RDS MySQL 版
Java
Android开发
数据库
关系型数据库
MySQL
关键词：
Spring Boot Maven
Spring Boot管理系统
管理系统云数据库 RDS MySQL 版
Spring Boot后台
springboot MyBatis vue
相关实践学习
基于CentOS快速搭建LAMP环境
本教程介绍如何搭建LAMP环境，其中LAMP分别代表Linux、Apache、MySQL和PHP。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
飞翔的佩奇
目录
相关文章
技术蜜糖罐
|
24天前
|
存储 关系型数据库 MySQL
轻松入门MySQL：数据库设计之范式规范，优化企业管理系统效率（21）
轻松入门MySQL：数据库设计之范式规范，优化企业管理系统效率（21）
技术蜜糖罐
44 0
技术蜜糖罐
|
24天前
|
SQL 关系型数据库 MySQL
轻松入门MySQL：保障数据完整性，MySQL事务在进销存管理系统中的应用（12）
轻松入门MySQL：保障数据完整性，MySQL事务在进销存管理系统中的应用（12）
技术蜜糖罐
33 0
骚戴
|
26天前
|
存储 Java 关系型数据库
实验室设备管理系统【GUI/Swing+MySQL】（Java课设）
实验室设备管理系统【GUI/Swing+MySQL】（Java课设）
骚戴
17 0
骚戴
|
26天前
|
存储 Java 关系型数据库
冬奥会传统文化管理系统【GUI/Swing+MySQL】（Java课设）
冬奥会传统文化管理系统【GUI/Swing+MySQL】（Java课设）
骚戴
8 0
骚戴
|
26天前
|
存储 Java 关系型数据库
学生宿舍管理系统【GUI/Swing+MySQL】（Java课设）
学生宿舍管理系统【GUI/Swing+MySQL】（Java课设）
骚戴
22 0
骚戴
|
26天前
|
存储 Java 关系型数据库
学生管理系统【GUI/Swing+MySQL】（Java课设）
学生管理系统【GUI/Swing+MySQL】（Java课设）
骚戴
19 0
骚戴
|
26天前
|
存储 Java 关系型数据库
洗浴中心管理系统【GUI/Swing+MySQL】（Java课设）
洗浴中心管理系统【GUI/Swing+MySQL】（Java课设）
骚戴
14 0
程序员三木
|
3天前
|
Java Maven Kotlin
[AIGC] 请你写一遍博客介绍 “使用idea+kotinlin+springboot+maven 结合开发一个简单的接口“，输出markdown格式，用中文回答，请尽可能详细
[AIGC] 请你写一遍博客介绍 “使用idea+kotinlin+springboot+maven 结合开发一个简单的接口“，输出markdown格式，用中文回答，请尽可能详细
程序员三木
10 0
爱笑的源码基地
|
9天前
|
Java 关系型数据库 MySQL
一套java+ spring boot与vue+ mysql技术开发的UWB高精度工厂人员定位全套系统源码有应用案例
UWB (ULTRA WIDE BAND, UWB) 技术是一种无线载波通讯技术，它不采用正弦载波，而是利用纳秒级的非正弦波窄脉冲传输数据，因此其所占的频谱范围很宽。一套UWB精确定位系统，最高定位精度可达10cm，具有高精度，高动态，高容量，低功耗的应用。
爱笑的源码基地
30 0
一套java+ spring boot与vue+ mysql技术开发的UWB高精度工厂人员定位全套系统源码有应用案例
丘比特惩罚陆
|
24天前
|
JavaScript Java 关系型数据库
基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
本文档介绍了基于Springboot的实习管理系统的设计与实现。系统采用B/S架构，旨在解决实习管理中的人工管理问题，提高效率。系统特点包括对用户输入的验证和数据安全性保障。功能涵盖首页、个人中心、班级管理、学生管理、教师管理、实习单位管理、实习作业管理、教师评分管理、单位成绩管理和系统管理等。用户分为管理员、教师和学生，各自有不同的操作权限。
丘比特惩罚陆
94 0

热门文章

最新文章

  • 1
    SpringBoot集成Redis
  • 2
    SpringBoot-Run启动流程
  • 3
    SpringBoot 企业级简化开发（一）
  • 4
    SpringBoot项目调用HTTP接口5种方式你了解多少？
  • 5
    SpringBoot3集成Swagger出现错误Error starting ApplicationContext. To display the condition evaluation repor
  • 6
    SpringBoot集成Redis解决表单重复提交接口幂等（亲测可用）
  • 7
    Springboot+Spring security +jwt认证+动态授权
  • 8
    开源一个基于SpringBoot的慈善公益平台（一）
  • 9
    SpringBoot实现多线程定时任务动态定时任务配置文件配置定时任务
  • 10
    SpringBoot出现 java.lang.IllegalArgumentException: Request header is too large 解决方法
  • 1
    使用Maven对Scala独立应用程序进行编
    19
  • 2
    基于 Spring MVC + MyBits + Maven
    290
  • 3
    《手把手教你》系列基础篇之（四）-java+ selenium自动化测试- 启动三大浏览器（下）基于Maven（详细教程）
    66
  • 4
    【四】SpringCloud Alibaba之重构Maven结构
    29
  • 5
    《手把手教你》系列基础篇之（二）-java+ selenium自动化测试-环境搭建（下）基于Maven（详细教程）
    68
  • 6
    如何使用Docker轻松搭建Nexus私有仓库，实现Maven私服的搭建和使用
    73
  • 7
    Linux系统Docker部署Nexus Maven并实现远程访问本地管理界面
    88
  • 8
    java修改当前项目的maven仓库地址为国内
    108
  • 9
    私有仓库工具Nexus Maven如何部署并实现远程访问管理界面
    58
  • 10
    spark 与 scala 的对应版本查看、在idea中maven版本不要选择17，弄了好久，换成11就可以啦
    110

    • 相关课程

    更多
  • MySQL企业常见架构与调优经验分享
  • 阿里云云原生数据仓库AnalyticDB MySQL版 使用教程
  • MySQL实战进阶
  • Springboot项目云开发快速迁移
  • 数据库及SQL/MySQL基础
  • 云数据库MySQL快速入门

    • 相关电子书

    更多
  • 搭建电商项目架构连接MySQL
  • 搭建4层电商项目架构，实战连接MySQL
  • PolarDB MySQL引擎重磅功能及产品能力盛大发布

    • 相关实验场景

    更多
  • 测试场景（RDS无优惠）
  • MySQL引擎及架构优化
  • 基于EBS部署高性能的MySQL服务
  • 使用Python完成RDS数据开发及分析
  • Excel文件转存到RDS数据库
  • 使用CloudLens采集RDS日志并进行审计分析

    • 推荐镜像

    更多
  • mysql
  • maven
  • mariadb
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）