import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.POST)
public void submit(final Callback<HttpResponse<String>> callback) {
    final HttpContext httpContext = new HttpContext();
    final Optional<HttpRequest> httpRequest = httpContext.getHttpRequest();


    final StringBuilder sb = new StringBuilder(128);

    if (httpRequest.isPresent()) {
        sb.append("Content Type :" ).append(httpRequest.get().getContentType()).append("\n");
        sb.append(" Method :").append(httpRequest.get().getMethod()).append("\n");
        sb.append(" Form Body Length ").append(httpRequest.get().getBody().length).append("\n");
        sb.append(" Params ").append(httpRequest.get().getParams().toString()).append("\n");
        sb.append(" Form Params ").append(httpRequest.get().getFormParams().toString()).append("\n");

        HttpTextResponse textResponse = HttpResponseBuilder.httpResponseBuilder()

                .setJsonBodyCodeOk(sb.toString())
                .buildTextResponse();

        callback.accept(textResponse);
    }
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/find")
public void findEmployee(final Callback<Employee> employeeCallback,
                         @RequestParam("name") final String name) {

    final long startTime = super.time;

    final CallbackBuilder callbackBuilder = super.reactor.callbackBuilder();
    callbackBuilder.delegateWithLogging(employeeCallback, logger, "employeeMap3");
    callbackBuilder.withOptionalCallback(Employee.class, employeeOptional -> {


        /** Record timing. */
        super.recordTiming("findEmployee", time - startTime);

        if (employeeOptional.isPresent()) {
            /* Increment count of employees found. */
            super.incrementCount("employeeFound");
            employeeCallback.returnThis(employeeOptional.get());
        } else {
            /* Increment count of employees not found. */
            super.incrementCount("employeeNotFound");
            employeeCallback.onError(new Exception("Employee not found"));
        }
    });
    employeeService.findEmployeeByName(callbackBuilder.build(), name);
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/find")
public void findEmployee(final Callback<Employee> employeeCallback,
                         @RequestParam("name") final String name) {

    final CallbackBuilder callbackBuilder = CallbackBuilder.newCallbackBuilder();
    // Forward to error handling and timeout defined in empMapCallback, but install some additional logging for
    // timeout and error handling that associates the error and timeout handling with this call.
    callbackBuilder.delegateWithLogging(employeeCallback, logger, "employeeMap3");
    callbackBuilder.withOptionalCallback(Employee.class, employeeOptional -> {


        if (employeeOptional.isPresent()) {
            employeeCallback.returnThis(employeeOptional.get());
        } else {
            employeeCallback.onError(new Exception("Employee not found"));
        }
    });
    employeeService.findEmployeeByName(callbackBuilder.build(), name);
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping ("http-info")
public String httpInfo() {

    final StringBuilder builder = new StringBuilder();
    final HttpContext httpContext = new HttpContext();
    final Optional<HttpRequest> httpRequest = httpContext.getHttpRequest();
    if (httpRequest.isPresent()) {
        builder.append("URI = ").append(httpRequest.get().getUri()).append("\n");
        builder.append("HTTP Method = ").append(httpRequest.get().getMethod()).append("\n");
        builder.append("USER AGENT = ").append(
                httpRequest.get().getHeaders().getFirst(HttpHeaders.USER_AGENT)).append("\n");
    } else {
        builder.append("request not found");
    }


    final RequestContext requestContext = new RequestContext();

    if (requestContext.getMethodCall().isPresent()) {
        final MethodCall<Object> methodCall = requestContext.getMethodCall().get();
        builder.append("Object Name = ").append(methodCall.objectName()).append("\n");
        builder.append("Method Name = ").append(methodCall.name()).append("\n");
    }
    return builder.toString();
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping(value = "/hello8", contentType = "application/xml", code = HttpStatus.CREATED)
public void hello8(final Callback<HttpTextResponse> callback) {

    final HttpTextResponse response = HttpResponseBuilder
            .httpResponseBuilder()
            .setBody("<xml><hi>hello world</hi></xml>")
            .setCode(201).buildTextResponse();
    callback.returnThis(response);
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/emap")
public void employeeMap(final Callback<Map<String, Employee>> empMapCallback) {

    final CallbackBuilder callbackBuilder =  super.reactor.callbackBuilder();
    callbackBuilder.wrap(empMapCallback); //Forward to error handling, timeout, and callback defined in empMapCallback
    employeeService.getEmployeesAsMap(callbackBuilder.build());

}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/emap2")
public void employeeMap2(final Callback<Map<String, Employee>> empMapCallback) {

    final CallbackBuilder callbackBuilder = super.reactor.callbackBuilder();
    callbackBuilder.delegate(empMapCallback); //Forward to error handling and timeout defined in empMapCallback

    callbackBuilder.withMapCallback(String.class, Employee.class, employeeMap -> {
        logger.info("GET MAP {}", employeeMap);
        empMapCallback.returnThis(employeeMap);
    });
    employeeService.getEmployeesAsMap(callbackBuilder.build());

}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/emap3")
public void employeeMap3(final Callback<Map<String, Employee>> empMapCallback) {

    final CallbackBuilder callbackBuilder = super.reactor.callbackBuilder();
    // Forward to error handling and timeout defined in empMapCallback, but install some additional logging for
    // timeout and error handling that associates the error and timeout handling with this call.
    callbackBuilder.delegateWithLogging(empMapCallback, logger, "employeeMap3");
    callbackBuilder.withMapCallback(String.class, Employee.class, employeeMap -> {
        logger.info("GET MAP {}", employeeMap);
        empMapCallback.returnThis(employeeMap);
    });
    employeeService.getEmployeesAsMap(callbackBuilder.build());
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/elist")
public void employeeList(final Callback<List<Employee>> empListCallback) {

    final CallbackBuilder callbackBuilder = super.reactor.callbackBuilder();
    // Forward to error handling and timeout defined in empMapCallback, but install some additional logging for
    // timeout and error handling that associates the error and timeout handling with this call.
    callbackBuilder.delegateWithLogging(empListCallback, logger, "employeeList");
    callbackBuilder.withListCallback(Employee.class, employeeList -> {
        logger.info("GET List {}", employeeList);
        empListCallback.returnThis(employeeList);
    });
    employeeService.getEmployeesAsList(callbackBuilder.build());
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/emap")
public void employeeMap(final Callback<Map<String, Employee>> empMapCallback) {

    final CallbackBuilder callbackBuilder = CallbackBuilder.newCallbackBuilder();
    callbackBuilder.wrap(empMapCallback); //Forward to error handling, timeout, and callback defined in empMapCallback
    employeeService.getEmployeesAsMap(callbackBuilder.build());

}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/emap2")
public void employeeMap2(final Callback<Map<String, Employee>> empMapCallback) {

    final CallbackBuilder callbackBuilder = CallbackBuilder.newCallbackBuilder();
    callbackBuilder.delegate(empMapCallback); //Forward to error handling and timeout defined in empMapCallback

    callbackBuilder.withMapCallback(String.class, Employee.class, employeeMap -> {
        logger.info("GET MAP {}", employeeMap);
        empMapCallback.returnThis(employeeMap);
    });
    employeeService.getEmployeesAsMap(callbackBuilder.build());

}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/emap3")
public void employeeMap3(final Callback<Map<String, Employee>> empMapCallback) {

    final CallbackBuilder callbackBuilder = CallbackBuilder.newCallbackBuilder();
    // Forward to error handling and timeout defined in empMapCallback, but install some additional logging for
    // timeout and error handling that associates the error and timeout handling with this call.
    callbackBuilder.delegateWithLogging(empMapCallback, logger, "employeeMap3");
    callbackBuilder.withMapCallback(String.class, Employee.class, employeeMap -> {
        logger.info("GET MAP {}", employeeMap);
        empMapCallback.returnThis(employeeMap);
    });
    employeeService.getEmployeesAsMap(callbackBuilder.build());
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/elist")
public void employeeList(final Callback<List<Employee>> empListCallback) {

    final CallbackBuilder callbackBuilder = CallbackBuilder.newCallbackBuilder();
    // Forward to error handling and timeout defined in empMapCallback, but install some additional logging for
    // timeout and error handling that associates the error and timeout handling with this call.
    callbackBuilder.delegateWithLogging(empListCallback, logger, "employeeList");
    callbackBuilder.withListCallback(Employee.class, employeeList -> {
        logger.info("GET List {}", employeeList);
        empListCallback.returnThis(employeeList);
    });
    employeeService.getEmployeesAsList(callbackBuilder.build());
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping("/register")
@Auth
public SessionModel register(
        @RequestParam("email") String email,
        @RequestParam("password") String password
) {
    return new SessionModel("SESSION_ID");
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping(value = "/todo", method = RequestMethod.POST,
        description = "add a todo item to the list", summary = "adds todo",
        returnDescription = "returns true if successful")
public boolean add(final Todo todo) {

    todoMap.put(todo.getId(), todo);
    return true;
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping(value = "/todo", method = RequestMethod.DELETE,
        description = "Deletes an item by id",  summary = "delete a todo item")
public void remove(@RequestParam(value = "id", description = "id of Todo item to delete")
                       final String id) {

    todoMap.remove(id);
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
/**
 * Run a gc if possible.
 *
 * @return true if no exceptions
 */
@RequestMapping(value = "/suggest-gc", summary = "run a gc if possible",
        description = "Run a System.gc().",
        returnDescription = "if run and there were no exceptions, returns true"
)
public boolean suggestGC() {
    System.gc();
    return true;
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
/**
 * Read annotation.
 *
 * @return swagger meta data
 */
@RequestMapping(value = "/meta/", summary = "swagger meta data about this service",
        description = "Swagger meta data. Swagger is used to generate " +
                "documents and clients.",
        returnDescription = "returns Swagger 2.0 JSON meta data."
)
public ServiceEndpointInfo getServiceEndpointInfo() {

    return serviceEndpointInfo;
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
/**
 * Read annotation.
 *
 * @return swagger meta data for admin
 */
@RequestMapping(value = "/admin-meta/", summary = "swagger meta data about the admin services",
        description = "Swagger admin meta data for the admin itself. Swagger is used to generate " +
                "documents and clients.",
        returnDescription = "returns Swagger 2.0 JSON meta data."
)
public ServiceEndpointInfo getAdminServiceEndpoint() {

    return adminServiceEndpoint;
}
 

import io.advantageous.qbit.annotation.RequestMapping; //导入依赖的package包/类
@RequestMapping(value = "/system/property/",
        summary = "",
        description = "",
        returnDescription = "")
public Map<String, String> getSystemProperties() {
    Map<String, String> propertyMap = new LinkedHashMap<>(System.getProperties().size());

    System.getProperties().entrySet().stream()
            .filter(entry -> !isBlackListed((String) entry.getKey()))
            .forEach(
                    entry -> propertyMap.put(entry.getKey().toString(), entry.getValue().toString()));
    return propertyMap;
}