商城项目利用Spring-Session做分布式session的解决方案-----商城项目

于 2024-09-17 19:39:43 发布
阅读量507 收藏 12
点赞数 12
分类专栏： 电商项目 # Spring-Cloud框架 # Spring-Boot框架 文章标签： 分布式 微服务 后端 spring spring boot spring cloud java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/142317754
版权
#如何看待IBM中国研发部裁员？# 
package com.alatus.mall.auth.app;

import com.alatus.common.utils.HttpUtils;
import com.alatus.common.utils.R;
import com.alatus.common.vo.GiteeSocialUser;
import com.alatus.common.vo.MemberRespVo;
import com.alatus.common.vo.WeiboSocialUser;
import com.alatus.mall.auth.feign.MemberFeignService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.HashMap;

@Controller
@Slf4j
public class OAuthController {
    @Value("${spring.oauth.properties.weibo.client_id}")
    private String weibo_client_id;
    @Value("${spring.oauth.properties.weibo.client_secret}")
    private String weibo_client_secret;
    @Value("${spring.oauth.properties.grant_type}")
    private String grant_type;
    @Value("${spring.oauth.properties.weibo.redirect_uri}")
    private String weibo_redirect_uri;
    @Value("${spring.oauth.properties.gitee.client_id}")
    private String gitee_client_id;
    @Value("${spring.oauth.properties.gitee.redirect_uri}")
    private String gitee_redirect_uri;
    @Value("${spring.oauth.properties.gitee.client_secret}")
    private String gitee_client_secret;
    @Autowired
    private MemberFeignService memberFeignService;
    @GetMapping("/oauth2.0/weibo/success")
    public String weiboLogin(@RequestParam("code") String code, HttpSession session) throws Exception {
//        根据这个code获取当前登录用户的第三方令牌
        HashMap<String, String> queryBody = new HashMap<>();
        queryBody.put("client_id",weibo_client_id);
        queryBody.put("client_secret",weibo_client_secret);
        queryBody.put("grant_type",grant_type);
        queryBody.put("redirect_uri",weibo_redirect_uri);
        queryBody.put("code",code);
        HttpResponse oauth = HttpUtils.doPost("https://api.weibo.com", "/oauth2/access_token", "post", new HashMap<>(), new HashMap<>(), queryBody);
        if(oauth.getStatusLine().getStatusCode()==200){
//            获取到了accessEntity
            String userJson = EntityUtils.toString(oauth.getEntity());
            WeiboSocialUser weiboSocialUser = JSON.parseObject(userJson, WeiboSocialUser.class);
            R r = memberFeignService.weiboOauthLogin(weiboSocialUser);
            if(r.getCode() == 0){
                MemberRespVo memberRespVo = r.getData(new TypeReference<MemberRespVo>() {});
                log.info("第三方用户登陆成功:,用户信息"+memberRespVo);
                session.setAttribute("loginUser",memberRespVo);
                return "redirect:http://alatusmall.com";
            }
            else {
                return "redirect:http://auth.alatusmall.com/login.html";
            }
        }
        else{
            return "redirect:http://auth.alatusmall.com/login.html";
        }
    }
    @GetMapping("/oauth2.0/gitee/success")
    public String gitLogin(@RequestParam("code") String code, HttpSession session, HttpServletResponse servletResponse) throws Exception {
//        根据这个code获取当前登录用户的第三方令牌
        HashMap<String, String> queryBody = new HashMap<>();
        queryBody.put("grant_type",grant_type);
        queryBody.put("code",code);
        queryBody.put("client_id",gitee_client_id);
        queryBody.put("redirect_uri",gitee_redirect_uri);
        queryBody.put("client_secret",gitee_client_secret);
        HttpResponse oauth = HttpUtils.doPost("https://gitee.com", "/oauth/token", "post", new HashMap<>(), new HashMap<>(), queryBody);
        if(oauth.getStatusLine().getStatusCode()==200){
//            获取到了accessEntity
            String userJson = EntityUtils.toString(oauth.getEntity());
            GiteeSocialUser giteeSocialUser = JSON.parseObject(userJson, GiteeSocialUser.class);
            R r = memberFeignService.giteeOauthLogin(giteeSocialUser);
            if(r.getCode() == 0){
                MemberRespVo memberRespVo = r.getData(new TypeReference<MemberRespVo>() {});
                log.info("第三方用户登陆成功:,用户信息"+memberRespVo);
//                第一次使用session,浏览器会保存我们的cookie,浏览器访问指定网站或域名就会带上这个cookie
//                让cookie在子域下也可以取出对应的cookie,需要我们指定域名
//                这样就是我们自己原生将cookie指定作用域和内容并回传,然后,session我们就存在redis里面
                session.setAttribute("loginUser",memberRespVo);
                return "redirect:http://alatusmall.com";
            }
            else {
                return "redirect:http://auth.alatusmall.com/login.html";
            }
        }
        else{
            return "redirect:http://auth.alatusmall.com/login.html";
        }
    }
}

package com.alatus.mall.auth.app;

import com.alatus.common.utils.HttpUtils;
import com.alatus.common.utils.R;
import com.alatus.common.vo.GiteeSocialUser;
import com.alatus.common.vo.MemberRespVo;
import com.alatus.common.vo.WeiboSocialUser;
import com.alatus.mall.auth.feign.MemberFeignService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.HashMap;

@Controller
@Slf4j
public class OAuthController {
    @Value("${spring.oauth.properties.weibo.client_id}")
    private String weibo_client_id;
    @Value("${spring.oauth.properties.weibo.client_secret}")
    private String weibo_client_secret;
    @Value("${spring.oauth.properties.grant_type}")
    private String grant_type;
    @Value("${spring.oauth.properties.weibo.redirect_uri}")
    private String weibo_redirect_uri;
    @Value("${spring.oauth.properties.gitee.client_id}")
    private String gitee_client_id;
    @Value("${spring.oauth.properties.gitee.redirect_uri}")
    private String gitee_redirect_uri;
    @Value("${spring.oauth.properties.gitee.client_secret}")
    private String gitee_client_secret;
    @Autowired
    private MemberFeignService memberFeignService;
    @GetMapping("/oauth2.0/weibo/success")
    public String weiboLogin(@RequestParam("code") String code, HttpSession session) throws Exception {
//        根据这个code获取当前登录用户的第三方令牌
        HashMap<String, String> queryBody = new HashMap<>();
        queryBody.put("client_id",weibo_client_id);
        queryBody.put("client_secret",weibo_client_secret);
        queryBody.put("grant_type",grant_type);
        queryBody.put("redirect_uri",weibo_redirect_uri);
        queryBody.put("code",code);
        HttpResponse oauth = HttpUtils.doPost("https://api.weibo.com", "/oauth2/access_token", "post", new HashMap<>(), new HashMap<>(), queryBody);
        if(oauth.getStatusLine().getStatusCode()==200){
//            获取到了accessEntity
            String userJson = EntityUtils.toString(oauth.getEntity());
            WeiboSocialUser weiboSocialUser = JSON.parseObject(userJson, WeiboSocialUser.class);
            R r = memberFeignService.weiboOauthLogin(weiboSocialUser);
            if(r.getCode() == 0){
                MemberRespVo memberRespVo = r.getData(new TypeReference<MemberRespVo>() {});
                log.info("第三方用户登陆成功:,用户信息"+memberRespVo);
                session.setAttribute("loginUser",memberRespVo);
                return "redirect:http://alatusmall.com";
            }
            else {
                return "redirect:http://auth.alatusmall.com/login.html";
            }
        }
        else{
            return "redirect:http://auth.alatusmall.com/login.html";
        }
    }
    @GetMapping("/oauth2.0/gitee/success")
    public String gitLogin(@RequestParam("code") String code, HttpSession session, HttpServletResponse servletResponse) throws Exception {
//        根据这个code获取当前登录用户的第三方令牌
        HashMap<String, String> queryBody = new HashMap<>();
        queryBody.put("grant_type",grant_type);
        queryBody.put("code",code);
        queryBody.put("client_id",gitee_client_id);
        queryBody.put("redirect_uri",gitee_redirect_uri);
        queryBody.put("client_secret",gitee_client_secret);
        HttpResponse oauth = HttpUtils.doPost("https://gitee.com", "/oauth/token", "post", new HashMap<>(), new HashMap<>(), queryBody);
        if(oauth.getStatusLine().getStatusCode()==200){
//            获取到了accessEntity
            String userJson = EntityUtils.toString(oauth.getEntity());
            GiteeSocialUser giteeSocialUser = JSON.parseObject(userJson, GiteeSocialUser.class);
            R r = memberFeignService.giteeOauthLogin(giteeSocialUser);
            if(r.getCode() == 0){
                MemberRespVo memberRespVo = r.getData(new TypeReference<MemberRespVo>() {});
                log.info("第三方用户登陆成功:,用户信息"+memberRespVo);
//                第一次使用session,浏览器会保存我们的cookie,浏览器访问指定网站或域名就会带上这个cookie
//                让cookie在子域下也可以取出对应的cookie,需要我们指定域名
//                这样就是我们自己原生将cookie指定作用域和内容并回传,然后,session我们就存在redis里面
                session.setAttribute("loginUser",memberRespVo);
                return "redirect:http://alatusmall.com";
            }
            else {
                return "redirect:http://auth.alatusmall.com/login.html";
            }
        }
        else{
            return "redirect:http://auth.alatusmall.com/login.html";
        }
    }
}

package com.alatus.mall.member.service.impl;

import com.alatus.common.utils.HttpUtils;
import com.alatus.mall.member.entity.OauthInfoEntity;
import com.alatus.mall.member.exception.PhoneExistException;
import com.alatus.mall.member.exception.UsernameExistException;
import com.alatus.mall.member.service.MemberLevelService;
import com.alatus.mall.member.service.OauthInfoService;
import com.alatus.mall.member.vo.GiteeUserInfo;
import com.alatus.mall.member.vo.MemberLoginVo;
import com.alatus.mall.member.vo.MemberRegisterVo;
import com.alatus.common.vo.GiteeSocialUser;
import com.alatus.common.vo.WeiboSocialUser;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;
import com.alatus.mall.member.dao.MemberDao;
import com.alatus.mall.member.entity.MemberEntity;
import com.alatus.mall.member.service.MemberService;

@Service("memberService")
public class MemberServiceImpl extends ServiceImpl<MemberDao, MemberEntity> implements MemberService {
    @Autowired
    private MemberLevelService memberLevelService;
    @Autowired
    private OauthInfoService oauthInfoService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<MemberEntity> page = this.page(
                new Query<MemberEntity>().getPage(params),
                new QueryWrapper<MemberEntity>()
        );
        return new PageUtils(page);
    }

    @Override
    public void register(MemberRegisterVo memberRegisterVo) {
//        检查用户名和手机号是否唯一(为了能让上层感知异常,我们这里抛出去)采用异常机制
        checkPhoneUnique(memberRegisterVo.getPhone());
        checkUsernameUnique(memberRegisterVo.getUsername());
        MemberEntity memberEntity = new MemberEntity();
//        设置默认等级
        memberEntity.setLevelId(memberLevelService.getDefaultLevel().getId());
//        密码绝对不能传递明文,一旦数据库泄露,就会导致所有数据曝光,我们应该存储MD5加密后的数据
//        MD5任何长度大小的数据,算出的值都是固定的,源数据哪怕任何改动,得到的MD5值都会不同
//        百度网盘的秒传功能本质上就是MD5值相同,在这个情况下,不同文件就不需要再次上传,达到了秒传效果
//        MD5的最大特点就说不可逆,无法通过MD5获取源数据的值
//        MD5抗修改性意味着MD5的数据可以通过暴力算或者字典查的穷举法获得,网上有一大堆对应的彩虹表
//        因此MD5不能直接用来加密,必须加盐存储
//        使用Spring原生的加密器实现
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        memberEntity.setPassword(passwordEncoder.encode(memberRegisterVo.getPassword()));
//        用户名
        memberEntity.setUsername(memberRegisterVo.getUsername());
//        手机号
        memberEntity.setMobile(memberRegisterVo.getPhone());
        memberEntity.setCreateTime(new Date());
        this.baseMapper.insert(memberEntity);
    }

    @Override
    public void checkPhoneUnique(String phone) throws PhoneExistException{
        Integer count = this.baseMapper.selectCount(new QueryWrapper<MemberEntity>().eq("mobile", phone));
        if(count>0){
            throw new PhoneExistException();
        }
    }

    @Override
    public void checkUsernameUnique(String username) throws UsernameExistException{
        Integer count = this.baseMapper.selectCount(new QueryWrapper<MemberEntity>().eq("username", username));
        if(count>0){
            throw new UsernameExistException();
        }
    }

    @Override
    public MemberEntity login(MemberLoginVo memberLoginVo) {
        String loginAccount = memberLoginVo.getLoginAccount();
        String password = memberLoginVo.getPassword();;
//        去数据库查询
        MemberEntity memberEntity = this.baseMapper.selectOne(new QueryWrapper<MemberEntity>().eq("username", loginAccount)
                .or().eq("mobile", loginAccount));
        if(memberEntity==null){
            // 登陆失败
            return null;
        }
        else{
            String memberEntityPassword = memberEntity.getPassword();
            BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//            进行密码匹配
            boolean matches = passwordEncoder.matches(password, memberEntityPassword);
            if(matches){
                return memberEntity;
            }
            else{
                return null;
            }
        }
    }

//    社交登录需要同时具有注册和登录的逻辑
    @Override
    public MemberEntity login(WeiboSocialUser weiboSocialUser){
        String uid = weiboSocialUser.getUid();
        OauthInfoEntity oauthInfoEntity = oauthInfoService.getOne(new QueryWrapper<OauthInfoEntity>().eq("source", "微博").eq("social_uid", uid));
        if(oauthInfoEntity != null){
            MemberEntity memberEntity = this.getById(oauthInfoEntity.getMemberId());
            redisTemplate.opsForValue().set("user_access_token:"+memberEntity.getId(),weiboSocialUser.getAccess_token());
            redisTemplate.opsForValue().set("user_expires_in:"+memberEntity.getId(), weiboSocialUser.getExpires_in().toString());
            return memberEntity;
        }
        else{
            MemberEntity register = new MemberEntity();
            try{
                HashMap<String, String> query = new HashMap<>();
                query.put("access_token", weiboSocialUser.getAccess_token());
                query.put("uid", weiboSocialUser.getUid());
                HttpResponse response = HttpUtils.doGet("https://api.weibo.com", "/2/users/show.json", "get", new HashMap<>(),query);
                if(response.getStatusLine().getStatusCode()==200){
                    String json = EntityUtils.toString(response.getEntity());
                    JSONObject jsonObject = JSON.parseObject(json);
                    register.setLevelId(memberLevelService.getDefaultLevel().getId());
                    register.setNickname(jsonObject.getString("name"));
                    register.setGender("m".equals(jsonObject.getString("gender"))?1:0);
                    register.setCreateTime(new Date());
                    this.save(register);
                    OauthInfoEntity registerOauthInfo = new OauthInfoEntity();
                    registerOauthInfo.setMemberId(register.getId());
                    registerOauthInfo.setSocialUid(uid.toString());
                    registerOauthInfo.setSource("微博");
                    oauthInfoService.save(registerOauthInfo);
                    redisTemplate.opsForValue().set("user_access_token:"+register.getId(),weiboSocialUser.getAccess_token());
                    redisTemplate.opsForValue().set("user_expires_in:"+register.getId(), weiboSocialUser.getExpires_in().toString());
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
            return register;
        }
    }

    @Override
    public MemberEntity login(GiteeSocialUser giteeSocialUser) throws Exception {
        GiteeUserInfo giteeUserInfo = null;
        HttpResponse response = HttpUtils.doGet("https://gitee.com", "/api/v5/user?access_token=" + giteeSocialUser.getAccess_token(), "get", new HashMap<>(), new HashMap<>());
        if(response.getStatusLine().getStatusCode()==200){
            String giteeJSON = EntityUtils.toString(response.getEntity());
            giteeUserInfo = JSON.parseObject(giteeJSON, GiteeUserInfo.class);
        }
        Long uid = giteeUserInfo.getId();
        OauthInfoEntity oauthInfoEntity = oauthInfoService.getOne(new QueryWrapper<OauthInfoEntity>().eq("source", "gitee").eq("social_uid", uid));
        if(oauthInfoEntity != null){
            MemberEntity memberEntity = this.getById(oauthInfoEntity.getMemberId());
            redisTemplate.opsForValue().set("user_access_token:"+memberEntity.getId(),giteeSocialUser.getAccess_token());
            redisTemplate.opsForValue().set("user_expires_in:"+memberEntity.getId(), giteeSocialUser.getExpires_in().toString());
            return memberEntity;
        }
        else{
            MemberEntity register = new MemberEntity();
            register.setLevelId(memberLevelService.getDefaultLevel().getId());
            register.setEmail(giteeUserInfo.getEmail());
            register.setNickname(giteeUserInfo.getName());
            register.setCreateTime(new Date());
            this.save(register);
            OauthInfoEntity registerOauthInfo = new OauthInfoEntity();
            registerOauthInfo.setMemberId(register.getId());
            registerOauthInfo.setSocialUid(uid.toString());
            registerOauthInfo.setSource("gitee");
            oauthInfoService.save(registerOauthInfo);
            redisTemplate.opsForValue().set("user_access_token:"+register.getId(),giteeSocialUser.getAccess_token());
            redisTemplate.opsForValue().set("user_expires_in:"+register.getId(), giteeSocialUser.getExpires_in().toString());
            return register;
        }
    }

}
package com.alatus.mall.member.service.impl;

import com.alatus.common.utils.HttpUtils;
import com.alatus.mall.member.entity.OauthInfoEntity;
import com.alatus.mall.member.exception.PhoneExistException;
import com.alatus.mall.member.exception.UsernameExistException;
import com.alatus.mall.member.service.MemberLevelService;
import com.alatus.mall.member.service.OauthInfoService;
import com.alatus.mall.member.vo.GiteeUserInfo;
import com.alatus.mall.member.vo.MemberLoginVo;
import com.alatus.mall.member.vo.MemberRegisterVo;
import com.alatus.common.vo.GiteeSocialUser;
import com.alatus.common.vo.WeiboSocialUser;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;
import com.alatus.mall.member.dao.MemberDao;
import com.alatus.mall.member.entity.MemberEntity;
import com.alatus.mall.member.service.MemberService;

@Service("memberService")
public class MemberServiceImpl extends ServiceImpl<MemberDao, MemberEntity> implements MemberService {
    @Autowired
    private MemberLevelService memberLevelService;
    @Autowired
    private OauthInfoService oauthInfoService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<MemberEntity> page = this.page(
                new Query<MemberEntity>().getPage(params),
                new QueryWrapper<MemberEntity>()
        );
        return new PageUtils(page);
    }

    @Override
    public void register(MemberRegisterVo memberRegisterVo) {
//        检查用户名和手机号是否唯一(为了能让上层感知异常,我们这里抛出去)采用异常机制
        checkPhoneUnique(memberRegisterVo.getPhone());
        checkUsernameUnique(memberRegisterVo.getUsername());
        MemberEntity memberEntity = new MemberEntity();
//        设置默认等级
        memberEntity.setLevelId(memberLevelService.getDefaultLevel().getId());
//        密码绝对不能传递明文,一旦数据库泄露,就会导致所有数据曝光,我们应该存储MD5加密后的数据
//        MD5任何长度大小的数据,算出的值都是固定的,源数据哪怕任何改动,得到的MD5值都会不同
//        百度网盘的秒传功能本质上就是MD5值相同,在这个情况下,不同文件就不需要再次上传,达到了秒传效果
//        MD5的最大特点就说不可逆,无法通过MD5获取源数据的值
//        MD5抗修改性意味着MD5的数据可以通过暴力算或者字典查的穷举法获得,网上有一大堆对应的彩虹表
//        因此MD5不能直接用来加密,必须加盐存储
//        使用Spring原生的加密器实现
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        memberEntity.setPassword(passwordEncoder.encode(memberRegisterVo.getPassword()));
//        用户名
        memberEntity.setUsername(memberRegisterVo.getUsername());
//        手机号
        memberEntity.setMobile(memberRegisterVo.getPhone());
        memberEntity.setCreateTime(new Date());
        this.baseMapper.insert(memberEntity);
    }

    @Override
    public void checkPhoneUnique(String phone) throws PhoneExistException{
        Integer count = this.baseMapper.selectCount(new QueryWrapper<MemberEntity>().eq("mobile", phone));
        if(count>0){
            throw new PhoneExistException();
        }
    }

    @Override
    public void checkUsernameUnique(String username) throws UsernameExistException{
        Integer count = this.baseMapper.selectCount(new QueryWrapper<MemberEntity>().eq("username", username));
        if(count>0){
            throw new UsernameExistException();
        }
    }

    @Override
    public MemberEntity login(MemberLoginVo memberLoginVo) {
        String loginAccount = memberLoginVo.getLoginAccount();
        String password = memberLoginVo.getPassword();;
//        去数据库查询
        MemberEntity memberEntity = this.baseMapper.selectOne(new QueryWrapper<MemberEntity>().eq("username", loginAccount)
                .or().eq("mobile", loginAccount));
        if(memberEntity==null){
            // 登陆失败
            return null;
        }
        else{
            String memberEntityPassword = memberEntity.getPassword();
            BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//            进行密码匹配
            boolean matches = passwordEncoder.matches(password, memberEntityPassword);
            if(matches){
                return memberEntity;
            }
            else{
                return null;
            }
        }
    }

//    社交登录需要同时具有注册和登录的逻辑
    @Override
    public MemberEntity login(WeiboSocialUser weiboSocialUser){
        String uid = weiboSocialUser.getUid();
        OauthInfoEntity oauthInfoEntity = oauthInfoService.getOne(new QueryWrapper<OauthInfoEntity>().eq("source", "微博").eq("social_uid", uid));
        if(oauthInfoEntity != null){
            MemberEntity memberEntity = this.getById(oauthInfoEntity.getMemberId());
            redisTemplate.opsForValue().set("user_access_token:"+memberEntity.getId(),weiboSocialUser.getAccess_token());
            redisTemplate.opsForValue().set("user_expires_in:"+memberEntity.getId(), weiboSocialUser.getExpires_in().toString());
            return memberEntity;
        }
        else{
            MemberEntity register = new MemberEntity();
            try{
                HashMap<String, String> query = new HashMap<>();
                query.put("access_token", weiboSocialUser.getAccess_token());
                query.put("uid", weiboSocialUser.getUid());
                HttpResponse response = HttpUtils.doGet("https://api.weibo.com", "/2/users/show.json", "get", new HashMap<>(),query);
                if(response.getStatusLine().getStatusCode()==200){
                    String json = EntityUtils.toString(response.getEntity());
                    JSONObject jsonObject = JSON.parseObject(json);
                    register.setLevelId(memberLevelService.getDefaultLevel().getId());
                    register.setNickname(jsonObject.getString("name"));
                    register.setGender("m".equals(jsonObject.getString("gender"))?1:0);
                    register.setCreateTime(new Date());
                    this.save(register);
                    OauthInfoEntity registerOauthInfo = new OauthInfoEntity();
                    registerOauthInfo.setMemberId(register.getId());
                    registerOauthInfo.setSocialUid(uid.toString());
                    registerOauthInfo.setSource("微博");
                    oauthInfoService.save(registerOauthInfo);
                    redisTemplate.opsForValue().set("user_access_token:"+register.getId(),weiboSocialUser.getAccess_token());
                    redisTemplate.opsForValue().set("user_expires_in:"+register.getId(), weiboSocialUser.getExpires_in().toString());
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
            return register;
        }
    }

    @Override
    public MemberEntity login(GiteeSocialUser giteeSocialUser) throws Exception {
        GiteeUserInfo giteeUserInfo = null;
        HttpResponse response = HttpUtils.doGet("https://gitee.com", "/api/v5/user?access_token=" + giteeSocialUser.getAccess_token(), "get", new HashMap<>(), new HashMap<>());
        if(response.getStatusLine().getStatusCode()==200){
            String giteeJSON = EntityUtils.toString(response.getEntity());
            giteeUserInfo = JSON.parseObject(giteeJSON, GiteeUserInfo.class);
        }
        Long uid = giteeUserInfo.getId();
        OauthInfoEntity oauthInfoEntity = oauthInfoService.getOne(new QueryWrapper<OauthInfoEntity>().eq("source", "gitee").eq("social_uid", uid));
        if(oauthInfoEntity != null){
            MemberEntity memberEntity = this.getById(oauthInfoEntity.getMemberId());
            redisTemplate.opsForValue().set("user_access_token:"+memberEntity.getId(),giteeSocialUser.getAccess_token());
            redisTemplate.opsForValue().set("user_expires_in:"+memberEntity.getId(), giteeSocialUser.getExpires_in().toString());
            return memberEntity;
        }
        else{
            MemberEntity register = new MemberEntity();
            register.setLevelId(memberLevelService.getDefaultLevel().getId());
            register.setEmail(giteeUserInfo.getEmail());
            register.setNickname(giteeUserInfo.getName());
            register.setCreateTime(new Date());
            this.save(register);
            OauthInfoEntity registerOauthInfo = new OauthInfoEntity();
            registerOauthInfo.setMemberId(register.getId());
            registerOauthInfo.setSocialUid(uid.toString());
            registerOauthInfo.setSource("gitee");
            oauthInfoService.save(registerOauthInfo);
            redisTemplate.opsForValue().set("user_access_token:"+register.getId(),giteeSocialUser.getAccess_token());
            redisTemplate.opsForValue().set("user_expires_in:"+register.getId(), giteeSocialUser.getExpires_in().toString());
            return register;
        }
    }

}
package com.alatus.mall.member.service;

import com.alatus.mall.member.exception.PhoneExistException;
import com.alatus.mall.member.exception.UsernameExistException;
import com.alatus.mall.member.vo.MemberLoginVo;
import com.alatus.mall.member.vo.MemberRegisterVo;
import com.baomidou.mybatisplus.extension.service.IService;
import com.alatus.common.utils.PageUtils;
import com.alatus.mall.member.entity.MemberEntity;
import com.alatus.common.vo.GiteeSocialUser;
import com.alatus.common.vo.WeiboSocialUser;
import java.util.Map;

/**
 * 会员
 *
 * @author alatus
 * @email 1571345941@qq.com
 * @date 2024-03-12 13:40:22
 */
public interface MemberService extends IService<MemberEntity> {
    PageUtils queryPage(Map<String, Object> params);

    void register(MemberRegisterVo memberRegisterVo);
    void checkPhoneUnique(String phone) throws PhoneExistException;
    void checkUsernameUnique(String username) throws UsernameExistException;
    MemberEntity login(MemberLoginVo memberLoginVo);
    MemberEntity login(WeiboSocialUser weiboSocialUser);
    MemberEntity login(GiteeSocialUser giteeSocialUser) throws Exception;
}
package com.alatus.mall.member.service;

import com.alatus.mall.member.exception.PhoneExistException;
import com.alatus.mall.member.exception.UsernameExistException;
import com.alatus.mall.member.vo.MemberLoginVo;
import com.alatus.mall.member.vo.MemberRegisterVo;
import com.baomidou.mybatisplus.extension.service.IService;
import com.alatus.common.utils.PageUtils;
import com.alatus.mall.member.entity.MemberEntity;
import com.alatus.common.vo.GiteeSocialUser;
import com.alatus.common.vo.WeiboSocialUser;
import java.util.Map;

/**
 * 会员
 *
 * @author alatus
 * @email 1571345941@qq.com
 * @date 2024-03-12 13:40:22
 */
public interface MemberService extends IService<MemberEntity> {
    PageUtils queryPage(Map<String, Object> params);

    void register(MemberRegisterVo memberRegisterVo);
    void checkPhoneUnique(String phone) throws PhoneExistException;
    void checkUsernameUnique(String username) throws UsernameExistException;
    MemberEntity login(MemberLoginVo memberLoginVo);
    MemberEntity login(WeiboSocialUser weiboSocialUser);
    MemberEntity login(GiteeSocialUser giteeSocialUser) throws Exception;
}
/**
 * Copyright 2024
 */
package com.alatus.common.vo;

import lombok.Data;

/**
 * Auto-generated: 2024-09-10 15:47:33
 *
 * @author bejson.com (i@bejson.com)
 * @website http://www.bejson.com/java2pojo/
 */
@Data
public class WeiboSocialUser {
    private String access_token;
    private String remind_in;
    private Long expires_in;
    private String uid;
    private String isRealName;
}

 

/**
 * Copyright 2024
 */
package com.alatus.common.vo;

import lombok.Data;

/**
 * Auto-generated: 2024-09-10 15:47:33
 *
 * @author bejson.com (i@bejson.com)
 * @website http://www.bejson.com/java2pojo/
 */
@Data
public class WeiboSocialUser {
    private String access_token;
    private String remind_in;
    private Long expires_in;
    private String uid;
    private String isRealName;
}


/**
 * Copyright 2024 bejson.com
 */
package com.alatus.common.vo;

import lombok.Data;

/**
 * Auto-generated: 2024-09-10 15:50:12
 *
 * @author bejson.com (i@bejson.com)
 * @website http://www.bejson.com/java2pojo/
 */
@Data
public class GiteeSocialUser {

    private String access_token;
    private String token_type;
    private Long expires_in;
    private String refresh_token;
    private String scope;
    private Long created_at;
}
/**
 * Copyright 2024 bejson.com
 */
package com.alatus.common.vo;

import lombok.Data;

/**
 * Auto-generated: 2024-09-10 15:50:12
 *
 * @author bejson.com (i@bejson.com)
 * @website http://www.bejson.com/java2pojo/
 */
@Data
public class GiteeSocialUser {

    private String access_token;
    private String token_type;
    private Long expires_in;
    private String refresh_token;
    private String scope;
    private Long created_at;
}
package com.alatus.common.vo;

import lombok.Data;
import java.io.Serializable;
import java.util.Date;

@Data
public class MemberRespVo implements Serializable {
    private Long id;
    /**
     * 会员等级id
     */
    private Long levelId;
    /**
     * 用户名
     */
    private String username;
    /**
     * 密码
     */
    private String password;
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 手机号码
     */
    private String mobile;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 头像
     */
    private String header;
    /**
     * 性别
     */
    private Integer gender;
    /**
     * 生日
     */
    private Date birth;
    /**
     * 所在城市
     */
    private String city;
    /**
     * 职业
     */
    private String job;
    /**
     * 个性签名
     */
    private String sign;
    /**
     * 用户来源
     */
    private Integer sourceType;
    /**
     * 积分
     */
    private Integer integration;
    /**
     * 成长值
     */
    private Integer growth;
    /**
     * 启用状态
     */
    private Integer status;
    /**
     * 注册时间
     */
    private Date createTime;
}

package com.alatus.common.vo;

import lombok.Data;
import java.io.Serializable;
import java.util.Date;

@Data
public class MemberRespVo implements Serializable {
    private Long id;
    /**
     * 会员等级id
     */
    private Long levelId;
    /**
     * 用户名
     */
    private String username;
    /**
     * 密码
     */
    private String password;
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 手机号码
     */
    private String mobile;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 头像
     */
    private String header;
    /**
     * 性别
     */
    private Integer gender;
    /**
     * 生日
     */
    private Date birth;
    /**
     * 所在城市
     */
    private String city;
    /**
     * 职业
     */
    private String job;
    /**
     * 个性签名
     */
    private String sign;
    /**
     * 用户来源
     */
    private Integer sourceType;
    /**
     * 积分
     */
    private Integer integration;
    /**
     * 成长值
     */
    private Integer growth;
    /**
     * 启用状态
     */
    private Integer status;
    /**
     * 注册时间
     */
    private Date createTime;
}

spring.application.name=Mall-product
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=a9d97010-7073-4ccf-a3f4-ba6604b86a0a
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
alatusmall.thread.core-size=20
alatusmall.thread.max-size=200
spring.session.store-type=redis
server.servlet.session.timeout=30m
alatusmall.thread.keep-alive-time=10
alatusmall.thread.blocking-deque=100000
spring.application.name=Mall-product
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=a9d97010-7073-4ccf-a3f4-ba6604b86a0a
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
alatusmall.thread.core-size=20
alatusmall.thread.max-size=200
spring.session.store-type=redis
server.servlet.session.timeout=30m
alatusmall.thread.keep-alive-time=10
alatusmall.thread.blocking-deque=100000
package com.alatus.mall.product;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

@SpringBootApplication
@EnableDiscoveryClient
@EnableRedisHttpSession
@EnableFeignClients(basePackages = "com.alatus.mall.product.feign")
@MapperScan("com.alatus.mall.product.dao")
public class MallProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(MallProductApplication.class, args);
    }
}

package com.alatus.mall.product;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

@SpringBootApplication
@EnableDiscoveryClient
@EnableRedisHttpSession
@EnableFeignClients(basePackages = "com.alatus.mall.product.feign")
@MapperScan("com.alatus.mall.product.dao")
public class MallProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(MallProductApplication.class, args);
    }
}
旧约Alatus
关注
专栏目录
SpringSession - 分布式Session解决方案及SpringSession基本使用
江南烟雨却痴缠丶
06-20 1599
分布式Session的几种解决方案 1、Session复制 Tomcat服务器互相同步session。 优点： web-server (Tomcat) 原生支持，只需要修改配置文件 缺点： 1、session同步需要数据传输，占用大量网络带宽，降低了服务器群的业务处理能力 2、任意一台web-server保存的数据都是所有web-server的sesdion总和，受到内存限制无法水平扩展更多的web-server 3、大型分布式集群情况下，由于所有web-server都全量保存数据，所以此方案不可取。 2
2024年Java最新架构设计：Spring-Session分布式集群会话管理，面试官的灵魂拷问
2401_84102840的博客
05-06 799
这份清华大牛整理的进大厂必备的redis视频、面试题和技术文档祝大家早日进入大厂，拿到满意的薪资和职级~~~加油！！！本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取Filter，注意在spring-redis.xml加入配置即可。这份清华大牛整理的进大厂必备的redis视频、面试题和技术文档祝大家早日进入大厂，拿到满意的薪资和职级~~~加油！！！
分布式环境下的session 共享-基于spring-session组件和Redis实现
雾林小妖的博客
12-06 1503
模拟在分布式环境下的，将用户的session信息存入到redis中，实现session信息共享。
SpringBoot 整合 Spring-Session 实现分布式会话（实战篇）
长安明月的博客
07-25 3792
Spring提供了处理分布式会话的解决方案Spring-Session提供了对Redis、MongoDB、MySQL等常用存储的支持，Spring-Session提供与HttpSession的透明整合，这意味着开发人员可以使用Spring-Session支持的实现方式，切换HttpSession至Spring-Session。本文采用Redis作为第三方存储，总结下SpringBoot整合Spring-Session实现分布式会话的实战方式及测试过程。...
spring-session的使用及其原理——分布式session解决方案
秃了也弱了
07-20 1834
当请求进来的时候，SessionRepositoryFilter会先拦截到请求，将request和response对象转换成SessionRepositoryRequestWrapper和SessionRepositoryResponseWrapper。后续当第一次调用request的getSession方法时，会调用到SessionRepositoryRequestWrapper的getSession方法。这个方法是被从写过的，逻辑是先从request的属性中查找，如果找不到。......
spring-session实现分布式session共享及自定义sessionid
热门推荐
小法的博客
02-08 1万+
spring-session实现分布式session共享及自定义sessionid
spring-session:spring session+redis实现分布式缓存
05-26
总的来说，Spring Session与Redis的结合为Java Web应用提供了强大的分布式会话管理解决方案，帮助开发者构建高可用、可扩展的应用。通过深入理解其工作原理和配置细节，我们可以更好地利用这个框架来提升系统的性能...
spring-mvc-redis-session:带有redis的spring-mvc http会话
05-11
spring-mvc-redis-session Spring-mvc session with redis. 使用redis作为session的持久化媒介。 特别说明 注意修改RedisHttpSession中的参数： COOKIE=session id DOMAIN=域名
spring-session+spring+redis的依赖包
02-24
在Java Web开发中，Spring Session是一个非常重要的组件，它提供了会话管理的解决方案，使得在分布式环境中能够跨多个服务器共享用户会话数据。本压缩包包含的“spring-session+spring+redis”组合，是将Spring ...
泽众P-One性能测试平台支持分布式全链路压测
09-14 1035
在当今数字化转型加速的时代，高性能、高可用性的系统已成为企业竞争力的核心要素之一。为了确保系统能够在高并发、大数据量的环境下稳定运行，分布式全链路压测成为了不可或缺的一环。P-One凭借其强大的功能，支持分布式全链路压测，为企业的系统验证提供了强有力的支持。 泽众P-One是泽众科技自主研发的B/S架构一站式性能测试平台，集管理、设计、压测、监控与分析于一体，可高效提升性能测试技术能力，降低门槛与成本，确保软件质量。适用于压力、负载、稳定性、可靠性及容量测试等多种非功能测试场景。
微服务保护学习笔记(五)Sentinel授权规则、获取origin、自定义异常结果、规则持久化
挑灯日记 记录自己
09-13 1197
微服务保护学习笔记(一)雪崩问题及解决方案、Sentinel介绍与安装微服务保护学习笔记(二)簇点链路、流控操作、流控模式(关联、链路)微服务保护学习笔记(三)流控效果(warm up、排队等待)、热点参数限流微服务保护学习笔记(四)FeignClient整合Sentinel、线程隔离（舱壁模式）、熔断降级默认情况下，当发生限流、降级或授权拦截时，都会抛出异常到调用方，并且异常结果都是flow limmiting（即限流，从4.3节的截图可以看出）。这样不够友好，无法得知具体原因。
微服务保护之熔断降级
cyt涛的博客
09-15 988
在微服务架构中，服务之间的调用是通过网络进行的，网络的不确定性和依赖服务的不可控性，可能导致某个服务出现异常或性能问题，进而引发整个系统的故障，这被称为 微服务雪崩。为了防止这种情况发生，常用的一些保护措施包括超时处理、熔断降级、限流、线程池隔离和信号量隔离等。
微服务以及注册中心
2201_75345199的博客
09-16 842
微服务是指开发一个单个小型的但有业务功能的服务，每个服务都有自己的处理和轻量通讯机制，可以部署在单个或多个服务器上。微服务也指一种松耦合的、有一定的有界上下文的面向服务架构。也就是说，如果每个服务都要同时修改，那么它们就不是微服务，因为它们紧耦合在一起：如果你需要掌握一个服务太多的上下文场景使用条件，那么它就是一个有上下文边界的服务，这个定义来自DDD领域驱动设计。
使用OpenFeign在不同微服务之间传递用户信息时失败
qq_45895217的博客
09-16 412
使用OpenFeign在不同微服务之间传递用户信息时失败
微服务之服务注册与发现：Etcd、Zookeeper、Consul 与 Nacos 比较
专注于Python编程技术的分享与交流，致力于帮助开发者提升编程技能，解决实际问题，探索Python的无限可能。
09-14 1095
选择合适的服务注册与发现工具需要综合考虑项目需求、团队技术栈、生态环境等因素。Etcd适合对一致性要求高、对功能相对简单的场景；Zookeeper适合需要高可靠性、丰富功能的场景；Consul适合需要全面的服务治理能力的场景；Nacos适合需要易用性、功能丰富、生态良好的场景。小型项目：优先考虑Etcd或Nacos，易于上手，社区活跃。大型复杂项目：优先考虑Consul或Zookeeper，功能全面，稳定可靠。云原生场景：优先考虑与云平台深度集成的工具，如Consul或Nacos。注意。
JDK 17 微服务启动JVM参数调优实战
极客星云-CSDN博客
09-11 956
JDK17 常用JVM参数调优配置
k8s 微服务 ingress-nginx 金丝雀发布
最新发布
HoweWWW的博客
09-16 986
用控制器来完成集群的工作负载，那么应用如何暴漏出去？需要通过微服务暴漏出去后才能被访问Service是一组提供相同服务的Pod对外开放的接口。借助Service，应用可以实现服务发现和负载均衡。service默认只支持4层负载均衡能力，没有7层功能。（可以通过Ingress实现）金丝雀发布（Canary Release）也称为灰度发布，是一种软件发布策略。主要目的是在将新版本的软件全面推广到生产环境之前，先在一小部分用户或服务器上进行测试和验证，以降低因新版本引入重大问题而对整个系统造成的影响。
微服务_入门1
qq_43563660的博客
09-16 390
微服务学习记录
构建基于 Feign 的微服务：从 Eureka 到负载均衡的实践 --day05
布说在见的博客
09-15 1799
通过上述步骤，成功地创建了一个使用 Feign 实现的服务消费者，它能够调用服务提供者的接口，并且能够处理不同类型的参数（如查询字符串参数和请求体中的复杂对象）。这样的设置不仅简化了服务间调用的代码量，同时也提高了代码的可读性和维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值