import ratpack.handling.Chain; //导入依赖的package包/类
@Override
    public void init() {
        try {
            RatpackServer.start(server -> {
                server.serverConfig(c -> {
                    for(Action<ServerConfigBuilder> cfg : getConfigurators()) {
                        c = cfg.with(c);
                    }
                });
                server.registry(Guice.registry(b -> {
                    for(Action<BindingsSpec> binding : getBindings()) {
                        b = binding.with(b);
                    }
                }));
                server.handlers(chain -> {
                    for(Action<Chain> handler : getHandlers()) {
//                        chain = chain.insert(handler);
                        chain = handler.with(chain);
                    }
                });
            });
        } catch (Exception e) {
            logger.error("Ratpack failure", e);
        }
    }
 

import ratpack.handling.Chain; //导入依赖的package包/类
public BaseServer(Action<Chain> handlers, ServerConfig config, Action<BindingsSpec> binding) throws ServerException {
    try {
        this.ratpackServer = RatpackServer.of(def ->
                def.serverConfig(config)
                        .registry(Guice.registry(binding))
                        .handlers(handlers));
    } catch (Exception e) {
        throw new ServerException("Error in building ratpack server.", e);
    }
}
 

import ratpack.handling.Chain; //导入依赖的package包/类
@Override
public void execute(Chain chain) throws Exception {
    //handle all requests to /users
    chain.prefix(UsersCollectionHandler.COLLECTION_NAME, chain.getRegistry().get(UsersCollectionHandler.class))
            //default handler, show REST endpoints
            .handler(ctx -> ctx.render("Users Service - list users: 'GET /v1/users' "));
}
 

import ratpack.handling.Chain; //导入依赖的package包/类
@Override
public void execute(Chain chain) throws Exception {
    chain
            //connections is a server side collection
            .handler(":user/connections", this::handleGetUserConnectionsListAsync)
                    //connect is a controller for resource user, another user id is passed as query parameter 'to'
                    //e.g. POST /v1/users/<user-id>/connect?to=<another-user-id>
            .handler(":user/connect", this::handleConnectionCreationAsync)
            .handler(context ->
                    //specify handlers for HTTP methods, (i.e. GET /users -> handleGetAllUsersAsync)
                    context.byMethod(spec ->
                            spec.post(this::handleAddNewUserAsync)));

}
 

import ratpack.handling.Chain; //导入依赖的package包/类
@Override
public void execute(Chain chain) throws Exception {
    //read id parameter from path
    chain
            //mapped to /v1/entities/:id
            .handler(":id", ctx -> ctx.byMethod(spec -> spec.get(this::handleFindByIdAsync)))
                    //mapped to /v1/entities
            .handler(ctx -> ctx.byMethod(spec -> spec.get(this::handleGetListAsync).post(this::handleSaveAsync)));
}
 

import ratpack.handling.Chain; //导入依赖的package包/类
public List<Action<Chain>> getHandlers() {
    return handlers;
}
 

import ratpack.handling.Chain; //导入依赖的package包/类
@Override
public void execute(Chain chain) throws Exception {
    chain.prefix(EntitiesCollectionHandler.COLLECTION_NAME, chain.getRegistry().get(EntitiesCollectionHandler.class))
            //default handler, show REST endpoints
            .handler(ctx -> ctx.render("Persistence Service:\nSave: POST /v1/entities\nGet by id: GET /v1/entities/:id"));
}
 

import ratpack.handling.Chain; //导入依赖的package包/类
/**
 * Creates an embedded application with a default launch config (no base dir, ephemeral port) and the given handler chain.
 * <p>
 * If you need to tweak the launch config, use {@link #fromLaunchConfigBuilder(Function)}.
 *
 * @param action the handler chain definition
 * @return a newly created embedded application
 */
static EmbeddedApp fromChain(Action<? super Chain> action) {
    return fromLaunchConfigBuilder(lcb -> lcb.build(lc -> Handlers.chain(lc, action)));
}