Gin CORS 跨域请求资源共享与中间件

目录

一、同源策略

1.1 什么是浏览器的同源策略?

  • 同源策略(Same origin policy)是一种约定,它是浏览器最核心也最基本的安全功能,如果缺少了同源策略,则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的,浏览器只是针对同源策略的一种实现
  • 浏览器最基本的安全策略
  • 浏览器只能接收相同域(IP地址+端口)返回的数据

1.2 同源策略判依据

请求的url地址,必须与浏览器上的url地址处于同域上,也就是域名,端口,协议相同只要协议、域名和端口任意一个不同,都是跨域请求

  1. 比如: 我在本地上的域名是127.0.0.1:8000,请求另外一个域名:127.0.0.1:8001一段数据
  2. 浏览器上就会报错,这个就是同源策略的保护,如果浏览器对javascript没有同源策略的保护,那么一些重要的机密网站将会很危险
  3. 已拦截跨源请求:同源策略禁止读取位于http://127.0.0.1:8001/SendAjax/的远程资源。(原因:CORS 头缺少 'Access-Control-Allow-Origin')
  4. 但是注意,项目2中的访问已经发生了,说明是浏览器对非同源请求返回的结果做了拦截

所以就导致了向不同域发请求,就会出现跨域问题(被浏览器阻止了),正常来说,如果我们不做额外处理,是没办法这么发请求的。

1.3 跨域问题三种解决方案

  • CORS(跨域资源共享:后端技术),主流采用的方案,使用第三方插件
  • 前端代理(只能在测试阶段使用):node起了一个服务,正向代理
  • jsonp:只能解决get请求跨域,本质原理使用了某些标签不限制跨域(img,script)

二、CORS:跨域资源共享简介(后端技术)

CORS需要浏览器和服务器同时支持。目前,所有浏览器都支持该功能,IE浏览器不能低于IE10。

整个CORS通信过程,都是浏览器自动完成,不需要用户参与。对于开发者来说,CORS通信与同源的AJAX通信没有差别,代码完全一样。浏览器一旦发现AJAX请求跨源,就会自动添加一些附加的头信息,有时还会多出一次附加的请求,但用户不会有感觉。

因此,实现CORS通信的关键是服务器。只要服务器实现了CORS接口,就可以跨源通信。

三 CORS基本流程

1.CORS请求分类

  • 简单请求 (simple request):简单请求只发一次

  • 非简单请求 (not-so-simple request):发送两次,第一次是options请求,第二次是真正的请求

2.基本流程

  • 浏览器发出CORS简单请求只需要在头信息之中增加一个Origin字段。
  • 浏览器发出CORS非简单请求会在正式通信之前,增加一次HTTP查询请求,称为"预检"请求(preflight)。浏览器先询问服务器,当前网页所在的域名是否在服务器的许可名单之中,以及可以使用哪些HTTP动词和头信息字段。只有得到肯定答复,浏览器才会发出正式的XMLHttpRequest请求,否则就报错。

四、CORS两种请求详解

1.两种请求详解

只要同时满足以下两大条件,就属于简单请求

  1. 请求方法是以下三种方法之一:

    • HEAD
    • GET
    • POST
  2. HTTP的头信息不超出以下几种字段:
    • Accept
    • Accept-Language
    • Content-Language
    • Last-Event-ID
    • Content-Type:只限于三个值application/x-www-form-urlencodedmultipart/form-data、text/plain

凡是不同时满足上面两个条件,就属于非简单请求

浏览器对这两种请求的处理,是不一样的。

简单请求和非简单请求的区别

  • 简单请求: 一次请求
  • 非简单请求:两次请求,在发送数据之前会先发一次请求用于做“预检”,只有“预检”通过后才再发送一次请求用于数据传输。

关于“预检”

  • 请求方式:OPTIONS
  • “预检”其实做检查,检查如果通过则允许传输数据,检查不通过则不再发送真正想要发送的消息

如何“预检” ?

  • 如果复杂请求是PUT等请求,则服务端需要设置允许某请求,否则“预检”不通过Access-Control-Allow-Methods

  • 如果复杂请求设置了请求头,则服务端需要设置允许某请求头,否则“预检”不通过Access-Control-Allow-Headers

2.解决跨域问题:浏览器对于这两种请求的处理

支持跨域,简单请求

  • 服务器设置响应头:Access-Control-Allow-Origin = ‘域名’ 或 ‘*’

支持跨域,复杂请求

非简单请求需要判断是否是options请求

由于复杂请求时,首先会发送“预检”请求,如果“预检”成功,则发送真实数据。

  • “预检”请求时,允许请求方式则需服务器设置响应头:Access-Control-Allow-Methods
  • “预检”请求时,允许请求头则需服务器设置响应头: Access-Control-Allow-Headers

五、Gin 中间件

在Gin框架中,中间件(Middleware)是一种允许在请求到达处理程序之前或之后执行一些逻辑的机制。中间件允许你在处理请求的过程中插入一些代码,例如验证请求、记录日志、处理跨域等。

5.1 中间件介绍

中间件是Gin框架的一个关键概念。它是一个函数,接受gin.Context作为参数,可以在请求到达处理程序之前或之后执行一些逻辑。中间件允许你在请求处理过程中执行预处理或后处理的操作。

5.2 初识中间件

在Gin框架中,使用Use方法可以注册一个全局中间件,它将应用于所有路由。例如:

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gin-gonic/gin"
  5. "net/http"
  6. )
  7. func LoggerMiddleware(c *gin.Context) {
  8. // 在请求处理之前执行的逻辑
  9. fmt.Println("Start Logging")
  10. // 将请求传递给下一个处理程序
  11. c.Next()
  12. // 在请求处理之后执行的逻辑
  13. fmt.Println("End Logging")
  14. }
  15. func main() {
  16. r := gin.Default()
  17. // 注册全局中间件
  18. r.Use(LoggerMiddleware)
  19. // 定义路由
  20. r.GET("/", func(c *gin.Context) {
  21. c.String(http.StatusOK, "Hello, Gin!")
  22. })
  23. r.Run(":8080")
  24. }

在上述例子中,LoggerMiddleware是一个简单的中间件,用于记录请求日志。通过使用Use方法,我们将这个中间件注册为全局中间件,它将应用于所有的路由。

查看Use方法源码如下:

综上,所以中间件必须是一个 gin.HandlerFunc 类型,配置路由的时候可以传递多个 func 回调函数。

5.3 c.Next()

在中间件中,通过调用c.Next()可以将请求传递给下一个处理程序。这是一个重要的步骤,如果你忘记调用c.Next(),那么请求将不会继续传递给后续的中间件或路由处理程序。

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gin-gonic/gin"
  5. "time"
  6. )
  7. // 写一个中间件,统计视图函数运行时间
  8. func totalTime(c *gin.Context) {
  9. start := time.Now()
  10. c.Next() //继续往后执行
  11. end := time.Now()
  12. fmt.Println("视图函数运行时间为:", end.Sub(start))
  13. }
  14. func main() {
  15. r := gin.Default()
  16. // 把中间件函数加在视图函数之前
  17. r.GET("/", totalTime, func(c *gin.Context) {
  18. time.Sleep(time.Second * 2)
  19. c.String(200, "hello,Gin!")
  20. })
  21. r.Run()
  22. }

5.4 多个中间件执行顺序

如果你有多个中间件,它们将按照注册的顺序执行。在上述例子中,如果我们有多个全局中间件,它们将按照注册的顺序依次执行。

  1. func Middleware1(c *gin.Context) {
  2. fmt.Println("Middleware 1 - Start")
  3. c.Next()
  4. fmt.Println("Middleware 1 - End")
  5. }
  6. func Middleware2(c *gin.Context) {
  7. fmt.Println("Middleware 2 - Start")
  8. c.Next()
  9. fmt.Println("Middleware 2 - End")
  10. }
  11. func main() {
  12. r := gin.Default()
  13. // 注册全局中间件,按照注册顺序执行
  14. r.Use(Middleware1)
  15. r.Use(Middleware2)
  16. r.GET("/hello", func(c *gin.Context) {
  17. c.String(http.StatusOK, "Hello, Gin!")
  18. })
  19. r.Run(":8080")
  20. }

输出结果如下:

  1. Middleware 1 - Start
  2. Middleware 2 - Start
  3. Middleware 2 - End
  4. Middleware 1 - End

5.5 c.Abort()

在中间件中,通过调用c.Abort()可以终止请求链,不再执行后续的中间件或路由处理程序。这通常是在中间件中检测到错误或条件不满足时使用的。

  1. package main
  2. import (
  3. "github.com/gin-gonic/gin"
  4. "net/http"
  5. )
  6. func isValidAuth(authorizationHeader string) bool {
  7. // 在这里实现你的身份验证逻辑
  8. // 例如,你可能验证一个令牌或检查凭证
  9. // 如果身份验证成功,返回 true;否则返回 false
  10. return true
  11. }
  12. func AuthMiddleware(c *gin.Context) {
  13. // 检查是否有有效的 Authorization 头
  14. if authorizationHeader := c.GetHeader("Authorization"); authorizationHeader == "" {
  15. // 如果 Authorization 头缺失,返回未授权状态
  16. c.AbortWithStatus(http.StatusUnauthorized)
  17. return
  18. }
  19. // 检查使用你的自定义逻辑提供的身份验证是否有效
  20. if !isValidAuth(c.GetHeader("Authorization")) {
  21. // 如果身份验证失败,返回未授权状态
  22. c.AbortWithStatus(http.StatusUnauthorized)
  23. return
  24. }
  25. // 如果身份验证成功,继续执行下一个中间件或路由处理程序
  26. c.Next()
  27. }
  28. func main() {
  29. r := gin.Default()
  30. // 应用 AuthMiddleware 以保护 "/protected" 路由
  31. r.GET("/protected", AuthMiddleware, func(c *gin.Context) {
  32. // 只有在 AuthMiddleware 允许请求继续时,才会执行此处理程序
  33. c.String(http.StatusOK, "你有权访问受保护的路由!")
  34. })
  35. r.Run(":8080")
  36. }

5.6 全局中间件与局部中间件

全局中间件是通过Use方法注册的,它将应用于所有路由。局部中间件是在定义单个路由时附加的。

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gin-gonic/gin"
  5. "net/http"
  6. )
  7. // GlobalMiddleware1 全局中间件1
  8. func GlobalMiddleware1(c *gin.Context) {
  9. c.Header("X-Global-Middleware-1", "Applied")
  10. fmt.Printf("GlobalMiddleware1\n")
  11. c.Next()
  12. }
  13. // GlobalMiddleware2 全局中间件2
  14. func GlobalMiddleware2(c *gin.Context) {
  15. c.Header("X-Global-Middleware-2", "Applied")
  16. fmt.Printf("GlobalMiddleware2\n")
  17. c.Next()
  18. }
  19. // LocalMiddleware3 局部中间件3
  20. func LocalMiddleware3(c *gin.Context) {
  21. c.Header("X-Local-Middleware-3", "Applied")
  22. fmt.Printf("LocalMiddleware3\n")
  23. c.Next()
  24. }
  25. func main() {
  26. // 创建一个新的 Gin 引擎
  27. r := gin.New()
  28. // 使用全局中间件1
  29. r.Use(GlobalMiddleware1)
  30. // 使用全局中间件2
  31. r.Use(GlobalMiddleware2)
  32. r.GET("/", func(c *gin.Context) {
  33. c.String(http.StatusOK, "Hello,Gin!")
  34. })
  35. // 定义一个路由组,并在路由组中使用局部中间件3
  36. apiGroup := r.Group("/api")
  37. apiGroup.Use(LocalMiddleware3)
  38. // 路由1,将同时应用全局中间件1、全局中间件2以及局部中间件3
  39. apiGroup.GET("/endpoint1", func(c *gin.Context) {
  40. c.String(http.StatusOK, "Endpoint 1")
  41. })
  42. // 路由2,将同时应用全局中间件1、全局中间件2
  43. r.GET("/endpoint2", func(c *gin.Context) {
  44. c.String(http.StatusOK, "Endpoint 2")
  45. })
  46. // 启动服务器
  47. r.Run(":8080")
  48. }

5.7 中间件和视图函数之间共享数据

在中间件和视图函数之间共享数据可以使用c.Setc.Get方法。

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gin-gonic/gin"
  5. "net/http"
  6. )
  7. func CustomMiddleware(c *gin.Context) {
  8. // 在中间件中设置数据
  9. c.Set("userID", 123)
  10. // 继续执行下一个中间件或路由处理程序
  11. c.Next()
  12. }
  13. func ProtectedRouteHandler(c *gin.Context) {
  14. // 从上一个中间件中获取数据
  15. userID, exists := c.Get("userID")
  16. if !exists {
  17. // 如果数据不存在,返回错误响应
  18. c.String(http.StatusInternalServerError, "无法获取用户信息")
  19. return
  20. }
  21. // 数据存在,继续处理
  22. c.String(http.StatusOK, fmt.Sprintf("用户ID:%v,你有权访问受保护的路由!", userID))
  23. }
  24. func main() {
  25. r := gin.Default()
  26. // 应用 CustomMiddleware 中间件以设置数据
  27. r.Use(CustomMiddleware)
  28. // 设置保护路由
  29. r.GET("/protected", ProtectedRouteHandler)
  30. r.Run(":8080")
  31. }

5.8 在路由分组中配置中间件

在Gin框架中,你可以使用路由分组将中间件应用于一组相关的路由。这样,你可以更清晰地组织你的中间件和路由。

  1. func LoggerMiddleware(c *gin.Context) {
  2. fmt.Println("Request Log")
  3. c.Next()
  4. }
  5. func AuthMiddleware(c *gin.Context) {
  6. // 检查是否有有效的身份验证信息
  7. if !isValidAuth(c.GetHeader("Authorization")) {
  8. c.AbortWithStatus(http.StatusUnauthorized)
  9. return
  10. }
  11. c.Next()
  12. }
  13. func main() {
  14. r := gin.Default()
  15. // 创建一个路由分组,并将中间件应用于该分组中的所有路由
  16. apiGroup := r.Group("/api", LoggerMiddleware, AuthMiddleware)
  17. apiGroup.GET("/users", func(c *gin.Context) {
  18. c.String(http.StatusOK, "List of Users")
  19. })
  20. apiGroup.GET("/products", func(c *gin.Context) {
  21. c.String(http.StatusOK, "List of Products")
  22. })
  23. r.Run(":8080")
  24. }

5.9 中间件解决跨域

下面是一个简单的例子:

  1. package main
  2. import (
  3. "github.com/gin-gonic/gin"
  4. "net/http"
  5. )
  6. func main() {
  7. r := gin.Default()
  8. // 使用中间件处理跨域问题
  9. r.Use(CORSMiddleware())
  10. // 其他路由注册
  11. r.GET("/hello", func(c *gin.Context) {
  12. c.JSON(http.StatusOK, gin.H{"message": "Hello, CORS is enabled!"})
  13. })
  14. // 启动 Gin 服务器
  15. r.Run(":8080")
  16. }
  17. // CORSMiddleware 中间件处理跨域问题
  18. func CORSMiddleware() gin.HandlerFunc {
  19. return func(c *gin.Context) {
  20. c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
  21. c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
  22. c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
  23. c.Writer.Header().Set("Access-Control-Allow-Headers", "Origin, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
  24. if c.Request.Method == "OPTIONS" {
  25. c.AbortWithStatus(204)
  26. return
  27. }
  28. c.Next()
  29. }
  30. }

在上述例子中,CORSMiddleware函数返回一个用于处理跨域的中间件。通过将该中间件注册到Gin框架中,可以轻松地解决跨域问题。

5.10 中间件注意事项

5.10.1 Gin 默认中间件

gin.Default()默认使用了 LoggerRecovery 中间件,其中:

  • Logger 中间件将日志写入 gin.DefaultWriter,即使配置了 GIN_MODE=release

  • Recovery 中间件会 recover 任何 panic。如果有 panic 的话,会写入 500 响应码。

    如果不想使用上面两个默认的中间件,可以使用 gin.New()新建一个没有任何默认中间件的 路由。

5.10.2 gin中间件中使用 goroutine

当在中间件或 handler 中启动新的 goroutine 时,不能使用原始的上下文(c *gin.Context), 必须使用其只读副本(c.Copy())

  1. r.GET("/", func(c *gin.Context) {
  2. cCp := c.Copy()
  3. go func() {
  4. // simulate a long task with time.Sleep(). 5 seconds time.Sleep(5 * time.Second)
  5. // 这里使用你创建的副本
  6. fmt.Println("Done! in path " + cCp.Request.URL.Path)
  7. }()
  8. c.String(200, "首页")
  9. })

六、Gin 框架跨域问题解决

目前大多数的 Web 框架,都提供了 CORS 的解决方案。Gin 也不例外,Gin 里面也提供了一个 middleware 实现来解决跨域问题,打开如下Gin 中间件插件库合集:

  1. https://github.com/gin-gonic/contrib

找到cors 文件夹:

进入后会提示:此软件包已于2016-12-07放弃。请改用gin-contrib/cors。点击进入最新的即可。

5.1 安装

  1. go get github.com/gin-contrib/cors

5.2 导入

  1. import "github.com/gin-contrib/cors"

5.3 直接设置跨域参数(一般用这个)

  1. package main
  2. import (
  3. "github.com/gin-contrib/cors"
  4. "github.com/gin-gonic/gin"
  5. "strings"
  6. "time"
  7. )
  8. func main() {
  9. // 创建一个默认的 Gin 实例
  10. server := gin.Default()
  11. // 使用 CORS 中间件处理跨域问题,配置 CORS 参数
  12. server.Use(cors.New(cors.Config{
  13. // 允许的源地址(CORS中的Access-Control-Allow-Origin)
  14. // AllowOrigins: []string{"https://foo.com"},
  15. // 允许的 HTTP 方法(CORS中的Access-Control-Allow-Methods)
  16. AllowMethods: []string{"PUT", "PATCH"},
  17. // 允许的 HTTP 头部(CORS中的Access-Control-Allow-Headers)
  18. AllowHeaders: []string{"Origin"},
  19. // 暴露的 HTTP 头部(CORS中的Access-Control-Expose-Headers)
  20. ExposeHeaders: []string{"Content-Length"},
  21. // 是否允许携带身份凭证(CORS中的Access-Control-Allow-Credentials)
  22. AllowCredentials: true,
  23. // 允许源的自定义判断函数,返回true表示允许,false表示不允许
  24. AllowOriginFunc: func(origin string) bool {
  25. if strings.HasPrefix(origin, "http://localhost") {
  26. // 允许你的开发环境
  27. return true
  28. }
  29. // 允许包含 "yourcompany.com" 的源
  30. return strings.Contains(origin, "yourcompany.com")
  31. },
  32. // 用于缓存预检请求结果的最大时间(CORS中的Access-Control-Max-Age)
  33. MaxAge: 12 * time.Hour,
  34. }))
  35. // 启动 Gin 服务器,监听在 0.0.0.0:8080 上
  36. server.Run(":8080")
  37. }

5.4 使用DefaultConfig作为起点

  1. func main() {
  2. router := gin.Default()
  3. // - No origin allowed by default
  4. // - GET,POST, PUT, HEAD methods
  5. // - Credentials share disabled
  6. // - Preflight requests cached for 12 hours
  7. config := cors.DefaultConfig()
  8. config.AllowOrigins = []string{"http://google.com"}
  9. // config.AllowOrigins = []string{"http://google.com", "http://facebook.com"}
  10. // config.AllowAllOrigins = true
  11. router.Use(cors.New(config))
  12. router.Run()
  13. }

注意:虽然 Default() 允许所有来源,但 DefaultConfig() 不允许,您仍然必须使用 AllowAllOriins

5.5 Default()允许所有来源

  1. func main() {
  2. router := gin.Default()
  3. // same as
  4. // config := cors.DefaultConfig()
  5. // config.AllowAllOrigins = true
  6. // router.Use(cors.New(config))
  7. router.Use(cors.Default())
  8. router.Run()
  9. }

使用所有来源会禁用 Gin 为客户端设置 cookie 的能力。处理凭据时,不要允许所有来源。

Gin CORS 跨域请求资源共享与中间件的更多相关文章

  1. 4 伪ajax:jsonp、cors 跨域请求

    一.同源策略 https://www.cnblogs.com/yuanchenqi/articles/7638956.html 同源策略(Same origin policy)是一种约定,它是浏览器最 ...

  2. CORS跨域请求规则以及在Spring中的实现

    CORS: 通常情况下浏览器禁止AJAX从外部获取资源,因此就衍生了CORS这一标准体系,来实现跨域请求. CORS是一个W3C标准,全称是"跨域资源共享"(Cross-origi ...

  3. Spring Boot Web应用开发 CORS 跨域请求支持:

    Spring Boot Web应用开发 CORS 跨域请求支持: 一.Web开发经常会遇到跨域问题,解决方案有:jsonp,iframe,CORS等等CORS与JSONP相比 1. JSONP只能实现 ...

  4. CORS跨域请求总结

    CORS跨域请求分为简单请求和复杂请求. 1. 简单请求: 满足一下两个条件的请求. (1) 请求方法是以下三种方法之一: HEAD GET POST (2)HTTP的头信息不超出以下几种字段: Ac ...

  5. 记一次 CORS 跨域请求出现 OPTIONS 请求的问题及解决方法

    今天前后端在联调接口的时候,发生了跨域请求资源获取不到的问题. 首先说明下跨域问题的由来.引自HTTP 访问控制 的一段话: 当 Web 资源请求由其它域名或端口提供的资源时,会发起跨域 HTTP 请 ...

  6. Java实现CORS跨域请求

    问题 使用前后端分离模式开发项目时,往往会遇到这样一个问题 -- 无法跨域获取服务端数据 这是由于浏览器的同源策略导致的,目的是为了安全.在前后端分离开发模式备受青睐的今天,前端和后台项目往往会在不同 ...

  7. CORS——跨域请求那些事儿

    在日常的项目开发时会不可避免的需要进行跨域操作,而在实际进行跨域请求时,经常会遇到类似 No 'Access-Control-Allow-Origin' header is present on th ...

  8. CORS跨域请求

    一.问题: 服务器端代码 from flask import Flask from flask import make_response from flask import jsonify app = ...

  9. CORS跨域请求[简单请求与复杂请求]

    CORS即Cross Origin Resource Sharing(跨来源资源共享),通俗说就是我们所熟知的跨域请求.众所周知,在以前,跨域可以采用代理.JSONP等方式,而在Modern浏览器面前 ...

  10. django之CORS跨域请求

    对于想要利用django框架实现前后端分离,首要的问题是解决跨域请求的问题,什么是跨域请求?简单来说就是当前发起的请求的域与该请求指向的资源所在的域不一致.当协议+域名+端口号均相同,那么就是同一个域 ...

随机推荐

  1. 揭露ROI提升5倍的秘密!火山引擎A/B测试白皮书重磅发布(内附下载链接)

    - 文末立即下载白皮书原文 -  近期,<火山引擎A/B测试总体经济影响白皮书>正式发布.这份白皮书由市场研究公司Forrester调研撰写,揭示了A/B测试对于企业营收增长.运营成本.生 ...

  2. Python 读取图片 转 base64 并生成 JSON

    Python 读取图片 转 base64 并生成 JSON import json import base64 img_path = r'D:\OpenSource\PaddlePaddle\Padd ...

  3. PPT 产品发布会PPT应该怎么样改

    PPT 毕业答辩PPT应该怎么样改 大图背景打底 刺眼 收集素材

  4. Docker 安装 kafka

    简单安装为了集成 SpringBoot,真实使用,增加增加更多配置,比如将log映射出来 1.安装 zookeeper [root@centos-linux ~]# docker pull wurst ...

  5. Python数据预处理:彻底理解标准化和归一化

    数据预处理 数据中不同特征的量纲可能不一致,数值间的差别可能很大,不进行处理可能会影响到数据分析的结果,因此,需要对数据按照一定比例进行缩放,使之落在一个特定的区域,便于进行综合分析. 常用的方法有两 ...

  6. HHKB 键盘布局记录以及一些闲言碎语

    HHKB (happy hacking keyboard) 是世界顶级键盘品牌,自 1996 年推出以来畅销至今.与其他键盘不同,HHKB 机身小巧,省略了 F1 - F12 功能键.光标键和 Pag ...

  7. 二、mongo集群搭建

    系列导航 一.linux单机版mongo安装(带密码验证) 二.mongo集群搭建 三.java连接mongo数据库 四.java对mongo数据库增删改查操作 五.mongo备份篇 mongoexp ...

  8. opensips简介

    概述 在众多的sip服务器中,主要有俩大类,一类侧重于媒体/业务服务器,比如freeswitch/asterisk,另一类侧重于代理/负载服务器,比如opensips/kamailio. 今天我们对o ...

  9. JUC包常用类原理

    放眼望去,java.util.concurrent包下类大致包括:atomic 原子类.锁.并发集合.线程池.工具类.我们挑重要的了解一下. Atomic 原子类 Java针对并发编程已经有了各种锁, ...

  10. idea中配置mybatis 映射文件模版及 mybatis plus 自定义sql

    本文为博主原创,未经允许不得转载: mybatis plus 使用过程中已经很大程度提升了我们开发的效率,因为它内部已经对单表的操作进行了完美的封装,但是关联表操作时, 这时就需要自己定义sql,自定 ...