• Spring Boot DTO 示例 - 实体到 DTO 的转换

    在本教程中，我们将学习如何在Spring Boot 应用程序中创建 DTO（数据传输对象）类，以及如何使用 ModelMapper 库将实体转换为 DTO，反之亦然。

    数据传输对象设计模式是一种常用的设计模式。它基本上用于一次性将具有多个属性的数据从客户端传递到服务器，以避免多次调用远程服务器。

    在用Java编写的RESTful API上使用DTO（以及在Spring Boot上）的另一个优点是，它们可以帮助隐藏域对象（JPA实体）的实现细节。如果我们不仔细处理可以通过哪些操作更改哪些属性，则通过终结点公开实体可能会成为安全问题。

    让我们从介绍ModelMapper Java库开始，我们将使用它来将实体转换为DTO，反之亦然。

    模型映射器库

    ModelMapper 旨在通过根据约定自动确定一个对象模型如何映射到另一个对象模型，使对象映射变得容易，就像人类一样，同时提供一个简单的、重构安全的 API 来处理特定的用例。
    在ModelMapper - Simple, Intelligent, Object Mapping. 阅读有关模型映射器库的更多信息。

    我们将在pom中需要这种依赖.xml：

    2.     org.modelmapper
    3.     modelmapper
    4.     2.3.5

    第 1 步：将模型映射器库添加到 Pom.xml

    我们将在pom中需要这种依赖.xml：

    2.     org.modelmapper
    3.     modelmapper
    4.     2.3.5

    步骤 2：定义 JPA 实体 - Post.java

    让我们创建一个Post实体类并向其添加以下内容： 
    1. package net.javaguides.springboot.model;
    2.  
    3. import java.util.HashSet;
    4.  
    5. import java.util.Set;
    6.  
    7. import javax.persistence.Column;
    8. import javax.persistence.Entity;
    9. import javax.persistence.GeneratedValue;
    10. import javax.persistence.GenerationType;
    11. import javax.persistence.Id;
    12. import javax.persistence.Table;
    13. import javax.persistence.UniqueConstraint;
    14.  
    15. import lombok.AllArgsConstructor;
    16. import lombok.Data;
    17. import lombok.NoArgsConstructor;
    18.  
    19. @Data
    20. @NoArgsConstructor
    21. @AllArgsConstructor
    22. @Entity
    23. @Table(name = "posts", uniqueConstraints = {@UniqueConstraint(columnNames = {"title"})})
    24. public class Post {
    25. 	
    26. 	@Id  
    27. 	@GeneratedValue(strategy = GenerationType.IDENTITY)
    28. 	private Long id;
    29. 	
    30. 	@Column(name = "title")
    31. 	private String title;
    32. 	
    33. 	@Column(name = "description")
    34. 	private String description;
    35. 	
    36. 	@Column(name = "content")
    37. 	private String content;
    38. }

    步骤 3：定义 DTO 类 - PostDto.java

    让我们创建PostDto类并向其添加以下内容： 
    1. package net.javaguides.springboot.payload;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5.  
    6. import lombok.Data;
    7.  
    8. @Data
    9. public class PostDto {
    10. 	private long id;
    11. 	private String title;
    12. 	private String description;
    13. 	private String content;
    14. }

    仅包含客户端所需的 DTO 类中的那些详细信息。实体和 DTO 字段看起来相同，但您将向客户端添加所需的字段。

    步骤 4：存储库层

    让我们创建一个PostRepository来与Post实体的数据库进行通信： 
    1. package com.springboot.blog.repository;
    2.  
    3. import com.springboot.blog.entity.Post;
    4. import org.springframework.data.jpa.repository.JpaRepository;
    5.  
    6. public interface PostRepository extends JpaRepository {
    7.  
    8. }

    第 5 步：服务层

    在服务层中，我们将只使用Post实体，而不使用PostDto类：

    PostService 接口

    1. package net.javaguides.springboot.service;
    2.  
    3. import java.util.List;
    4.  
    5. import net.javaguides.springboot.model.Post;
    6.  
    7. public interface PostService {
    8. 	List getAllPosts();
    9.  
    10. 	Post createPost(Post post);
    11.  
    12. 	Post updatePost(long id, Post post);
    13.  
    14. 	void deletePost(long id);
    15.  
    16. 	Post getPostById(long id);
    17. }

    PostServiceImpl Class

    1. package net.javaguides.springboot.service.impl;
    2.  
    3. import java.util.List;
    4. import java.util.Optional;
    5.  
    6. import org.springframework.stereotype.Service;
    7.  
    8. import net.javaguides.springboot.exception.ResourceNotFoundException;
    9. import net.javaguides.springboot.model.Post;
    10. import net.javaguides.springboot.repository.PostResository;
    11. import net.javaguides.springboot.service.PostService;
    12.  
    13. @Service
    14. public class PostServiceImpl implements PostService{
    15.  
    16. 	private final PostResository postRepository;
    17. 	
    18. 	public PostServiceImpl(PostResository postRepository) {
    19. 		super();
    20. 		this.postRepository = postRepository;
    21. 	}
    22.  
    23. 	@Override
    24. 	public List getAllPosts() {
    25. 		return postRepository.findAll();
    26. 	}
    27.  
    28. 	@Override
    29. 	public Post createPost(Post post) {
    30. 		return postRepository.save(post);
    31. 	}
    32.  
    33. 	@Override
    34. 	public Post updatePost(long id, Post postRequest) {
    35. 		Post post = postRepository.findById(id)
    36. 				.orElseThrow(() -> new ResourceNotFoundException("Post", "id", id));
    37. 		
    38. 		post.setTitle(postRequest.getTitle());
    39. 		post.setDescription(postRequest.getDescription());
    40. 		post.setContent(postRequest.getContent());
    41. 		return postRepository.save(post);
    42. 	}
    43.  
    44. 	@Override
    45. 	public void deletePost(long id) {
    46. 		Post post = postRepository.findById(id)
    47. 				.orElseThrow(() -> new ResourceNotFoundException("Post", "id", id));
    48. 		
    49. 		postRepository.delete(post);
    50. 	}
    51.  
    52. 	@Override
    53. 	public Post getPostById(long id) {
    54. 		Optional result = postRepository.findById(id);
    55. 		if(result.isPresent()) {
    56. 			return result.get();
    57. 		}else {
    58. 			throw new ResourceNotFoundException("Post", "id", id);
    59. 		}
    60. 		
    61. //		Post post = postRepository.findById(id)
    62. //				.orElseThrow(() -> new ResourceNotFoundException("Post", "id", id));
    63. 		//return post;
    64. 	}
    65. }
    请注意，我们不是在服务层中使用实体到 DTO，反之亦然。

    步骤 6：将 ModelMapper 类配置为 Spring Bean

    让我们将ModelMapper类配置为 Spring bean，以便我们可以将其注入到控制器类中： 
    1. package net.javaguides.springboot;
    2.  
    3. import org.modelmapper.ModelMapper;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. import org.springframework.context.annotation.Bean;
    7.  
    8. @SpringBootApplication
    9. public class SpringbootBlogApiApplication {
    10.  
    11. 	@Bean
    12. 	public ModelMapper modelMapper() {
    13. 		return new ModelMapper();
    14. 	}
    15. 	
    16. 	public static void main(String[] args) {
    17. 		SpringApplication.run(SpringbootBlogApiApplication.class, args);
    18. 	}
    19.  
    20. }

    步骤 7：控制器层

    在下面的PostController类中，我们注入了ModelMapper类，并在不同的REST API中将其用于实体到DTO的转换，反之亦然： 
    1. package net.javaguides.springboot.contoller;
    2.  
    3. import java.util.List;
    4. import java.util.stream.Collectors;
    5.  
    6. import org.modelmapper.ModelMapper;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.http.HttpStatus;
    9. import org.springframework.http.ResponseEntity;
    10. import org.springframework.web.bind.annotation.DeleteMapping;
    11. import org.springframework.web.bind.annotation.GetMapping;
    12. import org.springframework.web.bind.annotation.PathVariable;
    13. import org.springframework.web.bind.annotation.PostMapping;
    14. import org.springframework.web.bind.annotation.PutMapping;
    15. import org.springframework.web.bind.annotation.RequestBody;
    16. import org.springframework.web.bind.annotation.RequestMapping;
    17. import org.springframework.web.bind.annotation.RestController;
    18.  
    19. import net.javaguides.springboot.model.Post;
    20. import net.javaguides.springboot.payload.ApiResponse;
    21. import net.javaguides.springboot.payload.PostDto;
    22. import net.javaguides.springboot.service.PostService;
    23.  
    24. @RestController
    25. @RequestMapping("/api/posts")
    26. public class PostController {
    27.  
    28. 	@Autowired
    29. 	private ModelMapper modelMapper;
    30.  
    31. 	private PostService postService;
    32.  
    33. 	public PostController(PostService postService) {
    34. 		super();
    35. 		this.postService = postService;
    36. 	}
    37.  
    38. 	@GetMapping
    39. 	public List getAllPosts() {
    40.  
    41. 		return postService.getAllPosts().stream().map(post -> modelMapper.map(post, PostDto.class))
    42. 				.collect(Collectors.toList());
    43. 	}
    44.  
    45. 	@GetMapping("/{id}")
    46. 	public ResponseEntity getPostById(@PathVariable(name = "id") Long id) {
    47. 		Post post = postService.getPostById(id);
    48.  
    49. 		// convert entity to DTO
    50. 		PostDto postResponse = modelMapper.map(post, PostDto.class);
    51.  
    52. 		return ResponseEntity.ok().body(postResponse);
    53. 	}
    54.  
    55. 	@PostMapping
    56. 	public ResponseEntity createPost(@RequestBody PostDto postDto) {
    57.  
    58. 		// convert DTO to entity
    59. 		Post postRequest = modelMapper.map(postDto, Post.class);
    60.  
    61. 		Post post = postService.createPost(postRequest);
    62.  
    63. 		// convert entity to DTO
    64. 		PostDto postResponse = modelMapper.map(post, PostDto.class);
    65.  
    66. 		return new ResponseEntity(postResponse, HttpStatus.CREATED);
    67. 	}
    68.  
    69. 	// change the request for DTO
    70. 	// change the response for DTO
    71. 	@PutMapping("/{id}")
    72. 	public ResponseEntity updatePost(@PathVariable long id, @RequestBody PostDto postDto) {
    73.  
    74. 		// convert DTO to Entity
    75. 		Post postRequest = modelMapper.map(postDto, Post.class);
    76.  
    77. 		Post post = postService.updatePost(id, postRequest);
    78.  
    79. 		// entity to DTO
    80. 		PostDto postResponse = modelMapper.map(post, PostDto.class);
    81.  
    82. 		return ResponseEntity.ok().body(postResponse);
    83. 	}
    84.  
    85. 	@DeleteMapping("/{id}")
    86. 	public ResponseEntity deletePost(@PathVariable(name = "id") Long id) {
    87. 		postService.deletePost(id);
    88. 		ApiResponse apiResponse = new ApiResponse(Boolean.TRUE, "Post deleted successfully", HttpStatus.OK);
    89. 		return new ResponseEntity(apiResponse, HttpStatus.OK);
    90. 	}
    91. }
    我们在createPost（）方法中使用ModelMapper将实体转换为DTO，反之亦然： 
            @PostMapping
	public ResponseEntity createPost(@RequestBody PostDto postDto) {

		// convert DTO to entity
		Post postRequest = modelMapper.map(postDto, Post.class);

		Post post = postService.createPost(postRequest);

		// convert entity to DTO
		PostDto postResponse = modelMapper.map(post, PostDto.class);

		return new ResponseEntity(postResponse, HttpStatus.CREATED);
	}
    我们在更新Post（） 方法中使用 ModelMapper 将实体转换为 DTO，反之亦然： 
    	// change the request for DTO
	// change the response for DTO
	@PutMapping("/{id}")
	public ResponseEntity updatePost(@PathVariable long id, @RequestBody PostDto postDto) {

		// convert DTO to Entity
		Post postRequest = modelMapper.map(postDto, Post.class);

		Post post = postService.updatePost(id, postRequest);

		// entity to DTO
		PostDto postResponse = modelMapper.map(post, PostDto.class);

		return ResponseEntity.ok().body(postResponse);
	}
    我们在 getPostById（） 方法中使用 ModelMapper 将实体转换为 DTO，反之亦然： 
    	@GetMapping("/{id}")
	public ResponseEntity getPostById(@PathVariable(name = "id") Long id) {
		Post post = postService.getPostById(id);

		// convert entity to DTO
		PostDto postResponse = modelMapper.map(post, PostDto.class);

		return ResponseEntity.ok().body(postResponse);
	}
    我们在getAllPosts（）方法中使用ModelMapper将实体转换为DTO，反之亦然： 
            @GetMapping
	public List getAllPosts() {

		return postService.getAllPosts().stream().map(post -> modelMapper.map(post, PostDto.class))
				.collect(Collectors.toList());
	}

    结论

    本教程演示了如何在 Spring 引导 REST API 项目中执行从实体到 DTO 以及从 DTO 到实体的转换。我们使用了模型映射器库，而不是手动编写这些转换。

    引用

  • 相关阅读:
    Three光线投射实例
    Vite+React搭建开发构建环境实践
    Promise异步编程
    音频的各项指标
    有车型(CarModel)，车厂（CarFactory），经销商(Distributor)三个表
    Shiro：中的filterChainDefinitions详解。
    JavaScript
    电脑怎么截图，4种简单常用的截图方法
    C++编程常见错误及处理
    RichView TRVUnits 图像显示单位
  • 原文地址：https://blog.csdn.net/allway2/article/details/127786646