既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

public Date getBindDate() {
    return bindDate;
}

public void setDelFlag(String delFlag) {
    this.delFlag = delFlag;
}

public String getDelFlag() {
    return delFlag;
}

@Override
public String toString() {
    return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
            .append("id", getId())
            .append("userId", getUserId())
            .append("thirdUniqueAccount", getThirdUniqueAccount())
            .append("thirdUniqueName", getThirdUniqueName())
            .append("thirdUniqueAvatar", getThirdUniqueAvatar())
            .append("bindType", getBindType())
            .append("bindFlag", getBindFlag())
            .append("bindDate", getBindDate())
            .append("createBy", getCreateBy())
            .append("createTime", getCreateTime())
            .append("updateBy", getUpdateBy())
            .append("updateTime", getUpdateTime())
            .append("delFlag", getDelFlag())
            .toString();
}

}

#### 2.3.2：mapper.java

package com.ruoyi.system.mapper;

import com.ruoyi.system.domain.SysUserThirdAccount;

import java.util.List;

/**

• @author xiao_he
  /
  public interface SysUserThirdAccountMapper {
  /*

  • 查询第三方账户绑定
  • @param id 第三方账户绑定主键
  • @return 第三方账户绑定
    */
    public SysUserThirdAccount selectSysUserThirdAccountById(Long id);

  /**

  • 查询第三方账户绑定列表
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 第三方账户绑定集合
    */
    public List selectSysUserThirdAccountList(SysUserThirdAccount sysUserThirdAccount);

  /**

  • 新增第三方账户绑定
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 结果
    */
    public int insertSysUserThirdAccount(SysUserThirdAccount sysUserThirdAccount);

  /**

  • 修改第三方账户绑定
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 结果
    */
    public int updateSysUserThirdAccount(SysUserThirdAccount sysUserThirdAccount);

  /**

  • 删除第三方账户绑定
  • @param id 第三方账户绑定主键
  • @return 结果
    */
    public int deleteSysUserThirdAccountById(Long id);

  /**

  • 批量删除第三方账户绑定
  • @param ids 需要删除的数据主键集合
  • @return 结果
    */
    public int deleteSysUserThirdAccountByIds(Long[] ids);
    }

#### 2.3.3：mapper对应的xml

<?xml version="1.0" encoding="UTF-8" ?>

<resultMap type="SysUserThirdAccount" id="SysUserThirdAccountResult">
    <result property="id" column="id"/>
    <result property="userId" column="user_id"/>
    <result property="thirdUniqueAccount" column="third_unique_account"/>
    <result property="thirdUniqueName" column="third_unique_name"/>
    <result property="thirdUniqueAvatar" column="third_unique_avatar"/>
    <result property="bindType" column="bind_type"/>
    <result property="bindFlag" column="bind_flag"/>
    <result property="bindDate" column="bind_date"/>
    <result property="createBy" column="create_by"/>
    <result property="createTime" column="create_time"/>
    <result property="updateBy" column="update_by"/>
    <result property="updateTime" column="update_time"/>
    <result property="delFlag" column="del_flag"/>
</resultMap>

<sql id="selectSysUserThirdAccountVo">
    select id,
           user_id,
           third_unique_account,
           third_unique_name,
           third_unique_avatar,
           bind_type,
           bind_flag,
           bind_date,
           create_by,
           create_time,
           update_by,
           update_time,
           del_flag
    from sys_user_third_account
</sql>

<select id="selectSysUserThirdAccountList" parameterType="SysUserThirdAccount"
        resultMap="SysUserThirdAccountResult">
    <include refid="selectSysUserThirdAccountVo"/>
    <where>
        <if test="userId != null ">and user_id = #{userId}</if>
        <if test="thirdUniqueAccount != null  and thirdUniqueAccount != ''">and third_unique_account =
            #{thirdUniqueAccount}
        </if>
        <if test="thirdUniqueName != null  and thirdUniqueName != ''">and third_unique_name like concat('%',
            #{thirdUniqueName}, '%')
        </if>
        <if test="thirdUniqueAvatar != null  and thirdUniqueAvatar != ''">and third_unique_avatar =
            #{thirdUniqueAvatar}
        </if>
        <if test="bindType != null  and bindType != ''">and bind_type = #{bindType}</if>
        <if test="bindFlag != null  and bindFlag != ''">and bind_flag = #{bindFlag}</if>
        <if test="bindDate != null ">and bind_date = #{bindDate}</if>
        <if test="1==1 "> and del_flag ='0' </if>
    </where>
</select>

<select id="selectSysUserThirdAccountById" parameterType="Long" resultMap="SysUserThirdAccountResult">
    <include refid="selectSysUserThirdAccountVo"/>
    where id = #{id}
</select>

<insert id="insertSysUserThirdAccount" parameterType="SysUserThirdAccount" useGeneratedKeys="true" keyProperty="id">
    insert into sys_user_third_account
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="userId != null">user_id,</if>
        <if test="thirdUniqueAccount != null">third_unique_account,</if>
        <if test="thirdUniqueName != null">third_unique_name,</if>
        <if test="thirdUniqueAvatar != null">third_unique_avatar,</if>
        <if test="bindType != null">bind_type,</if>
        <if test="bindFlag != null">bind_flag,</if>
        <if test="bindDate != null">bind_date,</if>
        <if test="createBy != null">create_by,</if>
        <if test="createTime != null">create_time,</if>
        <if test="updateBy != null">update_by,</if>
        <if test="updateTime != null">update_time,</if>
        <if test="1==1">del_flag,</if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
        <if test="userId != null">#{userId},</if>
        <if test="thirdUniqueAccount != null">#{thirdUniqueAccount},</if>
        <if test="thirdUniqueName != null">#{thirdUniqueName},</if>
        <if test="thirdUniqueAvatar != null">#{thirdUniqueAvatar},</if>
        <if test="bindType != null">#{bindType},</if>
        <if test="bindFlag != null">#{bindFlag},</if>
        <if test="bindDate != null">#{bindDate},</if>
        <if test="createBy != null">#{createBy},</if>
        <if test="createTime != null">#{createTime},</if>
        <if test="updateBy != null">#{updateBy},</if>
        <if test="updateTime != null">#{updateTime},</if>
        <if test="1==1">#{delFlag},</if>
    </trim>
</insert>

<update id="updateSysUserThirdAccount" parameterType="SysUserThirdAccount">
    update sys_user_third_account
    <trim prefix="SET" suffixOverrides=",">
        <if test="userId != null">user_id = #{userId},</if>
        <if test="thirdUniqueAccount != null">third_unique_account = #{thirdUniqueAccount},</if>
        <if test="thirdUniqueName != null">third_unique_name = #{thirdUniqueName},</if>
        <if test="thirdUniqueAvatar != null">third_unique_avatar = #{thirdUniqueAvatar},</if>
        <if test="bindType != null">bind_type = #{bindType},</if>
        <if test="bindFlag != null">bind_flag = #{bindFlag},</if>
        <if test="bindDate != null">bind_date = #{bindDate},</if>
        <if test="createBy != null">create_by = #{createBy},</if>
        <if test="createTime != null">create_time = #{createTime},</if>
        <if test="updateBy != null">update_by = #{updateBy},</if>
        <if test="updateTime != null">update_time = #{updateTime},</if>
        <if test="delFlag != null">del_flag = #{delFlag},</if>
    </trim>
    where id = #{id}
</update>

<delete id="deleteSysUserThirdAccountById" parameterType="Long">
    update sys_user_third_account
    set del_flag = '2'
    where id = #{id}
</delete>

<delete id="deleteSysUserThirdAccountByIds" parameterType="String">
    update sys_user_third_account set del_flag = '2' where id in
    <foreach item="id" collection="array" open="(" separator="," close=")">
        #{id}
    </foreach>
</delete>

#### 2.3.4：service接口

package com.ruoyi.system.service;

import com.ruoyi.system.domain.SysUserThirdAccount;

import java.util.List;

/**

• @author xiao_he
  /
  public interface ISysUserThirdAccountService {
  /*

  • 查询第三方账户绑定
  • @param id 第三方账户绑定主键
  • @return 第三方账户绑定
    */
    public SysUserThirdAccount selectSysUserThirdAccountById(Long id);

  /**

  • 查询第三方账户绑定列表
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 第三方账户绑定集合
    */
    public List selectSysUserThirdAccountList(SysUserThirdAccount sysUserThirdAccount);

  /**

  • 新增第三方账户绑定
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 结果
    */
    public int insertSysUserThirdAccount(SysUserThirdAccount sysUserThirdAccount);

  /**

  • 修改第三方账户绑定
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 结果
    */
    public int updateSysUserThirdAccount(SysUserThirdAccount sysUserThirdAccount);

  /**

  • 批量删除第三方账户绑定
  • @param ids 需要删除的第三方账户绑定主键集合
  • @return 结果
    */
    public int deleteSysUserThirdAccountByIds(Long[] ids);

  /**

  • 删除第三方账户绑定信息
  • @param id 第三方账户绑定主键
  • @return 结果
    */
    public int deleteSysUserThirdAccountById(Long id);
    }

#### 2.3.5：service实现类

package com.ruoyi.system.service.impl;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.SysUserThirdAccount;
import com.ruoyi.system.mapper.SysUserThirdAccountMapper;
import com.ruoyi.system.service.ISysUserThirdAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**

• @author xiao_he
  */
  @Service(“sysUserThirdAccountService”)
  public class SysUserThirdAccountServiceImpl implements ISysUserThirdAccountService {
  @Autowired
  private SysUserThirdAccountMapper sysUserThirdAccountMapper;

  /**

  • 查询第三方账户绑定
  • @param id 第三方账户绑定主键
  • @return 第三方账户绑定
    */
    @Override
    public SysUserThirdAccount selectSysUserThirdAccountById(Long id) {
    return sysUserThirdAccountMapper.selectSysUserThirdAccountById(id);
    }

  /**

  • 查询第三方账户绑定列表
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 第三方账户绑定
    */
    @Override
    public List selectSysUserThirdAccountList(SysUserThirdAccount sysUserThirdAccount) {
    return sysUserThirdAccountMapper.selectSysUserThirdAccountList(sysUserThirdAccount);
    }

  /**

  • 新增第三方账户绑定
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 结果
    */
    @Override
    public int insertSysUserThirdAccount(SysUserThirdAccount sysUserThirdAccount) {
    sysUserThirdAccount.setCreateTime(DateUtils.getNowDate());
    return sysUserThirdAccountMapper.insertSysUserThirdAccount(sysUserThirdAccount);
    }

  /**

  • 修改第三方账户绑定
  • @param sysUserThirdAccount 第三方账户绑定
  • @return 结果
    */
    @Override
    public int updateSysUserThirdAccount(SysUserThirdAccount sysUserThirdAccount) {
    sysUserThirdAccount.setUpdateTime(DateUtils.getNowDate());
    return sysUserThirdAccountMapper.updateSysUserThirdAccount(sysUserThirdAccount);
    }

  /**

  • 批量删除第三方账户绑定
  • @param ids 需要删除的第三方账户绑定主键
  • @return 结果
    */
    @Override
    public int deleteSysUserThirdAccountByIds(Long[] ids) {
    return sysUserThirdAccountMapper.deleteSysUserThirdAccountByIds(ids);
    }

  /**

  • 删除第三方账户绑定信息
  • @param id 第三方账户绑定主键
  • @return 结果
    */
    @Override
    public int deleteSysUserThirdAccountById(Long id) {
    return sysUserThirdAccountMapper.deleteSysUserThirdAccountById(id);
    }
    }

#### 2.3.5：SysUserThirdAccountController

package cn.hfm.web.controller.system;

import java.util.List;
import javax.servlet.http.HttpServletResponse;

import cn.hfm.common.utils.SecurityUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import cn.hfm.common.annotation.Log;
import cn.hfm.common.core.controller.BaseController;
import cn.hfm.common.core.domain.AjaxResult;
import cn.hfm.common.enums.BusinessType;
import cn.hfm.system.domain.SysUserThirdAccount;
import cn.hfm.system.service.ISysUserThirdAccountService;
import cn.hfm.common.utils.poi.ExcelUtil;
import cn.hfm.common.core.page.TableDataInfo;

/**

• 第三方账户绑定Controller

• @author xiao_he

• @date 2023-07-07
  */
  @RestController
  @RequestMapping(“/system/account”)
  public class SysUserThirdAccountController extends BaseController {
  @Autowired
  private ISysUserThirdAccountService sysUserThirdAccountService;

  /**

  • 查询第三方账户绑定列表
    */
    @PreAuthorize(“@ss.hasPermi(‘system:account:list’)”)
    @GetMapping(“/list”)
    public TableDataInfo list(SysUserThirdAccount sysUserThirdAccount) {
    startPage();
    List list = sysUserThirdAccountService.selectSysUserThirdAccountList(sysUserThirdAccount);
    return getDataTable(list);
    }

  /**

  • 导出第三方账户绑定列表
    */
    @PreAuthorize(“@ss.hasPermi(‘system:account:export’)”)
    @Log(title = “第三方账户绑定”, businessType = BusinessType.EXPORT)
    @PostMapping(“/export”)
    public void export(HttpServletResponse response, SysUserThirdAccount sysUserThirdAccount) {
    List list = sysUserThirdAccountService.selectSysUserThirdAccountList(sysUserThirdAccount);
    ExcelUtil util = new ExcelUtil(SysUserThirdAccount.class);
    util.exportExcel(response, list, “第三方账户绑定数据”);
    }

  /**

  • 获取第三方账户绑定详细信息
    */
    @PreAuthorize(“@ss.hasPermi(‘system:account:query’)”)
    @GetMapping(value = “/{id}”)
    public AjaxResult getInfo(@PathVariable(“id”) Long id) {
    return AjaxResult.success(sysUserThirdAccountService.selectSysUserThirdAccountById(id));
    }

  /**

  • 新增第三方账户绑定
    */
    @PreAuthorize(“@ss.hasPermi(‘system:account:add’)”)
    @Log(title = “第三方账户绑定”, businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody SysUserThirdAccount sysUserThirdAccount) {
    return toAjax(sysUserThirdAccountService.insertSysUserThirdAccount(sysUserThirdAccount));
    }

  /**

  • 修改第三方账户绑定
    */
    @PreAuthorize(“@ss.hasPermi(‘system:account:edit’)”)
    @Log(title = “第三方账户绑定”, businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody SysUserThirdAccount sysUserThirdAccount) {
    return toAjax(sysUserThirdAccountService.updateSysUserThirdAccount(sysUserThirdAccount));
    }

  /**

  • 删除第三方账户绑定
    */
    @PreAuthorize(“@ss.hasPermi(‘system:account:remove’)”)
    @Log(title = “第三方账户绑定”, businessType = BusinessType.DELETE)
    @DeleteMapping(“/{ids}”)
    public AjaxResult remove(@PathVariable Long[] ids) {
    return toAjax(sysUserThirdAccountService.deleteSysUserThirdAccountByIds(ids));
    }

  /**

  • 查询当前用户第三方账户绑定列表
    */
    @GetMapping(“/thirdAccountList”)
    public TableDataInfo thirdAccountList(SysUserThirdAccount sysUserThirdAccount) {
    //设置优化id
    sysUserThirdAccount.setUserId(SecurityUtils.getUserId());
    sysUserThirdAccount.setBindFlag(“1”);
    startPage();
    List list = sysUserThirdAccountService.selectSysUserThirdAccountList(sysUserThirdAccount);
    return getDataTable(list);
    }
    }

## 第三步：若依的登录鉴权使用了springSecurity，现在我们对它进行基本的配置


### 3.1：创建OtherAuthenticationToken继承AbstractAuthenticationToken，里面的代码照抄就行了

package com.ruoyi.framework.security.othreLogin;

import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;

import java.util.Collection;

/**

• @author xiao_he
  */
  public class OtherAuthenticationToken extends AbstractAuthenticationToken {
  private final Object principal;

  public OtherAuthenticationToken(Object principal) {
  super(null);
  this.principal = principal;
  this.setAuthenticated(false);
  }

  public OtherAuthenticationToken(Object principal, Collection<? extends GrantedAuthority> authorities) {
  super(authorities);
  this.principal = principal;
  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();
  }
  }

### 3.2：创建OtherAuthenticationProvider实现AuthenticationProvider，这里的UserDetailsService在后面定义

package com.ruoyi.framework.security.othreLogin;

import com.ruoyi.framework.web.service.UserDetailsByOtherLoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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;
import org.springframework.stereotype.Component;

import java.util.Collections;

/**

• @author xiao_he
  */
  @Component
  public class OtherAuthenticationProvider implements AuthenticationProvider {

  @Autowired
  @Qualifier(“userDetailsByOtherLoginService”)
  private UserDetailsService userDetailsByOtherLoginService;

  /**

  • 认证逻辑
    /
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
    OtherAuthenticationToken otherAuthenticationToken = (OtherAuthenticationToken) authentication;
    String thirdUniqueAccountId = (String) otherAuthenticationToken.getPrincipal();
    UserDetails user = userDetailsByOtherLoginService.loadUserByUsername(thirdUniqueAccountId);
    OtherAuthenticationToken result = new OtherAuthenticationToken(user, Collections.emptyList());
    /
    Details 中包含了 ip地址、 sessionId 等等属性 也可以存储一些自己想要放进去的内容
    */
    result.setDetails(otherAuthenticationToken.getDetails());
    return result;
    }

  /**

  • UserIdAuthenticationToken交给UserIdAuthenticationProvider处理
  • @param aClass
  • @return
    */
    @Override
    public boolean supports(Class<?> aClass) {
    return OtherAuthenticationToken.class.isAssignableFrom(aClass);
    }
    }

### 3.3：创建一个工具类，用来获取第三方token、获取用户信息

package com.ruoyi.framework.security.othreLogin;

import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.UserStatus;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.web.service.SysPermissionService;
import com.ruoyi.system.domain.SysUserThirdAccount;
import com.ruoyi.system.service.ISysUserThirdAccountService;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.userdetails.UserDetails;

import java.io.IOException;
import java.util.Date;
import java.util.List;

/**

• @author xiao_he
  */
  public class UserDetailsUtils {
  private static final Logger log = LoggerFactory.getLogger(UserDetailsUtils.class);

  public static UserDetails createLoginUser(SysUser user) {
  SysPermissionService permissionService = SpringUtils.getBean(“sysPermissionService”);
  if (StringUtils.isNull(user)) {
  log.info(“该用户未绑定账户，请先进行注册后绑定！”);
  throw new ServiceException(“该用户未绑定账户，请先进行注册后绑定！”);
  } else if (UserStatus.DELETED.getCode().equals(user.getDelFlag())) {
  log.info(“登录用户：{} 已被删除.”, user.getUserName());
  throw new ServiceException(“对不起，您的账号：” + user.getUserName() + " 已被删除");
  } else if (UserStatus.DISABLE.getCode().equals(user.getStatus())) {
  log.info(“登录用户：{} 已被停用.”, user.getUserName());
  throw new ServiceException(“对不起，您的账号：” + user.getUserName() + " 已停用");
  }
  return new LoginUser(user.getUserId(), user.getDeptId(), user, permissionService.getMenuPermission(user));
  }

  public static void bindOtherUser(String token, String loginType, SysUser sysUser) throws IOException {
  if (StringUtils.isNotEmpty(token) && StringUtils.isNotEmpty(loginType)) {
  JSONObject jsonObject = getUserInfo(token, loginType);
  Object otherId = jsonObject.get(“id”);
  SysUserThirdAccount sysUserThirdAccount = new SysUserThirdAccount();
  sysUserThirdAccount.setBindType(loginType);
  sysUserThirdAccount.setThirdUniqueName(jsonObject.getString(“name”));
  sysUserThirdAccount.setThirdUniqueAvatar(jsonObject.getString(“avatar_url”));
  sysUserThirdAccount.setDelFlag(“0”);
  sysUserThirdAccount.setBindFlag(“1”);
  sysUserThirdAccount.setBindDate(new Date());
  sysUserThirdAccount.setThirdUniqueAccount(otherId.toString());
  ISysUserThirdAccountService userThirdAccountService = SpringUtils.getBean(“sysUserThirdAccountService”);
  List sysUserThirdAccounts = userThirdAccountService.selectSysUserThirdAccountList(sysUserThirdAccount);
  if (sysUserThirdAccounts.size() < 1) {
  sysUserThirdAccount.setUserId(sysUser.getUserId());
  userThirdAccountService.insertSysUserThirdAccount(sysUserThirdAccount);
  }
  }

  }
  /**

  • 获取Access Token
  • @param url
  • @param loginType 用来拓展以后还有其他的登录逻辑处理
  • @return
  • @throws IOException
    */
    public static JSONObject getAccessToken(String url, String loginType) {
    HttpClient client = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost(url);
    httpPost.setHeader(“User-Agent”, “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36”);
    HttpResponse response = null;
    try {
    response = client.execute(httpPost);
    HttpEntity entity = response.getEntity();
    if (null != entity) {
    String result = EntityUtils.toString(entity, “UTF-8”);
    return JSONObject.parseObject(result);
    }
    } catch (IOException e) {
    e.printStackTrace();
    }finally {
    httpPost.releaseConnection();
    }
    return null;
    }

  /**

  • 获取用户信息
  • @param tokenId
  • @param loginType 用来拓展以后还有其他的登录逻辑处理，
  • @return
    */
    public static JSONObject getUserInfo(String tokenId, String loginType) {
    String url = “https://gitee.com/api/v5/user?access_token=” + tokenId;
    CloseableHttpClient client = HttpClients.createDefault();
    HttpGet httpGet = new HttpGet(url);
    httpGet.setHeader(“User-Agent”, “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36”);
    HttpResponse response = null;
    try {
    response = client.execute(httpGet);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
    String result = EntityUtils.toString(entity, “UTF-8”);
    return JSONObject.parseObject(result);
    }
    } catch (IOException e) {
    e.printStackTrace();
    } finally {
    httpGet.releaseConnection();
    }
    return null;
    }
    }

### 3.4：Constants常量类中添加几个常量

/**

• REDIRECT 重定向地址
  */
  public static final String REDIRECT = “redirect”;

/**

• AUTH_METHOD 授权类型
  /
  public static final String AUTH_METHOD = “authMethod”;
  /*
• AUTH_METHOD_KEY 登录方式 redisKey
  */
  public static final String AUTH_METHOD_KEY = “authMethod:”;

/**

• LOGIN_TYPE 登录方式
  */
  public static final String LOGIN_TYPE = “loginType”;

public static final String OTHER_ID = “otherId”;

### 3.5：LoginBody类中添加字段，并提供get/set方法

/**

• 第三方token
  */
  private String token;

/**

• 登录类型
  */
  private String loginType;

### 3.6：创建UserDetailsByOtherLoginService实现UserDetailsService做第三方登录处理逻辑

package com.ruoyi.framework.web.service;

import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.framework.security.othreLogin.UserDetailsUtils;
import com.ruoyi.system.domain.SysUserThirdAccount;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.system.service.ISysUserThirdAccountService;
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;

import java.util.List;

/**

• @author xiao_he
  */
  @Service(“userDetailsByOtherLoginService”)
  public class UserDetailsByOtherLoginService implements UserDetailsService {
  @Autowired
  private ISysUserService userService;

  @Autowired
  private ISysUserThirdAccountService userThirdAccountService;

  @Override
  public UserDetails loadUserByUsername(String tokenId) throws UsernameNotFoundException {
  JSONObject jsonObject = null;
  //在session里拿loginType
  String loginType = (String) ServletUtils.getRequest().getSession().getAttribute(Constants.LOGIN_TYPE);
  jsonObject = UserDetailsUtils.getUserInfo(tokenId, loginType);
  Object thirdUniqueAccountId = jsonObject.get(“id”);
  SysUserThirdAccount sysUserThirdAccount = new SysUserThirdAccount();
  sysUserThirdAccount.setBindType(loginType);
  sysUserThirdAccount.setDelFlag(“0”);
  sysUserThirdAccount.setBindFlag(“1”);
  sysUserThirdAccount.setThirdUniqueAccount(thirdUniqueAccountId.toString());
  List sysUserThirdAccounts = userThirdAccountService.selectSysUserThirdAccountList(sysUserThirdAccount);
  Long userId = 0L;
  if (sysUserThirdAccounts.size() > 0) {
  userId = sysUserThirdAccounts.get(0).getUserId();
  } else {
  SysUser user = new SysUser();
  user.setUserId(-1L);
  ServletUtils.getRequest().setAttribute(Constants.OTHER_ID, thirdUniqueAccountId);
  //没有绑定用户，伪造一个用户，防止报错
  return new LoginUser(-1L, null, user, null);
  }
  SysUser user = userService.selectUserById(userId);
  UserDetails loginUser = UserDetailsUtils.createLoginUser(user);
  return loginUser;
  }
  }

### 3.7：在原来UserDetailsServiceImpl上添加注解，区分是哪个处理逻辑

@Service(“userDetailsByPasswordService”)

### 3.8：配置SecurityConfig


#### 3.8.1：在原来的注入UserDetailsService类上添加注解指定userDetailsByPasswordService

/**

• 自定义用户认证逻辑
  */
  @Autowired
  @Qualifier(“userDetailsByPasswordService”)
  private UserDetailsService userDetailsService;

#### 3.8.2：添加认证白名单，这几个链接配置为免登录链接

.antMatchers(“/otherLogin”, “/preOtherAuthUrl”, “/otherLoginCallback/“,”/system/dict/data/type/”).permitAll()

#### 3.8.3：将AuthenticationGiteeProvider注入进来，配置configure方法,添加一行auth.authenticationProvider(authenticationGiteeProvider);

@Autowired
private AuthenticationGiteeProvider authenticationGiteeProvider;

/**

• 身份认证接口
  */
  @Override
  protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
  auth.authenticationProvider(authenticationGiteeProvider);
  }

#### 3.8.4：SysLoginService中添加登录方法和绑定方法

/**

• 登录验证
• @param token 登录验证token
• @param loginType 登录类型，后期拓展
• @return 结果
  */
  public String otherLogin(String token, String loginType) {
  // 用户验证
  Authentication authentication = null;
  try {
  // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
  if (“1”.equals(loginType) || “2”.equals(loginType) || “3”.equals(loginType)) {
  authentication = authenticationManager.authenticate(new OtherAuthenticationToken(token));
  }
  } catch (Exception e) {
  if (e instanceof BadCredentialsException) {
  AsyncManager.me().execute(AsyncFactory.recordLogininfor(“username”, Constants.LOGIN_FAIL, MessageUtils.message(“user.password.not.match”)));
  throw new UserPasswordNotMatchException();
  } else {
  AsyncManager.me().execute(AsyncFactory.recordLogininfor(“username”, Constants.LOGIN_FAIL, e.getMessage()));
  throw new ServiceException(e.getMessage());
  }
  }
  AsyncManager.me().execute(AsyncFactory.recordLogininfor(authentication.getName(), Constants.LOGIN_SUCCESS, MessageUtils.message(“user.login.success”)));
  LoginUser loginUser = (LoginUser) authentication.getPrincipal();
  recordLoginInfo(loginUser.getUserId());
  // 生成token
  return tokenService.createToken(loginUser);
  }

/**

• 绑定第三方账户
• @param tokenId 第三放认证后的token
• @param loginType 登录类型
  */
  public void bindThirdAccount(String tokenId, String loginType) {
  LoginUser loginUser = SecurityUtils.getLoginUser();
  SysUser sysUser = loginUser.getUser();
  JSONObject jsonObject = null;
  jsonObject = UserDetailsUtils.getUserInfo(tokenId, loginType);
  SysUserThirdAccount thirdAccount = new SysUserThirdAccount();
  thirdAccount.setBindType(loginType);
  thirdAccount.setDelFlag(“0”);
  thirdAccount.setBindFlag(“1”);
  thirdAccount.setThirdUniqueAccount(jsonObject.getString(“id”));
  List sysUserThirdAccounts = userThirdAccountService.selectSysUserThirdAccountList(thirdAccount);
  if (sysUserThirdAccounts.size() > 0) {
  //绑定过账户
  SysUserThirdAccount userThirdAccount = sysUserThirdAccounts.get(0);
  if (!userThirdAccount.equals(SecurityUtils.getUserId())) {
  throw new ServiceException(“该合作账户已经绑定过其他账户,请先解绑其他账户！”);
  }
  userThirdAccount.setThirdUniqueName(jsonObject.getString(“name”));
  userThirdAccount.setThirdUniqueAvatar(jsonObject.getString(“avatar_url”));
  userThirdAccount.setBindFlag(“1”);
  userThirdAccount.setBindDate(new Date());
  userThirdAccount.setUserId(SecurityUtils.getUserId());
  userThirdAccountService.updateSysUserThirdAccount(userThirdAccount);
  } else {
  //看看当前账户有没有已经解绑的同类型，并且同tokenId账户，有解绑的了的，覆盖掉
  thirdAccount.setBindFlag(“2”);
  sysUserThirdAccounts = userThirdAccountService.selectSysUserThirdAccountList(thirdAccount);
  //设置绑定时间，以及第三方账号id
  thirdAccount.setThirdUniqueName(jsonObject.getString(“name”));
  thirdAccount.setThirdUniqueAvatar(jsonObject.getString(“avatar_url”));
  thirdAccount.setBindDate(new Date());
  thirdAccount.setBindFlag(“1”);
  thirdAccount.setUserId(SecurityUtils.getUserId());
  thirdAccount.setThirdUniqueAccount(jsonObject.getString(“id”));
  if (sysUserThirdAccounts.size() > 0) {
  thirdAccount.setId(sysUserThirdAccounts.get(0).getId());
  userThirdAccountService.updateSysUserThirdAccount(thirdAccount);
  } else {
  userThirdAccountService.insertSysUserThirdAccount(thirdAccount);
  }
  }
  }

### 3.8.5：创建OtherLoginController

package com.ruoyi.web.controller.system;

import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.model.LoginBody;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.uuid.UUID;
import com.ruoyi.framework.security.othreLogin.UserDetailsUtils;
import com.ruoyi.framework.web.service.SysLoginService;
import com.ruoyi.system.domain.SysUserThirdAccount;
import com.ruoyi.system.service.ISysUserThirdAccountService;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**

• @author xiao_he
  */
  @RestController
  public class OtherLoginController {
  @Autowired
  private SysLoginService loginService;

  @Autowired
  private ISysUserThirdAccountService userThirdAccountService;

  @Autowired
  private RedisCache redisCache;

  /**

  • gitee授权中提供的 appid 和 appkey
    */
    @Value(“$otherLogin.gitee.clientid")publicStringGI{T}_E{E}_{C}LIEN{T}_{I}D;@Value("${otherLogin.gitee.clientsecret}”)
    public String GIT_EE_CLIENT_SECRET;
    @Value(“$otherLogin.gitee.callback")publicStringGI{T}_E{E}_{C}LIEN{T}_{U}RL;@Value("${ruoyi.doMain}”)
    public String DO_MAIN;

  /**

  • 其他合作账户登录的公共方法
  • @param loginBody
  • @param request
  • @return
    */
    @PostMapping(“/otherLogin”)
    public AjaxResult otherLogin(@RequestBody LoginBody loginBody, HttpServletRequest request) {
    AjaxResult ajax = AjaxResult.success();
    String redirect = String.valueOf(request.getSession().getAttribute(Constants.REDIRECT));
    //授权类型
    String method = (String) redisCache.getCacheObject(Constants.AUTH_METHOD_KEY + loginBody.getUuid());
    request.getSession().setAttribute(Constants.LOGIN_TYPE, loginBody.getLoginType());
    if (“login”.equals(method)) {
    //验证token
    String token = loginService.otherLogin(loginBody.getToken(), loginBody.getLoginType());
    Object otherID = ServletUtils.getRequest().getAttribute(Constants.OTHER_ID);
    if (ObjectUtils.isEmpty(otherID)) {
    ajax.put(Constants.OTHER_ID, null);
    ajax.put(Constants.TOKEN, token);
    ajax.put(Constants.AUTH_METHOD, method);
    if (StringUtils.isNotEmpty(redirect) && (!“undefined”.equals(redirect)) && (!“null”.equals(redirect))) {
    ajax.put(Constants.REDIRECT, redirect);
    } else {
    ajax.put(Constants.REDIRECT, null);
    }
    } else {
    //么有token
    ajax.put(Constants.TOKEN, null);
    ajax.put(Constants.OTHER_ID, otherID);

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

rLogin(loginBody.getToken(), loginBody.getLoginType());
Object otherID = ServletUtils.getRequest().getAttribute(Constants.OTHER_ID);
if (ObjectUtils.isEmpty(otherID)) {
ajax.put(Constants.OTHER_ID, null);
ajax.put(Constants.TOKEN, token);
ajax.put(Constants.AUTH_METHOD, method);
if (StringUtils.isNotEmpty(redirect) && (!“undefined”.equals(redirect)) && (!“null”.equals(redirect))) {
ajax.put(Constants.REDIRECT, redirect);
} else {
ajax.put(Constants.REDIRECT, null);
}
} else {
//么有token
ajax.put(Constants.TOKEN, null);
ajax.put(Constants.OTHER_ID, otherID);

[外链图片转存中…(img-upKShpRw-1715452773871)]
[外链图片转存中…(img-mwTfUvJE-1715452773872)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！