SpringBoot后端实现微信小程序登录（JWT校验）

最新推荐文章于 2025-05-04 14:10:59 发布
最新推荐文章于 2025-05-04 14:10:59 发布
阅读量2.9k 收藏 36
点赞数 28
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： spring boot 微信小程序 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Gaomengsuanjia_/article/details/137650885

SpringBoot后端实现微信小程序登录（JWT校验）

（本篇文章采用Mybatis和Maven构建）
在开始之前我们需要引入一些依赖，其中包括mysql、mybatis、lombok、jjwt、fastjson、wechatpay等等

首先我们需要为JWT和微信小程序做一些配置

我创建了两个配置类JwtProperties和WeChatProperties:
（记得将他们交给IOC容器管理）

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "gmsj.jwt")
@Data
public class JwtProperties {
    /**
     * 用户端微信用户生成jwt令牌相关配置
     */
    private String userSecretKey;
    private long userTtl;
    private String userTokenName;

}

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "gmsj.wechat")
@Data
public class WeChatProperties {
    private String appid; //小程序的appid
    private String secret; //小程序的秘钥
}

并且在application配置文件中给出对应的配置信息:
这里的数据库配置和小程序配置要填写自己的

server:
  port: 8080
spring:
  datasource:
    #配置数据库连接信息
    url: jdbc:mysql://localhost:3306/wechat-login
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
gmsj:
  jwt:
    # 设置jwt签名加密时使用的秘钥
    user-secret-key: gaomengsuanjia
    # 设置jwt过期时间
    user-ttl: 7200000
    # 设置前端传递过来的令牌名称
    user-token-name: token
  wechat:
    #小程序的appid
    appid: wx1234567890523
    #小程序的秘钥
    secret: b0c46549847984561432165463ee6

接着我们来编写程序将要用到的一些pojo类和工具类

由于我们要用前端传来的微信授权码去请求微信接口服务器来获得openId：
微信登录流程
具体可参考微信小程序官网

所以我们要使用HttpClient来发送Http请求，还要使用JWT来生成和解析令牌，这里创建了两个工具类：

/**
 * Http工具类
 */
public class HttpClientUtil {
    static final  int TIMEOUT_MSEC = 5 * 1000;
    /**
     * 发送GET方式请求
     * @param url
     * @param paramMap
     * @return
     */
    public static String doGet(String url,Map<String,String> paramMap){
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String result = "";
        CloseableHttpResponse response = null;
        try{
            URIBuilder builder = new URIBuilder(url);
            if(paramMap != null){
                for (String key : paramMap.keySet()) {
                    builder.addParameter(key,paramMap.get(key));
                }
            }
            URI uri = builder.build();
            //创建GET请求
            HttpGet httpGet = new HttpGet(uri);
            //发送请求
            response = httpClient.execute(httpGet);
            //判断响应状态
            if(response.getStatusLine().getStatusCode() == 200){
                result = EntityUtils.toString(response.getEntity(),"UTF-8");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                response.close();
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
    /**
     * 发送POST方式请求
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPost(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);

            // 创建参数列表
            if (paramMap != null) {
                List<NameValuePair> paramList = new ArrayList();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    paramList.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }
    /**
     * 发送POST方式请求
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPost4Json(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            if (paramMap != null) {
                //构造json格式数据
                JSONObject jsonObject = new JSONObject();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    jsonObject.put(param.getKey(),param.getValue());
                }
                StringEntity entity = new StringEntity(jsonObject.toString(),"utf-8");
                //设置请求编码
                entity.setContentEncoding("utf-8");
                //设置数据类型
                entity.setContentType("application/json");
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }
    private static RequestConfig builderRequestConfig() {
        return RequestConfig.custom()
                .setConnectTimeout(TIMEOUT_MSEC)
                .setConnectionRequestTimeout(TIMEOUT_MSEC)
                .setSocketTimeout(TIMEOUT_MSEC).build();
    }

}

/**
 * JWT工具类
 */
public class JwtUtil {
    /**
     * 生成jwt
     * 使用Hs256算法, 私匙使用固定秘钥
     *
     * @param secretKey jwt秘钥
     * @param ttlMillis jwt过期时间(毫秒)
     * @param claims    设置的信息
     * @return
     */
    public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
        // 指定签名的时候使用的签名算法，也就是header那部分
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // 生成JWT的时间
        long expMillis = System.currentTimeMillis() + ttlMillis;
        Date exp = new Date(expMillis);

        // 设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置过期时间
                .setExpiration(exp);

        return builder.compact();
    }

    /**
     * Token解密
     *
     * @param secretKey jwt秘钥 此秘钥一定要保留好在服务端, 不能暴露出去, 否则sign就可以被伪造, 如果对接多个客户端建议改造成多个
     * @param token     加密后的token
     * @return
     */
    public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置需要解析的jwt
                .parseClaimsJws(token).getBody();
        return claims;
    }

}

紧接着我们来创建DTO和VO对象，接收到前端请求时，我们要获取到授权码code，然后将Token、openId等等一些必要信息响应给前端：
DTO对象:

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginDTO implements Serializable {
    //微信授权码
    private String code;
}

VO对象：

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginVO implements Serializable {
    private Long id;
    private String openid;
    private String token;
}

这里我采用了统一的响应格式：

import lombok.Data;
import java.io.Serializable;
@Data
public class Result<T> implements Serializable {
    private Integer code; //编码：1成功，0和其它数字为失败
    private String msg; //错误信息
    private T data; //数据
    public static <T> Result<T> success() {
        Result<T> result = new Result<T>();
        result.code = 1;
        return result;
    }
    public static <T> Result<T> success(T object) {
        Result<T> result = new Result<T>();
        result.data = object;
        result.code = 1;
        return result;
    }
    public static <T> Result<T> error(String msg) {
        Result result = new Result();
        result.msg = msg;
        result.code = 0;
        return result;
    }
}

现在我们要创建并注册拦截器，拦截动态请求，进行登录校验

在这之前，我们需要定义一个BaseContext类，使用ThreadLocal来存储当前线程的ID，这里将用来存储当前登录用户的userId,并且在当前线程的任何地方可以随时获取该userId:

public class BaseContext {

    public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();

    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }
    public static Long getCurrentId() {
        return threadLocal.get();
    }
    public static void removeCurrentId() {
        threadLocal.remove();
    }

}

然后创建Jwt令牌校验拦截器,这里先从请求头中提取令牌，使用先前编写的JwtUtil类进行解析令牌，判断是否为登录状态（此时我们还未编写登录模块，后面在拦截器注册时也会放行login请求，以便能够发放令牌）:

/**
 * Jwt令牌校验拦截器
 */
@Component
@Slf4j
public class JwtTokenInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtProperties jwtProperties;
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler) throws Exception{
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)){
            //当前拦截到的不是动态方法，直接放行
            return true;
        }
        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getUserTokenName());
        //2、校验令牌
        try {
            log.info("jwt登录校验{}",token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get("userId").toString());
            log.info("当前用户id:{}",userId);
            BaseContext.setCurrentId(userId);
            //3、放行
            return true;

        }catch (Exception ex){
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

接着我们创建一个配置类WebMvcConfiguration，并继承WebMvcConfigurationSupport类，用来注册我们的自定义拦截器:

/**
 * 配置类，注册web层相关组件
 */
@Configuration
@Slf4j
public class WebMvcConfiguration extends WebMvcConfigurationSupport {
    @Autowired
    private JwtTokenInterceptor jwtTokenInterceptor;
    /**
     * 注册自定义拦截器
     * @param registry
     */
    protected void addInterceptors(InterceptorRegistry registry){
        log.info("开始注册自定义拦截器.....");
        registry.addInterceptor(jwtTokenInterceptor)  //添加要注册的自定义拦截器
                .addPathPatterns("/user/**")  //要进行拦截的资源
                .excludePathPatterns("/user/user/login"); //需要放行的资源
    }
}

此时我们就可以开始编写服务模块的程序代码了

本人习惯从Controller层开始往下写
创建UserController类，在类中接收前端请求获取请求参数并封装成DTO对象，将其交给业务层进行处理，这里为Post请求方式

@RestController
@RequestMapping("/user/user")
@Slf4j
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private JwtProperties jwtProperties;
    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @PostMapping("/login")
    public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO){
        log.info("微信登录:{}",userLoginDTO);
        //获取登录user对象
        User user = userService.login(userLoginDTO);
        //封装当前用户信息
        Map<String, Object> claims = new HashMap<>();
        claims.put("userId",user.getId());
        //生成JWT令牌
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);
        //封装VO对象
        UserLoginVO userLoginVO = new UserLoginVO();
        userLoginVO.setId(user.getId());
        userLoginVO.setOpenid(user.getOpenId());
        userLoginVO.setToken(token);
        return Result.success(userLoginVO);
    }
}

接着我们要在service层中做逻辑业务处理，向微信接口服务器发送请求，获取该用户的openId并判断是否为新用户登录，并实现自动注册

public interface UserService {
    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    User login(UserLoginDTO userLoginDTO);
}

@Service
public class UserServiceImpl implements UserService {
    public static final String WxLoginUrl = "https://api.weixin.qq.com/sns/jscode2session";
    @Autowired
    private WeChatProperties weChatProperties;
    @Autowired
    private UserMapper userMapper;
    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @Override
    public User login(UserLoginDTO userLoginDTO) {
        //请求微信服务器获取openid
        Map<String, String> map = new HashMap<>();
        map.put("appid",weChatProperties.getAppid());
        map.put("secret",weChatProperties.getSecret());
        map.put("js_code",userLoginDTO.getCode());
        map.put("grant_type","authorization_code");
        String json = HttpClientUtil.doGet(WxLoginUrl, map);
        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");

        //检查openid是否为空
        if (openid == null){
            throw new LoginFailedException("登录失败");
        }
        //判断是否为新用户（自动注册）
        User user = userMapper.getUserByOpenId(openid);
        if (user == null){
            user = new User();
            user.setOpenId(openid);
            user.setCreatTime(LocalDateTime.now());
            userMapper.insert(user);
        }
        //返回用户对象
        return user;
    }
}

到这里，你会发现其中判断openid为空时会抛出异常，这里需要用到全局异常处理器，遇到的异常我们会上抛给Servlet容器，将错误信息返回给前端(所有的信息字符串都建议封装为常量类，我这里偷懒了)：

/**
 * 全局异常处理器，处理项目中抛出的业务异常
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    /**
     * 捕获业务异常
     * @param ex
     * @return
     */
    @ExceptionHandler
    public Result exceptionHandler(BaseException ex){
        log.error("异常信息：{}", ex.getMessage());
        return Result.error(ex.getMessage());
    }
    @ExceptionHandler
    public Result exceptionHandler(SQLIntegrityConstraintViolationException ex){
        String message = ex.getMessage();
        if (message.contains("Duplicate entry")){
            String[] split = message.split(" ");
            String username = split[2];
            String msg = username+ "账号已存在";
            return Result.error(msg);
        }
        else {
            return Result.error("未知错误");
        }
    }

}

/**
 * 业务异常
 */
public class BaseException extends RuntimeException {
    public BaseException() {
    }

    public BaseException(String msg) {
        super(msg);
    }
}

/**
 * 登录失败
 */
public class LoginFailedException extends BaseException{
    public LoginFailedException(String msg){
        super(msg);
    }
}

然后就可以编写持久层代码了，这里需要两个方法：

  1. 根据openId查询用户 :getUserByOpenId(String openid)
  2. 插入用户 :insert(User user)
@Mapper
public interface UserMapper {

    /**
     * 根据openid查询用户
     * @param openid
     * @return
     */
    @Select("select * from user where open_id = #{openid}")
    User getUserByOpenId(String openid);


    /**
     * 自动注册
     * @param user
     */
    void insert(User user);
}

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.gaomengsuanjia.westlake.server.mapper.UserMapper">
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        insert into user(open_id,username,phone,sex,avatar,creat_time) values (#{openId},#{username},#{phone},#{sex},#{avatar},#{creatTime})
    </insert>
</mapper>

到这里我们就实现了微信登陆的模块，可以与你的前端程序联合调试

（排版顺序不太熟练，若发现有代码错误尽管指出）

uniapp(vue3) - 实现微信小程序平台端微信授权登录功能，Java后端实现前端uniApp小程序微信授权登录，uni-app+SpringBoot微信小程序登录授权获取用户昵称头像手机号源码
资深程序员
10-26 1万+
uniapp，vue3，微信小程序，java，SpringBoot，微信授权登录，uni-app微信小程序+SpringBoot(java)实现小程序授权登录获取用户的数据，获取用户头像昵称等信息，微信小程序与Java后端实现微信授权登录功能，Uniapp微信小程序+Java实现微信授权登录，uniappvue3微信小程序登录授权，拿到用户手机号，一键登录，UNIAPP实现微信小程序登录授权和手机号授权功能(uniapp做微信小程序)，前后端源码，详细示例代码，调用微信提供的第三方接口来实现，Java
SpringBoot 集成微信小程序手机号登录实现方案
最新发布
qhj_886的博客
06-19 449
代码中的注解更详细一点,可以看注解。
Springboot实现微信小程序登录功能
m0_63624484的博客
06-15 2259
微信小程序登录功能一般用于开发微信小程序的时候，我们需要使用微信授权登录我们的微信小程序，本篇博客就微信小程序实现微信授权登录以及springboot服务端代码逻辑做一个详细讲解。
如何使用微信小程序。
weixin_46597615的博客
06-28 256
【代码】如何使用微信小程序。
springboot项目整合微信小程序登录
anan_yyds的博客
07-21 2608
1、申请小程序测试号 申请地址：https://mp.weixin.qq.com/wxamp/sandbox?doc=1 使用微信扫描二维码进行申请，申请成功之后，进入界面，获取小程序ID和秘钥 2、到项目中进行配置 首先在yml文件中配置appid和appsecret wx: # 小程序微信公众平台appId app_id: # 小程序微信公众平台api秘钥 app_secret: 整合微信登录需要向微信发送请求，所以我们引入HttpClient工具类发送http请求 引入依赖： &
基于Springboot实现微信小程序（后端）
Lysmua的博客
02-26 3001
基于Springboot实现微信小程序
SpringBoot实现微信小程序登录
热门推荐
我的博客
04-08 1万+
文章目录一、登录流程二、后端实现1、SpringBoot项目结构树2、实现auth.code2Session 接口的封装3、建立用户信息表及用户增删改查的管理4、实现登录认证及令牌生成三、前端实现与测试1、编写登录公共函数2、搭建登录页面3、登录测试 一、登录流程 首先参考小程序官方文档中的流程图： 根据流程图描述，主要步骤有以下几步 1、小程序端调用 wx.login()向微信接口服务获取...
前端uniapp+后端springboot 详细教程《实现微信小程序授权登录》（附完整前后端项目demo）
tigerhhzz的博客
05-20 9785
功能： 通过前端发送请求，请求头中携带token参数，后端接受到token，然后进行token验证，拿到openid，通过openid去数据库中查询用户信息,并返回前端。功能： 通过前端发送请求携带的参数code以及后端配置文件中的微信小程序appid和微信小程序密钥，后端拼接url向微信后台发送请求。通过拿到的openid，去数据库查询对应用户信息，如果没有openid的用户，进行新增操作；使用uniapp构建一套代码多端使用的前端框架项目。如果存在openid的用户，进行更新操作。
SpringBoot框架下微信小程序的集成策略与实践
Xs_20240309的博客
01-18 1288
通过本教程，我们详细介绍了如何在SpringBoot框架中集成微信小程序，涵盖从环境搭建到性能优化的各个环节。微信小程序作为一种创新的连接方式，允许用户在微信应用内轻松获取和分享服务，提供卓越的用户体验。研究表明，页面加载时间每增加1秒，跳出率就会提高约20%，因此优化响应速度至关重要。此外，合理的缓存策略和异步加载技术可以显著提升整体性能表现。安全性方面，引入JWT机制和数据加密手段，确保用户数据的安全传输与存储。同时，建立完善的异常处理和日志记录机制，有助于快速定位并解决问题。
springboot+security+jwt+redis 实现微信小程序登录及token权限鉴定
jamesluozhiwei的博客
07-11 1万+
tips:这是实战篇，默认各位看官具备相应的基础(文中使用了Lombok插件，如果使用源码请先安装插件) 文章目录项目配置依赖application.yml程序代码security相关security核心配置类鉴权各种情况处理类无权访问用户未登录时返回给前端的数据用户登录失败时返回给前端的数据(本程序未使用)用户登录成功时返回给前端的数据登出成功JWT自定义过滤器SelfUserDetailsSe...
微信小程序后端Springboot
07-07
微信小程序后端Springboot，功能增、删、改、查操作，一个交互demo 前端地址：https://download.youkuaiyun.com/download/huanfengzhiqiu/10526403 后端地址：https://download.youkuaiyun.com/download/huanfengzhiqiu/10526396
后端基于springboot微信小程序前端页面以及后端源码
11-26
基于springboot版微信小程序前端以及后端源码分享，大家可以参考学习，后端源码可导入IDE、前端可导入微信开发工具中正常使用
微信授权登陆全后台实现（springboot）
02-03
微信授权登陆全后台实现（springboot），博客地址https://blog.youkuaiyun.com/qq_38263083/article/details/86717327
java springboot data jpa 做的登录小程序 （未完成）
07-07
java springboot data jpa 做的登录小程序 为了熟悉springboot组件，自己写的一些测试，不足的地方大家多交流 相互提高
Springboot实现微信小程序登录
A20001230T的博客
07-19 2630
/ 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的。//商户API证书的证书序列号。//退款成功的回调地址。//支付成功的回调地址。// 指定签名的时候使用的签名算法，也就是header那部分。// 设置签名使用的签名算法和签名使用的秘钥。//小程序的appid。
Spring Boot + Spring Security + jwt实现微信小程序的后端登录
kandan_cc的博客
05-18 3133
其中wx：开头的配置，都是在请求微信接口要用到的相关数据，jwt开头的配置是生成jwt的token是使用的密钥和过期时间。相应的WxLoginService的实现类来实现具体的远程调用微信接口获取信息，并验证用户是否是新用户，最后返回token。由于需要连接数据库和使用jpa，配置文件要进行相应配置，这里把用到的全部配置都放到这里。测试接待token请求测试接口，成功的请求到了测试接口的返回值。创建一个jwt的工具类，用于生成和解析jwt的token。类，用于表示一个通过JWT认证的用户。
SpringBoot后端实现小程序微信登录
equila的博客
05-04 2167
微信小程序登录是开发者通过微信提供的身份验证机制，获取用户唯一标识(openid)和会话密钥(session_key)的过程。SpringBoot作为后端框架，可以与小程序前端配合完成完整的登录流程。小程序端调用wx.login()小程序前端调用此API获取临时登录凭证code示例代码：wx.login({// 发送code到后端})SpringBoot后端处理登录接收小程序传来的code向微信接口服务发起请求验证code获取用户唯一标识openid和会话密钥session_key。
springBoot+微信小程序登录
weixin_41988875的博客
11-01 3745
微信小程序登录流程 微信小程序登录流程涉及到三个角色：小程序、开发者服务器、微信服务器 三者交互步骤如下： 第一步：小程序通过wx.login()获取code。 第二步：小程序通过wx.request()发送code到开发者服务器。 第三步：开发者服务器接收小程序发送的code，并携带appid、appsecret（这两个需要到微信小程序后台查看）、code发送到微信服务器。 第四步：微信服务器接...
springboot小程序开发
05-10
SpringBoot小程序开发是近年来越来越流行的一种开发模式，尤其是在微信小程序等场景中越来越多的被应用。SpringBoot能够快速搭建轻量级的应用，同时可以将各种功能组件进行快速集成，因此受到了众多开发者的追捧。下面是详细介绍。 首先，SpringBoot小程序开发具有很强的可扩展性和灵活性。它可以支持多种数据库、消息队列、缓存等组件的集成，开发者可以按照自己的项目需求进行选择和组合，以满足不同场景的需求。同时，采用SpringBoot框架的应用具有高度的可测试性，开发者可以通过自动化的测试程序对应用程序进行测试，提高了开发效率和软件质量。 其次，SpringBoot小程序开发也有很好的注重安全性。它提供了多种安全机制，如基于OAuth2的安全机制等，可以满足不同项目的安全需求。 除此之外，SpringBoot小程序开发还支持多种API的开发方式，如RESTful API等，可以按照不同的具体需求来选择。同时，开发者也可以选择使用模版引擎来快速构建前端页面，避免冗长的html/css/js代码编写过程。 总之，SpringBoot小程序开发是一种非常理想的开发模式。它可以快速建立高效的应用程序，提供高度的可扩展性和灵活性，同时也支持不同的API和安全机制。因此，它被广泛应用于各种小程序开发之中，得到了开发者和用户的广泛好评。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值