mirror of
https://github.com/kataras/iris.git
synced 2025-01-23 18:51:03 +01:00
115 lines
3.6 KiB
Go
115 lines
3.6 KiB
Go
// Package main contains three different ways to render content based on the client's accepted.
|
|
package main
|
|
|
|
import "github.com/kataras/iris/v12"
|
|
|
|
type testdata struct {
|
|
Name string `json:"name" xml:"Name"`
|
|
Age int `json:"age" xml:"Age"`
|
|
}
|
|
|
|
func newApp() *iris.Application {
|
|
app := iris.New()
|
|
app.Logger().SetLevel("debug")
|
|
|
|
// app.Use(func(ctx iris.Context) {
|
|
// requestedMime := ctx.URLParamDefault("type", "application/json")
|
|
//
|
|
// ctx.Negotiation().Accept.Override().MIME(requestedMime, nil)
|
|
// ctx.Next()
|
|
// })
|
|
|
|
app.Get("/resource", func(ctx iris.Context) {
|
|
data := testdata{
|
|
Name: "test name",
|
|
Age: 26,
|
|
}
|
|
|
|
// Server allows response only JSON and XML. These values
|
|
// are compared with the clients mime needs. Iris comes with default mime types responses
|
|
// but you can add a custom one by the `Negotiation().Mime(mime, content)` method,
|
|
// same for the "accept".
|
|
// You can also pass a custom ContentSelector(mime string) or ContentNegotiator to the
|
|
// `Context.Negotiate` method if you want to perform more advanced things.
|
|
//
|
|
//
|
|
// By-default the client accept mime is retrieved by the "Accept" header
|
|
// Indeed you can override or update it by `Negotiation().Accept.XXX` i.e
|
|
// ctx.Negotiation().Accept.Override().XML()
|
|
//
|
|
// All these values can change inside middlewares, the `Negotiation().Override()` and `.Accept.Override()`
|
|
// can override any previously set values.
|
|
// Order matters, if the client accepts anything (*/*)
|
|
// then the first prioritized mime's response data will be rendered.
|
|
ctx.Negotiation().JSON().XML()
|
|
// Accept-Charset vs:
|
|
ctx.Negotiation().Charset("utf-8", "iso-8859-7")
|
|
// Alternatively you can define the content/data per mime type
|
|
// anywhere in the handlers chain using the optional "v" variadic
|
|
// input argument of the Context.Negotiation().JSON,XML,YAML,Binary,Text,HTML(...) and e.t.c
|
|
// example (order matters):
|
|
// ctx.Negotiation().JSON(data).XML(data).Any("content for */*")
|
|
// ctx.Negotiate(nil)
|
|
|
|
// if not nil passed in the `Context.Negotiate` method
|
|
// then it overrides any contents made by the negotitation builder above.
|
|
_, err := ctx.Negotiate(data)
|
|
if err != nil {
|
|
ctx.Writef("%v", err)
|
|
}
|
|
})
|
|
|
|
app.Get("/resource2", func(ctx iris.Context) {
|
|
jsonAndXML := testdata{
|
|
Name: "test name",
|
|
Age: 26,
|
|
}
|
|
|
|
// I prefer that one, as it gives me the freedom to modify
|
|
// response data per accepted mime content type on middlewares as well.
|
|
ctx.Negotiation().
|
|
JSON(jsonAndXML).
|
|
XML(jsonAndXML).
|
|
HTML("<h1>Test Name</h1><h2>Age 26</h2>")
|
|
|
|
ctx.Negotiate(nil)
|
|
})
|
|
|
|
app.Get("/resource3", func(ctx iris.Context) {
|
|
// If that line is missing and the requested
|
|
// mime type of content is */* or application/xml or application/json
|
|
// then 406 Not Acceptable http error code will be rendered instead.
|
|
//
|
|
// We also add the "gzip" algorithm as an option to encode
|
|
// resources on send.
|
|
ctx.Negotiation().JSON().XML().HTML().EncodingGzip()
|
|
|
|
jsonAndXML := testdata{
|
|
Name: "test name",
|
|
Age: 26,
|
|
}
|
|
|
|
// Prefer that way instead of the '/resource2' above
|
|
// if "iris.N" is a static one and can be declared
|
|
// outside of a handler.
|
|
ctx.Negotiate(iris.N{
|
|
// Text: for text/plain,
|
|
// Markdown: for text/mardown,
|
|
// Binary: for application/octet-stream,
|
|
// YAML: for application/x-yaml,
|
|
// JSONP: for text/javascript
|
|
// Other: for anything else,
|
|
JSON: jsonAndXML, // for application/json
|
|
XML: jsonAndXML, // for application/xml or text/xml
|
|
HTML: "<h1>Test Name</h1><h2>Age 26</h2>", // for text/html
|
|
})
|
|
})
|
|
|
|
return app
|
|
}
|
|
|
|
func main() {
|
|
app := newApp()
|
|
app.Listen(":8080")
|
|
}
|