Springboot初始化项目并完成登入注册的全过程-Java开发

工作之余,想要学习一下SpringBoot,通过网络大量教程最终成功运行SpringBoot项目,下面这篇文章主要给大家介绍了关于Springboot初始化项目并完成登入注册的相关资料,需要的朋友可以参考下

idea spring Initializr创建项目

勾选项目所需要的依赖

pom.xml文件会加载勾选的依赖，也可以不勾选后面通过自己常用的pom.xml统一导入。

Lombok 可以通过注解省去一些get，set方法。

简单项目常用pom.xml：

mybatis-plus、mybatis、

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example.community</groupId>
    <artifactId>springboot03</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot03</name>
    <description>springboot03</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.13</version>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

整体项目结构

创建User实体类放入Enity下

@TableName("user")是实体对应的表的名字

@TableId(type = IdType.AUTO)表的主键

@TableField(exist = false)不存在，就不会返回空。

package com.example.community.enity;

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.Data;

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Integer userId;
    private String email;
    private String username;
    private String password;
    private String avatar;
    private String phone;
    @TableField(exist = false)
    private String code;
    public User(String email, String password) {
        this.email = email;
        this.password = password;
    }
}

创建通用返回的结果类

可以使用泛型传入对应的实体类，这里我就不传了。

package com.example.community.common;

import lombok.Data;

@Data
public class R {
    private Integer code;
    private String msg;
    private Object data;

    public R(Integer code, String msg, Object ob) {
        this.code = code;
        this.msg = msg;
        this.data = ob;
    }
    public R(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    public static  R success(String msg){
        R r= new R(1,msg);
        return r;
    }
    public static  R success(String msg,Object ob){
        R r= new R(1,msg,ob);
        return r;
    }

    public static  R error(String msg){
        R r= new R(0,msg,null);
        return r;
    }
}

创建controller

在controller里可以对前端的请求进行一个分发，处理。根据地址链接找到对应的controller。

登入模块，可以创建一个UserController处理用户的相关信息。

package com.example.community.controller;

import com.example.community.common.R;
import com.example.community.enity.User;
import com.example.community.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpSession;
import java.util.Map;

@Slf4j
@RestController()
@RequestMapping("/user")
@CrossOrigin(origins = {"http://localhost:8090", "null"})
public class UserController {
    @Autowired
    UserService service;

    @PostMapping("/login")
    public R login(@RequestBody User user) {
        log.info("user"+user.toString());
        return service.login(user.getEmail(), user.getPassword());
    }

    @PostMapping("/register")
    @ResponseBody
    public R register(@RequestBody Map<String, Object> data, HttpSession session) {
        log.info(data.toString());
        String code1 = (String) session.getAttribute("code");
        String email1 = (String) session.getAttribute("email");
        log.info("---------------------------");
        log.info(email1);
        log.info(code1);
        log.info("---------------------------");
        if(code1 == null || email1 == null){
            return R.error("验证码已过期或邮箱有误");
        }
        if (!data.get("password").equals(data.get("password_confirmation"))) {
            return R.error("两次密码不一致");
        }

        if (!email1.equals(data.get("email").toString())) {
            return R.error("邮箱错误");
        }
        if (!code1.equals(data.get("code").toString())) {
            return R.error("验证码错误");
        }
        User user1 = new User(data.get("email").toString(), data.get("password").toString());
        return service.register(user1);
    }
}

创建service层

service层给controller层提供服务，调用dao层mapper查询数据库的数据，提供相对应的服务。

在这里我是用了mybtis-plus来进行数据库简单的查询。

用户模块的service层代码：

UserService接口

继承mybatis-plus的IService

package com.example.community.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.community.common.R;
import com.example.community.enity.User;

public interface UserService extends IService<User> {
    public R selectUserByUsername(String name);
    public R login(String username, String password);
    public R register(User user);
    public R logout(String token);
}

UserService实现类

在这个类中，调用了mapper提供的方法。

继承ServiceImpl

package com.example.community.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.community.Mapper.UserMapper;
import com.example.community.common.R;
import com.example.community.enity.User;
import com.example.community.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public R selectUserByUsername(String name){
        return null;
    }
    @Override
    public R login(String email, String password){
        User user = userMapper.selectOne(new QueryWrapper<User>().eq("email", email));
        if(user == null){
            return R.error("用户不存在");
        }
        if(!user.getPassword().equals(password)){
            return R.error("密码错误");
        }
        return R.success("登录成功");
    }
    @Override
    public R register(User user){
        User user1 = userMapper.selectOne(new QueryWrapper<User>().eq("username", user.getUsername()));
        if(user1 != null){
            return R.error("用户已存在");
        }
        userMapper.insert(user);
        return R.success("注册成功");
    }

    @Override
    public R logout(String token){
        return null;
    }
}

创建Mapper / Dao层

使用了mybatis-plus，所以只需要继承BaseMapper既可。

package com.example.community.Mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.community.enity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {

}

邮箱验证码、生成Token

使用邮箱进行登入验证码验证
使用jwt生成token返回给前端，服务端可以用来判断用户是否登入。并且支持跨域

实现这两个功能需要使用到一些工具类和配置，如下：

package com.example.community.utils;


import io.jsonwebtoken.Jwt;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JWTUtils {

    private static final String jwtToken = "123456Mszlu!@#$$";

    public static String createToken(Long userId) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("userId", userId);
        JwtBuilder jwtBuilder = Jwts.builder()
                .signWith(SignatureAlgorithm.HS256, jwtToken) // 签发算法，秘钥为jwtToken
                .setClaims(claims) // body数据，要唯一，自行设置
                .setIssuedAt(new Date()) // 设置签发时间
                .setExpiration(new Date(System.currentTimeMillis() + 24 * 60 * 60 * 1000));// 一天的有效时间
        String token = jwtBuilder.compact();
        return token;
    }

    public static Map<String, Object> checkToken(String token) {
        try {
            Jwt parse = Jwts.parser().setSigningKey(jwtToken).parse(token);
            return (Map<String, Object>) parse.getBody();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }
}

拦截器的配置

package com.example.community.handler;

import com.alibaba.druid.util.StringUtils;
import com.example.community.common.R;
import com.example.community.utils.JsonUtil;
import lombok.extern.slf4j.Slf4j;
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;

@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler) throws  Exception{
        log.info("请求被拦截{}",request);

        if(!(handler instanceof HandlerMethod)){
            return true;
        }
        String token = request.getHeader("Authorization");
        log.info("token:{}",token);
        if(StringUtils.isEmpty(token)){
            R r= R.error("未登录");
            response.setContentType("application/json;charset=utf-8");
            log.info("{}",r);
            response.getWriter().print(JsonUtil.objectToJson(r));
            return false;
        }

        return true;
    }
}

package com.example.community.config;

import com.example.community.handler.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 用户拦截器
        registry.addInterceptor(new LoginInterceptor())
                // 需要拦截的请求
                .addPathPatterns("/user/**","/article/**")
                // 需要放行的请求
                .excludePathPatterns("/user/login","/user/register","/mail/**")
                // 添加swagger-ui的放行路径
                .excludePathPatterns("/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html/**", "/doc.html/**")
        ;
    }
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOriginPatterns("*")
                .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")
                .maxAge(3600)
                .allowCredentials(true);
    }
}

实现邮箱认证登入，之前写过一个，传送门