Convert Springboot Controller Class in Ratpack Handler

Question

I am not able to convert my existing REST Controller into Ratpack Handler with SpringBoot application.

Please anybody help me to get this done. Below is my controller class:

@RestController
@RequestMapping("/api")
public class RestApiController {

    public static final Logger logger = LoggerFactory.getLogger(RestApiController.class);

    @Autowired
    private EmployeeService EmployeeService;

    /**
     * Service will retrieve data for particular Employee
     *
     * @param id Employee Id
     * @return ResponseEntity of Employee
     */
    @GetMapping(value = "/Employee/{id}")
    public Employee getEmployee(@PathVariable("id") String id) {
        logger.info("Fetching Employee with id {}", id);
        return EmployeeService.findById(id);
    }

    /**
     * Service will create Employee data into the System
     *
     * @param Employee             Data of the Employee
     * @param UriComponentsBuilder
     * @return ResponseEntity of String
     */
    @PostMapping(value = "/Employee/")
    public void createEmployee(@RequestBody Employee Employee) {
        logger.info("Creating Employee : {}", Employee);
        EmployeeService.saveEmployee(Employee);
    }
}

Answer 1

public class RatpackMain {

    public static void main(String... args) throws Exception {
        RatpackServer.start(server -> {
            server.serverConfig(config -> {
                // load config, set port, etc.
            }).registry(Guice.registry(bindings -> {
                bindings
                    .bind(EmployeeService.class, EmployeeServiceImpl.class).in(Scopes.SINGLETON)
                    .bind(EmplyeeChain.class).in(Scopes.SINGLETON)
                    .bind(CreateEmployeeHandler.class).in(Scopes.SINGLETON)
                    .bind(GetEmployeeHandler.class).in(Scopes.SINGLETON);
                    // other bindings you may have
            })).handlers(chain -> {
                chain.prefix("api/employee", EmployeeChain.class);
            });
        });
    }
}

public class EmployeeChain implements Action<Chain> {
    @Override
    public void execute(Chain chain) {
        chain.post(CreateEmployeeHandler.class)
                .get(":id", GetEmployeeHandler.class);
    }
}

public class CreateEmployeeHandler implements Handler {

    public static final Logger LOG = LoggerFactory.getLogger(CreateEmployeeHandler.class);

    private EmployeeService employeeService;

    @Inject
    public CreateEmployeeHandler(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @Override
    public void handle(Context ctx) throws Exception {
        ctx.parse(Employee.class).then(employee -> {
            LOG.info("Creating employee: {}", employee);
            employeeService.saveEmployee(employee);
            ctx.getResponse().status(201).send();
        });
    }
}

public class GetEmployeeHandler implements Handler {

    public static final Logger LOG = LoggerFactory.getLogger(GetEmployeeHandler.class);

    private EmployeeService employeeService;

    @Inject
    public GetEmployeeHandler(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @Override
    public void handle(Context ctx) throws Exception {
        String id = ctx.getAllPathTokens().get("id");
        LOG.info("Fetching employee with id {}", id);
        employeeService.findById(id)
                .onError(ctx::error)
                .then(ctx::render);
    }
}

public interface EmployeeService {

    void saveEmployee(Employee employee);

    Promise<Employee> findById(String id);
}

Assuming EmployeeService makes calls to the database, then any blocking operations should be wrapped in calls to Blocking.get().

Ratpack Documentation - Performing Blocking Operations