前后端分离式开发01

1 前后端练习 - 模拟用户登录

1.1 需求

模拟用户登录过程,利用前后端分离的开发方式,完成项目练习

1.2 数据库表设计

jack 123 | rose 456 | tony 1234 | test 123456

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(80) DEFAULT NULL,
  `password` varchar(80) DEFAULT NULL,
  `phone` varchar(20) DEFAULT NULL,
  `email` varchar(40) DEFAULT NULL,
  `status` tinyint(1) DEFAULT NULL,
  `created` datetime DEFAULT NULL,
  `updated` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

insert  into `user`(`id`,`username`,`password`,`phone`,`email`,`status`,`created`,`updated`) values 
(1,'jack','202cb962ac59075b964b07152d234b70','13111112222','[email protected]',1,'2021-02-18 19:17:23','2021-03-26 14:47:20'),
(2,'rose','250cf8b51c773f3f8dc8b4be867a9a02','13111112223','[email protected]',1,'2021-02-18 19:17:23','2021-05-21 17:34:32'),
(4,'tony','81dc9bdb52d04dc20036dbd8313ed055','13111112222','[email protected]',1,'2021-03-22 21:25:06','2021-03-22 21:25:06'),
(5,'test','e10adc3949ba59abbe56e057f20f883e','17688888888','[email protected]',1,'2021-05-10 19:01:45','2021-05-10 19:01:45');

1.3 后端项目结构

1.4 后端开发

1.4.1 修改pom.xml

<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.0modelVersion>
    <groupId>cn.tedugroupId>
    <artifactId>ssmartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>ssmname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <java.version>1.8java.version>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASEspring-boot.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>2.1.4version>
        dependency>

        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <scope>runtimescope>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
    dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-dependenciesartifactId>
                <version>${spring-boot.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.8.1version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                    <encoding>UTF-8encoding>
                configuration>
            plugin>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <version>2.3.7.RELEASEversion>
                <configuration>
                    <mainClass>cn.tedu.SsmApplicationmainClass>
                configuration>
                <executions>
                    <execution>
                        <id>repackageid>
                        <goals>
                            <goal>repackagegoal>
                        goals>
                    execution>
                executions>
            plugin>
        plugins>
    build>

project>

1.4.2 创建VO - SysResult类

VO：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来，SysResult统一前后端数据交互的格式

package cn.tedu.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
@Data
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class SysResult implements Serializable {
    private Integer status;//状态码  200成功 201失败
    private String msg;//描述信息
    private Object data;//返回给页面的数据

    //封装几个方便调用的方法
    public static SysResult failed(){
        return new SysResult(201,"调用失败!!",null);
    }
    public static SysResult success(){
        return new SysResult(200,"调用成功!!",null);
    }
    public static SysResult success(Object data){
        return new SysResult(200,"调用成功!!",data);
    }
   
}

1.4.3 创建启动类

package cn.tedu;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("cn.tedu.dao")//扫描dao层的接口文件所在包
public class SsmApplication {

    public static void main(String[] args) {
        SpringApplication.run(SsmApplication.class, args);
    }

}

1.4.4 创建核心配置文件application.yml

server:
  port: 8091
#SpringBoot配置mysql信息
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///cgbtest?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: root
#SpringBoot整合Mybatis配置
mybatis:
  #别名包
  type-aliases-package: cn.tedu.pojo
  #指定UserMapper.xml文件的位置
  mapper-locations: classpath:mappers/*.xml
  #开启驼峰映射
  configuration:
    map-underscore-to-camel-case: true

1.4.5 创建pojo

pojo是简单的Java对象，其中有一些属性及其getter setter方法的类，没有业务逻辑，有时可以作为VO
BasePojo

package cn.tedu.pojo;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

//pojo基类，完成2个任务，2个日期，实现序列化
@Data
@Accessors(chain=true)
public class BasePojo implements Serializable {
    @TableField(fill = FieldFill.INSERT)
    private Date created;	//表示入库时需要赋值
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updated;	//表示入库/更新时赋值.
}

User

package cn.tedu.pojo;

import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
@Data
@Accessors(chain = true)
public class User extends BasePojo implements Serializable {
    private Integer id;
    private String username;
    private String password;
    private String phone;
    private String email;
    private Integer status;//1是启用0是停用

}

1.4.6 创建Controller层

Token：Token （令牌）是在服务端产生的。如果前端使用用户名/密码向服务端请求认证，服务端认证成功，那么在服务端会返回 Token 给前端。前端可以在每次请求的时候带上 Token 证明自己的身份。如果这个 Token 在服务端持久化（比如存入数据库），那它就是一个永久的身份令牌。
使用token来标识当前用户，后端就能根据这个字段知道是哪个用户发起的请求了

package cn.tedu.controller;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.User;
import cn.tedu.service.UserService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("user")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    @PostMapping("login")
    public SysResult login(@RequestBody User user){
        String token = userService.login(user);
        if(null==token)
            return SysResult.failed();//登录失败
        return SysResult.success(token);//登录成功,返回token
    }

}

1.4.7 创建Service层

MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm）, 一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value）, 用于确保信息传输完整一致，（数字指纹）,MD5是不可逆的

接口文件

package cn.tedu.service;

import cn.tedu.pojo.User;

import java.util.List;

public interface UserService {
    List<User> findAll();
    String login(User user);
}

实现类

package cn.tedu.service;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.List;
import java.util.UUID;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

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

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    //密码还要加密处理,要拿着用户的明文密码 加密后 和 库里加密密码 对比->加密算法:md5/sha/md5hash..
    @Override
    public String login(User user) {
        //把明文密码获取出来,进行加密
        String pwd = user.getPassword();
        System.out.println(user+"=================="+pwd);
        //把明文密码加密,利用MD5算法
        /*
            MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），
            一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），
            用于确保信息传输完整一致。（数字指纹）,MD5是不可逆的
         */
        String md5pwd = DigestUtils.md5DigestAsHex(pwd.getBytes());
        System.out.println(user+"=================="+md5pwd);
        //查询用户数据
        user.setPassword(md5pwd);//用加密密码查
        User u = userMapper.findByNP(user);
        if(u==null) return null; //没查到就返回null
        String token = UUID.randomUUID().toString();//查到了,就返回一个token
        return token;
    }

1.4.8 创建Dao层

接口

package cn.tedu.dao;

import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

public interface UserMapper {
    List<User> findAll();//查找所有用户
    User findByNP(User user);//登录,根据账号密码查用户
}

映射文件

<mapper namespace="cn.tedu.dao.UserMapper">
    
    <select id="findAll" resultType="User">
        select * from user
    select>
    
    <select id="findByNP" resultType="User">
        select * from user where username=#{username} and password=#{password}
    select>
mapper>

1.5 前端开发

找到课程资料的jtadmin.zip，导入HB中开发，在命令行中使用 vue ui 启动vue项目，并访问测试

1.6 测试

2 前后端练习 - 展示左侧菜单

2.1 需求

当完成用户登录后,继续完善系统的左侧菜单,展示一级二级目录

2.2 数据库表设计

#创建表
CREATE TABLE `rights` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(40) DEFAULT NULL,
  `parent_id` INT(11) DEFAULT NULL,
  `path` VARCHAR(50) DEFAULT NULL,
  `level` INT(11) DEFAULT NULL,
  `created` DATETIME DEFAULT NULL,
  `updated` DATETIME DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8;

#插入数据
INSERT  INTO `rights`(`id`,`name`,`parent_id`,`path`,`level`,`created`,`updated`) VALUES (1,'用户管理',0,NULL,1,'2021-02-18 19:17:23','2021-02-18 19:17:23'),(2,'用户列表',1,'/user',2,'2021-02-18 19:22:19','2021-02-18 19:22:19'),(3,'商品管理',0,NULL,1,'2021-02-18 19:22:41','2021-02-18 19:22:41'),(4,'商品列表',3,'/item',2,'2021-02-18 19:23:12','2021-02-18 19:23:12'),(6,'商品分类',3,'/itemCat',2,'2021-02-18 19:25:00','2021-02-18 19:25:00'),(7,'权限管理',0,'',1,'2021-02-18 19:23:44','2021-02-18 19:23:44'),(8,'数据统计',0,NULL,1,'2021-02-18 19:24:12','2021-02-18 19:24:12'),(9,'权限列表',7,'/rights',2,'2021-02-18 19:24:12','2021-02-18 19:24:12'),(10,'角色列表',7,'/role',2,'2021-02-18 19:24:12','2021-02-18 19:24:12'),(11,'用户列表-新增按钮',2,NULL,3,'2021-02-18 19:24:12','2021-02-18 19:24:12'),(12,'用户列表-修改按钮',2,NULL,3,'2021-02-18 19:24:12','2021-02-18 19:24:12'),(13,'用户列表-删除按钮',2,NULL,3,'2021-02-18 19:24:12','2021-02-18 19:24:12'),(15,'统计报表',8,'/report',2,'2021-02-18 19:24:12','2021-02-18 19:24:12');

2.3 后端项目结构

2.4 后端开发

2.4.1 修改pom.xml

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-annotationartifactId>
    <version>3.4.2version>
dependency>

2.4.2 创建pojo

Rights

package cn.tedu.pojo;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.List;


//权限封装
@TableName
@Data
@Accessors(chain = true)
public class Rights extends BasePojo{
    private Integer id;
    private String name;
    private Integer parentId;
    private String path;
    private Integer level;
    @TableField(exist = false)
    private List<Rights> children; //不是表格固有属性,存二级菜单
}

2.4.3 创建Controller层

package cn.tedu.controller;

import cn.tedu.pojo.Rights;
import cn.tedu.service.RightsService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("rights")
@CrossOrigin
public class RightsController {
    @Autowired
    private RightsService rightsService;

    @GetMapping("getRightsList")
    public SysResult getRightsList(){
        //获取权限列表
        List<Rights> list = rightsService.getRightsList();
        return SysResult.success(list);
    }
}

2.4.4 创建Service层

接口文件

package cn.tedu.service;

import cn.tedu.pojo.Rights;

import java.util.List;

public interface RightsService {
    List<Rights> getRightsList(); //获取权限列表
}

实现类

package cn.tedu.service;

import cn.tedu.dao.RightsMapper;
import cn.tedu.pojo.Rights;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class RightsServiceImpl implements RightsService{

    @Autowired
    private RightsMapper rightsMapper;
    //获取权限列表
    @Override
    public List<Rights> getRightsList() {
        return rightsMapper.getRightsList();
    }
}

2.4.5 创建dao层

接口文件

package cn.tedu.dao;

import cn.tedu.pojo.Rights;

import java.util.List;

public interface RightsMapper {

    List<Rights> getRightsList();//获取权限列表
}

映射文件

<mapper namespace="cn.tedu.dao.RightsMapper">
    
    <resultMap id="rightsRM" type="Rights" autoMapping="true">
        <id property="id" column="id">id>
        
        <collection property="children" ofType="Rights">
            
            <id property="id" column="cid">id>
            <result property="name" column="cname">result>
            <result property="parentId" column="cparentid">result>
            <result property="path" column="cpath">result>
            <result property="level" column="clevel">result>
            <result property="created" column="ccreated">result>
            <result property="updated" column="cupdated">result>
        collection>
    resultMap>

    <select id="getRightsList" resultMap="rightsRM">
        /* 查一级菜单的子级:两种方式效果相同
            select * from rights p left join rights c
            where p.id=c.parent_id
            and p.parent_id=0
       */
       /* 存在大量重复的字段名,需用改名
            select * from
            ( select * from rights where parent_id=0 ) p left join rights c
            where p.id=c.parent_id
       */
        SELECT * FROM
        (SELECT * FROM rights a WHERE a.`parent_id`=0 )p  /*查一级*/
        LEFT JOIN /*关联查二级*/
        (SELECT id cid,NAME cname,parent_id cparentid,path cpath,LEVEL clevel,created ccreated,updated cupdated FROM rights) c
        ON p.id=c.cparentid /*用别名*/
    select>

mapper>

2.5测试

启动Vue项目，输入正确的用户名密码，直接登录，登录成功后，可以看到左侧菜单，就说明查询成功啦。

3 前后端练习 - 用户管理

3.1 需求

基于上面的过程,让我们继续来完成用户管理,完成用户的CRUD.

3.2 前端开发

打开router/index.js文件,修改文件的第二步,添加用户组件

3.3 后端开发 - 用户列表

3.3.1 项目结构

3.3.2 创建pojo层 - PageResult类

封装了分页信息,包括分页的查询条件,和查到的数据等.

package cn.tedu.pojo;

import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;

@Data
@Accessors(chain = true)
public class PageResult implements Serializable {
    private String query;//查询条件
    private Integer pageNum;//查询页数
    private Integer pageSize;//一次要查询条数
    private Long total;//查询总记录数
    private Object rows;//分页的结果
}

3.3.3 创建controller层

添加新的方法findUserList()

package cn.tedu.controller;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.service.UserService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("user")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;
	 //查分页,携带着参数来3个请求数据,query,pageNum,pageSize
    //返回数据中,包含着查到的分页数据
    @GetMapping("list")
    public SysResult findUserList(PageResult pageResult){
        pageResult = userService.findUserList(pageResult);//根据分页条件,查询分页数据
        return SysResult.success(pageResult);//把分页数据传递给前端
    }


    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    @PostMapping("login")
    public SysResult login(@RequestBody User user){
        String token = userService.login(user);
        if(null==token)
            return SysResult.failed();//登录失败
        return SysResult.success(token);//登录成功,返回token
    }

   
}

3.3.4 创建service层

接口文件

package cn.tedu.service;

import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;

import java.util.List;

public interface UserService {
   //查分页,携带着参数来请求数据,要从第几条开始查,一共要查几条
    PageResult findUserList(PageResult pageResult);
    
    List<User> findAll();
    String login(User user);
 
}

实现类,添加findUserList()的方法体

package cn.tedu.service;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.List;
import java.util.UUID;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;
    
  	//查分页,携带着参数来3个请求数据,要从第几条开始查,一共要查几条
    @Override
    public PageResult findUserList(PageResult pageResult) {
        //前端页面携带来3个数据,还差两个,需用自己封装
        Long total = userMapper.count(); //查询总记录数
        //第一页: limit 0,10  第二页: limit 10,10  第三页:limit 30,10  第n页:limit (n-1)*10,10
        int start = ( pageResult.getPageNum()-1 ) * pageResult.getPageSize() ; //limit后的第一个数值
        int num = pageResult.getPageSize(); //limit后的第一个数值
        String query = pageResult.getQuery(); //要查询的条件
        //根据分页条件,查询分页的数据,自己算位置
        List<User> list = userMapper.findUserList(start,num,query);
        return pageResult.setTotal(total).setRows(list);
    }
    
    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    //密码还要加密处理,要拿着用户的明文密码 加密后 和 库里加密密码 对比->加密算法:md5/sha/md5hash..
    @Override
    public String login(User user) {
        //把明文密码获取出来,进行加密
        String pwd = user.getPassword();
        System.out.println(user+"=================="+pwd);
        //把明文密码加密,利用MD5算法
        /*
            MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），
            一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），
            用于确保信息传输完整一致。（数字指纹）,MD5是不可逆的
         */
        String md5pwd = DigestUtils.md5DigestAsHex(pwd.getBytes());
        System.out.println(user+"=================="+md5pwd);
        //查询用户数据
        user.setPassword(md5pwd);//用加密密码查
        User u = userMapper.findByNP(user);
        if(u==null) return null;
        String token = UUID.randomUUID().toString();
        return token;
    }
  
}

3.3.5 创建dao层

接口文件

package cn.tedu.dao;

import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

public interface UserMapper {
   	//根据分页条件,查询分页的数据,多个数据,进行封装
    //@Param是为了传递多个参数，解决的是可读性和直观性,会自动把参数封装成map结构,key就是括号里的值,value就是变量名
    //@Param和@RequestParam是什么关系？雷锋和雷锋塔的关系,没关系
    List<User> findUserList(@Param("start") int start,@Param("num")  int num,@Param("query")  String query);
    
    List<User> findAll();//查找所有用户
    User findByNP(User user);//登录,根据账号密码查用户
    Long count();//查询总记录数
 
}

映射文件,添加后两个SQL

<mapper namespace="cn.tedu.dao.UserMapper">

 	
    <select id="count" resultType="long">
        select count(1) from user
    select>
    
     
    <select id="findUserList" resultType="User">
        select * from user
        <where>
            <if test="query!=null and query!='' ">
                username like '%'#{query}'%'
            if>
        where>
        limit #{start},#{num}
    select>

    
    <select id="findAll" resultType="User">
        select * from user
    select>
    
    <select id="findByNP" resultType="User">
        select * from user where username=#{username} and password=#{password}
    select>

   
mapper>

3.3.6 测试

3.4 后端开发 - 用户删除

3.4.1 创建Controller层

package cn.tedu.controller;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.service.UserService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.security.sasl.SaslServer;
import java.util.List;

@RestController
@RequestMapping("user")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;

    //删除用户
    @DeleteMapping("/{id}")
    public SysResult deleteById(@PathVariable Integer id){
        userService.deleteById(id);
        return SysResult.success();
    }

    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    @PostMapping("login")
    public SysResult login(@RequestBody User user){
        String token = userService.login(user);
        if(null==token)
            return SysResult.failed();//登录失败
        return SysResult.success(token);//登录成功,返回token
    }

    //查分页,携带着参数来3个请求数据,query,pageNum,pageSize
    //返回数据中,包含着查到的分页数据
    @GetMapping("list")
    public SysResult findUserList(PageResult pageResult){
        pageResult = userService.findUserList(pageResult);//根据分页条件,查询分页数据
        return SysResult.success(pageResult);//把分页数据传递给前端
    }


}

3.4.2 创建Service层

接口文件

package cn.tedu.service;

import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

public interface UserService {
    List<User> findAll();
    String login(User user);
    //查分页,携带着参数来请求数据,要从第几条开始查,一共要查几条
    PageResult findUserList(PageResult pageResult);
    //删除用户
    void deleteById(Integer id);
}

实现类文件

package cn.tedu.service;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.List;
import java.util.UUID;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

    //删除用户
    @Override
    public void deleteById(Integer id) {
        userMapper.deleteById(id);
    }

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

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    //密码还要加密处理,要拿着用户的明文密码 加密后 和 库里加密密码 对比->加密算法:md5/sha/md5hash..
    @Override
    public String login(User user) {
        //把明文密码获取出来,进行加密
        String pwd = user.getPassword();
        System.out.println(user+"=================="+pwd);
        //把明文密码加密,利用MD5算法
        /*
            MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），
            一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），
            用于确保信息传输完整一致。（数字指纹）,MD5是不可逆的
         */
        String md5pwd = DigestUtils.md5DigestAsHex(pwd.getBytes());
        System.out.println(user+"=================="+md5pwd);
        //查询用户数据
        user.setPassword(md5pwd);//用加密密码查
        User u = userMapper.findByNP(user);
        if(u==null) return null;
        String token = UUID.randomUUID().toString();
        return token;
    }
    //查分页,携带着参数来3个请求数据,要从第几条开始查,一共要查几条
    @Override
    public PageResult findUserList(PageResult pageResult) {
        //前端页面携带来3个数据,还差两个,需用自己封装
        Long total = userMapper.count(); //查询总记录数
        //第一页: limit 0,10  第二页: limit 10,10  第三页:limit 30,10  第n页:limit (n-1)*10,10
        int start = ( pageResult.getPageNum()-1 ) * pageResult.getPageSize() ; //limit后的第一个数值
        int num = pageResult.getPageSize(); //limit后的第一个数值
        String query = pageResult.getQuery(); //要查询的条件
        //根据分页条件,查询分页的数据,自己算位置
        List<User> list = userMapper.findUserList(start,num,query);
        return pageResult.setTotal(total).setRows(list);
    }

}

3.4.3 创建dao层

接口文件

package cn.tedu.dao;

import cn.tedu.pojo.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {
    List<User> findAll();//查找所有用户
    User findByNP(User user);//登录,根据账号密码查用户

    //MP,省略了去mapper.xml文件中,写SQL的过程
    @Select("select count(1) from user")
    Long count();//查询总记录数
    //根据分页条件,查询分页的数据,多个数据,进行封装,@Param,可以把参数自动封装成map结构,key就是括号里的值
    List<User> findUserList(@Param("start") int start,@Param("num")  int num,@Param("query")  String query);

    //删除用户
    @Delete("delete from user where id=#{id}")
    void deleteById(Integer id);
}

3.4.4 测试

3.5 后端开发 - 用户新增

3.5.1 创建Controller层

package cn.tedu.controller;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.service.UserService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.security.sasl.SaslServer;
import java.util.List;

@RestController
@RequestMapping("user")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;

    //添加用户
    @PostMapping("addUser")
    public SysResult addUser(@RequestBody User user){
        userService.addUser(user);
        return SysResult.success();
    }

    //删除用户
    @DeleteMapping("/{id}")
    public SysResult deleteById(@PathVariable Integer id){
        userService.deleteById(id);
        return SysResult.success();
    }

    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    @PostMapping("login")
    public SysResult login(@RequestBody User user){
        String token = userService.login(user);
        if(null==token)
            return SysResult.failed();//登录失败
        return SysResult.success(token);//登录成功,返回token
    }

    //查分页,携带着参数来3个请求数据,query,pageNum,pageSize
    //返回数据中,包含着查到的分页数据
    @GetMapping("list")
    public SysResult findUserList(PageResult pageResult){
        pageResult = userService.findUserList(pageResult);//根据分页条件,查询分页数据
        return SysResult.success(pageResult);//把分页数据传递给前端
    }


}

3.5.2 创建Service层

接口文件

package cn.tedu.service;

import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

public interface UserService {

    //添加用户
    void addUser(User user);
    
    List<User> findAll();
    String login(User user);
    //查分页,携带着参数来请求数据,要从第几条开始查,一共要查几条
    PageResult findUserList(PageResult pageResult);
    //删除用户
    void deleteById(Integer id);

}

实现类

package cn.tedu.service;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

    //添加用户
    @Override
    public void addUser(User user) {
        //把明文密码  加密后 入库
        String password = user.getPassword();
        String md5password = DigestUtils.md5DigestAsHex(password.getBytes());
        //设置用户信息
        user.setPassword(md5password).setStatus(1)
                .setCreated(new Date()).setUpdated(user.getCreated());
        userMapper.addUser(user);
    }

    //删除用户
    @Override
    public void deleteById(Integer id) {
        userMapper.deleteById(id);
    }

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

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    //密码还要加密处理,要拿着用户的明文密码 加密后 和 库里加密密码 对比->加密算法:md5/sha/md5hash..
    @Override
    public String login(User user) {
        //把明文密码获取出来,进行加密
        String pwd = user.getPassword();
        System.out.println(user+"=================="+pwd);
        //把明文密码加密,利用MD5算法
        /*
            MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），
            一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），
            用于确保信息传输完整一致。（数字指纹）,MD5是不可逆的
         */
        String md5pwd = DigestUtils.md5DigestAsHex(pwd.getBytes());
        System.out.println(user+"=================="+md5pwd);
        //查询用户数据
        user.setPassword(md5pwd);//用加密密码查
        User u = userMapper.findByNP(user);
        if(u==null) return null;
        String token = UUID.randomUUID().toString();
        return token;
    }
    //查分页,携带着参数来3个请求数据,要从第几条开始查,一共要查几条
    @Override
    public PageResult findUserList(PageResult pageResult) {
        //前端页面携带来3个数据,还差两个,需用自己封装
        Long total = userMapper.count(); //查询总记录数
        //第一页: limit 0,10  第二页: limit 10,10  第三页:limit 30,10  第n页:limit (n-1)*10,10
        int start = ( pageResult.getPageNum()-1 ) * pageResult.getPageSize() ; //limit后的第一个数值
        int num = pageResult.getPageSize(); //limit后的第一个数值
        String query = pageResult.getQuery(); //要查询的条件
        //根据分页条件,查询分页的数据,自己算位置
        List<User> list = userMapper.findUserList(start,num,query);
        return pageResult.setTotal(total).setRows(list);
    }

}

3.5.3 创建dao层

接口文件

package cn.tedu.dao;

import cn.tedu.pojo.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {
   	//添加用户
    @Insert("INSERT INTO USER VALUES(NULL,#{username},#{password},#{phone},#{email},#{status},#{created},#{updated})")
    void addUser(User user);

    List<User> findAll();//查找所有用户
    User findByNP(User user);//登录,根据账号密码查用户

    //MP,省略了去mapper.xml文件中,写SQL的过程
    @Select("select count(1) from user")
    Long count();//查询总记录数
    //根据分页条件,查询分页的数据,多个数据,进行封装,@Param,可以把参数自动封装成map结构,key就是括号里的值
    List<User> findUserList(@Param("start") int start,@Param("num")  int num,@Param("query")  String query);

    //删除用户
    @Delete("delete from user where id=#{id}")
    void deleteById(Integer id);
 
}

3.5.4 测试

3.6 后端开发 - 用户修改

想要做修改,必须先查出来做个回显再改,所以过程应该也是先把要改的数据查到,然后再改
查询数据的流程如下

3.6.1 创建Controller层 - 回显

package cn.tedu.controller;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.service.UserService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.security.sasl.SaslServer;
import java.util.List;

@RestController
@RequestMapping("user")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;

    //修改用户的 查询回显
    @GetMapping("{id}")
    public SysResult updateById(@PathVariable Integer id){
        User user = userService.findById(id);
        return SysResult.success(user);
    }

    //添加用户
    @PostMapping("addUser")
    public SysResult addUser(@RequestBody User user){
        userService.addUser(user);
        return SysResult.success();
    }

    //删除用户
    @DeleteMapping("/{id}")
    public SysResult deleteById(@PathVariable Integer id){
        userService.deleteById(id);
        return SysResult.success();
    }

    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    @PostMapping("login")
    public SysResult login(@RequestBody User user){
        String token = userService.login(user);
        if(null==token)
            return SysResult.failed();//登录失败
        return SysResult.success(token);//登录成功,返回token
    }

    //查分页,携带着参数来3个请求数据,query,pageNum,pageSize
    //返回数据中,包含着查到的分页数据
    @GetMapping("list")
    public SysResult findUserList(PageResult pageResult){
        pageResult = userService.findUserList(pageResult);//根据分页条件,查询分页数据
        return SysResult.success(pageResult);//把分页数据传递给前端
    }


}

3.6.2 创建Service层 - 回显

接口文件

package cn.tedu.service;

import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

public interface UserService {
    List<User> findAll();
    String login(User user);
    //查分页,携带着参数来请求数据,要从第几条开始查,一共要查几条
    PageResult findUserList(PageResult pageResult);
    //删除用户
    void deleteById(Integer id);
    //添加用户
    void addUser(User user);
    //修改用户的 查询回显
    User findById(Integer id);
}

实现类

package cn.tedu.service;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

    //修改用户的 查询回显
    @Override
    public User findById(Integer id) {
        return userMapper.findById(id);
    }

    //添加用户
    @Override
    public void addUser(User user) {
        //把明文密码  加密后 入库
        String password = user.getPassword();
        String md5password = DigestUtils.md5DigestAsHex(password.getBytes());
        //设置用户信息
        user.setPassword(md5password).setStatus(1)
                .setCreated(new Date()).setUpdated(user.getCreated());
        userMapper.addUser(user);
    }

    //删除用户
    @Override
    public void deleteById(Integer id) {
        userMapper.deleteById(id);
    }

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

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    //密码还要加密处理,要拿着用户的明文密码 加密后 和 库里加密密码 对比->加密算法:md5/sha/md5hash..
    @Override
    public String login(User user) {
        //把明文密码获取出来,进行加密
        String pwd = user.getPassword();
        System.out.println(user+"=================="+pwd);
        //把明文密码加密,利用MD5算法
        /*
            MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），
            一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），
            用于确保信息传输完整一致。（数字指纹）,MD5是不可逆的
         */
        String md5pwd = DigestUtils.md5DigestAsHex(pwd.getBytes());
        System.out.println(user+"=================="+md5pwd);
        //查询用户数据
        user.setPassword(md5pwd);//用加密密码查
        User u = userMapper.findByNP(user);
        if(u==null) return null;
        String token = UUID.randomUUID().toString();
        return token;
    }
    //查分页,携带着参数来3个请求数据,要从第几条开始查,一共要查几条
    @Override
    public PageResult findUserList(PageResult pageResult) {
        //前端页面携带来3个数据,还差两个,需用自己封装
        Long total = userMapper.count(); //查询总记录数
        //第一页: limit 0,10  第二页: limit 10,10  第三页:limit 30,10  第n页:limit (n-1)*10,10
        int start = ( pageResult.getPageNum()-1 ) * pageResult.getPageSize() ; //limit后的第一个数值
        int num = pageResult.getPageSize(); //limit后的第一个数值
        String query = pageResult.getQuery(); //要查询的条件
        //根据分页条件,查询分页的数据,自己算位置
        List<User> list = userMapper.findUserList(start,num,query);
        return pageResult.setTotal(total).setRows(list);
    }

}

3.6.3 创建dao层 - 回显

package cn.tedu.dao;

import cn.tedu.pojo.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {
    List<User> findAll();//查找所有用户
    User findByNP(User user);//登录,根据账号密码查用户

    //MP,省略了去mapper.xml文件中,写SQL的过程
    @Select("select count(1) from user")
    Long count();//查询总记录数
    //根据分页条件,查询分页的数据,多个数据,进行封装,@Param,可以把参数自动封装成map结构,key就是括号里的值
    List<User> findUserList(@Param("start") int start,@Param("num")  int num,@Param("query")  String query);

    //删除用户
    @Delete("delete from user where id=#{id}")
    void deleteById(Integer id);
    //添加用户
    @Insert("INSERT INTO USER VALUES(NULL,#{username},#{password},#{phone},#{email},#{status},#{created},#{updated})")
    void addUser(User user);
    //修改用户的 查询回显
    @Select("select * from user where id=#{id}")
    User findById(Integer id);
}

3.6.4 测试 - 回显

3.6.5 创建Controller层 - 修改

package cn.tedu.controller;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.service.UserService;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.security.sasl.SaslServer;
import java.util.List;

@RestController
@RequestMapping("user")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;

    /** 修改用户信息--手机号/邮箱 */
    @PutMapping("updateUser")
    public SysResult updateUser(@RequestBody User user){
        userService.updateUser(user);
        return SysResult.success();
    }

    //修改用户的 查询回显
    @GetMapping("{id}")
    public SysResult updateById(@PathVariable Integer id){
        User user = userService.findById(id);
        return SysResult.success(user);
    }

    //添加用户
    @PostMapping("addUser")
    public SysResult addUser(@RequestBody User user){
        userService.addUser(user);
        return SysResult.success();
    }

    //删除用户
    @DeleteMapping("/{id}")
    public SysResult deleteById(@PathVariable Integer id){
        userService.deleteById(id);
        return SysResult.success();
    }

    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    @PostMapping("login")
    public SysResult login(@RequestBody User user){
        String token = userService.login(user);
        if(null==token)
            return SysResult.failed();//登录失败
        return SysResult.success(token);//登录成功,返回token
    }

    //查分页,携带着参数来3个请求数据,query,pageNum,pageSize
    //返回数据中,包含着查到的分页数据
    @GetMapping("list")
    public SysResult findUserList(PageResult pageResult){
        pageResult = userService.findUserList(pageResult);//根据分页条件,查询分页数据
        return SysResult.success(pageResult);//把分页数据传递给前端
    }


}

3.6.6 创建Service层 - 修改

接口文件

package cn.tedu.service;

import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

public interface UserService {

  	//修改用户的 查询回显
    User findById(Integer id);
    /**修改用户信息--手机号/邮箱 */
    void updateUser(User user);
    
    List<User> findAll();
    String login(User user);
    //查分页,携带着参数来请求数据,要从第几条开始查,一共要查几条
    PageResult findUserList(PageResult pageResult);
    //删除用户
    void deleteById(Integer id);
    //添加用户
    void addUser(User user);
  
}

实现类

package cn.tedu.service;

import cn.tedu.dao.UserMapper;
import cn.tedu.pojo.PageResult;
import cn.tedu.pojo.User;
import cn.tedu.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

    /** 修改用户信息--手机号/邮箱  */
    @Override
    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    //修改用户的 查询回显
    @Override
    public User findById(Integer id) {
        return userMapper.findById(id);
    }

    //添加用户
    @Override
    public void addUser(User user) {
        //把明文密码  加密后 入库
        String password = user.getPassword();
        String md5password = DigestUtils.md5DigestAsHex(password.getBytes());
        //设置用户信息
        user.setPassword(md5password).setStatus(1)
                .setCreated(new Date()).setUpdated(user.getCreated());
        userMapper.addUser(user);
    }

    //删除用户
    @Override
    public void deleteById(Integer id) {
        userMapper.deleteById(id);
    }

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

    //登录,拿着账号.密码查库,查到了就返回token,没查到就返回null
    //密码还要加密处理,要拿着用户的明文密码 加密后 和 库里加密密码 对比->加密算法:md5/sha/md5hash..
    @Override
    public String login(User user) {
        //把明文密码获取出来,进行加密
        String pwd = user.getPassword();
        System.out.println(user+"=================="+pwd);
        //把明文密码加密,利用MD5算法
        /*
            MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），
            一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），
            用于确保信息传输完整一致。（数字指纹）,MD5是不可逆的
         */
        String md5pwd = DigestUtils.md5DigestAsHex(pwd.getBytes());
        System.out.println(user+"=================="+md5pwd);
        //查询用户数据
        user.setPassword(md5pwd);//用加密密码查
        User u = userMapper.findByNP(user);
        if(u==null) return null;
        String token = UUID.randomUUID().toString();
        return token;
    }
    //查分页,携带着参数来3个请求数据,要从第几条开始查,一共要查几条
    @Override
    public PageResult findUserList(PageResult pageResult) {
        //前端页面携带来3个数据,还差两个,需用自己封装
        Long total = userMapper.count(); //查询总记录数
        //第一页: limit 0,10  第二页: limit 10,10  第三页:limit 30,10  第n页:limit (n-1)*10,10
        int start = ( pageResult.getPageNum()-1 ) * pageResult.getPageSize() ; //limit后的第一个数值
        int num = pageResult.getPageSize(); //limit后的第一个数值
        String query = pageResult.getQuery(); //要查询的条件
        //根据分页条件,查询分页的数据,自己算位置
        List<User> list = userMapper.findUserList(start,num,query);
        return pageResult.setTotal(total).setRows(list);
    }

}

3.6.5 创建dao层 - 修改

package cn.tedu.dao;

import cn.tedu.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface UserMapper {
  
  	 //修改用户的 查询回显
    @Select("select * from user where id=#{id}")
    User findById(Integer id);
    /** 修改用户信息--手机号/邮箱/修改时间  */
    @Update("update user set phone=#{phone},email=#{email},updated=now() where id=#{id}")
    void updateUser(User user);

    List<User> findAll();//查找所有用户
    User findByNP(User user);//登录,根据账号密码查用户

    //MP,省略了去mapper.xml文件中,写SQL的过程
    @Select("select count(1) from user")
    Long count();//查询总记录数
    //根据分页条件,查询分页的数据,多个数据,进行封装,@Param,可以把参数自动封装成map结构,key就是括号里的值
    List<User> findUserList(@Param("start") int start,@Param("num")  int num,@Param("query")  String query);

    //删除用户
    @Delete("delete from user where id=#{id}")
    void deleteById(Integer id);
    //添加用户
    @Insert("INSERT INTO USER VALUES(NULL,#{username},#{password},#{phone},#{email},#{status},#{created},#{updated})")
    void addUser(User user);
 
}

3.6.5 测试 - 修改

3.7 后端开发 - 事务管理

为了防止数据出错,给Service层的增删改,都加上事务的控制

//添加用户
@Override
@Transactional
//b.加上这个注解,解决下面的问题呀....就是出错了能回滚,有了事务管理,要给增删改都加上
public void addUser(User user) {
    //把明文密码  加密后 入库
    String password = user.getPassword();
    String md5password = DigestUtils.md5DigestAsHex(password.getBytes());
    //设置用户信息
    user.setPassword(md5password).setStatus(1)
            .setCreated(new Date()).setUpdated(user.getCreated());
    userMapper.addUser(user);
    int a = 1/0; //a.上面都没问题,甚至数据都入库了,然后报错了,此时数据已经入库就应该回滚才行!!
}

3.8 后端开发 - 异常处理

为了防止代码中出现异常,我们通常的做法是在代码中加入异常捕获的代码try…catch(…){…},
但是想要完成一个项目,有太多的地方需用进行异常的处理.
这样我们就太累了,如果采用AOP的思想,就可以把异常处理方案形成一个切面,实现程序间的松耦合高内聚等.

原始方式:处理异常

//添加用户
@PostMapping("addUser")
public SysResult addUser(@RequestBody User user){
    try {
        userService.addUser(user);
        return SysResult.success(); 
    } catch (Exception e) { 
//现在的问题是：万一出现异常，页面啥提示也没有，只是后台有报错。现在要给页面反馈失败信息,进行异常捕获的处理,就需要处处进行catch...
        e.printStackTrace();
        return SysResult.failed();
    }
}

AOP思想处理异常

package cn.tedu.aop;

import cn.tedu.vo.SysResult;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

//用来完成全局异常处理,所有运行时期的异常,统统交给这里处理,把controller层的所有异常一并处理
//原理就像AOP一样,把增删改查业务和异常处理分开,实现松耦合,增强controller的功能
//但是这里,又不需要我们进行原始的aop开发,@aspect @around...
@RestControllerAdvice//省略掉controller中的try-catch,封装异常信息,返回给前端
public class AllException {
    @ExceptionHandler(RuntimeException.class)//用来捕获指定的异常
    public SysResult catchExcption(Exception e){
        e.printStackTrace();
        return SysResult.failed();
    }
}

3.9 测试

至此,登录模块已经完成,用户管理模块的CRUD已经完成