book

Spring MVC: Designing Real-World Web Applications

Name: Spring MVC: Designing Real-World Web Applications
ISBN: 9781787126398

by Shameer Kunjumohamed, Hamidreza Sattari, Alex Bretet, Geoffroy Warin

November 2016

Intermediate to advanced

944 pages

21h 1m

English

Packt Publishing

Read now

Unlock full access

Spring MVC: Designing Real-World Web Applications
Table of Contents
Spring MVC: Designing Real-World Web Applications
Spring MVC: Designing Real-World Web Applications
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions

I. Module 1
1. Getting Started with Spring Core
The Spring landscapeThe Spring Framework modulesSpring Tool Suite (STS)Spring subprojects
Design concepts behind Spring Framework
Setting up the development environment
Your first Spring application
Inversion of Control explained
Dependency Injection
The Spring IoC containerConfiguration metadataXML-based configuration metadataAnnotation-based configuration metadataXML-based versus annotation-based configurationComponent stereotype annotationsJava-based configuration metadataJSR 330 standard annotations
Beans in detail
Bean definitionInstantiating beansWith constructorsWith a static factory-methodWith an instance factory-methodInjecting bean dependenciesConstructor-based Dependency InjectionSetter-based Dependency InjectionConstructor-based or setter-based DI – which is better?Cleaner bean definitions with namespace shortcutsWiring a List as a dependencyWiring a Map as a dependencyAutowiring dependenciesBean scopingDependency Injection with scoped beansCreating a custom scope
Hooking to bean life cycles
Implementing InitializingBean and DisposableBeanAnnotating @PostConstruct and @PreDestroy on @ComponentsThe init-method and destroy-method attributes of <bean/>
Container-level default-init-method and default-destroy-method
Working with bean definition profiles
Injecting properties into the Spring environment
Externalizing properties with PropertyPlaceholderConfigurer
Handling resources
Spring Expression Language
SpEL featuresSpEL annotation supportThe SpEL API
Aspect Oriented Programming
Static and dynamic AOPAOP concepts and terminologySpring AOP – definition and configuration stylesXML schema-based AOP@AspectJ annotation-based AOPDeclaring an @Aspect annotationPointcutsPointcut designatorsPointcut examplesAdvicesThe @Around AdviceAccessing Advice parameters
Testing with Spring
Mock objectsUnit and integration testing utilities
Summary
2. Building the Web Layer with Spring Web MVC
Features of Spring MVC
The Model-View-Controller pattern
Your first Spring MVC application
Setting up a Spring MVC application
The project structure of a Spring MVC applicationThe web.xml file – Springifying the web appApplicationContext files in a Spring MVC applicationHomeController – @Controller for the home screenThe home.jsp file – the landing screenHandling incoming requests
The architecture and components of Spring MVC
DispatcherServlet explained
WebApplicationContext – ApplicationContext for the WebBeans supporting DispatcherServlet and their roles
Controllers in detail
Mapping request URLs with @RequestMappingURI template patterns with the @PathVariable annotationBinding parameters with the @RequestParam annotationRequest handler method argumentsRequest handler method return typesSetting Model attributesBuilding RESTful services for JSON and XML mediaBuilding a RESTful service with RestController
Asynchronous request processing in Spring MVC
Working with views
Resolving viewsResolving JSP viewsBinding Model attributes in JSP pages using JSTL
Spring and Spring form tag libraries
Composing a form in JSP
Validating forms
Handling file uploads
Resolving Thymeleaf views
More view technologies
Summary
3. Accessing Data with Spring
Configuring DataSource
Using embedded databases
Handling exceptions in the Spring Data layer
DAO support and @Repository annotation
Spring JDBC abstraction
JdbcTemplateNamedParameterJdbcTemplateSimpleJdbc classesJDBC operations with Sql* classes
Spring Data
Spring Data CommonsSpring Data repository specificationSpring Data JPAEnabling Spring Data JPAJpaRepositorySpring Data MongoDBEnabling Spring Data MongoDBMongoRepositoryDomain objects and entitiesQuery resolution methodsUsing the @Query annotationSpring Data web support extensionsAuditing with Spring Data
Spring Transaction support
Relevance of Spring Transaction
Spring Transaction fundamentalsDeclarative transaction managementTransactional modes – proxy and AspectJDefining transactional behaviorSetting rollback rulesUsing the @Transactional annotationEnabling transaction management for @TransactionalProgrammatic transaction management
Summary
4. Understanding WebSocket
Creating a simple WebSocket application
STOMP over WebSocket and the fallback option in Spring 4
Broadcasting a message to a single user in a WebSocket application
Summary
5. Securing Your Applications
Authentication
Authorization
The OAuth2 Authorization Framework
Summary
6. Building a Single-Page Spring Application
The motivations behind SPAs
SPAs explained
The architectural benefits of SPAsSPA frameworks
Introducing Ember.js
The anatomy of an Ember application
RoutersRoutes or route handlersTemplatesComponentsModelsControllersInput helpersCustom helpersInitializersServices
Working with Ember CLI
Setting up Ember CLIGetting started with Ember CLI commandsThe Ember project structureWorking with the POD structure
Understanding the Ember object model
Declaring types (classes) and instancesAccessing and mutating propertiesComputed propertiesProperty observers
Working with collections
Building UI templates using Handlebars
Handlebars helpersData binding with input helpersUsing control flow helpers in HandlebarsUsing event helpers
Handling routes
Handling UI behavior using components
Building a ToggleButton component step by step
Persisting data with Ember Data
Ember Data architectureDefining modelsDefining model relationships
Building a Taskify application
Building the API server app
Setting up and configuring the projectDefining the model definitions – User and TaskBuilding API endpoints for the Taskify appUserController.javaTaskController.java
Building the Taskify Ember app
Setting up Taskify as an Ember CLI projectSetting up Ember DataConfiguring application routesBuilding the home screenBuilding the user screenBuilding a custom helperAdding action handlersBuilding a custom component – modal windowBuilding userEditModal using {{modal-window}}Building the task screen
Summary
7. Integrating with Other Web Frameworks
Spring's JSF integration
Spring's Struts integration
Summary
II. Module 2
1. Setup Routine for an Enterprise Spring Application
IntroductionWhy such a routine?Why making use of the Eclipse IDE?Why making use of Maven?What does the Spring Framework bring?
Installing Eclipse for JEE Developers and Java SE 8
Getting readyHow to do it...How it works…Eclipse for Java EE developersChoosing a JVMJava SE 8
Configuring Eclipse for Java 8, Maven 3, and Tomcat 8
Getting readyHow to do it...How it works...The eclipse.ini fileSetting the –vm optionCustomizing JVM argumentsChanging the JDK compliance levelConfiguring MavenA repository managerTomcat 8 inside EclipseThere's more...
Defining the project structure with Maven
Getting readyHow to do it...How it works...New Maven project, new Maven moduleThe standard project hierarchyThe project's structure in the IDEMaven's build life cyclesThe clean life cycleThe default life cyclePlugin goalsBuilt-in life cycle bindingsAbout Maven commandsThere's more...How did we choose the jar module's name?How did we choose the names for deployable modules?Why did we create core modules?See also...
Installing Spring, Spring MVC, and a web structure
Getting readyHow to do it...How it works...Inheritance of Maven dependenciesBasic inheritanceManaged inheritanceIncluding third-party dependenciesThe Spring Framework dependency modelThe Spring MVC dependencyUsing Maven propertiesThe web resourcesThe target runtime environmentThe Spring web application contextPluginsThe Maven compiler pluginThe Maven surefire pluginThe Maven enforcer pluginThe Maven war pluginThere's more...See alsoThe Maven checkstyle plugin
2. Designing a Microservice Architecture with Spring MVC
IntroductionThe User eXperience paradigmMicroservice architectures
Configuring a controller with simple URL mapping
Getting readyHow to do it...Downloading and installing GITConfiguring GIT in EclipseHow it works...Spring MVC overviewFront controllerMVC design patternSpring MVC flowDispatcherServlet – the Spring MVC entrypointAnnotation-defined controllers@Controller@RequestMappingController method-handler signaturesSupported method arguments typesSupported annotations for method argumentsSupported return TypesThere's more...
Configuring a fallback controller using ViewResolver
Getting readyHow to do it...How it works...URI template patternsAnt-style path patternsPath pattern comparisonViewResolversThere's more...@PathVariable to read variables in URI template patterns
Setting up and customizing a responsive single page webdesign with Bootstrap
Getting readyHow to do it...Installing a Bootstrap themeCustomising a Bootstrap themeCreating responsive contentHow it works...The theme installationBootstrap highlightsBootstrap scaffoldingGrid system and responsive designDefining columnsOffsetting and nestingFluid griddingBootstrap CSS utilitiesUniform ButtonsIconsTablesBootstrap componentsNavbarsHero unitsAlertsBadges and labelsThere's more...See also
Displaying a model in the View, using the JSTL
Getting readyHow to do it...How it works...The approach to handle our dataInjection of services via interfacesHow does Spring choose the dummy implementations?DTOs to be used in View layerDummy service implementationsPopulating the Model in the controllerRendering variables with the JSP ELImplicit objectsRendering variables with the JSTLTaglib directives in JSPsThere's more...More about JSP ELMore about the JavaBeans standardMore about the JSTL
Defining a common WebContentInterceptor
Getting readyHow to do it...How it works...Common behaviors for ControllersGlobal session controlRequiring sessionsSynchronizing sessionsCache-header managementHTTP method supportA high-level interceptorRequest lifecycleThere is more...More features offered by WebContentGeneratorSee also...Web cachingNew support classes for @RequestMapping since Spring MVC 3.1
Designing a client-side MVC pattern with AngularJS
Getting readyHow to do it...Setting up the DOM and creating modulesDefining the module's componentsHow it works...One app per HTML documentModule autobootstrapManual module bootstrapAngularJS ControllersBidirectional DOM-scope bindingAngularJS directivesng-repeatng-ifAngularJS factoriesDependency injectionThere's more...
3. Working with Java Persistence and Entities
IntroductionThe Entities' benefitsThe Entity manager and its persistence context
Configuring the Java Persistence API in Spring
Getting readyHow to do it...How it works...The Spring-managed DataSource beanThe EntityManagerFactory bean and its persistence unitThe Spring Data JPA configurationSee also
Defining useful EJB3 entities and relationships
Getting readyHow to do it...How it works...Entity requirementsMapping the schemaMapping tablesMapping columnsAnnotating fields or gettersMapping primary keysIdentifier generationDefining inheritanceThe single-table strategyThe table-per-class strategyDefining relationshipsHow relationships between entities have been chosenThere's more...The FetchType attributeThe Cascade attributeSee also
Making use of the JPA and Spring Data JPA
How to do it...How it works...Injecting an EntityManager instanceUsing JPQLReducing boilerplate code with Spring Data JPAQuery creationPersisting EntitiesThere's more...Using native SQL queriesTransactionsSee also
4. Building a REST API for a Stateless Architecture
IntroductionA definition of RESTRESTful CloudStreetMarket
Binding requests and marshalling responses
Getting readyHow to do it...How it works...A super RequestMappingHandlerAdapter beanBroad support for @RequestMapping annotationssetMessageConverterssetCustomArgumentResolverssetWebBindingInitializerThe ConversionService APIChoosing between PropertyEditors or convertersThere's more...Built-in PropertyEditor implementationsThe Spring IO reference document
Configuring content-negotiation (JSON, XML, and so on)
Getting readyHow to do it...How it works...Support for XML marshallingThe XStream marshallerNegotiation strategies with ContentNegotiationManagerThe Accept headerThe file extension suffix in the URL pathThe request parameterJava Activation Framework@RequestMapping annotations as ultimate filtersThere's more...Using a JAXB2 implementation as an XML parserThe ContentNegotiationManagerFactoryBean JavaDoc
Adding pagination, filters, and sorting capabilities
Getting readyHow to do it...How it works...Spring Data pagination support (you will love it!)Pagination and sorting in repositoriesPagingAndSortingRepository<T,ID>The web part – PageableHandlerMethodArgumentResolverA useful specification argument resolverThe JPA2 criteria API and Spring Data JPA specificationsSpecificationArgumentResolverThere's more...Spring DataAngular routesSee alsoBootstrap pagination with the Angular UI
Handling exceptions globally
Getting readyHow to do it...How it works...Global exception handling with @ControllerAdviceThe support ResponseEntityExceptionHandler classA uniform error response objectThere's more...HTTP Status CodesThe official article about exception handling in Spring MVCJavaDocsSee also
Documenting and exposing an API with Swagger
Getting readyHow to do it...How it works...An exposed metadataThe Swagger UIThere's more...The Swagger.ioThe swagger-springmvc documentationSee alsoDifferent tools, different standards
5. Authenticating with Spring MVC
Introduction
Configuring Apache HTTP to proxy your Tomcat(s)
Getting readyHow to do it...How it works...DNS configuration or host aliasingIn production – editing DNS recordsAn alias for the hostAlias definition for OAuth developmentsApache HTTP configurationVirtual-hostingThe mod_proxy moduleProxyPassReverseWorkersThe mod_alias moduleTomcat connectorsHTTP connectorsAJP connectorsThere is more…See alsoAlternatives to Apache HTTP
Adapting users and roles to Spring Security
Getting readyHow to do it...How it works...Introduction to Spring SecurityThreadLocal context holdersNoticeable Spring Security interfacesThe Authentication interfaceThe UserDetails interfaceAuthentication providersThe UserDetailsManager interfaceThe GrantedAuthority interfaceThere is more…Spring Security referenceTechnical overviewSample applicationsCore services
Authenticating over a BASIC scheme
Getting readyHow to do it...How it works...The Spring Security namespaceThe <http> componentThe Spring Security filter-chainOur <http> configurationThe AuthenticationManager interfaceBasic authenticationBasicAuthenticationFilterWith an authenticationEntryPointWithout an authenticationEntryPointThere is more…In the Spring Security referenceThe remember-me cookie/feature
Authenticating with a third-party OAuth2 scheme
Getting readyHow to do it...How it works...From the application point of viewFrom the Yahoo! point of viewOAuth2 explicit grant flowRefresh-token and access-tokenSpring social – role and key featuresSocial connection persistenceProvider-specific configurationOne entry-point – connectionFactoryLocatorProvider-specific ConnectionFactoriesSigning in with provider accountsThere is more…Performing authenticated API callsThe Spring social ConnectControllerSee alsoSocialAuthenticationFilterThe list of Spring social connectorsImplementing an OAuth2 authentication serverThe harmonic development blog
Storing credentials in a REST environment
Getting readyHow to do it...Client side (AngularJS)Server sideHow it works...Authenticating for MicroservicesUsing the BASIC authenticationUsing OAuth2HTML5 SessionStorageSSL/TLSBCryptPasswordEncoderThere is more…Setting HTTP headers with AngularJSBrowser support for localStorageAbout SSL and TLS
Authorizing on services and controllers
Getting readyHow to do it...How it works...Spring Security authoritiesConfiguration attributesPre-invocation handlingAccessDecisionManagerAfter invocation handlingExpression-based access controlWeb Security expressionsMethod security expressionsAccess control using @PreAuthorize and @PostAuthorizeFiltering collections using @PreFilter and @PostFilterJSR-250 and legacy method securityThere is more…Domain Object Security (ACLs)Spring ELThe Spring Security referenceSee also
6. Implementing HATEOAS
IntroductionThe Richardson Maturity Model
Turning DTOs into Spring HATEOAS resources
How to do it…How it works...Spring HATEOAS resourcesThe ResourceSupport classThe Resource classThe Identifiable interfaceAbstracting the Entities' @IdThere's more…See also
Building links for a hypermedia-driven API
How to do it…How it works...Resource assemblersPagedResourcesAssemblerBuilding linksEntityLinksControllerLinkBuilderThere's more…The use of regular expressions in @RequestMappingSee also
Choosing a strategy to expose JPA Entities
How to do it…How it works...The REST CRUD principleExposing the minimumIf the Entity doesn't own the relationshipIf the Entity owns the relationshipSeparation of resourcesThere's more…Jackson custom serializersXStream converters
Retrieving data from a third-party API with OAuth
How to do it…How it works...Introduction to the financial data of Yahoo!Graph generation/displayHow is the financial data pulled/refreshed?Calling third-party servicesThere's more…Spring Social — existing API providersSee also
7. Developing CRUD Operations and Validations
Introduction
Extending REST handlers to all HTTP methods
Getting readyHow to do it…How it works...HTTP/1.1 specifications – RFC 7231 semantics and contentBasic requirementsSafe and Idempotent methodsOther method-specific constraintsMapping request payloads with @RequestBodyHttpMessageConvertersProvided HttpMessageConvertersUsing MappingJackson2HttpMessageConverterUsing @RequestPart to upload an imageTransaction managementThe simplistic approachThere's more…Transaction managementACID propertiesGlobal versus local transactionsSee also
Validating resources using bean validation support
Getting readyHow to do it…How it works...Using Spring validatorValidationUtilsI18n validation errorsUsing JSR-303/JSR-349 Bean ValidationOn-field constraint annotationsImplementation-specific constraintsLocalValidator (reusable)There's more…ValidationUtilsGrouping constraintsCreating a custom validatorThe Spring reference on validationSee also
Internationalizing messages and contents for REST
How to do it…BackendFrontendHow it works...MessageSource beansResourceBundleMessageSourceReloadableResourceBundleMessageSourceStaticMessageSourceOur MessageSource bean definitionUsing a LocaleResolverAcceptHeaderLocaleResolverFixedLocaleResolverSessionLocaleResolverCookieLocaleResolverThere's more…Translating client-side with angular-translate.js
Validating client-side forms with HTML5 AngularJS
How to do it…How it works...Validation-constraintsRequiredMinimum/maximum lengthRegex patternNumber/e-mail/URLControl variables in formsModified/Unmodified stateValid/Invalid stateErrorsForm state transclusions and styleSee also
8. Communicating Through WebSockets and STOMP
Introduction
Streaming social events with STOMP over SockJS
Getting readyHow to do it…Apache HTTP Proxy configurationFrontendBackendHow it works...An introduction to WebSocketsWebSocket LifecycleTwo dedicated URI schemesThe STOMP protocolSockJSSpring WebSocket supportAll-in-one configurationDefining message handlers via @MessageMappingSending a message to dispatchSimpMessagingTemplateThe @SendTo annotationThere's more…See also
Using RabbitMQ as a multiprotocol message broker
Getting readyHow to do it…How it works...Using a full-featured message brokerClusterability – RabbitMQMore STOMP message typesStompMessageBrokerRelaySee also
Stacking and consuming tasks with RabbitMQ and AMQP
Getting readyHow to do it…Sender sideConsumer sideClient-sideHow it works...Messaging architecture overviewA scalable modelAMQP or JMS?There's more…A great introduction to AMQP by pivotalA better way to publish application eventsSee also
Securing messages with Spring Session and Redis
Getting readyHow to do it…Apache HTTP proxy configurationRedis server installationMySQL server installationApplication-level changesRabbitMQ configurationThe resultsHow it works...The Redis serverSpring sessionSessionRepositoryFilterRedisConnectionFactoryCookieHttpSessionStrategySpring Data Redis and Spring Session Data RedisThe Redis Session manager for TomcatViewing/flushing sessions in RedissecurityContextPersistenceFilterAbstractSessionWebSocketMessageBrokerConfigurerAbstractSecurityWebSocketMessageBrokerConfigurerThere's more…Spring SessionApache HTTP proxy extra configurationSpring Data RedisSee also
9. Testing and Troubleshooting
Introduction
Automating Database Migrations with FlyWay
Getting readyHow to do it…How it works...A limited number of commandsMigrateCleanInfoValidateBaselineRepairAbout Flyway Maven pluginThere is more…The official documentationSee also
Unit testing with Mockito and Maven Surefire
How to do it…How it works...@Test annotationThe expected and timeout argumentsThe @RunWith annotation@Before and @After annotations@BeforeClass and @AfterClass annotationsUsing MockitoMockitoJUnitRunnerThe transferCriticalData exampleThe registerUser exampleThere is more…About MockitoJUnit RulesSee also
Integration testing with Cargo, Rest-assured, and Maven failsafe
Getting readyHow to do it…How it works...Maven Failsafe versus Maven SurefireCode CargoCargo Maven PluginBinding to Maven phasesUsing an existing Tomcat instanceRest assuredStatic importsA Given, When, Then approachThere is more…About CargoMore REST-assured examples
Injecting Spring Beans into integration tests
Getting readyHow to do it…How it works...SpringJUnit4ClassRunnerThe @ContextConfiguration annotationThere is more…JdbcTemplateAbstraction of boilerplate logicExtraction of auto-generated IDs
Modern application Logging with Log4j2
Getting readyHow to do it…How it works...Apache Log4j2 among other logging frameworksThe case of SLF4jMigrating to log4j 2Log4j 2 API and CoreLog4j 2 AdaptersLog4j 1.x API BridgeApache Commons Logging BridgeSLF4J BridgeJava Util Logging AdaptersWeb Servlet SupportConfiguration filesThere is more…Automatic configurationOfficial documentationInteresting Redis Appender implementation
III. Module 3
1. Mastering the MVC Architecture
The MVC architecture
MVC critics and best practices
Anemic Domain ModelLearning from the sources
Spring MVC 1-0-1
Using Thymeleaf
Our first page
Spring MVC architecture
DispatcherServletPassing data to the view
Spring Expression Language
Getting data with a request parameter
Enough Hello Worlds, let's fetch tweets!
Registering your applicationSetting up Spring Social TwitterAccessing Twitter
Java 8 streams and lambdas
Material design with WebJars
Using layoutsNavigation
The check point
Summary
2. Handling Forms and Complex URL Mapping
The profile page – a form
Validation
Customize validation messagesCustom annotation for validation
Internationalization
Changing the localeTranslating the application textA list in a form
Client validation
The check point
Summary
3. File Upload and Error Handling
Uploading a fileWriting an image to the responseManaging upload propertiesDisplaying the uploaded pictureHandling file upload errors
Translating the error messages
Placing the profile in a session
Custom error pages
URL mapping with matrix variables
Putting it together
The check point
Summary
4. Crafting a RESTful Application
What is REST?
Richardson's maturity model
Level 0 – HTTPLevel 1 – ResourcesLevel 2 – HTTP verbsLevel 3 – Hypermedia controls
API versioning
Useful HTTP codes
Client is the king
Debugging a RESTful API
A JSON formatting extensionA RESTful client in your browserhttpie
Customizing the JSON output
A user management API
Status codes and exception handling
Status code with ResponseEntityStatus codes with exceptions
Documentation with Swagger
Generating XML
The check point
Summary
5. Securing Your Application
Basic authenticationAuthorized usersAuthorized URLsThymeleaf security tags
The login form
Twitter authentication
Setting up social authenticationExplanation
Distributed sessions
SSL
Generating a self-signed certificateThe easy wayThe dual wayBehind a secured server
The check point
Summary
6. Leaving Nothing to Luck – Unit Tests and Acceptance Tests
Why should I test my code?
How should I test my code?
Test-driven development
The unit tests
The right tools for the job
The acceptance tests
Our first unit test
Mocks and stubs
Mocking with MockitoStubbing our beans while testingShould I use mocks or stubs?
Unit testing REST controllers
Testing the authentication
Writing acceptance tests
The Gradle configurationOur first FluentLenium testPage Objects with FluentLeniumMaking our tests more GroovyUnit tests with SpockIntegration tests with GebPage Objects with Geb
The check point
Summary
7. Optimizing Your Requests
A production profile
Gzipping
Cache control
Application cache
Cache invalidationDistributed cache
Async methods
ETags
WebSockets
The check point
Summary
8. Deploying Your Web Application to the Cloud
Choosing your hostCloud FoundryOpenShiftHeroku
Deploying your web application to Pivotal Web Services
Installing the Cloud Foundry CLI toolsAssembling the applicationActivating Redis
Deploying your web application on Heroku
Installing the toolsSetting up the applicationGradleProcfileA Heroku profileRunning your applicationActivating Redis
Improving your application
Summary
9. Beyond Spring Web
The Spring ecosystemCoreExecutionDataOther noteworthy projects
The deployment
Docker
Single Page Applications
The playersThe futureGoing stateless
Summary
A. Bibliography
Index

Content preview from Spring MVC: Designing Real-World Web Applications

Debugging a RESTful API

With your browser, you will only be able to perform GET requests on a specific API. The good tools will make your developments much simpler. There are lots of tools to test a RESTful API. I will just list the one I use and love.

A JSON formatting extension

Often, you will just test the GET method and your first reflex will be to copy the address into your browser to check the result. In that case, you have the possibility to get more than plain text with extensions such as JSON Formatter for Chrome or JSONView for Firefox.

A RESTful client in your browser

The browser is the natural tool for dealing with HTTP requests. However, using the address bar will rarely allow you to test your API in detail.

Postman is an extension for ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Practical Vaadin: Developing Web Applications in Java

Publisher Resources

ISBN: 9781787126398

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills