swagger 2 ui

how to implement spring rest api with swagger 2 example

Swagger 2 implementation with Spring

Spring and Swagger 2 play together very well.... Spring makes developing RESTful services ridiculously easy — and using Swagger makes documenting your RESTful services easy.... In this post, I’ll cover how to use Swagger 2 to generate REST API documentation for a Spring

API Design

Design is the foundation of your API development. Swagger makes API design a breeze, with easy-to-use tools for developers, architects, and product owners.

API Development

Protocols, error handling, and code modularity are just some of the questions your teams need to address before building a great API. Swagger provides tools for quickly prototyping and building your API’s functionality.

API Documentation

Swagger takes the manual work out of API documentation, with a range of solutions for generating, visualizing, and maintaining API docs.

API Testing

Start your functional, security, and performance testing right from the OpenAPI Spec. Swagger tooling and the ReadyAPI platform make it easy to rapidly create, manage, & execute API tests in your pipeline.

API Mocking and Virtualization

Reduce dependencies in your development and testing cycles and stand-up realistic, dynamic mocks in seconds with Swagger and ServiceV Pro.

API Monitoring

Monitor API availability, speed, and functionality starting from your OpenAPI Specification (OAS) with AlertSite for OAS. Automate monitor creation and instantly track API behavior to ensure everything runs smoothly in production.

Below have example .

Create a Configuration Class.

package com.xavient.configuration;

import javax.naming.NamingException;

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.jndi.JndiTemplate;

import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import springfox.documentation.builders.PathSelectors;

import springfox.documentation.builders.RequestHandlerSelectors;

import springfox.documentation.spi.DocumentationType;

import springfox.documentation.spring.web.plugins.Docket;

import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration

@EnableWebMvc

@EnableSwagger2

@ComponentScan(basePackages = "com.xavient")

public class HelloWorldConfiguration extends WebMvcConfigurerAdapter {

@Bean

public DataSource dataSource() throws NamingException {

return (DataSource) new JndiTemplate().lookup("java:jboss/datasources/mysqldb");

}

@Bean

public Docket api() {

return new Docket(DocumentationType.SWAGGER_2)

.select()

.apis(RequestHandlerSelectors.basePackage("com.xavient.controller"))

.paths(PathSelectors.any())

.build();

}

@Override

public void addResourceHandlers(ResourceHandlerRegistry registry) {

registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");

registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");

}

2. Create Initialiser Class.

package com.xavient.configuration;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class HelloWorldInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

@Override

protected Class<?>[] getRootConfigClasses() {

return new Class[] { HelloWorldConfiguration.class };

}

@Override

protected Class<?>[] getServletConfigClasses() {

return null;

}

@Override

protected String[] getServletMappings() {

return new String[] { "/" };

}

3. Create Controller Class

package com.xavient.controller;

import java.text.DateFormat;

import java.util.Date;

import java.util.List;

import java.util.Locale;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.util.UriComponentsBuilder;

import com.xavient.model.User;

import com.xavient.service.UBUserService;

import com.xavient.service.UserService;

import com.xavient.serviceimpl.UBUserServiceImpl;

@RestController

@RequestMapping(value = "/myappuser")

public class HelloWorldRestController {

private static final Logger log = LoggerFactory.getLogger(UBUserServiceImpl.class);

@Autowired

UserService userService; //Service which will do all data retrieval/manipulation work

@Autowired

UBUserService ubUserService;

@RequestMapping(value = "/", method = RequestMethod.GET)

public String home(Locale locale, Model model) {

Date date = new Date();

DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

String formattedDate = dateFormat.format(date);

model.addAttribute("serverTime", formattedDate );

return "/user";

}

//-------------------Retrieve All Users--------------------------------------------------------

@RequestMapping(value = "/user", method = RequestMethod.GET)

public ResponseEntity<List<User>> listAllUsers() {

List<User> users = ubUserService.findAllUsers();

if(users.isEmpty()){

return new ResponseEntity<List<User>>(HttpStatus.NO_CONTENT);//You many decide to return HttpStatus.NOT_FOUND

}

return new ResponseEntity<List<User>>(users, HttpStatus.OK);

}

//-------------------Retrieve Single User--------------------------------------------------------

@RequestMapping(value = "/user/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

public ResponseEntity<User> getUser(@PathVariable("id") long id) {

log.info("Fetching User with id " + id);

User user = ubUserService.findById(id);

if (user == null) {

log.info("User with id " + id + " not found");

return new ResponseEntity<User>(HttpStatus.NOT_FOUND);

}

return new ResponseEntity<User>(user, HttpStatus.OK);

}

//-------------------Create a User--------------------------------------------------------

@RequestMapping(value = "/user", method = RequestMethod.POST)

public ResponseEntity<Void> createUser(@RequestBody User user, UriComponentsBuilder ucBuilder) {

log.info("Creating User " + user.getName());

if (ubUserService.isUserExist(user)) {

log.info("A User with name " + user.getName() + " already exist");

return new ResponseEntity<Void>(HttpStatus.CONFLICT);

}

ubUserService.saveUser(user);

HttpHeaders headers = new HttpHeaders();

headers.setLocation(ucBuilder.path("/user/{id}").buildAndExpand(user.getId()).toUri());

return new ResponseEntity<Void>(headers, HttpStatus.CREATED);

}

//------------------- Update a User --------------------------------------------------------

@RequestMapping(value = "/user/{id}", method = RequestMethod.PUT)

public ResponseEntity<User> updateUser(@PathVariable("id") long id, @RequestBody User user) {

log.info("Updating User " + id);

User currentUser = ubUserService.findById(id);

if (currentUser==null) {

log.info("User with id " + id + " not found");

return new ResponseEntity<User>(HttpStatus.NOT_FOUND);

}

currentUser.setName(user.getName());

currentUser.setAge(user.getAge());

currentUser.setSalary(user.getSalary());

ubUserService.updateUser(currentUser);

return new ResponseEntity<User>(currentUser, HttpStatus.OK);

}

//------------------- Delete a User --------------------------------------------------------

@RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)

public ResponseEntity<User> deleteUser(@PathVariable("id") long id) {

log.info("Fetching & Deleting User with id " + id);

User user = ubUserService.findById(id);

if (user == null) {

log.info("Unable to delete. User with id " + id + " not found");

return new ResponseEntity<User>(HttpStatus.NOT_FOUND);

}

ubUserService.deleteUserById(id);

return new ResponseEntity<User>(HttpStatus.NO_CONTENT);

}

//------------------- Delete All User --------------------------------------------------------

@RequestMapping(value = "/user ", method = RequestMethod.DELETE)

public ResponseEntity<User> deleteAllUsers() {

log.info("Deleting All Users");

ubUserService.deleteAllUsers();

return new ResponseEntity<User>(HttpStatus.NO_CONTENT);

}

4 . Create Dao

public interface UserDao {

User findById(long id);

User findByName(String name);

void saveUser(User user);

void updateUser(User user);

void deleteUserById(long id);

List<User> findAllUsers();

void deleteAllUsers();

public boolean isUserExist(User user);

}

5. Create Dao Implementation class.

package com.xavient.daoimp;

import java.util.List;

import javax.sql.DataSource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Repository;

import com.xavient.dao.UserDao;

import com.xavient.model.User;

@Repository

public class UserDaoImpl implements UserDao {

private static final Logger log = LoggerFactory.getLogger(UserDaoImpl.class);

JdbcTemplate jdbcTemplate;

boolean flag;

@Autowired // tried @Autowired also

public void setDataSource(DataSource datasource) {

this.jdbcTemplate = new JdbcTemplate(datasource);

}

@Override

public User findById(long id) {

log.info("Querying for user records by Id");

User user = new User();

jdbcTemplate.query("SELECT id,name,age,salary FROM user WHERE id = ?",new Object[] { id }, rs -> {

if(rs.next()){

user.setId(rs.getLong("id"));

user.setName(rs.getString("name"));

user.setAge(rs.getInt("age"));

user.setSalary(rs.getDouble("salary"));

return user;

}

else {

return null;

}

});

return user;

}

@Override

public User findByName(String name) {

log.info("Querying for user records by Name");

User user = new User();

jdbcTemplate.query("SELECT id,name,age,salary FROM user WHERE name = ?",new Object[] { name }, rs -> {

if(rs.next()){

user.setId(rs.getLong("id"));

user.setName(rs.getString("name"));

user.setAge(rs.getInt("age"));

user.setSalary(rs.getDouble("salary"));

return user;

}

else {

return null;

}

});

return user;

}

@Override

public void saveUser(User user) {

jdbcTemplate.update("INSERT INTO user(id,name,age,salary) VALUES (?,?,?,?)",user.getId(),user.getName(),user.getAge(),user.getSalary());

// jdbcTemplate.update("INSERT INTO user(name) VALUES (?)", user);

}

@Override

public void updateUser(User user) {

String sqlUpdate = "UPDATE user set name=?,age=?,salary=? where id=?";

jdbcTemplate.update(sqlUpdate, user.getName(),user.getAge(),user.getSalary(), user.getId());

}

@Override

public void deleteUserById(long id) {

jdbcTemplate.update("delete from user where id=?",id);

}

@Override

public List<User> findAllUsers() {

log.info("Querying for user records where name like 'Josh %':");

List<User> user=(List<User>) jdbcTemplate.query("SELECT id,name,age,salary FROM user",

(rs, rowNum) -> new User(rs.getLong("id"), rs.getString("name"), rs.getInt("age"),rs.getDouble("salary")));

return user;

}

@Override

public void deleteAllUsers() {

jdbcTemplate.execute("delete from user");

}

@Override

public boolean isUserExist(User user) {

log.info("Querying for user records by Name");

User u = new User();

jdbcTemplate.query("SELECT id,name,age,salary FROM user WHERE id = ?",new Object[] { user.getId() }, rs -> {

if(rs.next()){

u.setId(rs.getLong("id"));

u.setName(rs.getString("name"));

u.setAge(rs.getInt("age"));

u.setSalary(rs.getDouble("salary"));

return true;

}

else {

flag=false;

return false;

}

});

return flag;

}

6. Create Model Class.\

package com.xavient.model;

public class User {

private long id;

private String name;

private int age;

private double salary;

public User(){

id=0;

}

public User(long id, String name, int age, double salary){

this.id = id;

this.name = name;

this.age = age;

this.salary = salary;

}

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public double getSalary() {

return salary;

}

public void setSalary(double salary) {

this.salary = salary;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + (int) (id ^ (id >>> 32));

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

User other = (User) obj;

if (id != other.id)

return false;

return true;

}

@Override

public String toString() {

return "User [id=" + id + ", name=" + name + ", age=" + age

+ ", salary=" + salary + "]";

}

8. Create Service Interface

public interface UserService {

void createTable();

User findById(long id);

User findByName(String name);

void saveUser(User user);

void updateUser(User user);

void deleteUserById(long id);

List<User> findAllUsers();

void deleteAllUsers();

public boolean isUserExist(User user);

}

public interface UBUserService {

void createTable();

User findById(long id);

User findByName(String name);

void saveUser(User user);

void updateUser(User user);

void deleteUserById(long id);

List<User> findAllUsers();

void deleteAllUsers();

public boolean isUserExist(User user);

}

9. Create Service Impl.

package com.xavient.serviceimpl;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.concurrent.atomic.AtomicLong;

import java.util.stream.Collectors;

import javax.sql.DataSource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.xavient.model.User;

import com.xavient.service.UserService;

@Service("userService")

@Transactional

public class UserServiceImpl implements UserService{

private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);

private static final AtomicLong counter = new AtomicLong();

JdbcTemplate jdbcTemplate;

@Autowired // tried @Autowired also

public void setDataSource(DataSource datasource) {

this.jdbcTemplate = new JdbcTemplate(datasource);

}

private static List<User> users;

static{

users= populateDummyUsers();

}

public List<User> findAllUsers() {

//createTable();

return users;

}

public User findById(long id) {

for(User user : users){

if(user.getId() == id){

return user;

}

return null;

}

public User findByName(String name) {

for(User user : users){

if(user.getName().equalsIgnoreCase(name)){

return user;

}

return null;

}

public void saveUser(User user) {

user.setId(counter.incrementAndGet());

users.add(user);

}

public void updateUser(User user) {

int index = users.indexOf(user);

users.set(index, user);

}

public void deleteUserById(long id) {

for (Iterator<User> iterator = users.iterator(); iterator.hasNext(); ) {

User user = iterator.next();

if (user.getId() == id) {

iterator.remove();

}

public boolean isUserExist(User user) {

return findByName(user.getName())!=null;

}

private static List<User> populateDummyUsers(){

List<User> users = new ArrayList<User>();

users.add(new User(counter.incrementAndGet(),"Sam",30, 70000));

users.add(new User(counter.incrementAndGet(),"Tom",40, 50000));

users.add(new User(counter.incrementAndGet(),"Jerome",45, 30000));

users.add(new User(counter.incrementAndGet(),"Silvia",50, 40000));

return users;

}

public void deleteAllUsers() {

users.clear();

}

@Override

public void createTable() {

log.info("Creating tables");

System.out.println("hello");

// jdbcTemplate.execute("DROP TABLE user IF EXISTS");

jdbcTemplate.execute("CREATE TABLE user(" +

"id long, name VARCHAR(255), age int, salary double)");

// Split up the array of whole names into an array of first/last names

List<Object[]> splitUpNames = Arrays.asList("John Woo", "Jeff Dean", "Josh Bloch", "Josh Long").stream()

.map(name -> name.split(","))

.collect(Collectors.toList());

// Use a Java 8 stream to print out each tuple of the list

splitUpNames.forEach(name -> log.info(String.format("Inserting user record for %s ", name[0])));

// Uses JdbcTemplate's batchUpdate operation to bulk load data

jdbcTemplate.batchUpdate("INSERT INTO user(name) VALUES (?)", splitUpNames);

log.info("Querying for user records where name = 'Josh':");

jdbcTemplate.query(

"SELECT id,name, age,salary FROM user WHERE name = ?", new Object[] { "Josh" },

(rs, rowNum) -> new User(rs.getLong("id"), rs.getString("name"), rs.getInt("age"),rs.getDouble("salary"))

).forEach(customer -> log.info(customer.toString()));

}

package com.xavient.serviceimpl;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.xavient.daoimp.UserDaoImpl;

import com.xavient.model.User;

import com.xavient.service.UBUserService;

@Service

public class UBUserServiceImpl implements UBUserService {

private static final Logger log = LoggerFactory.getLogger(UBUserServiceImpl.class);

@Autowired

UserDaoImpl userDao;

@Override

public void createTable() {

// TODO Auto-generated method stub

}

@Override

public User findById(long id) {

log.info("findById method called whith id :"+id);

return userDao.findById(id);

}

@Override

public User findByName(String name) {

log.info("findByName method called whith Name :"+name);

return userDao.findByName(name);

}

@Override

public void saveUser(User user) {

log.info("saveUser method called whith user :"+user);

userDao.saveUser(user);

}

@Override

public void updateUser(User user) {

log.info("updateUser method called whith user :"+user);

userDao.updateUser(user);

}

@Override

public void deleteUserById(long id) {

log.info("deleteUserById method called whith user :"+id);

userDao.deleteUserById(id);

}

@Override

public List<User> findAllUsers() {

log.info("findAllUsers method called");

return userDao.findAllUsers();

}

@Override

public void deleteAllUsers() {

log.info("deleteAllUsers method called");

userDao.deleteAllUsers();

}

@Override

public boolean isUserExist(User user) {

log.info("isUserExist method called");

return userDao.isUserExist(user);

}

10. Create Log4j.xml to maintain the log

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

</layout>

</appender>

<param name="ConversionPattern"

value="%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n" />

</layout>

</appender>

</logger>

</logger>

</logger>

</logger>

</logger>

<root>

<appender-ref ref="file" />

<appender-ref ref="console" />

</root>

</log4j:configuration>

11. Create deployment descriptor to build the project

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

<artifactId>myapp</artifactId>

<name>myapp</name>

<java-version>1.8</java-version>

<org.springframework-version>5.0.0.RELEASE</org.springframework-version>

<jackson.version>2.9.4</jackson.version>

<org.aspectj-version>1.6.10</org.aspectj-version>

<org.slf4j-version>1.6.6</org.slf4j-version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${org.springframework-version}</version>

<groupId>commons-logging</groupId>

<artifactId>commons-logging</artifactId>

</exclusion>

</exclusions>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${org.springframework-version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${org.springframework-version}</version>

</dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjrt</artifactId>

<version>${org.aspectj-version}</version>

</dependency>

<version>${org.slf4j-version}</version>

</dependency>

<version>${org.slf4j-version}</version>

<scope>runtime</scope>

</dependency>

<version>${org.slf4j-version}</version>

<scope>runtime</scope>

</dependency>

<groupId>javax.mail</groupId>

</exclusion>

<groupId>javax.jms</groupId>

</exclusion>

<artifactId>jmxtools</artifactId>

</exclusion>

<artifactId>jmxri</artifactId>

</exclusion>

</exclusions>

<scope>runtime</scope>

</dependency>

<groupId>javax.inject</groupId>

<artifactId>javax.inject</artifactId>

</dependency>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

<version>${jackson.version}</version>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>javax.servlet-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet.jsp</groupId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet</groupId>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>5.0.4.RELEASE</version>

</dependency>

<!-- <dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency> -->

<groupId>com.h2database</groupId>

</dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger2</artifactId>

</dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger-ui</artifactId>

</dependency>

<groupId>org.springframework.hateoas</groupId>

<artifactId>spring-hateoas</artifactId>

<version>0.24.0.RELEASE</version>

</dependency>

</dependencies>

<build>

<!-- <plugin> <artifactId>maven-eclipse-plugin</artifactId> <version>3.2</version>

<configuration> <additionalProjectnatures> <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>

</additionalProjectnatures> <additionalBuildcommands> <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>

</additionalBuildcommands> <downloadSources>true</downloadSources> <downloadJavadocs>true</downloadJavadocs>

</configuration> </plugin> -->

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-war-plugin</artifactId>

<warSourceDirectory>src/main/webapp</warSourceDirectory>

<warName>myapp</warName>

<failOnMissingWebXml>false</failOnMissingWebXml>

</configuration>

</plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

<compilerArgument>-Xlint:all</compilerArgument>

</configuration>

</plugin>

<groupId>org.codehaus.mojo</groupId>

<artifactId>exec-maven-plugin</artifactId>

</configuration>

</plugin>

</plugins>

<finalName>myapp</finalName>

</build>

</project>

To test the swagger out put type the below URL in browser address bar

http://localhost:8080/myapp/swagger-ui.html#/

Thursday, 3 January 2019

swagger ui

swagger 2 ui

how to implement spring rest api with swagger 2 example

API Design

Design is the foundation of your API development. Swagger makes API design a breeze, with easy-to-use tools for developers, architects, and product owners.

API Development

API Documentation

API Testing

API Mocking and Virtualization

API Monitoring

No comments:

Post a Comment

Social Media Icons

Popular Posts