JDA strives to provide a clean and full wrapping of the Discord REST api and its Websocket-Events for Java.
JDA will be continued with version 3.x and will support Bot-features (for bot-accounts) and Client-features (for user-accounts). Please see the Discord docs for more information about bot accounts.
This officially makes JDA-Client deprecated. Please do not continue using it, and instead switch to the promoted 3.x version listed further below.
Creating the JDA Object is done via the JDABuilder class by providing an AccountType (Bot/Client).
After setting the token via setter,
the JDA Object is then created by calling the .buildBlocking()
or the .buildAsync()
(non-blocking login) method.
Example:
JDA jda = new JDABuilder(AccountType.BOT).setToken("token").buildBlocking();
Note: It is important to set the correct AccountType because Bot-accounts require a token prefix to login.
Using EventListener:
public class ReadyListener implements EventListener
{
public static void main(String[] args)
throws LoginException, RateLimitedException, InterruptedException
{
// Note: It is important to register your ReadyListener before building
JDA jda = new JDABuilder(AccountType.BOT)
.setToken("token")
.addEventListener(new ReadyListener())
.buildBlocking();
}
@Override
public void onEvent(Event event)
{
if (event instanceof ReadyEvent)
System.out.println("API is ready!");
}
}
Using ListenerAdapter:
public class MessageListener extends ListenerAdapter
{
public static void main(String[] args)
throws LoginException, RateLimitedException, InterruptedException
{
JDA jda = new JDABuilder(AccountType.BOT).setToken("token").buildBlocking();
jda.addEventListener(new MessageListener());
}
@Override
public void onMessageReceived(MessageReceivedEvent event)
{
if (event.isFromType(ChannelType.PRIVATE))
{
System.out.printf("[PM] %s: %s\n", event.getAuthor().getName(),
event.getMessage().getContentDisplay());
}
else
{
System.out.printf("[%s][%s] %s: %s\n", event.getGuild().getName(),
event.getTextChannel().getName(), event.getMember().getEffectiveName(),
event.getMessage().getContentDisplay());
}
}
}
Note: In these examples we override methods from the inheriting class
ListenerAdapter
.
The usage of the@Override
annotation is recommended to validate methods.
Discord allows Bot-accounts to share load across sessions by limiting them to a fraction of the total connected Guilds/Servers of the bot.
This can be done using sharding which will limit JDA to only a certain amount of Guilds/Servers including events and entities.
Sharding will limit the amount of Guilds/Channels/Users visible to the JDA session so it is recommended to have some kind of elevated management to
access information of other shards.
To use sharding in JDA you will need to use JDABuilder.useSharding(int shardId, int shardTotal)
. The shardId is 0-based which means the first shard
has the ID 0. The shardTotal is the total amount of shards (not 0-based) which can be seen similar to the length of an array, the last shard has the ID of
shardTotal - 1
.
When using sharding it is also recommended to use a SessionReconnectQueue
instance for all shards. This allows JDA to properly
handle reconnecting multiple shards without violating Discord limitations (not using this might cause an IP ban on bad days).
Additionally to keep track of the global REST rate-limit JDA has a ShardedRateLimiter
which is set by default when using the same JDABuilder
for all shards. If you want to use multiple builders to build your shards you should use the same ShardedRateLimiter instance!
Logins between shards must happen with a minimum of 5 SECONDS of backoff time. JDA will inform you if the backoff is too short with a log message:
Encountered IDENTIFY (OP 2) Rate Limit! Waiting 5 seconds before trying again!
Note: Failing to backoff properly will cause JDA to wait 5 seconds after failing to connect. Respect the 5 second login rate limit!
public static void main(String[] args) throws Exception
{
JDABuilder shardBuilder = new JDABuilder(AccountType.BOT).setToken(args[0]).setReconnectQueue(new SessionReconnectQueue());
//register your listeners here using shardBuilder.addEventListener(...)
shardBuilder.addEventListener(new MessageListener());
for (int i = 0; i < 10; i++)
{
//using buildBlocking(JDA.Status.AWAITING_LOGIN_CONFIRMATION)
// makes sure we start to delay the next shard once the current one actually
// sent the login information, otherwise we might hit nasty race conditions
shardBuilder.useSharding(i, 10)
.buildBlocking(JDA.Status.AWAITING_LOGIN_CONFIRMATION);
Thread.sleep(5000); //sleep 5 seconds between each login
}
}
Note: We are not setting a
ShardedRateLimiter
here as it isn't necessary when we use the same builder!
When you use multiple builders you should use JDABuilder.setShardedRateLimiter(ShardedRateLimiter) with a shared instance of the same ShardedRateLimiter!
We provide a small set of Examples in the Example Directory.
In addition you can look at the many Discord Bots that were implemented using JDA:
Latest Stable Version: GitHub Release
Latest Version:
Be sure to replace the VERSION key below with the one of the versions shown above!
Maven
<dependency>
<groupId>net.dv8tion</groupId>
<artifactId>JDA</artifactId>
<version>VERSION</version>
</dependency>
<repository>
<id>jcenter</id>
<name>jcenter-bintray</name>
<url>http://jcenter.bintray.com</url>
</repository>
Gradle
dependencies {
compile 'net.dv8tion:JDA:VERSION'
}
repositories {
jcenter()
}
The builds are distributed using JCenter through Bintray JDA JCenter Bintray
JDA is using SLF4J to log its messages.
That means you should add some SLF4J implementation to your build path in addition to JDA. If no implementation is found, following message will be printed to the console on startup:
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
JDA currently provides a fallback Logger in case that no SLF4J implementation is present. We strongly recommend to use one though, as that can improve speed and allows you to customize the Logger as well as log to files
The most popular implementations are Log4j 2 and Logback
Docs can be found on the Jenkins or directly here
A simple Wiki can also be found in this repository's Wiki section
If you need help, or just want to talk with the JDA or other Devs, you can join the Official JDA Discord Guild.
Alternatively you can also join the Unofficial Discord API Guild.
Once you joined, you can find JDA-specific help in the #java_jda
channel.
For guides and setup help you can also take a look at the wiki
Especially interesting are the Getting Started
and Setup Pages.
Created and maintained by sedmelluq
LavaPlayer is the most popular library used by Music Bots created in Java.
It is highly compatible with JDA and Discord4J and allows to play audio from
Youtube, Soundcloud, Twitch, Bandcamp and more providers.
The library can easily be expanded to more services by implementing your own AudioSourceManager and registering it.
It is recommended to read the Usage section of LavaPlayer
to understand a proper implementation.
Sedmelluq provided a demo in his repository which presents an example implementation for JDA:
https://github.com/sedmelluq/lavaplayer/tree/master/demo-jda
Created and maintained by jagrosh.
JDA-Utilities provides a Command-Extension and several utilities to make using JDA very simple.
Features include:
- Paginated Message using Reactions
- EventWaiter allowing to wait for a response and other events
Created and maintained by sedmelluq
JDAction is a Gradle plugin which makes sure that the return values of all methods which return a RestAction are used.
Since it is a common mistake to forget to .queue()
/.complete()
/.submit()
RestActions,
and it is often only discovered after noticing that something doesn't work,
this plugin will help catch those cases quickly as it will cause a build failure in such case.
More info about RestAction: Wiki
More can be found in our github organization: JDA-Applications
If you want to contribute to JDA, make sure to base your branch off of our development branch (or a feature-branch) and create your PR into that same branch. We will be rejecting any PRs between branches or into release branches!
It is also highly recommended to get in touch with the Devs before opening Pull Requests (either through an issue or the Discord servers mentioned above).
It is very possible that your change might already be in development or you missed something.
More information can be found at the wiki page Contributing
When a feature is introduced to replace or enhance existing functionality we might deprecate old functionality.
A deprecated method/class usually has a replacement mentioned in its documentation which should be switched to. Deprecated
functionality might or might not exist in the next minor release. (Hint: The minor version is the MM
of XX.MM.RR_BB
in our version format)
It is possible that some features are deprecated without replacement, in this case the functionality is no longer supported by either the JDA structure due to fundamental changes (for example automation of a feature) or due to discord API changes that cause it to be removed.
We highly recommend to discontinue usage of deprecated functionality and update by going through each minor release instead of jumping. For instance, when updating from version 3.3.0 to version 3.5.1 you should do the following:
- Update to
3.4.RR_BB
and check for deprecation, replace - Update to
3.5.1_BB
and check for deprecation, replace
The BB
indicates the build number specified in the release details.
The RR
in version 3.4.RR
should be replaced by the latest version that was published for 3.4
, you can find out which the latest
version was by looking at the release page
This project requires Java 8.
All dependencies are managed automatically by Gradle.
- NV Websocket Client
- Version: 2.2
- Github
- JCenter Repository
- OkHttp
- Version: 3.8.1
- Github
- JCenter Repository
- Apache Commons Collections4
- Version: 4.1
- Website
- JCenter Repository
- org.json
- Version: 20160810
- Github
- JCenter Repository
- JNA
- Version: 4.4.0
- Github
- JCenter Repository
- Trove4j
- Version: 3.0.3
- BitBucket
- JCenter Repository
- slf4j-api
- Version: 1.7.25
- Website
- JCenter Repository
See also: https://discordapp.com/developers/docs/topics/libraries