• 20.项目开发之量化交易QuantTrade(二)

    项目开发之量化交易QuantTrade(二)

    前后端业务：用户登录

    业务实现

    MemberController

    /**
* 登录用户
* @param member
* @return
*/
@ApiOperation("登录接口")
@PostMapping("/login")
public @ResponseBody RestObject login(@RequestBody Member member, @ApiIgnore HttpSession httpSession){
   RestObject restObject = memberService.login(member,httpSession);
   return restObject;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    MemberService

    import com.quanttrade.member.javabean.Member;
import com.quanttrade.member.mapper.MemberMapper;
import com.quanttrade.utils.javabean.RestObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import javax.servlet.http.HttpSession;

@Service
public class MemberService {
   @Autowired
   private MemberMapper memberMapper;

   /**
    * 注册用户信息
    * @param param 用户名、密码、确认密码
    * @return 注册结果
    */
   public RestObject register(Member param) {
       //1、合法性校验
       String serviceMsg = "注册";
       RestObject serviceMsg1 = legitimacyVerification(param, serviceMsg);
       if (serviceMsg1 != null) return serviceMsg1;
       //1.3、确认密码必须存在
       if(param.getRepeat()==null || "".equals(param.getRepeat().trim())){
           return RestObject.ERROR(serviceMsg+"失败，请先填写确认密码！");
       }
       //1.4、密码和确认密码必须保持一致
       if(!param.getAuthstring().equals(param.getRepeat())){
           return RestObject.ERROR(serviceMsg+"失败，密码和确认密码必须保持一致！");
       }
       //2、先对密码进行MD5加密，替换未加密密码
       param.setAuthstring(
               DigestUtils.md5DigestAsHex(
                       param.getAuthstring().getBytes()
               )
       );
       //3、调用mapper层保存数据
       int rows = 0;
       try {
           rows = memberMapper.saveMemberInfo(param);
       } catch (Exception e) {
           String errorMsg = e.getMessage();
           System.out.println(errorMsg);
           if(errorMsg.contains("Duplicate entry")&& errorMsg.contains("tb_member.account")){
               //判断如果是用户名重复了，抛出用户名重复的问题
               return RestObject.ERROR("注册失败，该用户名已注册，请更换一个新的用户名！");
           }
           return RestObject.ERROR("注册失败，请联系管理员");
       }
       //4、返回业务结果
       if(rows>0){
           return RestObject.OK("注册成功！");
       }else{
           return RestObject.ERROR("注册失败，请联系管理员");
       }
   }

   /**
    * 用户名和密码的合法性校验
    * @param param
    * @param serviceMsg
    * @return
    */
   private static RestObject legitimacyVerification(Member param, String serviceMsg) {
       //1.0、防止空指针异常
       if(param == null){
           return RestObject.ERROR(serviceMsg + "失败，请联系管理员");
       }
       //1.1、用户名必须存在
       if(param.getAccount()==null || "".equals(param.getAccount().trim())){
           return RestObject.ERROR(serviceMsg + "失败，请先填写用户名！");
       }
       //1.2、密码必须存在
       if(param.getAuthstring()==null || "".equals(param.getAuthstring().trim())){
           return RestObject.ERROR(serviceMsg + "失败，请先填写密码！");
       }
       return null;
   }

   /**
    * 用户登录业务
    * @param param     用户名、密码
    * @param session   session对象
    * @return              业务结果
    */
   public RestObject login(Member param, HttpSession session) {
       //1、合法性校验
       String serviceMsg = "登录";
       RestObject serviceMsg1 = legitimacyVerification(param, serviceMsg);
       if (serviceMsg1 != null) return serviceMsg1;
       //2、对密码进行一次MD5加密
       param.setAuthstring(
               DigestUtils.md5DigestAsHex(
                       param.getAuthstring().getBytes()
               )
       );
       //3、根据用户名和密码对用户信息进行查询
       Member member = null;
       try {
           member = memberMapper.searchAccountByUserNameAndPassWord(param);
       } catch (Exception e) {
           System.out.println(e.getMessage());
           return RestObject.ERROR("登录失败，请联系管理员!");
       }
       //4、登录业务判断
       if(member!=null && member.getAccount()!=null && !"".equals(member.getAccount())){
           //登录成功
           session.setAttribute("member",member);      //session中保存了用户信息，登录成功的标志
           return RestObject.OK("登录成功");
       }else{
           //登录失败
           return RestObject.ERROR("登录失败，用户名或密码错误!");
       }
   }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118

    MemberMapper

    /**
* 根据用户名和密码查询用户信息
* @param param
* @return
*/
Member searchAccountByUserNameAndPassWord(@Param("member") Member param);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    MemberMapper.xml

    <select id="searchAccountByUserNameAndPassWord" resultType="com.quanttrade.member.javabean.Member">
   SELECT ACCOUNT FROM tb_member WHERE ACCOUNT=#{member.account} AND authstring=#{member.authstring}
</select>


    • 1
    • 2
    • 3
    • 4

    测试：
    01
    02
    03
    04
    05

    前端整合

    06

    后端业务：登录权限校验（自定义注解定制化过程）

    需求说明

    07

    自定义一个注解，要求哪个方法加入@RequireLogin注解，该方法只有登录用户才能执行，非登录用户执行会报错

    业务实现

    构建自定义注解：
    08

    import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface RequireLogin {
   boolean value() default true;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    编写拦截器：
    09

    import com.alibaba.fastjson.JSON;
import com.quanttrade.utils.annotation.RequireLogin;
import com.quanttrade.utils.javabean.RestObject;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;

@Component
public class LoginInterceptor implements HandlerInterceptor {
   /**
    * 在请求指定的 控制器业务方法之前，进行拦截，判断是否有登录权限。
    * 有权限，放行
    * 没有权限，拦截
    * @param request
    * @param response
    * @param handler
    * @return    true 放行   false 拦截
    * @throws Exception
    */
   @Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       if(handler instanceof HandlerMethod){
           //1、判断当前执行的业务方法 是否被注解修饰了
           //1.1、对Handler进行强转
           HandlerMethod handlerMethod = (HandlerMethod) handler;
           //1.2、判断当前方法是否被注解修饰
           RequireLogin requireLogin = handlerMethod.getMethodAnnotation(RequireLogin.class);
           //2、判断当前方法是否需要进行权限校验
           if(requireLogin!=null && requireLogin.value()){
               //3、如果需要进行校验，判断是否有权限，有权限就放行，没有权限就拦截
               //3.1、获取session中的member对象
               Object member = request.getSession().getAttribute("member");
               //3.2、判断member对象是否存在
               if(member==null){
                   //3.3、如果Member不存在，说明没有登录权限，拦截，返回错误信息
                   //处理中文
                   response.setContentType("application/json;charset=utf-8");
                   //向前写出信息
                   PrintWriter writer = response.getWriter();
                   writer.write(JSON.toJSONString(RestObject.ERROR("请先登录！")));
                   //拦截
                   return false;
               }
               //3.4、如果member存在，说明有登录权限直接放行
           }
           //4、如果不需要权限校验，直接放行即可
       }
       //如果不是要拦截的业务方法系列，直接放行
       return true;
   }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    注册拦截器：
    10

    import com.quanttrade.utils.interceptor.LoginInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class MVCConfig implements WebMvcConfigurer {
   @Autowired
   private LoginInterceptor loginInterceptor;

   /**
    * 注册拦截器，为拦截器配置拦截路径
    * @param registry
    */
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
       //注册拦截器，并为该拦截器添加拦截路径
       registry.addInterceptor(loginInterceptor).addPathPatterns("/member/**");
   }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    编写一个测试用的控制器方法：
    MemberController：

    /**
* 测试登录权限校验的接口
* @return
*/
@ApiOperation("测试登录权限校验的接口")
@PostMapping("/testRequireLogin")
@RequireLogin
public @ResponseBody RestObject testRequireLogin(){
   return RestObject.OK("测试成功！您已登录");
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    分别测试未登录 和 登录状态即可!!!
    至此前后端业务实现成功，接下来将数据数据获取阶段

  • 相关阅读:
    【源码解读】VUE2.0和VUE3.0响应式区别？
    Dubbo-接口数据序列化Serialization
    samba 共享目录write permission deny问题修复 可读取内容但不可修改 删除 新增文件
    flink-sql自定义函数
    Docker 自动化部署（实践）
    Linux基础内容（11）—— 进程理解
    MySQL ORDER BY排序一篇就够了
    行为型设计模式 - C++实现
    Docker安装与简单操作
    前端对普通数字数组排序示例
  • 原文地址：https://blog.csdn.net/m0_58503202/article/details/133881494