12:19:50.294 [Test worker] INFO app.privitar.InvPortTest - [test]
└── system properties
└── env variables
└── conf/application.conf
└── defaults
@snowyukischnee Hi, welcome. Try the mvc/controller model
@jknack Hi, when i try to define the mvc controller in the same class which is mainClass in jooby-openapi plugin then the generated openapi.yaml was generated fine, but if i move the controller to an another place then the generated spec was not contain the api spec of that controller
i was seperated the route definitions, app config to another place by writing class which consume Jooby instance like AppConfig and RouteConfig, both those class are inherit Extension interface
Routes from Extension are not considered
but this should works OK:
class MyApp extends Jooby {
{
mvc(new MyController());
}
}
MyController can be in his own file, no need to have in same file as MyApp
@jknack Here is my application code
@OpenAPIDefinition(
info = @Info(
title = "Title",
description = "description",
termsOfService = "Terms",
contact = @Contact(
name = "Jooby",
url = "https://jooby.io",
email = "support@jooby.io"
),
license = @License(
name = "Apache",
url = "https://jooby.io/LICENSE"
),
version = "10"
),
tags = @Tag(name = "mytag")
)
public class App extends Jooby{
public static void main(String[] args) {
Jooby.runApp(args, app -> {
// app name
app.setName(App.class.getSimpleName());
// configs
app.install(new AppConfig());
app.install(new RouterConfig());
});
}
}here is the class that import the mvc controller
public class RouterConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) throws Exception {
app.mvc(CustomerController.class);
}
}here is the controller
@Path("/customer")
public class CustomerController {
@Operation(
summary = "Find a pet by ID",
description = "Find a pet by ID or throws a 404"
)
@Path("/v")
@GET
public Object test() {
return "!";
}
}but the generated api specs return this
openapi: 3.0.1
info:
title: Title
description: description
termsOfService: Terms
contact:
name: Jooby
url: https://jooby.io
email: support@jooby.io
license:
name: Apache
url: https://jooby.io/LICENSE
version: "10"
tags:
- name: mytag
paths: {}
This is not supported:
public class RouterConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) throws Exception {
app.mvc(CustomerController.class);
}
}
Routes from extension are considered internal or infrastructure, not part of an API
Remove that class and just do:
public class App extends Jooby{
public static void main(String[] args) {
Jooby.runApp(args, app -> {
// app name
app.setName(App.class.getSimpleName());
// configs
app.install(new AppConfig());
app.mvc(CustomController.class);
});
}
}
openapi scanner traverse known API calls (except for Extensions)
i've work around this problem by move the OpenAPIDefinition to the RouterConfig class
@OpenAPIDefinition(
info = @Info(
title = "Title",
description = "description",
termsOfService = "Terms",
contact = @Contact(
name = "Jooby",
url = "https://jooby.io",
email = "support@jooby.io"
),
license = @License(
name = "Apache",
url = "https://jooby.io/LICENSE"
),
version = "10"
),
tags = @Tag(name = "mytag")
)
public class RouterConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) throws Exception {
app.mvc(CustomerController.class);
}
}and create my customized openapi module
public class CustomOpenAPIModule extends OpenAPIModule {
private Class<?> apiDefinitionClass;
public CustomOpenAPIModule(Class<?> apiDefinitionClass) {
super();
this.apiDefinitionClass = apiDefinitionClass;
}
@Override
public void install(@Nonnull Jooby application) throws Exception {
String dir = Optional.ofNullable(apiDefinitionClass.getPackage()).map(Package::getName).orElse("/").replace(".", "/");
String appname = apiDefinitionClass.getSimpleName();
Field fFormat = getClass().getSuperclass().getDeclaredField("format");
fFormat.setAccessible(true);
EnumSet<Format> format = (EnumSet<Format>) fFormat.get(this);
Field fopenAPIPath = getClass().getSuperclass().getDeclaredField("openAPIPath");
fopenAPIPath.setAccessible(true);
String openAPIPath = (String) fopenAPIPath.get(this);
for (Format ext : format) {
String filename = String.format("/%s.%s", appname, ext.name().toLowerCase());
String openAPIFileLocation = Router.normalizePath(dir) + filename;
application.assets(Router.noTrailingSlash(Router.normalizePath(openAPIPath + "/openapi." + ext.name().toLowerCase())), openAPIFileLocation);
}
Method mConfigureUI = getClass().getSuperclass().getDeclaredMethod("configureUI", Jooby.class);
mConfigureUI.setAccessible(true);
mConfigureUI.invoke(this, application);
}
}and this is work fine except my code will be bad
why do you need to put the controller inside an Extension?
for example, you are forking how it works and might miss something new from module (like bug fixing, new features, etc)
Also, open-api doesn’t use reflection and your version does it… not necessarily bad but not need it
since my project structure that will seperate the route register from the main app
the App class contains no information about it will has route A or route B
I just move the definition to another to do that
but if you ruly want this, try this instead: https://jooby.io/#router-composing-routes
So you still have your “MainApp"
Then:
public static void main(String[] args) {
Jooby.runApp(args, app -> {
// app name
app.setName(App.class.getSimpleName());
app.install(new GracefulShutdown());
app.decorator(new AccessLogHandler());
app.error(new HttpDefaultJsonHandler());
// metrics
app.install(new MetricsModule("/actuator")
.threadDump()
.ping()
.healthCheck("deadlock", new ThreadDeadlockHealthCheck())
.metric("memory", new MemoryUsageGaugeSet())
.metric("threads", new ThreadStatesGaugeSet())
.metric("gc", new GarbageCollectorMetricSet())
.metric("fs", new FileDescriptorRatioGauge())
);
// openapi
app.install(new CustomOpenAPIModule(RouterConfig.class));
// dependency injection
app.install(new GuiceModule(
// inject here
));
app.mvc(CustomerController.class);
});
}
like this
that is supported by open api
and follow the design/goal of extensions: infrasture support