breakthrough_01

breakthrough_01

关注
发信
关注(28)粉丝(399)

使用Spring Boot搭建简单的web服务

1 引言

1.1 Spring Boot简介

Spring Boot是由Pivotal团队提供的一套开源框架，旨在简化Spring应用的创建及部署。

一、核心设计思想

Spring Boot的核心设计思想是“约定优于配置”（Convention Over Configuration，简称COC）。这种设计哲学强调通过遵循一系列预设的约定来减少显式配置的需要，从而降低配置的复杂性和出错的可能性，提高开发效率。

二、主要特点

  1. 简化开发：Spring Boot提供了一整套开发工具，如Spring Initializr，帮助开发者快速生成项目骨架，简化了项目的配置和开发流程。
  2. 自动配置：基于约定优于配置的原则，Spring Boot提供了大量的默认配置，减少了开发者对项目配置的工作量。同时，开发者也可以通过自定义配置来满足特定需求。
  3. 内嵌服务器：Spring Boot集成了多种内嵌服务器（如Tomcat、Jetty等），可以直接打包成可执行的JAR文件，方便部署和运行。
  4. 无需XML配置：Spring Boot使用注解方式进行配置，减少了配置文件（如XML）的使用，提高了开发效率。
  5. 组件化：Spring Boot采用了模块化的设计，将项目拆分成多个独立的组件，可以实现单个组件的独立开发和部署。
  6. 外部化配置：Spring Boot支持多种配置方式，包括properties、YAML等，可以实现外部化配置，方便应用的配置管理。
  7. 强大的插件支持：Spring Boot提供了丰富的starter POMs（项目对象模型），集成了大量的第三方库和框架，如MyBatis、Hibernate、Redis等，使得开发者能够快速搭建起一个功能完备的Spring应用。
  8. 微服务支持：Spring Boot支持微服务架构，可以通过Spring Cloud进行微服务的开发和管理。

三、常用功能

  1. 热部署：Spring Boot提供了dev-tools工具，支持热部署功能。当开发者对代码进行修改后，程序会自动重启，提高了开发效率。
  2. 单元测试：Spring Boot整合了Junit进行单元测试，方便开发者对代码进行验证和调试。
  3. 监控和管理：通过Actuator模块，Spring Boot应用可以暴露出一系列端点（endpoints），这些端点可以通过HTTP、JMX等方式进行访问，提供应用的各种信息（如健康状态、配置属性、线程信息等），帮助开发者实时监控应用的运行状态和性能指标。

四、依赖环境要求

  1. Java编译环境：Spring Boot 2.x版本要求Java 8作为最低版本。随着Spring Boot版本的更新，对Java版本的要求也可能会有所提高。例如，Spring Boot 3.x版本通常需要Java 17或更高版本。
  2. 构建工具：Spring Boot项目通常使用Maven或Gradle作为构建工具。Maven是一个项目管理和构建自动化工具，而Gradle则是一个基于Apache Ant和Apache Maven概念的项目自动化构建工具。
  3. 集成开发环境（IDE）：开发Spring Boot项目需要一个集成开发环境（IDE）工具，如IntelliJ IDEA、Eclipse、Visual Studio Code等。这些IDE工具提供了丰富的代码编辑、调试、构建和部署功能，可以大大提高开发效率。

1.2 Web服务基础概念

Web服务基础概念主要涉及Web服务的定义、特性、协议栈、关键技术以及应用场景等方面。

一、Web服务的定义

Web服务是一种基于互联网的服务，它允许不同的应用程序和系统之间进行通信和数据交换。这种服务通常使用标准的协议和格式（如HTTP、XML、SOAP等）来支持不同平台和语言之间的互操作性。Web服务是一种新型的分布式构件模型，已经在电子商务、企业应用集成等领域扮演越来越重要的角色，并不断影响现代企业应用的开发与部署。

二、Web服务的特性

Web服务具有以下几个主要特性：

  1. 互操作性：Web服务可以在不同的操作系统、编程语言和硬件平台之间实现无缝通信。
  2. 重用性：Web服务可以被不同的应用程序和系统重用，提高了开发效率和降低了成本。
  3. 可描述性：Web服务可以通过一种服务描述语言（如WSDL）来描述其接口和功能。
  4. 可发布性：Web服务可以在注册中心（如UDDI）注册其描述信息并发布，方便其他应用程序发现和调用。
  5. 可查找性：通过向注册服务器发送查询请求，可以找到满足查询条件的服务，并获取服务的绑定信息。
  6. 可调用性：使用服务描述信息中的绑定细节，可以实现服务的远程调用。

三、Web服务协议栈

Web服务协议栈是Web服务技术的基础，它包括了多个关键的协议和技术。这些协议和技术共同构成了Web服务的通信、描述、质量和服务流程等主体部分。

  1. 服务通信协议：如HTTP、SMTP等，用于实现Web服务之间的通信和数据交换。
  2. 服务描述语言：如WSDL，用于描述Web服务的接口和功能。
  3. 服务质量协议：如WS-Reliability、WS-Security等，用于保证Web服务的可靠性和安全性。
  4. 服务流程协议：如BPEL、WS-CDL等，用于描述和协调Web服务之间的交互和协作。

四、Web服务的关键技术

  1. SOAP（Simple Object Access Protocol）：一种用于在分散的或分布式环境中交换结构化信息的轻量级协议。它使用XML技术定义了一个可扩展的消息框架，用于在多种下层协议上进行消息交换。SOAP的主要设计目标是简单性和可扩展性。
  2. WSDL（Web Services Description Language）：一种基于XML的语言，用于描述Web服务的接口和功能。WSDL使得其他应用程序能够理解和调用Web服务。
  3. UDDI（Universal Description, Discovery and Integration）：一个基于Web的、跨平台的、全球性的注册表系统，用于存储和查找Web服务的描述信息。UDDI使得应用程序能够发现和调用网络上可用的Web服务。

五、Web服务的应用场景

Web服务在多个领域都有广泛的应用，包括但不限于以下几个方面：

  1. 电子商务：Web服务可以用于实现电子商务网站之间的商品信息交换、订单处理等功能。
  2. 企业应用集成：Web服务可以用于实现企业内部不同系统之间的数据交换和集成，如ERP系统、CRM系统等。
  3. 云计算：Web服务是云计算平台的重要组成部分，用于提供弹性计算、存储等资源和服务。
  4. 物联网：Web服务可以用于实现物联网设备之间的数据交换和协同工作。

2 项目环境准备

2.1 安装JDK

一、推荐使用的JDK版本

  1. Spring Boot 2.x：

    • 推荐使用JDK 1.8.0_201及以上版本。JDK 1.8提供了良好的稳定性和性能，并且与Spring Boot 2.x版本兼容。

  2. Spring Boot 3.x：

    • 推荐使用JDK 17及以上版本。随着Java版本的更新，JDK 17带来了更多的新特性和性能改进，同时Spring Boot 3.x也针对JDK 17进行了优化。

二、本文使用的JDK版本

** jdk-17.0.13 **

2.2 安装并配置Maven

Maven是一个项目构建及管理工具，可以自动完成工程的基础构建配置，如清理、编译、测试、安装、打包、发布等。

一、下载Maven

  1. 访问Maven的官方网站：https://maven.apache.org/download.cgi
  2. 在下载页面选择适合的Maven版本进行下载。通常，建议选择最新的稳定版本，本文选择版本为：3.9.9
  3. 下载完成后，将Maven的压缩包解压到一个没有中文、空格或其他特殊字符的文件夹内。

二、配置Maven环境变量

  1. 新增环境变量：

    • 在Windows系统中，右键点击“此电脑”或“计算机”，选择“属性”。
    • 点击“高级系统设置”，然后点击“环境变量”。
    • 在“系统变量”区域，点击“新建”按钮。
    • 变量名设置为MAVEN_HOME，变量值设置为Maven解压后的路径（例如：D:\apache-maven-3.x.x）。

  2. 编辑Path环境变量：

    • 在“系统变量”区域，找到名为Path的变量，并选中它。
    • 点击“编辑”按钮。
    • 在“编辑环境变量”窗口中，点击“新建”按钮，并输入%MAVEN_HOME%\bin。
    • 点击“确定”按钮保存更改。

  3. 验证Maven安装：

    • 打开命令提示符（CMD）窗口。
    • 输入mvn -v或mvn --version命令。
    • 如果Maven安装和环境变量配置正确，你应该能看到Maven的版本信息。

三、配置Maven的settings.xml文件

  1. 找到settings.xml文件：

    • 通常，settings.xml文件位于Maven安装目录下的conf文件夹中（例如：D:\apache-maven-3.x.x\conf\settings.xml）。

  2. 配置本地仓库：

    • 打开settings.xml文件。
    • 找到<localRepository>标签。默认情况下，该标签是被注释掉的。
    • 取消注释该标签，并将其值设置为你希望用作Maven本地仓库的目录路径（例如：<localRepository>D:/maven/repository</localRepository>）。
    • 保存文件。

  3. 配置镜像源（可选）：

    • 在settings.xml文件中，找到<mirrors>标签。
    • 在<mirrors>标签内添加你希望使用的镜像源配置。例如，使用阿里云的镜像源可以加快依赖的下载速度。
    <mirror>
	<id>nexus-aliyun</id>
	<mirrorOf>central</mirrorOf>
	<name>Nexus aliyun</name>
	<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
    • 保存文件。

  4. 配置JDK版本（可选）：

    • 在settings.xml文件中，可以配置Maven使用的JDK版本。这通常在<profiles>标签内配置。
    <profiles>
	<profile>
		<id>jdk-1.8</id>
		<activation>
			<activeByDefault>true</activeByDefault>
			<jdk>1.8</jdk>
		</activation>
		<properties>
			<maven.compiler.source>1.8</maven.compiler.source>
			<maven.compiler.target>1.8</maven.compiler.target>
		</properties>
	</profile>
</profiles>
    • 注意：这里的JDK版本应该与你的项目需求和开发环境相匹配。

四、验证Maven配置

  1. 打开命令提示符（CMD）窗口。
  2. 输入mvn help:system命令。
  3. 执行完该命令后，你应该能在本地仓库目录下看到Maven从中央仓库下载的文件。

2.3 安装并配置IDE

本文所用IDE及其版本为：** IntelliJ IDEA Community Edition 2023.1.2 **

3 创建Spring Boot项目

3.1 使用Spring Initializr创建项目

以下是通过Spring Initializr创建项目的详细步骤：

一、访问Spring Initializr

打开浏览器，访问Spring Initializr的官方网址：https://start.spring.io/

二、配置项目参数

  1. Project：选择项目构建工具，Maven或Gradle。这里以Maven为例。
  2. Language：选择编程语言，Java、Kotlin或Groovy。通常选择Java。
  3. Spring Boot：选择Spring Boot的版本。默认是最新版本，但你也可以选择其他稳定版本。本文选择的是 3.3.5 。
  4. Project Metadata：
    • Group：项目的组ID，通常是反向域名格式，如com.example。
    • Artifact：项目的artifactId，即项目的名称，如demo。
    • Name：项目的完整名称，可以是中文或其他字符。
    • Description：项目的描述信息。
    • Package Name：项目的包名，通常自动生成，基于Group和Artifact。
    • Packaging：打包方式，通常选择Jar。
    • Java：选择项目的Java版本。

三、选择依赖

  1. 在“Dependencies”部分，选择你的项目需要的依赖。Spring Initializr提供了丰富的依赖选项，如Spring Web、Spring Data JPA、MySQL Driver等。本文仅添加了 Spring Web 依赖。
  2. 你可以通过搜索框搜索依赖，也可以从左侧的类别中浏览并选择依赖。
  3. 选择完依赖后，点击“Add”按钮将它们添加到项目中。

四、生成项目

  1. 配置完成后，点击页面底部的“Generate”按钮，生成项目。
  2. 等待片刻，Spring Initializr会生成一个包含你指定依赖的Maven项目，并下载为一个压缩文件（如.zip）。

五、解压并导入项目

  1. 将下载的压缩文件解压到你希望存放项目的目录中。
  2. 通过IntelliJ IDEA的“Open Project”功能导入刚才解压的项目。

六、运行项目

  1. 在IDE中打开项目后，找到包含main方法的启动类（通常位于src/main/java目录下，包名与你在Spring Initializr中配置的包名一致）。
  2. 右键点击启动类，选择“Run”或“Debug”选项运行项目。
  3. 如果你的项目配置了Spring Web依赖，并且没有错误，你应该能够在浏览器中访问项目的默认页面（通常是http://localhost:8080）。

3.2 项目目录结构解析

使用Spring Initializr创建Spring Boot项目后，会生成一个具有标准目录结构的项目。以下是对该目录结构的详细解析：

一、根目录

项目的根目录通常以项目的artifactId命名，如demo。这个目录包含了整个项目的所有文件和文件夹。

二、src目录

src目录是整个项目的源代码目录，包含了项目的所有代码文件。它通常包含两个子目录：main和test。

** 1. src/main目录 **

src/main目录是项目的主要代码目录，包含了项目的核心代码和资源文件。它通常包含以下子目录：

  • java：用于存放项目的Java源代码文件。通常，项目的各个模块按照功能划分，每个模块都有自己的包目录结构。例如，一个Web应用程序的模块可以将所有的控制器代码放在com.example.project.controller包下，而服务层代码可以放在com.example.project.service包下。
  • resources：用于存放项目的资源文件，如配置文件、模板文件、静态资源文件等。Spring Boot会自动将这些资源文件加载到项目中供使用。常见的配置文件有application.properties或application.yml，它们包含了Spring Boot运行的各种配置。

** 2. src/test目录 **

src/test目录是项目的测试代码目录，用于存放项目的测试代码文件。测试代码通常与主要代码位于相同的包目录结构下，但是在src/test目录中。这样做的好处是可以将测试代码与主要代码分离，方便进行测试和维护。

三、pom.xml文件

pom.xml文件是Maven项目的配置文件，用于管理项目的依赖关系和构建配置。在这个文件中，你可以定义项目的依赖、插件、构建目标等信息。Spring Boot项目通常会继承spring-boot-starter-parent作为父POM，以获取Spring Boot的默认配置和依赖管理。

四、其他文件和目录

  • .mvn：这是Maven Wrapper的存放位置。Maven Wrapper是一个包装器工具，用于在没有预先安装Maven的系统上运行Maven项目。
  • target：Maven构建项目时生成的目录，包含了编译后的字节码文件和打包后的可执行文件（如jar包、war包等）。
  • .gitignore：用于指定应该被Git忽略的文件和目录，以防止它们被添加到版本控制中。
  • HELP.md：一个Markdown格式的文件，通常包含项目的帮助信息、说明和指南。
  • mvnw和mvnw.cmd：Maven Wrapper的可执行脚本文件，分别用于Unix/Linux系统和Windows系统。它们允许在没有全局Maven安装的情况下运行Maven项目。

五、示例目录结构

以下是一个典型的Spring Boot项目的目录结构示例：

my-spring-boot-app
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           ├── controller
│   │   │           │   └── MyController.java
│   │   │           ├── service
│   │   │           │   └── MyService.java
│   │   │           ├── repository
│   │   │           │   └── MyRepository.java
│   │   │           └── ...（其他包和类）
│   │   └── resources
│   │       ├── application.properties
│   │       └── static
│   │           └── css
│   │               └── style.css
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── MyServiceTests.java
├── pom.xml
├── .mvn
│   ├── wrapper
│   │   ├── maven-wrapper.jar
│   │   └── maven-wrapper.properties
│   └── mvnw
│       ├── mvnw
│       └── mvnw.cmd
├── .gitignore
└── HELP.md

4 搭建Web服务

4.1 编写Controller类以响应HTTP请求

在Spring Boot项目中，Controller类用于处理HTTP请求并返回响应。

一、Controller类示例

首先，我们创建一个名为MyController的Controller类。这个类将包含两个方法：一个用于处理GET请求，另一个用于处理POST请求。

package com.example.demo.controller;

import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api")
public class MyController {

    // GET方法示例
    @GetMapping("/greeting")
    public Map<String, String> greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
        Map<String, String> response = new HashMap<>();
        response.put("message", "Hello, " + name + "!");
        return response;
    }

    // POST方法示例
    @PostMapping("/submit")
    public Map<String, String> submitForm(@RequestBody Map<String, String> formData) {
        Map<String, String> response = new HashMap<>();
        String receivedName = formData.get("name");
        String receivedEmail = formData.get("email");

        // 在这里可以添加业务逻辑，比如验证输入、保存到数据库等

        response.put("message", "Form submitted successfully!");
        response.put("receivedName", receivedName);
        response.put("receivedEmail", receivedEmail);
        return response;
    }
}

二、解释

  1. @RestController：这是一个方便的注解，它结合了@Controller和@ResponseBody的功能。它表示这个类是一个Spring MVC Controller，并且所有方法的返回值都会自动作为HTTP响应体返回。

  2. @RequestMapping(“/api”)：这个注解用于定义这个Controller处理的所有请求的根URL路径。在这个例子中，所有这个Controller处理的请求都会以/api作为URL的前缀。

  3. @GetMapping(“/greeting”)：这个注解用于将HTTP GET请求映射到greeting方法。请求的完整URL将是/api/greeting。@RequestParam注解用于从请求参数中获取值，如果参数不存在，则使用默认值"World"。

  4. @PostMapping(“/submit”)：这个注解用于将HTTP POST请求映射到submitForm方法。请求的完整URL将是/api/submit。@RequestBody注解用于将请求体中的JSON数据绑定到Java对象（在这个例子中是Map<String, String>）。

  5. 方法返回值：这两个方法都返回一个Map<String, String>对象，其中包含了要返回给客户端的响应数据。在Spring MVC中，你可以返回多种类型的对象作为响应体，包括字符串、对象、集合等。

三、测试

要测试这些API，你可以使用工具如Postman或curl。

  • GET请求：

    curl http://localhost:8080/api/greeting?name=John

    你应该会收到一个JSON响应，类似于：{"message":"Hello, John!"}

  • POST请求：

    curl -X POST -H "Content-Type: application/json" -d '{"name":"John","email":"john@example.com"}' http://localhost:8080/api/submit

    你应该会收到一个JSON响应，类似于：{"message":"Form submitted successfully!","receivedName":"John","receivedEmail":"john@example.com"}

请注意，这些示例假设你的Spring Boot应用程序正在本地运行，并且监听默认的8080端口。如果端口不同，请相应地调整URL。

4.2 配置跨域请求支持

跨域资源共享（CORS）是一个机制，它使用额外的HTTP头来告诉浏览器一个web应用允许一个网页从不同源（domain、scheme、或port）的服务器请求资源。

一、使用@CrossOrigin注解

@CrossOrigin注解可以添加到Controller类或者具体的处理方法上，以启用跨域请求。

示例：在Controller方法上使用@CrossOrigin

package com.example.demo.controller;

import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api")
// 可以直接在类上应用@CrossOrigin注解，允许所有源的跨域请求  
// @CrossOrigin(origins = "*") 
public class MyController {

    // 允许来自所有域的跨域请求
    @CrossOrigin(origins = "*")
    @GetMapping("/greeting")
    public Map<String, String> greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
        Map<String, String> response = new HashMap<>();
        response.put("message", "Hello, " + name + "!");
        return response;
    }

    // 同样允许跨域请求的POST方法
    @CrossOrigin(origins = "*")
    @PostMapping("/submit")
    public Map<String, String> submitForm(@RequestBody Map<String, String> formData) {
        // ...（之前的代码）
        return response;
    }
}

在这个例子中，@CrossOrigin(origins = "*")表示允许来自任何域的跨域请求。你也可以指定具体的域，例如origins = "http://example.com"。

二、配置全局跨域支持

如果想要为整个应用配置全局的跨域支持，可以实现WebMvcConfigurer接口并重写addCorsMappings方法。

** 示例：全局跨域配置 **

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        // 允许来自所有域的跨域请求，并允许所有HTTP方法
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedMethods("GET", "POST", PUT, DELETE, OPTIONS")
                .allowCredentials(true)
                .allowedHeaders("*")
                .exposedHeaders("*");
    }

    // 如果还需要其他Bean配置，可以在这里添加@Bean方法
}

在这个例子中，addMapping("/**")表示应用全局的CORS配置到所有的URL路径。allowedOrigins("*")允许来自任何域的请求。allowedMethods指定了允许的HTTP方法。allowCredentials(true)表示是否允许发送Cookie。allowedHeaders和exposedHeaders分别指定了允许的请求头和响应头。

三、注意事项

  1. 安全性：在生产环境中，应该避免使用origins = "*"或类似的配置，因为这会使API对任何域都开放。

  2. Spring Security：如果你的应用使用了Spring Security，你还需要在Spring Security配置中启用CORS。

  3. 浏览器限制：即使正确配置了CORS，某些浏览器（特别是较旧的版本）可能仍然会限制跨域请求。

5 统计前端网站的浏览日志

统计前端网站的浏览日志是一个常见的需求，它可以帮助你了解用户的行为和网站的使用情况。以下是一个具体示例，展示了如何设计并实现这一功能。

5.1 设计浏览日志数据模型

首先，我们需要一个数据模型来表示浏览日志。这个模型可以包含用户ID、页面URL、访问时间、IP地址等信息。

package com.example.demo.model;

import java.time.LocalDateTime;

public class BrowseLog {
    private String userId;
    private String pageUrl;
    private LocalDateTime visitTime;
    private String ipAddress;

    // Getters and Setters
    // ...

    // Constructor
    public BrowseLog(String userId, String pageUrl, LocalDateTime visitTime, String ipAddress) {
        this.userId = userId;
        this.pageUrl = pageUrl;
        this.visitTime = visitTime;
        this.ipAddress = ipAddress;
    }

    // toString() 方法（可选，用于调试）
    @Override
    public String toString() {
        return "BrowseLog{" +
                "userId='" + userId + '\'' +
                ", pageUrl='" + pageUrl + '\'' +
                ", visitTime=" + visitTime +
                ", ipAddress='" + ipAddress + '\'' +
                '}';
    }
}

5.2 创建Service类以处理日志记录逻辑

接下来，我们创建一个Service类来处理日志记录的逻辑。这个类将负责将日志数据保存到文件中。

package com.example.demo.service;

import com.example.demo.model.BrowseLog;
import org.springframework.stereotype.Service;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Paths;
import java.time.format.DateTimeFormatter;
import java.util.List;

@Service
public class LogService {

    private static final String LOG_FILE_PATH = "logs/browse_logs.txt"; // 配置日志文件的保存路径
    private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public void saveLogs(List<BrowseLog> logs) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(LOG_FILE_PATH).toFile(), true))) {
            for (BrowseLog log : logs) {
                writer.write(log.getUserId() + "," +
                        log.getPageUrl() + "," +
                        log.getVisitTime().format(DATE_TIME_FORMATTER) + "," +
                        log.getIpAddress() + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
            // 可以添加日志记录或异常处理逻辑
        }
    }
}

5.3 创建Controller类以接收前端发送的日志数据

现在，我们创建一个Controller类来接收前端发送的日志数据，并调用Service类来保存这些数据。

package com.example.demo.controller;

import com.example.demo.model.BrowseLog;
import com.example.demo.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/logs")
public class LogController {

    @Autowired
    private LogService logService;

    @PostMapping("/submit")
    public String submitLogs(@RequestBody List<BrowseLogDto> logDtos) {
        List<BrowseLog> logs = new ArrayList<>();
        for (BrowseLogDto logDto : logDtos) {
            BrowseLog log = new BrowseLog(
                    logDto.getUserId(),
                    logDto.getPageUrl(),
                    LocalDateTime.now(), // 使用当前时间作为访问时间
                    logDto.getIpAddress()
            );
            logs.add(log);
        }
        logService.saveLogs(logs);
        return "Logs saved successfully!";
    }
}

// 创建一个DTO类来接收前端发送的数据
class BrowseLogDto {
    private String userId;
    private String pageUrl;
    private String ipAddress;

    // Getters and Setters
    // ...
}

注意：在这个例子中，我创建了一个BrowseLogDto类来接收前端发送的数据，并将其转换为BrowseLog对象。这是因为前端发送的数据格式可能与我们的数据模型不完全匹配，或者我们可能只想接收部分字段。

5.4 配置日志文件的保存路径和格式（已在Service类中配置）

在LogService类中，我们已经配置了日志文件的保存路径（LOG_FILE_PATH）和日志的格式（使用逗号分隔的字符串）。这些配置可以根据需要进行调整。

5.5 编写代码将日志数据保存到指定目录下的文本文件中（已在Service类中实现）

在LogService类的saveLogs方法中，我们已经实现了将日志数据保存到指定目录下的文本文件中的逻辑。这个方法会遍历传入的日志列表，并将每个日志对象转换为字符串格式，然后写入到文件中。

5.6 注意事项

  • 确保Spring Boot应用有权限写入指定的日志文件路径。
  • 在生产环境中，可能需要考虑日志文件的轮转和归档，以避免日志文件过大或占用过多磁盘空间。

6 配置SSL证书以支持HTTPS请求

在Spring Boot程序中配置SSL证书以支持HTTPS请求，通常涉及将SSL证书和私钥文件加载到Spring Boot的嵌入式服务器（如Tomcat或Jetty）中。以下是一个基本的步骤指南，说明如何在Spring Boot应用中配置SSL证书：

一、准备SSL证书和私钥

确保已经从可信的证书颁发机构（CA）获得了SSL证书，并且你有相应的私钥文件。这些文件通常以.crt（或.pem）和.key扩展名保存。

二、将证书和私钥转换为PKCS12密钥库（可选）

虽然Spring Boot可以直接使用PEM格式的证书和私钥（通过一些额外的配置），但最常见和最简单的方法是将它们转换为一个PKCS12密钥库（.p12或.pfx文件）。这可以通过OpenSSL工具来完成：

openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -certfile ca_bundle.crt -name mykeyalias -CAfile root_ca.crt

在这个命令中：

  • -inkey 指定私钥文件。
  • -in 指定你的证书文件。
  • -certfile（或-certs）指定任何中间证书（如果有的话）。
  • -name 指定密钥库中的别名。
  • -CAfile（可选）指定根证书（用于验证证书链）。

注意：不是所有的参数都是必需的，具体取决于证书和私钥文件的内容。

三、配置Spring Boot应用

在Spring Boot的application.properties或application.yml文件中，配置服务器以使用HTTPS和指定的密钥库：

application.properties

server.port=443
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=yourKeystorePassword
server.ssl.keyStoreType=PKCS12
server.ssl.keyAlias=mykeyalias

application.yml

server:
  port: 443
  ssl:
    key-store: classpath:keystore.p12
    key-store-password: yourKeystorePassword
    keyStoreType: PKCS12
    keyAlias: mykeyalias

确保将keystore.p12、yourKeystorePassword和mykeyalias替换为你的实际文件名、密钥库密码和密钥别名。

四、验证配置

启动Spring Boot应用，并尝试通过HTTPS访问它（例如，使用浏览器或curl命令）。如果一切配置正确，你应该能够安全地访问你的应用，并且浏览器应该显示一个锁图标，表示连接是加密的。

五、注意事项

  • 如果你使用的是自签名证书，浏览器可能会显示警告，因为自签名证书不是由受信任的证书颁发机构颁发的。
  • 确保你的密钥库密码和私钥文件是安全的，不要将它们硬编码在代码中或存储在公共版本控制系统中。
  • 如果你使用的是外部Web服务器（如Nginx或Apache），你可能需要在该服务器上配置SSL，并将Spring Boot应用作为反向代理的后端服务。在这种情况下，你不需要在Spring Boot配置中直接指定SSL证书和私钥。

7 项目部署

在IntelliJ IDEA中打包并部署Spring Boot应用，可以按照以下步骤进行：

一、打包Spring Boot应用

  1. 添加Maven打包插件：
    • 打开Spring Boot项目的pom.xml文件。
    • 在<build>标签内添加<plugins>标签，并配置spring-boot-maven-plugin插件，用于辅助对项目进行打包。
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
  1. 使用Idea进行打包：
    • 在Idea中，打开项目的Maven视图（在右侧边框）。
    • 在Maven视图对应的操作窗口中，选择项目目录下的Lifecycle目录中的package选项，并双击进行项目打包。
    • 打包完成后，控制台会显示打包运行过程以及最终的打包结果，包括Jar包的具体存放路径以及名称。
    • 同时，也可以在Idea中打开项目的target目录，查看生成的Jar包。

二、部署Spring Boot应用

  1. 准备部署环境：

    • 确保服务器上已经安装了JDK，并且版本与Spring Boot应用兼容。
    • 如果使用Nginx或Apache作为反向代理，需要确保这些服务器也已经安装并配置好。

  2. 上传Jar包到服务器：

    • 使用SCP、SFTP等工具将生成的Jar包上传到服务器上的指定目录。

  3. 运行Jar包：

    • 通过SSH连接到服务器。
    • 使用cd命令切换到Jar包所在的目录。
    • 运行以下命令启动Spring Boot应用：
java -jar your-application.jar

其中，your-application.jar是你的Spring Boot应用的Jar包名称。

  1. 配置反向代理（如果使用）：

    • 在Nginx或Apache的配置文件中，添加反向代理规则，将前端网页的请求转发到Spring Boot应用的后端服务。
    • 重启Nginx或Apache服务器，使配置生效。

  2. 验证部署：

    • 打开浏览器，访问前端网页的URL。
    • 通过开发者工具（如浏览器的F12工具）或网络抓包工具（如Wireshark）验证前端网页的请求是否成功转发到后端服务，并查看后端服务的响应。

三、指定IP与端口

在Spring Boot程序启动时，可以通过几种方式指定应用程序监听的IP地址和端口。以下是几种常见的方法：

  1. 使用application.properties或application.yml配置文件：

这是最常见和推荐的方法。你可以在src/main/resources目录下的application.properties或application.yml文件中设置服务器端口和IP地址。

application.properties:

server.address=你的IP地址
server.port=你的端口号

application.yml:

server:
  address: 你的IP地址
  port: 你的端口号

注意：server.address属性不是必需的，因为默认情况下Spring Boot会监听所有可用的网络接口（即0.0.0.0）。如果你只想监听特定的IP地址，才需要设置这个属性。

  1. 使用命令行参数：

你也可以在启动Spring Boot应用程序时通过命令行参数来指定端口和IP地址。

java -jar your-application.jar --server.port=你的端口号 --server.address=你的IP地址

或者，如果你使用的是Spring Boot的Maven插件或Gradle插件来运行应用程序，你可以在mvn spring-boot:run或gradle bootRun命令后添加这些参数（注意，这可能需要一些额外的配置来确保参数被正确传递）。

  1. 使用@Value注解或Environment接口在代码中设置：

虽然不推荐这样做（因为最好将配置保持在配置文件中），但你可以在代码中通过@Value注解或Environment接口来读取配置值，并在程序启动时动态地设置它们。然而，这种方法通常用于读取配置文件的值，而不是用于在启动时指定新的值。

  1. 使用ServerProperties自定义Bean：

你可以创建一个配置类，并通过@Bean方法返回一个自定义的ServerProperties对象，但这种方法比较复杂，通常用于高级配置场景。

四、注意事项

  1. 端口冲突：

    • 确保Spring Boot应用使用的端口没有被其他服务占用。
    • 如果使用Nginx或Apache作为反向代理，需要确保它们的监听端口也没有被占用。

  2. 日志和监控：

    • 配置Spring Boot应用的日志输出，以便跟踪和调试应用的运行状态。
    • 可以使用监控工具（如Prometheus、Grafana等）对Spring Boot应用进行性能监控和告警。

  3. 安全性：

    • 确保服务器和Spring Boot应用的安全性，包括配置防火墙、使用HTTPS协议、定期更新依赖库等。
11-05 04:41
Powered by LMLPHP ©2024 breakthrough_01 0.001427