Considering the API Policy of Jira:
“In general, it may not be possible to create a single plugin artifact that is compatible with different major release families.”
Considering this (in the hard way), usage of API across major release changes of Jira may result in throwing away the complete API of the previous major version and to introduce a totally new API.
This is - my interpretation - not the intention of Atlassian. The result would be, that no plugins (with serious functionality) would be available in the new Jira release. I think (and this is our interpretation), that the API policy is a strict reminder (as far as possible and feasible) for Atlassian to keep an eye on seamless plugin consistency across major Jira versions as well.
Plugin developer requirements (assumption):
To ensure quality and functionality of (non Jira) Plugins, developers would like to have the chance to see (better test) compatibility even across major Jira releases. From our point of view, it should be possible to build a single plugin version which can be deployed on any Jira Version which has not reached end of life.
This does NOT mean, that the plugin (code) can be left unchanged while Atlassian APIs changes as this would NOT allow Atlassian to improve the framework itself. But - and this is important - Atlassian schould (consider) to provide a compile time available solution usable by the plugin across the all framework versions which have not reached EOL.
The problem in the given case is, that :
- the removed method provides core functionality to the most important business object in Jira (the issue!)
- there is no compile time checked solution available supported in 7.x and 8.x
The solution which has been posted here already works. This is the good news. The bad news is: The solution can not be treated as “good” as it relies on reflection. As a result (for the future) usage (better dependency) can not be checked any longer during compile time. A possible failure can only be detected during runtime (e.g. using a test) which is in contrast of using a type safe implementation language (Java) in combination with a proposed API.
At the end of the day reliability of the API decreases and might result in lower stability of provided plugins for the Atlassian framework.
We - as plugin developers - have to deal with the decisions taken by Atlassian. But - here - I take the chance to vote for a solution to be provided by Atlassian considering our concerns regarding the above issue. I am convinced, that our arguments are good enough to be considered in Jira 8.x. Atlassian may even put our solution in a Util class to be further maintained by Atlassian to allow seamless ongoing plugin usage and development in this case.
Comments and feedback to our thoughts are highly appreciated.