Cpp五条

这个屌丝很懒，什么也没留下！

热门标签

大数据技术SpringBoot框架---实现前后端分离(MVC)对数据进行可视化_springboot框架是大数据框架吗

作者：Cpp五条 | 2024-02-26 02:36:30

踩

springboot框架是大数据框架吗

文章目录

Spring Boot

Spring Boot

1、什么是Spring Boot

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

2、Spring Boot 的特点

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

Spring Boot 可以以jar包的形式独立运行，Spring Boot 项目只需通过命令"java-jar xx.jar" 即可运行。

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

Spring Boot 使用嵌入式的 Servlet 容器（例如 Tomcat、Jetty 或者 Undertow 等），应用无需打成WAR包。

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

Spring Boot 提供了一系列的 “start” 项目对象模型（POMS）来简化 Maven 配置。

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

Spring Boot 提供了大量的默认自动配置，来简化项目的发展，开发人员也通过配置文件修改默认配置。

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

Spring Boot 可以对正在运行的项目库提供监控。

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

Spring Boot 不需要任何xml配置即可实现Spring 的所有配置。

3、SpringBoot项目结构

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

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

4、Spring Boot 分层

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层数据库在项目中的类，该文件包含实体类的属性和对应属性的setXxx()、getXxx() 方法。

6、它们之间的关系

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

7、总结

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

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

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

View层叫做表示层，此层与控制层结合起来协同工作。View层主要负责前台jsp页面的表示。

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

配置开发环境

在使用Spring Boot进行开发之前，第一件事就是配置好开发环境。这里我们以Windows操作系统为例，如果您使用的是其它操作系统，请对照其相关设置进行操作。
工欲善其事，必先利其器IDE (集成开发环境) 的选择相当重要，目前市面上有很多优秀的IDE开发工具，例如IntelliJ IDEA、Spring Tools、Visual Studio Code 和 Eclipse 等等，那么我们该如何选择呢？
这里我们极力推荐大家使用 IntelliJ IDEA，因为相比于与其他 IDE，IntelliJ IDEA 对 Spring Boot 提供了更好的支持。
Spring Boot 版本及其环境配置要求如下表。

在 Java 官方网站下载 JDK 8.0 及以上版本，JDK 的安装以及环境配置请参考 Java JDK下载与安装教程和 Java JDK环境变量配置。
Maven 3.x 的下载安装及配置过程，请参考 Maven 安装与配置。
浏览器访问 IntelliJ IDEA 官方下载页面，下载并安装 IntelliJ IDEA。

创建 Spring Boot 项目

开发环境配置完成后，接下来，我们就可以通过 Intellij IDEA 创建一个 Spring Boot 项目了。

Intellij IDEA 一般可以通过两种方式创建 Spring Boot 项目：

使用 Maven 创建
使用 Spring Initializr 创建

使用 Maven 创建

1.使用 IntelliJ IDEA 创建一个名称为 SpringBootDemoTest的 Maven 项目，创建过程请参考 IDEA 新建 Maven 项目。
**2. 在该 Maven 项目的 pom.xml 中添加以下配置，导入 Spring Boot 相关的依赖。 **

<project>

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>
  
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--添加Springmvc依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- springBoot JPA的起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

    </dependencies>
    
   <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.1.4.RELEASE</version>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3、新建自己的包，新建一个名为SpringBootApplication的主启动程序

此时，几乎所有的准备工作都已经准备就绪，我们可以在没有编写任何代码的情况下，直接将在Spring Boot 项目运行起来。

启动 Spring Boot

默认情况下，Spring Boot 项目会创建一个名为[***Application]的主程序启动类，该类中使用了一个组合注解@SpringBootApplication，用来开启Spring Boot 的自动配置，另外该启动类中包含一个main()方法,用来启动该项目。

SpringBoot的主程序启动类代码如下：

package com.liangzai;

import org.springframework.boot.SpringApplication;

/**
 * @author liangzai
 * @SpringBootApplication 是Spring Boot 项目的核心注解，目的是开启自动配置
 */
@org.springframework.boot.autoconfigure.SpringBootApplication
public class SpringBootApplication {
    public static void main(String[] args) {
        //启动Spring应用
        SpringApplication.run(SpringBootApplication.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

直接运行启动类SpringBootApplication中的main()方法，便可以启动该项目，运行结果如下。

Spring Boot 项目SpringBootApplication 运行日志
注意：SpringBoot内部集成了 Tomcat，不需要人为手动配置TomCat，开发者只需要关注具体的业务逻辑即可。

加载数据库配置文件

虽然我们的SpringBoot的日志是启动了，但是这里会出现一个错误，需要我们手动在resource资源目录中加载一个名为application.properties的数据库配置文件。

application.properties

# 对MySQL连接进行配置
spring.datasource.url=jdbc:mysql://master:3306/springbootdemo?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
1
2
3
4
5

当我们将MySQL数据库配置文件加载完毕之后我们再来运行一下

端口占用解决办法

Verify the connector’s configuration, identify and stop any process that’s listening on port 8080, or configure this application to listen on another port.
翻译：验证连接器的配置，识别并停止正在侦听端口20000的任何进程，或将该应用程序配置为侦听另一个端口。

原因

由于之前使用改端口号的程序不正常关闭，导致端口并未释放，需要手动释放

解决方法

方法一：

直接重启，一般可以解决该问题，如果重启比较麻烦，可以使用下面的方法

方法二：

1、进入cmd，执行命令：[netstat -ano]

2、在窗口中继续输入：[netstat -aon|findstr “端口”]，这里的提示的端口为8080，那么就输入命令为【netstat -aon|findstr “8080”】，回车之后就可以看见列表中的PID。根据PID在电脑的任务管理器中查看对应的占用程序，然后将其关闭即可。

3、我们可以看到占用8080这个程序进程的ID：26304，继续输入命令【tasklist|findstr “26304”】，26304就是进程ID，现在知道是哪个进程占用的我们就可以采取相应措施进行解决了。

然后我们在浏览器地址栏访问"localhost:8080"

显示出这个页面就证明我们Tomcat访问localhost:8080是通的

新建Entity、Dao、Service、Controller层

在Entity实体层中新建Student类

这里我们再加入一个maven依赖lombok

点击File—Setting设置界面，开启AnnocationProcessors:
开启该项是为了让Lombok注解在编译阶段起到作用

@Getter/@Setter: 作用类上，生成所有成员变量的getter/setter方法；作用于成员变量上，生成该成员变量的getter/setter方法。可以设定访问权限及是否懒加载等。
@NoArgsConstructor：生成无参构造器
@AllArgsConstructor：生成全参构造器

package com.liangzai.Entity;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;

/**
 * @author liangzai
 * @version 1.0
 * Entity实体层，也就是所谓的model，也称pojo层数据库在项目中的类，
 * 该文件包含实体类的属性和对应属性的setXxx()、getXxx()方法
 * @Getter/@Setter: 作用类上，生成所有成员变量的getter/setter方法；
 * 作用于成员变量上，生成该成员变量的getter/setter方法。
 * 可以设定访问权限及是否懒加载等。
 * @Getter 注解 定义getXxx()方法
 * @Setter 注解 定义setXxx()方法
 * @NoArgsConstructor 注解 定义无参的构造方法
 * @AllArgsConstructor 注解 定义有参的构造方法
 * @Entity 注解 表明是一个实体类
 * @Table 注解 对应的数据表名
 * @Id 注解 主键
 * @GeneratedValue 注解 主键生成策略 这里用到的是描述id自增
 * @Column 注解 映射表对应的字段名
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "student")
public class Student {
    @Id
    //描述id自增
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private Integer age;
    private String gender;
    private String clazz;
    //属性名一般同数据库中表的列名保持一致，不一致时可以使用@Column注解
    @Column(name = "sum_score")
    private Integer sum_score;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

至此我们Entity实体层就编写完毕了

在Dao数据持久层新建StudentRepository接口

使用Dao数据持久层进行封装

package com.liangzai.Dao;

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

/**
 * @author liangzai
 * @version 1.0
 * Dao层主要做数据持久层的工作，负责数据库进行联络的一些任务都封装在此。
 * Dao层的设计：首先是设计Dao层的接口，然后再Spring的配置文件中定义此接口的实现类，
 * 然后就可以再将模块中调用此接口来进行数据业务的处理，而不用关心接口的具体实现类是哪个类，
 * 显得结构非常清晰，dao层的数据元配置，以及有关数据库连接参数都在Spring配置文件中进行配置。
 * @Repository 注解 修饰哪个类，则表名这个类具有对对象进行CRUD（增删改查）的功能。
 */
@Repository
//继承JpaRepository，指定一个泛型Student，和主键的类型Integer
public interface StudentRepository extends JpaRepository<Student, Integer> {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在Service业务服务层上新建StudentService类

该类可以根据需求实现对student信息进行CRUD（增删改查）等功能

package com.liangzai.Service;

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

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

/**
 * @author liangzai
 * @version 1.0
 * @return 返回所有MySQL中所有的student信息
 * 该类可以根据需求实现CRUD（增删改查）等功能
 * Service层主要负责业务模块的应用设计。
 * Service层的设计：同样是首先设计接口，再设计其实现类，
 * 接着在Spring的配置文件中配置其实现的关联。这
 * 样我们就可以在应用中调用service接口来进行处理。
 * service层的业务实现具体要调用已定义的dao层接口，
 * 封装service层业务逻辑有利于通过的业务逻辑的独立性和重复利用性。
 * 程序显得非常简洁。
 * @Service 注解 用于类上，标记当前类是一个service类，
 * 加上该注解会将当前类自动注入到spring容器中，
 * 不需要再在applicationContext.xml文件定义bean了
 * @Resource 注解 默认安照名称进行装配，名称可以通过name属性进行指定，
 * 如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，
 * 如果注解写在setter方法上默认取属性名进行装配。
 * 当找不到与名称匹配的bean时才按照类型进行装配。
 * 但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配.
 */
@Service
public class StudentService {
    @Resource
    //引用Dao接口
    private StudentRepository studentRepository;//把所有的student信息取出来

    //最终返回MySQL的数据，用集合去接收student类的所有信息
    public List<Student> findASll() {
        //返回所有MySQL中所有的student信息
        return studentRepository.findAll();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

在Controller层新建StudentController类

此时我们需要先在common包里面新建一个Result类

新建common包，并新建一个Result类

该类用来创建返回对象实体（泛型）、返回结果数据格式封装
说明：code为状态码、msg为提示信息、data为返回的数据

package com.liangzai.common;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * @param <T> 定义泛型传data数据，获取不同的响应状态及返回值
 * @author liangzai
 * @version 1.0
 * 该类用来创建返回对象实体（泛型）、返回结果数据格式封装
 * 说明：code为状态码、msg为提示信息、data为返回的数据
 * @Getter 注解 定义getXxx()方法
 * @Setter 注解 定义setXxx()方法
 * @NoArgsConstructor 注解 定义无参的构造方法
 */
@Getter
@Setter
@NoArgsConstructor
public class Result<T> {
    private String code;
    private String msg;
    private T data;

    //定义泛型方法,传data
    public Result(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 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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

200的状码如图所示

404状态码如图所示

StudentController

package com.liangzai.Controller;

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

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

/**
 * @author liangzai
 * @version 1.0
 * Controller层，负责具体的业务模块流程的控制，在此层要调用service层的接口来控制业务流程，
 * 控制的配置也同样是在Spring的配置文件里进行，针对具体的业务流程，会有不同的控制器。
 * 我们具体的设计过程可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块。
 * 这样不仅使程序结构变得清晰，也大大减少了代码量。
 * @RestController 注解 将数据以JSON格式返回
 * @RequestMapping 注解 在SpringMVC中使用@RequestMapping来映射请求
 * @Resource 注解 默认安照名称进行装配，名称可以通过name属性进行指定，
 * 如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，
 * 如果注解写在setter方法上默认取属性名进行装配。
 * 当找不到与名称匹配的bean时才按照类型进行装配。
 * 但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配.
 * @GetMapping 组合注解 将HTTP Get请求映射到特定的处理方法上。
 */
@RestController //将数据以JSON格式返回
@RequestMapping("/stu")
public class StudentController {
    @Resource
    private StudentService studentService;

    @GetMapping
    public Result<List<Student>> findAll() {
        List<Student> list = studentService.findAll();
        return Result.success(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

这时我们再输入[http://localhost:8080/stu] 运行一下

这时我们发现返回200 ok 请求成功了

{
  "code": "200",
  "msg": "ok",
  "data": []
}
1
2
3
4
5

在resource目录下新建static目录，用来实现前后端分离的view层

这里我们使用第三方工具Element来从网上找一个可以提供我们前端可视化的模板

我们找到对应需要的模板，复制下来修改参数即可

static目录结构如下

由于前端代码量太大，这里就不作展示

可视化效果如下

这里可视化只是实现了查询效果，今后可以实现删除、添加、等功能（很简单，加对应的注解即可实现）

到底啦！给靓仔一个关注吧(●’◡’●)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/143365