用户增删改查事例

August_May

已于 2024-07-08 00:29:07 修改

阅读量235

点赞数 3

文章标签： spring maven

于 2024-07-07 20:53:25 首次发布

本文链接：https://blog.csdn.net/2301_79923000/article/details/140252054

版权

User

package com.example.demo2.entity;

//import com.example.demo1.vo.UserVO;
import lombok.Data;

@Data
public class User {
    private String username;

    private String password;

    private String name;

    private String profession;

    private String classname;

    private String studentId;

    private int role;

    }

UserController

package com.example.demo2.controller;

import com.example.demo2.common.Wrapper;
import com.example.demo2.common.WrapMapper;
import com.example.demo2.entity.User;
import com.example.demo2.mapper.UserMapper;
import com.example.demo2.service.PhoneService;
import com.example.demo2.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;


@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PhoneService phoneService;


    @ResponseBody
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    public Map<String, Object> userRegister(@RequestBody User user) {
        Map<String, Object> retData = new HashMap<>();
        if (user.getUsername().isEmpty() || user.getPassword().isEmpty() || user.getStudentId().isEmpty()){
            retData.put("code", 500);
            retData.put("message", "参数错误");
            return retData;
        } else {
            return userService.userRegister(user);
        }
    }


//    @Autowired
//    private RedisTemplate redisTemplate;
//
//    @RequestMapping(value = "/register",method = RequestMethod.POST)
//    public Wrapper<Object> userRegister(@RequestBody User user){
//        redisTemplate.opsForValue().set("username",user.getUsername());
//        return WrapMapper.ok();
//    }

//    @RequestMapping(value = "/login",method = RequestMethod.POST)
//    public Wrapper userLogin(){
//        return WrapMapper.ok(redisTemplate.opsForValue().get("username"));
//    }



    @ResponseBody
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
    public Map<String, Object> deleteUser(@RequestBody Map<String, Object> params) {
        String username = (String) params.get("username");
        if (username == null || username.isEmpty()) {
            Map<String, Object> retData = new HashMap<>();
            retData.put("code", 500);
            retData.put("message", "参数错误！");
            return retData;
        } else {
            userMapper.deleteUser(username);
            Map<String, Object> retData = new HashMap<>();
            retData.put("code", 200);
            retData.put("message", "删除成功！");
            return retData;
        }
    }

    @ResponseBody
    @CrossOrigin
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public Map<String, Object> userUpdate(@RequestBody User user) {
        Map<String ,Object> retData = new HashMap<>();
        if(user.getUsername().isEmpty()){
            retData.put("code",500);
            retData.put("message","参数错误!");
            return retData;
        } else {
            return userService.upData(user);
        }
    }



    @Autowired
    private RedisTemplate<String, String> redisTemplate; // Redis客户端实例

    @ResponseBody
    @CrossOrigin
    @RequestMapping(value = "/login", method = RequestMethod.GET)
    public Map<String, Object> login(@RequestParam String username, @RequestParam String password, HttpServletRequest request, HttpSession session) {
        HashMap<String, Object> retMap = new HashMap<>();

        // 检查账户是否被锁定
        String accountLocked = redisTemplate.opsForValue().get("account_locked:" + username);
        if ("locked".equals(accountLocked)) {
            // 检查锁定时间是否已过期
            Long remainingTime = redisTemplate.getExpire("account_locked:" + username, TimeUnit.SECONDS);
            if (remainingTime != null && remainingTime <= 0) {
                // 锁定时间已过期，清除锁定状态并继续登录
                redisTemplate.delete("account_locked:" + username);
            } else {
                // 锁定时间未过期，返回账户已被锁定的错误信息
                retMap.put("code", 401);
                retMap.put("message", "账户已被锁定，请稍后再试");
                return retMap;
            }
        }

        // 如果账号未被锁定，则进行密码验证
        User user = userMapper.getByUsernameAndPassword(username, password);
        if (user != null) {
            // 登录成功，清除错误次数计数器
            redisTemplate.delete("login_failures:" + username);
            request.getSession().setAttribute("user", user);
            retMap.put("data", "登录成功"); // 将字段名称修改为 "data"
            retMap.put("code", 200);
            retMap.put("message", "success");
        } else {
            // 登录失败，增加错误次数计数器
            String storedCount = redisTemplate.opsForValue().get("login_failures:" + username);
            if (storedCount != null) {
                int count = Integer.parseInt(storedCount) + 1;
                redisTemplate.opsForValue().set("login_failures:" + username, String.valueOf(count));
                // 判断错误次数是否达到 3 次
                if (count >= 3) {
                    redisTemplate.opsForValue().set("account_locked:" + username, "locked");
                    redisTemplate.expire("account_locked:" + username, 30, TimeUnit.SECONDS); // 锁定账号 30 秒钟
                    retMap.put("code", 401);
                    retMap.put("message", "账户已被锁定，请稍后再试");
                    return retMap;
                }
            } else {
                // 第一次错误，设置错误次数为 1，并设置过期时间
                redisTemplate.opsForValue().set("login_failures:" + username, "1");
                redisTemplate.expire("login_failures:" + username, 30, TimeUnit.SECONDS);
            }
            retMap.put("code", 401);
            retMap.put("message", "用户名或密码错误，请检查修改");
        }

        return retMap;
    }


    @RequestMapping(value = "/profession")
    public Map<String, Object> getUserByProfession(@RequestParam String profession){
        List<User> users = userService.getUserByProfession(profession);
        HashMap<String, Object> retData = new HashMap<>();
        if(users == null){
            retData.put("code",500);
            retData.put("message","用户为空");
        }else {
            for(User user : users) {
                user.setPassword("********");
            }
            retData.put("code",200);
            retData.put("message","success");
            retData.put("data",users);
        }
        return retData;
    }


    @ResponseBody
    @RequestMapping("/{username}")
    public Map<String, Object> getUserByUsername(@PathVariable String username, HttpServletRequest request){
        User user = userService.getUserByUsername(username);
        Map<String, Object> retData = new HashMap<>();
        request.getSession().getId();
        if(user != null){
            request.getSession().setAttribute("userInfo",user);
            retData.put("code",200);
            retData.put("message","success");
            retData.put("data",user);
        }else {
            retData.put("code",500);
            retData.put("message","null");
        }
        return retData;
    }


    public List<User> getUsers(@RequestBody Map<String, String> requestData) {
        String username = requestData.get("username");
        String password = requestData.get("password");
        String name = requestData.get("name");
        String profession = requestData.get("profession");
        String classname = requestData.get("classname");
        String studentId = requestData.get("student_id");
        Integer role = null;
        if (requestData.containsKey("role")) {
            role = Integer.parseInt(requestData.get("role"));
        }

        // 根据请求参数查询用户

        List<User> users = userMapper.getUser(username, password, name, profession, classname, studentId, role);

        return users;
    }

    @ResponseBody
    @RequestMapping(value = "/get", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
    public Map<String, Object> getUser(@RequestBody Map<String, String> requestData) {
        Map<String, Object> retData = new HashMap<>();

        List<User> users = getUsers(requestData);

        if (!users.isEmpty()) {
            retData.put("status", "success");
            retData.put("message", "查询成功");
            // 隐藏密码
            hidePasswords(users);
            retData.put("users", users);
        } else {
            retData.put("status", "fail");
            retData.put("message", "未找到匹配用户");
        }
        return retData;
    }


    private void hidePasswords(List<User> users) {
        for (User user : users) {
            user.setPassword("******");
        }
    }

    @ResponseBody
    @RequestMapping(value = "/phone")
    public Wrapper getPhoneCode(@RequestParam String channel,@RequestParam String PhoneNum){
        return phoneService.getPhoneCode(channel,PhoneNum);
    }


    @ResponseBody
    @RequestMapping(value = "/login_code", method = RequestMethod.POST)
    public Wrapper getPhoneCode(@RequestParam String channel, @RequestParam String PhoneNum,
                                @RequestParam String PhoneCode, @RequestParam String username,
                                HttpServletRequest request) {
        if (phoneService.validPhoneCode(channel, PhoneNum, PhoneCode)) {
            // 验证码验证成功
            User user = userMapper.getByUsername(username);
            if (user != null) {
                // 用户存在，将用户信息存入会话中
                request.getSession().setAttribute("user", user);
                return WrapMapper.ok();
            } else {
                // 用户不存在
                return WrapMapper.error("用户不存在！");
            }
        } else {
            // 验证码验证失败
            return WrapMapper.error("验证码错误！");
        }
    }
}

UserMapper

package com.example.demo2.mapper;


import com.example.demo2.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

@Mapper
public interface UserMapper {

    public void deleteUser(String username);

    public void updateUser(User user);

    public User getByStudentIdOrName(String studentId,String username);

    public void insertUser(User user);

//    public List<User> getUser(Map<String,Object> params);

    List<User> getUser(@Param("username") String username,
                       @Param("password") String password,
                       @Param("name") String name,
                       @Param("profession") String profession,
                       @Param("classname") String classname,
                       @Param("student_id") String studentId,
                       @Param("role") Integer role);

    public List<User> getByProfession(String profession);

    public User getByUsername(String username);

    User getByUsernameAndPassword(String username, String password);

    List<User> findByUsername(String username);

    // 根据条件查询用户信息
    List<User> getUser(Map<String, Object> params);

    // 删除用户
    void delete(@Param("username") String username);

    // 修改密码
    void updatePwd(@Param("password") String password, @Param("username") String username);
}

UserService

package com.example.demo2.service;

import com.example.demo2.entity.User;
import com.example.demo2.mapper.UserMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class UserService {

    @Autowired
    HttpServletRequest request;

    @Autowired
    private UserMapper userMapper;

    public Map<String,Object> userRegister(User user){
        Map<String,Object> retData = new HashMap<>();
        User userOld = userMapper.getByStudentIdOrName(user.getStudentId(),user.getUsername());
        if(userOld == null){
            userMapper.insertUser(user);
            retData.put("code",200);
            retData.put("message","success");
        }else{
            retData.put("code",200);
            retData.put("message","用户已注册");
        }
        return retData;
    }


    public Map<String,Object> upData(User user){

        Map<String ,Object> retData = new HashMap<>();
        if(user.getUsername() != null){
            userMapper.updateUser(user);
            retData.put("code",200);
            retData.put("message","修改成功");
        }else {
            retData.put("code",500);
            retData.put("message","不能修改用户名和密码");
        }
        return retData;
    }

    public List<User> getUserByProfession(String profession) {
        return userMapper.getByProfession(profession);
    }

    public User getUserByUsername(String username) {
        return userMapper.getByUsername(username);
    }

    public List<User> VerificationCodeLogin(String username){
        return userMapper.findByUsername(username);
    }

    // 根据条件查询用户信息
    public List<User> getUser(Map<String, Object> params) {
        return userMapper.getUser(params);
    }

    // 删除用户
    public void delete(String username) {
        userMapper.delete(username);
    }

    // 修改密码
    public void updatePwd(String password, String username) {
        userMapper.updatePwd(password, username);
    }
}

UserMapper.xml

<?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.example.demo2.mapper.UserMapper">

    <resultMap id="user" type="com.example.demo2.entity.User">
        <id property="username" column="username"></id>
        <result property="password" column="password"></result>
        <result property="name" column="name"></result>
        <result property="profession" column="profession"></result>
        <result property="classname" column="classname"></result>
        <result property="studentId" column="student_id"></result>
        <result property="role" column="role"></result>
    </resultMap>

    <select id="getUserByUsername" resultMap="user">
        select * from register where username = #{username};
    </select>

    <delete id="deleteUser">
        delete from register where username = #{username};
    </delete>

    <delete id="delete">
        DELETE FROM user WHERE username = #{username}
    </delete>

    <!-- 修改密码 -->
    <update id="updatePwd">
        UPDATE user SET password = #{password} WHERE username = #{username}
    </update>

    <select id="getByUsername"  resultMap="user">
        select * from register where username = #{username};
    </select>

    <select id="getByStudentIdOrName"  resultMap="user">
        select * from register where student_id = #{studentId} or username = #{username};
    </select>

    <insert id="insertUser">
        insert into register values (#{username},#{password},#{name},#{profession},#{classname},#{studentId});
    </insert>

    <select id="getUser" resultMap="user">
        select * from register
        <where>
            <if test="username != null">
                and username = #{username}
            </if>
            <if test="password != null">
                and password = #{password}
            </if>
            <if test="name != null">
                and name = #{name}
            </if>
            <if test="profession != null">
                and profession = #{profession}
            </if>
            <if test="classname != null">
                and classname = #{classname}
            </if>
            <if test="student_id != null">
                and student_id = #{studentId}
            </if>
            <if test="role !=null">
                and role = #{role}
            </if>
        </where>
    </select>

    <update id="updateUser">
        update register set password=#{password},name=#{name},profession=#{profession},classname=#{classname}
        where username=#{username};
    </update>

    <select id="getByProfession"  resultMap="user">
        select * from register where profession = #{profession};
    </select>

    <select id="getByUsernameAndPassword"  resultMap="user">
        select * from register where username = #{username} and password = #{password};
    </select>
</mapper>

application.yml

server:
  port: 8090

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/student_system?serverTimezone&useUnicode=true&characterEncoding=UTF-8
    username: root
    password: 1708lgf2580
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

  redis:
    host: 127.0.0.1
    port: 8888
    password: 123456
    lettuce:
      pool:
        max-idle: 16
        max-active: 32
        min-idle: 8

  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 50MB


mybatis:
  mapper-locations: mapper/*.xml

logging:
  file:
    path: D:\idea_project\log
  level:
    com: debug

pom.xml(依赖）


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.29</version>
        </dependency>


        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>


        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>