For a good long time now, XAgents have been one of the common ways to do non-HTML output in an XPages environment - JSON, mostly. I think the technique was codified and the term coined by Stephan Wissel back in 2008 and the idea has been the same since.
Effectively, an XAgent lets you write a Servlet but with a bit more scaffolding. Though XPages has a path to use Servlets officially, that method is more out-of-the-way than XAgents and doesn't (without further hoop jumping) give you some niceties like sessionAsSigner.
However, though they're venerable and sort of convenient, XAgents are lacking in a number of ways. For one, stuffing them inside an XPage is ungainly: even if the XPage just calls out to some Java code, you're polluting your UI-element space with something kind of unrelated, forcing you to name your XPages stuff like "apiEmployees.xsp". More importantly, though, it doesn't provide a lot of affordances for the sort of work you'd actually want to do when writing a REST API. Though XPages has a couple mechanisms for generating JSON, little of that is exposed by the XPage editor environment, and I suspect that many or most XAgents writing JSON commit the cardinal sin of doing so through direct string concatenation, likely often without much escaping. Further, there's no built-in mechanism for picking apart path segments or multi-branched routing.
So I figured today is a good opportunity to talk a bit about one of the XPages Jakarta EE Support project's flagship features: writing REST services that consume and emit JSON. This post covers some of the same ground I've talked about before, but sometimes it's useful to re-contextualize this sort of thing.
The XAgent Way
To level-set the discussion, I'll give a starting example in an XAgent, and we'll keep it simple. The idea here will be that you have Person documents in a database and you want to write an API that will take a UNID and emit the corresponding person's first and last name. This is very similar to the Employees example in the "Code-First REST API" example project from the JEE repo, but without diving into more-complex parts or the Jakarta NoSQL data layer.
In an XAgent, you might do something like this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | <?xml version="1.0" encoding="UTF-8"?>
<xp:view xmlns:xp="http://www.ibm.com/xsp/core" viewState="nostate" rendered="false">
<xp:this.afterRenderResponse><![CDATA[#{javascript:
var resp = facesContext.getExternalContext().getResponse();
resp.setContentType("application/json");
var writer = facesContext.getResponseWriter();
var doc = database.getDocumentByUNID(param.unid);
var result = toJson({
"firstName": doc.getItemValueString("FirstName"),
"lastName": doc.getItemValueString("LastName")
});
writer.write(result);
writer.endDocument();
facesContext.responseComplete();
}]]></xp:this.afterRenderResponse>
</xp:view>
|
You'd put that in an XPage and call it like:
1
2 | $ curl http://your.server/someapp.nsf/apiPeople.xsp?unid=68D1CAA80F65780D8525894D006B1CE7
{"lastName":"Fooson","firstName":"Foo"}
|
That does the job well enough. However, this will get gangly very fast. If you want to expand on the types of data the Person document contains, add more operations to the API, add other query parameters, or so forth, you'll have to either have a giant blob of code here, spin it off to an SSJS script library, or move it to Java classes. And, all along the way, the dev environment won't be giving you any help with the process - it knows nothing about writing REST APIs, and so it's all "manual". Better than with a classic agent, but not great.
Jakarta Way, Take 1
So let's move this over to Jakarta EE. We'll start by doing basically a concept-for-concept move: just take the above and make a REST class out of it.
Such a class could look something like this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 | package rest;
import com.ibm.xsp.extlib.util.ExtLibUtil;
import jakarta.json.Json;
import jakarta.json.JsonObject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import lotus.domino.Database;
import lotus.domino.Document;
import lotus.domino.NotesException;
@Path("v1/person")
public class PersonResourceV1 {
@Path("{unid}")
@GET
@Produces(MediaType.APPLICATION_JSON)
public JsonObject get(@PathParam("unid") String unid) throws NotesException {
Database database = ExtLibUtil.getCurrentDatabase();
Document doc = database.getDocumentByUNID(unid);
return Json.createObjectBuilder()
.add("firstName", doc.getItemValueString("FirstName"))
.add("lastName", doc.getItemValueString("LastName"))
.build();
}
}
|
This one you'd call in a similar way, and get similar results:
1
2 | $ curl http://your.server/someapp.nsf/xsp/app/v1/person/68D1CAA80F65780D8525894D006B1CE7
{"firstName":"Foo","lastName":"Fooson"}
|
There's a bit more boilerplate - it is Java - but you can already see some of the benefits. The URL is a little more REST-like and the code is much more task-focused. Instead of disabling all the normal features of the XPage and manually emitting text, a large amount of the code is explicitly describing what you intend to do in a REST service. The @Path annotations describe the components of the URL, and the use of @Path("{unid}") lets us name one of those parts without having to do a query string. Similarly, the @GET and @Produces(MediaType.APPLICATION_JSON) lines directly say what's going on: you can do a GET request to the URL and get JSON back.
These annotations pay off in a couple ways. First of all, the code will be a lot easier to understand when you come back later. Imagine if your API also handled new documents, deletions, and modifications - with an XAgent, you'd have branching paths and would have to rely on either good naming or commenting to mentally traverse it. With this, you would have other methods with similar annotations - @PUT, @POST, @DELETE - and would see exactly where requests are going to go.
And it's not just for you the programmer (or for the next human replacing you when you retire to a beach somewhere): these annotations mean something to tools that process it as well. One such tool comes with the XPages JEE project: the MicroProfile OpenAPI generator. With this class present, you automatically get a useful OpenAPI spec:
1 | $ curl http://your.server/someapp.nsf/xsp/app/openapi.yaml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | ---
openapi: 3.0.3
info:
title: XAgent Comparison
servers:
- url: http://your.server/someapp.nsf/xsp/app
paths:
/v1/person/{unid}:
get:
parameters:
- name: unid
in: path
required: true
schema:
type: string
responses:
"200":
description: OK
content:
application/json:
schema:
type: object
|
This sort of thing pays off tremendously once you start working with a client JS app, especially with a larger development team.
Jakarta Way, Take 2
But we can do better than this. As it is, the direct translation from the XAgent still left the actual output pretty vague. We at least know it's emitting a JSON object, but that's the extent of it. Moreover, the app code wastes some conceptual time actually building the JSON object, which is okay but unnecessary. Let's bring JSON Binding into the mix. This will increase the size of the code, but will pay off in conceptual cleanliness and in future work.
That could look like:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 | package rest;
import com.ibm.xsp.extlib.util.ExtLibUtil;
import jakarta.validation.constraints.NotEmpty;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import lotus.domino.Database;
import lotus.domino.Document;
import lotus.domino.NotesException;
@Path("v2/person")
public class PersonResourceV2 {
// Normally, this class would be in a separate file
public static class Person {
private String firstName;
private @NotEmpty String lastName;
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}
@Path("{unid}")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Person get(@PathParam("unid") String unid) throws NotesException {
Database database = ExtLibUtil.getCurrentDatabase();
Document doc = database.getDocumentByUNID(unid);
Person result = new Person();
result.setFirstName(doc.getItemValueString("FirstName"));
result.setLastName(doc.getItemValueString("LastName"));
return result;
}
}
|
Calling this will work the same way as last time, but with a "v2" to indicate our new-and-improved back end:
1
2 | $ curl http://your.server/someapp.nsf/xsp/app/v2/person/68D1CAA80F65780D8525894D006B1CE7
{"firstName":"Foo","lastName":"Fooson"}
|
What does this get us? Well, for one, we're no longer explicitly working with JSON, which is nice. We could change the media type to XML and the output type will automatically adapt, and the same will go for any future formats we write an adapter for. Additionally, this will work better with a more-structured database access layer. I'll leave that part out here, but the aforementioned "Code-First REST API" example shows that.
Some more of the payoff shows up when we check the generated OpenAPI spec. If we make the same call as above, the output will be more descriptive now:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 | ---
openapi: 3.0.3
info:
title: XAgent Comparison
servers:
- url: http://your.server/someapp.nsf/xsp/app
paths:
/v2/person/{unid}:
get:
parameters:
- name: unid
in: path
required: true
schema:
type: string
responses:
"200":
description: OK
content:
application/json:
schema:
$ref: '#/components/schemas/Person'
components:
schemas:
Person:
required:
- lastName
type: object
properties:
firstName:
type: string
lastName:
minLength: 1
type: string
|
For someone consuming this spec, this is starting to get really good. No longer does the output just say it's a generic JSON object: now it describes it as "Person", shows the two properties that will be output, and declares that lastName will always be at least one character both for input and output. As you add more operations and types, this spec will continue to grow, naturally piggybacking on the annotations and types you write.
Conclusion
Strictly speaking, you can do the same stuff with an XAgent that you can with the XPages JEE project. You could manage the internal complexity and you could manually write the OpenAPI spec, but it would be much, much harder to do, and I think it'd be a safe bet to say that very few XAgent-based APIs have specs to go with them anyway.
Especially as the scope of your app grows, the development and maintenance experience with the JEE approach is night-and-day compared to classical mechanisms like XAgents. If you're still writing APIs that way or similar, I definitely recommend you give this path a try.