java Spring Boot用途 spring boot用来做什么

上面我们介绍了一些基本的springboot的基础知识，教了如何创建springboot的项目，这里我们将把项目进行完善，这里我会把每个代码进行仔细分析，认真的分析，尽量做到每个地方都能看得懂，大家可以和我交流哦.

基础介绍

1、什么是SpringBoot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

2、特点

（1）可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；

（2）内嵌Tomcat或Jetty等Servlet容器；

（3）提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置；

（4）尽可能自动配置Spring容器；

（5）提供准备好的特性，如指标、健康检查和外部化配置；

（6）绝对没有代码生成，不需要XML配置

3、SpringBoot项目结构

如果从一个用户访问一个网站的情况来看，对应着项目代码结构来分析，可以贯穿整个代码分层

对应代码目录的流转逻辑就是：

4、SpringBoot分层

1.Dao层

Dao层主要做数据持久层的工作， 负责与数据库进行联络的一些任务都封装在此。 Dao层的设计：首先 是设计dao层的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可以再模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，dao层的数据源配置，以及有关数据库连接参数都在Spring配置文件中进行配置。

2.Service层

Service层主要负责业务模块的应用逻辑应用设计。 Service层的设计：同样是首先设计接口，再设计其实现类，接着再Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用service接口来进行业务处理。service层的业务实， 具体要调用已经定义的dao层接口 ，封装service层业务逻辑有利于通用的业务逻辑的独立性和重复利用性。程序显得非常简洁。

3.Controller层

Controller层，负责具体的业务模块流程的控制，在此层要调用service层的接口来控制业务流程，控制的配置也同样是在Spring的配置文件里进行，针对具体的业务流程，会有不同的控制器。我们具体的设计过程可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块。这样不仅使程序结构变得清晰，也大大减少了代码量。

4.view层

view层与控制层结合比较紧密，需要二者结合起来协同开发。view层主要负责前台jsp页面的显示。

5.Entity层

Entity层是实体层，也就是所谓的model，也称为pojo层，是数据库在项目中的类，该文件包含实体类的属性和对应属性的set、get方法；

6.它们之间的关系

Service层是建立在Dao层之上的，建立了Dao层后才可以建立Service层，而Service层又是在Controller层之下的，因而 Service层应该既调用Dao层的接口，又要提供接口给Controller层的类来进行调用，它刚好处于一个中间层的位置。 每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。

7.总结：

Controller层叫做控制层，负责请求转发，接受页面过来的参数，传给Service处理，接到返回值，再传给页面。即用于接口暴露。

Service层叫服务层，被称为服务，粗略的理解就是对一个或多个DAO进行的再次封装，封装成一个服务。即sevice层用于逻辑处理，sevice层专注业务逻辑，对于其中需要的数据库操作，都通过Dao去实现。

Dao层叫数据访问层,全称为data access object，属于一种比较底层，比较基础的操作，具体到对于某个表、某个实体的增删改查，不涉及业务逻辑，只是达到按某个条件获得指定数据的要求。

View层叫做表示层，此层与控制层结合比较紧密，需要二者结合起来协同工发。View层主要负责前台jsp页面的表示。

表示层（View\Web） 调用 控制层（Controller），控制层（Controller）调用业务层（Service），业务层（Service）调用数据访问层（Dao）Dao面向表，Service面向业务。后端开发时先数据库设计出所有表，然后对每一张表设计出Dao层，然后根据具体的业务逻辑进一步封装Dao层成一个Service层，对外提供成一个服务。

代码完善

这里我们将继续深入的学习springboot，将代码进行完善和讲解。

连接mysql

创造环境（可选）

前面已经建立好了springboot的project项目，这里开始配置mysql，由于安装了springboot
的插件，或者使用了专业版的idea，所以这里不需要写maven下载包文件，如果有问题的可以，可
以创建maven项目，这里我也把需要的maven放在这里。

如果是导包或者专业版的idea这一步可以省略不写

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>


    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>


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


 <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>


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

开始配置

这里来配置连接mysql

如果是通过我的方法创建springboot的项目，那么这里会自动的生成application.properties文件，如果没有这个文件，可以在对应的文件夹下面创建一个file文件，文件名一致即可

这里就是对应的配置文件

不要直接的就复制粘贴进去，下面我加上引号的就是需要更改的内容。

#对mysql连接进行配置
# 应用名称
spring.application.name=spingbootdemo
# 应用服务 WEB 访问端口
server.port=8080
# 数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据库连接地址
spring.datasource.url=jdbc:mysql://localhost:3306/“kayleigh”?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8
# 数据库用户名&密码：
spring.datasource.username=”root“
spring.datasource.password=”12345678“

项目入口

我们在main问价下的java文件中创建一个com.kayleigh文件夹，（这里文件夹名字可以任意更换），然后创建一个class文件，名字为SpringBootApplicationDemo的class文件，这里面主要是项目的入口

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//这个注解表示这是作为spingboot的应用
@SpringBootApplication
public class SpringBootApplicationDemo {
    public static void main(String[] args) {
        //这是启动Spring的应用
        SpringApplication.run(SpringBootApplicationDemo.class,args);
    }
}

创建完成以后就可以直接运行试试代码有没有问题，没有问题的话下面就接着做

创建数据库和表

由于前面创建一个Kayleigh的database，这里我们在这个下面创建一个Student的表，由于我们后面需要用name进行搜索，所以，这里还需要创建一个索引，我直接把代码付下：

use kayleigh;
CREATE TABLE Student(
    id INT PRIMARY KEY auto_increment,
    name VARCHAR(255) NOT NULL,
    age INT NOT NULL DEFAULT 0,
    gender VARCHAR(255),
    clazz VARCHAR(255),
    sum_score INT
);


--对那么做索引，需要按name做查询
CREATE INDEX stu_name_index ON Student(name);

OK，准备工作做完了，这里我们继续开始编写代码吧

前端显示

**创建几个如下的文件夹，这里创建问价夹是为了方便后面的维护和管理，为了统一代码的规范性。

**

Entity层

这里我们在Entity文件夹下面创建一个Student类，其实这里的代码很简单，就是将创建表的时
候的字段设置成private，由于private不能直接获取所以添加其get/set方法。

package com.kayleigh.Entity;


import javax.persistence.*;

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

    //定义一张表的时候需要指定主键，一般主键是通过下面的方式进行指定
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//描述ID自增
    private Integer id;
    private String name;
    private Integer age;
    private String gender;
    private String clazz;
    //属性名一般同数据库中的表的列名保持一致，不至于时候，可以用@Column注解
    private Integer sum_score;


    //由于这里的变量值都是private的不能直接赋值也不能直接获取，所以我们需要添加get/set方法


    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }

    public Integer getSum_score() {
        return sum_score;
    }

    public void setSum_score(Integer sum_score) {
        this.sum_score = sum_score;
    }
}

Dao层

叫数据访问层,全称为data access object，属于一种比较底层，比较基础的操作，具体到对于
某个表、某个实体的增删改查，不涉及业务逻辑，只是达到按某个条件获得指定数据的要求。
这一层主要是写一些接口，继承JpaRepository，由于JpaRepository里就有很多的方法，所以这个接口暂时可以不写方法，后续有需求在写

import com.kayleigh.Entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/*
数据的持久化层，这里定义一个接口。这里命名Repository的原因就是需要继承一个JpaRepository
 */
//这里的Student就是刚刚定义的Entity，后面添加的就是主键的字段类型
//这个就写完了，这是一个接口，父类有很多的方法
@Repository
public interface StudentRepository extends JpaRepository<Student,Integer> {

}

common

这里主要是放请求成功和请求失败返回的数据

package com.kayleigh.common;

public class Result<T> {
    private String code;
    private String msg;
    private T data;

    public Result() {

    }

    public Result(T data) {
        this.data = data;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    //请求成功不返回数据
    public static <T> Result<T> success(){
        Result rs = new Result<>();
        rs.setCode("200");
        rs.setMsg("ok");
        return rs;
    }
    //请求成功返回数据
    public static <T> Result<T> success(T data){
        Result<T> rs = new Result<T>(data);
        rs.setCode("200");
        rs.setMsg("ok");
        return rs;
    }

    //请求失败
    public static <T> Result<T> error(String code,String msg){
        Result rs = new Result<>();
        rs.setCode("code");
        rs.setMsg("msg");
        return rs;
    }
}

Controller层

叫做控制层，负责请求转发，接受页面过来的参数，传给Service处理，接到返回值，再传给页面。即用于接口暴露。

package com.kayleigh.Controller;

import com.kayleigh.Entity.Student;
import com.kayleigh.Service.StudentService;
import com.kayleigh.common.Result;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@RestController  //将数据以json格式返回
@RequestMapping("/stu")
public class StudentController {

    @Resource
    private StudentService studentService;

    @RequestMapping("all")
    public Result<List<Student>> findAll(){

        List<Student> list = studentService.findAll();
        return Result.success(list);
    }

    @RequestMapping("all2")
    public Result<List<Student>> findAll2(){

        List<Student> list = studentService.findAll();
        return Result.success(list);
    }
}

Service层

服务层，被称为服务，粗略的理解就是对一个或多个DAO进行的再次封装，封装成一个服务。即sevice层用于逻辑处理，sevice层专注业务逻辑，对于其中需要的数据库操作，都通过Dao去实现

package com.kayleigh.Service;

import com.kayleigh.Dao.StudentRepository;
import com.kayleigh.Entity.Student;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/*
具体的业务逻辑
 */
//加上注解
@Service
public class StudentService {
    @Resource
    private StudentRepository studentrepository;


    public List<Student> findAll(){
        return studentrepository.findAll();

    }
}

测试运行

这几步都弄完了，可以测试连接，测试之前记得开启mysql，如果出现下面的样子就说明已经成功了。

• 访问形式：http://localhost:8080/stu/all
• 访问样式：

美化并且在前端显示数据