Software Programming: Rest API

Multiples DATABASE Connection and Data shifting Using Spring Boots API

cron job scheduler , java 8 , Microservices , Multiples DATABASE Connection , Rest API , Spring Boot 1 comment :

Multiple DataBase Connection and Data shifting using Spring boot API configuration Example.

Step-by-step Write Java files.
1. application.properties File for Add multiple DataBase Connection.

2. DBConfigDBNAME.JAVA Files for multiple DataBase Connection.

3. Job Scheduler.java file for Auto shift programm.

4. Entity Beans, Repository, Services Implementations for Binding and shifting Data.

Create Spring Boot Java (Microservices)

Create Spring Boot Java (Microservices).

Project Name: DataShiftingConfigSpringBoots
Group: DataShifting-a143mk
Artifactid: DataShifting-a143mk
Description: DataBase Connection and Data shifting using Spring boot API.
Package: DataShiftinga143mk

Select the technologies and library(Maven Dependency ) to be.

spring-boot-configuration-processor
ojdbc8

while creating the project pom.xml file and some maven dependency, main class is automatically created when web add any dependency like.

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>DataShiftinga143mk</groupId>
	<artifactId>DataShifting-a143mk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>DataShiftingConfigSpringBoots</name>
	<description>DataBase Connection and Data shifting using Spring boot API</description>

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.3.RELEASE</version>
		<relativePath/> 
	</parent>

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

<dependency>
               <groupId>com.oracle.database.jdbc</groupId>
               <artifactId>ojdbc8</artifactId>
               <version>12.2.0.1</version>
           </dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
	</dependencies>

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

<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				
				<configuration>
					<useFile>false</useFile>
					<includes>
						<include>**/*Spec.java</include>
					</includes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

1. Configure application.properties

spring.jpa.database=default
spring.jpa.generate-ddl=true
server.port=9191

#  DB - "DATABASE1"
DATABASE1.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE1.datasource.url=jdbc:oracle:thin:@100.00.0.001:1521/serviceName(SID)
DATABASE1.datasource.username=db1UserName
DATABASE1.datasource.password=db1Password

#  DB - "DATABASE2"
DATABASE2.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE2.datasource.url=jdbc:oracle:thin:@100.00.1.002:1521/serviceName(SID)
DATABASE2.datasource.username=db2UserName
DATABASE2.datasource.password=db2Password

#  DB - "DATABASE3"
DATABASE3.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE3.datasource.url=jdbc:oracle:thin:@100.00.1.003:1521/serviceName(SID)
DATABASE3.datasource.username=db3UserName
DATABASE3.datasource.password=db3Password

#### LOGE FILE BLOCK#####
logging.level.org.springframework.web=INFO
logging.level.guru.springframework.controllers=DEBUG
logging.level.org.hibernate=ERROR
logging.file=logs/SHIPTING/masterShift.log
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

Create DataBase Configuration java Files :
DBConfigDATABASE1.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE1EntityManagerFactory",
    transactionManagerRef = "DATABASE1TransactionManager", basePackages = {"com.a143mk.DATABASE1.CustomerRepo"})
public class DATABASE1DbConfig {

@Bean(name = "DATABASE1DataSource")
  @ConfigurationProperties(prefix = "DATABASE1.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE1EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE1EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE1DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE1.CustomerEntity").persistenceUnit("DATABASE1")
        .build();
  }

@Bean(name = "DATABASE1TransactionManager")
  public PlatformTransactionManager DATABASE1TransactionManager(
      @Qualifier("DATABASE1EntityManagerFactory") EntityManagerFactory DATABASE1EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE1EntityManagerFactory);
  }

}

DBConfigDATABASE2.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE2EntityManagerFactory",
    transactionManagerRef = "DATABASE2TransactionManager", basePackages = {"com.a143mk.DATABASE2.CustomerRepo"})
public class DATABASE2DbConfig {

@Bean(name = "DATABASE2DataSource")
  @ConfigurationProperties(prefix = "DATABASE2.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE2EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE2EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE2DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE2.CustomerEntity").persistenceUnit("DATABASE2")
        .build();
  }

@Bean(name = "DATABASE2TransactionManager")
  public PlatformTransactionManager DATABASE2TransactionManager(
      @Qualifier("DATABASE2EntityManagerFactory") EntityManagerFactory DATABASE2EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE2EntityManagerFactory);
  }

}

DBConfigDATABASE3.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE3EntityManagerFactory",
    transactionManagerRef = "DATABASE3TransactionManager", basePackages = {"com.a143mk.DATABASE3.CustomerRepo"})
public class DATABASE3DbConfig {

@Bean(name = "DATABASE3DataSource")
  @ConfigurationProperties(prefix = "DATABASE3.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE3EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE3EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE3DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE3.CustomerEntity").persistenceUnit("DATABASE3")
        .build();
  }

@Bean(name = "DATABASE3TransactionManager")
  public PlatformTransactionManager DATABASE3TransactionManager(
      @Qualifier("DATABASE3EntityManagerFactory") EntityManagerFactory DATABASE3EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE3EntityManagerFactory);
  }

}

Create Scheduler ClassCreate Scheduler for Auto run Program and import some Packages Scheduler.java as below:

package com.a143mk.schedule;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import com.a143mk.DATABASE3.ServiceImpl.MastCustomerDATABASE3ServiceImpl;
import com.a143mk.DATABASE2.ServiceImpl.MastCustomerDATABASE2ServiceImpl;
import com.a143mk.DATABASE1.CustomerServicesImpl.CustomerMasterDATABASE1SericesImpl;
@EnableScheduling
@Configuration
public class Scheduler {
	
	
	@Autowired
	private CustomerMasterDATABASE1SericesImpl custDATABASE1ServiceImpl;
	
	@Autowired
	private MastCustomerDATABASE3ServiceImpl DATABASE3CustomerServiImpl;
	
	@Autowired
	private  MastCustomerDATABASE2ServiceImpl  DATABASE2CustServeImple;

@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE1() throws Exception {
		custDATABASE1ServiceImpl.customerinsertToDATABASE1();	
	}
	
	@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE3() throws Exception {
	 DATABASE3CustomerServiImpl.customerinsertToDATABASE3();	
	}
	
	@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE2() throws Exception {
	DATABASE2CustServeImple.customerinsertToDATABASE2();	
	}

}

Have you seen the previous post? You all know how to learn and create Entity Bean, Repository, Service Implementation in the project. If you don't know about it then go to the previous post and learn it.

A Rest API with Spring Boot using JSON, MySQL and JPA

java , Rest API , Spring , Spring Boot 2 comments :

Introduction:
In this article will look into how to create a REST API using HTTP methods for Create and Retrieve operations in Spring Boot along with MYSQL database. Spring Boot is an open source Java-based framework to build enterprise spring applications. .

Overview:

Create MYSQL database From WampServer.
Create the Spring Boot Project From STS-4.
Create Entity model class.
Create JPA Data Repository.
Create Service class.
Create Rest Controllers class.
Run the Project.
Testing using Postman.
Video Link for watching How to build API.

Create MYSQL database using WampServer.
Download WampServer install and Run-> go to phpMyAdmin and click.

Open localhost/phpmyadmin/

Create Database Name is “hostel”.

Crate Table in hostel Database. Table Name is states with number of fields/Column.

Create Table column name, which is show in image.

Create the Spring Boot Project from STS-4:
It will write project name, group, artifact, version, description, package etc.

Create Entity model class.

Create the States model class to map with the States table.
@Entity is used to annotate that the class is an entity in the database.
@Table is used to annotate name of table in the database.
@id is used to reference that widget to your java file and access it from java file.
@GeneratedValue is used to generation strategies for the values of primary keys.

States.java

Create JPA Data Repository.

Create StatsRepository Repository interface extending JPA Repository.
There are not need writing any SQL/MySql etc query.
@Repository annotation is used to indicate that the class provides the mechanism for storage, retrieval, search, and update and delete operation on objects.

StatsRepository.java

Create Service class.

Create StateService service class to code the business logic and it acts as a middle layer between repository and controller class.
@Service annotation is a specialization of @Component annotation. Spring Service annotation can be applied only to classes. It is used to mark the class as a service provider.
@Transactional StateService annotate methods are executed in transactions.
Example:
@Transactional(readOnly = false, rollbackFor={Throwable.class, Exception.class}, propagation = Propagation.SUPPORTS)
@Autowired annotation is used for automatic dependency injection. Spring framework is built on dependency injection and we inject the class dependencies through spring bean configuration file.

StateService.java

Create Rest Controllers class.

Create Rest StateController Controller class which contains all REST API endpoints for Create and Retrieve operations.
@RestController annotation was introduced in Spring 4.0 to simplify the creation of REST web services. It's a convenience annotation that combines @Controller and @ResponseBody– which eliminates the need to annotate every request handling method of the controller class with the @ResponseBody annotation.

StateService.java

package com.a143mk.SpringBoot.Controller;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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.RestController;
import com.a143mk.SpringBoot.Entity.States;
import com.a143mk.SpringBoot.Services.StateService;

@RestController
public class StateController {
	private static final Logger loginf = LoggerFactory.getLogger(StateController.class);
	
	@Autowired
	private StateService servAutoWar;
	
	
	@RequestMapping("/test")
	public String testUrl() {
		return "Welcome to A143Mk!";
	}
	
	//save Sate Mapping function
	@RequestMapping("/saveState")
	public States saveSatesTo(@RequestBody States  state ) {
		loginf.info("saveSatesTo Information");
		return servAutoWar.seveSate(state);
	}
	
	//get id wise State in State Table
	@RequestMapping("/{id}")
	public States getSateTo(@PathVariable("id") int id) {
		loginf.info("getSateTo Information");
		return servAutoWar.getStateID(id);
	}
	
	
	//get all State in State Table
	@RequestMapping("/allState")
	public List<States> getAllSate() {
		loginf.info("getAllSate Information");
		return servAutoWar.getAllState();
	}

}

Run the Project:
Write click to project and Run as->Spring boot App, it will check console to run project success and check running port.

Testing using Postman.
Execute GET Request method to add a States to the Database.

Video Link for watching How to build API.

Download Project: Download

Subscribe to: Posts ( Atom )

Multiples DATABASE Connection and Data shifting Using Spring Boots API

A Rest API with Spring Boot using JSON, MySQL and JPA

Pageviews

OUR TECH-PROJECTS

Development Accessories

DOWNLOAD ANY ONLINE VIDEOS

LABELS

POPULAR POSTS