Clean architecture

@lievendoclo#DevoxxPL
Platinum Sponsor:
Implementing Clean
Architecture
Lieven DOCLO
ACA IT Solutions

• Senior Java Engineer @ ACA
• Software craftsman
• Design and architecture afficionado
Who am I?
www.insaneprogramming.be

What is this about?

Clean Architecture?

• Hexagonal
• Onion
• Screaming
It’s a mixed bag of goodies

• Core concepts been around for decades
• Got popular by the 2012 article by Robert C. Martin
• A lot of video’s onYouTube
It’s been around for a while

The use cases
@FunctionalInterface
@Boundary
public interface CreateBuilding {
String execute(CreateBuildingRequest request);
}
@Value
public class CreateBuildingRequest {
private final String name;
}
@FunctionalInterface
@Boundary
public interface GetBuilding {
BuildingResponseModel execute(GetBuildingRequest request);
}
@Value
public class BuildingResponseModel {
private final String id;
}
@Value
public class GetBuildingRequest {
private final String buildingId;
}

Exposing the use case through REST
@RestController
@RequestMapping("/building")
public class BuildingController {
private final CreateBuilding createBuilding;
public BuildingController(CreateBuilding createBuilding) {
this.createBuilding = createBuilding;
}
@PostMapping
public ResponseEntity create(@RequestBody CreateBuildingJsonPayload payload) {
String id = createBuilding.execute(new CreateBuildingRequest(payload.getName()));
return ResponseEntity.created(URI.create("/building/" + id))
.build();
}
}

@GET
@Produces("application/json")
@Path("/{buildingId}")
public BuildingJson get(@PathParam(("buildingId")) String buildingId) {
BuildingResponseModel response = getBuilding.execute(
new GetBuildingRequest(buildingId));
return present(response);
}
public BuildingJson present(BuildingResponseModel buildingResponse) {
return new BuildingJson(buildingResponse.getId(), buildingResponse.getName());
}
@Value
public class BuildingJson {
}

@Immutable
public class BuildingResponseModel {
public <T> T present(Function<BuildingResponseModel, T> presentFunction) {
return presentFunction.apply(this);
}
}
@GET
@Produces("application/json")
@Path("/{buildingId}")
public BuildingJson get(@PathParam(("buildingId")) String buildingId) {
BuildingResponseModel responseModel = getBuilding.execute(
new GetBuildingRequest(buildingId));
return responseModel.present(m ->
new BuildingJson(m.getId(), m.getName()));
}

• Freedom to choose your exposure
• REST
• JSON-RPC
• SOAP
• Messaging solutions
• …
Exposing the use case

You can already try this out
@Transactional
@Named
public class CreateBuildingMock implements CreateBuilding {
@Override
public String execute(CreateBuildingRequest request) {
return "42";
}
}
@SpringBootApplication
public class Runner {
public static void main(String[] args) {
SpringApplication.run(Runner.class, args);
}
}

Creating the domain
@Value
public class Building {
}
public interface BuildingEntityGateway {
String save(Building building);
Building get(String id);
}

May the real use case please stand up?
@Transactional
@Named
public class CreateBuildingImpl implements CreateBuilding {
private final BuildingEntityGateway buildingEntityGateway;
public CreateBuildingImpl(BuildingEntityGateway buildingEntityGateway) {
this.buildingEntityGateway = buildingEntityGateway;
}
@Override
public String execute(CreateBuildingRequest request) {
Building building = new Building(null, request.getName());
return buildingEntityGateway.save(building);
}
}

Again: you can try this out
@Named
public class MockBuildingEntityGateway implements BuildingEntityGateway {
@Override
public String save(Building building) {
return "42";
}
@Override
public Building get(String id) {
return new Building(id, “Acme Corp HQ”);
}
}

Implementing the gateway
@Named
public class MongoDbBuildingEntityGateway implements BuildingEntityGateway {
private final Datastore datastore;
public MongoDbBuildingEntityGateway(Datastore datastore) {
this.datastore = datastore;
}
public String save(Building building) {
return datastore.save(
new BuildingDocument(building.getId(), building.getName())
).getId();
}
} @Value
public class BuildingDocument {
@Id
}

• Once again, complete freedom
• MongoDB
• JPA
• JDBC
• Kafka
• Layering
• Caching
• Calling other API’s (REST or other)
Implementing the gateway

• A lot of data structures for a simple write
• Building
• CreateBuildingRequestModel
• CreateBuildingJsonPayload
• BuildingDocument
• When adding reads, it gets worse
• BuildingResponseModel
• JsonBuilding
Decoupling has a price

• You can make compromises
• Add JPA annotations on domain
• Add JSON annotations on response 
models
• You can expose your use cases through 
RPC (decoupling danger)
• Return the domain from the use case 
(wouldn’t recommend it tho, decoupling)
• DDD leakage, need to use interfaces on domain
• Your JSON payload extends the use case request model
• Your JSON view model extends the use case response model
Being pragmatic

• You can make bad compromises
• Add JPA and JSON annotations on domain 
and use a single data structure
• Exposing your gateways to the 
outside world
• “We’re only doing CRUD anyway!”
Being too pragmatic

• Compromises are not a bad thing
• Going pure isn’t always the most efficient way forward
• Perfection isn’t always needed or even wanted
• Nice to strive for though
• They can be an acceptable level of technical debt
• But it’s debt nonetheless
• There may come a day someone will collect
• Hint: keep track compromise decisions
Just remember

Using modular approach

• Using Kotlin
• Going reactive
• Use event sourcing
Getting all fancy in 2017
interface CreateBuilding {
fun create(request: Mono<CreateBuildingRequest>):
Mono<CreateBuildingResponse>
}
interface GetBuildings {
fun list(): Flux<BuildingResponse>
}

• Clean Architecture can be evolutionary
• Start off from use cases
• Services
• Go up or down
• Fit for purpose
What about legacy projects?
#TDD

• More readable code
• Also for business people!
• More maintainable code
• Every layer is easily testable
• Unit tests
• Integration tests
• System tests
• Modular boundaries more easily enforced
So why use Clean Architecture?

• As little frameworks as possible in inner layers
• Domain logic and business logic, that’s it!
• Choices are made on the outside (infrastructure) layers
• Easy interchangeability
• The main partition does the runtime wiring
• You can choose Spring Boot, Java EE, Dropwizard or OSGi
here
Just remember

#DevoxxPL @lievendoclo
https://github.com/lievendoclo/cleanarch

Clean architecture

More Related Content

Similar to Clean architecture

Recently uploaded

Clean architecture