Spring Boot + Maven + RestFul + JPA + Sqlite

1. 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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.wfd</groupId>
<artifactId>springDemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>springDemo</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<!-- Dependencies for swagger -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.5.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.5.0</version>
</dependency>

<!-- Dependencies for SQLite -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.3.156</version>
</dependency>
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.8.11.2</version>
</dependency>
<dependency>
<groupId>net.kemitix</groupId>
<artifactId>sqlite-dialect</artifactId>
<version>0.1.0</version>
</dependency>

<!-- Dependencies for JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

2. application.properties :-

jdbc.driverClassName=org.sqlite.JDBC

jdbc.url=jdbc:sqlite:G:/SW/Development/database/sqlite/sample.db

#jdbc.username=

#jdbc.password=

hibernate.dialect=org.hibernate.dialect.SQLiteDialect

hibernate.show_sql=true

3.  main Program : - 

import static com.google.common.collect.Lists.newArrayList;

import static springfox.documentation.schema.AlternateTypeRules.newRule;

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

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.context.annotation.Bean;

import org.springframework.http.ResponseEntity;

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

import org.springframework.web.context.request.async.DeferredResult;

import com.fasterxml.classmate.TypeResolver;

import springfox.documentation.builders.PathSelectors;

import springfox.documentation.builders.RequestHandlerSelectors;

import springfox.documentation.builders.ResponseMessageBuilder;

import springfox.documentation.schema.ModelRef;

import springfox.documentation.schema.WildcardType;

import springfox.documentation.spi.DocumentationType;

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

import springfox.documentation.swagger2.annotations.EnableSwagger2;

@EnableSwagger2

@SpringBootApplication

public class SpringDemoApplication {

public static void main(String[] args) {

System.out.println("main");

SpringApplication.run(SpringDemoApplication.class, args);

}

@Autowired

private TypeResolver typeResolver;

@Bean

public Docket pcfgradleApi() {

return new Docket(DocumentationType.SWAGGER_2).select().apis(RequestHandlerSelectors.any())

.paths(PathSelectors.any()).build().pathMapping("/").genericModelSubstitutes(Re   sponseEntity.class)

.alternateTypeRules(newRule(

typeResolver.resolve(DeferredResult.class,

typeResolver.resolve(ResponseEntity.class, WildcardType.class)),

typeResolver.resolve(WildcardType.class)))

.useDefaultResponseMessages(false)

.globalResponseMessage(RequestMethod.GET, newArrayList(new ResponseMessageBuilder().code(500)

.message("500 message").responseModel(new ModelRef("Error")).build()));

}

}

3. Entity(mapped with Data Base) :-

import javax.persistence.*;

@Entity

@Table(name = "person")

public class Person {

@Id

 @GeneratedValue(strategy = GenerationType.AUTO)

private Integer id ;

@Column

 private  String name ;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "Person [id=" + id + ", name=" + name + "]";

}

}

4. Repository :-

import org.springframework.data.jpa.repository.JpaRepository;

import com.wfd.springDemo.entity.Person;

public interface PersonRepository extends JpaRepository<Person,Integer> {

}

5.  Controller :-

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

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.RequestParam;

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

import com.wfd.springDemo.entity.Person;

import com.wfd.springDemo.sevice.StudentService;

/**

 * @author BayaReddy

 *

 */

@RestController

@RequestMapping("/student")

public class StudentControler {

@Autowired

@Qualifier("oldStudentService")

StudentService studentService;

@RequestMapping(method = RequestMethod.POST)

public Person createStudent(@RequestBody Person person){

System.out.println("person : "+person);

System.out.println("service scope : "+ studentService);

// calling to service

return studentService.createPerson(person);

}

}

5. Service :-

import java.util.Map;

import com.wfd.springDemo.entity.Person;

public interface StudentService {

public Person createStudent(Person person);

}

StudentServiceImpl  :-

import java.util.Map;

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

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

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

import org.springframework.stereotype.Component;

import com.wfd.springDemo.entity.Person;

import com.wfd.springDemo.repository.PersonRepository;

@Component

@Qualifier("oldStudentService")

public class StudentServiceImpl implements StudentService{

@Autowired

PersonRepository personRepository;

public List<Person> createStudent(Person person){

System.out.println("Save person recrod");

return personRepository.save(person);

}

}

Download application :-
download application with this link.

SqLite link