uni-app +java小程序端对接微信登陆

程序员欧文

已于 2023-02-25 09:02:33 修改

阅读量2.8k

点赞数 2

文章标签： uni-app 微信微信开放平台 java

于 2023-02-14 16:48:33 首次发布

本文链接：https://blog.csdn.net/qq_60827837/article/details/129028360

版权

一：前期准备

要想实现微信登陆，首先必须注册开发者账号。

登录微信开放平台，添加移动应用并提交审核，审核通过后可获取应用ID（AppID），AppSecret等信息
在应用详情中申请开通微信登录功能，根据页面提示填写资料，提交审核
申请审核通过后即可打包使用微信授权登录功能

二：实现思路

1.app端请求调用微信登陆，用户登陆授权之后会返回一个code，通过这个code加上appid和 appSecret和可以得到access_token和openid等信息，通过access_token和openid 我们就可以去查询到用户基本登陆信息了。

在这里插入图片描述

三：具体实现

1.配置

在Hbulidx工具里打开uniapp项目，找到

manifest.json文件，在“App模块配置”项的“OAuth(登录鉴权)”下，勾选“微信登录”：

appid
微信开放平台申请应用的AppID值
appSecret（HBuilderX3.4.18+ 不再提供此参数的可视化配置，详见配置参数安全性问题）
微信开放平台申请应用的AppSecret值
UniversalLinks
iOS平台通用链接，必须与微信开放平台配置的一致，推荐使用一键生成iOS通用链接

2.前端代码

<template>
	<view class="content">
		<view class="text-area">
			<button @click="wxlogin">微信登陆</button>
		</view>
	</view>
</template>

<script>
	export default {
		data() {
			return {
				title: 'Hello'
			}
		},
		onLoad() {

		},
		methods: {
			wxlogin() {
				   
				   uni.login({
				     provider: 'weixin', //使用微信登录
					// onlyAuthorize: true,
				     success: function (loginRes) {
				       console.log(loginRes.authResult);
					   console.log("loginRes.authResult.accessToken="+loginRes.authResult.access_token)
					   uni.request({
					   		    url: 'http://192.168.1.9:8085/wx/login', //仅为示例，并非真实接口地址。
					   			method:'GET',
					   		    data: {
					   		       accessToken:loginRes.authResult.access_token,
					   		       openid:loginRes.authResult.openid,
					   		    },
					   		    
					   		});
					  },					   	
					   
					  })
				   
					

			}
		},
		
		 
	}
	
</script>

<style>

</style>

这里就简单展示一下，效果图：

点击登陆后就会自动跳转到微信登陆授权页面了。

3.后端代码

1.WechatTokenEntity类

package com.jdzh.enterprise.wxlogin;


/**
 * 描述: 凭证 </br>
 * 发布版本：V1.0 </br>
 */
public class WechatTokenEntity {
    /**
     * 接口访问凭证֤
     */
    private String accessToken;
    /**
     * 接口访问凭证֤，刷新
     */
    private String refreshToken;
    /**
     * 凭证有效期单位：second
     */
    private int expiresIn;
    /**
     * 授权用户唯一标识
     */
    private String openid;
    /**
     * 微信用户唯一标识
     */
    private String unionId;

    public String getOpenid() {
        return openid;
    }

    public void setOpenid(String openid) {
        this.openid = openid;
    }

    public String getAccessToken() {
        return accessToken;
    }

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public int getExpiresIn() {
        return expiresIn;
    }

    public void setExpiresIn(int expiresIn) {
        this.expiresIn = expiresIn;
    }

    public String getUnionId() {
        return unionId;
    }

    public void setUnionId(String unionId) {
        this.unionId = unionId;
    }

    public String getRefreshToken() {
        return refreshToken;
    }

    public void setRefreshToken(String refreshToken) {
        this.refreshToken = refreshToken;
    }
}

2.WechatTrustManager类

package com.jdzh.enterprise.wxlogin;


import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.X509TrustManager;

/**
 * 描述:信任管理器 </br>
 * 发布版本：V1.0 </br>
 */
/*
 * 证书管理器的作用是让它新人我们指定的证书，
 * 此类中的代码意味着信任所有的证书，不管是不是权威机构颁发的。
 */
public class WechatTrustManager implements X509TrustManager {
    // 检查客户端证书
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    }

    // 检查服务器端证书
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    }

    // 返回受信任的X509证书数组
    public X509Certificate[] getAcceptedIssuers() {
        return null;
    }
}

3.WechatUserEntity

package com.jdzh.enterprise.wxlogin;


import java.io.Serializable;

/**
 * 用户管理InfoVO
 *
 * @author es
 * @email es@126.com
 */
public class WechatUserEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 用户的标识
     */
    private String openId;
    /**
     * 关注状态（1是关注，0是未关注），未关注时获取不到其余信息
     */
    private int subscribe;
    /**
     * 用户关注时间，为时间戳。如果用户曾多次关注，则取最后关注时间
     */
    private String subscribeTime;
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 用户的性别（1是男性，2是女性，0是未知）
     */
    private int sex;
    /**
     * 用户所在国家
     */
    private String country;
    /**
     * 用户所在省份
     */
    private String province;
    /**
     * 用户所在城市
     */
    private String city;
    /**
     * 用户的语言，简体中文为zh_CN
     */
    private String language;
    /**
     * 用户头像
     */
    private String headImgUrl;
    /**
     * 用户特权信息
     */
    private String PrivilegeList;
    /**
     * 微信授权用户唯一标识
     */
    private String unionId;

    public String getOpenId() {
        return openId;
    }

    public void setOpenId(String openId) {
        this.openId = openId;
    }

    public int getSubscribe() {
        return subscribe;
    }

    public void setSubscribe(int subscribe) {
        this.subscribe = subscribe;
    }

    public String getSubscribeTime() {
        return subscribeTime;
    }

    public void setSubscribeTime(String subscribeTime) {
        this.subscribeTime = subscribeTime;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public String getHeadImgUrl() {
        return headImgUrl;
    }

    public void setHeadImgUrl(String headImgUrl) {
        this.headImgUrl = headImgUrl;
    }

    public String getPrivilegeList() {
        return PrivilegeList;
    }

    public void setPrivilegeList(String privilegeList) {
        PrivilegeList = privilegeList;
    }

    public String getUnionId() {
        return unionId;
    }

    public void setUnionId(String unionId) {
        this.unionId = unionId;
    }
}

4.WechatUtils

package com.jdzh.enterprise.wxlogin;



import net.sf.json.JSONException;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class WechatUtils {
    private final static Logger log = LoggerFactory.getLogger(WechatUtils.class);
    private final static String appid = "appid"; //凭证
    private final static String appsecret = "appsecret"; //凭证密钥

    // 凭证获取（GET）
    public final static String tokenUrl = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code";
    //userinfo
    public final static String userInfoUrl = "https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID&lang=zh_CN";

    /**
     * 获取接口访问凭证
     *
     * @param code app授权后传回
     * @return
     */
    public static WechatTokenEntity getToken(String code) {
        WechatTokenEntity token = new WechatTokenEntity();
//        long now = new Date().getTime();
//        if (tokenTime != 0 && now - tokenTime < 7000000) {//token有效时间 7e6 毫秒
//            return token;
//        }
        String requestUrl = tokenUrl.replace("APPID", appid).replace("SECRET", appsecret).replace("CODE", code);
        // 发起GET请求获取凭证
        JSONObject jsonObject = httpsRequest(requestUrl, "GET", null);
        if (null != jsonObject) {
            try {
                token.setUnionId(jsonObject.getString("unionid"));
                token.setOpenid(jsonObject.getString("openid"));
                token.setAccessToken(jsonObject.getString("access_token"));
                token.setRefreshToken(jsonObject.getString("refresh_token"));
                token.setExpiresIn(jsonObject.getInt("expires_in"));
            } catch (JSONException e) {
                token = null;
                // 获取token失败
                log.error("获取token失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
            }
        }
        return token;
    }

    public static void main(String args[]) {
        // 获取接口访问凭证
//        我这里是直接从前端传入accessToken，openid，所以可以直接拿到，下面是通过code生成
        String accessToken = getToken("code").getAccessToken();
        String openid = getToken("code").getOpenid();



//        /**
//         * 获取用户信息
//         */
        WechatUserEntity user = getUserInfo(accessToken, openid);
        //做这个测试的时候可以先关注，或者取消关注，控制台会打印出来此用户的openid
        System.out.println("OpenID：" + user.getOpenId());
        System.out.println("关注状态：" + user.getSubscribe());
        System.out.println("关注时间：" + user.getSubscribeTime());
        System.out.println("昵称：" + user.getNickname());
        System.out.println("性别：" + user.getSex());
        System.out.println("国家：" + user.getCountry());
        System.out.println("省份：" + user.getProvince());
        System.out.println("城市：" + user.getCity());
        System.out.println("语言：" + user.getLanguage());
        System.out.println("头像：" + user.getHeadImgUrl());
        getToken("02315v0w35TA603fsF0w3Q0fov415v0B");


    }

    /**
     * 获取用户信息
     *
     * @param accessToken 接口访问凭证
     * @param openId      用户标识
     * @return WeixinUserInfo
     */
    public static WechatUserEntity getUserInfo(String accessToken, String openId) {

        WechatUserEntity wechatUserEntity = null;
        // 拼接请求地址
        String requestUrl = userInfoUrl.replace("ACCESS_TOKEN", accessToken).replace("OPENID", openId);
        // 获取用户信息
        JSONObject jsonObject = httpsRequest(requestUrl, "GET", null);
        if (null != jsonObject) {
            try {
                wechatUserEntity = new WechatUserEntity();
                // 用户的标识
                wechatUserEntity.setOpenId(jsonObject.getString("openid"));
                wechatUserEntity.setUnionId(jsonObject.getString("unionid"));
                // 关注状态（1是关注，0是未关注），未关注时获取不到其余信息
//                wechatUserEntity.setSubscribe(jsonObject.getInt("subscribe"));
                // 用户关注时间
//                wechatUserEntity.setSubscribeTime(jsonObject.getString("subscribe_time"));
                // 昵称
                wechatUserEntity.setNickname(jsonObject.getString("nickname"));
                // 用户的性别（1是男性，2是女性，0是未知）
//                wechatUserEntity.setSex(jsonObject.getInt("sex"));
                // 用户所在国家
//                wechatUserEntity.setCountry(jsonObject.getString("country"));
                // 用户所在省份
//                wechatUserEntity.setProvince(jsonObject.getString("province"));
                // 用户所在城市
//                wechatUserEntity.setCity(jsonObject.getString("city"));
                // 用户的语言，简体中文为zh_CN
                wechatUserEntity.setLanguage(jsonObject.getString("language"));
                // 用户头像
                wechatUserEntity.setHeadImgUrl(jsonObject.getString("headimgurl"));
            } catch (Exception e) {
                int errorCode = jsonObject.getInt("errcode");
                String errorMsg = jsonObject.getString("errmsg");
//                System.err.printf("获取用户信息失败 errcode:{} errmsg:{}", errorCode, errorMsg);
            }
        }
        return wechatUserEntity;
    }

    /**
     * 发送https请求
     *
     * @param requestUrl    请求地址
     * @param requestMethod 请求方式（GET、POST）
     * @param outputStr     提交的数据
     * @return JSONObject(通过JSONObject.get ( key)的方式获取json对象的属性值)
     */
    public static JSONObject httpsRequest(String requestUrl, String requestMethod, String outputStr) {
        JSONObject jsonObject = null;
        try {
            // 创建SSLContext对象，并使用我们指定的信任管理器初始化
            TrustManager[] tm = {new WechatTrustManager()};
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, tm, new java.security.SecureRandom());
            // 从上述SSLContext对象中得到SSLSocketFactory对象
            SSLSocketFactory ssf = sslContext.getSocketFactory();

            URL url = new URL(requestUrl);
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
            conn.setSSLSocketFactory(ssf);

            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            conn.setRequestMethod(requestMethod);

            // 当outputStr不为null时向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(outputStr.getBytes(StandardCharsets.UTF_8));
                outputStream.close();
            }

            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            StringBuilder stringBuilder = new StringBuilder();
            while ((str = bufferedReader.readLine()) != null) {
                stringBuilder.append(str);
            }

            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            inputStream = null;
            conn.disconnect();
            jsonObject = JSONObject.fromObject(stringBuilder.toString());
        } catch (ConnectException ce) {
            System.err.printf("连接超时：{}", ce);
        } catch (Exception e) {
            System.err.printf("https请求异常：{}", e);
        }
        return jsonObject;
    }
}

调用main方法就可以得到我们要的用户信息了。

至于controller层怎么写，大家可以参考一下我的

package com.jdzh.enterprise.wxlogin;

import com.jdzh.enterprise.framework.entity.RespBean;
import com.jdzh.enterprise.framework.entity.User;
import com.jdzh.enterprise.framework.service.IUserService;
import net.sf.json.JSONException;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.URL;
import java.nio.charset.StandardCharsets;


@RestController
@RequestMapping("/wx")
public class WxLoginController {
    @Autowired
    IUserService iUserService;
    private final static Logger log = LoggerFactory.getLogger(WechatUtils.class);
    private final static String appid = "appid "; //凭证
    private final static String appsecret = "appsecret "; //凭证密钥

    // 凭证获取（GET）
    public final static String tokenUrl = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code";
    //userinfo
    public final static String userInfoUrl = "https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID&lang=zh_CN";

    @GetMapping("/login")
    public RespBean login(String accessToken, String openid) {
//        System.out.println("code = " + code);
//        // 获取接口访问凭证
//        String accessToken = getToken(code).getAccessToken();
//        String openid = getToken(code).getOpenid();
        System.out.println("accessToken = " + accessToken);
        System.out.println("openid = " + openid);
        /**
         * 获取用户信息
         */
        WechatUserEntity wechatUserEntity = getUserInfo(accessToken, openid);
//        System.out.println("关注状态：" + wechatUserEntity.getSubscribe());
//        System.out.println("关注时间：" + wechatUserEntity.getSubscribeTime());
        System.out.println("昵称：" + wechatUserEntity.getNickname());
//        System.out.println("性别：" + wechatUserEntity.getSex());
//        System.out.println("国家：" + wechatUserEntity.getCountry());
//        System.out.println("省份：" + wechatUserEntity.getProvince());
//        System.out.println("城市：" + wechatUserEntity.getCity());
//        System.out.println("语言：" + wechatUserEntity.getLanguage());
        System.out.println("头像：" + wechatUserEntity.getHeadImgUrl());
        String nickname = wechatUserEntity.getNickname();
        if(wechatUserEntity!=null){
           //将用户信息存在数据库中
            User user = new User();
              user.setOpenid(openid);
              user.setNickname(nickname);
              user.setIsVip(0);
              //查询openId是否存在
            User user1 = iUserService.findByOpenId(openid);
           if(user1==null){
               //如果不存在，则添加
               iUserService.save(user);
           }else{
               System.out.println("用户信息已存在");
           }

           return RespBean.ok("登陆成功",wechatUserEntity);
       }else{
           return RespBean.error("登陆失败",wechatUserEntity);
       }

    }

    /**
     * 获取用户信息
     *
     * @param accessToken 接口访问凭证
     * @param openid      用户标识
     * @return WeixinUserInfo
     */
    public static WechatUserEntity getUserInfo(String accessToken, String openid) {

        WechatUserEntity wechatUserEntity = null;
        // 拼接请求地址
        String requestUrl = userInfoUrl.replace("ACCESS_TOKEN", accessToken).replace("OPENID", openid);
        // 获取用户信息
        JSONObject jsonObject = httpsRequest(requestUrl, "GET", null);
        if (null != jsonObject) {
            try {
                wechatUserEntity = new WechatUserEntity();
                // 用户的标识
                wechatUserEntity.setOpenId(jsonObject.getString("openid"));
                wechatUserEntity.setUnionId(jsonObject.getString("unionid"));
                // 关注状态（1是关注，0是未关注），未关注时获取不到其余信息
//                wechatUserEntity.setSubscribe(jsonObject.getInt("subscribe"));
                // 用户关注时间
//                wechatUserEntity.setSubscribeTime(jsonObject.getString("subscribe_time"));
                // 昵称
                wechatUserEntity.setNickname(jsonObject.getString("nickname"));
//                 用户的性别（1是男性，2是女性，0是未知）
//                wechatUserEntity.setSex(jsonObject.getInt("sex"));
//                 用户所在国家
//                wechatUserEntity.setCountry(jsonObject.getString("country"));
//                 用户所在省份
//                wechatUserEntity.setProvince(jsonObject.getString("province"));
//                 用户所在城市
//                wechatUserEntity.setCity(jsonObject.getString("city"));
                // 用户的语言，简体中文为zh_CN
//                wechatUserEntity.setLanguage(jsonObject.getString("language"));
                // 用户头像
                wechatUserEntity.setHeadImgUrl(jsonObject.getString("headimgurl"));
            } catch (Exception e) {
                int errorCode = jsonObject.getInt("errcode");
                String errorMsg = jsonObject.getString("errmsg");
                System.err.printf("获取用户信息失败 errcode:{} errmsg:{}", errorCode, errorMsg);
            }
        }
        return wechatUserEntity;
    }

    /**
     * 发送https请求
     *
     * @param requestUrl    请求地址
     * @param requestMethod 请求方式（GET、POST）
     * @param outputStr     提交的数据
     * @return JSONObject(通过JSONObject.get ( key)的方式获取json对象的属性值)
     */
    public static JSONObject httpsRequest(String requestUrl, String requestMethod, String outputStr) {
        JSONObject jsonObject = null;
        try {
            // 创建SSLContext对象，并使用我们指定的信任管理器初始化
            TrustManager[] tm = {new WechatTrustManager()};
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, tm, new java.security.SecureRandom());
            // 从上述SSLContext对象中得到SSLSocketFactory对象
            SSLSocketFactory ssf = sslContext.getSocketFactory();

            URL url = new URL(requestUrl);
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
            conn.setSSLSocketFactory(ssf);

            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            conn.setRequestMethod(requestMethod);

            // 当outputStr不为null时向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(outputStr.getBytes(StandardCharsets.UTF_8));
                outputStream.close();
            }

            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            StringBuilder stringBuilder = new StringBuilder();
            while ((str = bufferedReader.readLine()) != null) {
                stringBuilder.append(str);
            }

            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            inputStream = null;
            conn.disconnect();
            jsonObject = JSONObject.fromObject(stringBuilder.toString());
        } catch (ConnectException ce) {
            System.err.printf("连接超时：{}", ce);
        } catch (Exception e) {
            System.err.printf("https请求异常：{}", e);
        }
        return jsonObject;
    }
}

User类

package com.jdzh.enterprise.framework.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.io.Serializable;
import java.util.Collection;


@TableName("user")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable , UserDetails {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 手机号
     */
    @TableField("phone")
    private String username;

    /**
     * 密码
     */
    private String password;
    /**
     * openid
     */
    private  String openid;
    /**
     * 微信用户名
     */
    private  String nickname;

    /**
     * 角色身份
     */
    @TableField("roleType")
    private Integer roleType;
    /**
     * 是否是vip
     */
    private Integer isVip;

    /**
     * vip截止日期
     */
    private String endTime;

    public Integer getIsVip() {
        return isVip;
    }

    public void setIsVip(Integer isVip) {
        this.isVip = isVip;
    }



    public String getEndTime() {
        return endTime;
    }

    public void setEndTime(String endTime) {
        this.endTime = endTime;
    }



    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    @Override
    public String getPassword() {
        return password;
    }




}

RespBean

package com.jdzh.enterprise.framework.entity;


public class RespBean {
    private Integer status;
    private String msg;
    private Object data;

    public static RespBean ok(String msg,Object data){
        return new RespBean(200,msg,data);
    }
    public static RespBean ok(String msg){
        return new RespBean(200,msg,null);
    }

    public static RespBean error(String msg,Object data){
        return new RespBean(500,msg,data);
    }
    public static RespBean error(String msg){
        return new RespBean(500,msg,null);
    }

    public RespBean() {
    }

    public RespBean(Integer status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}

数据库设计

小伙伴们可以根据自己的需求设计数据库表哦