Try to bind body into different structs

The normal methods for binding request body consumes ctx.Request().Body and they cannot be called multiple times, unless the iris.WithoutBodyConsumptionOnUnmarshal configurator is passed to app.Run/Listen.

package main
import "github.com/kataras/iris/v12"
func main() {
    app := iris.New()
    app.Post("/", logAllBody, logJSON, logFormValues, func(ctx iris.Context) {
        // body, err := ioutil.ReadAll(ctx.Request().Body) once or
        body, err := ctx.GetBody() // as many times as you need.
        if err != nil {
            ctx.StopWithError(iris.StatusInternalServerError, err)
            return
        }
        if len(body) == 0 {
            ctx.WriteString(`The body was empty.`)
        } else {
            ctx.WriteString("OK body is still:\n")
            ctx.Write(body)
        }
    })
    app.Listen(":8080", iris.WithoutBodyConsumptionOnUnmarshal)
}
func logAllBody(ctx iris.Context) {
    body, err := ctx.GetBody()
    if err == nil && len(body) > 0 {
        ctx.Application().Logger().Infof("logAllBody: %s", string(body))
    }
    ctx.Next()
}
func logJSON(ctx iris.Context) {
    var p interface{}
    if err := ctx.ReadJSON(&p); err == nil {
        ctx.Application().Logger().Infof("logJSON: %#+v", p)
    }
    ctx.Next()
}
func logFormValues(ctx iris.Context) {
    values := ctx.FormValues()
    if values != nil {
        ctx.Application().Logger().Infof("logFormValues: %v", values)
    }
    ctx.Next()
}

You can use the ReadBody to bind a struct to a request based on the client’s content-type. You can also use Content Negotiation. Here’s a full example:

package main
import (
    "github.com/kataras/iris/v12"
)
func main() {
    app := newApp()
    // See main_test.go for usage.
    app.Listen(":8080")
}
func newApp() *iris.Application {
    app := iris.New()
    // To automatically decompress using gzip:
    // app.Use(iris.GzipReader)
    app.Use(setAllowedResponses)
    app.Post("/", readBody)
    return app
}
type payload struct {
    Message string `json:"message" xml:"message" msgpack:"message" yaml:"Message" url:"message" form:"message"`
}
func readBody(ctx iris.Context) {
    var p payload
    // Bind request body to "p" depending on the content-type that client sends the data,
    // e.g. JSON, XML, YAML, MessagePack, Protobuf, Form and URL Query.
    err := ctx.ReadBody(&p)
    if err != nil {
        ctx.StopWithProblem(iris.StatusBadRequest,
            iris.NewProblem().Title("Parser issue").Detail(err.Error()))
        return
    }
    // For the sake of the example, log the received payload.
    ctx.Application().Logger().Infof("Received: %#+v", p)
    // Send back the payload depending on the accept content type and accept-encoding of the client,
    // e.g. JSON, XML and so on.
    ctx.Negotiate(p)
}
func setAllowedResponses(ctx iris.Context) {
    // Indicate that the Server can send JSON, XML, YAML and MessagePack for this request.
    ctx.Negotiation().JSON().XML().YAML().MsgPack()
    // Add more, allowed by the server format of responses, mime types here...
    // If client is missing an "Accept: " header then default it to JSON.
    ctx.Negotiation().Accept.JSON()
    ctx.Next()
}