从零开始的SpringBoot前后端分离入门级项目（四）

最新推荐文章于 2023-03-30 19:06:59 发布

Alfalfa99

最新推荐文章于 2023-03-30 19:06:59 发布

阅读量848

点赞数 11

本文链接：https://blog.csdn.net/Alfalfa99/article/details/108730154

版权

Spring Boot 专栏收录该内容

8 篇文章 3 订阅

订阅专栏

这是一个目录

前情回顾
正文

前情回顾

在前面几篇文章中我们完成了项目的构建、统一请求返回体和权限验证层面代码的编写，在本次博客我们将通过用户注册和登录功能的编写来感受SpringBoot为程序员带来的便捷体验！

正文

我们目前项目的结构如下，今天我们将在Controller、Service、Dao三层进行我们的开发工作
在这里插入图片描述

构建注册接口

构建UserDao

在编写相关代码之前我们先把目光投向application.yml，我们需要在里面添加相应的配置，这样我们每次执行的SQL语句都会输出到控制台便于调试

mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

我们首先在dao包下创建UserDao接口，该接口将存放与用户有关的持久化的操作。
接口内容如下:

@Repository
public interface UserDao {
}

在目前的实际项目中大多已经转为采用手机号+验证码进行注册了，但是为了简单展示一个大致的流程，本项目仅采用用户名+密码注册的方式。

/**
     * 注册用户
     *
     * @param user 用户pojo
     */
    @Insert("INSERT INTO tb_user(id,username,password,nickname,enable,addtime)" +
            "VALUES(#{user.id},#{user.username},#{user.password},#{user.nickname},#{user.enable},#{user.addtime})")
    void userRegister(@Param("user") User user);

本项目采用的是注解开发的方式，部分注解不会详细解释，如果想要了解更多关于@Insert和@Param注解的读者可以自行前往Mybatis官网阅读相关文档。到此为止我们就将UserDao中用户注册相关的代码编写完毕了。平时我们注册网站时，通常注册时都是比较简洁的，只需要填写账号密码昵称即可，但在代码中还出现了id,addtime,enable等属性这些属性是从哪里来的呢，接下来我们就进入Service层！

构建UserService

步骤同上，我们现在service包下新建UserService类，该类将存放与用户行为有关的业务逻辑。
类的内容如下:

/**
 * @Author Alfalfa99
 * @Date 2020/9/15 19:39
 * @Version 1.0
 */
@Service
public class UserService {
    //通过构造方法注入
	private final UserDao userDao;
    private final IdWorker idWorker;
    private final JwtUtil jwtUtil;
    public UserService(UserDao userDao, IdWorker idWorker, JwtUtil jwtUtil) {
        this.userDao = userDao;
        this.idWorker = idWorker;
        this.jwtUtil = jwtUtil;
    }
}

@Service同样也是向Spring注册自身，在过去我们常常使用@Autowired注解直接对字段进行注入，但是Spring目前已经不推荐这么做了，所以我们使用其推荐的通过构造方法注入的方式。

分布式ID生成算法

注：本类来自网络
IdWorker是推特的Snowflake 的Java实现方式，是一种分布式ID生成方法，其主要适用于微服务架构的系统中，本系统其实无需使用该技术，但为了拓宽读者的知识面所以使用。
请各位笔者在util包下创建IdWorker类，类的内容如下:

/**
 * <p>名称：IdWorker.java</p>
 * <p>描述：分布式自增长ID</p>
 * <pre>
 *     Twitter的 Snowflake　JAVA实现方案
 * </pre>
 * 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用：
 * 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000
 * 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间，
 * 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识），
 * 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。
 * 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分），
 * 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。
 * <p>
 * 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加))
 *
 * @author Polim
 */
@Component
public class IdWorker {
    // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
    private final static long twepoch = 1288834974657L;
    // 机器标识位数
    private final static long workerIdBits = 5L;
    // 数据中心标识位数
    private final static long datacenterIdBits = 5L;
    // 机器ID最大值
    private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
    // 数据中心ID最大值
    private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    // 毫秒内自增位
    private final static long sequenceBits = 12L;
    // 机器ID偏左移12位
    private final static long workerIdShift = sequenceBits;
    // 数据中心ID左移17位
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    // 时间毫秒左移22位
    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    /* 上次生产id时间戳 */
    private static long lastTimestamp = -1L;
    // 0，并发控制
    private long sequence = 0L;

    private final long workerId;
    // 数据标识id部分
    private final long datacenterId;

    public IdWorker(){
        this.datacenterId = getDatacenterId(maxDatacenterId);
        this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
    }
    /**
     * @param workerId
     *            工作机器ID
     * @param datacenterId
     *            序列号
     */
    public IdWorker(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
    /**
     * 获取下一个ID
     *
     * @return
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        if (lastTimestamp == timestamp) {
            // 当前毫秒内，则+1
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 当前毫秒内计数满了，则等待下一秒
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        // ID偏移组合生成最终的ID，并返回ID
        long nextId = ((timestamp - twepoch) << timestampLeftShift)
                | (datacenterId << datacenterIdShift)
                | (workerId << workerIdShift) | sequence;

        return nextId;
    }

    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }

    /**
     * <p>
     * 获取 maxWorkerId
     * </p>
     */
    protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
        StringBuffer mpid = new StringBuffer();
        mpid.append(datacenterId);
        String name = ManagementFactory.getRuntimeMXBean().getName();
        if (!name.isEmpty()) {
         /*
          * GET jvmPid
          */
            mpid.append(name.split("@")[0]);
        }
      /*
       * MAC + PID 的 hashcode 获取16个低位
       */
        return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
    }

    /**
     * <p>
     * 数据标识id部分
     * </p>
     */
    protected static long getDatacenterId(long maxDatacenterId) {
        long id = 0L;
        try {
            InetAddress ip = InetAddress.getLocalHost();
            NetworkInterface network = NetworkInterface.getByInetAddress(ip);
            if (network == null) {
                id = 1L;
            } else {
                byte[] mac = network.getHardwareAddress();
                id = ((0x000000FF & (long) mac[mac.length - 1])
                        | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
                id = id % (maxDatacenterId + 1);
            }
        } catch (Exception e) {
            System.out.println(" getDatacenterId: " + e.getMessage());
        }
        return id;
    }
}

时间戳转换工具(DateTimeTransferUtil)

目前我们在数据库中存储时间时一般存储的是时间戳，为了方便转换和获取我们编写如下的时间戳转换类DateTimeTransferUtil

/**
 * @Author Alfalfa99
 * @Date 2020/9/13 13:54
 * @Version 1.0
 * 获取当前时间戳 && 获取当前标准时间
 */
@Component
public class DateTimeTransferUtil {
    public static String getNowTimeStamp(){
        long time = System.currentTimeMillis();
        time/=1000;
        return String.valueOf(time);
    }

    public static String getFormatTime(){
        String format = "yyyy-MM-dd HH:mm:ss";
        String date = new SimpleDateFormat(format, Locale.CHINA).format(new Date());
        return date;
    }
}

完成上面两个工具类的编写之后我们在UserService中先创建一个userRegister方法

public void userRegister(User user) {
        try {
            user.setId(idWorker.nextId() + "");
            user.setEnable(1);
            user.setAddtime(DateTimeTransferUtil.getNowTimeStamp());
            userDao.userRegister(user);
        } catch (Exception e) {
            throw new DuplicateKeyException("用户名重复");
        }
    }

从这里我们能够看到，类似于用户id，用户注册时间这一类属性其实并不需要前端进行传输，在网络传输中数据量越大效率就越慢，用户的体验也就越差，所以我们将这些业务逻辑在Service层进行处理，在调用userDao的userRegister方法将用户信息持久化到数据库中，在此期间有可能会出现用户名重复的的错误，所以一旦报错就抛出异常告诉前端用户名发生重复，让用户重新填写用户名。

构建UserController

Service层已经构建完成了，让我们将目光转向Controller。我们在controller包下创建UserController类，该类将存放所有与普通用户行为有关的接口。
类的内容如下：

/**
 * @Author Alfalfa99
 * @Date 2020/9/13 13:54
 * @Version 1.0
 * 用户控制器
 */
@RestController
@RequestMapping("/user")
public class UserController {
	private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }
}

@RestController注解是我们将Controller向Spring注册所需的注解，它允许我们直接向前端返回Json格式的数据，是Controller注解和@ResponseBody注解合成而来，它可以简化前后端分离模式中后端接口的开发。
而@RequestMapping注解就很明显了，限定该类中所有方法的父路径为/user 例如： http://localhost:8090/user/A
接下来我们先创建一个注册方法register：

	@PostMapping("/register")
    public CommonResult<String> register(@RequestBody User user) {
    	userService.userRegister(user);
        return new CommonResult<>(20000, "OK", "注册成功");
    }

在前文中我们已经讲述过统一请求返回体CommonResult了，此处就不再啰嗦。
@RequestBody注解用于从前端的请求体中获取数据并可以自动帮我们封装到某个对象或Map中。
@PostMapping()则是制定我们的注册接口只能通过Post方式进行请求，整个注册方法的完整路径为:http://localhost:8090/user/register，在这里一定不要忘记我们在类上添加的RequestMapping("/user")注解！不然项目执行时去访问注册接口会出现404！

测试注册接口

这时候注册接口已经初步构建完成！让我们使用PostMan对接口进行测试吧~
首先我们将项目启动，项目成功启动后控制台输出如下图
在这里插入图片描述
然后我们在PostMan中新建一个请求页面

点击发送按钮！发现什么都没有发生，服务器也没有返回任何响应！

但是看向控制台我们发现确实是有接受到请求的

那这是因为什么呢？让我们把目光放回postman，在响应的状态码一栏我们看到了 401 Unauthorized 说明我们没有权限进行访问！这个问题出现的原因就在于我们引入了SpringSecurity但是没有进行配置~

配置SpringSecurity

在config包下新建WebSecurityConfig配置类

/**
 * 安全配置类
 * @author 苜蓿
 */
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/**").permitAll() //放行所有请求
                .anyRequest().authenticated()
                .and().csrf().disable(); //不允许跨域
    }
}

更多具体的配置内容可以查阅SpringSecurity官方文档

在配置完毕后重启服务，使用postman重新发送请求就发现已经成功了
在这里插入图片描述
同样的内容再发送一次能够看见全局异常处理类也正常

到这里我们的注册功能已经基本完成了，接下来我们进入用户登录功能的编写

构建登录接口

向UserDao添加方法

在前面几个段落中我们已经创建了UserDao，这次我们要实现登录功能，就需在UserDao中添加userLogin方法。

    /**
     * 通过登录的账号查询是否存在该用户
     *
     * @param loginName 登录名，可能是username也可能是email
     * @return 返回用户密码
     */
    @Select("SELECT password FROM tb_user WHERE username = #{loginName}")
    String userLogin(@Param("loginName") String loginName);

我们首先通过用户名去查询数据库中存储的相应密码，由于username存在主键约束，所以我们无需担心重复的问题。

向UserService添加方法

    public String userLogin(User user) {
        String truePassword = userDao.userLogin(user.getUsername());
        if (truePassword.equals(user.getPassword())){
            return "登陆成功";
        }
        throw new InternalAuthenticationServiceException("用户名或密码有误");
    }

在Service层我们判断数据库中存储的密码和用户输入的密码是否匹配，如果匹配则登录成功，如果不匹配则说明账号或密码有误。

向UserController添加方法

    @PostMapping("/login")
    public CommonResult<String> login(@RequestBody User user) {
        userService.userLogin(user);
        return new CommonResult<>(20000, "OK", "登陆成功");
    }

那么我们的登录流程也大致完毕了，这时候我们再次运行程序，使用PostMan进行测试
在这里插入图片描述

我们分别使用正确的和错误的密码去尝试，也得到了相应的结果，说明我们的登录接口也已经编写完成！但事实真的是这样么？请读者重新仔细的阅读上述流程，并回想本系列文章的前面几篇关于鉴权的设计，答案将于本系列的下一篇博客给出，敬请期待！
本次博客的内容也到此为止了,如果对博客内容有疑问可以私信联系笔者，如果这篇文章对你有用希望你能点一个赞，谢谢~