ToB企服应用市场:ToB评测及商务社交产业平台

标题: MJGA，让 Java 再次伟大，开箱即用 Spring Boot 怕不怕 Gin？ [打印本页]
作者: 用户云卷云舒    时间: 2024-11-28 13:04
标题: MJGA，让 Java 再次伟大，开箱即用 Spring Boot 怕不怕 Gin？
泉源：juejin.cn/post/7245942451105562685
媒介

隔壁组的云盘算零零后女同事，后文简称 云女士 ，非说 Go 的 Gin 框架比 Springboot 更加的开箱即用，我心想在 Java 内里 Springboot 已经打遍天下无对手，这份秘闻岂是 Gin 能比。
但是云女士突出一个执拗，非我要 PK 一把， PK 内容就是她使用 Gin，而我使用 Springboot 快速搭建一个简单的 Crud 工程，最后让其他同事来评判哪个更开箱即用。我毫不犹豫就允许了，作为搭建 Springboot 学习工程的资深 Crud 选手，咱这份底气还是有的。
云女士选择使用 Gin + Gorm 来搭建，而我原本想选择 Springboot + MyBatis，后面转念一想，这 MyBatis 要写 XML 文件，指不定就由于这个被云女士嘲笑了，所以我把 MyBatis 替换为了 MyBatis-Plus，这就富足的简洁了吧。
正文

准备事项

既然是 Crud 工程，自然要准备好操作的表，我和云女士通过如下语句在各自的数据库中创建好了如下两张表。
  1. CREATE TABLE people (
  2.     id INT(11) PRIMARY KEY AUTO_INCREMENT,
  3.     p_name VARCHAR(255) NOT NULL,
  4.     p_age INT(11) NOT NULL
  5. )
  7. CREATE TABLE book (
  8.     id INT(11) PRIMARY KEY AUTO_INCREMENT,
  9.     b_name VARCHAR(255) NOT NULL,
  10.     b_price FLOAT NOT NULL
  11. )
复制代码
Gin快速搭建Crud工程

云女士的工程布局如下所示。

云女士的 go.mod 文件内容如下所示。
  1. module gobase
  3. go 1.17
  5. require (
  6.     github.com/gin-gonic/gin v1.6.0
  7.     github.com/jinzhu/gorm v1.9.16
  8.     github.com/sirupsen/logrus v1.9.3
  9.     github.com/spf13/cast v1.5.1
  10. )
复制代码
云女士定义了两个布局体作为模型（ Model ），book.go 文件内容如下所示。
  1. package model
  3. const (
  4.     BookTableName = "book"
  5. )
  7. type Book struct {
  8.     ID int64 `gorm:"column:id"`
  9.     BookName string `gorm:"column:b_name"`
  10.     BookPrice float64 `gorm:"column:b_price"`
  11. }
  13. func (b *Book) TableName() string {
  14.     return BookTableName
  15. }
复制代码
people.go 文件内容如下所示。
  1. package model
  3. const (
  4.     PeopleTableName = "people"
  5. )
  7. type People struct {
  8.     ID int64 `gorm:"column:id"`
  9.     PeopleName string `gorm:"column:p_name"`
  10.     PeopleAge int64 `gorm:"column:p_age"`
  11. }
  13. func (p *People) TableName() string {
  14.     return PeopleTableName
  15. }
复制代码
云女士增补道，TableName()方法是为模型指定对应的表名。
云女士为 book 表和 people 表分别定义了 Dao 接口，dao.go 文件内容如下所示。
  1. package dao
  3. import "gobase/model"
  5. type BookDao interface {
  6.     AddBook(book *model.Book) error
  7.     UpdateBook(book *model.Book) error
  8.     DeleteBook(book *model.Book) error
  9.     ListBookById(id uint) (*model.Book, error)
  10. }
  12. type PeopleDao interface {
  13.     AddPeople(book *model.People) error
  14.     UpdatePeople(book *model.People) error
  15.     DeletePeople(book *model.People) error
  16.     ListPeopleById(id uint) (*model.People, error)
  17. }
复制代码
BookDao 接口对应的实现在book_dao_impl.go文件中，实现如下。
  1. package dao
  3. import (
  4.     "github.com/jinzhu/gorm"
  5.     "gobase/model"
  6. )
  8. type BookDaoImpl struct {
  9.     DB *gorm.DB
  10. }
  12. func (b *BookDaoImpl) AddBook(book *model.Book) error {
  13.     if createResult := b.DB.Create(book); createResult.Error != nil {
  14.         return createResult.Error
  15.     }
  16.     return nil
  17. }
  19. func (b *BookDaoImpl) UpdateBook(book *model.Book) error {
  20.     if saveResult := b.DB.Save(book); saveResult.Error != nil {
  21.         return saveResult.Error
  22.     }
  23.     return nil
  24. }
  26. func (b *BookDaoImpl) DeleteBook(book *model.Book) error {
  27.     if deleteResult := b.DB.Delete(book); deleteResult.Error != nil {
  28.         return deleteResult.Error
  29.     }
  30.     return nil
  31. }
  33. func (b *BookDaoImpl) ListBookById(id uint) (*model.Book, error) {
  34.     var book model.Book
  35.     if listResult := b.DB.Where("id = ?", id).First(&book); listResult.Error != nil {
  36.         return nil, listResult.Error
  37.     }
  38.     return &book, nil
  39. }
复制代码
PeopleDao 接口对应的实现在people_dao_impl.go文件中，实现如下。
  1. package dao
  3. import (
  4.     "github.com/jinzhu/gorm"
  5.     "gobase/model"
  6. )
  8. type PeopleDaoImpl struct {
  9.     DB *gorm.DB
  10. }
  12. func (b *PeopleDaoImpl) AddPeople(people *model.People) error {
  13.     if createResult := b.DB.Create(people); createResult.Error != nil {
  14.         return createResult.Error
  15.     }
  16.     return nil
  17. }
  19. func (b *PeopleDaoImpl) UpdatePeople(people *model.People) error {
  20.     if saveResult := b.DB.Save(people); saveResult.Error != nil {
  21.         return saveResult.Error
  22.     }
  23.     return nil
  24. }
  26. func (b *PeopleDaoImpl) DeletePeople(people *model.People) error {
  27.     if deleteResult := b.DB.Delete(people); deleteResult.Error != nil {
  28.         return deleteResult.Error
  29.     }
  30.     return nil
  31. }
  33. func (b *PeopleDaoImpl) ListPeopleById(id uint) (*model.People, error) {
  34.     var people model.People
  35.     if listResult := b.DB.Where("id = ?", id).First(&people); listResult.Error != nil {
  36.         return nil, listResult.Error
  37.     }
  38.     return &people, nil
  39. }
复制代码
要操作数据库，肯定需要数据库毗连，云女士将数据库毗连的管理实现在了mysql_connection_pool.go文件中，内容如下所示。
  1. package mysql
  3. import (
  4.     "fmt"
  5.     "github.com/jinzhu/gorm"
  6.     "gobase/dao"
  7.     "log"
  8.     "time"
  9. )
  11. const (
  12.     UserName     = "root"
  13.     PassWord     = "root"
  14.     Host         = "192.168.101.8"
  15.     Port         = 3306
  16.     Database     = "gotest"
  17.     MaxLifetime  = 60 * time.Second
  18.     MaxIdletime  = 30 * time.Second
  19.     MaxOpenconns = 6
  20.     MaxIdleconns = 2
  21.     Dialect      = "mysql"
  22. )
  24. type DataSouce struct {
  25.     db      *gorm.DB
  26. }
  28. func NewDataSource() *DataSouce {
  29.     var db *gorm.DB
  31.     dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Asia%%2FShanghai",
  32.             UserName, PassWord, Host, Port, Database)
  33.     db, err := gorm.Open(Dialect, dsn)
  34.     if err != nil {
  35.         log.Fatal(err.Error())
  36.     }
  38.     db.DB().SetConnMaxLifetime(MaxLifetime)
  39.     db.DB().SetConnMaxIdleTime(MaxIdletime)
  40.     db.DB().SetMaxOpenConns(MaxOpenconns)
  41.     db.DB().SetMaxOpenConns(MaxIdleconns)
  43.     return &DataSouce{
  44.         db: db,
  45.     }
  46. }
  48. // BookDao 操作book表
  49. func (d *DataSouce) BookDao() dao.BookDao {
  50.     return &dao.BookDaoImpl{
  51.         DB: d.db,
  52.     }
  53. }
  55. // PeopleDao 操作people表
  56. func (d *DataSouce) PeopleDao() dao.PeopleDao {
  57.     return &dao.PeopleDaoImpl{
  58.         DB: d.db,
  59.     }
  60. }
复制代码
云女士将路由写在了webservice.go文件中，内容如下。
  1. package adapter
  3. import (
  4.     "github.com/gin-gonic/gin"
  5.     "gobase/mysql"
  6. )
  8. func Init() error {
  9.     dataSouce := mysql.NewDataSource()
  11.     bookController := NewBookController(dataSouce)
  12.     propleController := NewPropleController(dataSouce)
  14.     engine := gin.Default()
  15.     routerGroupBook := engine.Group("/book")
  16.     routerGroupBook.POST("/add", bookController.AddBook)
  17.     routerGroupBook.POST("/update", bookController.UpdateBook)
  18.     routerGroupBook.POST("/delete", bookController.DeleteBook)
  19.     routerGroupBook.POST("/list", bookController.ListBookById)
  21.     routerGroupPeople := engine.Group("/people")
  22.     routerGroupPeople.POST("/add", propleController.AddPeople)
  23.     routerGroupPeople.POST("/update", propleController.UpdatePeople)
  24.     routerGroupPeople.POST("/delete", propleController.DeletePeople)
  25.     routerGroupPeople.POST("/list", propleController.ListPeopleById)
  27.     return engine.Run()
  28. }
复制代码
其实除了绑定路由，云女士还在Init()函数中进行了简单的服务注入，也就是创建数据库毗连池，然后将数据库毗连池给到对应的 web 服务。
云女士将操作 book 表对应的 web 服务写在了book_controller.go文件中，其实现如下所示。
  1. package adapter
  3. import (
  4.     "github.com/gin-gonic/gin"
  5.     "github.com/sirupsen/logrus"
  6.     "github.com/spf13/cast"
  7.     "gobase/model"
  8.     "gobase/mysql"
  9.     "net/http"
  10. )
  12. type BookController struct {
  13.     dataSource *mysql.DataSouce
  14. }
  16. func NewBookController(dataSource *mysql.DataSouce) BookController {
  17.     return BookController{
  18.         dataSource: dataSource,
  19.     }
  20. }
  22. func (b *BookController) AddBook(ctx *gin.Context) {
  23.     var book model.Book
  24.     if err := ctx.ShouldBind(&book); err != nil {
  25.         logrus.Error("读取Book信息失败")
  26.         ctx.JSON(http.StatusInternalServerError, gin.H{
  27.             "message": "failed",
  28.         })
  29.         return
  30.     }
  31.     bookDao := b.dataSource.BookDao()
  32.     err := bookDao.AddBook(&book)
  33.     if err != nil {
  34.         logrus.Error("添加Book失败", err)
  35.         ctx.JSON(http.StatusInternalServerError, gin.H{
  36.             "message": "failed",
  37.         })
  38.         return
  39.     }
  40.     ctx.JSON(http.StatusOK, gin.H{
  41.         "message": "success",
  42.     })
  43. }
  45. func (b *BookController) UpdateBook(ctx *gin.Context) {
  46.     var book model.Book
  47.     if err := ctx.ShouldBind(&book); err != nil {
  48.         logrus.Error("读取Book信息失败")
  49.         ctx.JSON(http.StatusInternalServerError, gin.H{
  50.             "message": "failed",
  51.         })
  52.         return
  53.     }
  54.     bookDao := b.dataSource.BookDao()
  55.     err := bookDao.UpdateBook(&book)
  56.     if err != nil {
  57.         logrus.Error("更新Book失败", err)
  58.         ctx.JSON(http.StatusInternalServerError, gin.H{
  59.             "message": "failed",
  60.         })
  61.         return
  62.     }
  63.     ctx.JSON(http.StatusOK, gin.H{
  64.         "message": "success",
  65.     })
  66. }
  68. func (b *BookController) DeleteBook(ctx *gin.Context) {
  69.     var book model.Book
  70.     if err := ctx.ShouldBind(&book); err != nil {
  71.         logrus.Error("读取Book信息失败")
  72.         ctx.JSON(http.StatusInternalServerError, gin.H{
  73.             "message": "failed",
  74.         })
  75.         return
  76.     }
  77.     bookDao := b.dataSource.BookDao()
  78.     err := bookDao.DeleteBook(&book)
  79.     if err != nil {
  80.         logrus.Error("删除Book失败", err)
  81.         ctx.JSON(http.StatusInternalServerError, gin.H{
  82.             "message": "failed",
  83.         })
  84.         return
  85.     }
  86.     ctx.JSON(http.StatusOK, gin.H{
  87.         "message": "success",
  88.     })
  89. }
  91. func (b *BookController) ListBookById(ctx *gin.Context) {
  92.     id := cast.ToUint(ctx.Query("id"))
  93.     bookDao := b.dataSource.BookDao()
  94.     book, err := bookDao.ListBookById(id)
  95.     if err != nil {
  96.         logrus.Error("查询Book失败", err)
  97.         ctx.JSON(http.StatusInternalServerError, gin.H{
  98.             "message": "failed",
  99.         })
  100.         return
  101.     }
  102.     ctx.JSON(http.StatusOK, book)
  103. }
复制代码
云女士将操作 people 表对应的 web 服务写在了people_controller.go文件中，其实现如下所示。
  1. package adapter
  3. import (
  4.     "github.com/gin-gonic/gin"
  5.     "github.com/sirupsen/logrus"
  6.     "github.com/spf13/cast"
  7.     "gobase/model"
  8.     "gobase/mysql"
  9.     "net/http"
  10. )
  12. type PeopleController struct {
  13.     dataSource *mysql.DataSouce
  14. }
  16. func NewPropleController(dataSource *mysql.DataSouce) PeopleController {
  17.     return PeopleController{
  18.         dataSource: dataSource,
  19.     }
  20. }
  22. func (p *PeopleController) AddPeople(ctx *gin.Context) {
  23.     var people model.People
  24.     if err := ctx.ShouldBind(&people); err != nil {
  25.         logrus.Error("读取People信息失败")
  26.         ctx.JSON(http.StatusInternalServerError, gin.H{
  27.             "message": "failed",
  28.         })
  29.         return
  30.     }
  31.     peopleDao := p.dataSource.PeopleDao()
  32.     err := peopleDao.AddPeople(&people)
  33.     if err != nil {
  34.         logrus.Error("添加People失败", err)
  35.         ctx.JSON(http.StatusInternalServerError, gin.H{
  36.             "message": "failed",
  37.         })
  38.         return
  39.     }
  40.     ctx.JSON(http.StatusOK, gin.H{
  41.         "message": "success",
  42.     })
  43. }
  45. func (p *PeopleController) UpdatePeople(ctx *gin.Context) {
  46.     var people model.People
  47.     if err := ctx.ShouldBind(&people); err != nil {
  48.         logrus.Error("读取People信息失败")
  49.         ctx.JSON(http.StatusInternalServerError, gin.H{
  50.             "message": "failed",
  51.         })
  52.         return
  53.     }
  54.     peopleDao := p.dataSource.PeopleDao()
  55.     err := peopleDao.UpdatePeople(&people)
  56.     if err != nil {
  57.         logrus.Error("更新People失败", err)
  58.         ctx.JSON(http.StatusInternalServerError, gin.H{
  59.             "message": "failed",
  60.         })
  61.         return
  62.     }
  63.     ctx.JSON(http.StatusOK, gin.H{
  64.         "message": "success",
  65.     })
  66. }
  68. func (p *PeopleController) DeletePeople(ctx *gin.Context) {
  69.     var people model.People
  70.     if err := ctx.ShouldBind(&people); err != nil {
  71.         logrus.Error("读取People信息失败")
  72.         ctx.JSON(http.StatusInternalServerError, gin.H{
  73.             "message": "failed",
  74.         })
  75.         return
  76.     }
  77.     peopleDao := p.dataSource.PeopleDao()
  78.     err := peopleDao.DeletePeople(&people)
  79.     if err != nil {
  80.         logrus.Error("删除People失败", err)
  81.         ctx.JSON(http.StatusInternalServerError, gin.H{
  82.             "message": "failed",
  83.         })
  84.         return
  85.     }
  86.     ctx.JSON(http.StatusOK, gin.H{
  87.         "message": "success",
  88.     })
  89. }
  91. func (p *PeopleController) ListPeopleById(ctx *gin.Context) {
  92.     id := cast.ToUint(ctx.Query("id"))
  93.     peopleDao := p.dataSource.PeopleDao()
  94.     people, err := peopleDao.ListPeopleById(id)
  95.     if err != nil {
  96.         logrus.Error("查询People失败", err)
  97.         ctx.JSON(http.StatusInternalServerError, gin.H{
  98.             "message": "failed",
  99.         })
  100.         return
  101.     }
  102.     ctx.JSON(http.StatusOK, people)
  103. }
复制代码
最后，云女士简单的展示了一下对 book 表和 prople 表的 Crud 操作。
book 表和 people 表的增删改成功时返回内容如下所示。

book 表和 people 表的查询成功时返回内容如下所示。


Spring boot 快速搭建Crud工程

Spring Boot 基础就不介绍了，推荐看这个实战项目：
https://github.com/javastacks/spring-boot-best-practice
云女士基于 Gin 和 Gorm 搭建的 Crud 工程，我看完后内心扑哧一笑：不外如此。
那现在该轮到我表演了。首先给出整个工程布局图如下所示。

POM 文件内容如下所示。
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <parent>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-parent</artifactId>
  10.         <version>2.4.1</version>
  11.     </parent>
  13.     <groupId>com.lee.javabase</groupId>
  14.     <artifactId>javabase</artifactId>
  15.     <version>1.0-SNAPSHOT</version>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>org.springframework.boot</groupId>
  20.             <artifactId>spring-boot-starter-web</artifactId>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-jdbc</artifactId>
  25.         </dependency>
  27.         <dependency>
  28.             <groupId>com.baomidou</groupId>
  29.             <artifactId>mybatis-plus-boot-starter</artifactId>
  30.             <version>3.1.0</version>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>mysql</groupId>
  34.             <artifactId>mysql-connector-java</artifactId>
  35.             <version>8.0.16</version>
  36.         </dependency>
  38.         <dependency>
  39.             <groupId>org.projectlombok</groupId>
  40.             <artifactId>lombok</artifactId>
  41.         </dependency>
  42.     </dependencies>
  44. </project>
复制代码
同样，定义 book 表和 people 表对应的实体类 Book 和 People，如下所示。
  1. @Getter
  2. @Setter
  3. public class Book {
  4.     @TableField("id")
  5.     private int id;
  7.     @TableField("b_name")
  8.     private String bookName;
  9.     @TableField("b_price")
  10.     private float bookPrice;
  12. }
  14. @Getter
  15. @Setter
  16. public class People {
  18.     @TableField("id")
  19.     private int id;
  21.     @TableField("p_name")
  22.     private String peopleName;
  23.     @TableField("p_age")
  24.     private int peopleAge;
  26. }
复制代码
然后定义定义接口，如下所示。
  1. @Mapper
  2. public interface BookMapper extends BaseMapper<Book> {
  3. }
  5. @Mapper
  6. public interface PeopleMapper extends BaseMapper<People> {
  7. }
复制代码
最后是对应的 Controller 实现， BookController 实现如下。
  1. @Slf4j
  2. @RestController
  3. @RequestMapping("/book")
  4. public class BookController {
  6.     @Autowired
  7.     private BookMapper bookMapper;
  9.     @PostMapping("/add")
  10.     public ResponseEntity<String> addBook(@RequestBody Book book) {
  11.         try {
  12.             bookMapper.insert(book);
  13.             return new ResponseEntity<>("添加图书成功", HttpStatus.OK);
  14.         } catch (Exception e) {
  15.             log.error("添加图书失败", e);
  16.             return new ResponseEntity<>("添加图书失败", HttpStatus.INTERNAL_SERVER_ERROR);
  17.         }
  18.     }
  20.     @PostMapping("/update")
  21.     public ResponseEntity<String> updateBook(@RequestBody Book book) {
  22.         try {
  23.             bookMapper.updateById(book);
  24.             return new ResponseEntity<>("更新图书成功", HttpStatus.OK);
  25.         } catch (Exception e) {
  26.             log.error("更新图书失败", e);
  27.             return new ResponseEntity<>("更新图书失败", HttpStatus.INTERNAL_SERVER_ERROR);
  28.         }
  29.     }
  31.     @PostMapping("/delete")
  32.     public ResponseEntity<String> deleteBook(@RequestParam("id") int id) {
  33.         try {
  34.             bookMapper.deleteById(id);
  35.             return new ResponseEntity<>("删除图书成功", HttpStatus.OK);
  36.         } catch (Exception e) {
  37.             log.error("删除图书失败", e);
  38.             return new ResponseEntity<>("删除图书失败", HttpStatus.INTERNAL_SERVER_ERROR);
  39.         }
  40.     }
  42.     @PostMapping("/list")
  43.     public ResponseEntity<Book> listBook(@RequestParam("id") int id) {
  44.         try {
  45.             Book book = bookMapper.selectById(id);
  46.             return new ResponseEntity<>(book, HttpStatus.OK);
  47.         } catch (Exception e) {
  48.             log.error("查询图书失败", e);
  49.             return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
  50.         }
  51.     }
  52. }
复制代码
PeopleController 实现如下所示。
  1. @Slf4j
  2. @RestController
  3. @RequestMapping("/people")
  4. public class PeopleController {
  6.     @Autowired
  7.     private PeopleMapper peopleMapper;
  9.     @PostMapping("/add")
  10.     public ResponseEntity<String> addPeople(@RequestBody People people) {
  11.         try {
  12.             peopleMapper.insert(people);
  13.             return new ResponseEntity<>("添加人物成功", HttpStatus.OK);
  14.         } catch (Exception e) {
  15.             log.error("添加人物失败", e);
  16.             return new ResponseEntity<>("添加人物失败", HttpStatus.INTERNAL_SERVER_ERROR);
  17.         }
  18.     }
  20.     @PostMapping("/update")
  21.     public ResponseEntity<String> updatePeople(@RequestBody People people) {
  22.         try {
  23.             peopleMapper.updateById(people);
  24.             return new ResponseEntity<>("更新人物成功", HttpStatus.OK);
  25.         } catch (Exception e) {
  26.             log.error("更新人物失败", e);
  27.             return new ResponseEntity<>("更新人物失败", HttpStatus.INTERNAL_SERVER_ERROR);
  28.         }
  29.     }
  31.     @PostMapping("/delete")
  32.     public ResponseEntity<String> deletePeople(@RequestParam("id") int id) {
  33.         try {
  34.             peopleMapper.deleteById(id);
  35.             return new ResponseEntity<>("删除人物成功", HttpStatus.OK);
  36.         } catch (Exception e) {
  37.             log.error("删除人物失败", e);
  38.             return new ResponseEntity<>("删除人物失败", HttpStatus.INTERNAL_SERVER_ERROR);
  39.         }
  40.     }
  42.     @PostMapping("/list")
  43.     public ResponseEntity<People> listPeople(@RequestParam("id") int id) {
  44.         try {
  45.             People people = peopleMapper.selectById(id);
  46.             return new ResponseEntity<>(people, HttpStatus.OK);
  47.         } catch (Exception e) {
  48.             log.error("查询人物失败", e);
  49.             return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
  50.         }
  51.     }
  52. }
复制代码
启动应用步伐， book 表的 Crud 操作效果如下所示。

prople 表的 Crud 操作效果如下所示。

总结

我公布，Springboot 就是快速搭建 Crud 工程的神。
其实，在基于 Gin 和 Gorm 搭建 Crud 工程时，云女士还是写得复杂了一点，但是我有幸看过她们云平台的项目的代码，云女士写得也没毛病，虽然是个简化版，但也是严酷服从她们项目的代码布局来实现的。
说回 Springboot，毫无疑问，无论是天然自带 Tomcat 或 Jetty ，还是和三方框架整合的各种 Starter 包，Springboot 都将开箱即用做到了极致，但是转念又一想，其实 Springboot 和 Gin 严酷来说做比力没啥意义，就像 Java 和 Go 的比力一样，我觉得也没啥意义，各自的优势区间不一样，而且各自也都在相关的领域叱咤风云。
各位看官，你们觉得呢。
更多文章推荐：
1.Spring Boot 3.x 教程，太全了！
2.2,000+ 道 Java面试题及答案整理(2024最新版)
3.免费获取 IDEA 激活码的 7 种方式（2024最新版）
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4