Application Integration: Protocols, Formats, Connectors
Key Points
- Application integration is the discipline of enabling independent applications—each built for its own purpose—to communicate and work together, a need that arises when scaling code, connecting to pre‑built systems, or integrating disparate services.
- The first major integration challenge is handling **different protocols** (e.g., HTTP, file‑based transfers, XML, messaging protocols such as AMQP, and web sockets) which dictate how services exchange messages.
- The second challenge involves **varying data formats and standards** (e.g., EDI for B2B, HL7 for healthcare, SWIFT for banking), requiring applications to translate or map data to satisfy industry‑specific schemas.
- Additional integration considerations include **data operations and specialized connectors** (such as SaaS connectors), which help manage transformations, routing, and orchestration across heterogeneous systems.
Full Transcript
# Application Integration: Protocols, Formats, Connectors **Source:** [https://www.youtube.com/watch?v=rcuu-O02xqE](https://www.youtube.com/watch?v=rcuu-O02xqE) **Duration:** 00:10:26 ## Summary - Application integration is the discipline of enabling independent applications—each built for its own purpose—to communicate and work together, a need that arises when scaling code, connecting to pre‑built systems, or integrating disparate services. - The first major integration challenge is handling **different protocols** (e.g., HTTP, file‑based transfers, XML, messaging protocols such as AMQP, and web sockets) which dictate how services exchange messages. - The second challenge involves **varying data formats and standards** (e.g., EDI for B2B, HL7 for healthcare, SWIFT for banking), requiring applications to translate or map data to satisfy industry‑specific schemas. - Additional integration considerations include **data operations and specialized connectors** (such as SaaS connectors), which help manage transformations, routing, and orchestration across heterogeneous systems. ## Sections - [00:00:00](https://www.youtube.com/watch?v=rcuu-O02xqE&t=0s) **Introducing Application Integration Fundamentals** - Jamil Spain defines application integration, explains its necessity for connecting disparate systems, and outlines four primary integration scenarios—protocols, data formats, data operations, and connectors. ## Full Transcript
as a technologist there comes a time
when you write your applications and the
code necessarily has to grow especially
when you have the need to interact with
other systems or better yet another
scenario is where you've built your
application it's running fine in
production but let's say you need to
connect to other pre-built systems that
are functioning did you know that
there's a whole discipline dedicated to
this type of integration hello my name
is jamil spain developer advocate with
the ibm cloud and my topic for today is
application integration
and let me go ahead and define this
topic i think you already are aware
where i'm headed here application
integration is the process of enabling
individual applications to communicate
together very simple but the key about
these applications is they're already
designed for their own purpose so let me
go ahead and
write this down here so we'll just say
it enables
i abbreviate communication with the ceo
ilm here and i really want to talk about
this topic from the perspective of you
having your architect on hat on again
but noticing when you need to use
application integration and there are
four scenarios that really come to mind
a is when you have to interact with
different protocols
formats
data operations or
my favorite sas connectors
so let's get started talking about all
these four areas and then we'll
summarize it all at the end the first
are protocols and when i think about
protocols it's really the most
major one is going to be
http definitely top of the line here you
also have protocols like you may
actually have to deal with files or
maybe xml
a lot of the popular services or
leverage that kind of protocol
or maybe even some messaging protocols
like amqp
all right messaging protocols that are
there
web services all these are different
type of interactions that i need to
create
uh between services and this is probably
the most common one especially when you
start dealing with web sockets and a lot
of spa applications there are so many
different things that you have to
interact type of protocols or systems
that you have to interact with there
secondly formats so formax really gets
you into you know a lot of larger
enterprise business they already have
protocols or standards that are set up
for these systems to work together
things that come to mind here are um
definitely when it comes to a lot of edi
when it comes to how
business the business may interact with
each other so a lot of b2b
in healthcare there's the hl7 format
which really talks about
how
healthcare companies and insurance
companies kind of communicate together
to work
the next is swift
there's actually a complete
um
network that's set up for a lot of
banking institutions and marketplaces to
actually communicate with each other
worldwide and so at some point you'll
have to interact with if you're writing
your own custom applications you'll want
to have to interact with that system and
so definitely when you need to embed
into those
particular interact with those other
systems
getting your data in the proper format
is necessary here great use case for
application integration here
let me talk about sas connectors so we
have this big growing need for the api
economy and it's really blossom to
almost where almost any third-party
service has rest apis that are available
for you to interact with and so it's
almost to the point now that i can even
sign up for a sas service interact with
the service without actually having to
log in thus giving my application that
i've built the immediate benefit of all
the services and formats or
functionality of these sas connectors
provide here i really want to break
those down by the actual rest api so you
have rest
and it's going to provide
uh three different four different
operations that are very critical all
right we'll talk about one part and
that's the crud
that's the ability to create
read update and delete
but not only for the
the ability to interact with those
systems uh based upon these kind of four
basic operations there also is an
ability to provide some
event uh event web hooks and called call
web hooks let me breeze right into it so
as their web hooks they provide the
callback based upon any of these
operations so let's say for instance
i am building a
application where i need to manage a
list of orders or products and as i may
be interacting with another
sas service that may handle that
functionality for me when i create
products to go into inventory i can also
get a call back when a product is
created so it'll kind of give me a
functioning another rest call
that i can listen for to know to make
some interactions uh there as well
this really starts it really is the
start of a lot of event driven type of
functionality that you can provide your
application and of course
these events can function across
denoting that is a kind of an iterative
cycle here as i make operations i can
also get the feedback from that and
immediately enable a lot of the
functionalities there
the last one i want to talk about is
data operations so not only do i have to
interact with other systems and
different protocols
maybe interact with other
systems in different formats that they
function with
and i may actually i also interact with
other sas services the lastly is i want
to actually enable
uh particular operations that i want to
occur so
things that come to mind here are
routing and transformation
going to vva transform here
so routing where i want depending on the
data inspecting the data payload i may
want data to go any number of services
route to different places i may want to
have a response that comes in through
rest and i may want to transfer that to
xml format to interact with another
system and then push that data along or
break a large payload into smaller
payloads to go into other systems maybe
i want to actually interact with other
systems like kafka or any other
messaging system and i started out from
my http call all right some type of web
web service api calls there so a lot of
great opportunity there to function and
work
there
next is filtering
and i kind of alluded a little bit to
that already where i can kind of inspect
the payload maybe make decisions
based upon
things that i want to do and this can
also
involve some other patterns that are
very great to have which can be
kind of the
publication and subscribing format or
what i like to call the scattergatter
pattern
all right so think of pub subway i have
something that's publishing information
and i want to
we'll just use my air quotes and say
spray that data out to multiple
receiving sources who have an interest
in that particular thing so let's say a
user
creates an order or submits an order on
e-commerce site i may want to enable
calls to go out to multiple apis that
handle different departments or in the
scatter gather method i may want to pull
off the functionality of
i want to kind of pull data from
different sources and correlate that all
together to go back
a lot of your common
use cases for
looking for better prices on services
kind of enable that kind of pattern you
know i give my basic information it goes
out and checks multiple services comes
back with a nice list of all your
options that are there alright so common
pattern that that that's achieved with
now let's get back to the core principle
here and why this is kind of useful we
talked about protocols these are the
situations where application integration
really should ring a bell that i need to
look into this as well
so with my applications i'm going to be
writing a lot of this code myself it is
code then we all know that code you
write has to mature one of the great
benefits of leveraging
the
ecosystem here for application
integration is this is probably going to
be facilitated by
low code or no code
meaning there are pre-built applications
that really can enable a lot of this
functionality maybe it's connections to
sas services
but i get to kind of just focus on the
business logic aspect of that leveraging
by dragging drop uis to do data
operations uh to do my filtering between
services or translate between different
data formats and kind of really
facilitate a lot of this functionality
there and by the fact that they're
already pre-built
already they're running it gives me the
the consistency and the comfort to know
that that part of my code i don't have
to test too much because i'm just
interacting with that it performs a
certain function and really helps expand
the bounds that your application that
you're writing or context of your
application can really grow
and connect to many many more data
services
so this is
all i wanted to cover here on the topic
of application integration definitely
hope that you give me all your feedback
or questions or comments in the comments
below and i look forward to seeing you
next time and oh while you're there
don't forget to like and subscribe to
our channel so we can keep bringing you
great content on topics like this until
next time technically yours jamil spain
if you have any questions please drop us
a line below and if you want to see more
videos like this in the future please
like and subscribe