Detailed explanation

Summary

The golangAnnotations-tool parses your golang source-code into an intermediate representation.

Using this intermediate representation, the tool uses your annotations to generate source code that would be cumbersome and error-prone to write manually.

Bottom line, a lot less code needs to be written.

Example:

// @RestOperation( method = "GET", path = "/person/{uid}" )
func (s *Service) getPerson(c context.Context, uid string) (*Person, error) {
    ...
} 

Based on the annotation line code is generated that will do do all http handling:

• read-request
• unmarshall request
• call business logic
• marshall response
• write response

In addition, typestrong test functions are generated that ease testing of your rest operations.

The same "annotation"-approach is used to ease event-sourcing.

Getting the software

$ go get -u -t -v github.com/MarcGrol/golangAnnotations/...

Testing and installing

$ make gen
$ make test
$ make install

or

$ make

Currently supported annotations

This first implementation provides the following kind of annotations:

• web-services (jax-rs like):

  • Generate server-side http-handling for a "service"
  • Generate client-side http-handling for a "service"
  • Generate helpers to ease integration testing of your services

• event-listeners:

  • Generate server-side http-handling for receiving events
  • Generate helpers to ease integration testing of your event-listeners

• event-sourcing:

  • Describe which events belong to which aggregate
  • Type-strong boiler-plate code to build an aggregate from individual events
  • Type-strong boiler-plate code to wrap and unwrap events into an envelope so that it can be easily stored and emitted

How to use http-server related annotations ("jax-rs"-like)?

A regular golang struct definition with our own "RestService" and "RestOperation"-annotations. Observe that ./examples/rest/tourService.go is used as input.

// @RestService( path = "/api" )
type Service struct {
   ...
}

// @RestOperation( method = "GET", path = "/person/{uid}" )
func (s *Service) getPerson(c context.Context, uid string) (*Person, error) {
    ...
}        

Observe that ./examples/rest/gen_tourService.go have been generated.

Example of the generated http handler.

How to use event-sourcing related annotations?

A regular golang struct definition with our own "Event"-annotation.

// @Event( aggregate = Tour" )
type TourEtappeCreated struct {
    ...
}        

Observe that ./examples/event/gen_wrappers.go and ./examples/event/gen_aggregates.go have been created in ./examples/structExample.

Command to trigger code-generation:

We use the "go:generate" mechanism to trigger our goAnnotations-executable. In order to trigger this mechanisme we use a '//go:genarate' comment with the command to be executed.

example:

//go:generate golangAnnotations -input-dir .

So can can use the regular toolchain to trigger code-genaration

$ cd ${GOPATH/src/github.com/MarcGrol/golangAnnotations
$ go generate ./...
// go imports will fix all the imports
$ for i in `find . -name "*.go"`; do goimports -w -local github.com/ ${i}; done
// fixes formatting for generated code
$ for i in `find . -name "*.go"`; do gofmt -s -w ${i}; done