SpringBoot+layui社区人员健康信息管理系统-毕业设计-【JSB项目实战】

SpringBoot系列文章目录

SpringBoot知识范围-学习步骤【JSB系列之000】

---

本项目效果图

本项目特色， springBoot+mybatis-plus+ layui，文件上传 JSP页面放web-inf下，经后台映射转发

SpringBoot技术很多很多

韩顺平说：学习JAVA的人有两大难
第一困惑，JAVA能百度到的知识太多太多，完全不知道学啥
第二困惑，就是不知道以什么样的顺序去学，有的时候乱看一堆视频有遗漏，有的时候，两边的视频还有重复。

然后，再来看一般的springboot 的书籍中内容。
一般是这样。右侧为基础

如果基础不牢，要回避的知识

假定，你在学校做过了JAVA的小项目了。（我指的是swing，servlet 之类） 可能会点SSM，也可能不会，那我马上就要毕业了，我得搞项目，搞毕设呀。啊！！！

• 第一个要回避的就是JWT。
• 上面的不使用了，shiro 也就不需要了
• 然后是redis
  说一下理由。第一，你一个人使用的系统，你用啥JWT？Session. cookie , JWT 都是你一个人在用。完全不存在用户信息泄漏。
  单点登录就更用不上了。一共就一个系统。
  redis 也不需要，别说你一个人在使用，就是全班的人都在使用50人在线，redis 的优势也自不出来。mysql 数据库连这一点点的数据都不能快速响应，那PHP的平台的不是要直接宕机？而且mybatis 本身还有缓存。
  当然了，这是指你自己要把代码弄懂的这个前提下说的。如果说别人运行好的。那用啥环境也不是你能决定了，是吧？

环境及工具：

本系列环境

环境	win11
工具	idea 2018
jdk	1.8
数据库	mysql5.5
maven	3.6.0
项目导入方式	maven 导入
数据库前端工具	mysql-front (navicat 也可以)

数据库前端工具：mysql-front (navicat 也可以)
主要是这些跟PHPStudy 2018 整合了，所以有的时候懒的打开navicat
关于环境的重要性，直接看上面的《SpringBoot 的项目编译即报错处理–JSB系列之001》

项目里可能要用到的技术

json

JSON（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式。它基于 ECMAScript（European Computer Manufacturers Association, 欧洲计算机协会制定的js规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写。
这个东东一出来就直接把xml 的这种格式按地上摩擦了。而且可以可读性好，也把一些不可读的数据包形式也给取代了。

spring是一个开源的Java开发框架，它提供了一种全面的解决方案，用于构建企业级应用程序。Spring框架的设计理念是基于面向对象的编程思想和松耦合的架构原则，旨在简化Java应用程序的开发，并提供可扩展性和灵活性。

Spring框架的核心特性包括：
1、 控制反转（IoC）：Spring通过控制反转将对象的创建和管理交给框架来完成，开发人员只需关注业务逻辑的实现。这种解耦的设计模式可以降低组件之间的耦合度，提高代码的可维护性和可测试性。

2、 依赖注入（DI）：Spring通过依赖注入将组件之间的依赖关系注入到对象中，而不是硬编码在代码中。这样可以使得组件之间的关系更加灵活，并方便进行单元测试和模块化开发。
spring会自动的把JAR里的功能加到项目里，不管你用不用得上。过于灵活，导致spring的JAR包依赖成为了一个噩梦。
注意的是，这个是SSM为啥 要升级成springBoot的重大原因
如果用升级成使用maven ，不用springBoot 这种父pom 的办法，那么初学者 把一个项目的JAR的依赖整明白，怕是黄瓜菜都凉了。关公大老爷都可以把1000多个华雄杀一个来回了。：）

3、 面向切面编程（AOP）
Spring提供了面向切面编程的支持，可以将横切关注点（如事务管理、安全性等）从业务逻辑中分离出来，以提高代码的模块化和重用性。
spring成名之作。SSM的时候，你可以理解为事务的最方便的实现。
springBoot的时候，你可以理解为配置类的各种妙用。
4、 组件化开发：Spring鼓励使用组件化开发的方式，通过将应用程序划分为多个独立的模块（组件），来提高代码的可重用性和可维护性。同时，Spring提供了一些开箱即用的组件（如数据访问、Web开发、消息传递等），简化了开发过程。

Mybatis

M 一般指的是mybatis.
MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。

Mybatis-plus

MyBatis-Plus (opens new window)(简称 MP)是一个 MyBatis (opens new window)的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。

MyBatis-Plus 已连续 5 年（2017 (opens new window)、2018 (opens new
window)、2019 (opens new window)、2020 (opens new window)、2021 (opens
new window)）获得“OSC 年度最受欢迎中国开源软件”殊荣

MyBatis 项目是 apache 的一个开源项目
MyBatis Plus 是国内一家苞米豆公司对 MyBatis 进行的为此封装
按道理，苞米豆是不可能把他的产品名称起的这么让人混淆的。而且这个名称里还有mybatis 的字样，貌似不太光明正大的感觉。

其它的必要知识

• 网页三剑客，这个不用说了
• JAVA，你总得会idea吧
• maven 这个也是必须的

配置文件

这个项目的重点是配置文件，因为这个项目使用的springboot + mybatis 并非是mybatis plus。

POM

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.2.5.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.codegroupId>
    <artifactId>myprojectartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <packaging>warpackaging>
    <name>myprojectname>
    <description>module project for Spring Bootdescription>

    <properties>
        <java.version>1.8java.version>
        
        <mysql.version>5.1.6mysql.version>
        
        <mahout.version>0.6mahout.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.mahoutgroupId>
            <artifactId>mahout-coreartifactId>
            <version>${mahout.version}version>
        dependency>
        <dependency>
            <groupId>org.apache.mahoutgroupId>
            <artifactId>mahout-integrationartifactId>
            <version>${mahout.version}version>
            <exclusions>
                <exclusion>
                    <groupId>org.mortbay.jettygroupId>
                    <artifactId>jettyartifactId>
                exclusion>
                <exclusion>
                    <groupId>org.apache.cassandragroupId>
                    <artifactId>cassandra-allartifactId>
                exclusion>
                <exclusion>
                    <groupId>me.prettyprintgroupId>
                    <artifactId>hector-coreartifactId>
                exclusion>
            exclusions>
        dependency>

        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <scope>runtimescope>
            <version>${mysql.version}version>
        dependency>
        
        <dependency>
            <groupId>commons-dbutilsgroupId>
            <artifactId>commons-dbutilsartifactId>
            <version>1.6version>
        dependency>

        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.1.6version>
        dependency>


        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.16.10version>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>

        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>javax.servlet-apiartifactId>
           
        dependency>
        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>jstlartifactId>
        dependency>

        
        <dependency>
            <groupId>org.apache.tomcat.embedgroupId>
            <artifactId>tomcat-embed-jasperartifactId>
            <scope>providedscope>
        dependency>


        <dependency>
            <groupId>org.apache.tomcat.embedgroupId>
            <artifactId>tomcat-embed-jasperartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-jdbcartifactId>
        dependency>
        
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>


        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-tomcatartifactId>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>


        
        <dependency>
            <groupId>org.apache.httpcomponentsgroupId>
            <artifactId>httpclientartifactId>
            <version>4.3.3version>
        dependency>
        <dependency>
            <groupId>org.apache.httpcomponentsgroupId>
            <artifactId>httpclient-cacheartifactId>
            <version>4.3.3version>
        dependency>
        <dependency>
            <groupId>org.apache.httpcomponentsgroupId>
            <artifactId>httpmimeartifactId>
            <version>4.3.3version>
        dependency>
        <dependency>
            <groupId>commons-httpclientgroupId>
            <artifactId>commons-httpclientartifactId>
            <version>3.1version>
        dependency>
        <dependency>
            <groupId>org.jsoupgroupId>
            <artifactId>jsoupartifactId>
            <version>1.10.3version>
        dependency>
        

        
        <dependency>
            <groupId>org.apache.poigroupId>
            <artifactId>poi-ooxmlartifactId>
            <version>3.8version>
        dependency>
        <dependency>
            <groupId>org.apache.poigroupId>
            <artifactId>poiartifactId>
            <version>3.8version>
        dependency>
        <dependency>
            <groupId>org.apache.poigroupId>
            <artifactId>poi-ooxml-schemasartifactId>
            <version>3.8version>
        dependency>

        
        <dependency>
            <groupId>commons-iogroupId>
            <artifactId>commons-ioartifactId>
            <version>2.6version>
        dependency>
        <dependency>
            <groupId>commons-fileuploadgroupId>
            <artifactId>commons-fileuploadartifactId>
            <version>1.3.2version>
        dependency>

        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>1.2.7version>
        dependency>


        
        <dependency>
            <groupId>commons-langgroupId>
            <artifactId>commons-langartifactId>
            <version>2.6version>
        dependency>

        <dependency>
            <groupId>commons-beanutilsgroupId>
            <artifactId>commons-beanutilsartifactId>
            <version>1.9.3version>
        dependency>


        
        <dependency>
            <groupId>com.google.zxinggroupId>
            <artifactId>coreartifactId>
            <version>3.2.1version>
        dependency>
        
        <dependency>
            <groupId>com.google.zxinggroupId>
            <artifactId>javaseartifactId>
            <version>3.2.1version>
        dependency>
        
        <dependency>
            <groupId>com.sun.mailgroupId>
            <artifactId>javax.mailartifactId>
            <version>1.4.4version>
        dependency>

        
        
        <dependency>
            <groupId>com.github.pagehelpergroupId>
            <artifactId>pagehelperartifactId>
            <version>5.1.2version>
        dependency>

        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatisplus-spring-boot-starterartifactId>
            <version>1.0.5version>
        dependency>
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plusartifactId>
            <version>2.3version>
        dependency>
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>1.3.1version>
        dependency>

    dependencies>

    <build>
        <resources>
            
            <resource>
                <directory>src/main/resourcesdirectory>
                <filtering>truefiltering>
            resource>
            
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                includes>
            resource>
        resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>

    build>

project>

yml配置

#运行端口号
server.port=8889
#配置项目路径
server.servlet.context-path=/myproject
#数据库连接配置信息  Ctrl+/ 注释
#mysql8驱动
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#mysql5驱动   记得把连接地址换成本机ip地址
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/jsbperson_db?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
spring.datasource.username=root
spring.datasource.password=123456
#mybatis配置
mybatis.type-aliases-package=com.code.entity
#mybatis.mapper-locations=classpath*:mapper/*.xml
mybatis-plus.mapper-locations=classpath*:mapper/*.xml
#jsp视图解析器
spring.mvc.view.prefix=/view/
spring.mvc.view.suffix=.jsp
#文件上传的配置
spring.servlet.multipart.max-file-size=120MB
spring.servlet.multipart.max-request-size=120MB
#开启日志调试
#logging.level.root=debug
#显示mybatis日志
logging.level.com.code.mapper=debug

这里要特别注意的是
这两行。

#jsp视图解析器
spring.mvc.view.prefix=/view/
spring.mvc.view.suffix=.jsp

上代码

package com.code.controller;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.code.entity.*;
import com.code.util.GlobalResult;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@CrossOrigin("*") //允许跨域请求
public class IndexController extends BaseController {

    //跳转发布信息
    @RequestMapping("/send")
    public String send(Model model, HttpSession session) {
        List<Sorttype> sorttypeList = sorttypeMapper.selectByMap(null);
        model.addAttribute("sorttypeList", sorttypeList);
        return "send";
    }

    //跳转发布信息
    @RequestMapping("/yiqingMap")
    public String yiqingMap(Model model, HttpSession session) {
        return "yiqingMap";
    }

    //发布信息保存
    @RequestMapping("/sendSubmit")
    public String sendSubmit(Datainfo datainfo, Model model, HttpSession session) {
        datainfoMapper.insert(datainfo);
        return "redirect:index";
    }

    //信息删除
    @RequestMapping("/datainfoDelete")
    public String datainfoDelete(Integer id, Model model, HttpSession session) {
        datainfoMapper.deleteById(id);
        return "redirect:myDataList";
    }

    //发布信息
    @RequestMapping("/myDataList")
    public String myDataList(Model model, HttpSession session) {
        //判断是否登陆
        if (session.getAttribute("loginUserinfo") == null) {
            model.addAttribute("errorMsg", "登陆以后才可以操作");
            return "login";
        }
        Userinfo loginUserinfo = getLoginUserinfo(session);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("adduser", loginUserinfo.getName());
        List<Datainfo> datainfoList = datainfoMapper.selectByMap(map);
        model.addAttribute("datainfoList", datainfoList);   //绑定搜索关键词
        return "myDataList";
    }


    @RequestMapping("/")
    public String index2() {
        return "redirect:index";
    }

    @RequestMapping("/core")
    public String core() {
        return "core";
    }

    //列表页面  分页搜索功能都有
    @RequestMapping("/index")
    public String index(String keyword, String sorttype, String type, Integer p, Model model, HttpSession session) {
        System.out.println("进入系统首页......");
        p = null == p ? 1 : p; //默认显示第一页
        Integer pageSize = 6; //默认每页显示10条

        EntityWrapper<Datainfo> queryWrapper = new EntityWrapper<Datainfo>();
        if (StringUtils.isNotEmpty(keyword)) {
            queryWrapper.like("name", keyword);
            model.addAttribute("keyword", keyword);   //绑定搜索关键词
            pageSize = 1000;
        }
        if (StringUtils.isNotEmpty(sorttype)) {
            queryWrapper.eq("sorttype", sorttype);
            model.addAttribute("sorttype", sorttype);   //绑定搜索关键词
            pageSize = 1000;
        }
        queryWrapper.orderBy("id", true);  // order by id desc 根据id倒序
        Page<Datainfo> sortPage = new Page<Datainfo>(p, pageSize);//参数一是当前页，参数二是每页个数
        List<Datainfo> datainfoList = datainfoMapper.selectPage(sortPage, queryWrapper);

        long total = sortPage.getTotal(); //总页数
        int current = sortPage.getCurrent();
        long pages = sortPage.getPages();
        model.addAttribute("datainfoList", datainfoList);  //绑定接受参数
        model.addAttribute("cp", current);   //当前页
        model.addAttribute("tp", pages);   //总页数
        model.addAttribute("total", total);   //总条数
        model.addAttribute("pageListURL", "/index");   //总条数

        List<Sorttype> sorttypeList = sorttypeMapper.selectByMap(null);
        model.addAttribute("sorttypeList", sorttypeList);
        List<Carousel> carouselList = carouselMapper.selectByMap(null);
        session.setAttribute("carouselListIndex", carouselList);
        if (null != type) {
            return "index2";
        }
        return "index";
    }


    //详情页面
    @RequestMapping("/detail")
    public String index(Integer id, Model model, HttpSession session) {
        Datainfo datainfo = datainfoMapper.selectById(id);
        model.addAttribute("datainfo", datainfo);
        datainfo.setNums(datainfo.getNums() + 1);
        datainfoMapper.updateById(datainfo);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("tid", id);
        List<Commentinfo> commentinfoList = commentinfoMapper.selectByMap(map);
        model.addAttribute("commentinfoList", commentinfoList);
        List<Sorttype> sorttypeList = sorttypeMapper.selectByMap(null);
        model.addAttribute("sorttypeList", sorttypeList);
        return "detail";
    }


    //评论保存
    @RequestMapping("/commentinfoSubmit")
    public String commentinfoSubmit(Commentinfo obj, Model model, HttpSession session) {
        commentinfoMapper.insert(obj);
        return "redirect:detail?id=" + obj.getTid();
    }

    //评论点赞
    @RequestMapping("/commentinfoDianzan")
    @ResponseBody
    public GlobalResult commentinfoDianzan(int id, Model model, HttpSession session) {
        Commentinfo commentinfo = commentinfoMapper.selectById(id);
        commentinfo.setLikenum(commentinfo.getLikenum() + 1);
        commentinfoMapper.updateById(commentinfo);
        return GlobalResult.ok("评论点赞成功");
    }

    //个人中心
    @RequestMapping("/userinfoCenter")
    public String userinfoCenter(HttpSession session, Model model) {
        Userinfo userinfo = (Userinfo) session.getAttribute("loginUserinfo");
        model.addAttribute("userinfo", userinfo);
        return "userinfoCenter";
    }


    //退出登陆
    @RequestMapping("/loginOut")
    public String loginOut(HttpSession session, Model model) {
        session.invalidate();
        return "redirect:index";
    }

    @RequestMapping("/infoList")
    public String infoList(Model model, String keyword) {
        EntityWrapper<Noticeinfo> queryWrapper = new EntityWrapper<Noticeinfo>();
        //如果有搜索内容 则进行模糊查询
        if (StringUtils.isNotEmpty(keyword)) {
            queryWrapper.like("noticetitle", keyword).or().like("noticecontent", keyword);
            model.addAttribute("keyword", keyword);   //绑定搜索关键词
        }
        List<Noticeinfo> noticeinfoList = noticeinfoMapper.selectList(queryWrapper);
        model.addAttribute("noticeinfoList", noticeinfoList);
        return "infoList";
    }


    @ResponseBody
    @RequestMapping("/checkName")
    public GlobalResult registerSubmit(String name, HttpSession session) {
        List<Userinfo> userinfoList = userinfoMapper.selectByMap(null);
        for (Userinfo u : userinfoList) {
            if (u.getName().equals(name)) {
                return GlobalResult.errorMsg("用户名已经存在");
            }
        }
        return GlobalResult.ok("可用使用");
    }

    //注册提交
    @ResponseBody
    @RequestMapping("/registerSubmit")
    public GlobalResult registerSubmit(Userinfo userinfo, String vercode, HttpSession session) {
        String randCode = session.getAttribute("randCode").toString();
        if (!randCode.equals(vercode)) {
            return GlobalResult.errorMsg("验证码不正确");
        }
        List<Userinfo> userinfoList = userinfoMapper.selectByMap(null);
        for (Userinfo u : userinfoList) {
            if (u.getName().equals(userinfo.getName())) {
                return GlobalResult.errorMsg("用户名已经存在");
            }
            if (u.getPhone().equals(userinfo.getPhone())) {
                return GlobalResult.errorMsg("手机号已经存在");
            }
            if (u.getEmail().equals(userinfo.getEmail())) {
                return GlobalResult.errorMsg("邮箱已经存在");
            }
        }
        Integer insert = userinfoMapper.insert(userinfo);
        return GlobalResult.ok("用户注册成功");
    }

    //个人信息修改
    @ResponseBody
    @RequestMapping("/updateUserinfo")
    public GlobalResult updateUserinfo(HttpSession session, Userinfo userinfo) {
        Integer insert = userinfoMapper.updateById(userinfo);
        setLoginUserinfo(session, userinfo);
        return GlobalResult.ok("个人信息修改成功");
    }

    //公共查询方法
    @ResponseBody
    @RequestMapping("/selectAction")
    public GlobalResult selectAction(String sql) {
        List<Map> mapList = commonMapper.selectAction(sql);
        return GlobalResult.ok(mapList);
    }

    //公共修改方法
    @ResponseBody
    @RequestMapping("/updateAction")
    public GlobalResult updateAction(String sql) {
        commonMapper.updateAction(sql);
        return GlobalResult.ok("操作成功");
    }

    //登陆提交验证
    @ResponseBody
    @RequestMapping("/loginSubmit") //插入数据
    public GlobalResult login(String username, String password, String vercode, HttpSession session, Model model) {
        String randCode = session.getAttribute("randCode").toString();
        if (!randCode.equals(vercode)) {
            return GlobalResult.errorMsg("验证码不正确");
        }
        List<Userinfo> userinfoList = userinfoMapper.selectByMap(null);
        Userinfo admin = new Userinfo();
        boolean is = false;
        for (Userinfo admininfo : userinfoList) {
            if (admininfo.getName().equals(username) && admininfo.getPassword().equals(password)) {
                admin = admininfo;
                is = true;
                break;
            }
        }
        if (is) {
            session.setAttribute("loginUserinfo", admin);
            return GlobalResult.ok("登陆成功");
        } else {
            model.addAttribute("msg", "账号或者密码错误");
            return GlobalResult.errorMsg("账号或者密码错误");
        }
    }


    //测试直接登录
    @RequestMapping("/index00")
    public String index00(HttpSession session) {
        session.setAttribute("loginUserinfo", userinfoMapper.selectById(1));
        return "redirect:index";
    }

}

	@RequestMapping("/location")
	public R location(String lng,String lat) {
		if(BAIDU_DITU_AK==null) {
			BAIDU_DITU_AK = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "baidu_ditu_ak")).getValue();
			if(BAIDU_DITU_AK==null) {
				return R.error("请在配置管理中正确配置baidu_ditu_ak");
			}
		}
		Map<String, String> map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat);
		return R.ok().put("data", map);
	}

mapper

mybatis-plus的mapper 肯定比mybatis 要简单一些。

package com.code.mapper;

import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.code.entity.Admininfo;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

@Component
public interface CommonMapper extends BaseMapper<Admininfo> {

    //公共的查询方法
    @Select(" ${sql} ")
    public List<Map> selectAction(@Param("sql") String sql);

    //公共的增删修改方法
    @Update(" ${sql} ")
    public int updateAction(@Param("sql") String sql);



}

实体类

这里有必要说一下idea2018并不直接支持lombok，需要自己导入一下。

跑起来

后台

数据库的部分你自己搞定吧，如果到了做毕设还不会数据库，这个还是要下点功夫了。
加入启动的URL 与用户的提示，这样对初学者要方便太多。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<c:set var="ctx" value="${pageContext.request.contextPath}"/>
<ul class="layui-nav layui-bg-blue" lay-filter="" style="margin-bottom: 0px;text-align: center;">
    <li class="layui-nav-item"><a href="${ctx}/index">某社区人员健康信息管理系统</a></li>
    <li class="layui-nav-item"><a href="${ctx}/index">首页</a></li>
    <li class="layui-nav-item"><a href="${ctx}/infoList">公告</a></li>
    <c:if test="${sessionScope.loginUserinfo==null}">
        <li class="layui-nav-item"><a href="${ctx}/admininfo/tologin" target="_blank">后台管理</a></li>
        <li class="layui-nav-item"><a href="${ctx}/view/login.jsp">用户登陆</a></li>
        <li class="layui-nav-item"><a href="${ctx}/view/register.jsp">点我注册</a></li>
    </c:if>
    <c:if test="${sessionScope.loginUserinfo!=null}">

      <%--  <li class="layui-nav-item"><a href="${ctx}/send">发布信息</a></li>
        <li class="layui-nav-item"><a href="${ctx}/myDataList">我的数据</a></li>--%>
        <li class="layui-nav-item"><a href="${ctx}/core">我的功能</a></li>
        <li class="layui-nav-item">
            <a href=""><img src="${sessionScope.loginUserinfo.picurl}"
                            class="layui-nav-img">${sessionScope.loginUserinfo.name}-${sessionScope.loginUserinfo.role}
            </a>
            <dl class="layui-nav-child">
                <dd><a href="${ctx}/userinfoCenter">个人中心</a></dd>
                <dd><a href="${ctx}/loginOut">退出登录</a></dd>
            </dl>
        </li>
    </c:if>
</ul>

用浏览器最原始的方式验证

在浏览器上念出一段神奇的古老埃及法老的字符。点击运行出来的那个命令窗口里的URL就可以了。
事实上这种方式比程序直接打开CHROME还方便，因为有人会使用好几个浏览器

http://localhost:8889/myproject/index

页面展示

前台登陆可以填写的信息如下：


后台的登陆。（入口从前台的菜单进入）


有管理员维护，社区用户维护，健康等信息维护，以及网站的轮播，新闻等的维护。


是一个SSM或springBoot 的大作业，或毕业设计。
好，一步成功点亮，关电，拉闸，领盒饭！走人。

总结

提示：IT是一个要多动手的职业，一定要多练不要贪快：
这一部涉及到的知识可以说非常之多。能花一周的时间把这篇文章里的东西弄一个大概并运行出来，也是很不容易的，而且难度也不低，准确一点说，培训机构也能让你似懂非懂的把这个代码跑起来。
做到这一步，你会了springBoot了么？会了，但是现在你会的都是初级基本上就是对付一下简单项目。传的对象复杂了，数据信息多了，都可能会出现这样那样的问题。
还有就是springboot 的缓存，JWT，消息队列，安全机制 ，任务管理其实他们从SSM甚至SSH的时候就有了。只是springboot 一下子全集成过来了。你去看别人的SSM项目 ，这些东西也都有。
所以，程序猿与学员纯在着本质的差别。那么如何提高呢？当然要多读别人的成功项目了。
GITEE上面存在着大量的springboot的项目，英文没有问题的话，可以去github。

配套资源

这个资源上成的VIP的，不好意思了
SpringBoot+layui社区人员健康信息管理系统-毕业设计-【JSB项目实战】

https://download.csdn.net/download/dearmite/88175536

非VIP的0积分资源
https://download.csdn.net/download/dearmite/88235718