springboot整合mybatis-实现简单注册登录-体现拦截器

springboot整合mybatis-实现简单注册登录-体现拦截器

思路

springboot整合mybatis实现curd -> 书写注册登录的功能 -> 写注册，登录 ，登陆后可查看的页面 ->设置拦截器（登录后会将用户信息写入session 如果session中那个数据为空，则拦截，不为空，则放行）

步骤

1.导入依赖
2.application.yml 配置文件（配置端口号，mysql数据库连接信息，mybatis配置文件‘mapper’ 的位置）
3.实体类 User
4.持久层 UserMapper mapper配置文件（实现sql语句）
5.服务层 UserService
6.控制层 UserController
7.主页面(登录页面):index.html 注册页面:register.html 登陆后可查看的页面(体现拦截器):welcome.html
8.自定义拦截器 UserInterceptor
9.注册拦截器(配置类) SessionInterceptorConfig 标明拦截哪些，不拦截哪些
10.测试

整体项目结构

1.导入依赖

thymleaf
web
JDBC
mysql
mybatis

		<!--thymleaf 启动依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		<!--JDBC-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<!--web启动依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!--mybatis-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.2.0</version>
		</dependency>
		<!--Mysql-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.9</version>
			<scope>runtime</scope>
		</dependency>

application.yml 配置文件

配置端口号，mysql数据库连接信息，mybatis配置文件(mapper映射文件) 的位置

注：.xml配置文件要编译进去才会起作用（在target下能找到）
springboot中 .xml文件 我习惯于放在recourse目录下

server:
  port: 8082

spring:
  datasource:
    username: root
    password: 111111
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_login

mybatis:
  # mapper映射文件的位置
  mapper-locations: classpath:mybatis/*.xml

3.实体类 User

package com.node.springboot.model;

public class User {

    private int id;
    private String username;
    private String password;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

4.持久层

UserMapper

mapper持久层 要在类上方加入@Mapper注解 或者 @Repository注解

@Mapper和@Repository的区别：

@Repository需要在Spring中配置扫描地址，然后生成Dao层的Bean才能被注入到Service层中。

@Mapper不需要配置扫描地址，通过xml里面的namespace里面的接口地址，生成了Bean后注入到Service层中。

package com.node.springboot.mapper;

import com.node.springboot.model.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
public interface UserMapper {

    public void insertUser(User user);

    public User selectUserByUid(int uid);

    public List<User> selectAll();

    public int register(User user);

    public User login(User user);
}

mapper配置文件（实现sql语句） UserMapper.xml

注：mapper类和mapper配置文件的名称必须一样

namespace: mapper类的全限定名称

resultType: 结果集的全限定名称

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.node.springboot.mapper.UserMapper">
    <select id="selectUserByUid" resultType="com.node.springboot.model.User">
        select id,username,password,age from user where id=#{uid}
    </select>

    <select id="selectAll" resultType="com.node.springboot.model.User">
        select * from user
    </select>

    <insert id="insertUser">
        insert into user (id,username,password,age) values (#{id},#{username},#{password},#{age})
    </insert>

    <insert id="register">
        insert into user (username,password,age) values (#{username},#{password},#{age})
    </insert>

    <select id="login" resultType="com.node.springboot.model.User">
        select id,username,password,age from user where username=#{username} and password=#{password}
    </select>
</mapper>

5.服务层

接口UserService

注：@Service注解加载接口的实现类上

package com.node.springboot.service;

import com.node.springboot.model.User;

import java.util.List;

public interface UserService {

    public boolean insert(User user);

    public User findUserByUid(int uid);

    public List<User> findAll();

    public int register(User user);

    public User login(User user);

}

接口实现类 UserServiceImpl

package com.node.springboot.service.impl;

import com.node.springboot.mapper.UserMapper;
import com.node.springboot.model.User;
import com.node.springboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public boolean insert(User user) {
        try{
            userMapper.insertUser(user);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    @Override
    public User findUserByUid(int uid) {

        return userMapper.selectUserByUid(uid);
    }

    @Override
    public List<User> findAll() {
        return userMapper.selectAll();
    }

    @Override
    public int register(User user) {
        return userMapper.register(user);
    }

    @Override
    public User login(User user) {
        return userMapper.login(user);
    }
}

6.控制层 UserController

package com.node.springboot.controller;

import com.node.springboot.model.User;
import com.node.springboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

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

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 注册
     * @param username
     * @param password
     * @return
     */
    @RequestMapping("/registerUser")
    public String register(@RequestParam("username")String username, @RequestParam("password")String password,
                           HttpServletRequest request){

        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        if(userService.register(user)>0){
            request.getSession().setAttribute("session_user",user);
            return "welcome";
        }

        else
            return "注册失败";
    }

    /**
     * 登录 把登录的信息保存到session中
     * @param username
     * @param password
     * @param request
     * @return
     */
    @RequestMapping("/loginUser")
    public String login(@RequestParam("username")String username, @RequestParam("password")String password,
                        HttpServletRequest request){
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);

        User user2 = userService.login(user);
        if(user2==null){
            return "用户名或密码错误";
        }else{
            request.getSession().setAttribute("session_user",user);//登录成功后将用户放入session中，用于拦截
            return "welcome";
        }
    }

    //跳转到首页
    @RequestMapping("/toIndex")
    public String show(){
        return "index";
    }

    //跳转到注册页面
    @RequestMapping("/toRegister")
    public String toRegister(){
        return "register";
    }

    //测试未登陆拦截页面
    @RequestMapping("/toWelcome")
    public String welcome(){
        return "welcome";
    }

}

7.html页面

主页面(登录页面):index.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<form action="/user/loginUser" method="post">
    请输入用户名--：<input type="text" name="username" id="userName"/><br>
    请你输入密码--：<input type="password" name="password" id="passWord"/><br>
    <input type="submit" value="Login"/>
    <a href="/user/toRegister">--注册--</a>
</form>

</body>
</html>

注册页面:register.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>register</title>
</head>
<body>

<form action="/user/registerUser" method="post">
    请输入用户名--：<input type="text" name="username" id="userName"/><br>
    请你输入密码--：<input type="password" name="password" id="passWord"/><br>
    <input type="submit" value="Register"/>
</form>

</body>
</html>

登陆后可查看的页面(体现拦截器):welcome.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

注册或登录后才能看到的界面

<a href="/user/outUser">退出登录</a>
</body>
</html>

8.自定义拦截器 UserInterceptor

在类上方加上@Component注解 把该类当作Bean交给springboot容器

package com.node.springboot.interceptor;

import com.node.springboot.model.User;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

@Component
public class UserInterceptor implements HandlerInterceptor {

    /*
     * 进入controller层之前拦截请求
     * 返回值：表示是否将当前的请求拦截下来  false：拦截请求，请求别终止。true：请求不被拦截，继续执行
     * Object obj:表示被拦的请求的目标对象（controller中方法）
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
        System.out.println("执行到了preHandle方法");
        System.out.println(handler);
        User user = (User) request.getSession().getAttribute("session_user");
        if (user==null){
            response.sendRedirect(request.getContextPath()+"/user/toIndex");//拦截后跳转的方法
            System.out.println("已成功拦截并转发跳转");
            return false;
        }
        System.out.println("合格不需要拦截，放行");
        return true;
    }

    /*
     * 处理请求完成后视图渲染之前的处理操作
     * 通过ModelAndView参数改变显示的视图，或发往视图的方法
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        System.out.println("执行了postHandle方法");
    }

    /*
     * 视图渲染之后的操作
     */
    @Override
    public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {
        System.out.println("执行到了afterCompletion方法");
    }

}

9.注册拦截器(配置类) SessionInterceptorConfig

在类上方加上@Configuration注解

自定义拦截器后 需要注册拦截器，把自定义的拦截器加入到容器中，声明拦截哪些，不拦截哪些url请求

package com.node.springboot.config;

import com.node.springboot.interceptor.UserInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class SessionInterceptorConfig implements WebMvcConfigurer {
    /**
     * 自定义拦截器，添加拦截路径和排除拦截路径
     * addPathPatterns():添加需要拦截的路径
     * excludePathPatterns():添加不需要拦截的路径
     */
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        List list = new ArrayList();
        list.add("/user/toIndex");
        list.add("/user/loginUser");
        list.add("/user/registerUser");
        list.add("/user/toRegister");
        registry.addInterceptor(new UserInterceptor()).addPathPatterns("/**").excludePathPatterns(list);
    }

}

测试

访问

因为未登录 所以拦截url请求 进入指定的url (就是下面那张图)

登陆成功后会跳转到welcome界面