ruoyi-vue v3.8.3新增微信用户code登录（带用户权限）

已于 2024-05-24 18:12:04 修改
阅读量2.1k 收藏 33
点赞数 10
分类专栏： ruoyi-vue 文章标签： 微信 java ruoyi-vue spring boot spring security
于 2023-06-12 18:12:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43871182/article/details/131174399
版权

1.创建微信登录token验证-WxCodeAuthenticationToken

模仿
UsernamePasswordAuthenticationToken 实现

package com.szbt.framework.security.wx;  
  
import org.springframework.security.authentication.AbstractAuthenticationToken;  
import org.springframework.security.core.GrantedAuthority;  
import org.springframework.security.core.SpringSecurityCoreVersion;  
  
import java.util.Collection;  
  
/**  
 * @author wut  
 * @PackageName:com.szbt.framework.security.authentication  
 * @ClassName:WxCodeAuthenticationToken  
 * @Description: 自定义微信登录token验证  
 * @date 2023/6/12 10:40  
 */
 public class WxCodeAuthenticationToken extends AbstractAuthenticationToken {  
  
    private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;  
  
    /**  
     * 在 UsernamePasswordAuthenticationToken 中该字段代表登录的用户名，  
     * 在这里就代表登录的openId  
     */    private final Object principal;  
  
    /**  
     * 构建一个没有鉴权的 WxCodeAuthenticationToken  
     */    public WxCodeAuthenticationToken(Object principal) {  
        super(null);  
        this.principal = principal;  
        setAuthenticated(false);  
    }  
  
    /**  
     * 构建拥有鉴权的 WxCodeAuthenticationToken  
     */    
     public WxCodeAuthenticationToken(Object principal, Collection<? extends GrantedAuthority> authorities) {  
        super(authorities);  
        this.principal = principal;  
        // must use super, as we override  
        super.setAuthenticated(true);  
    }  
  
    @Override  
    public Object getCredentials() {  
        return null;  
    }  
  
    @Override  
    public Object getPrincipal() {  
        return this.principal;  
    }  
  
    @Override  
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {  
        if (isAuthenticated) {  
            throw new IllegalArgumentException(  
                    "Cannot set this token to trusted - use constructor which takes a GrantedAuthority list instead");  
        }  
  
        super.setAuthenticated(false);  
    }  
  
    @Override  
    public void eraseCredentials() {  
        super.eraseCredentials();  
    }  
  
}

2.创建登陆鉴权 Provider-WxCodeAuthenticationProvider

package com.szbt.framework.security.wx;  
  
import org.springframework.security.authentication.AuthenticationProvider;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.AuthenticationException;  
import org.springframework.security.core.userdetails.UserDetails;  
import org.springframework.security.core.userdetails.UserDetailsService;  
  
/**  
 * @author wut  
 * @PackageName:com.szbt.framework.security.wx  
 * @ClassName:WxCodeAuthenticationProvider  
 * @Description: wx登陆鉴权 Provider，要求实现 AuthenticationProvider 接口  
 * @date 2023/6/12 10:47  
 */
 public class WxCodeAuthenticationProvider implements AuthenticationProvider {  
  
    private UserDetailsService userDetailsService;  
  
    @Override  
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {  
        WxCodeAuthenticationToken authenticationToken = (WxCodeAuthenticationToken) authentication;  
  
        String openId = (String) authenticationToken.getPrincipal();  
  
        UserDetails userDetails = userDetailsService.loadUserByUsername(openId);  
  
        // 此时鉴权成功后，应当重新 new 一个拥有鉴权的 authenticationResult 返回  
        WxCodeAuthenticationToken authenticationResult = new WxCodeAuthenticationToken(userDetails, userDetails.getAuthorities());  
  
        authenticationResult.setDetails(authenticationToken.getDetails());  
  
        return authenticationResult;  
    }  
  
  
    @Override  
    public boolean supports(Class<?> authentication) {  
        // 判断 authentication 是不是 WxCodeAuthenticationToken 的子类或子接口  
        return WxCodeAuthenticationToken.class.isAssignableFrom(authentication);  
    }  
  
    public UserDetailsService getUserDetailsService() {  
        return userDetailsService;  
    }  
  
    public void setUserDetailsService(UserDetailsService userDetailsService) {  
        this.userDetailsService = userDetailsService;  
    }  
}

3.编写UserDetailsService实现类-UserDetailsByOpenIdServiceImpl

package com.szbt.framework.web.service;  
  
import com.szbt.common.core.domain.entity.SysUser;  
import com.szbt.common.core.domain.model.LoginUser;  
import com.szbt.common.enums.UserStatus;  
import com.szbt.common.exception.base.BaseException;  
import com.szbt.common.utils.StringUtils;  
import com.szbt.system.service.ISysUserService;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.security.core.userdetails.UserDetails;  
import org.springframework.security.core.userdetails.UserDetailsService;  
import org.springframework.security.core.userdetails.UsernameNotFoundException;  
import org.springframework.stereotype.Service;  
  
/**  
 * @author wut  
 * @PackageName:com.szbt.framework.web.service  
 * @ClassName:UserDetailsByOpenIdServiceImpl  
 * @Description:  wx用户验证处理  
 * @date 2023/6/12 10:48  
 */
@Service("UserDetailsByOpenIdServiceImpl")  
public class UserDetailsByOpenIdServiceImpl implements UserDetailsService {  
  
    private static final Logger log = LoggerFactory.getLogger(UserDetailsByOpenIdServiceImpl.class);  
  
    @Autowired  
    private ISysUserService userService;  
  
    @Autowired  
    private SysPermissionService permissionService;  
  
    @Override  
    public UserDetails loadUserByUsername(String openId) throws UsernameNotFoundException {  
        SysUser user = userService.selectWxUserByOpenId(openId);  
        if (StringUtils.isNull(user)) {  
            log.info("登录用户：{} 不存在.", openId);  
            throw new UsernameNotFoundException("登录用户：" + openId + " 不存在");  
        } else if (UserStatus.DELETED.getCode().equals(user.getDelFlag())) {  
            log.info("登录用户：{} 已被删除.", openId);  
            throw new BaseException("对不起，您的账号：" + openId + " 已被删除");  
        } else if (UserStatus.DISABLE.getCode().equals(user.getStatus())) {  
            log.info("登录用户：{} 已被停用.", openId);  
            throw new BaseException("对不起，您的账号：" + openId + " 已停用");  
        }  
  
        return createLoginUser(user);  
    }  
  
    public UserDetails createLoginUser(SysUser user) {  
        return new LoginUser(user.getUserId(), user.getDeptId(), user, permissionService.getMenuPermission(user));  
    }  
}

4. 完善SecurityConfig配置类

package com.szbt.framework.config;  
  
import com.szbt.framework.security.filter.JwtAuthenticationTokenFilter;  
import com.szbt.framework.security.handle.AuthenticationEntryPointImpl;  
import com.szbt.framework.security.handle.LogoutSuccessHandlerImpl;  
import com.szbt.framework.security.wx.WxCodeAuthenticationProvider;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.beans.factory.annotation.Qualifier;  
import org.springframework.context.annotation.Bean;  
import org.springframework.http.HttpMethod;  
import org.springframework.security.authentication.AuthenticationManager;  
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;  
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;  
import org.springframework.security.config.annotation.web.builders.HttpSecurity;  
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;  
import org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer;  
import org.springframework.security.config.http.SessionCreationPolicy;  
import org.springframework.security.core.userdetails.UserDetailsService;  
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;  
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;  
import org.springframework.security.web.authentication.logout.LogoutFilter;  
import org.springframework.web.filter.CorsFilter;  
import com.szbt.framework.config.properties.PermitAllUrlProperties;  
  
/**  
 * spring security配置  
 *  
 * @author szbt  
 */
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)  
public class SecurityConfig extends WebSecurityConfigurerAdapter {  
    /**  
     * 自定义用户认证逻辑  
     */  
    @Autowired  
    @Qualifier("UserDetailsByUsernameServiceImpl")  
    private UserDetailsService userDetailsService;  
  
  
    /**  
     * 自定义用户(手机号验证码)认证逻辑  
     */  
    @Autowired  
    @Qualifier("UserDetailsByOpenIdServiceImpl")  
    private UserDetailsService userDetailsServiceByOpenId;  
  
    /**  
     * 认证失败处理类  
     */  
    @Autowired  
    private AuthenticationEntryPointImpl unauthorizedHandler;  
  
    /**  
     * 退出处理类  
     */  
    @Autowired  
    private LogoutSuccessHandlerImpl logoutSuccessHandler;  
  
    /**  
     * token认证过滤器  
     */  
    @Autowired  
    private JwtAuthenticationTokenFilter authenticationTokenFilter;  
  
    /**  
     * 跨域过滤器  
     */  
    @Autowired  
    private CorsFilter corsFilter;  
  
    /**  
     * 允许匿名访问的地址  
     */  
    @Autowired  
    private PermitAllUrlProperties permitAllUrl;  
  
    /**  
     * 解决 无法直接注入 AuthenticationManager  
     *     * @return  
     * @throws Exception  
     */    
    @Bean  
    @Override    
    public AuthenticationManager authenticationManagerBean() throws Exception {  
        return super.authenticationManagerBean();  
    }  
  
    /**  
     * anyRequest          |   匹配所有请求路径  
     * access              |   SpringEl表达式结果为true时可以访问  
     * anonymous           |   匿名可以访问  
     * denyAll             |   用户不能访问  
     * fullyAuthenticated  |   用户完全认证可以访问（非remember-me下自动登录）  
     * hasAnyAuthority     |   如果有参数，参数表示权限，则其中任何一个权限可以访问  
     * hasAnyRole          |   如果有参数，参数表示角色，则其中任何一个角色可以访问  
     * hasAuthority        |   如果有参数，参数表示权限，则其权限可以访问  
     * hasIpAddress        |   如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问  
     * hasRole             |   如果有参数，参数表示角色，则其角色可以访问  
     * permitAll           |   用户可以任意访问  
     * rememberMe          |   允许通过remember-me登录的用户访问  
     * authenticated       |   用户登录后可访问  
     */  
    @Override  
    protected void configure(HttpSecurity httpSecurity) throws Exception {  
  		
  		// wx登陆鉴权 Provider
        WxCodeAuthenticationProvider wxCodeAuthenticationProvider = new WxCodeAuthenticationProvider();  
        wxCodeAuthenticationProvider.setUserDetailsService(userDetailsServiceByOpenId);  
  
        // 注解标记允许匿名访问的url  
        ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = httpSecurity.authorizeRequests();  
        permitAllUrl.getUrls().forEach(url -> registry.antMatchers(url).permitAll());  
  
        httpSecurity  
                // CSRF禁用，因为不使用session  
                .csrf().disable()  
                // 禁用HTTP响应标头  
                .headers().cacheControl().disable().and()  
                // 认证失败处理类  
                .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()  
                // 基于token，所以不需要session  
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()  
                // 过滤请求  
                .authorizeRequests()  
                // 对于登录login 注册register 验证码captchaImage 允许匿名访问  
                .antMatchers("/login", "/register", "/captchaImage").permitAll()  
                // 对于登录wxlogin  允许匿名访问  
                .antMatchers("/wxLogin").permitAll()  
                // 静态资源，可匿名访问  
                .antMatchers(HttpMethod.GET, "/", "/*.html", "/**/*.html", "/**/*.css", "/**/*.js", "/profile/**").permitAll()  
                .antMatchers("/swagger-ui.html", "/swagger-resources/**", "/webjars/**", "/*/api-docs", "/druid-5694/**").permitAll()  
                // 除上面外的所有请求全部需要鉴权认证  
                .anyRequest().authenticated()  
                .and()  
                .headers().frameOptions().disable();  
        // 添加Logout filter  
        httpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);  
        // 添加JWT filter  
        httpSecurity.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);  
        // 添加CORS filter  
        httpSecurity.addFilterBefore(corsFilter, JwtAuthenticationTokenFilter.class);  
        httpSecurity.addFilterBefore(corsFilter, LogoutFilter.class)  
                //wx登录验证的provider  
                .authenticationProvider(wxCodeAuthenticationProvider);;  
    }  
  
    /**  
     * 强散列哈希加密实现  
     */  
    @Bean  
    public BCryptPasswordEncoder bCryptPasswordEncoder() {  
        return new BCryptPasswordEncoder();  
    }  
  
    /**  
     * 身份认证接口  
     */  
    @Override  
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {  
        auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());  
    }  
}

5.编写wxCode登录接口

5.1 SysLoginController中添加登录接口

/**  
 * 登录方法  
 *  
 * @param wxLoginBody 登录信息  
 * @return 结果  
 */  
@PostMapping("/wxLogin")  
public AjaxResult wxLogin(@RequestBody WxLoginBody wxLoginBody) {  
    AjaxResult ajax = AjaxResult.success();  
    //微信官方提供的微信小程序登录授权时使用的URL地址  
    String url = "https://api.weixin.qq.com/sns/jscode2session";  
  
    /**  
     * 拼接需要的参数  
     * appid = AppID 你自己的微信小程序APPID  
     * js_code = AppSecret 你自己的微信APP密钥  
     * grant_type=authorization_code = code 微信官方提供的临时凭证  
     */  
    String params = StrUtil.format("appid={}&secret={}&js_code={}&grant_type=authorization_code", wxAppConfig.getAppId(), wxAppConfig.getAppSecret(), wxLoginBody.getCode());  
    //向微信服务器发送恳求获取用户信息  
	String res = HttpUtils.sendGet(url, params);  
	log.info("wxLogin返回：{}", res);  
	WxLoginResultVo wxLoginResultVo = JSON.parseObject(res, WxLoginResultVo.class);  
	if (wxLoginResultVo.getErrcode() == 40029) {  
		return AjaxResult.error("wxLoginCode无效");  
	}  
	if (wxLoginResultVo.getErrcode() == 45011) {  
		return AjaxResult.error("API 调用太频繁，请稍候再试");  
	}  
	if (wxLoginResultVo.getErrcode() == 40226) {  
		return AjaxResult.error("高风险等级用户，小程序登录拦截 。");  
	}  
	if (wxLoginResultVo.getErrcode() == -1) {  
		return AjaxResult.error("系统繁忙，此时请开发者稍候再试");  
	}  
	String openid = wxLoginResultVo.getOpenid();  
	if (StrUtil.isEmpty(openid)) {  
		return AjaxResult.error("未获取到openid");  
    }  
    // 生成令牌  
    String token = loginService.wxLogin(openid, wxLoginBody.getNickName(), wxLoginBody.getAvatarUrl());  
    ajax.put(Constants.TOKEN, token);  
    return ajax;  
}

5.2 SysLoginService中添加登录服务

/**  
 * 微信登录  
 *  
 * @param openId 登录凭据 只能用一次  
 * @return  
 */  
public String wxLogin(String openId, String nickName, String avatarUrl) {  
  
    // 微信用户首次登录创建用户  
    //依据openid判别数据库中是否有该用户  
    //依据openid查询用户信息  
    SysUser wxUser = userService.selectWxUserByOpenId(openId);  
    //假如查不到，则新增，查到了，则更新  
    String nickNameStr = StringUtils.isEmpty(nickName) ? getStringRandom(8) : nickName;  
    String avatarUrlStr = StringUtils.isEmpty(avatarUrl) ? "/profile/avatar/2023/05/30/blob_20230530184944A001.png" : avatarUrl;  
    SysUser user = new SysUser();  
    if (ObjectUtil.isEmpty(wxUser)) {  
        // 新增  
        log.info("微信用户不存在,注册中...");  
        user.setUserName("wx" + getStringRandom(14));// 生成16位随机用户名  
        user.setPassword(SecurityUtils.encryptPassword("wx20230606@"));  
        user.setNickName(nickNameStr);  
        user.setAvatar(avatarUrlStr);  
        user.setOpenId(openId);  
        user.setDeptId(100L);  
        user.setCreateBy("微信注册");  
        //新增 用户  
        userService.insertUser(user);  
        // 分配角色  可根据需求设置默认角色及权限
        userService.insertUserAuth(user.getUserId(), new Long[]{100L});  
        // 操作完成后 查询用户明细信息  
    } else {  
        //更新  
        user = wxUser;  
        user.setNickName(nickNameStr);  
        user.setAvatar(avatarUrlStr);  
        user.setUpdateTime(DateUtils.getNowDate());  
        userService.updateUserProfile(user);  
    }  
  
    // 用户验证  
    Authentication authentication = null;  
    try {  
        // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername  
        authentication = authenticationManager  
                .authenticate(new WxCodeAuthenticationToken(openId));  
    } catch (Exception e) {  
        if (e instanceof BadCredentialsException) {  
            AsyncManager.me().execute(AsyncFactory.recordLogininfor(openId, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match")));  
            throw new UserPasswordNotMatchException();  
        } else {  
            AsyncManager.me().execute(AsyncFactory.recordLogininfor(openId, Constants.LOGIN_FAIL, e.getMessage()));  
            throw new MpsException(e.getMessage());  
        }  
    }  
    AsyncManager.me().execute(AsyncFactory.recordLogininfor(openId, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));  
    LoginUser loginUser = (LoginUser) authentication.getPrincipal();  
    // 生成token  
    return tokenService.createToken(loginUser);  
}  
  
//生成随机用户名，数字和字母组成,  
public static String getStringRandom(int length) {  
    String val = "";  
    Random random = new Random();  
    //参数length，表明生成几位随机数  
    for (int i = 0; i < length; i++) {  
        String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";  
        //输出字母仍是数字  
        if ("char".equalsIgnoreCase(charOrNum)) {  
            //输出是大写字母仍是小写字母  
            int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;  
            val += (char) (random.nextInt(26) + temp);  
        } else if ("num".equalsIgnoreCase(charOrNum)) {  
            val += String.valueOf(random.nextInt(10));  
        }  
    }  
    return "wx" + val;  
}

5.3 完善登录对象 微信用户登录对象

package com.szbt.common.core.domain.model;  
  
/**  
 * @author wut  
 * @PackageName:com.szbt.common.core.domain.model  
 * @ClassName:WxLoginBody  
 * @Description: 微信用户登录对象  
 * @date 2023/5/31 18:22  
 */public class WxLoginBody {  
  
    /**  
     * 暂时登陆凭据 code 只能运用一次  
     */  
    private String code;  
  
    /**  
     * 昵称  
     */  
    private String nickName;  
    /**  
     * 头像  
     */  
    private String avatarUrl;  
  
  
    public String getCode() {  
        return code;  
    }  
  
    public void setCode(String code) {  
        this.code = code;  
    }  
  
    public String getNickName() {  
        return nickName;  
    }  
  
    public void setNickName(String nickName) {  
        this.nickName = nickName;  
    }  
  
    public String getAvatarUrl() {  
        return avatarUrl;  
    }  
  
    public void setAvatarUrl(String avatarUrl) {  
        this.avatarUrl = avatarUrl;  
    }  
}

5.4 完善微信服务请求返回对象

package com.szbt.wxmpsms.domain.vo;  
  
  
/**  
 * @author wut  
 * @PackageName:com.szbt.wxmpsms.domain.vo  
 * @ClassName:WxLoginResultVo  
 * @Description: 微信服务请求返回对象  
 * @date 2023/5/31 12:18  
 */public class WxLoginResultVo {  
  
    /**  
     * 会话密钥  
     **/  
    private String session_key;  
  
    /**  
     * 用户在开放平台的唯一标识符，若当前小程序已绑定到微信开放平台帐号下会返回  
     **/  
    private String unionid;  
  
    /**  
     * 错误信息  
     **/  
    private String errmsg;  
  
    /**  
     * 用户唯一标识 目前只用到这个返回数据  
     **/  
    private String openid;  
  
    /**  
     * 错误码  
     **/  
    private int errcode;  
  
    public String getSession_key() {  
        return session_key;  
    }  
  
    public void setSession_key(String session_key) {  
        this.session_key = session_key;  
    }  
  
    public String getUnionid() {  
        return unionid;  
    }  
  
    public void setUnionid(String unionid) {  
        this.unionid = unionid;  
    }  
  
    public String getErrmsg() {  
        return errmsg;  
    }  
  
    public void setErrmsg(String errmsg) {  
        this.errmsg = errmsg;  
    }  
  
    public String getOpenid() {  
        return openid;  
    }  
  
    public void setOpenid(String openid) {  
        this.openid = openid;  
    }  
  
    public int getErrcode() {  
        return errcode;  
    }  
  
    public void setErrcode(int errcode) {  
        this.errcode = errcode;  
    }  
}

6.还需调整的内容

6.1 原UserDetailsServiceImpl调整(必须调整)

@Service("UserDetailsByUsernameServiceImpl")
public class UserDetailsServiceImpl implements UserDetailsService {
	...
}

6.2 sysUser调整(必须调整)

  • sys_user 增加open_id字段
  • sysUser 增加openId字段
  • ISysUserService 增加selectWxUserByOpenId查询方法
  • ISysUserService 注意crud把openId字段补充哦！

6.3 MpsException为业务模块异常通知(按需增加)

我新增业务就是wxmps
在这里插入图片描述
具体代码为：

package com.szbt.common.exception.wxmpsms;

/**
 * @author wut
 * @PackageName:com.szbt.common.exception.wxmpsms
 * @ClassName:MpsException
 * @Description: mps服务异常
 * @date 2023/6/8 19:18
 */
public class MpsException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    /**
     * 错误码
     */
    private Integer code;

    /**
     * 错误提示
     */
    private String message;

    /**
     * 错误明细，内部调试错误
     * <p>
     * 和 {@link CommonResult#getDetailMessage()} 一致的设计
     */
    private String detailMessage;

    /**
     * 空构造方法，避免反序列化问题
     */
    public MpsException() {
    }

    public MpsException(String message) {
        this.message = message;
    }

    public MpsException(String message, Integer code) {
        this.message = message;
        this.code = code;
    }

    public String getDetailMessage() {
        return detailMessage;
    }

    @Override
    public String getMessage() {
        return message;
    }

    public Integer getCode() {
        return code;
    }

    public MpsException setMessage(String message) {
        this.message = message;
        return this;
    }

    public MpsException setDetailMessage(String detailMessage) {
        this.detailMessage = detailMessage;
        return this;
    }
}

6.4 WxAppConfig为微信小程序配置(按需增加，也可以直接在SysLoginController.wxLogin写死参数)

/**
 * @author toolman
 * @PackageName:com.szbt.common.config
 * @ClassName:WxAppConfig
 * @Description: 微信小程序配置
 * @date 2023/5/31 18:32
 */
@Component
@ConfigurationProperties(prefix = "wx-app")
public class WxAppConfig {

    /**
     * APPID
     */
    private String appId;

    /**
     * APP密钥
     */
    private String appSecret;

    public String getAppId() {
        return appId;
    }

    public void setAppId(String appId) {
        this.appId = appId;
    }

    public String getAppSecret() {
        return appSecret;
    }

    public void setAppSecret(String appSecret) {
        this.appSecret = appSecret;
    }
}

配置文件application.yml中添加

# 微信小程序配置
wx-app:
    appId: 你的appId
    appSecret: 你的appSecret

6.5 优化登录用户属性(按需参考，该方法为5.2中 SysLoginService.wxLogin)

  • 优化了昵称和用户名为上一个用户的id+1，
  • 部门和角色通过系统配置的字典获取
  • 启用userType字段做两种用户区分
 /**
     * 微信登录
     *
     * @param openId 登录凭据 只能用一次
     * @return
     */
    public String wxLogin(String openId, String nickName, String avatarUrl) {

        // 微信用户首次登录创建用户
        // 依据openid判别数据库中是否有该用户
        // 依据openid查询用户信息
        SysUser wxUser = userService.selectWxUserByOpenId(openId);
        // 假如查不到，则新增，查到了，则更新
        String nickNameStr = StringUtils.isEmpty(nickName) ? getWxGenUsername() : nickName;
        String avatarUrlStr = StringUtils.isEmpty(avatarUrl) ? "http://aa.jpg" : avatarUrl;
        SysUser user = new SysUser();
        if (ObjectUtil.isEmpty(wxUser)) {
            // 新增
            log.info("微信用户不存在,注册中...");
            user.setUserName(getWxGenUsername()); // 生成随机用户名，数字和字母组成
            user.setPassword(SecurityUtils.encryptPassword("wx20230606@"));
            user.setNickName(nickNameStr);
            user.setAvatar(avatarUrlStr);
            user.setOpenId(openId);
            // 00为系统用户 01为小程序用户
            user.setUserType("01");
            // 字典中添加默认用户部门
            user.setDeptId(Long.valueOf(configService.selectConfigByKey("hd.wxuser.dept")));
            user.setCreateBy("微信注册");
            // 新增 用户
            userService.insertUser(user);
            // 分配角色  可根据需求设置默认角色及权限
            // 获取默认角色
            String roleKey = configService.selectConfigByKey("hd.wxuser.role");
            SysRole defaultRole = roleService.selectRoleByKey(roleKey);
            userService.insertUserAuth(user.getUserId(), new Long[]{defaultRole.getRoleId()});
            // 操作完成后 查询用户明细信息
        } else {
            // 更新
            log.info("微信用户存在,登录中...");
            user = wxUser;
            if (StringUtils.isEmpty(wxUser.getAvatar())) {
                 user.setAvatar(avatarUrlStr);
            }
            if (StringUtils.isEmpty(wxUser.getAvatar())) {
                user.setNickName(nickNameStr);
             }
            user.setUpdateTime(DateUtils.getNowDate());
            userService.updateUserProfile(user);
        }
        // 用户验证
        Authentication authentication = null;
        try {
            // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
            authentication = authenticationManager
                    .authenticate(new WxCodeAuthenticationToken(openId));
        } catch (Exception e) {
            if (e instanceof BadCredentialsException) {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(openId, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match")));
                throw new UserPasswordNotMatchException();
            } else {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(openId, Constants.LOGIN_FAIL, e.getMessage()));
                throw new HdException(e.getMessage());
            }
        }
        AsyncManager.me().execute(AsyncFactory.recordLogininfor(openId, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        // 生成token
        return tokenService.createToken(loginUser);
    }

    // 生成随机用户名，数字和字母组成
    public String getWxGenUsername() {
        Long userId = userService.selectUserByLast() + 1;
        return "wx" + userId;
    }

7.测试登录效果

登录接口
在这里插入图片描述
权限接口：
在这里插入图片描述

TooMan工具人
关注
  • 10
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
RuoYi-Vue-Plus 是重写 RuoYi-Vue
03-07
RuoYi-Vue-Plus 引入了更强大的权限控制机制，如基于角色的访问控制（RBAC），以及更完善的用户认证和授权，保障了系统和数据的安全。 5. **模块化设计**： 为了适应复杂的业务需求，RuoYi-Vue-Plus 采用模块化...
RuoYi-Vue-Plus 是重写 RuoYi-Vue 针对 分布式集群与多租户 场景全方位升级(不兼容原框架)
06-02
在 RuoYi-Vue-Plus 中，Vue.js 被用来构建用户界面，通过虚拟DOM技术实现高效的页面渲染，提高用户体验。同时，Vue Router 提供了强大的路由管理，Vuex 用于状态管理，这些核心库的配合使得开发更加便捷高效。 二、...
RuoYi-Vue微信小程序登录授权
热门推荐
李大哥
05-10 1万+
目前的框架中token是使用jwt生成，存储到redis控制token时效，而认证是使用UsernamePasswordAuthenticationToken实现的 这里写目录标题需求分析解决方案代码改造新建WxUser类修改LoginUser类修改SysLoginService类修改SysLoginController类修改SecurityConfig类总结 需求分析 微信小程序登录是通过上传一个code到后台，后台根据code调用微信端接口获取到openId和sessionKey（有些场景下不需要.
Ruoyi-vue前后端不分离集成微信小程序授权登录思路
weixin_43860634的博客
02-20 2850
用户进入小程序登录界面，输入手机号进行登录，后台根据手机号去数据库中查询，判断手机号是否绑定openId，如果已绑定，则页面不再弹窗 允许授权的提示。用户输入手机号，发送验证码进行登录，后台根据手机号去数据库中查询，判断手机号是否绑定openId，如果没有，则页面弹窗 允许授权的提示。方案二：调用微信接口，获取用户绑定微信的手机号，然后用手机号去数据库查询，如果查询不到，则说明非平台用户，点击一键登录，前台传递code到后台，后台根据code，调用微信接口，获得openId，
标题：【深度解析】RuoYi V3.6.3：基于Vue与Spring生态的高效能开发利器
gitblog_00061的博客
06-10 354
标题：【深度解析】RuoYi V3.6.3：基于Vue与Spring生态的高效能开发利器 项目地址:https://gitcode.com/yangzongzhuanRuoYi-fast/RuoYi-Cloud ???? 开篇导语： 在软件开发的世界中，高效的工具往往能为团队带来事半功倍的效果。今天，我们要向您推荐一个强大且全面的开源项目——RuoYi V3.6.3。这款基于Vue/Element UI...
若依框架 + uniApp 实现微信小程序授权登录
weixin_44096450的博客
06-27 1333
点击微信登陆后，向wxLogin()发起请求，如果系统用户中有open_id，则返回token；如如该用户open_id，则增加该用户，用户名与昵称随机生成16位字符，调用登陆接口，返回token。**开发工具：**IDEA、HbuilderX、Navicat、RDM。根据业务需要，如多个应用可接入统一标识UnionID。双击manifest.json进行设置。**中间件：**Redis、Mysql8.0。openId的字段映射。
结合ruoyi-cloud和ruoyi-app实现微信小程序的授权登录
胡云峰的博客
03-21 2932
文章目录1 前言1.1 环境准备1.2 登录流程图2 小程序代码2.1 RuoYi-App编辑api/login.js2.2 RuoYi-App修改store/modules/user.js2.3 RuoYi-App修改pages/mine/avatar/index.vue2.4 新增按钮微信授权登录2.5 新增参数code2.6 新增wxHandleLogin方法获取code2.7 在@/api/login.js中新增wxLogin2.8 在@/store/modules/user.js下新增WxLogi
vue 实现微信扫码登录的方法
花生日记
06-04 5293
已登录
使用Vue.js实现电脑端微信扫码登录功能
qq_35309973的博客
03-02 1148
本文将详细介绍如何使用Vue.js框架实现电脑端微信扫码登录功能。我们将通过调用微信开放平台的API，结合Vue.js的特性，实现用户在电脑端通过扫描二维码进行微信登录的功能。
内网环境中ruoyi若依实现微信小程序授权登录解决办法
weixin_43860634的博客
02-24 2158
内网环境中ruoyi若依实现微信小程序授权登录解决办法
vue3+vite微信二维码扫描登录教程，简单易懂，提供多种方法，写这个的时候也是遇到很多坑，记录并分享一下心得体会
Gy_gsdsb的博客
01-08 2812
vue3微信二维码登录
ruoyi-vue-pro开发指南PDF下载
03-07
ruoyi-vue-pro开发指南PDF下载 包含各种组件开发指南
RuoYi-Vue全新Pro版本
10-09
基于Spring Boot + MyBatis Plus + Vue & Element实现的后台管理系统+微信小程序，支持RBAC动态权限、数据权限、SaaS多机场、Flowable工作流、三方登录、支付、短信、商城等功能。你的下载，是作者生发的动力！
若依ruoyi ruoyi-vue ruoyi-cloud 微服务全网最全视频教程网盘资源
12-25
若依ruoyi ，ruoyi-vue， ruoyi-cloud， 微服务全网最全视频教程网盘资源 若依框架系列视频教程(RuoVi-Vue前后端分高版本) 01 项目概述,mp4 02 项目运行,mp4 03 构建发布到 RuoYi-Cloud 微服务版本视频课程目录 ├...
vue项目实现微信扫码登录
weixin_44220888的博客
07-06 3207
创建组件：在Vue项目中创建一个组件，用于展示微信扫码登录的界面和处理登录逻辑。你可以在组件中引入微信登录的JavaScript SDK，并使用Axios发送请求获取登录二维码和登录状态。具体的实现方式和需求可能会有所不同，你可以根据自己的项目需求进行调整。注册微信开放平台账号并创建应用：首先，在微信开放平台上注册一个账号，并创建一个应用，获取到应用的AppID和AppSecret。后端处理登录状态检查请求：在你的后端服务器中，创建一个路由处理来接收检查登录状态的请求，并验证用户的登录状态。
若依前后端分离版ruoyi-vue：增加新的登录接口（新用户表），用于小程序或者APP获取token，并使用若依的验证方法，结合腾讯云短信验证码实现手机号+验证码登陆
ytgytg28的博客
11-19 5148
添加新用户表实体类，一定要添加Getter和Setter,之前未添加导致存入Redis后没有用户实体类的信息，查找了好久，主要是我水平有限，可能水平高的人一下就会找到原因了。路径：src/main/java/com/wanuw/common/core/domain/model/LoginUser.java。路径：src/main/java/com/wanuw/framework/config/SecurityConfig.java。根据自己腾讯云实际情况填写，下面只是个样子，*为加密。此时已经添加完成了。
vue3接入微信扫码授权登录流程
m0_62857167的博客
05-23 5331
vue3、微信、登录、微信扫码登录
人员信息二维码创建教程
caoliaoerweima的博客
03-28 338
人员信息二维码，微信扫码即可查看人员的身份、证件、资质等信息，扫码填写表单、更新状态、记录档案，实现一人一码数字化管理。
uniapp实现微信一键登录按钮样式，如何开发胶囊按钮的样式
最新发布
Python私教
07-16 315
关键点：让圆角的值变成高度的一半。
ruoyi-vue-pro 登录跳转到动态路由
08-31
ruoyi-vue-pro 是一个基于 Vue.js 和 Spring Boot 的前后端分离开发框架，用于构建管理系统和企业级应用。动态路由是指在用户登录后，系统根据用户的权限动态生成路由信息，实现根据用户不同角色显示不同功能页面的功能。 实现 ruoyi-vue-pro 登录跳转到动态路由的步骤如下： 1. 在登录界面，用户输入用户名和密码并点击登录按钮。 2. 后端接收到登录请求，进行身份验证，验证通过后返回一个包含用户信息和权限的 Token。 3. 前端接收到 Token 后，保存在本地的 session 或者 localStorage 中，用于后续的路由权限验证。 4. 前端根据用户的角色和权限信息，向后端发送请求，获取动态路由的配置信息。 5. 后端根据用户的角色和权限，根据一定的规则生成动态路由的配置信息。 6. 后端将动态路由的配置信息返回给前端。 7. 前端根据返回的动态路由配置信息，动态生成路由。 8. 根据用户的角色和权限，前端根据路由的配置信息渲染相应的页面和功能。 9. 用户登录成功后，前端根据用户的角色和权限，跳转到相应的路由页面。 以上是实现 ruoyi-vue-pro 登录跳转到动态路由的一般步骤，具体的实现细节还需要根据具体情况进行调整和完善。希望以上回答能对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值