Avoiding code duplication

I am trying to write a web application and given the effort to write clean code.

I have a controller for handle incoming request and base controller that all controller will borrow the fields.

This is my base controller

type Controller struct {
	Request  *http.Request
	Response http.ResponseWriter

	// Reqeust language
	lang string

	// HTML parts
	Title   string
	body    string
	head    string
	content string
	view    string
	errors  []string
	success []string
}
// And methods followed here
func (self *Controller) renderHeadView() { .....

and my sign up controller

type Controller struct {
    base.Controller
    user *account
}

func (self *Controller) ServeHTTP(rw http.ResponseWriter, r *http.Request) {

	self.Title = "Sign Up"
	self.Request = r
	self.Response = rw

	self.lang = header.Language(self.Request)
	self.user = &account{lang: self.lang}

	switch self.Request.Method {
	case "GET":
		self.get()
	case "POST":
		if err := self.post(); err != nil {
			self.get()
		} else {
			// If everything was successfully
			return
		}

	}
	self.RenderResponseView()
}

and my activate controller

type Controller struct {
	base.Controller
}

func (self *Controller) ServeHTTP(rw http.ResponseWriter, r *http.Request) {

	self.Title = "Activate account"
	self.Request = r
	self.Response = rw
	self.lang = header.Language(self.Request)

	self.RenderResponseView()
}

As you can see, the ServeHTTP method looks pretty much the same. I am thinking of to move ServeHTTP into base controller and then provide an method to call for special work. To clarify what I mean look at the following code snippet(base controller)

func (self *Controller) ServeHTTP(rw http.ResponseWriter, r *http.Request) {

	self.Title = "Activate account"
	self.Request = r
	self.Response = rw
	self.lang = header.Language(self.Request)
    
    // here would come function for special work
    function()
	self.RenderResponseView()
}

I have no idea how to provide this implementation. I would be very happy, if someone could give me some suggestions.

A good article to refer to is "Middlewares in Go: Best practices and examples"

> The first code smell we encounter when writing a web application in Go is code duplication.
Before processing the request, we will often need to log the request, convert app errors into HTTP 500 errors, authenticate users, etc. And we need to do most of these things for each handler.

> We could create a function with a closure. But if we have multiple functions like that, it will become as bad as callback spaghetti in Javascript. We don't want that.

> So we can write a handler and pass another handler to it.

loggingHandler(recoverHandler(indexHandler))

> So a middleware would be something like func (http.Handler) http.Handler
This way we pass a handler and returns a handler. At the end we have one handler and can be called with http.Handle(pattern, handler)

Alice

> Alice is a small package to chain handlers more elegantly. Furthermore, we can create a common list of handlers and reuse them for each route like this:

func main() {
  commonHandlers := alice.New(loggingHandler, recoverHandler)
  http.Handle("/about", commonHandlers.ThenFunc(aboutHandler))
  http.Handle("/", alice.New(commonHandlers, bodyParserHandler).ThenFunc(indexHandler))
  http.ListenAndServe(":8080", nil)
}

> Problem solved. We now have a middleware system that is idiomatic and use standard interfaces. Alice is 50 lines of code, so it is a very small dependency.