Level up your Twilio API skills in TwilioQuest, an educational game for Mac, Windows, and Linux. Download Now
Build the future of communications.
Start building for free
  • By Matthew Gilliard
    Comment Lire et Comprendre la Stacktrace en Java ? lire-comprendre-stacktrace-java

    Lorsque quelque chose ne tourne pas rond dans une application Java en cours d'exécution, le premier indice est souvent l'impression de lignes à l'écran qui ressemblent à peu près à ce qui suit :

    Exception in thread "main" java.lang.RuntimeException: Something has gone wrong, aborting!
        at com.myproject.module.MyProject.badMethod(MyProject.java:22)
        at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)
        at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)
        at com.myproject.module.MyProject.someMethod(MyProject.java:10)
        at com.myproject.module.MyProject.main(MyProject.java:6)
    

    Ceci est une Stacktrace, et dans ce blog post, je vais vous expliquer de quoi il s'agit, comment ils sont générés et comment les lire et les comprendre. Si ça à déjà l’air pénible, lisez la suite...

    Anatomie d'une Stacktrace

    Habituellement, une Stacktrace s'affiche lorsqu'une Exception n'est pas gérée correctement dans le code. Il peut s'agir d'un des types d'exception intégrés de base dans Java, ou d'une exception customisée créée par un programme ou une librairie.

    La Stacktrace contient le type d'exception et un message, ainsi qu'une liste de tous les …

    Read More
  • By Matthew Gilliard
    Handling Webhooks with Java, Spring Cloud Function and Azure Functions Title: Handling Webhooks with Java, Spring Cloud Function and Azure Functions

    When you want to send an SMS or a WhatsApp message using Twilio's API, the programming model is straightforward: You call the API and the message gets sent. Responding to incoming messages is a different question. When the message arrives Twilio needs to find out how to handle it, and the mechanism we use is the Webhook. You configure your Twilio number with a URL and the platform makes a request to it passing some details about the incoming message - your app's response decides what happens next.

    This means your app needs a public URL, which in turn means that you need some hosting. In the last few years serverless platforms have become popular for this, because they alleviate many of the pains of hosting. You provide code, which can handle an individual request, and the platform takes care of routing, scaling and most other concerns. Java's no …

    Read More
  • By Matthew Gilliard
    Building Voicemail with Twilio and Java Building Voicemail with Twilio and Java

    One useful and common way to use Twilio is to create a phone number which forwards to your real phone. You can hand out the Twilio number to colleagues or customers and take business calls on your personal phone without worrying about handing out your real phone number. This also gives you a lot of options for how to handle these calls - you have the full power of Twilio at your disposal.

    In this post I'll show you how to create a voicemail system that will jump in when your cell number is busy, or when you don't answer the call. It will play a message to your caller, then record their message and text you a link to the recording when it's done.

    Primer: How Twilio Handles Calls

    When someone dials your Twilio number, an HTTP request is sent to a URL that you provide. The web server …

    Read More
  • By Matthew Gilliard
    Building Single-Page Apps with React and Twilio Functions Title: Building Single-Page Apps with React and Twilio Functions

    You can do all kinds of weird and wonderful things with Twilio's APIs, and if you could call those APIs from your browser you'd be able to build some awesome apps that you could use from a browser anywhere. This isn't directly possible, because the Twilio API doesn't send any CORS headers (for good reason).

    A better way to use Twilio API from the browser is to implement a custom web app which accesses Twilio API. In this post I'll show how you can build such a custom web app on the Twilio Runtime platform, using Functions and Assets.

    If you follow along with the code, you'll build a single-page app with a backend that is hosted on Twilio. This will let you call the Lookup API from anywhere in the world. I've chosen the Lookup API because it's relatively simple, but using the same principles you …

    Read More
  • By Matthew Gilliard
    How to make asynchronous API requests in Java using CompletableFutures Title: How to make asynchronous API requests in Java using CompletableFutures

    Java 8 was released in 2014, and introduced a raft of new language features such as Lambdas and the Streams API. A lot has happened since 2014 - Java is now at version 15, but industry surveys consistently report 8 as the most widely-used version, with very few developers using 7 or lower.

    In October this year, the Twilio Java Helper Library was updated to use Java 8 features in release 8.0.0. This new major version reflects the fact that the library no longer supports Java 7.

    One Java 8 API which sometimes gets overlooked is the CompletionStage API, usually accessed through the CompletableFuture class. The CompletionStage API lets programmers define pipelines of asynchronous operations for data, and handles the asynchronous behaviour for you. You define what you want to happen, and Java takes care of when it can happen.

    In this post I'll show how you …

    Read More
  • By Matthew Gilliard
    How to use custom HTTP clients with Twilio in Java Title: How to use custom HTTP clients with Twilio in Java

    [Header image adapted from this image, CC BY 2.0 from Microsoft NYC]

    When building a Java application that uses Twilio's API most developers will have code that runs at startup, initializing the Twilio helper library like this:

    Twilio.init(
        TWILIO_ACCOUNT_SID,
        TWILIO_AUTH_TOKEN);
    

    This sets the account credentials as static fields in the Twilio class. Effectively they are now global settings for the application, and when your code calls the API these will be used automatically, and the helper library creates an HTTP client for you. This means that you don't have to repeat your credentials every time you call a method that uses the Twilio API:

    Message.creator(TO_NUMBER, FROM_NUMBER, "Hello 👋").create();
    

    This is convenient, however there are cases where you want more control over the HTTP client. This might be to configure an HTTP proxy, or to provide custom credentials if you are using multiple Twilio accounts or Projects in the same …

    Read More
  • By Matthew Gilliard
    What's new for developers in Java 15? Title: What's new for developers in Java 15?

    [header image credit: NASA Astronomy Picture Of the Day, Sep 15 2020]

    Happy Java 15 release day! This release marks three years since the start of the six-monthly release schedule and I am still appreciating the speed of new features and the insight it's giving into what's coming up in Java's future.

    In Java 15 there are improvements to tooling, security, cross-platform consistency, efficiency and performance. You can read the full release notes and the list of major features, which are designated a Java Enhancement Proposal (JEP) number. In this post I've selected a few features which I think are interesting for developers.

    The features I've selected are a mix of fully-released and "preview" features (more on these later).

    How to use these features

    You can download Java 15 from https://jdk.java.net/15/ - downstream builds will be available from places like AdoptOpenJDK soon after. You can also install it …

    Read More
  • By Matthew Gilliard
    Securing your Twilio webhooks in Java Header image: Securing your Twilio webhooks in Java

    Using webhooks is a common and powerful way to configure your Twilio phone numbers to respond to incoming phone calls or SMS (or faxes). You provide a URL and Twilio makes an HTTP request to that URL when a call or message comes in to find out how to respond.

    Diagram of the flow: Someone sends SMS, Twilio makes an HTTP request to your app, the response is passed back to Twilio which sends an SMS reply.

    One implication of this is that the URL you provide has to be accessible from the internet, so when you're building your web app to handle the webhooks, how can you know for sure that the requests are really coming from Twilio and not malicious or opportunistic internet scoundrels?

    The answer is that all valid webhook requests from Twilio are signed in a header called X-Twilio-Signature. The algorithm used to create the signature is described in detail in our docs.  Briefly, the ingredients of the signature are:

    • The details of the request
    • The webhook URL as configured …
    Read More
  • By Matthew Gilliard
    How to build a CLI app in Java using jbang and picocli Title card: How to build a CLI app in Java using jbang and picocli

    Traditionally Java applications have been used for long-running processes - web application servers can run for days or weeks at a time. The JVM handles this well: Garbage Collection is efficient over huge amounts of memory, and Profile-Guided Optimization can make your code faster the longer it runs.

    However, it’s perfectly possible to write short-lived apps too, and in this post I’ll show how to build a CLI app whose total runtime is just a couple of seconds. You can build sophisticated CLI tools in Java for data processing, connection to databases, fetching data from the web, or taking advantage of any of the Java libraries that you're used to.

    I’ll use jbang for packaging and running the app, and picocli to handle argument parsing and output.  The app will send an SMS using Twilio’s Messaging API, in a single Java source file less than 100 lines long. …

    Read More
  • By Matthew Gilliard
    5 ways to make HTTP requests in Java 5 ways to make HTTP requests in Java

    [header image credit: Iron in the Butterfly Nebula, NASA Astronomy Picture of the Day July 21 2020 (modified)]

    Making HTTP requests is a core feature of modern programming, and is often one of the first things you want to do when learning a new programming language. For Java programmers there are many ways to do it - core libraries in the JDK and third-party libraries. This post will introduce you to the Java HTTP clients that I reach for. If you use other ones, that’s great! Let me know about it. In this post I’ll cover:

    Core Java:
    • HttpURLConnection
    • HttpClient
    Popular Libraries:
    • ApacheHttpClient
    • OkHttp
    • Retrofit

    I’ll use the Astronomy Picture of the Day API from the NASA APIs for the code samples, and the code is all on GitHub in a project based on Java 11.

    Core Java APIs for making Java http requests

    Since Java 1.1 there has …

    Read More
  • Newer
    Older
    Sign up and start building
    Not ready yet? Talk to an expert.