MJGA,让Java再次伟大,开箱即用Springboot怕不怕Gin?

一个全新设计的 Java 脚手架;一副崭新的 Java 生态蓝图;一门现代化的 Java 编程哲学。 一个值得与 IntelliJ IDEA 配套的现代 Java 脚手架,你的专属生产力工具。 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

5229360aaae76e30eb4d06e98bfb2f06.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能:

  • Boot 仓库:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源:juejin.cn/post/
7245942451105562685

62ba529dd744f7cdbd5e98ecb980ca96.jpeg


前言

隔壁组的云计算零零后女同事,后文简称 云女士 ,非说 Go 的 Gin 框架比 Springboot 更加的开箱即用,我心想在 Java 里面 Springboot 已经打遍天下无敌手,这份底蕴岂是 Gin 能比。

但是云女士突出一个执拗,非我要 PK 一把, PK 内容就是她使用 Gin,而我使用 Springboot 快速搭建一个简单的 Crud 工程,最后让其他同事来评判哪个更开箱即用。我毫不犹豫就答应了,作为搭建 Springboot 学习工程的资深 Crud 选手,咱这份底气还是有的。

云女士选择使用 Gin + Gorm 来搭建,而我原本想选择 Springboot + MyBatis,后面转念一想,这 MyBatis 要写 XML 文件,指不定就因为这个被云女士嘲笑了,所以我把 MyBatis 替换为了 MyBatis-Plus,这就足够的简洁了吧。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

正文

准备事项

既然是 Crud 工程,自然要准备好操作的表,我和云女士通过如下语句在各自的数据库中创建好了如下两张表。

CREATE TABLE people (
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    p_name VARCHAR(255) NOT NULL,
    p_age INT(11) NOT NULL
)

CREATE TABLE book (
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    b_name VARCHAR(255) NOT NULL,
    b_price FLOAT NOT NULL
)

Gin快速搭建Crud工程

云女士的工程结构如下所示。

30ee01102ee95fab00f02fb0b4ed95c5.jpeg
Gin目录结构

云女士的 go.mod 文件内容如下所示。

module gobase

go 1.17

require (
    github.com/gin-gonic/gin v1.6.0
    github.com/jinzhu/gorm v1.9.16
    github.com/sirupsen/logrus v1.9.3
    github.com/spf13/cast v1.5.1
)

云女士定义了两个结构体作为模型( Model ),book.go 文件内容如下所示。

package model

const (
    BookTableName = "book"
)

type Book struct {
    ID int64 `gorm:"column:id"`
    BookName string `gorm:"column:b_name"`
    BookPrice float64 `gorm:"column:b_price"`
}

func (b *Book) TableName() string {
    return BookTableName
}

people.go 文件内容如下所示。

package model

const (
    PeopleTableName = "people"
)

type People struct {
    ID int64 `gorm:"column:id"`
    PeopleName string `gorm:"column:p_name"`
    PeopleAge int64 `gorm:"column:p_age"`
}

func (p *People) TableName() string {
    return PeopleTableName
}

云女士补充道,TableName()方法是为模型指定对应的表名。

云女士为 book 表和 people 表分别定义了 Dao 接口,dao.go 文件内容如下所示。

package dao

import "gobase/model"

type BookDao interface {
    AddBook(book *model.Book) error
    UpdateBook(book *model.Book) error
    DeleteBook(book *model.Book) error
    ListBookById(id uint) (*model.Book, error)
}

type PeopleDao interface {
    AddPeople(book *model.People) error
    UpdatePeople(book *model.People) error
    DeletePeople(book *model.People) error
    ListPeopleById(id uint) (*model.People, error)
}

BookDao 接口对应的实现在book_dao_impl.go文件中,实现如下。

package dao

import (
    "github.com/jinzhu/gorm"
    "gobase/model"
)

type BookDaoImpl struct {
    DB *gorm.DB
}

func (b *BookDaoImpl) AddBook(book *model.Book) error {
    if createResult := b.DB.Create(book); createResult.Error != nil {
        return createResult.Error
    }
    return nil
}

func (b *BookDaoImpl) UpdateBook(book *model.Book) error {
    if saveResult := b.DB.Save(book); saveResult.Error != nil {
        return saveResult.Error
    }
    return nil
}

func (b *BookDaoImpl) DeleteBook(book *model.Book) error {
    if deleteResult := b.DB.Delete(book); deleteResult.Error != nil {
        return deleteResult.Error
    }
    return nil
}

func (b *BookDaoImpl) ListBookById(id uint) (*model.Book, error) {
    var book model.Book
    if listResult := b.DB.Where("id = ?", id).First(&book); listResult.Error != nil {
        return nil, listResult.Error
    }
    return &book, nil
}

PeopleDao 接口对应的实现在people_dao_impl.go文件中,实现如下。

package dao

import (
    "github.com/jinzhu/gorm"
    "gobase/model"
)

type PeopleDaoImpl struct {
    DB *gorm.DB
}

func (b *PeopleDaoImpl) AddPeople(people *model.People) error {
    if createResult := b.DB.Create(people); createResult.Error != nil {
        return createResult.Error
    }
    return nil
}

func (b *PeopleDaoImpl) UpdatePeople(people *model.People) error {
    if saveResult := b.DB.Save(people); saveResult.Error != nil {
        return saveResult.Error
    }
    return nil
}

func (b *PeopleDaoImpl) DeletePeople(people *model.People) error {
    if deleteResult := b.DB.Delete(people); deleteResult.Error != nil {
        return deleteResult.Error
    }
    return nil
}

func (b *PeopleDaoImpl) ListPeopleById(id uint) (*model.People, error) {
    var people model.People
    if listResult := b.DB.Where("id = ?", id).First(&people); listResult.Error != nil {
        return nil, listResult.Error
    }
    return &people, nil
}

要操作数据库,肯定需要数据库连接,云女士将数据库连接的管理实现在了mysql_connection_pool.go文件中,内容如下所示。

package mysql

import (
    "fmt"
    "github.com/jinzhu/gorm"
    "gobase/dao"
    "log"
    "time"
)

const (
    UserName     = "root"
    PassWord     = "root"
    Host         = "192.168.101.8"
    Port         = 3306
    Database     = "gotest"
    MaxLifetime  = 60 * time.Second
    MaxIdletime  = 30 * time.Second
    MaxOpenconns = 6
    MaxIdleconns = 2
    Dialect      = "mysql"
)

type DataSouce struct {
    db      *gorm.DB
}

func NewDataSource() *DataSouce {
    var db *gorm.DB

    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Asia%%2FShanghai",
            UserName, PassWord, Host, Port, Database)
    db, err := gorm.Open(Dialect, dsn)
    if err != nil {
        log.Fatal(err.Error())
    }
    
    db.DB().SetConnMaxLifetime(MaxLifetime)
    db.DB().SetConnMaxIdleTime(MaxIdletime)
    db.DB().SetMaxOpenConns(MaxOpenconns)
    db.DB().SetMaxOpenConns(MaxIdleconns)

    return &DataSouce{
        db: db,
    }
}

// BookDao 操作book表
func (d *DataSouce) BookDao() dao.BookDao {
    return &dao.BookDaoImpl{
        DB: d.db,
    }
}

// PeopleDao 操作people表
func (d *DataSouce) PeopleDao() dao.PeopleDao {
    return &dao.PeopleDaoImpl{
        DB: d.db,
    }
}

云女士将路由写在了webservice.go文件中,内容如下。

package adapter

import (
    "github.com/gin-gonic/gin"
    "gobase/mysql"
)

func Init() error {
    dataSouce := mysql.NewDataSource()

    bookController := NewBookController(dataSouce)
    propleController := NewPropleController(dataSouce)

    engine := gin.Default()
    routerGroupBook := engine.Group("/book")
    routerGroupBook.POST("/add", bookController.AddBook)
    routerGroupBook.POST("/update", bookController.UpdateBook)
    routerGroupBook.POST("/delete", bookController.DeleteBook)
    routerGroupBook.POST("/list", bookController.ListBookById)

    routerGroupPeople := engine.Group("/people")
    routerGroupPeople.POST("/add", propleController.AddPeople)
    routerGroupPeople.POST("/update", propleController.UpdatePeople)
    routerGroupPeople.POST("/delete", propleController.DeletePeople)
    routerGroupPeople.POST("/list", propleController.ListPeopleById)

    return engine.Run()
}

其实除了绑定路由,云女士还在Init()函数中进行了简单的服务注入,也就是创建数据库连接池,然后将数据库连接池给到对应的 web 服务。

云女士将操作 book 表对应的 web 服务写在了book_controller.go文件中,其实现如下所示。

package adapter

import (
    "github.com/gin-gonic/gin"
    "github.com/sirupsen/logrus"
    "github.com/spf13/cast"
    "gobase/model"
    "gobase/mysql"
    "net/http"
)

type BookController struct {
    dataSource *mysql.DataSouce
}

func NewBookController(dataSource *mysql.DataSouce) BookController {
    return BookController{
        dataSource: dataSource,
    }
}

func (b *BookController) AddBook(ctx *gin.Context) {
    var book model.Book
    if err := ctx.ShouldBind(&book); err != nil {
        logrus.Error("读取Book信息失败")
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    bookDao := b.dataSource.BookDao()
    err := bookDao.AddBook(&book)
    if err != nil {
        logrus.Error("添加Book失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, gin.H{
        "message": "success",
    })
}

func (b *BookController) UpdateBook(ctx *gin.Context) {
    var book model.Book
    if err := ctx.ShouldBind(&book); err != nil {
        logrus.Error("读取Book信息失败")
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    bookDao := b.dataSource.BookDao()
    err := bookDao.UpdateBook(&book)
    if err != nil {
        logrus.Error("更新Book失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, gin.H{
        "message": "success",
    })
}

func (b *BookController) DeleteBook(ctx *gin.Context) {
    var book model.Book
    if err := ctx.ShouldBind(&book); err != nil {
        logrus.Error("读取Book信息失败")
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    bookDao := b.dataSource.BookDao()
    err := bookDao.DeleteBook(&book)
    if err != nil {
        logrus.Error("删除Book失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, gin.H{
        "message": "success",
    })
}

func (b *BookController) ListBookById(ctx *gin.Context) {
    id := cast.ToUint(ctx.Query("id"))
    bookDao := b.dataSource.BookDao()
    book, err := bookDao.ListBookById(id)
    if err != nil {
        logrus.Error("查询Book失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, book)
}

云女士将操作 people 表对应的 web 服务写在了people_controller.go文件中,其实现如下所示。

package adapter

import (
    "github.com/gin-gonic/gin"
    "github.com/sirupsen/logrus"
    "github.com/spf13/cast"
    "gobase/model"
    "gobase/mysql"
    "net/http"
)

type PeopleController struct {
    dataSource *mysql.DataSouce
}

func NewPropleController(dataSource *mysql.DataSouce) PeopleController {
    return PeopleController{
        dataSource: dataSource,
    }
}

func (p *PeopleController) AddPeople(ctx *gin.Context) {
    var people model.People
    if err := ctx.ShouldBind(&people); err != nil {
        logrus.Error("读取People信息失败")
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    peopleDao := p.dataSource.PeopleDao()
    err := peopleDao.AddPeople(&people)
    if err != nil {
        logrus.Error("添加People失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, gin.H{
        "message": "success",
    })
}

func (p *PeopleController) UpdatePeople(ctx *gin.Context) {
    var people model.People
    if err := ctx.ShouldBind(&people); err != nil {
        logrus.Error("读取People信息失败")
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    peopleDao := p.dataSource.PeopleDao()
    err := peopleDao.UpdatePeople(&people)
    if err != nil {
        logrus.Error("更新People失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, gin.H{
        "message": "success",
    })
}

func (p *PeopleController) DeletePeople(ctx *gin.Context) {
    var people model.People
    if err := ctx.ShouldBind(&people); err != nil {
        logrus.Error("读取People信息失败")
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    peopleDao := p.dataSource.PeopleDao()
    err := peopleDao.DeletePeople(&people)
    if err != nil {
        logrus.Error("删除People失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, gin.H{
        "message": "success",
    })
}

func (p *PeopleController) ListPeopleById(ctx *gin.Context) {
    id := cast.ToUint(ctx.Query("id"))
    peopleDao := p.dataSource.PeopleDao()
    people, err := peopleDao.ListPeopleById(id)
    if err != nil {
        logrus.Error("查询People失败", err)
        ctx.JSON(http.StatusInternalServerError, gin.H{
            "message": "failed",
        })
        return
    }
    ctx.JSON(http.StatusOK, people)
}

最后,云女士简单的展示了一下对 book 表和 prople 表的 Crud 操作。

book 表和 people 表的增删改成功时返回内容如下所示。

5417aabacf2eae09b999e2d9e63ae7df.jpeg
Gin-增删改成功

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

04fb9a0b435fa85d69a813571a7ae782.jpeg
Gin-查询图书
973b0c11b525bb40544ee87a72b2dffc.jpeg
Gin-查询人物

Springboot快速搭建Crud工程

云女士基于 Gin 和 Gorm 搭建的 Crud 工程,我看完后内心扑哧一笑:不过如此。

那现在该轮到我表演了。首先给出整个工程结构图如下所示。

7d9a44119ba4b6966445ec2ee4b5be3b.jpeg
Springboot目录结构

POM 文件内容如下所示。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.1</version>
    </parent>

    <groupId>com.lee.javabase</groupId>
    <artifactId>javabase</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

同样,定义 book 表和 people 表对应的实体类 Book 和 People,如下所示。

@Getter
@Setter
public class Book {
    @TableField("id")
    private int id;

    @TableField("b_name")
    private String bookName;
    @TableField("b_price")
    private float bookPrice;

}

@Getter
@Setter
public class People {

    @TableField("id")
    private int id;

    @TableField("p_name")
    private String peopleName;
    @TableField("p_age")
    private int peopleAge;

}

然后定义定义接口,如下所示。

@Mapper
public interface BookMapper extends BaseMapper<Book> {
}

@Mapper
public interface PeopleMapper extends BaseMapper<People> {
}

最后是对应的 Controller 实现, BookController 实现如下。

@Slf4j
@RestController
@RequestMapping("/book")
public class BookController {

    @Autowired
    private BookMapper bookMapper;

    @PostMapping("/add")
    public ResponseEntity<String> addBook(@RequestBody Book book) {
        try {
            bookMapper.insert(book);
            return new ResponseEntity<>("添加图书成功", HttpStatus.OK);
        } catch (Exception e) {
            log.error("添加图书失败", e);
            return new ResponseEntity<>("添加图书失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/update")
    public ResponseEntity<String> updateBook(@RequestBody Book book) {
        try {
            bookMapper.updateById(book);
            return new ResponseEntity<>("更新图书成功", HttpStatus.OK);
        } catch (Exception e) {
            log.error("更新图书失败", e);
            return new ResponseEntity<>("更新图书失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/delete")
    public ResponseEntity<String> deleteBook(@RequestParam("id") int id) {
        try {
            bookMapper.deleteById(id);
            return new ResponseEntity<>("删除图书成功", HttpStatus.OK);
        } catch (Exception e) {
            log.error("删除图书失败", e);
            return new ResponseEntity<>("删除图书失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/list")
    public ResponseEntity<Book> listBook(@RequestParam("id") int id) {
        try {
            Book book = bookMapper.selectById(id);
            return new ResponseEntity<>(book, HttpStatus.OK);
        } catch (Exception e) {
            log.error("查询图书失败", e);
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

PeopleController 实现如下所示。

@Slf4j
@RestController
@RequestMapping("/people")
public class PeopleController {

    @Autowired
    private PeopleMapper peopleMapper;

    @PostMapping("/add")
    public ResponseEntity<String> addPeople(@RequestBody People people) {
        try {
            peopleMapper.insert(people);
            return new ResponseEntity<>("添加人物成功", HttpStatus.OK);
        } catch (Exception e) {
            log.error("添加人物失败", e);
            return new ResponseEntity<>("添加人物失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/update")
    public ResponseEntity<String> updatePeople(@RequestBody People people) {
        try {
            peopleMapper.updateById(people);
            return new ResponseEntity<>("更新人物成功", HttpStatus.OK);
        } catch (Exception e) {
            log.error("更新人物失败", e);
            return new ResponseEntity<>("更新人物失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/delete")
    public ResponseEntity<String> deletePeople(@RequestParam("id") int id) {
        try {
            peopleMapper.deleteById(id);
            return new ResponseEntity<>("删除人物成功", HttpStatus.OK);
        } catch (Exception e) {
            log.error("删除人物失败", e);
            return new ResponseEntity<>("删除人物失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/list")
    public ResponseEntity<People> listPeople(@RequestParam("id") int id) {
        try {
            People people = peopleMapper.selectById(id);
            return new ResponseEntity<>(people, HttpStatus.OK);
        } catch (Exception e) {
            log.error("查询人物失败", e);
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

启动应用程序, book 表的 Crud 操作结果如下所示。

8034ee31640546cff66ecbfd0d4ab584.png

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

2286e35750f1f78b8bb574698aff973f.png

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

总结

我宣布,Springboot 就是快速搭建 Crud 工程的神。

其实,在基于 Gin 和 Gorm 搭建 Crud 工程时,云女士还是写得复杂了一点,但是我有幸看过她们云平台的项目的代码,云女士写得也没毛病,虽然是个简化版,但也是严格遵从她们项目的代码结构来实现的。

说回 Springboot,毫无疑问,无论是天然自带 Tomcat 或 Jetty ,还是和三方框架整合的各种 Starter 包,Springboot 都将开箱即用做到了极致,但是转念又一想,其实 Springboot 和 Gin 严格来说做比较没啥意义,就像 Java 和 Go 的比较一样,我觉得也没啥意义,各自的优势区间不一样,并且各自也都在相关的领域叱咤风云。

各位看官,你们觉得呢。


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

3d1b1cb4e25ceb9662f808a780353f2b.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

10b762c5e3cfba33e4cd9c03784dfd39.png

d79c39c912823b20791c63843055a0fc.pngcd86c6f2b264fb124f8992c75ba73cba.png15b1e6c337487333afcac05f8a8f6f6e.png7a327896624b47b57bc0318091dc7ac1.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
SpringBoot+Vue+MySQL 高校学科竞赛平台 完整可运行版(源码+文档) 本项目基于SpringBoot+Vue+MySQL构建高校学科竞赛管理平台,覆盖学生、教师、领队教师、管理员四大角色,实现竞赛发布、报名、刷题、评分、公示等全流程闭环管理。系统架构清晰,技术主流,配套完整源码、数据库脚本、万字论文、开题报告、答辩PPT及部署文档,支持一键运行,适用于毕业设计、课程设计及院系二次开发,真正实现“开箱即用”。 阅读详情

相关推荐

避坑指南:Livox Mid-360双雷达SLAM配置中,那些官方文档没说的细节(IP设置、话题分离与时间同步)

本文详细解析了Livox Mid-360双雷达SLAM配置中的关键优化点,包括IP设置、话题分离与时间同步等官方文档未提及的细节。通过实战案例和代码示例,帮助开发者解决点云错位、IMU数据混乱等问题,提升SLAM系统的稳定性和精度。特别针对网络架构设计、驱动修改和时间同步机制提供了专业指导。

weixin_29745609的博客 426

MJGA,让Java再次伟大,开箱即用 SpringBoot 怕不怕Gin?

隔壁组的云计算零零后女同事,后文简称 云女士 ,非说 Go 的 Gin 框架比 Springboot 更加的开箱即用,我心想在 Java 里面 Springboot 已经打遍天下无敌手,这份底蕴岂是 Gin 能比。但是云女士突出一个执拗,非我要 PK 一把, PK 内容就是她使用 Gin,而我使用 Springboot 快速搭建一个简单的 Crud 工程,最后让其他同事来评判哪个更开箱即用。我毫不犹豫就答应了,作为搭建 Springboot 学习工程的资深 Crud 选手,咱这份底气还是有的。

tangjieqing的博客 1055

基于本地知识库的智能问答系统架构

智能问答系统的核心可以分为4部分。1)知识库构建。2)检索。3)后处理。4)推理。知识库构建:知识库中可以包含多个向量数据库和知识图谱等,核心是怎么建立索引,使得检索时能够将与问题相关的知识给检索出来。检索:从知识库中的多个库或者知识图谱中检索出与问题相关的信息。后处理:从知识库中检索出来的信息可能是冗余的,而且可能不符合我们希望的格式要求,因此,我们需要对这些数据进行过滤,格式化等操作。推理: 基于检索出来的知识进行推理,让输出能够回答用户的问题,目前主要使用大模型进行推理。

qq_44993593的博客 1714

MJGA,让Java再次伟大,开箱即用Spring Boot怕不怕Gin?

Java精选面试题(微信小程序):5000+道面试题和选择题,真实面经,简历模版,包含Java基础、并发、JVM、线程、MQ系列、Redis、Spring系列、Elasticsearch、Docker、K8s、Flink、Spark、架构设计、大厂真题等,在线随时刷题!前言unset隔壁组的云计算零零后女同事,后文简称 云女士 ,非说Go的Gin框架比 Springboot 更加的开箱即用,我心想...

Java精选 90

四阶龙格库塔法求解一次常微分方程组(python实现)

之前在博客发布了关于使用四阶龙格库塔方法求解一次常微分方程组的文章,由于代码缺少具体的验证,部分朋友可能存在疑问,因此这里打算再重新写一篇博客来验证一下程序的正确性,另外,这里是使用python语言来实现的。

HelloWorldTM的博客 8543

从Peer到脉冲地震波:免费Python工具全流程配置教程(PyCharm+Anaconda)

本文详细介绍了如何使用Python工具链(PyCharm+Anaconda)实现从Peer数据库获取地震波数据到生成脉冲地震波的全流程配置。通过开源工具EQTOOL和PySeismicGen,结合Python环境搭建、数据格式转换和脉冲地震动生成技术,为结构抗震分析提供高效、灵活的解决方案。

weixin_29093169的博客 432

什么样的老程序员,写出这么低级的 bug!

往期热门文章: 1、大厂也在用的分布式链路追踪:TraceIdFilter + MDC + Skywalking 2、MJGA,让Java再次伟大,开箱即用Springboot怕不怕Gin? 3、改变习惯性 !=null 的判断,只需一秒! 4、开发人员,千万不要去碰那该死的业务参数,无论什么时候! 5、为什么数据库连接很消耗资源?被问根本答不出来…… 5、Git不要只会pull和push,试试...

Java后端技术 144

NOIP2008年普及组初赛题目答案及解析

NOIP2008年初赛详细题解

城南蝈蝈 930

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 311

数据库系统概论第五版课后习题答案第十二章

对元组的插入、删除、修改;语义检查的具体做法是,DBMS读取数据字典,检查是否存在与该语句中的表、视图或索引等要创建的对象相同的对象名,检查该用户是否具有创建数据库对象的权限。答:操作系统提供的封锁机制和DBMS的封锁机制在封锁对象、封锁对象的状态、封锁的粒度、及封锁的类型上存在很大的差别,操作系统的封锁机制不能直接应用在DBMS中,DBMS必须重新设计,来满足复杂的封锁需求。数据库的建立和维护包括数据库的初始建立、数据的转换、数据库的转储和恢复、数据库的重组织和重构造以及性能监测分析等功能。

wenling54321的博客 696

点云数据处理:体素滤波算法

体素滤波是一种简单而有效的点云数据处理方法,可用于去除离群点和平滑点云表面。体素滤波是一种常用的点云数据处理算法,用于去除离群点并平滑点云表面。在本文中,我们将介绍CloudCompare和PCL(Point Cloud Library)中的体素滤波算法,并提供相应的源代码示例。PCL是一个专门用于点云处理的开源库,提供了一系列高效的点云处理算法和工具。然后,我们创建了一个。方法执行体素滤波,并将滤波后的点云保存为"filtered_cloud.ply"文件。方法来执行体素滤波,指定体素大小为0.01。

ZyqfCss的博客 390

信创环境下PageOffice文档控件适配与实践

信创适配做到文档控件这一层,拼的已经不是"有没有国产版本",而是同一个功能在两类终端上是否真的等价。等价的标准很具体:同一次点击能得到同样的结果,同一份公文能得到同样的版式,同一个项目不需要维护两套代码。这背后是三件并不轻松的工作:服务端用一套接口同时支撑两类终端,客户端把两种系统与四种芯片的安装包分发清楚,文档内核层由产品侧跟着 WPS 的版本走。浏览器这一层的压力,则被收进了产品自己的窗口里——升级节奏由产品掌握,不再交给运气。

zi_wu_xian的专栏 340

将指定文件夹下每张用LabelImg标注的图片中标注部分抠出来保存到指定文件夹下。

将指定文件夹下每张用LabelImg标注的图片中标注部分抠出来保存到指定文件夹下。

weixin_44119674的博客 441

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 557

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 624

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

pcl2启动器下载(Minecraft PCL2 启动器 最新版 安装与使用说明)

摘要:PCL2(Plain Craft Launcher 2)是一款面向 Minecraft 的第三方启动器,支持正式版与快照版本管理、模组与整合包安装、Java 运行时自动匹配,绿色免安装、双击即可运行。适合在 Windows 上玩单机整合包、需要多版本共存或离线启动的用户使用

2611_96675819的博客 239

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

spring boot 4集成SQLLite,及其SQLLite的建库

spring boot 4集成SQLLite,及其SQLLite的建库

weixin_41463944的博客 256

Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

HashMap 树化阈值 8 的泊松分布依据、退化阈值 6 的防抖设计、JDK 1.7 头插成环死循环的排查与修复、1.8 尾插后为何仍线程不安全、ConcurrentHashMap 放弃分段锁的原因与 ForwardingNode 协作扩容、computeIfAbsent 死锁陷阱、大集合找重复的场景题选型,附三层追问链自测。题目来源为 38 期公开招聘 JD 样本与字节、拼多多、建行、美团、快手公开面经。

蒙眼过河 436

spdlog 同步日志库使用详解

spdlog是一个轻量级 C++ 日志库,支持同步日志、异步日志、多线程日志、日志文件轮转和自定义日志格式。对于嵌入式 Linux 应用开发,我建议先使用。它可以帮我们完成:日志级别过滤。时间戳和线程 ID 输出。日志格式化。终端和文件输出。多线程安全写入。日志文件按大小或时间轮转。我们不需要自己实现互斥锁、文件写入、日志格式化和轮转等底层功能。

zengjiajun2006的博客 1127

JavaSE通关手册:数据类型与变量

代码无需额外处理,编译时编译器自动完成转换。

xys_678的博客 236

IDEA 简介:从零认识 IntelliJ IDEA

IDEA 全称,是由 JetBrains 公司开发的一款主流 Java 集成开发环境(IDE)。它集代码编辑、编译、调试、测试、版本控制、构建管理等功能于一体,被大量 Java 开发者视为日常开发的首选工具。所谓 IDE(Integrated Development Environment,集成开发环境),就是把写代码所需的各类工具整合到同一个界面中。相比只用文本编辑器加命令行编译,IDE 能显著减少重复操作,让开发者把精力集中在业务逻辑上。

ztI10的博客 194
上一篇: 工作 6 年,@Transactional 注解用的一塌糊涂!
下一篇: 大爱这个IDEA插件,不写代码照样统计方法耗时
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值