使用springboot实现简单的CRUD

搭建项目

项目的结构还是要使用 mvc 模式进行搭建，那么我们需要 DAO 层、service 层以及 controller 层，最后需要一个贯穿全部的实体类。

这几层结构他们的关系就像这张图的关系一样：
三层架构
DAO层为service层提供CRUD方法，service层对DAO层提供的方法进行更进一步的封装，封装成具体事务，controller层则是对客户端的访问进行处理。实体类entity贯穿三层，进行数据的传输。那么到最后，我们的目录结构就像这样的：

|-----controller
|-----controller类
|-----service
|-----service接口
|-----service类
|-----Dao
|-----DAO接口
|-----entity
|-----entity类

搭建springboot项目

具体使用idea搭建springboot项目可以参考这篇博客：一望红尘简单springboot项目实现增删改查加分页

这里我们将目光放在更加重要的事情上，比如：文件的配置和容易掉进去的坑。
项目目录
在这里我圈出来了三个文件，其中，application.properties和pom.xml是两个配置文件，而studentsApplication则是代表着整个应用，当服务启动的时候就是启动的这个文件。

我们先看看配置文件中的配置：

application.properties：根据需要来配置应用的相关内容

#数据源配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/studentscon?useSSL=false&useUnicode=true&characterEncoding=utf-8&autoReconnect=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.initialSize=20
spring.datasource.minIdle=50
spring.datasource.maxActive=500


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

##配置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

pom.xml：主要是管理Maven中的jar包

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- druid数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--添加阿里巴巴的json解析类库fastjson-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!--添加糊涂工具类-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.5.6</version>
        </dependency>

        <!--javamail依赖用来发送电子邮件-->
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4.7</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper-spring-boot-starter -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.10</version>
        </dependency>

    </dependencies>

最后，最关键的来啦！

studentsApplication这个文件，一定要和DAO、service、controller、entity 同级！！同级！！同级！！

如果他们没有处于同一级包下，当你启动服务器的时候会正常的启动，但是你的服务不能部署到服务器上，也就是说，当你访问页面的时候它会一直报 404，永远找不到你的页面，而且不会有错，因为他就是一个干净的服务器，里面怎么可能有错。

实现项目中的各个层

首先，我们来做贯穿整个项目的entity

package com.student.students.entity;


import javax.persistence.*;

@Entity
@Table(name = "students")
public class students {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String Password;
    private String sex;
    private int age;

    @Override
    public String toString() {
        return "students{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", Password='" + Password + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return Password;
    }

    public void setPassword(String password) {
        Password = password;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

entity类需要我们使用@Entity标签来说明它是一个实体类，之后使用@Table(name = "students")标签将实体类与数据库中的表进行映射。

DAO：

studentsDao :

package com.student.students.dao;

import com.student.students.entity.students;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface studentsDao extends JpaRepository<students, Integer> {
    students deleteById(int stuId);
    students findById(int stuId);
    students save(students stu);

    @Query(name = "findstudentsByName",nativeQuery = true,
            value = "select id,name,password,sex,age from students where NAME =:name")
    List<students> findstudentsByName(@Param("name") String name);
}

studentsDao 为操作实体类提供接口，之后对实体类的CURD操作全部使用接口来实现。接口类继承了JpaRepository类，这个类可以为接口自动实现简单的CURD操作。

service

studentService ：定义业务层的具体操作的接口

package com.student.students.service;

import com.student.students.entity.students;
import org.springframework.data.domain.Page;

import java.util.List;

public interface studentService {
    students addStudent(students stu);
    students deleteStudentById(int stuId);
    students updateStudent(students stu);
    students findStudentById(int stuId);
    List<students> findStudentByName(String name);
    List<students> findAll();
    Page<students> findAllStudent(int pageIndex,int pageSize);
}

实现studentService 接口：

studentsServicelmpl

package com.student.students.service;

import com.student.students.dao.studentsDao;
import com.student.students.entity.students;
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;

@Service
public class studentsServicelmpl implements studentService {

    @Autowired
    private studentsDao studentdao ;

    /**
     * 增加记录
     * @author xm99
     * @param stu
     * @return students
     */
    @Override
    public students addStudent(students stu) {
        return studentdao.save(stu);
    }


    /**
     * 通过 ID 删除记录
     * @author xm99
     * @param stuId
     * @return
     */
    @Override
    public students deleteStudentById(int stuId) {
        return studentdao.deleteById(stuId);
    }


    /**
     * 更新记录
     * @author xm99
     * @param stu
     * @return
     */
    @Override
    public students updateStudent(students stu) {
        return studentdao.save(stu);
    }


    /**
     * 通过 ID 查询记录
     * @author xm99
     * @param stuId
     * @return
     */
    @Override
    public students findStudentById(int stuId) {
        return studentdao.findById(stuId);
    }


    /**
     * 通过名字查询记录
     * @author xm99
     * @param name
     * @return
     */
    @Override
    public List<students> findStudentByName(String name) {
        return studentdao.findstudentsByName(name);
    }


    /**
     * 查询所有记录
     * @author xm99
     * @return
     */
    @Override
    public List<students> findAll() {
        return studentdao.findAll();
    }


    /**
     * 分页的方式查询所有记录
     * @author xm99
     * @param pageIndex
     * @param pageSize
     * @return
     */
    @Override
    public Page<students> findAllStudent(int pageIndex, int pageSize) {
        Pageable pages = PageRequest.of(pageIndex,pageSize);
        return studentdao.findAll(pages);
    }
}

使用@Service标签将实现类与接口联系起来，之后使用DAO提供的操作接口来实现CURD操作，其中的DAO对象使用自动注入的方式。

controller

studentsControler实现对客户端访问的控制，其中的操作使用service为其提供的接口进行，也使用自动注入的方式。

package com.student.students.controler;

import com.student.students.entity.students;
import com.student.students.service.studentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/student")
public class studentsControler {

    @Autowired
    private studentService studentservice;

    /**
     * 往数据库中增加一条新的纪录
     * @author xm99
     * @param stu
     * @return students
     */
    @PostMapping("/add")
    public students addStudent(students stu){
        return studentservice.addStudent(stu);
    }


    /**
     * 从数据库中删除一条记录
     * @author xm99
     * @param stuId
     * @return students
     */
    @RequestMapping("/del")
    public students deleteStudentById(int stuId){
        return studentservice.deleteStudentById(stuId);
    }


    /**
     * 更新数据库中的记录
     * @author xm99
     * @param stu
     * @return students
     */
    @RequestMapping("/update")
    public students updateStudnet(students stu){
        return studentservice.addStudent(stu);
    }


    /**
     * 通过 id 来查找数据库中的记录
     * @author xm99
     * @param stuId
     * @param hsr
     * @return students
     */
    @RequestMapping("/find")
    public students findStudentById(int stuId,HttpServletResponse hsr){
        hsr.addHeader("Access-Control-Allow-Origin","*");
        return studentservice.findStudentById(stuId);
    }


    /**
     * 从数据库中查询所有的数据，并整理成一个 List 进行返回
     * @author xm99
     * @return List<students>
     */
    @RequestMapping("/findAll")
    public List<students> findAll(){
        return studentservice.findAll();
    }


    /**
     * 查询所有的记录，并且以分页的方式返回
     * @author xm99
     * @param page
     * @param hsr
     * @return Page<students>
     */
    @RequestMapping("/findAllStu")
    public Page<students> findStudentsByPage(Integer page, HttpServletResponse hsr){

        hsr.addHeader("Access-Control-Allow-Origin","*");
        if(page == null || page <= 0 ){
            page = 0 ;
        }else{
            page = page-1;
        }
        return studentservice.findAllStudent(page,5);
    }


    /**
     * student的登录方法，通过传入的用户名找到记录并且判断密码是否正确
     * @author xm99
     * @param name
     * @param password
     * @return students
     */
    @RequestMapping("/login")
    public students login(String name,String password){
        List<students> allStudents = studentservice.findStudentByName(name);
        for (students s:allStudents ) {
            if (s.getName().equals(name)){
                if(s.getPassword().equals(password)){
                    return s;
                }else{
                    return null;
                }
            }else {
                return null;
            }
        }
        return null;
    }
}

开发环境

win10企业版 + mysql 5.7 + idea 2018.3 + spring boot 2.1