Accessing Confluence Components from Plugin Modules

Confluence is built around Spring, an open-source component framework for Java.

If you are familiar with Spring, then you may only wish to know that Confluence plugin modules (and their implementing classes) are autowired by name. Thus, if you want to access a Confluence component from your plugin, just include the appropriate setter method in your implementing class.

If you want to write Confluence plugins but are unfamiliar with Spring, the rest of this page should give you more than enough information on how to have your plugin interact with Confluence.

Interacting with Confluence

When you are writing anything but the simplest Confluence plugin, you will need to interact with the Confluence application itself in order to retrieve, change or store information. This document describes how this can be done.

Manager Objects

At the core of Confluence is a group of "Manager" objects. For example, the pageManager is in charge of Confluence pages, the spaceManager of spaces, the attachmentManager of attachments, and so on.

Dependency Injection

Traditionally, in a component-based system, components are retrieved from some kind of central repository. For example, in an EJB-based system, you would retrieve the bean from the application server's JNDI repository.

Confluence works the other way round. When a plugin module is instantiated, Confluence determines which components the module needs, and delivers them to it.

Confluence determines which components a module needs by reflecting on the module's methods. There are two different mechanisms that are used, based on whether you are using a v1 or v2 plugin.

Setter-based injection (v1 plugins)

With setter-based injection, any method with a signature that matches a standard JavaBeans-style setter of the same name as a Confluence component will have that component passed to it when the module is initialised.

So, if your plugin module needs to access the pageManager, all you need to do is put the following setter method on your module's implementing class:

public void setPageManager(PageManager pageManager)
{
    this.pageManager = pageManager;
}
Constructor-based injection (v2 plugins)

With constructor-based injection, the constructor which has the greatest number of arguments which can be satisfied by Confluence or plugin components will be called by Spring when constructing your module.

So, if your plugin module needs to access the pageManager, you need to have a constructor which takes a PageManager instance and assigns it to a field for later use:

public class MyModule {
    private final PageManager pageManager;

    public MyModule(PageManager pageManager) {
        this.pageManager = pageManager;
    }

    // ...
}

With constructor injection, you need to make sure there are no circular dependencies among your modules. If there are, you plugin will fail to start up and you will see an error message in the Confluence log file with information about the dependency problem.

Manager Classes

There are several dozen managers for different areas of functionality in Confluence. The following table lists some of the more commonly used ones:

Manager class

Responsibility

Sample methods

PageManager

Pages, blogs

getPage(), getBlogPost(), getRecentlyAddedPages(), findNextBlogPost(), saveContentEntity()

SpaceManager

Spaces

getSpace(), getPersonalSpace(), createSpace()

UserAccessor

Users, groups, preferences

getUser(), addUser(), addMembership(), hasMembership(), getConfluenceUserPreferences(), getUserProfilePicture()

CommentManager

Comments

getComment(), updateCommentContent()

LabelManager

Labels

addLabel(), removeLabel(), getCurrentContentForLabel()

AttachmentManager

Attachment storage and retrieval

getAttachments(Content), getAttachmentData(Attachment), saveAttachment()

SmartListManager

Searching (2.8 and earlier)

getListQueryResults()

SearchManager

Searching (2.9 and later)

search(), convertToEntities(), searchEntities()

ContentEntityManager

Saving and retrieving all content. Parent interface of PageManager, CommentManager, etc.

saveContentEntity(), getVersionHistorySummaries()

SettingsManager

Global, space, plugin configuration

getGlobalSettings(), updateSpaceSettings(), getPluginSettings()

I18NBean

Getting localised text

getText(String), getText(String, Object[]), getText(String, List)

PermissionManager

Checking permissions (do this before calling a manager)

hasPermission(), hasCreatePermission(), isConfluenceAdministrator(), getPermittedEntities()

SpacePermissionManager

Adding or modifying space permissions

savePermission(), getGlobalPermissions(), getGroupsWithPermissions()

EventManager

Register listeners or publish events

publishEvent(), registerListener()

WebInterfaceManager

Rendering web-sections and web-items in Velocity

getDisplayableSections(), getDisplayableItems()

Note that these are all interfaces. The actual implementation will be injected in your class by Spring, if you include the appropriate setter method in your class as described above.

Do not directly use implementations or cast the injected class to a particular implementation. Implementation classes are subject to change across versions without warning. Where possible, interface methods will be marked as deprecated for two major versions before being removed.

Service Classes

Managers in Confluence are responsible for the data integrity of their domain, but they are not generally responsible for validation or security. Invalid calls will typically result in a runtime exception. Historically, this wasn't a major problem, but as time went by there was more duplication of this functionality across actions, remote API methods and plugins. In recent releases, a service layer is being introduced in Confluence to address this.

The services will follow a command pattern, where the service is responsible for creating a command that can then be validated and executed. The following nascent services are available:

Service class

Responsibility

Sample commands

CommentService

Comments

CreateCommentCommand, DeleteCommentCommand, EditCommentCommand

PageService

Pages, blog posts

MovePageCommand

SearchService (2.9+)

Performing searches

These simpler services don't follow the command pattern, nor do they perform any data modification. They are generally used to simplify other functionality:

Service class

Responsibility

HttpRetrievalService

Http Connectivity to External Services

More information

Was this page helpful?

Have a question about this article?

See questions about this article

Powered by Confluence and Scroll Viewport