一个简单的基于springboot增删改查的用户管理系统

创建项目

idea搭建环境，创建一个Spring initializr的项目。

引入依赖

pom.xml文件依赖

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

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- druid数据库连接池-->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.10</version>
		</dependency>

application.properties文件配置

#数据源配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#在下面3306配置自己的数据库（自己配置）
spring.datasource.url=jdbc:mysql://192.168.113.49:3306/book-test
#数据库用户（自己配置）
spring.datasource.username=dev1
#数据库密码（自己配置）
spring.datasource.password=123456
spring.datasource.initialSize=20
spring.datasource.minIdle=50
spring.datasource.maxActive=500

#上下文配置
server.port=8888
#server.servlet.context-path=/stu

#配置jpa
#帮我们自动生成表结构
spring.jpa.properties.hibernate.hbm2ddl.auto=update
#spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql= true
#spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true


spring.jpa.properties.hibernate.show_sql=false

后台源码及系统结构

UserController

```java
package com.stu.demostu.controller;

import com.stu.demostu.entity.User;
import com.stu.demostu.service.UserService;
import com.stu.demostu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/u")
public class UserController {

    @Autowired   //@Autowired 是一个注释，它可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。
    private UserService userService;

    @RequestMapping(value = "queryAll")
    public List<User> findAll(){
        List<User> s = userService.findAll();
        return s;
    }


    /* 添加学生
     * @param User 要添加的学生对象
     * @return*/
    @PostMapping("/add")   //@postMapping = @requestMapping(method = RequestMethod.POST)
    public User save(User User){

        return userService.save(User);
    }

    /*
     * 修改学生
     * @param User
     * @return*/
    @PostMapping("/update")
    public User update(User User){
        return userService.save(User);
    }

    /*
     * 删除学生
     * @param id 要删除的学生id
     * @return*/
    @GetMapping("/del/{id}")
    public String del(@PathVariable int id){    //@PathVariable 将请求URL中的模板变量映射到接口方法的参数上
        userService.delete(id);
        return "yes";
    }


    /*
     * 通过姓名找到信息
     * @param name
     * @return*/
    @GetMapping("/findByName/{name}")
    public List<User> findByName(@PathVariable String name){
        return userService.findStuByName(name);
    }

//      /*
//      * 利用分页查找全部信息
//      * @param page
//     * @param response
//     * @return

    @GetMapping("/query")
    public Page<User> findByPage(Integer page, HttpServletResponse response){

        //异步请求使用
        response.setHeader("Access-Control-Allow-Origin","*");
        if(page==null || page<=0){
            page = 0;
        }else{
            page -= 1;
        }
        return userService.findAll(page,5);
    }

    @RequestMapping("/findaaa")
    public List<User> findaaa(){
        return userService.findaaa();
    }

    @RequestMapping("/findbbb")
    public List<Map> findbbb(){
        return userService.findbbb();
    }
    @RequestMapping("/findc")
    public List<Map> findc(int id){
        return userService.findc(id);
    }
}

UserService

package com.stu.demostu.service;

import com.stu.demostu.entity.User;
import org.springframework.data.domain.Page;

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

public interface UserService {
    
    
    List<User> findAll(); //UserService定义一个findAll()方法

    User save(User user);
    User update(User User);
    void delete(Integer sid);
    User findStuById(Integer id);
    List<User> findStuByName(String name);

    List<User> findaaa();
    List<Map> findbbb();

    //     *//**//**
//     * 分页查询所有数据
//     * @param page 当前页
//     * @param pageSize 每页记录数
//     * @return
//     *//**//*
    Page<User> findAll(int page, int pageSize);

    List<Map> findc(int id);
}

UserServiceImpl

package com.stu.demostu.service;

import com.stu.demostu.dao.UserDao;
import com.stu.demostu.dao.UserDao;
import com.stu.demostu.entity.User;
import com.stu.demostu.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

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

@Service
public class UserServiceImpl implements UserService {
    
    


    @Autowired
    private UserDao userDao;

    public List<User> findAll(){
    
    
        System.out.println("service---------------------");
        List<User> all = userDao.findAll();
        return all;
    }



    @Override
    public User save(User User) {
    
    
        return userDao.save(User);
    }

    @Override
    public User update(User User) {
    
    
        return userDao.save(User);//调用save如果传入的id已经存在那么会把之前的信息进行覆盖。
    }

    @Override
    public void delete(Integer sid) {
    
    
        userDao.deleteById(sid);
    }

    @Override
    public User findStuById(Integer sid) {
    
    
        return userDao.findUserById(sid);
    }

    @Override
    public List<User> findStuByName(String name) {
    
    
        return userDao.findStuByName(name);
    }

    @Override
    public List<User> findaaa() {
    
    
        return userDao.findaaa();
    }

    @Override
    public List<Map> findbbb() {
    
    
        return userDao.findbbb();
    }
    @Override
    public List<Map> findc(int id) {
    
    
        return userDao.findc(id);
    }

    @Override
    public Page<User> findAll(int page, int pageSize) {
    
    
        Pageable pageable = PageRequest.of(page,pageSize);
        return userDao.findAll(pageable);
    }
}

User

package com.stu.demostu.entity;

import lombok.Data;
import javax.persistence.*;

@Entity //表明实体类，有了这个注解，就不用再自己去写SQL创建表了，SpringBoot会自动扫描带有这个注解的类，然后通过对象关系映射，自动帮我们创建表。
@Table(name="t_user") //@Table注解用来说明该实体类对应的表和数据库，其中name =“xxx"，用来表示数据表的名字
@Data     //@Data注解是lambda的注解，用来节省代码开发的，不是JPA中的注解
public class User {
    
    

    @Id    //@Id注解表名是表的自增主键，一个实体里只能有一个
    @GeneratedValue(strategy = GenerationType.IDENTITY)  //设置为自动递增  @GeneratedValue(strategy = GenerationType.IDENTITY)指定自增主键
    // 的自增策略，GenerationType有四个值：TABLE、SEQUENCE、IDENTITY、AUTO，我们常用的是后两种，一般mysql数据库使用SEQUENCE，AUTO的话是让JPA自己
    // 选择合适的策略，默认的策略就是AUTO

//    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
//    @JoinColumn(name = "user_id")

    @Column(name = "id")  //@Column注解，该注解定义属性对应数据库的列名，以及是否为空等的限制
    private int id;

    @Column(name = "name")
    private String name;

    @Column(name = "sex")
    private String sex;

    @Column(name = "age")
    private int age;

//    @ManyToOne(fetch = FetchType.EAGER)
//    @JoinColumn(name = "stu_name")





    @Column(name = "stu_name")
    private String stu_name;


    public User() {
    
    
    }
}

UserDao

package com.stu.demostu.dao;

import com.stu.demostu.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

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

@Repository
public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> {
    
    

        User findUserById(Integer id);

        @Query(name = "findStuByName", nativeQuery = true, value = "select * from t_user where name=:name")
        List<User> findStuByName(@Param("name") String name);

        String s = "select t1.id user_id,t1.name user_name,t1.sex user_sex,t1.age user_age,t3.id stu_id,t3.name stu_name,t3.sex stu_sex,t3.age stu_age " +
                "from t_user t1 join t_su t2 on t1.id = t2.user_id " +
                "join t_stu t3 on t2.stu_id = t3.id";

       @Query(name = "findaaa", nativeQuery = true, value = "select * from t_user u join t_stu s on u.stu_name=s.name")
       List<User> findaaa();

    @Query(name = "findbbb", nativeQuery = true, value = s)
    List<Map> findbbb();

    @Query(name = "findc", nativeQuery = true, value = "select t1.id user_id,t1.name user_name,t1.sex user_sex,t1.age user_age,t3.id stu_id,t3.name stu_name,t3.sex stu_sex,t3.age stu_age " +
            "from t_user t1 join t_su t2 on t1.id = t2.user_id " +
            "join t_stu t3 on t2.stu_id = t3.id where t1.id = :id" )
    List<Map> findc(@Param("id") int id);

//    t_user u join t_stu s where u.stu_name=s.name

}

数据库

这里没有写前端页面，在postman中进行测试