微信小程序开发者工具如何连接spring boot后端 微信小程序与springboot

首先展示一下已经写完的效果：大概效果就是这样，实现登陆增删改查

使用技术：SpringBoot   +  微信小程序开发   +   MyBatis  + MySql  + Maven

开发工具 idea + Navicat（MySQL的编辑器）

做个记录，加深记忆，如果各位有兴趣可以看下去，哪里不懂的可以问我 直接在CSDN评论即可，我每天都会看的，我会尽力写的很详细，好了废话不多说了，上代码喽。

各种安装就不说了，1.官网下载SpringBoot项目  官网路径：https://start.spring.io/ ，如果看不懂，用谷歌浏览器打开可以转换中文，我的SpringBoot版本是2.1.1  现在2.1.6就可以了，选则好你的选项，我使用的java8 SpringBoot 最低支持是JDK8，然后点击下面Generate the Project生成jar包，下载完成以后解压 直接用IDEA打开即可，或则可以直接用我之前下载的Demo

SpringBoot 官方下载的Demo

链接：https://pan.baidu.com/s/1tuxi8puXbc05YzWwRrijQg 
提取码：xq44

因为需要导入jar，所以我们需要Maven,现在开始下载Maven，前往https://maven.apache.org/download.cgi下载最新版的Maven程序：在当前页里找到Files,如下图所示：下载  apache-maven-3.6.1-bin.zip。

首先我们将文件解压到D:\Program Files\Apache\maven目录下:

然后我们可以新建环境变量MAVEN_HOME，赋值D:\Program Files\Apache\maven

最后我们可以编辑环境变量Path，追加%MAVEN_HOME%\bin\; 

至此，maven已经完成了安装，我们可以通过DOS命令检查一下我们是否安装成功：命令符：mvn -v,如图所示则OK。

在idea 中配置Maven  idea左上角打开File ---> Settings根据下图配置,此图从别处借用的。

 配置项目中的pom.xml文件，配置之后可以自动的添加jar包

<dependencies>
        <!--web部建 springmvn依赖于它启动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--初始化不需要-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--mysql配置-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--测试的jar-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--配置连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!--导入StringUtils.lang3-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-core</artifactId>
            <version>3.0.7.1</version>
        </dependency> 
        // 此处为了可以使用 @Data注解 可以省区 get set写法。
       <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
    </dependencies>

每一个配置<dependency> 都有着注解，下面我们来配置Maven导入jar包,右键项目找到Open in Terminal  点击如图：

 输入命令  mvn clean install    //清除旧包，导入新包的命令。首次输入会等待很长时间，不要慌，千万不要慌哦，下载完成

下面要写application.properties: 如下

#端口号
server.port=8080
#访问路径
server.servlet.context-path=/demo
#访问数据库
jdbc.driver=com.mysql.cj.jdbc.Driver
# 数据库url
jdbc.url=jdbc:mysql://localhost:3306/spring?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT
# 数据库用户名
jdbc.username=root
# 密码
jdbc.password=Admin@123

#Mybatis 配置
mybatis_config_file=mybatis-config.xml
mapper_path=/mapper/*.xml
entity_package=com.spring.demo.bean

这里配置一下mybatis-config.xml 配置：这些可以配置在 application.properties中的，暂时配置在这里，之后我会使用application.yml 进行配置这些。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--配置全局变量-->
    <settings>
        <setting name="useGeneratedKeys" value="true"/>
        <!--使用列标签替换列别名 默认：true-->
        <setting name="useColumnLabel" value="true"></setting>
        <!--开启驼峰命名：Table{create_Time} -> Entity{createTime}-->
        <setting name="mapUnderscoreToCamelCase" value="true"></setting>
    </settings>
</configuration>

 

 开始创建连接application.properties的配置文件，首先配置数据源，连接数据库使用，

package com.spring.demo.config.dao;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.beans.PropertyVetoException;
/*
* <p>
*     数据源配置  @Configuration（告诉spring容器需要来到这个累下面）
*     @MapperScan（扫面dao mapper的路径）
 * </p>
* @author hcq
* @date 15:35 2019/1/16
* @description DataSourceConfiguration
**/
@Configuration
@MapperScan("com.spring.dao")
public class DataSourceConfiguration {
    @Value("${jdbc.driver}")
    private String jdbcDricer; //从application.properties中取出配置JDBC
    @Value("${jdbc.url}")
    private String jdbcUrl;//  取出路径
    @Value("${jdbc.username}")
    private String jdbcUsername;//取出用户名
    @Value("${jdbc.password}")
    private String jdbcPassword;// 去除你的密码
    //  bean 注入连接  SessionFactoryConfiguration（这一步为了dataSource和mybatis绑定到一起）
    @Bean(name = "dataSource")
    public ComboPooledDataSource creatDataSource() throws PropertyVetoException {
        //创建数据池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //获取jdbc值  以下一样
        dataSource.setDriverClass(jdbcDricer);
        dataSource.setJdbcUrl(jdbcUrl);
        dataSource.setUser(jdbcUsername);
        dataSource.setPassword(jdbcPassword);
        //关闭后不自动commit(提交)
        dataSource.setAutoCommitOnClose(false);
        return dataSource;
    }

}

现在写一下刚才注入连接的Bean  把dataSource 和MyBatis 绑定到一起。

package com.spring.demo.config.dao;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.web.util.pattern.PathPattern;

import javax.sql.DataSource;
import java.io.IOException;

/*
 * <p>
 *     dataSource和mybatis绑定到一起
 *     支持事务的SessionFactory
 * </p>
 * @author hcq
 * @date 13:16 2019/1/11
 * @description SessionFactoryConfiguration
 **/
@Configuration
public class SessionFactoryConfiguration {
    //mybatis-config.xml配置文件的路径
    @Value("${mybatis_config_file}")
    private String mybatisConfigFilePath;
    //mybatis mapper文件所在路径
    @Value("${mapper_path}")
    private String mapperPath;
    @Autowired
    @Qualifier("dataSource")
    private DataSource dataSource;
    //扫描bean
    @Value("${entity_package}")
    private String entityPackage;

    /*
     * <p>
     *     初始化SqlSessionFactoryBean
     * </p>
     * @author hcq
     * @date 2019/1/11 15:17
     * @param
     * @return
     * @description
     **/
    @Bean("sqlSessionFactory")
    public SqlSessionFactoryBean createSqlSessionFactoryBean() throws IOException {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //扫描mybatis.xml路径
        sqlSessionFactoryBean.setConfigLocation(new ClassPathResource(mybatisConfigFilePath));
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        String packageSearchPath = PathMatchingResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + mapperPath;
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources(packageSearchPath));
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTypeAliasesPackage(entityPackage);
        return sqlSessionFactoryBean;
    }
}

现在扫描dao接口：

package com.spring.demo.config.dao;

import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
* <p>
*     扫描dao
* </p>
* @author 郝昌祺
* @date 15:43 2019/1/16
* @description MybatiMapperScannerConfig
**/
@Configuration
@AutoConfigureAfter(DataSourceConfiguration.class)
public class MybatiMapperScannerConfig {

    @Bean
    public MapperScannerConfigurer creanMapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer =new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        mapperScannerConfigurer.setBasePackage("com.spring.demo.dao");//这里写的是你的dao层的url
        return mapperScannerConfigurer;
    }
}

以上配置就ok了，现在可以写小程序的增删改查以及登陆了，

先创建数据库，先创用户表  tb_user:   还有区域表 tb_area: 

数据库创建完成以后  写bean  实体类。

User  实体类：

package com.spring.demo.bean;

import lombok.Data;

import java.io.Serializable;
@Data  // 此注解可以省略get set
public class User implements Serializable {

    private Long id;
    /**
     * 用户名
     */
    private String username;
   /**
     * 密码
     */
    private String password;
    
}

Area  实体类：

package com.spring.demo.bean;

import lombok.Data;

import java.util.Date;
@Data
public class Area {

    private Integer areaId;
    /**
     * 区域名
     */
    private String areaName;
    /**
     * 优先级
     */
    private Integer priority;
    /**
     * 开始时间
     */
    private Date createTime;
    /**
     * 结束时间
     */
    private Date lastEditTime;

}

接下来我们要写的是什么呢？   对就是Mapper   接口编写SQL  我们用的是MyBatis-plus,不得不说MyBtais-plus真的强大，

简单介绍一下 MyBatis 和 MyBatis-plus的区别， Mybatis-plus 可以直接生成简单的增删该查，直接生成代码的，而且 

MyBatis-plus 是加强版的MyBatis， 只是做了增强，并没有修改MyBatis,

UserDaoMapper

package com.spring.demo.dao;

import com.spring.demo.bean.User;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface UserDaoMapper {

    // 登陆的sql 接口
    User loginUser(@Param("username")String userName,@Param("password")String password);


}


// 对应的xml 文件
/*
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.spring.demo.dao.UserDaoMapper">

    <select id="loginUser" resultType="com.spring.demo.bean.User">
        select * from `user` where username=#{username} and `password` = #{password}
    </select>
</mapper>
*/

AraeDaoMapper: 编写sql   我这个项目还是用的MyBatis  最近准备升级为 MyBatis-plus,我会及时更新的。

package com.spring.demo.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.spring.demo.bean.Area;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

import java.util.List;
public interface AreaDaoMapper extends BaseMapper<Area> {
    //区域查
    List<Area> showArea();
    //区域id查
    Area showAreaById(Integer id);
    //区域增
    Integer insertArea(@Param("area") Area area);
    //区域修改
    Integer updateArea(@Param("area")Area area);
    //区域删除
    Integer deleteArea(@Param("id")Integer id);

}



/*  对应的xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.spring.demo.dao.AreaDaoMapper">
    <insert id="insertArea" useGeneratedKeys="true" keyProperty="areaId" keyColumn="area_id" parameterType="com.spring.demo.bean.Area">
        INSERT INTO `tb_area` ( `area_name`, `priority`, `create_time`, `last_edit_time`)
        VALUES (#{area.areaName}, #{area.priority}, #{area.createTime}, #{area.lastEditTime});
    </insert>
    <update id="updateArea" parameterType="com.spring.demo.bean.Area">
        UPDATE tb_area SET area_name=#{area.areaName},priority=#{area.priority},
        create_time=#{area.createTime},last_edit_time=#{area.lastEditTime}
        where area_id=#{area.areaId};
    </update>
    <delete id="deleteArea" parameterType="com.spring.demo.bean.Area">
        DELETE from tb_area where area_id = #{id}
    </delete>
    <select id="showArea" resultType="com.spring.demo.bean.Area">
        select * from tb_area ORDER BY priority DESC
    </select>
    <select id="showAreaById" resultType="com.spring.demo.bean.Area">
        select * from tb_area where area_id = #{id}
    </select>
</mapper>
*/

这里我介绍一下上面写的 extends BaseMapper 可以看看BaseMapper里面的方法：直接调用方法可以省去编写SQL，这个就是MyBatis的升级版 MyBatis-plus, 如果有兴趣深入了解，跳转此链接：https://mp.baomidou.com/guide/wrapper.html#excludecolumns

public interface BaseMapper<T> {
 
    /**
     * <p>
     * 插入一条记录
     * </p>
     *
     * @param entity 实体对象
     */
    Integer insert(T entity);
 
    /**
     * <p>
     * 根据 ID 删除
     * </p>
     *
     * @param id 主键ID
     */
    Integer deleteById(Serializable id);
 
    /**
     * <p>
     * 根据 columnMap 条件，删除记录
     * </p>
     *
     * @param columnMap 表字段 map 对象
     */
    Integer deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
 
    /**
     * <p>
     * 根据 entity 条件，删除记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Integer delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 删除（根据ID 批量删除）
     * </p>
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    Integer deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
 
    /**
     * <p>
     * 根据 ID 修改
     * </p>
     *
     * @param entity 实体对象
     */
    Integer updateById(@Param(Constants.ENTITY) T entity);
 
    /**
     * <p>
     * 根据 whereEntity 条件，更新记录
     * </p>
     *
     * @param entity        实体对象 (set 条件值,不能为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    Integer update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
 
    /**
     * <p>
     * 根据 ID 查询
     * </p>
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);
 
    /**
     * <p>
     * 查询（根据ID 批量查询）
     * </p>
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
 
    /**
     * <p>
     * 查询（根据 columnMap 条件）
     * </p>
     *
     * @param columnMap 表字段 map 对象
     */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
 
    /**
     * <p>
     * 根据 entity 条件，查询一条记录
     * </p>
     *
     * @param queryWrapper 实体对象
     */
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询总记录数
     * </p>
     *
     * @param queryWrapper 实体对象
     */
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 entity 条件，查询全部记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录
     * 注意： 只返回第一个字段的值
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 entity 条件，查询全部记录（并翻页）
     * </p>
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     * </p>
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     */
    IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

继续看一下AreaService:  

package com.spring.demo.service.serviceImpl;

import com.spring.demo.bean.Area;
import com.spring.demo.dao.AreaDaoMapper;
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.List;
@Service
public class AreaService {
    @Autowired
    private AreaDaoMapper areaDao;

    /**
     * @return 查询区域
     */
    public List<Area> showArea() {
        return areaDao.showArea();
    }

    public Area showAreaById(Integer id) {
        // 这里有一个更简单方便的使用方法  在AreaDaoMapper里面继承extends BaseMapper<Area> 可以使用  areaDao.selectById(id);方法 免去编写sql
        return areaDao.showAreaById(id);
    }
    @Transactional
    public Boolean insertArea(Area area) {
        if(area.getAreaName() != null && area.getAreaName()!=""){
          area.setCreateTime(new Date());
          area.setLastEditTime(new Date());
          try {
              int effectedNum = areaDao.insertArea(area);
              if(effectedNum>0){
                  return true;
              } else {
                  throw new RuntimeException("插入区域信息失败！！！");
              }
          } catch (Exception e){
              throw new RuntimeException("插入区域信息失败！！！"+e.toString());
          }
        }else{
            throw new RuntimeException("插入信息不能为空！！！");
        }
    }

    public Boolean updateArea(Area area) {
        if(area.getAreaName() != null && area.getAreaName() != ""){
            try {


                int effectedNum = areaDao.updateArea(area);
                if (effectedNum > 0) {
                    return true;
                } else {
                    throw new RuntimeException("更新数据失败！！");
                }
            }catch (Exception e){
                throw new RuntimeException("插入数据失败！"+e.toString());
            }
        }else{
            throw new RuntimeException("区域不能为空！！");
        }
    }

    public Boolean deleteArea(Integer id) {
       if(id >0){
           try {
               int effectedNum = areaDao.deleteArea(id);
               if(effectedNum > 0){
                   return true;
               }else{
                   return false;
               }
           }catch (Exception e){
               throw new RuntimeException("删除数据失败！~");
           }
       }else{
          throw  new RuntimeException("区域id不能为空");
       }

    }

}

再来看一下UserService:

package com.spring.demo.service.serviceImpl;

import com.spring.demo.bean.User;
import com.spring.demo.dao.UserDaoMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestBody;

@Service
public class UserService {
    @Autowired
    private UserDaoMapper userDao;

    public Boolean loginUser(@RequestBody String userName, @RequestBody String password) {
        if (StringUtils.isNotBlank(userName) && StringUtils.isNotBlank(password)) {
            User user = userDao.loginUser(userName, password);
            if(user != null){
                return true;
            }else {
                return false;
            }
        } else {
            return false;
        }
    }
}

最后看一下 AreaController:

package com.spring.demo.controller;

import com.spring.demo.bean.Area;
import com.spring.demo.service.serviceImpl.AreaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;

@RequestMapping("/area")
@RestController
public class AreaController {
    @Autowired
    private AreaService areaService;

    @RequestMapping(value = "/listArea",method = RequestMethod.GET)
    public Map<String,Object> listArea(){
        Map<String,Object> areaMap = new HashMap<>();
        List<Area> areaList = areaService.showArea();
        areaMap.put("areaList",areaList);
        return areaMap;
    }

    @RequestMapping(value = "/listByIdArea",method = RequestMethod.GET)
    public Map<String,Object> listAreaById(Integer areaId){
       Map<String,Object> areaMapById = new HashMap<>();
       Area area = areaService.showAreaById(areaId);
       areaMapById.put("area",area);
       return areaMapById;
     }

     @RequestMapping(value = "/addArea",method = RequestMethod.POST)
    public Map<String,Object> addArea(@RequestBody Area area){
     Map<String,Object> addArea = new HashMap<>();
     addArea.put("success",areaService.insertArea(area));
     return addArea;
     }

    @RequestMapping(value = "/updateArea",method = RequestMethod.POST)
    public Map<String,Object> updateArea(@RequestBody Area area){
        Map<String,Object> updateArea = new HashMap<>();
        updateArea.put("success",areaService.updateArea(area));
        return updateArea;
    }

    @RequestMapping(value = "/deleteArea",method = RequestMethod.GET)
    public Map<String,Object> deleteArea( Integer areaId){
        Map<String,Object> deleteArea = new HashMap<>();
        deleteArea.put("success",areaService.deleteArea(areaId));
        return deleteArea;
    }

}

UserController:

package com.spring.demo.controller;

import com.spring.demo.bean.User;
import com.spring.demo.service.serviceImpl.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "login")
    public Boolean loginNameByPwd(@RequestBody User user){
       Boolean aBoolean = userService.loginUser(user.getUsername(),user.getPassword());
       if(aBoolean == false){
          return false;
       }else {
           return true;
       }
    }
}

好了，以上就是Java的整体编写，小程序的代码我就不贴出来了，我直接放在百度网盘上面了，运行本地是直接可以使用的，不过得下载一下 微信小程序开发者工具工具的样式如下图，我直接把项目放在百度网盘上：

微信小程序的代码：

链接：https://pan.baidu.com/s/1UBZprmmaHrcyxjpG1omdTg 
提取码：sapy 

SpringBoot后台代码（内涵有MySQL数据库）：

链接：https://pan.baidu.com/s/1Kmh9fBMlbYZ8FfGaJwnLMg 
提取码：ewg8

好了，到这里我也是写完了，如果有Bug，或则解决不了的问题可以评论问我，本人文采不咋滴，各位见谅。

祝愿各位  开开心心学习，写的代码没BUG 。