1. 首页
  2. 分类
  3. java
Spring Boot项目中使用MockMvc进行测试的详细指南
System
2024-09-01
所有,java



import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
 
@SpringBootTest
@AutoConfigureMockMvc
public class ExampleControllerTest {
 
    @Autowired
    private MockMvc mockMvc;
 
    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        this.mockMvc.perform(MockMvcRequestBuilders.get("/hello"))
            .andDo(MockMvcResultHandlers.print())
            .andExpect(MockMvcResultMatchers.status().isOk())
            .andExpect(MockMvcResultMatchers.content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(MockMvcResultMatchers.jsonPath("$.message").value("Hello, World!"));
    }
}

这段代码演示了如何使用Spring Boot的@SpringBootTest和@AutoConfigureMockMvc注解来进行集成测试，并使用MockMvc来发起GET请求，检查响应状态、内容类型和JSON内容。

- 阅读更多 -
Tomcat和Servlet基础知识的讲解（JavaEE初阶系列16）
System
2024-09-01
所有,java

Tomcat 是一个开源的Java Servlet 容器，用于运行Java Web应用程序。Servlet（Server Applet）是运行在服务器端的Java小程序，用于交互式地浏览和修改数据，生成动态Web内容。

以下是一个简单的Servlet示例，展示了如何创建一个Servlet并响应HTTP请求：




import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class HelloWorldServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

在这个例子中，HelloWorldServlet 继承自 HttpServlet 类，并覆盖了 doGet 方法来处理GET请求。当Servlet容器（如Tomcat）接收到一个指向这个Servlet的请求时，它会调用 doGet 方法，并将HTTP请求和响应作为参数传递进去。

要使这个Servlet工作，你需要将它部署到Tomcat中，并确保Tomcat已经启动。部署通常涉及将编译后的.class文件放入Tomcat的webapps目录下的适当位置，或者在web.xml文件中进行配置。

启动Tomcat后，你可以通过浏览器访问这个Servlet，URL通常如下：




http://localhost:8080/<你的应用路径>/hello

这里，<你的应用路径> 是你的应用目录名，hello 是映射到 HelloWorldServlet 的URL路径。当访问这个URL时，Servlet将响应“Hello World”的HTML页面。

- 阅读更多 -
深入解析Spring Boot的application.yml配置文件
System
2024-09-01
所有,java

Spring Boot的application.yml是一种非常灵活的配置文件，它使用YAML格式来提供一个清晰、简洁的配置方式。

YAML（YAML Ain't Markup Language）是一种数据序列化语言，设计的目标就是方便人类阅读和编写，同时也方便应用程序解析。它支持更为复杂的数据结构，比如映射（Maps）、序列（Lists）和可以包含其他Maps和Lists的结构。

下面是一个简单的application.yml配置文件示例，展示了如何配置应用程序的名称、服务器端口和环境变量：




spring:
  application:
    name: my-application
server:
  port: 8080
 
env:
  key1: value1
  key2: value2

在Spring Boot应用程序中，你可以使用@Value注解来注入YAML文件中的值到Java类中：




import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
 
@Component
public class MyBean {
 
    @Value("${env.key1}")
    private String key1;
 
    @Value("${env.key2}")
    private String key2;
 
    // Getters and Setters
}

Spring Boot会自动解析application.yml文件，并使配置项可用于Spring应用程序。通过使用@ConfigurationProperties注解，你还可以将YAML中的配置组织到一个配置类中：




import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
 
@Component
@ConfigurationProperties(prefix = "env")
public class EnvConfig {
 
    private String key1;
    private String key2;
 
    // Getters and Setters
}

这样，你可以通过EnvConfig类直接访问YAML中定义的配置项。

- 阅读更多 -
Tomcat内存马
System
2024-09-01
所有,java

"Tomcat内存马"通常指的是部署在Tomcat服务器上的恶意代码，它隐藏在合法的Java Web应用程序中，并在服务器运行时执行恶意操作。内存马是一个安全术语，用来描述那些在服务器内存中运行的恶意代码。

解决方法：

  1. 立即停止Tomcat服务器。
  2. 进行全面的安全扫描，检查服务器上是否有其他恶意文件或配置。
  3. 审查所有的Java Web应用程序，检查是否有未授权的应用程序部署在Tomcat中。
  4. 更新所有的应用程序和Tomcat服务器到最新版本，确保没有已知的安全漏洞。
  5. 审查服务器的安全配置，如context.xml、web.xml、以及其他Tomcat配置文件，确保没有恶意代码被注入。
  6. 如果有必要，更换服务器和应用程序的密码，并考虑使用防火墙和入侵检测系统。
  7. 清理恶意代码并移除已经识别的文件。
  8. 重新启动Tomcat服务器，确保没有恶意代码在运行。

注意：在处理内存马时，务必确保不破坏正常运行的业务逻辑，并在专业的安全专家指导下进行操作。

- 阅读更多 -
SpringBoot前后端交互、全局异常处理：后端异常信息抛到前端显示弹窗
System
2024-09-01
所有,java



import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
 
@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
    // 处理所有Exception类型的异常
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseEntity<ExceptionResponse> handleException(Exception e) {
        // 打印异常堆栈
        e.printStackTrace();
 
        // 将异常信息封装到ExceptionResponse对象中
        ExceptionResponse exceptionResponse = new ExceptionResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage());
 
        // 返回包含异常信息的响应实体
        return new ResponseEntity<>(exceptionResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
 
    // 处理特定的ArithmeticException异常
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public ResponseEntity<ExceptionResponse> handleArithmeticException(ArithmeticException e) {
        // 打印异常堆栈
        e.printStackTrace();
 
        // 将异常信息封装到ExceptionResponse对象中
        ExceptionResponse exceptionResponse = new ExceptionResponse(HttpStatus.BAD_REQUEST.value(), e.getMessage());
 
        // 返回包含异常信息的响应实体
        return new ResponseEntity<>(exceptionResponse, HttpStatus.BAD_REQUEST);
    }
 
    // 如果需要处理其他特定类型的异常，可以继续添加相应的方法
}
 
// 异常信息封装类
class ExceptionResponse {
    private int statusCode;
    private String message;
 
    public ExceptionResponse(int statusCode, String message) {
        this.statusCode = statusCode;
        this.message = message;
    }
 
    // Getter和Setter方法
    public int getStatusCode() {
        return statusCode;
    }
 
    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
}

这个代码示例展示了如何在Spring Boot应用中创建一个全局异常处理器，它能捕获并处理应用中发生的各种异常。在这个例子中，我们捕获了两种类型的异常：Exception（捕获所有异常）和ArithmeticException（捕获算术异常），并将异常信息封装到ExceptionResponse对象中，返回给前端。这样，前端就可以根据返回的状态码和信息，弹出相应的对话框。

- 阅读更多 -
查看项目springboot的版本
System
2024-09-01
所有,java

要查看Spring Boot项目的版本，你可以查看项目的pom.xml文件，在这个文件中会有一个parent元素指定了Spring Boot的starter父项目（spring-boot-starter-parent），在这个parent中会定义Spring Boot的版本。

例如：




<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

在这个例子中，Spring Boot的版本是2.3.1.RELEASE。

另外，你也可以通过Maven的命令行查看版本，运行以下命令：




mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate -Dexpression=project.parent.version

这将输出项目中定义的Spring Boot父项目版本。

如果你的项目没有使用Spring Boot的父项目，你可以在properties元素中查看或指定Spring Boot的版本：




<properties>
    <spring-boot.version>2.3.1.RELEASE</spring-boot.version>
</properties>

在这个例子中，Spring Boot的版本是2.3.1.RELEASE。

- 阅读更多 -
tomcat安装、部署JSPGOU项目、Tomcat多实例
System
2024-09-01
所有,java

Tomcat安装和部署JSPGOU项目的步骤：

  1. 安装Tomcat：

    • 下载Tomcat压缩包。
    • 解压到指定目录。
    • 确保Java环境（JRE或JDK）已安装并配置环境变量。

  2. 部署JSPGOU项目：

    • 将JSPGOU项目的war包复制到Tomcat的webapps目录下。
    • 启动Tomcat（通常在Tomcat安装目录的bin目录下执行startup.sh或startup.bat）。
    • 访问项目，通常是通过浏览器输入http://<服务器IP>:<端口>/JSPGOU。

  3. 配置Tomcat多实例：

    • 确保每个实例使用不同的端口。
    • 为每个实例创建一个新的Tomcat实例目录。
    • 复制原Tomcat目录到新的位置，并重命名为不同的名字（例如tomcat-instance2）。
    • 修改每个实例的conf/server.xml文件，更改<Connector port="8080" ... />的端口号。
    • 在每个实例的bin目录下启动Tomcat（使用startup.sh或startup.bat）。

注意：具体步骤可能因Tomcat版本和操作系统而异。

- 阅读更多 -
Tomcat在linux环境中开机自启(定时重启)
System
2024-09-01
所有,java

要在Linux环境中设置Tomcat开机自启，可以创建一个名为 setenv.sh 的脚本文件，并将其放置在Tomcat的 bin 目录下。然后，你需要将Tomcat服务添加到系统的启动服务中。

  1. 创建 setenv.sh 文件:



touch setenv.sh
chmod +x setenv.sh
  1. 编辑 setenv.sh 文件，添加以下内容:



#!/bin/sh
 
export CATALINA_HOME=/path/to/tomcat
export JAVA_HOME=/path/to/java
 
exec "$CATALINA_HOME/bin/catalina.sh" run

将 /path/to/tomcat 和 /path/to/java 替换为你的Tomcat和Java安装路径。

  1. 创建一个systemd服务文件:

创建一个名为 tomcat.service 的文件:




sudo nano /etc/systemd/system/tomcat.service

添加以下内容:




[Unit]
Description=Tomcat Web Application Container
After=network.target
 
[Service]
Type=forking
 
Environment=JAVA_HOME=/path/to/java
Environment=CATALINA_PID=/path/to/tomcat/temp/tomcat.pid
Environment=CATALINA_HOME=/path/to/tomcat
Environment=CATALINA_BASE=/path/to/tomcat
Environment='CATALINA_OPTS=-Xms512M -Xmx1024M -server -XX:+UseParallelGC'
Environment='JAVA_OPTS=-Djava.awt.headless=true -Djava.security.egd=file:/dev/./urandom'
 
ExecStart=/path/to/tomcat/bin/startup.sh
ExecStop=/path/to/tomcat/bin/shutdown.sh
 
User=tomcat
Group=tomcat
UMask=0007
RestartSec=10
Restart=always
 
[Install]
WantedBy=multi-user.target

替换上面文件中的 /path/to/java、/path/to/tomcat、User 和 Group 为你的实际路径和用户。

  1. 启用并启动Tomcat服务:



sudo systemctl daemon-reload
sudo systemctl enable tomcat.service
sudo systemctl start tomcat.service
  1. 设置定时重启:

如果你需要定时重启Tomcat，可以使用 cron 任务来实现。编辑当前用户的 crontab 文件:




crontab -e

添加一行来设置定时任务，例如每天凌晨2点重启Tomcat:




0 2 * * * /usr/bin/systemctl restart tomcat.service

保存并退出编辑器，定时任务将自动设置。

确保你已经按照上述步骤替换了所有路径和配置，并根据你的系统调整用户和组。这样，Tomcat就会在Linux系统开机时自动启动，并且根据定时任务每天自动重启。

- 阅读更多 -
Spring Boot性能优化：提高响应速度的秘密
System
2024-09-01
所有,java

在Spring Boot应用中，提高响应速度可以通过以下方法实现：

  1. 使用缓存：合理使用缓存可以减少处理单个请求的时间。例如，使用Spring Cache Abstraction或者Redis等。
  2. 代码优化：优化代码逻辑，减少不必要的计算和数据库调用。
  3. 异步处理：对于耗时的操作，可以使用异步处理来避免阻塞主线程。
  4. 压缩响应数据：开启GZIP压缩可以减少网络传输的数据量。
  5. 优化数据库查询：优化SQL查询，使用索引，减少不必要的查询。
  6. 连接池管理：选择合适的数据库连接池，并进行合理配置。
  7. 配置优化：调整Spring Boot的配置，如减少JVM堆大小，开启线程池的优化等。

以下是一个简单的示例代码，展示如何在Spring Boot应用中开启GZIP压缩：




@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new GzipInterceptor());
    }
 
    private static class GzipInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
            response.addHeader("Content-Encoding", "gzip");
            return true;
        }
    }
}

以上代码通过实现WebMvcConfigurer接口，并添加自定义的GzipInterceptor来添加GZIP压缩的HTTP头部，从而开启GZIP压缩。这只是一个简单的示例，实际情况可能需要更复杂的配置和优化。

- 阅读更多 -
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
System
2024-09-01
所有,java

在SpringBoot中，我们可以通过创建自定义的序列化和反序列化来解决Date和LocalDateTime转换为时间戳以及数组的问题。

首先，我们需要创建一个自定义的序列化器和反序列化器。




public class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
 
    @Override
    public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeNumber(value.toInstant(ZoneOffset.UTC).toEpochMilli());
    }
}
 
public class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
 
    @Override
    public LocalDateTime deserialize(JsonParser p, DeserializationContext deserializationContext) throws IOException {
        return LocalDateTime.ofInstant(Instant.ofEpochMilli(p.getValueAsLong()), ZoneOffset.UTC);
    }
}
 
public class DateSerializer extends JsonSerializer<Date> {
 
    @Override
    public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeNumber(value.getTime());
    }
}
 
public class DateDeserializer extends JsonDeserializer<Date> {
 
    @Override
    public Date deserialize(JsonParser p, DeserializationContext deserializationContext) throws IOException {
        return new Date(p.getValueAsLong());
    }
}

然后，我们需要在配置类中注册这些自定义的序列化器和反序列化器。




@Configuration
public class JacksonConfig {
 
    @Bean
    public Jackson2ObjectMapperBuilder objectMapperBuilder() {
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
        builder.simpleDateFormat("yyyy-MM-dd HH:mm:ss");
        builder.modules(new SimpleModule()
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer())
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer())
                .addSerializer(Date.class, new DateSerializer())
                .addDeserializer(Date.class, new DateDeserializer()));
        return builder;
    }
}

在这个配置类中，我们定义了一个objectMapperBuilder方法，在这个方法中，我们添加了自定义的序列化器和反序列化器。这样，在序列化和反序列化过程中，SpringBoot就会使用我们自定义的方式来处理Date和LocalDateTime。

这样，我们就解决了在SpringBoot中处理Date和LocalDateTime时遇到的时间戳和数组的问题。

- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号