spring-petclinic-rest

REST version of Spring PetClinic Sample Application (spring-framework-petclinic extension)

This backend version of the Spring Petclinic application only provides a REST API. There is no UI. The spring-petclinic-angular project is a Angular front-end application which consumes the REST API.

Understanding the Spring Petclinic application with a few diagrams

See the presentation of the Spring Petclinic Framework version

Petclinic ER Model

Running Petclinic locally

With Maven command line

git clone https://github.com/spring-petclinic/spring-petclinic-rest.git
cd spring-petclinic-rest
./mvnw spring-boot:run

With Docker

docker run -p 9966:9966 springcommunity/spring-petclinic-rest

You can then access petclinic here: http://localhost:9966/petclinic/

There is an actuator health check route as well:

• http://localhost:9966/petclinic/actuator/health

📖 OpenAPI REST API Documentation

This project provides a RESTful API for managing a veterinary clinic’s owners, pets, veterinarians, visits, and specialties.

Access Swagger UI

Swagger UI is available at: http://localhost:9966/petclinic/swagger-ui.html.

API documentation (OAS 3.1) is accessible at: http://localhost:9966/petclinic/v3/api-docs.

📌 API Endpoints Overview

Method	Endpoint	Description
Owners
GET	/api/owners	Retrieve all pet owners
GET	/api/owners/{ownerId}	Get a pet owner by ID
POST	/api/owners	Add a new pet owner
PUT	/api/owners/{ownerId}	Update an owner’s details
DELETE	/api/owners/{ownerId}	Delete an owner
GET	/api/owners/{ownerId}/pets/{petId}	Get a pet by ID (owner’s pet)
PUT	/api/owners/{ownerId}/pets/{petId}	Update pet details (owner’s pet)
POST	/api/owners/{ownerId}/pets	Add a new pet to an owner
POST	/api/owners/{ownerId}/pets/{petId}/visits	Add a vet visit for a pet
Pets
GET	/api/pets	Retrieve all pets
GET	/api/pets/{petId}	Get a pet by ID
PUT	/api/pets/{petId}	Update pet details
DELETE	/api/pets/{petId}	Delete a pet
Vets
GET	/api/vets	Retrieve all veterinarians
GET	/api/vets/{vetId}	Get a vet by ID
POST	/api/vets	Add a new vet
PUT	/api/vets/{vetId}	Update vet details
DELETE	/api/vets/{vetId}	Delete a vet
Pet Types
GET	/api/pettypes	Retrieve all pet types
GET	/api/pettypes/{petTypeId}	Get a pet type by ID
POST	/api/pettypes	Add a new pet type
PUT	/api/pettypes/{petTypeId}	Update pet type details
DELETE	/api/pettypes/{petTypeId}	Delete a pet type
Specialties
GET	/api/specialties	Retrieve all vet specialties
GET	/api/specialties/{specialtyId}	Get a specialty by ID
POST	/api/specialties	Add a new specialty
PUT	/api/specialties/{specialtyId}	Update a specialty
DELETE	/api/specialties/{specialtyId}	Delete a specialty
Visits
GET	/api/visits	Retrieve all vet visits
GET	/api/visits/{visitId}	Get a visit by ID
POST	/api/visits	Add a new visit
PUT	/api/visits/{visitId}	Update a visit
DELETE	/api/visits/{visitId}	Delete a visit
Users
POST	/api/users	Create a new user

Screenshot of the Angular client

See its repository here: https://github.com/spring-petclinic/spring-petclinic-angular

In case you find a bug/suggested improvement for Spring Petclinic

Our issue tracker is available here: https://github.com/spring-petclinic/spring-petclinic-rest/issues

Database configuration

By default, Petclinic uses an in-memory H2 database, which is automatically populated with sample data at startup.

Supported Databases

Petclinic supports the following databases:

• H2 (Default, In-Memory)
• HSQLDB (Alternative In-Memory Option)
• MySQL (Persistent)
• PostgreSQL (Persistent)

Switching Databases

You can change the database by updating the spring.profiles.active property in application.properties:

Database	Profile Configuration
H2 (Default)	spring.profiles.active=h2,spring-data-jpa
HSQLDB (Alternative In-Memory)	spring.profiles.active=hsqldb,spring-data-jpa
MySQL (Persistent)	spring.profiles.active=mysql,spring-data-jpa
PostgreSQL (Persistent)	spring.profiles.active=postgres,spring-data-jpa

For more details, see the Spring Boot documentation.

Using H2 (Default)

• No additional setup is required.
• The database schema and sample data are loaded automatically from src/main/resources/db/h2/.
• You can access the H2 Console to inspect the database.

Accessing the H2 Console

1. Run the application:

   mvn spring-boot:run
   

2. Open H2 Console in your browser:
   • URL: http://localhost:9966/petclinic/h2-console
   • JDBC URL: jdbc:h2:mem:petclinic
   • Username: sa
   • Password: (leave blank)

Using HSQLDB

• HSQLDB works similarly to H2 as an in-memory database.

• No additional setup is required—schema and sample data are loaded automatically from src/main/resources/db/hsqldb/.

• Swtich to HSQLDB by modifying application.properties:

  spring.profiles.active=hsqldb,spring-data-jpa
  

Using MySQL

Modify application.properties:

spring.profiles.active=mysql,spring-data-jpa

Start a MySQL database using Docker:

docker run -e MYSQL_USER=petclinic -e MYSQL_PASSWORD=petclinic -e MYSQL_ROOT_PASSWORD=root -e MYSQL_DATABASE=petclinic -p 3306:3306 mysql:8.4

Using PostgreSQL

Modify application.properties:

spring.profiles.active=postgres,spring-data-jpa

Start a PostgreSQL database using Docker:

docker run -e POSTGRES_USER=petclinic -e POSTGRES_PASSWORD=petclinic -e POSTGRES_DB=petclinic -p 5432:5432 postgres:16.3

Instead of manually running containers, you can also use docker-compose.yml:

docker-compose --profile mysql up
docker-compose --profile postgres up

Further Documentation

• HSQLDB
• MySQL
• PostgreSQL

API First Approach

This API is built following some API First approach principles.

It is specified through the OpenAPI. It is specified in this file.

Some of the required classes are generated during the build time. Here are the generated file types:

• DTOs
• API template interfaces specifying methods to override in the controllers

To see how to get them generated you can read the next chapter.

Generated code

Some of the required classes are generated during the build time using maven or any IDE (e.g., IntelliJ Idea or Eclipse).

All of these classes are generated into the target/generated-sources folder.

Here is a list of the generated packages and the corresponding tooling:

Package name	Tool
org.springframework.samples.petclinic.mapper	MapStruct
org.springframework.samples.petclinic.rest.dto	OpenAPI Generator maven plugin

To get both, you have to run the following command:

mvn clean install

Security configuration

In its default configuration, Petclinic doesn’t have authentication and authorization enabled.

Basic Authentication

In order to use the basic authentication functionality, turn in on from the application.properties file

petclinic.security.enable=true

This will secure all APIs and in order to access them, basic authentication is required. Apart from authentication, APIs also require authorization. This is done via roles that a user can have. The existing roles are listed below with the corresponding permissions

• OWNER_ADMIN -> OwnerController, PetController, PetTypeController (getAllPetTypes and getPetType), VisitController
• VET_ADMIN -> PetTypeController, SpecialityController, VetController
• ADMIN -> UserController

There is an existing user with the username admin and password admin that has access to all APIs. In order to add a new user, please make POST /api/users request with the following payload:

{
    "username": "secondAdmin",
    "password": "password",
    "enabled": true,
    "roles": [
    	{ "name" : "OWNER_ADMIN" }
    ]
}

Working with Petclinic in Eclipse/STS

prerequisites

The following items should be installed in your system:

• Maven 3 (https://maven.apache.org/install.html)
• git command line tool (https://help.github.com/articles/set-up-git)
• Eclipse with the m2e plugin (m2e is installed by default when using the STS (http://www.springsource.org/sts) distribution of Eclipse)

Note: when m2e is available, there is an m2 icon in Help -> About dialog. If m2e is not there, just follow the install process here: http://eclipse.org/m2e/download/

• Eclipse with the mapstruct plugin installed.

Steps:

1. In the command line

git clone https://github.com/spring-petclinic/spring-petclinic-rest.git

2. Inside Eclipse

File -> Import -> Maven -> Existing Maven project

Looking for something in particular?

Layer	Source
REST API controllers	REST folder
Service	ClinicServiceImpl.java
JDBC	jdbc folder
JPA	jpa folder
Spring Data JPA	springdatajpa folder
Tests	AbstractClinicServiceTests.java

Publishing a Docker image

This application uses Google Jib to build an optimized Docker image into the Docker Hub repository. The pom.xml has been configured to publish the image with name: springcommunity/spring-petclinic-rest

Command line to run:

mvn compile jib:build -X -DjibSerialize=true -Djib.to.auth.username=xxx -Djib.to.auth.password=xxxxx

Performance Testing

To benchmark the scalability of the PetClinic REST API, a JMeter test plan is available.

• See the JMeter Performance Test for details.
• Run the test using:

  jmeter -n -t src/test/jmeter/petclinic-jmeter-crud-benchmark.jmx \
  -Jthreads=100 -Jduration=600 -Jops=2000 -Jramp_time=120 \
  -l results/petclinic-test-results.jtl
  
  

API Testing with Postman + Newman

This project contains non-regression tests for the Petclinic API, built with Postman and executed via Newman, with automated HTML reports for easy analysis.

• See the Postman + Newman Test for details.
• You can run the tests with 2 ways: I. Giving Execution Permission to the script file:

  chmod +x postman-tests.sh
  ./postman-tests.sh
  

  II. Without Permission to the script file:

  zsh postman-tests.sh
  

Note: You can use your currently bash installed. Like: “bash postman-tests.sh”

Interesting Spring Petclinic forks

The Spring Petclinic master branch in the main spring-projects GitHub org is the “canonical” implementation, currently based on Spring Boot and Thymeleaf.

This spring-petclinic-rest project is one of the several forks hosted in a special GitHub org: spring-petclinic. If you have a special interest in a different technology stack that could be used to implement the Pet Clinic then please join the community there.

Contributing

The issue tracker is the preferred channel for bug reports, features requests and submitting pull requests.

For pull requests, editor preferences are available in the editor config for easy use in common text editors. Read more and download plugins at http://editorconfig.org.