Java发布公告的实现流程

Tech Synapse

于 2024-05-17 19:12:11 发布

阅读量647

点赞数 14

文章标签： java 开发语言 spring boot

本文链接：https://blog.csdn.net/m0_72958694/article/details/139011536

版权

在Java中发布公告通常不直接涉及特定的Java库或框架，因为这更多是一个业务逻辑和可能的数据存储（如数据库）交互的问题。不过，我们也可以用Java编写一个基于Spring Boot和JPA（Java Persistence API）的简单示例，该示例展示了如何发布公告、存储它并在需要时检索它。

1. 项目设置

首先，我们需要设置一个Spring Boot项目。你可以使用Spring Initializr来快速生成一个包含所需依赖的项目。

2. 定义数据模型

假设我们有一个Announcement实体类，用于存储公告信息。

import javax.persistence.*;  
  
@Entity  
@Table(name = "announcements")  
public class Announcement {  
  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)  
    private Long id;  
  
    @Column(nullable = false)  
    private String title;  
  
    @Column(nullable = false, columnDefinition = "TEXT")  
    private String content;  
  
    @Column(nullable = false)  
    private LocalDateTime createdAt;  
  
    // 构造器、getter和setter方法（省略）  
}

3. 创建JPA仓库

接下来，我们需要一个接口来与数据库中的Announcement实体交互。

import org.springframework.data.jpa.repository.JpaRepository;  
  
public interface AnnouncementRepository extends JpaRepository<Announcement, Long> {  
    // 可以添加自定义查询方法（如果需要）  
}

4. 创建服务层

服务层将处理业务逻辑。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
  
import java.time.LocalDateTime;  
  
@Service  
public class AnnouncementService {  
  
    private final AnnouncementRepository announcementRepository;  
  
    @Autowired  
    public AnnouncementService(AnnouncementRepository announcementRepository) {  
        this.announcementRepository = announcementRepository;  
    }  
  
    public Announcement createAnnouncement(String title, String content) {  
        Announcement announcement = new Announcement();  
        announcement.setTitle(title);  
        announcement.setContent(content);  
        announcement.setCreatedAt(LocalDateTime.now());  
        return announcementRepository.save(announcement);  
    }  
  
    // 可以添加其他方法，如获取所有公告、根据ID获取公告等  
}

5. 创建控制器

控制器将处理HTTP请求并调用服务层的方法。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.*;  
  
@RestController  
@RequestMapping("/api/announcements")  
public class AnnouncementController {  
  
    private final AnnouncementService announcementService;  
  
    @Autowired  
    public AnnouncementController(AnnouncementService announcementService) {  
        this.announcementService = announcementService;  
    }  
  
    @PostMapping  
    public ResponseEntity<Announcement> createAnnouncement(@RequestBody AnnouncementRequest request) {  
        Announcement announcement = announcementService.createAnnouncement(request.getTitle(), request.getContent());  
        return ResponseEntity.created(URI.create("/api/announcements/" + announcement.getId())).body(announcement);  
    }  
  
    // 你可以添加其他端点，如获取所有公告、根据ID获取公告等  
  
    // 用于接收请求体的DTO（数据传输对象）  
    static class AnnouncementRequest {  
        private String title;  
        private String content;  
  
        // 构造器、getter和setter方法（省略）  
    }  
}

6. 运行和测试

现在我们可以运行我们的Spring Boot应用程序，并使用如Postman或curl之类的工具来测试/api/announcements端点，以创建新的公告。

注意：，例如添加异常处理、验证、权限控制等。

这只是一个基本的示例，你可能需要根据你的具体需求进行调整；为了更贴近我们现实中的应用，我们添加添加异常处理、验证、权限控制等。为了异常处理、验证和权限控制，我们需要进一步扩展上面的示例。以下是一个更完整的代码示例：

7. 异常处理

我们可以使用Spring的@ControllerAdvice和@ExceptionHandler来全局处理异常。

import org.springframework.http.HttpStatus;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.ControllerAdvice;  
import org.springframework.web.bind.annotation.ExceptionHandler;  
  
@ControllerAdvice  
public class GlobalExceptionHandler {  
  
    @ExceptionHandler(value = Exception.class)  
    public ResponseEntity<Object> handleException(Exception e) {  
        // 这里可以记录日志或执行其他操作  
        return new ResponseEntity<>(e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);  
    }  
  
    // 可以添加其他特定的异常处理器  
}

8. 验证

我们可以使用Spring的验证框架（基于Hibernate Validator）来验证请求体。

首先，我们需要定义验证规则：

import javax.validation.constraints.NotBlank;  
  
public class AnnouncementRequest {  
  
    @NotBlank(message = "Title must not be blank")  
    private String title;  
  
    @NotBlank(message = "Content must not be blank")  
    private String content;  
  
    // 构造器、getter和setter方法（省略）  
}

然后，在控制器中启用验证：

import org.springframework.http.ResponseEntity;  
import org.springframework.validation.annotation.Validated;  
import org.springframework.web.bind.MethodArgumentNotValidException;  
import org.springframework.web.bind.annotation.*;  
  
@RestController  
@RequestMapping("/api/announcements")  
@Validated  
public class AnnouncementController {  
  
    // ... 省略其他代码 ...  
  
    @PostMapping  
    public ResponseEntity<Announcement> createAnnouncement(@RequestBody @Valid AnnouncementRequest request) {  
        // ... 省略其他代码 ...  
    }  
  
    @ExceptionHandler(MethodArgumentNotValidException.class)  
    public ResponseEntity<Object> handleValidationExceptions(MethodArgumentNotValidException ex) {  
        // 提取验证错误并返回给客户端  
        BindingResult result = ex.getBindingResult();  
        List<FieldError> fieldErrors = result.getFieldErrors();  
          
        // 这里只是简单地将错误信息作为字符串返回，实际应用中可能需要更复杂的结构  
        String errorMessage = fieldErrors.stream()  
                .map(FieldError::getDefaultMessage)  
                .collect(Collectors.joining(", "));  
  
        return new ResponseEntity<>(errorMessage, HttpStatus.BAD_REQUEST);  
    }  
}

9. 权限控制

我们可以使用Spring Security来实现权限控制。以下是一个简单的示例，它要求所有/api/announcements的端点都需要认证。

首先，添加Spring Security依赖到你的pom.xml（Maven）或build.gradle（Gradle）文件中。

然后，配置Spring Security：

import org.springframework.context.annotation.Configuration;  
import org.springframework.security.config.annotation.web.builders.HttpSecurity;  
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;  
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;  
  
@Configuration  
@EnableWebSecurity  
public class SecurityConfig extends WebSecurityConfigurerAdapter {  
  
    @Override  
    protected void configure(HttpSecurity http) throws Exception {  
        http  
            .authorizeRequests()  
                .antMatchers("/api/announcements/**").authenticated() // 所有/api/announcements的端点都需要认证  
                .anyRequest().permitAll() // 其他端点允许所有访问（仅用于示例）  
            .and()  
            .httpBasic(); // 使用HTTP Basic认证（仅用于示例，实际中可能使用其他方式）  
    }  
  
    // 可以添加其他配置，如用户详情服务、密码编码器等  
}

注意：上面的示例使用了HTTP Basic认证，这仅用于演示目的。在实际应用中，我们可以使用更复杂的认证机制，如OAuth2、JWT等。

此外，在实际运用过程中，我们可能还需要定义用户、角色和权限之间的关系，并在控制器或服务层中检查用户的权限。这通常涉及使用Spring Security的注解（如@PreAuthorize、@Secured等）或编程式安全。

10.集成测试示例

为了验证上述功能，我们可以编写一个集成测试用例，该测试将模拟HTTP请求并检查响应。在这个例子中，我们将使用Spring Boot Test、Spring Security Test以及Mockito（可选的，如果我们需要模拟服务层）来编写测试用例。

以下是一个简化的测试用例，用于验证异常处理、验证和权限控制：

import org.junit.jupiter.api.Test;  
import org.junit.jupiter.api.extension.ExtendWith;  
import org.mockito.InjectMocks;  
import org.mockito.MockitoAnnotations;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;  
import org.springframework.boot.test.mock.mockito.MockBean;  
import org.springframework.http.MediaType;  
import org.springframework.security.test.context.support.WithMockUser;  
import org.springframework.test.context.junit.jupiter.SpringExtension;  
import org.springframework.test.web.servlet.MockMvc;  
  
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;  
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;  
  
@ExtendWith(SpringExtension.class)  
@WebMvcTest(AnnouncementController.class) // 假设AnnouncementController是你的控制器类  
public class AnnouncementControllerTest {  
  
    @Autowired  
    private MockMvc mockMvc;  
  
    @MockBean // 如果需要模拟服务层  
    private AnnouncementService announcementService;  
  
    @InjectMocks // 如果需要注入mock到controller中（这里可能不需要）  
    private AnnouncementController announcementController;  
  
    @Test  
    public void testCreateAnnouncementWithInvalidData() throws Exception {  
        // 创建一个无效的AnnouncementRequest对象（例如，没有title）  
        String invalidJson = "{\"content\":\"Hello, this is an announcement!\"}";  
  
        mockMvc.perform(post("/api/announcements")  
                .contentType(MediaType.APPLICATION_JSON)  
                .content(invalidJson))  
                .andExpect(status().isBadRequest()) // 期望状态码为400  
                .andExpect(jsonPath("$.message").value("Title must not be blank")); // 期望的错误消息  
    }  
  
    @Test  
    @WithMockUser(username = "user", roles = {"USER"}) // 假设USER角色有权限创建公告  
    public void testCreateAnnouncementWithValidDataAndAuthenticatedUser() throws Exception {  
        // 创建一个有效的AnnouncementRequest对象  
        String validJson = "{\"title\":\"Announcement Title\",\"content\":\"Hello, this is an announcement!\"}";  
  
        // 假设服务层的方法返回成功的Announcement对象（如果需要的话，用Mockito模拟它）  
  
        mockMvc.perform(post("/api/announcements")  
                .contentType(MediaType.APPLICATION_JSON)  
                .content(validJson))  
                .andExpect(status().isCreated()); // 期望状态码为201  
    }  
  
    @Test  
    public void testCreateAnnouncementWithValidDataButUnauthenticatedUser() throws Exception {  
        // 创建一个有效的AnnouncementRequest对象  
        String validJson = "{\"title\":\"Announcement Title\",\"content\":\"Hello, this is an announcement!\"}";  
  
        mockMvc.perform(post("/api/announcements")  
                .contentType(MediaType.APPLICATION_JSON)  
                .content(validJson))  
                .andExpect(status().isUnauthorized()); // 期望状态码为401，因为用户未认证  
    }  
  
    // 在@BeforeEach或构造函数中初始化Mockito（如果需要的话）  
    public AnnouncementControllerTest() {  
        MockitoAnnotations.openMocks(this);  
    }  
}

注意：上面的测试用例使用了Spring Boot Test的@WebMvcTest注解，它会自动配置Spring MVC基础设施并禁用完整的应用程序上下文，使得测试运行得更快。@MockBean用于模拟服务层组件（如果需要的话），而@WithMockUser用于在测试期间模拟认证用户。在使用过程中请确保你的项目中已经包含了Spring Boot Test和Spring Security Test的依赖，以便这些注解和类能够正常工作。