Java Beginners Tutorial - How to program in JAVA

Kafka multi broker cluster setup on windows 10 | kafka tutorials

noreply@blogger.com (Abderrahmen Ben Mariem) — Fri, 01 Jan 2021 22:32:00 +0000

Kafka multi broker cluster setup on windows 10 tutorial shows step by step how to setup apache kafka multi broker cluster on wirdows 10.

In order to know how to install and setup a single broker cluster on windows, you should check this apache kafka install tutorial.

Create Apache Kafka configurations for two brokers

We should duplicate the file config/server.properties two times to create the configurations of the two brokers. In order to do that, we execute these commands :

copy config/server.properties config/server-1.properties
copy config/server.properties config/server-2.properties

Then, we change the following properties of the two files to be the followings :

config/server-1.properties:

broker.id=1
listeners=PLAINTEXT://:9093
log.dir=/tmp/kafka-logs-1

config/server-2.properties:

broker.id=2
listeners=PLAINTEXT://:9094
log.dir=/tmp/kafka-logs-2

Startup the tree Apache Kafka nodes

Before starting apache kafka, you should startup the Zookeeper like what is explained in this apache kafka install tutorial.

Then, you can start the three kafka brokers using these commands

bin/windows/kafka-server-start.bat config/server.properties
bin/windows/kafka-server-start.bat config/server-1.properties
bin/windows/kafka-server-start.bat config/server-2.properties

In fact, you should run each command in a separate terminal.

Create new topic replicated to all 3 brokers

Creating apache kafka topic

In order to create an apache Kafka topic, you should run this command :

bin/windows/kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic replicated-topic

This command creates a topic called replicated-topic that we will use to send and receive messages.

Visualizing apache kafka topic

We can visualize apache kafka topic using this command :

bin/windows/kafka-topics.sh --describe --zookeeper localhost:2181 --topic replicated-topic

In order to check how to produce and consume messages, please check this apache kafka setup tutorial.

Conclusion

This Kafka multi broker cluster setup on windows 10 tutorial arrives at its end.

You may check also our core java tutorial to learn core java from scratch. Please keep tuned because we will release more tutorials about apache kafka and java microservices.

In order to get our latest updates, please feel free to like our how to program facebook page.

Install apache kafka on windows 10 | kafka tutorials

noreply@blogger.com (Abderrahmen Ben Mariem) — Fri, 01 Jan 2021 16:44:00 +0000

Install apache kafka on windows 10 tutorial shows step by step how to install apache kafka on wirdows 10.

Download and install Apache Kafka

First of all, you should download the compressed version of kafka from the kafka website.

In fact, you should already have the JDK installed.

Then, you should put the zipped version of apache Kafka at the root of C:\ drive. This avoids the error that says command is too long.

Now, you should uncompress it using this command :

tar -xzf <kafka tarball>

Startup Apache Kafka

Before starting apache kafka, you should startup the Zookeeper using this command :

bin/windows/zookeeper-server-start.bat config/zookeeper.properties

Then, you can start the kafka server using this command :

bin/windows/kafka-server-start.bat config/server.properties

In order to allow the Kafka server to connect to the zookeeper, you should change these parameters in the kafka server configuration file.

In the server.properties in the config folder, you should make these modifications :

zookeeper.connection.timeout.ms=60000
#broker.id=0

Creating and visualising Apache Kafka topics

Creating apache kafka topic

In order to create an apache Kafka topic, you should run this command :

bin/windows/kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

This command creates a topic called test that we will use to send and receive messages.

Visualizing apache kafka topic

We can visualize apache kafka topic using this command :

bin/windows/kafka-topics.bat --list --zookeeper localhost:2181

Producing and consuming messages using Apache Kafka

Before launching the kafka producer and consumer programs, we should make sure that both the zookeeper and the kafka server are up and running.

Producing messages

To launch the kafka console producer executable, we should run this command :

bin/windows/kafka-console-producer.bat --broker-list localhost:9092 --topic test

This command sends the data entered in the console to the kafka server. So that, the receiver program listening to the test topic will receive it.

Consuming messages

In order to receive the data from the test topic, we should run this command :

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

Stopping Apache Kafka server and the zookeeper

We shouldn’t stop apache kafka server and the zookeeper using CTRL + C command because we may cause a data corruption.

To stop the kafka server, we should run this command :

bin/windows/kafka-server-stop.bat

In order to stop the zookeeper, we should run this command :

bin/windows/zookeeper-server-stop.bat

Conclusion

This install apache kafka on windows 10 tutorial arrives at its end.

You may check also our core java tutorial to learn core java from scratch. Please keep tuned because we will release more tutorials about apache kafka and java microservices.

In order to get our latest updates, please feel free to like our how to program facebook page.

Spring boot spring data MongoDB reactive crud example | JAVASNEO

noreply@blogger.com (Abderrahmen Ben Mariem) — Fri, 18 Dec 2020 07:57:00 +0000

Spring boot spring data MongoDB reactive crud example tutorial that explains how to create a REST api using Spring boot 2, Spring data MongoDB reactive, Spring Webflux and MongoDB database.

This tutorial is a modification of the tutorial Spring Boot Spring Data MongoDB database tutorial.

Adding Spring data MongoDB reactive and Spring webflux maven dependencies

Spring Webflux replaces Spring MVC and implements the Reactor framework. It has the same annotations as Spring MVC and it doesn’t dépend on the Servlet API.

The dependencies to be added to the maven POM file are the followings :

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

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
</dependency>

Setting up Spring Data Mongo Reactive Repository using JAVA configuration class

The configuration class of the Spring Data MongoDB reactive Repository is the following:

package com.javasneo.todolist.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.repository.config.EnableReactiveMongoRepositories;

@Configuration
@EnableReactiveMongoRepositories(basePackages = "com.javasneo.todolist.repository")
public class ReactiveMongoConfig {
}

Here, we activate Spring Data Mongo Reactive Repositories by providing the package where those repositories can be found.

Updating the REST API to use MongoDB database reactive

In order to update the Spring Boot REST API example, we will :

Update repository that makes the CRUD operations
Update service that uses this repository
Update the controller to use this service

In order to be full reactive, the repositories, the services and the controllers should return a reactive type (Flux, Mono) and take a reactive type as possible.

To get a good introduction about Spring webflux and the reactive programming using Spring Framework 5, you may check the part 3 of this book.

Rest API Repository

The repository is a java interface with no javaclass implementing it. This is a spring Data Mongodb reactive feature that auto-generates the CRUD code for us based on an interface that we specify.

The code of the repository is the following :

package com.javasneo.todolist.repository;

import com.javasneo.todolist.model.Todo;
import org.springframework.data.mongodb.repository.ReactiveMongoRepository;

public interface TodoRepository extends ReactiveMongoRepository<Todo, String> {
}

The TodoRepository interface should extend the Spring Data MongoDB reactive interface ReactiveMongoRepository and give two parameters to that interface :

The first one is the Type of the Entity that we will generate the CRUD code for.
The second one is the type of the primary key of the entity (the id attribute in the Todo class is of type String)

Rest API Service

The service layer of the application is composed by the interface of the service and its implementation. Here, we changed the return type of the methods to be either Mono or Flux.

The source code of the interface is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface TodoService {
  Flux<Todo> getAll();
  Mono<Todo> saveOrUpdate(Todo todo);
  void delete(String id);
}

The source code of the implementation is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.repository.TodoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Service
public class TodoServiceImpl implements TodoService{
  @Autowired
  TodoRepository todoRepository;

  public Flux<Todo> getAll(){
    return todoRepository.findAll();
  }

  public Mono<Todo> saveOrUpdate(Todo todo)
  {
    return todoRepository.save(todo);
  }

  public void delete(String id)
  {
    todoRepository.deleteById(id);
  }

}

Rest API controller

The REST controller uses the service layer to provide the CRUD endpoints.

The source code of the controller is the following :

package com.javasneo.todolist.controller;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.service.TodoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/todos")
@CrossOrigin()
public class TodoController {

  @Autowired
  TodoService todoService;

  @RequestMapping(method = RequestMethod.GET)
  public Flux<Todo> todos (){
    return todoService.getAll();
  }

  @RequestMapping(method = RequestMethod.POST)
  public Mono<Todo> addtodo (@RequestBody Todo todo){
    return todoService.saveOrUpdate(todo);
  }


  @RequestMapping(method = RequestMethod.PUT)
  public Mono<Todo> updateTodo (@RequestBody Todo todo){
    return todoService.saveOrUpdate(todo);
  }

  @RequestMapping(value="/{id}", method = RequestMethod.DELETE)
  public void deleteTodo (@PathVariable("id") String id){
    todoService.delete(id);
  }

}

Conclusion

This spring boot spring data MongoDB reactive crud example tutorial arrives at its end.

If you want to know how to test the endpoints using Postman, please check the part 1 of these series of tutorials that deal with Spring Boot 2 REST API.

You may check also our core java tutorial to learn core java from scratch. Please keep tuned because we will release more tutorials about Spring Boot, unit testing, integration testing and other important subjects.

In order to get our latest updates, please feel free to like our how to program facebook page.

Spring boot spring data Cassandra crud example | JAVASNEO

noreply@blogger.com (Abderrahmen Ben Mariem) — Wed, 16 Dec 2020 19:43:00 +0000

Spring boot spring data Cassandra crud example tutorial that explains how to create a REST api using Spring boot 2, Spring data Cassandra and Cassandra database.

This tutorial is a modification of the tutorial Spring Boot Spring Data H2 database tutorial.

Adding Spring data Cassandra maven dependency

You should install Python 2.7 and Cassandra community in order to follow this tutorial.

You can download Python 2.7 from this link .

You can also download cassandra 3.11.6 from this link.

Cassandra has a problems with Python 3.x and JAVA 11. This is why i am using an old version of Python and jdk1.8.0_221.

The dependency to be added to the maven POM file is the following :

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

Setting up Cassandra database using JAVA configuration file

The configuration file of Cassandra is the following:

package com.javasneo.todolist.config;
import com.datastax.oss.driver.api.core.CqlSession;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.cassandra.SessionFactory;
import org.springframework.data.cassandra.config.*;
import org.springframework.data.cassandra.core.CassandraOperations;
import org.springframework.data.cassandra.core.CassandraTemplate;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.mapping.CassandraMappingContext;
import org.springframework.data.cassandra.core.mapping.SimpleUserTypeResolver;
import org.springframework.data.cassandra.repository.config.EnableCassandraRepositories;

@Configuration
@EnableCassandraRepositories(
  basePackages = "com.javasneo.todolist.repository")
public class CassandraConfig extends AbstractCassandraConfiguration {
  @Override
  protected String getKeyspaceName() {
    return "abderrahmen";
  }
  
  public String getContactPoints() {
    return "localhost";
  }

  @Override
  protected String getLocalDataCenter() {
    return "datacenter1";
  }

  @Bean
  @Primary
  public CqlSessionFactoryBean session() {

    CqlSessionFactoryBean session = new CqlSessionFactoryBean();
    session.setContactPoints(getContactPoints());
    session.setKeyspaceName(getKeyspaceName());
    session.setLocalDatacenter(getLocalDataCenter());
    return session;
  }

  @Bean
  @Primary
  public SessionFactoryFactoryBean sessionFactory(CqlSession session, CassandraConverter converter) {
    SessionFactoryFactoryBean sessionFactory = new SessionFactoryFactoryBean();
    sessionFactory.setSession(session);
    sessionFactory.setConverter(converter);
    sessionFactory.setSchemaAction(SchemaAction.NONE);
    return sessionFactory;
  }

  @Bean
  @Primary
  public CassandraMappingContext mappingContext(CqlSession cqlSession) {

    CassandraMappingContext mappingContext = new CassandraMappingContext();
    mappingContext.setUserTypeResolver(new SimpleUserTypeResolver(cqlSession));
    return mappingContext;
  }

  @Bean
  @Primary
  public CassandraConverter converter(CassandraMappingContext mappingContext) {
    return new MappingCassandraConverter(mappingContext);
  }

  @Bean
  public CassandraOperations cassandraTemplate(SessionFactory sessionFactory, CassandraConverter converter) {
    return new CassandraTemplate(sessionFactory, converter);
  }

}

Here, i set set the keyspace as abderrahmen and i set the local data center as datacenter1 (the default value). That keyspace is used when creating our Todo table in Cassandra.

Updating the REST API to use Cassandra database

In order to update the Spring Boot REST API example, we will :

Update the model to add Cassandra annotations
Update repository that makes the CRUD operations
Update service that uses this repository
Update the controller to use this service

Rest API Model

We will add the Cassandra annotations to the Todo entity in order to make it managed by Spring Data Cassandra.

The required annotations are :

@Table : to make the class a Cassandra table
@PrimaryKey : to make a field a primary key

In this class, we can get rid of Getters, Setters and constructors by using lombok. But, i don’t do it for the sake of simplicity and to make the beginners understand the code.

The code of the class is the following :

package com.javasneo.todolist.model;
import org.springframework.data.cassandra.core.mapping.PrimaryKey;
import org.springframework.data.cassandra.core.mapping.Table;
import java.util.UUID;

@Table
public class Todo {

  @PrimaryKey
  private UUID id;
  private String name;
  private String description;

  public Todo() {
  }

  public Todo(UUID id, String name, String description) {
    this.id = id;
    this.name = name;
    this.description = description;
  }

  public UUID getId() {
    return id;
  }

  public void setId(UUID id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public void setName(String name) {
    this.name = name;
  }

  public void setDescription(String description) {
    this.description = description;
  }
}

Rest API Repository

The repository is a java interface with no javaclass implementing it. This is a spring Data Cassandra feature that auto-generates the CRUD code for us based on an interface that we specify.

The code of the repository is the following :

package com.javasneo.todolist.repository;

import com.javasneo.todolist.model.Todo;
import org.springframework.data.cassandra.repository.CassandraRepository;

import java.util.UUID;

public interface TodoRepository extends CassandraRepository<Todo, UUID> {
}

The TodoRepository interface should extend the Spring Data Cassandra interface CassandraRepository and give two parameters to that interface :

The first one is the Type of the Entity that we will generate the CRUD code for.
The second one is the type of the primary key of the entity (the id attribute in the Todo class is of type UUID)

Rest API Service

The service layer of the application is composed by the interface of the service and its implementation.

The source code of the interface is the following :

package com.javasneo.todolist.service;
import com.javasneo.todolist.model.Todo;
import java.util.List;
import java.util.UUID;

public interface TodoService {
  List<Todo> getAll();
  Todo create(Todo todo);
  Todo update(Todo todo);
  void delete(UUID id);
}

The source code of the implementation is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.repository.TodoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@Service
public class TodoServiceImpl implements TodoService{
  @Autowired
  TodoRepository todoRepository;

  public List<Todo> getAll(){
    List<Todo> todoList = new ArrayList<Todo>();
    todoRepository.findAll().forEach(todo -> todoList.add(todo));
    return todoList;
  }

  public Todo create(Todo todo)
  {
    return todoRepository.save(new Todo(UUID.randomUUID(), todo.getName(), todo.getDescription()));
  }
  
  public Todo update(Todo todo)
  {
    return todoRepository.save(todo);
  }

  public void delete(UUID id)
  {
    todoRepository.deleteById(id);
  }

}

Rest API controller

The controller uses the service layer to provide the CRUD endpoints.

The source code of the controller is the following :

package com.javasneo.todolist.controller;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.model.TodoListResponse;
import com.javasneo.todolist.service.TodoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@RestController
@RequestMapping("/todos")
@CrossOrigin()
public class TodoController {

  @Autowired
  TodoService todoService;

  @RequestMapping(method = RequestMethod.GET)
  public TodoListResponse todos (){
    List<Todo> todoList = todoService.getAll();
    TodoListResponse todoListResponse = new TodoListResponse();
    todoListResponse.setTodos(todoList);
    return todoListResponse;
  }

  @RequestMapping(method = RequestMethod.POST)
  public Todo addtodo (@RequestBody Todo todo){
    return todoService.create(todo);
  }

  @RequestMapping(method = RequestMethod.PUT)
  public Todo updateTodo (@RequestBody Todo todo){
    return todoService.update(todo);
  }

  @RequestMapping(value="/{id}", method = RequestMethod.DELETE)
  public void deleteTodo (@PathVariable("id") UUID id){
    todoService.delete(id);
  }

}

Cassandra table creation

The script of the Todo table creation is the following :

create keyspace abderrahmen with replication={'class':'SimpleStrategy', 'replication_factor':1};
use abderrahmen;
 
CREATE TABLE todo(
   id uuid PRIMARY KEY,
   name text,
   description text
);

We run cqlsh executable present in the bin directory of Cassandra. Then, we run the commands above. The Cassandra database should be up and running (we should run cassandra.bat file present in the bin directory before running cqlsh)

Spring Boot REST API Testing

Before being able to test the restful webservice, we should run cassandra by running cassandra.bat present in the bin folder of the unzipped cassandra folder.

If you want to know how to test the endpoints using Postman, please check the part 1 of these series of tutorials that deal with Spring Boot 2 REST API.

In order to check the data in Cassandra, we use cqlsh.bat present in the bin directory of Cassandra community edition. The cqlsh executable gives us a prompt that allow us to run SQL queries.

We may run « select * from todo » to check the content of the todo table.

conclusion

This spring boot spring data Cassandra crud example tutorial arrives at its end.

In order to get our latest updates, please feel free to like our how to program facebook page.

The source code is present in this spring boot spring data Cassandra crud example git repository.

Spring boot Spring data MongoDB crud example | JAVASNEO

noreply@blogger.com (Abderrahmen Ben Mariem) — Tue, 15 Dec 2020 15:55:00 +0000

Spring boot spring data MongoDB crud example tutorial that explains how to create a REST api using Spring boot 2, Spring data jpa and mongoDB database.

This tutorial is a modification of the tutorial Spring Boot Spring Data H2 database tutorial.

Adding Spring data Mongo maven dependency

MongoDB is a very famous noSql database that supports reactive programming.

You should install MongoDB community using this link in order to follow this tutorial.

The dependency to be added to the maven POM file is the following :

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

Setting up MongoDB database using the application.properties file

In the application.properties files, we provide the connection url, the jdbc driver, the username, the password and all the database settings.

The database settings are the followings :

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mydb

Updating the REST API to use MongoDB database

In order to update the Spring Boot Spring Data JPA H2 database CRUD example, we will :

Update the model to add MongoDB annotations
Update the repository that makes the CRUD operations
Update the service that uses this repository
Update the controller that uses this service

Rest API Model

We will add the Mongo annotations to the Todo entity in order to make it managed by Spring Data Mongo.

The required annotations are :

· @Document : to make the class a MongoDB document

· @Id : to make a field a primary key

In this class, we can get rid of Getters, Setters and constructors by using lombok. But, i don’t do it for the sake of simplicity and to make the beginners understand the code.

The code of the class is the following :

package com.javasneo.todolist.model;

import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.annotation.Id;

@Document(collection = "todo")
public class Todo {

  @Id
  private String id;
  private String name;
  private String description;

  public Todo() {
  }

  public Todo(String id, String name, String description) {
    this.id = id;
    this.name = name;
    this.description = description;
  }

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public void setName(String name) {
    this.name = name;
  }

  public void setDescription(String description) {
    this.description = description;
  }
}

Rest API Repository

The repository is a java interface with no java class implementing it. This is a spring Data MongoDB feature that auto-generates the CRUD code for us based on an interface that we specify.

The code of the repository is the following :

package com.javasneo.todolist.repository;

import com.javasneo.todolist.model.Todo;
import org.springframework.data.mongodb.repository.MongoRepository;
public interface TodoRepository extends MongoRepository<Todo, String> {
}

The TodoRepository interface should extend the Spring Data MongoDB interface MongoRepository and give two parameters to that interface :

The first one is the Type of the Entity that we will generate the CRUD code for.
The second one is the type of the primary key of the entity (the id attribute in the Todo class is of type String)

Rest API Service

The service layer of the application is composed by the interface of the service and its implementation.

The source code of the interface is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;

import java.util.List;

public interface TodoService {
  List<Todo> getAll();
  Todo saveOrUpdate(Todo todo);
  void delete(String id);
}

The source code of the implementation is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;

import java.util.List;

public interface TodoService {
  List<todo> getAll();
  Todo saveOrUpdate(Todo todo);
  void delete(String id);
}

The source code of the implementation is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.repository.TodoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class TodoServiceImpl implements TodoService{
  @Autowired
  TodoRepository todoRepository;

  public List<Todo> getAll(){
    List<Todo> todoList = new ArrayList<Todo>();
    todoRepository.findAll().forEach(todo -> todoList.add(todo));
    return todoList;
  }

  public Todo saveOrUpdate(Todo todo)
  {
    return todoRepository.save(todo);
  }

  public void delete(String id)
  {
    todoRepository.deleteById(id);
  }

}

Rest API controller

The controller uses the service layer to provide the CRUD endpoints.

The source code of the controller is the following :

package com.javasneo.todolist.controller;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.model.TodoListResponse;
import com.javasneo.todolist.service.TodoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Abderrahmen on 31/01/2018.
 */
@RestController
@RequestMapping("/todos")
@CrossOrigin()
public class TodoController {

  @Autowired
  TodoService todoService;

  @RequestMapping(method = RequestMethod.GET)
  public TodoListResponse todos (){
    List<Todo> todoList = todoService.getAll();
    TodoListResponse todoListResponse = new TodoListResponse();
    todoListResponse.setTodos(todoList);
    return todoListResponse;
  }

  @RequestMapping(method = RequestMethod.POST)
  public Todo addtodo (@RequestBody Todo todo){
    return todoService.saveOrUpdate(todo);
  }


  @RequestMapping(method = RequestMethod.PUT)
  public Todo updateTodo (@RequestBody Todo todo){
    return todoService.saveOrUpdate(todo);
  }

  @RequestMapping(value="/{id}", method = RequestMethod.DELETE)
  public void deleteTodo (@PathVariable("id") String id){
    todoService.delete(id);
  }

}

Spring Boot REST API Testing

If you want to know how to test the endpoints using Postman, please check the part 1 of these series of tutorials that deal with Spring Boot 2 REST API.

In order to check the data in MongoDB, we use MongoDB compass integrated by default in MongoDB community edition.

This is the UI of the connection to the database : mongodb://localhost:27017

Here, we haven’t specified a login and a password for mongoDB in the application.properties.

We can do it using these lines of code :

spring.data.mongodb.authentication-database=admin
spring.data.mongodb.username=abderrahmen
spring.data.mongodb.password=password

When clicking on connect, we can see our database mydb and our collection todo.

conclusion

this spring boot spring data Mongo crud example tutorial arrives at its end.

In order to get our latest updates, please feel free to like our how to program facebook page.

The source code of this tutorial is present in the github of the author Abderrahmen Ben Mariem.

spring boot spring data jpa h2 database crud example tutorial | JAVASNEO

noreply@blogger.com (Abderrahmen Ben Mariem) — Mon, 14 Dec 2020 23:14:00 +0000

spring boot spring data jpa h2 database crud example tutorial that explains how to create a REST api using Spring boot 2, Spring data jpa and h2 database.

This tutorial is an enhancement of the tutorial that creates a restful webservice using an arrayList as our datasource.

Adding Spring data JPA and h2 database maven dependencies

H2 is an in memory database used for integration testing when we want to test the real endpoint and we don’t want to hit the real database (if we stop the application, we will loose the data stored in the H2 database).

We should be able to replay the tests during the build. So, we add the data used for the tests before running the tests and we don’t depend on the data present in the real database.

We will deal with unit and integration testing of restful webservices in a future tutorial, so please stay tuned.

The dependencies to be added to the maven POM file are the followings :

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

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
   <scope>runtime</scope>
</dependency>

Setting up H2 database using the application.properties file

In the application.properties files, we provide the connection url, the jdbc driver, the username, the password and all the database settings.

The database settings are the followings :

spring.datasource.url=jdbc:h2:mem:mydb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=abderrahmen
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Here the database name is mydb.

We can make the database persistent and not volatile by using a file to store the data.

In this case, we need to change the connection URL to be like this :

spring.datasource.url=jdbc:h2:file:/data/mydb

In order to make Spring Boot create the table used in this tutorial, we add a file in src/main/resources.This file is the data.sql file and its content is the following :

DROP TABLE IF EXISTS todo;

CREATE TABLE todo (
  id INT AUTO_INCREMENT  PRIMARY KEY,
  name VARCHAR(250) NOT NULL,
  description VARCHAR(250) NOT NULL
);

Accessing H2 database console

H2 database has an embedded UI that allows to run SQL queries and manage the database.

This UI is called the H2 database console. In order to enable this console, we should add this line in the application.properties file :

spring.h2.console.enabled=true

Then, we should run the application and access this URL in the browser :

http://localhost:8080/h2-console

Here, we make sure that the JDBC URL is correct. Then, we put the password present in the application.properties and we click on the connect button.

The JDBC URL and the password should be the ones present in the application.properties file.

After clicking on the connect button, we should see this interface :

Now, we should see the TODO table created on the application startup.

Updating the REST API to use H2 database

In order to update the Spring BootREST API example, we will :

Update the model to add JPA annotations
Create a new repository that makes the CRUD operations
Create a new service that uses this repository
Update the controller to use this service

Rest API Model

We will add the JPA annotations to the Todo entity in order to make it managed by Spring Data JPA.

The required annotations are :

@Entity : to make the class a JPA entity
@Id : to make a field a primary key
@GeneratedValue : to make the id auto-incremented

In this class, we can get rid of Getters, Setters and constructors by using lombok. But, i don’t do it for the sake of simplicity and to make the beginners understand the code.

The code of the class is the following :

package com.javasneo.todolist.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Todo {

  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private int id;
  private String name;
  private String description;

  public Todo() {
  }

  public Todo(int id, String name, String description) {
    this.id = id;
    this.name = name;
    this.description = description;
  }

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public void setName(String name) {
    this.name = name;
  }

  public void setDescription(String description) {
    this.description = description;
  }
}

Rest API Repository

The repository is a java interface with no java class implementing it. This is a spring Data JPA feature that auto-generates the CRUD code for us based on an interface that we specify.

The code of the repository is the following :

package com.javasneo.todolist.repository;

import com.javasneo.todolist.model.Todo;
import org.springframework.data.repository.CrudRepository;

public interface TodoRepository extends CrudRepository<Todo, Integer> {
}

The TodoRepository interface should extend the Spring Data JPA interface CrudRepository and give two parameters to that interface :

The first one is the Type of the Entity that we will generate the CRUD code for.
The second one is the type of the primary key of the entity (the id attribute in the Todo class is of type Integer)

Rest API Service

The service layer of the application is composed by the interface of the service and its implementation.

The source code of the interface is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;

import java.util.List;

public interface TodoService {
  List<Todo> getAll();
  Todo saveOrUpdate(Todo todo);
  void delete(int id);
}

The source code of the implementation is the following :

package com.javasneo.todolist.service;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.repository.TodoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class TodoServiceImpl implements TodoService{
  @Autowired
  TodoRepository todoRepository;

  public List<Todo> getAll(){
    List<Todo> todoList = new ArrayList<Todo>();
    todoRepository.findAll().forEach(todo -> todoList.add(todo));
    return todoList;
  }

  public Todo saveOrUpdate(Todo todo)
  {
    return todoRepository.save(todo);
  }

  public void delete(int id)
  {
    todoRepository.deleteById(id);
  }

}

Rest API controller

The controller uses the service layer to provide the CRUD endpoints.

The source code of the controller is the following :

package com.javasneo.todolist.controller;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.model.TodoListResponse;
import com.javasneo.todolist.service.TodoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;


@RestController
@RequestMapping("/todos")
@CrossOrigin()
public class TodoController {

  @Autowired
  TodoService todoService;

  @RequestMapping(method = RequestMethod.GET)
  public TodoListResponse todos (){
    List<Todo> todoList = todoService.getAll();
    TodoListResponse todoListResponse = new TodoListResponse();
    todoListResponse.setTodos(todoList);
    return todoListResponse;
  }

  @RequestMapping(method = RequestMethod.POST)
  public Todo addtodo (@RequestBody Todo todo){
    return todoService.saveOrUpdate(todo);
  }

  @RequestMapping(method = RequestMethod.PUT)
  public Todo updateTodo (@RequestBody Todo todo){
    return todoService.saveOrUpdate(todo);
  }

  @RequestMapping(value="/{id}", method = RequestMethod.DELETE)
  public void deleteTodo (@PathVariable("id") int id){
    todoService.delete(id);
  }

}

Conclusion

this spring boot spring data jpa h2 database crud example tutorial arrives at its end.

If you want to know how to test the endpoints using Postman, please check the part 1 of these series of tutorials that deal with Spring Boot 2 RESTAPI.

In order to get our latest updates, please feel free to like our how toprogram facebook page.

The source code can be found in abderrahmen ben mariem github.

Spring Boot 2 REST API Example - JAVASNEO

noreply@blogger.com (Abderrahmen Ben Mariem) — Sun, 13 Dec 2020 09:59:00 +0000

spring boot rest api example tutorial presents a todo list rest api created using spring boot 2.

The api presents 4 endpoints :

GET api endpoint : returns all the tod list
POST api endpoint : creates a todo and ad dit to the todo list
PUT api endpoint : updates a todo
DELETE api endpoint : deletes a todo

In this spring boot rest api example, we don’t use a database. So, the todo list is stored in an arrayList in the controller that exposes the todo list REST API.

Spring Boot 2 REST API maven dependencies

In this project we use spring-boot-starter-web to expose the rest API and spring-boot-starter-test to make unit tests. In this spring boot rest api example, we don’t focus on unit testing because we will create a dedicated tutorial for unit testing a REST API.

The maven POM file is the following :

<?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.javasneo</groupId>

   <artifactId>todo-list</artifactId>

   <version>0.0.1-SNAPSHOT</version>

   <packaging>jar</packaging>

   <name>todo-list</name>

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

   <parent>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-parent</artifactId>

      <version>2.4.0</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-web</artifactId>

      </dependency>

      <dependency>

         <groupId>org.springframework.boot</groupId>

         <artifactId>spring-boot-starter-test</artifactId>

         <scope>test</scope>

      </dependency>

   </dependencies>

   <build>

      <plugins>

         <plugin>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-maven-plugin</artifactId>

         </plugin>

      </plugins>

   </build>

</project>

Spring Boot 2 REST API configuration
This class is a JAVA configuration class marked with the
annotation @Configuration. It enables Spring MVC and declares that our
endpoints supports all the hTTP methods (GET, POST, PUT, DELETE, PATCH).
The code of the configuration class is the following :

package com.javasneo.todolist.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class WebConfig {

  @Bean
  public WebMvcConfigurer corsConfigurer() {
    return new WebMvcConfigurerAdapter() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
          .allowedMethods("GET", "PUT", "POST", "DELETE", "PATCH");
      }
    };
  }
}

Spring Boot 2 REST API model

In this spring boot rest api example, we use two classes as our model :

The Todo class
The TodoListResponse class : it represent the response of Getting all the Todos endpoint

The source code of those classes is the following :

package com.javasneo.todolist.model;

public class Todo {

  private int id;
  private String name;
  private String description;

  public Todo() {
  }

  public Todo(int id, String name, String description) {
    this.id = id;
    this.name = name;
    this.description = description;
  }

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public void setName(String name) {
    this.name = name;
  }

  public void setDescription(String description) {
    this.description = description;
  }
}

TodoListResponse.java

package com.javasneo.todolist.model;

import java.util.ArrayList;

public class TodoListResponse {

  private ArrayList todos;

  public ArrayList getTodos() {
    return todos;
  }

  public void setTodos(ArrayList todos) {
    this.todos = todos;
  }
}

Spring Boot 2 REST API controller

This controller presents the four REST endpoints that we spoke about above.

The data in this REST API controller is stored in an ArrayList that we initialize in the controller ‘s constructor.

In order to make a controller as a REST controller, we annotate it using @RestController and in order to mark a method in the controller as a REST endpoint we annotate it using @RequestMapping annotation.

In the @RequestMapping annotation, we indicate the http method used by that endpoint.

In order to generate an id for a newly added Todo, the controller uses a static variable called id that it increments for the newly created Todo.

The source code of the REST controller is the following :

package com.javasneo.todolist.controller;

import com.javasneo.todolist.model.Todo;
import com.javasneo.todolist.model.TodoListResponse;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;

/**
 * Created by Abderrahmen on 31/01/2018.
 */
@RestController
@RequestMapping("/todos")
@CrossOrigin()
public class TodoController {

  ArrayList<todo> todos;

  static int id = 0;

  public TodoController(){
    this.todos = new ArrayList<>();
    this.todos.add(new Todo(id++,"my first todo","my first todo description"));
    this.todos.add(new Todo(id++, "my second todo","my second todo description"));
    this.todos.add(new Todo(id++, "my third todo","my third todo description"));

  }

  @RequestMapping(method = RequestMethod.GET)
  public TodoListResponse todos (){
    TodoListResponse todoListResponse = new TodoListResponse();
    todoListResponse.setTodos(this.todos);

    return todoListResponse;
  }

  @RequestMapping(method = RequestMethod.POST)
  public Todo addtodo (@RequestBody Todo todo){
    todo.setId(++id);
    this.todos.add(todo);
    return todo;
  }


  @RequestMapping(method = RequestMethod.PUT)
  public Todo updateTodo (@RequestBody Todo todo){

    for(int i =0; i < this.todos.size(); i++){

      if(this.todos.get(i).getId()  == todo.getId()){
        this.todos.get(i).setName(todo.getName());
        this.todos.get(i).setDescription(todo.getDescription());
        break;
      }
    }
    return todo;
  }

  @RequestMapping(value="/{id}", method = RequestMethod.DELETE)
  public void deleteTodo (@PathVariable("id") int id){

    for(int i =0; i < this.todos.size(); i++){

      if(this.todos.get(i).getId()  == id){
        this.todos.remove(i);
        break;
      }
    }
  }

}

Spring Boot 2 REST API main Class

The main class is the entry point of any Spring boot application. The code of that main class is very simple an is the following :

package com.javasneo.todolist;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TodoListApplication {

 public static void main(String[] args) {
  SpringApplication.run(TodoListApplication.class, args);
 }

}

Invoking Spring Boot 2 Rest API endpoints

In this section, we invoke all the REST API endpoints using Postman. You can install postman using this link. In order to use this section, you need to run the TodoListApplication class. Otherwise the REST endpoints will be down.

HTTP GET /todos

The Request is the following :

Here, we just add the url of our REST GET endpoint in Postman. The URL is the following : localhost:8080/todos

Initially, the endpoint returns the Todo list manually created in the controller. But, the list gets updated when we use the other REST endpoints.

HTTP POST /todos

Here, we add the following Todo object to the TodoList :

{
	"name": "added todo",
	"description": "added todo description"
}

The rest endpoint returns the newly added Todo in the response.

HTTP PUT /todos

Here, we update the which id is equal to zero. In fact, we replace the Todo object which id is equal to zero with another object and we keep the same id (zero).

If we want to implement the partial update of the object, we should use the PATCH http method.

So, here we replace the original object at index 0 with this object :

{
	"id":0,
	"name": "modified first todo",
	"description": "first todo description"
}

This REST endpoint returns the modified Todo object as shown in the image below:

HTTP DELETE /todo/{id}

This REST endpoint deletes the Todo object present at the id put in the URL.

To delete the Todo at the index 0, we invoke this url : localhost:8080/todos/0

You may guess the URL to invoke the delete the Todo at the index 1 : localhost:8080/todos/1

This endpoint returns a 200 OK response for the moment. But we can return a no content response instead if we want.

We just want to be as simple as possible because we will use this REST api to build a fullstack Angular application.

Conclusion :

This spring boot rest api example arrives at its end. The next step is to use a real database. As a first step, we will use an in memory database like H2. Then, we will move to using hibernate and a nosql database like MongoDB.

In the final step, we will build the frontend part of the app using Angular, react and Vue JS.

So, keep tuned and give as a like and share this tutorial to spread the knowledge.

We share our tutorial in our how to program Facebook page and the source code can be found at abderrahmen ben mariem Github.

You may also check our core java tutorial or the other spring boot 2 tutorials.

Best React Books in 2020 | Best Programming Books

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 05 Dec 2020 15:32:00 +0000

In this post, we will present an up to date list of best react books for learning React JS.

These best react books cover the latest features of react and are selected as the best sold books.

So, I advise you to check these react books in order to enhance your skills in react.

Learning React :

Modern Patterns for Developing React Apps

If you want to learn how to build efficient React applications, this is your book. Ideal for web developers and software engineers who understand how JavaScript, CSS, and HTML work in the browser, this updated edition provides best practices and patterns for writing modern React code. No prior knowledge of React or functional programming is necessary. Authors Alex Banks and Eve Porcello show you how to create UIs that can deftly display changes without page reloads on large-scale data-driven websites. You'll also discover how to work with functional programming and the latest ECMAScript features. Once you learn how to build React components with this hands-on guide, you'll understand just how useful React can be in your organization. Understand key functional programming concepts with JavaScript Look under the hood to learn how React runs in the browser Create application presentation layers with React components Manage data and reduce the time you spend debugging applications Explore React's component lifecycle to improve UI performance Use a routing solution for single-page application features Learn how to structure React applications with servers in mind.

Book Details

· Item Weight : 1.09 pounds

· Paperback : 310 pages

· ISBN-10 : 1492051721

· ISBN-13 : 978-1492051725

· Dimensions : 7.01 x 0.65 x 9.17 inches

· Publisher : O'Reilly Media; 2nd edition (June 30, 2020)

· Language: : English

About the Author

Alex Banks and Eve Porcello are software engineers, authors, and trainers. With their company Moon Highway, theyâ??ve taught JavaScript, Node, React, and GraphQL courses to engineers all over the world. They have also created videos and authored training content for OReilly, LinkedIn Learning, and egghead.io.

React Explained: Your Step-by-Step Guide
to React (2020 Edition)

In React Explained, readers will dig deep into how React works and will learn how to build applications with it. While the focus is on building for the frontend on the web, many of the skills you will learn will also apply to writing React on the server side, for native applications and even for Virtual Reality environments.

Book Details

Publication date : March 5, 2019
File size : 3658 KB
Word Wise : Not Enabled
Print length : 371 pages
Publisher : OS Training, LLC (March 5, 2019)
Language: : English
ASIN : B07PHQZJQ5

About the Author

Zac Gordon is a professional educator, who currently focuses on JavaScript development with and alongside WordPress at javascriptforwp.com. Zac has years of experience teaching at high schools, colleges, bootcamps and online learning sites like Treehouse, Udemy and Frontend Masters. In addition to teaching, Zac also runs Web Hosting for Students, one of the world’s largest hosting companies dedicated to students and teachers. You can also catch his free Office Yoga sessions on OfficeYoga.tv.

1. The Javascript You Should Know for React

2. Helpful Developer Tools for React

3. A High Level Overview of React

4. React Elements and Components Explained

5. 5 Exercises in Writing React With Elements and Components

6. JSX Explained

7. 5 Exercises in Writing React With JSX

8. Create React App Explained

9. 5 Exercises With Create React App

10. Props in React Explained

11. 5 Exercises in Working With Props

12. State in React Explained

13. 5 Exercises in Working With State

14. The Component Lifecycle Explained

15. 5 Exercises With the Component Lifecycle

16. Context Explained

17. React Hooks Explained

18. Exercises with Hooks

19. Project Introduction

20. Step 1 - Listing Content from State

21. Step 2 - Routing and Single Content Views

22. Step 3 - Adding a Content Form

23. Step 4 - Adding Flash Messages

24. Step 5 - Updating Content

25. Step 6 - Deleting Content

26. Step 7 - Maintaining Persistent State With Local Storage

27. Step 8 - Authenticating With a Firebase Database

28. Step 9 - CRUD and Live Syncing With Firebase

29. Step 10 - Deploying the Project

30. Step 11 - Refactoring Your Code

React and React Native: Acomplete hands-on guide to modern web and mobile development with React.js, 3rdEdition

This book is for any JavaScript developer who wants to start learning how to use Facebook's UI libraries, React and React Native, for mobile and web application development. Although no prior knowledge of React is needed, working knowledge of JavaScript programming will help you understand the concepts covered in the book more effectively.

Book Details

Item Weight : 1.97 pounds
Paperback : 526 pages
ISBN-10 : 1839211148
ISBN-13 : 978-1839211140
Dimensions : 7.5 x 1.19 x 9.25 inches
Publisher : Packt Publishing (April 30, 2020)
Language: : English

About the Author

Adam Boduch has been involved in large-scale JavaScript development for nearly 10 years. Before moving to the frontend, he worked on several large-scale cloud computing products using Python and Linux. No stranger to complexity, Adam has practical experience with real-world software systems and the scaling challenges they pose. He is the author of several JavaScript and React books and is passionate about innovative user experiences and high performance.

Roy Derks is a serial start-up CTO, conference speaker, and developer from Amsterdam. He has been actively programming since he was a teenager, starting as a self-taught programmer using online tutorials and books. At the age of 14, he founded his first start-up, a peer-to-peer platform where users could trade DVDs with other users for free. This marked the start of his career in web development, which back then primarily consisted of creating web applications using an MVC architecture with the LAMP stack.

In 2015, he was introduced to React and GraphQL at a hackathon in Berlin, and after winning a prize for his project, he started to use these technologies professionally. Over the next few years, he helped multiple start-ups create cross-platform applications using React and React Native, including a start-up that he co-founded. He also started giving workshops and talks at conferences around the globe. In 2019, he gave over 20 conference talks about React, React Native, and GraphQL, inspiring over 10,000 developers worldwide.

1. Why React?

2. Rendering with JSX

3. Component Properties, State, and Context

4. Getting Started with Hooks

5. Event Handling - The React Way

6. Crafting Reusable Components

7. The React Component Life Cycle

8. Validating Component Properties

9. Handling Navigation with Routes

10. Code Splitting Using Lazy Components and Suspense

11. Server-Side React Components

12. User Interface Framework Components

13. Why React Native?

14. Kick-Starting React Native Projects

15. Building Responsive Layouts with Flexbox

16. Navigating Between Screens

17. Rendering Item Lists

18. Showing Progress

19. Geolocation and Maps

20. Collecting User Input

21. Displaying Modal Screens

22. Responding to User Gestures

23. Controlling Image Display

24. Going Offline

25. Native UI Components Using NativeBase

26. Handling Application State

27. Why Apollo?

28. Building an Apollo React App

Learning React js: Learn React JS From Scratch with Hands-OnProjects , 2nd Edition

In this book, we take you on a fun, hands-on and pragmatic journey to master React from a web development point of view. You'll start building React apps within minutes. Every section is written in a bite-sized manner and straight to the point as I don’t want to waste your time (and most certainly mine) on the content you don't need. In the end, you will have what it takes to develop a real-life app.

Book Details

Publication date : October 2, 2020
File size : 450 KB
Print length : 115 pages
Word Wise : Not Enabled
Language: : English
ASIN : B08KNW41JB

Full-Stack React Projects: LearnMERN stack development by building modern web apps using MongoDB, Express,React, and Node.js, 2nd Edition

This is one of the most useful web development books for JavaScript developers who may have worked with React but have minimal experience in full-stack development with Node, Express, and MongoDB.

Book Details

Item Weight : 2.66 pounds
Paperback : 716 pages
ISBN-10 : 1839215410
ISBN-13 : 978-1839215414
Dimensions : 7.5 x 1.62 x 9.25 inches
Publisher : Packt Publishing (April 17, 2020)
Language: : English

About the Author

Shama Hoque has more than 9 years of experience as a software developer and mentor, with a Master’s in Software Engineering from Carnegie Mellon University.
From Java programming to full-stack development with JavaScript, the applications she has worked on include national Olympiad registration websites, universally accessible widgets, video conferencing apps, and medical 3D reconstruction software.
Currently, she makes web-based prototypes for R&D start-ups in California, while training aspiring software engineers and teaching web development to CS undergrads in Bangladesh.

1. Unleashing React Applications with MERN

2. Preparing the Development Environment

3. Building a Backend with MongoDB, Express, and Node

4. Adding a React Frontend to Complete MERN

5. Growing the Skeleton into a Social Media Application

6. Building a Web-Based Classroom Application

7. Exercising MERN Skills with an Online Marketplace

8. Extending the Marketplace for Orders and Payments

9. Adding Real-Time Bidding Capabilities to the Marketplace

10. Integrating Data Visualization with an Expense Tracking Application

11. Building a Media Streaming Application

12. Customizing the Media Player and Improving SEO

13. Developing a Web-Based VR Game

14. Making the VR Game Dynamic Using MERN

15. Following Best Practices and Developing MERN Further

Substring in java | java beginners tutorial

noreply@blogger.com (Abderrahmen Ben Mariem) — Fri, 04 Dec 2020 20:56:00 +0000

Substring in java

Substring is a method in the String class that allows to get a subset of a String.

Substring in java methods

There are two methods offered by the String class that return a substring :

public String substring(int startIndex)

this method returns a new string that starts from startIndex inclusive and finishes at the original string’s last index inclusive also (the last index of the original string is at the index originalString.length() -1 )

substring in java example 1

The substring example below displays the substring of the string « abderrahmen » beginning from the index 4 inclusive and finishing at the last index of that string (10 = 11-1)


public class substring {

  public static void main(String[] args){
    String myString = "abderrahmen";
    String substring = myString.substring(4);
    System.out.println(substring);

  }
}

The output of the codeabove is the following :

rrahmen

public String substring(int startIndex, int endIndex)

This method returns a new string beginning from a starting index and finishing at a final index. (the caracter at the final index is excluded from the resulting string )

Substring in java example 2

The substring example below displays the substring of the string « abderrahmen » beginning from the index zero and finishing at the index three (the caracter at the index 3 is excluded).

public class substring {

  public static void main(String[] args){
    String myString = "abderrahmen";
    String substring = myString.substring(0, 3);
    System.out.println(substring);

  }
}

The displayed string is the following :

abd

This core JAVA tutorial which deals with the substring method in java arrives at its end.

To check the other JAVA tutorials, please check our core java tutorial.

Please, don’t forget to follow us on Facebook to get our next JAVA core tutorial.

Type casting in java with example

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 27 Jun 2020 12:59:00 +0000

Type casting in java is used when assigning a value of type TypeA to a variable of type TypeB.

There are two types of casting in java:

Implicit casting
Explicit casting

If you don’t know how to use java variables, please check our corresponding java variables tutorial.

Each variable has a type in java.

Each data type has a size (number of bits used by that type).

byte < short < (char)< int < long < float < double

Each data type has a range of values that it can hold. This range of values is based on the size of the data type.

The byte, long, float and double are signed.

The char type is unsigned. We cannot assign a byte or a short to a char and vice versa.

Casting example in java

The size of byte data type is 8 bits.

The range of values that can be coded using 8 bits is the following: from 0 to 127.

We can imagine that each type is a bag. The bags are of different sizes.

The bag associated to the byte type is the smallest one.

The bag associated to the double type is the biggest one.

A bag can be either full or partially filled.

Casting in java: problem

Let’s imagine that we have a big bag and a small one.

The big bag is filled up with items.

What happens when we put the content of the big bag inside the small one?

The answer is that we cannot do that.

The same problem occurs when we try to assign a bigger type value to a smaller type variable.

int a = 100;
byte b = a;

Here we try to assign an int value (the content of the variable a) to a variable of type byte.

In this case, the java compiler will complain.

But, w said above that the byte type can hold the value 100.

Here, the java compiler complains because there is a chance that the variable a contains a value that cannot be held by a variable of byte type.

We can imagine here that the bag associated to the int type is partially filled. But, it can be totally filled in the future when our app runs.

So, we haven’t made a mistake.

Here where comes the necessity of casting.

In fact, we can use casting here to tell the compiler to trust us and not to complain.

The code becomes like this:

int a = 100;
byte b = (byte) a;

So, the casting in java is related to assignment.

It is done by putting the type of the variable on the left hand side of the assignment between parentheses.

This is the only way to do casting.

Implicit casting in java

This type of casting is performed automatically by the compiler.

The developer doesn’t do anything to make implicit casting.

This is an example of implicit casting:

char c = ‘a’;
int b = c;

In this case, the compiler converts the character ‘a’ into its ASCHI code.

Then, it assigns this ASCHI code to the variable b.

The implicit casting is performed when assigning a smaller data type value to a bigger data type variable.

This is called widening assignment or upcasting.

Here, we put the content of a small bag into a big bag. This operation can be done with no problem.

There is no loss of information when making this operation.

Explicit casting in java

This type of casting is performed by the developer.

The explicit casting is performed when assigning a bigger data type value to a smaller data type variable.

This is called narrowing assignment or downcasting.

If we don’t perform the explicit casting, we will get a compiler error.

Here, we put the content of a big bag into a small bag.

This operation is problematic because it may cause a loss of information when making.

This is why we have to perform the java cast in this situation.

Explicit casting example

This is the same example mentioned above:

int a = 100;
byte b = (byte) a;

Explicit casting problem

If we don’t use the explicit casting wisely, we may cause a loss of information:

int x = 128;
byte b = (byte) x;

b will get the value -127 which is incorrect. The maximum value that can be held by a byte is 128.

Not allowed casts in JAVA

int x = 20;
boolean b = (boolean) x;

We cannot cast a numerical type to a boolean type and vice versa.

int x = 20;
String s = (String) x; -> compiler error

We cannot cast a numeric type to a String type and vice versa.

The cast in JAVA has high precedence

byte b = (byte) 124 - 20;

The 124 is cast to a byte type then the 124 is promoted to int.

The whole expression in the right is of type int. We cannot assign an int to a byte without cast.

The solution is the following:

byte b = (byte) (124 - 20);

This java tutorial which deals with the java casting arrives at its end.

To check the other tutorials that deal with core java, please check our core java tutorial.
Please, don’t forget to follow us on our how to program Facebook page to get our next java tutorial.

Kubernetes deployment explained with examples

noreply@blogger.com (Abderrahmen Ben Mariem) — Sun, 21 Jun 2020 14:50:00 +0000

A kubernetes deployment is a kubernetes resource that manages a replicaset which in its turn manages a set of pods. Those pods contain running docker containers.

Kubernates deployment use cases:

upgrade the docker images seamlessly : if we upgrade them at once, we will have some downtime of the app. So we need to upgrade them one by one. This is called rolling update.
Rollback changes : if you make an upgrade to your app and you make some regression. You can rollback your modification seemlessly.

In production environment, we will not be creating a pod definition file or a replicaset definition file.

But, we will be creating directly a deployment definition file.

If you don't know what is a pod or a replicaset, please feel free to check the correspondant tutorials.

Kubernetes deployment desfinition file example:

The deployment definition file is similar to the replicaSet definition file except for the kind part which is equal to Deployment in the case of a deployment.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    tier: backend
spec:
  replicas: 4
  template:
    metadata:
      name: nginx-pod
      labels:
        tier: backend
    spec:
      containers:
        - name: nginx
          image: nginx
  selector:
    matchLabels:
      tier: backend

Here the deployment has as name nginx-deployment. It creates a replicaset that creates in its turn 4 pods (replicas = 4) based on the nginx image. The created pods have as label tier: backend and the deployment is configured to manage those pods: the selector is configured to manage the pods that have as label tier:backend.

Kubernetes Deployment : rollout and rollback

When a new deployment is created, a new rollout is created with version 1 (a rollout is the process of deployment of new containers).

When the container is upgraded, a new Rollout with new revision is created which is version 2.

This enables us to rollback to a previous version of the deployment if necessary.

You can see the status of the Rollout using this command :

kubectl rollout status deployment <deployment_name>

To see the revisions and the history of the rollout, we run :

kubectl rollout history deployment <deployment_name>

Kubernetes deployment strategies

There are two types of deployment strategies :

Destroy all the old containers which are running the old version of the app and deploying new ones running the new version of the app : this is called the recreate strategy and this is not the default strategy -> it incurs a down time of the app
Destroy the old containers one by one and create new container once an old container is destroyed : this strategy is called Rolling update and its is seamless because there is no down time of the app

In order to update a deployment, we make the necessary changes in the deployment description file (changing the container image version, changing the deployment name, etc). Then we run this command :

kubectl apply -f deployment-description-file.yml

Here, i will modify the deployment description file above in order to run nginx:1.19-alpine image instead of nginx:latest image. The deployment definition file becomes like this:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    tier: backend
spec:
  replicas: 4
  template:
    metadata:
      name: nginx-pod
      labels:
        tier: backend
    spec:
      containers:
        - name: nginx
          image: nginx:1.19-alpine
  selector:
    matchLabels:
      tier: backend

Here, i kept the same name of the deployment in order to update the present deployment.

Otherwise, a new deployment will be created.

When, we upgrade the application, a new replicaset is created and the pods of the old replicaset are destroyed one by one. Once an old pod is destroyed, a new one is created in the new replicaset.

We notice that the old replicaset has zero pods running and the new replicaset has four pods running.

In order to rollback our changes to the previous version, we run this command :

kubectl rollout undo deployment <deployment_name>

This command destroys the new pods in the new replicaset and creates a pods with the previous version of the app in the old replicaset. Once, a new po dis destroyed, an old pod is created in the old replicaset.

Here we arrived at the end of the kubernetes deployment tutorial.

In order to check our kubernetes tutorial, please like our howto program facebook page and subscribe to our newsletter to get our latest tutorials.

How to install minikube on ubuntu

noreply@blogger.com (Abderrahmen Ben Mariem) — Tue, 16 Jun 2020 18:17:00 +0000

Install minikube on ubuntu is very easy. We will walk through the necessary steps to install minikube on ubuntu from A to Z.

Install minikube on ubuntu step 1 :

we should update the system packages to the latest release.

To do that we run these two commands:

sudo apt-get update
sudo apt-get install apt-transport-https

Install minikube on ubuntu step 2 :

Now, we need to install virtualbox hypervisor. we will get a prompt telling us to accept the virtualbox license.

sudo apt install virtualbox virtualbox-ext-pack

Install minikube on ubuntu step 3:

Now, we download the minikube binary file and we copy it to to the /usr/local/bin directory.

In order to do that, we run the following commands in order:

wget https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube-linux-amd64
sudo mv minikube-linux-amd64 /usr/local/bin/minikube

We add executable right to the downloaded file:

Then we move the executable file to /usr/local/bin/ in order to be in the PATH.

Next, we check if minikube was installed with success :

Install minikube on ubuntu : Step 4

We need to install the Kubernetes command line tool (kubectl) in order to manage our cluster.

Here, the cluster is composed by a single node.

In order to do that, we run this command :

curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl

Next, we add the exécution permission to kubectl file using this command: chmod +x ./kubectl

Then, we move the kubectl file to the directory /usr/local/bin to be able to call it from any directory in the system.

sudo mv ./kubectl /usr/local/bin/kubectl

We check whether the installation of kubectl succeeded or not using the following command :

kubectl version

Install minikube on ubuntu : step 5

Now we will start minikube using this command :

minikube start

This will download the minikube iso file and launch the minikube virtual machine.

To stop a running kubernetes cluster, we run this command:

minikube stop

To delete a running kubernetes cluster, we run this command:

minikube delete

Install minikube on ubuntu : step 6

minikube has a web dashboard that allows to manage the minikube cluster from a web interface.

To get the url of this dashboard, we run this command :

minikube dashboard --url

This install kubernetes on ubuntu tutorial for beginners arrives at its end.

If you want to deep dive into kubernetes, you can check our kubernate cluster architecture tutorial, kubernetes pod tutorial or our kubernetes replicaset tutorial.

To check our other tutorials, you can like our how to program facebook page.

Kubernetes cluster architecture

noreply@blogger.com (Abderrahmen Ben Mariem) — Mon, 15 Jun 2020 21:05:00 +0000

Kubernetes cluster architecture : introduction

Kubernetes cluster architecture is a complex subject. Here we will try to clarify the concepts and make it easy to understand for beginners.

A node is a machine (virtual machine or a real machine)

If you have an application running in a single node and the node goes down, the application goes offline and this incurs a loss of money.

This is why we deploy our app in a cluster which is a set of nodes : if a node fails, the other nodes will execute the app and there will not be a service interrupt.

In kubernetes, there are master nodes and a set of worker nodes. A master node manages the worker nodes (it is responsible for the distribution of the traffic between the worker nodes, replaces a worker node which goes down, orchestrates the containers running inside the nodes, etc).

A masternode is a node that has kubernetes installed in it and it is configured as a masternode.

Roles of kubernetes components :

The Kubectl command line interface communicates with the api server.

etcd : is a key value store used to store the data needed to manage the cluster.

Scheduler: is responsible for distributing the containers across multiple nodes.

The controller: is responsible for adding containers and removing them.

Container runtime is the runtime necessary to run containers (docker)

Kubelet : is the agent running on each node in the cluster. It is responsible for monitoring the containers and checking if they are running as expected.

Masternode vs worker node

This diagram shows the components explained above and their distribution on nodes.

This differs depending on whether the node is a master node or a worker node.

This kubernetes architecture tutorial for beginners arrives at its end.

If you want to deep dive into kubernetes, you can check our kubernetes pod tutorial or our kubernetes replicaset tutorial.

To check our other tutorials, you can like our how to program facebook page.

Kubernetes Replicaset tutorial for beginners

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 13 Jun 2020 22:02:00 +0000

Kubernetes Replicaset : introduction

Kubernetes replicaset monitors a set of pods : if a pod crashes, the replicaset replaces it and guarantees that we have the required number of replicas (pods).

This is the pod definition file that we created in the kubernetes pod tutorial :

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    name: nginx
    tier: frontend
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
     - containerPort: 80

In order to create the replicaset definition file, we will reuse the pod definition file : we will use all the sections of the pod definition file except the apiVersion and the kind sections.

We paste the pod definition file in the template section of the replicaset definition file.

Also, we add two sections :

Replicas : the number of pods that the replicaset will manage
Selector : designs the pods that will be managed by the replicaset : those pods will have the label tier with the value frontend. If we check the pod definition part, we see that the pod has a label tier with the value frontend.

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  template:
    metadata:
      name: nginx
      labels:
        name: nginx
        tier: frontend
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
           - containerPort: 80
  replicas: 3
  selector:
    matchLabels:
     tier: frontend

Kubernetes replicaset creation

We create a replicaset based on the definition file using this command :

Kubectl create -f replicaset-definition-file.yaml

We check our replicaset using this command that lists the available replicasets :

kubectl get replicasets

Here we see that we have a unique replicaset which name is frontend.

The replicaset manages three pods. Those pods are in the ready state.

Scale Kubernetes pods

Now, we have 3 pods declared in the replicaset definition file.

We aim to scale up to have 6 pods. We can do it using three methods :

1) Method 1

Change the replicas in the replicaset definition file
Run kubectl replace -f replicaset-definition-file.yml

2) Method 2

Kubectl scale –replicas=6 -f replicaset-definition-file.yml

3) Method 3

Kubectl scale –replicas=6 replicaset frontend ( frontend : the name of replicaset in the replicaset definition file)

We will use the first method to scale our replicaset :

We check the number of pods created using the command kubectl get pods :

We notice that we have six kubernetes pods running.

If we delete a pod using the command : kubectl delete pod <pod_name>, we will notice that the replicaset will replace the deleted pod :

Delete kubernetes replicaset

We use the following command in order to delete a replicaset :

kubectl delete replicaset <replicaset-name>

When we delete a replicaset, the pods that it manages will be deleted as well.

If we check the presence of these pods, we will find nothing:

This kubernetes replicaset tutorial for beginners arrives at its end.

To check our other tutorials, you can like our how to program facebook page.

Kubernetes pod tutorial for beginners

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 13 Jun 2020 15:30:00 +0000

Kubernetes Pod creation

There are two ways of creating a Kubernetes pod.

Kubernetes pod creation way 1

kubectl run nginx --image=nginx : creates a deployment nginx which creates a pod from the image nginx

When we run the command kubectl get pods, we see our created pod. Its name is nginx-6b489d4b7-9qghk.

To display the informations of the created deployment, we run this command:kubectl get deployments. The result of executing this command is the following:

Kubernetes pod creation way2 : using pod definition file

Kubernetes pod definition file

The kubernetes pod definition file is composed from 3 parts :

apiVersion
kind
metadata
spec

Example of kubernetes pod definition file

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    name: nginx
    app: nginx-app
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
     - containerPort: 80

In the case of a pod, the kind section is always equal to Pod.

The labels part is used to distinguish the pods created by this definition file (it is used by replication set to monitor a subset of pods having a label)

The spec part contains the containers which will be created in the pod.

We notice that the containers section contains an array of objects : this means that we can run multiple containers in the same pod.

Her ewe specified a unique container created using the nginx image and running on the port 80.

In order to create the pod, we run this command :

kubectl create pod -f pod-definition-file.yml

This command creates only a pod resource based on the pod definition file described above.

It doesn't create any resource other than the pod.

Displaying informations about kubernetes pods:

kubectl describe pod <pod_name> : checks informations about a pod (image name, node name, how many containers are running on the pod, get the state of the container in the pod, etc)

Container image name: we find it in the containers section of the out put of the describe command

Here we figure out that there is one container running in the pod and the corresponding image is the nginx image.

kubectl get pods -o wide : displays on which node each kubernetes pod is running

Here the pod is running on the node vps-a45eb589.

This kubernetes pod tutorial for beginners arrives at its end.

To check our others tutorials, you can like our how to program facebook page.

public static void main string arguments | what is public static void main string arguments in java

noreply@blogger.com (Abderrahmen Ben Mariem) — Fri, 12 Jun 2020 16:57:00 +0000

public static void main string arguments introduction

public static void main string arguments method is the entry point to any java program.

Here, we speak about desktop applications. In the web context, there is a container that will manage the startup and the shutdown of a java application.

We will present a simple example that shows how to use the public static void main string args in java :

public class TestMain {

public static void main(String[] args) {

System.out.println("Hello JAVA from how-to-program-in-java.com");

}

The public static void main string args method must go inside a class. There are no standalone methods in java. Everything goes into java classes.

The class that contains the public static void main method is the principal class.

Here, our main class is called TestMain.

The main method is the method that gets executed when our program executes.

So, when we create classes and we don’t use them inside the main method, those classes aren’t actually used by our program: They are useless.

In fact, we use classes inside the main method by creating java objects based on those classes.

The program above prints in the console the message: Hello JAVA from how-to-program-in-java.com

public static void main string arguments explained

Now, we will explain the keywords present in the signature of the main method.

public : defines the visibility of the public static void main(String args) method. It means that this method can be accessed by any other class with no problem.

In fact, this method will not be accessed by others classes. It will be executed by the JVM when our program runs. But, keeping the public keyword is mandatory to let the JVM execute this method.

static: This keyword means that the main method belongs to the class itself and doesn’t belong to instances of this class. This keyword allows us to call a method without creating an instance of the class that contains this method.

In our case, the JVM will call this method without creating an instance of the class TestMain.

This will save a little bit of memory.

void: this keyword means that the public static void main method doesn’t return anything.

So, we don’t expect any returned value from the main method.

String [] args: this is a java array of strings. It can be used to pass arguments to the main method when executing it. The type of elements in the array is String because we can convert any type to a string.

Also, we can change the name of the array (args) with no problem. It is dealt with like any name of a formal argument of a regular method.

Running public static void main string args from the command line

public static void main string args running without command line parameters

Here we will run the program above from within the command line.

In order to follow the examples, you need to set the JAVA_HOME, classpath and add java to the path variable.

In order to set your environment, please feel free to check our tutorial: install the necessary tools

We should follow those steps:

1) We begin by saving the program above in a file called: TestMain.java.

Note that the name of the file must match the name of the public class contained in that file. Also, a source file in java contains no more than one public class.

2) we put this file in this path: C:\program1\TestMain.java

3) We open the command line (cmd) and we type those commands

4) cd C:\program1

5) javac TestMain.java

6) java -classpath . TestMain

The output of the program is the following:

In step 5, we compiled the class TestMain. After launching this command, we notice that we have an extra file in the C:\program1 directory.

This file contains the byte code generated after compiling the class TestMain.

In step 6, the java command invokes the JVM. The latter will run the compiled version of the class TestMain.

public static void main string arguments running with command line parameters

This is our java program:

public class TestMainWithArguments {

public static void main(String[] args) {

for(int i = 0; i< args.length; i++){

System.out.println("Hello "+ args[i]);

}

In this section, we just repeat the same steps until step 6.

In fact, we just replace TestMain with TestMainWithArguments.

In step 6, we will run this command: java -classpath . TestMainWithArguments john peter

Here, we passed two parameters to our public static void main string args method: john and peter.

The arguments are separated by a space.

The output of this program is the following:

This tutorial that explains what is public static void main string arguments arrives at its end.

Please don’t forget to subscribe to like our Program In JAVA Facebook page or to subscribe to our newsletter to get our latest JAVA tutorials.

To check our core java tutorial, please check this link.

See you in the next core java tutorial.

Spring boot batch quartz scheduler example

noreply@blogger.com (Abderrahmen Ben Mariem) — Mon, 08 Jun 2020 17:11:00 +0000

This Spring boot batch quartz scheduler example tutorial presents step by step how to integrate Spring Boot 2, Spring Batch and Quartz using H2 database.

Spring Boot Spring Batch Quartz Scheduler Integration example

In fact, we will create an application which reads data from a database table (CUSTOMER_INPUT) and writes this data in another table CUSTOMER_OUTPUT.

The two tables have the same columns.

ID : primary key
Firstname : String
Lastname : String

The project overview is the following:

Spring batch is used to read data from the table CUSTOMER_INPUT and store it in the table CUSTOMER_OUTPUT.

So, in spring batch we have a custom reader that reads data from CUSTOMER_INPUT using pagination and a custom writer that writes data into CUSTOMER_OUTPUT.

Here, we have no processor.

The code of the domain objects is the following :

CustomerInput.java

package io.spring.batch.domain;

import javax.persistence.*;

public class CustomerInput {

  @Id
  private long id;

  private String firstName;

  private String lastName;

  public CustomerInput() {
  }

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public CustomerInput(long id, String firstName, String lastName) {
    this.id = id;
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return "CustomerInput{" +
      "id=" + id +
      ", firstName='" + firstName + '\'' +
      ", lastName='" + lastName + '\'' +
      '}';
  }
}

CustomerOutput.java

package io.spring.batch.domain;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

public class CustomerOutput {
  @Id
  private long id;

  private String firstName;

  private String lastName;

  public CustomerOutput() {
  }

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public CustomerOutput(long id, String firstName, String lastName) {
    this.id = id;
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return "CustomerOutput{" +
      "id=" + id +
      ", firstName='" + firstName + '\'' +
      ", lastName='" + lastName + '\'' +
      '}';
  }
}

The row mapper that maps every row in the CUSTOMER_INPUT table to a CustomerInput object.

CustomerRowMapper.java

package io.spring.batch.domain;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;


public class CustomerRowMapper implements RowMapper {
  @Override
  public CustomerInput mapRow(ResultSet resultSet, int i) throws SQLException {
    return new CustomerInput(resultSet.getLong("ID"),
      resultSet.getString("FIRSTNAME"),
      resultSet.getString("LASTNAME"));
  }
}

The configuration of Spring batch is in the JobConfiguration class :

JobConfiguration.java

package io.spring.batch.configuration;

import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import io.spring.batch.domain.CustomerInput;
import io.spring.batch.domain.CustomerOutput;
import io.spring.batch.domain.CustomerRowMapper;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.database.JdbcPagingItemReader;
import org.springframework.batch.item.database.Order;
import org.springframework.batch.item.database.support.MySqlPagingQueryProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author Michael Minella
 */
@Configuration
public class JobConfiguration {

  @Autowired
  public JobBuilderFactory jobBuilderFactory;

  @Autowired
  public StepBuilderFactory stepBuilderFactory;

  @Autowired
  public DataSource dataSource;

  @Bean
  public JdbcPagingItemReader pagingItemReader() {
    JdbcPagingItemReader reader = new JdbcPagingItemReader<>();

    reader.setDataSource(this.dataSource);
    reader.setFetchSize(10);
    reader.setRowMapper(new CustomerRowMapper());

    MySqlPagingQueryProvider queryProvider = new MySqlPagingQueryProvider();
    queryProvider.setSelectClause("ID, FIRSTNAME, LASTNAME");
    queryProvider.setFromClause("from CUSTOMER_INPUT");

    Map sortKeys = new HashMap<>(1);

    sortKeys.put("ID", Order.ASCENDING);

    queryProvider.setSortKeys(sortKeys);

    reader.setQueryProvider(queryProvider);

    return reader;
  }

  @Bean
  public JdbcBatchItemWriter customerItemWriter() {
    JdbcBatchItemWriter itemWriter = new JdbcBatchItemWriter<>();

    itemWriter.setDataSource(this.dataSource);
    itemWriter.setSql("INSERT INTO CUSTOMER_OUTPUT(FIRSTNAME,LASTNAME) VALUES (:firstName, :lastName)");
    itemWriter.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider());
    itemWriter.afterPropertiesSet();
    return itemWriter;
  }

  @Bean
  public Step step1() {
    return stepBuilderFactory.get("step1")
      .chunk(10)
      .reader(pagingItemReader())
      .writer(customerItemWriter())
      .build();
  }

  @Bean
  public Job job() {
    return jobBuilderFactory.get("job")
      .start(step1())
      .build();
  }
}

Here, the job Spring batch is composed by a single step that reads the data from CUSTOMER_INPUT and writes it in CUSTOMER_OUTPUT.

The custom Quartz job is the following :

QuartzJobLauncher.java

package io.spring.batch.quartz;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.JobParametersInvalidException;
import org.springframework.batch.core.configuration.JobLocator;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.NoSuchJobException;
import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
import org.springframework.batch.core.repository.JobRestartException;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class QuartzJobLauncher extends QuartzJobBean {

  private String jobName;
  private JobLauncher jobLauncher;
  private JobLocator jobLocator;

  public String getJobName() {
    return jobName;
  }

  public void setJobName(String jobName) {
    this.jobName = jobName;
  }

  public JobLauncher getJobLauncher() {
    return jobLauncher;
  }

  public void setJobLauncher(JobLauncher jobLauncher) {
    this.jobLauncher = jobLauncher;
  }

  public JobLocator getJobLocator() {
    return jobLocator;
  }

  public void setJobLocator(JobLocator jobLocator) {
    this.jobLocator = jobLocator;
  }

  @Override
  protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
    JobParameters jobParameters = new JobParametersBuilder().addLong("time", System.currentTimeMillis()).toJobParameters();

    try
    {
      ApplicationContext applicationContext = (ApplicationContext) context.getScheduler().getContext().get("applicationContext");
      jobLocator = (JobLocator) applicationContext.getBean(JobLocator.class);
      jobLauncher = (JobLauncher) applicationContext.getBean(JobLauncher.class);
      Job job = jobLocator.getJob(jobName);
      JobParameters params = new JobParametersBuilder()
        .addString("JobID", String.valueOf(System.currentTimeMillis()))
        .toJobParameters();

      jobLauncher.run(job, params);
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }
}

The Quartz configuration is presented in the following file :

QuartzConfig.java

package io.spring.batch.configuration;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import io.spring.batch.quartz.QuartzJobLauncher;
import org.quartz.*;
import org.springframework.batch.core.configuration.JobLocator;
import org.springframework.batch.core.configuration.JobRegistry;
import org.springframework.batch.core.configuration.support.JobRegistryBeanPostProcessor;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import static org.quartz.CronScheduleBuilder.cronSchedule;

@Configuration
public class QuartzConfig {

  @Autowired
  private JobLauncher jobLauncher;

  @Autowired
  private JobLocator jobLocator;

  @Value("${cronExpression}")
  private String cronExpression;

  @Bean
  public JobRegistryBeanPostProcessor jobRegistryBeanPostProcessor(JobRegistry jobRegistry) {
    JobRegistryBeanPostProcessor jobRegistryBeanPostProcessor = new JobRegistryBeanPostProcessor();
    jobRegistryBeanPostProcessor.setJobRegistry(jobRegistry);

    return jobRegistryBeanPostProcessor;
  }

  @Bean
  public JobDetail jobDetail() {
    //Set Job data map
    JobDataMap jobDataMap = new JobDataMap();
    jobDataMap.put("jobName", "job");

    return JobBuilder.newJob(QuartzJobLauncher.class)
      .withIdentity("job",null)
      .setJobData(jobDataMap)
      .storeDurably()
      .build();
  }

  @Bean
  public Trigger jobTrigger()
  {
    return TriggerBuilder
      .newTrigger()
      .forJob(jobDetail())
      .withIdentity("jobTrigger",null)
      .withSchedule(cronSchedule(cronExpression))
      .build();
  }

  @Bean
  public SchedulerFactoryBean schedulerFactoryBean() throws IOException, SchedulerException
  {
    SchedulerFactoryBean scheduler = new SchedulerFactoryBean();
    scheduler.setTriggers(jobTrigger());
    scheduler.setQuartzProperties(quartzProperties());
    scheduler.setJobDetails(jobDetail());
    scheduler.setApplicationContextSchedulerContextKey("applicationContext");
    return scheduler;
  }

  public Properties quartzProperties() throws IOException
  {
    PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
    propertiesFactoryBean.setLocation(new ClassPathResource("/application.properties"));
    propertiesFactoryBean.afterPropertiesSet();
    return propertiesFactoryBean.getObject();
  }
}

The main class is the SpringQuartzIntegration class. It is the entry point to the app.

SpringQuartzIntegration.java

package io.spring.batch;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;

/**
 * Created by Abderrahmen on 08/06/2020.
 */
@SpringBootApplication
@EnableBatchProcessing(modular = false)
@EntityScan("io.spring.batch.domain")
public class SpringQuartzIntegration {
  public static void main(String[] args) {
    SpringApplication.run(SpringQuartzIntegration.class, args);
  }
}

The application.properties file is the following :

application.properties

spring.datasource.url=jdbc:h2:file:~/spring-boot-h2-db;DATABASE_TO_UPPER=false
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=ha
spring.datasource.password=ha
spring.h2.console.enabled=true
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
#spring.batch.job.enabled =false
spring.h2.console.path=/h2
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

spring.application.name=batch purge
logging.level.org.springframework.cloud.task=DEBUG

scheduler.enabled=true
cronExpression=*/10 * * * * ? *

# Spring Batch properties
spring.batch.job.enabled=false

#Quartz
#Quartz persistent jobStore config
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix=QRTZ_   
org.quartz.jobStore.dataSource=myDS
#org.quartz.jobStore.useProperties=false
org.quartz.jobStore.isClustered=false

#Quartz dataSource
org.quartz.dataSource.myDS.driver=org.h2.Driver
#org.quartz.dataSource.myDS.URL=jdbc:h2:file:~/h2/testdb;INIT=RUNSCRIPT FROM 'classpath:schema-quartz.sql'
#org.quartz.dataSource.myDS.URL=jdbc:h2:file:~/spring-boot-h2-db;DB_CLOSE_ON_EXIT=FALSE;MODE=PostgreSQL
org.quartz.dataSource.myDS.URL=jdbc:h2:file:~/h2/testdb;INIT=RUNSCRIPT FROM 'classpath:schema-quartz.sql'
org.quartz.dataSource.myDS.user=ha
org.quartz.dataSource.myDS.password =ha
org.quartz.dataSource.myDS.maxConnections=5
org.quartz.dataSource.myDS.validationQuery=select 1
spring.quartz.jdbc.comment-prefix=#
#spring.quartz.jdbc.initialize-schema = never
spring.quartz.job-store-type= jdbc
org.quartz.jobStore.useProperties= false

Here the metadata tables of Spring batch are stored in a H2 database presented by the file spring-boot-h2-db

While the metadata of Quartz are written in another H2 database stored in the file testdb.

The file data.sql is used to insert data in the CUSTOMER_INPUT table when the app starts :

data.sql

INSERT INTO CUSTOMER_INPUT (FIRSTNAME,LASTNAME) VALUES ('Reed','Edwards');

The file schema.sql contain the creation script of the CUSTOMER_INPUT and the CUSTOMER_OUTPUT tables.

Schema.sql

DROP TABLE IF EXISTS CUSTOMER_INPUT;
DROP TABLE IF EXISTS CUSTOMER_OUTPUT;

CREATE TABLE CUSTOMER_INPUT (
  ID INTEGER NOT NULL auto_increment,
  FIRSTNAME CHARACTER(255) default NULL,
  LASTNAME CHARACTER(255) default NULL,
  PRIMARY KEY (ID)
);

CREATE TABLE CUSTOMER_OUTPUT (
  ID INTEGER NOT NULL auto_increment,
  FIRSTNAME CHARACTER(255) default NULL,
  LASTNAME CHARACTER(255) default NULL,
  PRIMARY KEY (ID)
);

The file schema-quartz.sql contain the creation script of the metadata tables of Quartz

schema-quartz.sql

The pom.xml is the following :

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>io.spring.batch</groupId>

    <artifactId>batch-integration</artifactId>

    <packaging>jar</packaging>

    <version>2.3.0-SNAPSHOT</version>

    <description>Batch Integration</description>

    <name>Batch Quartz integration</name>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.3.0.RELEASE</version>

        <relativePath/>

    </parent>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-batch</artifactId>

        </dependency>

        <dependency>

            <groupId>com.h2database</groupId>

            <artifactId>h2</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>com.mchange</groupId>

            <artifactId>c3p0</artifactId>

            <version>0.9.5.2</version>

        </dependency>

    </dependencies>



    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

Here we arrived at the end of the spring boot 2, Spring batch and Quartz integration tutorial.

In order to check our core java tutorial, please like our howto program facebook page and subscribe to our newsletter to get our latest tutorials.

To download the project of this tutorial, please check my Github.

what is java interface tutorial

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 15:38:00 +0000

Java interface introduction

JAVA interface is an important concept in the java programming language.

This java interface tutorial will dive in depth into this concept and explain it with many examples.

In a previous tutorial, we learned what is an abstract class in java.

A java interface is like an abstract class that has only:

final attributes (constant)
no full implemented methods (only abstract methods)

In fact, an interface in java has only:

final attributes
abstract methods

In addition, an interface may inherit from many java interfaces unlike classes that have to inherit from a unique parent class.

In java, multiple inheritances in the context of classes is not allowed while it is allowed for interfaces.

If you don’t know what the concept of inheritance is, please feel free to check our java inheritance tutorial.

Also, a class can implement many interfaces with no problem.

JAVA interface definition (h2)

The syntax of a java interface is the following:

interface I {

//final attributes

final int a =100;

final static int b = 300;

//abstract methods

public abstract int f(float p);

}

The only visibilities that can be applied to an interface are public or nothing (package visibility).

This is the same rule applied for java classes.

By default, the methods declared in an interface are public and abstract.

So, we can omit to mention the keywords public and abstract in the signatures of the interface ‘s methods.

But, we recommend mentioning these two keywords in the signature of the methods because it is a best practice.

JAVA interface implemented by a class (h2)

When defining a class, we can mention that it implements an interface using this syntax:

class A implements I {

// The class A must implement all the methods of the interface I

}

The class A must implement all the methods of the interface I.

Otherwise, we will get a compiler error.

In conclusion, when a class implements an interface, we are sure that it implements all the methods present in that interface.

So, the java interface is like a contract that the class will respect.

In the following, we will present a class that implements two interfaces. It may implement more than two interfaces. But in our case we will take the example of two interfaces.

This is the second interface:

interface J {

//abstract methods

public abstract float g();

}

This is the class B that implements the interfaces I and J:

class B implements I, J {

// The class A must implement all the methods of the interfaces I and J

}

Here, the class B implements two interfaces (I and J) separated by comma.

It must implement all the methods of the interfaces I and J.

If a class implements an interface, it can access any constant defined by this interface.

If the constant defined in an interface is static, it can be accessed directly using the name of the interface.

So, the constant b defined in the interface I can be accessed like this: I.b

JAVA interface implemented by a class (h2)

If you are not familiar with polymorphism, you can check our java polymorphism tutorial.

In context of inheritance, we can declare a variable of a parent type.

Then, we can assign to it an object of a child type.

We can do something like that using an interface in java:

I a;

We can declare a variable whose type is an interface.

Also, we can assign any class that implements the interface I to the variable a.

So, we can assign an object of type A to the variable a:

a = new A();

In fact, we can even assign a java anonymous class to the variable a.

The inheritance between java interfaces (h2)

An interface can inherit from many interfaces unlike the classes.

So, multiple inheritance between interfaces is allowed in java.

An interface that inherits from two other interfaces I and J contains all the declarations of all the methods of I an J.

Java interface inheritance is a simple grouping of method declarations.

interface K extends I, J {

//contains the declaration of all the methods of both I an J

}

JAVA interfaces and naming conflicts (h2)

Let’s consider the following example.

This is the first interface:

interface P {

public abstract int l(int a);

public abstract void q();

}

This is the second interface:

interface M {

//abstract methods

public abstract int l(float a);

public abstract void q();

}

Let’s consider the T class that implements the two interfaces P and M:

class T implements P, M {

}

In this case, the class T must implement these methods:

The method l of the interface P
The method l of the interface Q
The method q (because it has the same signature in the two interfaces)

The method l is implemented in the class T two times because the two signatures of this method in the two interfaces respect java method overloading rules.

JAVA interfaces and default method implementation in JAVA 8 (h2)

JAVA 8 allows to an interface to give a default implementation for a method.

The syntax is the following:

interface D {

default int f(){

//default implementation of the interface

}

Here, a class that implements the D interface may or may not give an implementation of the method f(). In the second case, it will use the default implementation offered by the interface D.

Java interface: conclusion (h2)

This java interface tutorial arrives at its end.

We have explained the interface concept with many examples.

If this java tutorial was helpful for you, please check our core java tutorial.

You can like our how to program facebook page for more tutorials or follow our how to program Google plus page.

What is JAVA abstract Class

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 15:31:00 +0000

Java abstract class introduction

Java abstract class is a class that cannot be instantiated.

We may say that this type of java class is useless because we cannot create instances from a java abstract class.

But, the concept of abstract class is very useful in object oriented programming.

We covered also other OOP concepts like the encapsulation,the polymorphism and the abstraction.

An abstract class is manned to be a parent class. It is created to be used for inheritance as a base class.

An abstract class is declared like this:

Abstract class A {}

This type of classes may have methods and attributes that are inherited by child classes:

Abstract class A {
type1 attr1;
type2 attr2;
public type3 f(){
}
public abstract Type1 g();
}

A java abstract class can have fully implemented methods or methods that have no implementations.

A method declared with its signature and have no implementation is called an abstract method.

In the example above, the method g() is an abstract method.

It has the abstract keyword in its signature.

The method f() is not an abstract method because we opened and closed the curl braces even if its implementation is empty.

We can declare a variable of type A but we cannot instantiate an object of type A.

A variable1; //OK

But, we cannot create an object of type A.

A variable2 = new A(); //compiler error

Let’s define a child class B that inherits from class A and implements the abstract method g():

class B extends A {
public Type1 g(){
}
}

In the class B, the method g() inherited from class A is no longer abstract. So, the class B hasn’t any abstract methods.

Therefore, it is not abstract and we can instantiate it.

This line of code is correct:

B variable3 = new B ();

Or using the polymorphism principle, we can do like this:

A variable4 = new B (); //OK

Java abstract class characteristics

1) A java class is abstract if it contains one or many abstract methods. The abstract keyword in the class declaration is not mandatory.

class A {
public abstract Type1 g();
}

2) An abstract method must be public

3) In an abstract method, the names of formal arguments of the method are mandatory.

class A {
public abstract Type1 g(int); //compiler error
}

4) A child class that inherits from an abstract class must define all the abstract methods of its parent class in order to be not abstract.

5) If a child class that inherits from an abstract class doesn’t implement one abstract method, it is abstract and it cannot be instanciated.

6) Abstract classes cannot have abstract constructors

Java abstract class use cases

Abstract class in java is important in the Object oriented design.

We can use it like this:

We put the common state of child classes inside the parent abstract class
Implement the methods that have the same implementation for all child classes
Keep the methods that are specific to each child class as abstracts. In this way, the child class is responsible for providing its own implementation for its parent‘s abstract methods. Otherwise, it will be abstract. It will override its parent class‘s abstract classes.

Java abstract class example

In this example, we will create an abstract class called Shape that has two child classes.

Those child classes are: Circle and Square.

The code of the abstract class Shape is the following:

public abstract class Shape {
 
       protected String name;
       
       public Shape() {
             this.name ="shape";
       }
             
       public Shape(String name) {
             this.name = name;
       }
 
       public String getName() {
             return name;
       }
 
       public void setName(String name) {
             this.name = name;
       }
 
 
       protected void display(){
             System.out.println("My name is "+ name);
       }
       
       public abstract double area();
}

The source code of the Square class is the following:

public class Square extends Shape{
 
       private double side;
             
       public Square() {
             super("square");
             this.side = 0;
       }
       
       public Square(double side, String name) {
             super(name);
             this.side = side;
       }
       
       @Override
       public double area() {
             return side * side;
       }
 
       public double getSide() {
             return side;
       }
 
       public void setSide(double side) {
             this.side = side;
       }
 
}

The code of the circle class is the following:

public class Circle extends Shape {
 
       private double radius;
       
       
       public Circle() {
             super("circle");
             this.radius = 0;
       }
       
       public Circle(double radius, String name) {
             super(name);
             this.radius = radius;
       }
       
       @Override
       public double area(){
             
             return 3.14 * radius * radius;         
       }
       
       
       public double getRadius() {
             return radius;
       }
 
       public void setRadius(float radius) {
             this.radius = radius;
       }
 
}

The Shape abstract class defines:

A common attribute for all its child classes: the name attribute

A common method for all its child classes: the radius method

Then, each one from the child classes will give its own implementation to the area method.

Also, the display method is defined once in the parent class and is reused by its child classes.

This is what we call code reuse.

This is an important concept in Object oriented design that is offered by inheritance.

This is the code of the main class that puts everything in action:

public class
TestShapes {
public static void main(String[] args) {
Shape sq = new Square(1.5,"sq");
System.out.println("The area of sq = "+ sq.area());
sq.display();
Shape cir = new Circle(2.3, "cir");
System.out.println("The area of cir = "+ cir.area());
cir.display();
Square sq1 = new Square(6.7,"sq1");

System.out.println("The area of sq1 = "+ sq1.area());

sq1.display();
             
Shape cir1 = new Circle(7.5, "cir1");
System.out.println("The area of cir1 = "+ cir1.area());
cir1.display();
}
}

Java abstract class : conclusion

This java abstract class tutorial arrives at its end.

We have explained the abstract class concept with many examples.

If this java tutorial was helpful for you, please check our core java tutorial.

You can like our how to program facebook page for more tutorials or follow our how to program Google plus page.

inheritance in java tutorial for beginners

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 14:24:00 +0000

Inheritance in java: introduction

The term inheritance in nature refers us to the inheritance between humans or between animals.

In the object oriented development, we borrowed this concept from the nature to enhance the quality of our code.

In fact, through the inheritance, we avoid code duplication and we increase the maintainability of our applications:

We define common behavior once in the parent class and all the child classes get this behavior automatically without having to copy/paste the code that implements this behavior.
This increases the readability and the maintainability of the code:

· The number of code lines is minimal

· Maintainability: the bugs are localized in the same class. So we correct the bug once inside one class and this correction is spread to the child classes.

The child classes can have, in addition to the behavior defined in the parent class, their own behavior.

The child classes do what does the parent class and do other things that their parent can't do.

In fact, this is taken from the nature were animals’s children are better than their parents.

Let's take the example of gazelle:

A gazelle with low speed will be caught by a carnivorous and will not survive.

A couple of gazelles with high speed will survive and get children which are better than their parents in term of speed.

These gazelle’s children inherit chromosomes from their parents that make them better than their parents in term of speed.

This is called natural selection.

Inheritance in java example: the extends keyword

We will present a class Doctor that is a child of the class Employee.

The class Employee is the following:

package sandbox;
public class Employee {
String firstName;

String lastName;
int age;

public void introduceYourself(){

 System.out.println("I am an employee");
            }
}

The class Employee has three attributes which have the default visibility (the package visibility).

To learn what is a package and why we use package, please check the package tutorial.

To learn about the access modifiers, please check the access modifiers tutorial.

We will deal about the visibility problem when dealing with the inheritance in a next section.

The class employee is called the super class or the parent class or the base class of the Doctor class.

The Doctor class is called the child class or the subclass or the derived class of the Doctor class.

The code of the Doctor class is the following:

package sandbox;
public class Doctor extends Employee {
}

The extends keyword says that the Doctor class inherits from the Employee class.

We have defined neither attributes nor methods inside the Doctor class.

But, the Doctor class has the stuff defined in its superclass (the default visibility allows the inheritance because the two classes are inside the sandbox package):

It has the three attributes of the super class (firstName, lastName and age)
It has the introduceYourself() method (a public method is inherited)

Here, we are reusing the code defined in the super class (Employee).

Inheritance in java and the access modifiers

The private attributes and methods defined in the super class are not inherited.

The public and protected attributes and methods defined in the super class are inherited.

Inheritance in Java and the super keyword

We can access an attribute or a method of the super class using the super keyword.

We can do it if the access modifier allows it.

These examples show some uses of the super keyword.

super(): calls the default constructor of the parent class

super(String, String, int) : calls the constructor of the super class that takes two Strings and an integer

super.age : accesses the age attribute of the parent class

super.introduceYourself() : calls the introduceYourself() method of the parent class

Inheritance in Java and constructors:

To learn what a constructor is, please check the constructor tutorial.

The child classes inherit the default constructor.

But, they don’t inherit the overloaded constructors.

In order to learn about overloading methods inside a class, please check the method overloading tutorial.

Inheritance in Java and the default constructor: example

package sandbox;

public class Employee {

String firstName;

String lastName;

int age;

public Employee() {

System.out.println("The Employee class default constructor is called");

}

public void introduceYourself(){

System.out.println("I am an employee");

}

The code of the Doctor class is the following:

package
sandbox;
public class Doctor extends Employee {
public Doctor(){
System.out.println("TheDoctor class default constructor is called");

}
}

The main class is the following:

package
sandbox;
public
class TestInheritance {

public static void main(String[] args) {
Doctor d = new Doctor();
}
}

The output of this example is the following:

The Employee class default constructor is called

The Doctor class default constructor is called

This example shows that the default constructor of the parent class is called automatically without calling it explicitly in the default constructor of the child class.

This is not true for an overloaded constructor.

Inheritance in Java and the overloaded constructors: example

An overloaded constructor of a super class is not called automatically in the correspondent overloaded constructor of a child class.

Inheritance in Java example: an overloaded constructor of the parent class is not called automatically

The code of the Employee class is the following:

package
sandbox;
public
class Employee {
String firstName;
String lastName;
int age;                       
public Employee() {
System.out.println("The Employee class default constructor is called");
}  
public Employee(String firstName, String lastName, int age) {
System.out.println("The Employee class's overloaded constructor is called");
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
public void introduceYourself(){
System.out.println("I am an employee");
}          
}

The code of the Doctor class is the following:

package sandbox;
public class Doctor extends Employee {
public Doctor(){
System.out.println("The Doctor class default constructor is called");
}
public Doctor(String firstName,
String lastName, int age) {                       
System.out.println("The Doctor class's overloaded constructor is called");

}          
}

The main class is the following:

package sandbox;
public class TestInheritance {

public static void main(String[] args) {
Doctor d = new Doctor("Mary","James",32);
}
}

The output of this program is the following:

The Employee class default constructor is called

The Doctor class's overloaded constructor is called

This example shows that the default constructor is called automatically (implicitly) in the default and the overloaded constructors of child classes.

The overloaded constructor of the Employee super class isn’t called implicitly in the correspondent overloaded constructor of the child class.

Inheritance in Java example: calling an overloaded constructor of the parent class in the child class

We can call an overloaded constructor of the parent class explicitly in the child class.

This can be done using the super keyword.

The
example below shows this:
package
sandbox;
public
class Employee {
String firstName;
String lastName;
int age;

public Employee() {
System.out.println("The Employee class default constructor is called");
}
public Employee(String firstName, String lastName, int age) {
System.out.println("The Employee class's overloaded constructor is called");
this.firstName = firstName;
this.lastName = lastName;

this.age = age;

}
public void introduceYourself(){
System.out.println("I am an employee");
}          
}

The code of the Doctor class is the following:

package
sandbox;
public
class Doctor extends Employee {
public Doctor(){
System.out.println("The Doctor class default constructor is called");
}
public Doctor(String firstName, String lastName, int age) {                       
super(firstName, lastName, age);
System.out.println("The Doctor class's overloaded constructor is called");
}                      
}

The code of the main class is the following:

package sandbox;

public class TestInheritance {
public static void main(String[] args) {        
Doctor d = new Doctor("Mary","James",32);
}
}

The output of the program is:

The Employee class's overloaded constructor is called

The Doctor class's overloaded constructor is called

In the Doctor class, the overloaded constructor of the super class is called using the super keyword.

In this case, the default constructor isn’t called.

Inheritance In Java and multiple inheritance

Java doesn’t allow the multiple inheritances unlike other programming languages like the C++.

This means that a java class cannot inherit from more than one class.

This tutorial whose title is inheritance in java arrives at its end. You can also check the oracle inheritance in java tutorial.

Please don’t forget to subscribe to like our How to Program Facebook page or to subscribe to our newsletter to get our latest JAVA tutorials.

To check our core java tutorial, please check this link.

See you in the next core java tutorial.

Core java interview questions and answers

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 13:36:00 +0000

Core java interview questions and answers asked by the top recruiters in the world. These core java interview questions and answers aim to prepare you to pass any interview that deals with core java.

Those top 55 Core java interview questions are selected over the years by recruiters to test the knowledge of the candidate in java.

We have also a core java tutorial that you can check in order to learn the basics of the java language.

1) What is JVM?

JVM stands for Java Virtual Machine. It simulates a real computer and provides the runtime environment for running java applications.

In the first step, the java source code is converted to a byte code (binary code that can be understood by the JVM : instruction set of the JVM) by the java compiler (javac).

This byte code is converted by the JVM into a machine code (binary). Then, the machine code is run by the computer that has the JRE installed.

Actually, JVM interprets the byte code and runs the java program.

It uses the class libraries, and other files provided in JRE in order to accomplish this task.

2) What is JRE ?

JRE is an acronym of Java Runtime Environment.

Java Runtime Environment is an executable file that includes JVM, class libraries (util, math,etc), and other files.

JRE doesn’t include any development tool like compiler, debugger, etc.

JRE = JVM + Java standard classes (math, lang, util, etc) + runtime libraries

JREs are available for download in Oracle website. There are many versions for each hardware configuration (32 bits/ 64 bits) or operating system (windows, linux, Mac OS, etc).

3) What is JDK ?

JDK stands for Java Development Kit.

It is an executable or a set of tools created by sun Microsystems that is used for creating java application.

JDK=JRE+ java compiler (javac) + debugger + other development tools.

Please feel free to check this tutorial in order to install java development environment.

4) What is a JIT compiler?

JIT compiler stands for Just In Time Compiler.

A JIT compiler runs after the program has started and compiles the code (usually bytecode or some kind of VM instructions) on the fly (or just-in-time, as it's called) into a form that's usually faster, typically the host CPU's native instruction set.

A JIT has access to dynamic runtime information whereas a standard compiler doesn't and can make better optimizations like inlining functions that are used frequently.

This is in contrast to a traditional compiler that compiles all the code to machine language before the program is first run (check this link for more details stackoverflow).

5) What is the extension of a source file in java?

The extension of a source file in java is “.java”

6) What is byte code?

The byte code is different from the machine code.

This is a binary code that the JVM can understand and interpret.

The byte code is written in the instruction set of the JVM.

The JVM is like a real computer that has a CPU having an instruction set. This instruction set is used inside the byte code.

7) What is the extension of a compiled file in java?

The extension of a compiled file in java is “.class”.

8) What is a platform?

A platform can be software (Operating system, etc) or a hardware platform (hardware architecture, CPU family, etc).

9) Why JAVA is platform independent?

The JVM is platform dependant whereas our java code is platform independent.

The Java executable file for desktop applications is an executable Jar (Java Archive).

This Jar file is an archive (a compressed file that contains .class files). You can unzip it like any rar or zip archive.

We can break platform independency when we write a program that looks for specific OS related files or when using JNI (Java Native Interface).

10) What is a classloader?

The class loader is a piece of software packaged in the JRE. Its role is to dynamically load Java classes into the JVM.

JVM must at least include one class loader which is the primordial (or bootstrap) class loader.

The classes are loaded in java when needed. The first class loaded is the one that has a static main method.

11) What is classpath?

The Java Virtual Machine must know where to find the project’s compiled classes.

It is not appropriate that the JVM looks through every folder on your machine in order to find your compiled classes.

So, we have to provide the JVM with the directories to use to look up for our compiled classes.

This is done by putting those directories in the classpath.

So, the classpath contains the paths used by the JVM (classloader) in order to find our compiled classes or the libraries used.

12) What are the default values of attributes in a class?

When accessed before their initialization, the attributes of a class take a default value based on the type of each attribute:

· Numeric types attributes (int, float, double, etc) take zero as a default value.

· Reference type attributes take null as a default value.

13) What are the default values of local variables declared inside methods?

Those variables have whatever value when accessed before their initialization. We can’t predict their values before their initialization.

14) How many public classes can be put per source file?

Only one public class per source file is allowed.

For more details, please check our java class tutorial.

15) What are the allowed visibility modifiers for a class?

The allowed modifiers for a class are nothing or the public modifier.

16) What is the default visibility of an attribute or a method?

When declaring an attribute in a class without specifying its visibility, it has the default visibility. The default visibility is the package visibility.

17) What is the this keyword in java?

This keyword contains a reference to the current class.

18) What is a constructor?

A constructor is a method that initializes the attributes of an object when it is created.

The constructor is called when using the new keyword.

19) What are the characteristics of a constructor?

A constructor is a method inside a java class that respects those conditions:

· Has the same name as the class

· Has no return type

20) What is a default constructor?

The default constructor is the constructor that has no arguments. This constructor is automatically generated by the compiler if we don’t write it explicitly.

When overloading constructor, the compiler will not auto-generate the default constructor for us. So, we should write the default constructor by ourselves.

This can cause many problems when using the well known frameworks like hibernate, spring, etc

21) Do child classes inherit the constructor of parent classes?

No, the constructor is not inherited. We can call the constructor of the parent class explicitly using the super keyword.

22) Can we overload a constructor?

Yes, a constructor can be overloaded.

23) Can we override a constructor?

No, overriding concept is related to inheritance.

The constructor is not inherited.

24) Can we make a constructor final?

No, a constructor cannot be final.

For more details, please check our java constructor tutorial.

25) What means a final class?

We cannot make child classes from this class. We cannot inherit from a final class.

26) What means a final method?

The method cannot be overridden.

27) What is blank final variable?

The variable is constant. We cannot change its value once it is initialized.

28) What is blank final variable?

This is a variable declared as final and not initialized when declaring it.

29) Where a blank final variable can be initialized?

The blank final variable should be initialized in the constructor of the class if it is not static.

If it is static, we should initialize it in a static block.

If we don’t respect these rules, we will get an exception.

For more details, please check our java variables for beginners tutorial.

30) Can we declare the main method as final?

Yes

31) What is an abstract class?

It is a class that has the abstract keyword in its declaration.

This class cannot be instantiated. It is created to be inherited.

A class that has at least one abstract method is an abstract class.

32) What is an abstract method?

It is a method that has no implementation and is marked with the abstract keyword.

33) What is method overriding?

Method overriding is used when creating a method that is provided in the parent class in a child class. This concept is tightly related to inheritance.

34) Is it possible to override static method?

NO, we can’t override static methods because they belong to the class itself and not to the instance.

35) Is it possible to override the overloaded method?

Yes, there is no problem.

For more details, please check our java method overriding tutorial.

36) What is method overloading?

Method overriding is used inside a single class. It is used when creating, in the same class, many methods that have the same name but differ by the list of arguments.

37) How method overloading enhances the readability of a program?

Method overloading enhances the readability of a program because we aren’t forced to create method of different names that make the same thing.

38) Is it possible to overload methods by changing the return type?

No, keeping the same list of parameters and changing only the return type will cause a compiler error.

39) Is it possible to overload the main method ?

Yes

For more details, please check our java method overloading tutorial.

40) Do virtual methods exist in java?

For those who are familiar with C++, virtual methods are used to make dynamic binding. They are related to the polymorphism concept.

In JAVA, all the methods are virtuals.

41) What is difference between method Overriding and method Overloading ?

Method Overloading	Method Overriding
Inside the same class	In the child classes: related to inheritance
Different parameters list	Same parameters list

42) What is inheritance?

A class B inherits from class A. The class B inherits some attributes and method from the class A under certain conditions (public and protected members are inherited).

In this case, class A is called the parent class (super class) and class B is called the child class.

So, the child class can use the inherited members without having to copy/paste them in the code of the class.

43) What is the purpose of inheritance in OOP?

The inheritance allows the reuse of the code of the parent class inside child classes.

44) What is the super class of all the classes in java ?

The Object class.

45) What is the super keyword in java?

The super keyword is used inside the child class to call a method present in the parent class explicitly using the dot notation.

We can call a constructor present in the parent class using the super keyword.

46) Can we use both this() and super() in a constructor?

No, because each one among the two calls needs to be the first statement.

47) Does JAVA allow multiple inheritance?

48) What replaces multiple inheritance in java ?

The use of interfaces

For more details, please check our java inheritance tutorial.

49) What we can put in an interface?

We can put inside an interface:

· final variables

· abstract methods: we can omit the abstract keyword

50) What is the difference between abstract classes and interfaces ?

Abstract class	interface
abstract classes has abstract methods and implemented methods. So, the child class needs only to implement the abstract methods to be non abstract.	The implementing class must implement all the methods of the interface or it will be abstract.
abstract classes don’t have this restriction.	The interface can only have final data.
Multiple inheritance is not allowed for classes.	An interface can inherit from many interfaces
The abstract keyword must be used	The abstract keyword is not used even when declaring methods.

51) What is static variable?

A static variable belongs to the class itself whereas instance variable belongs to an instance created from this class.

The static variable is shared between all the instances of a class. It is accessed using the class name and the dot notation.

Example: ClassName.staticVariableName

52) What is static method?

A static method belongs to the class itself whereas instance method belongs to an instance created from this class.

The static method can be called without creating an instance of the class. It is accessed using the class name and the dot notation.

Example: ClassName.staticMethodName(params)

We can’t use not static attributes inside a static method and vice versa.

53) Why main method is static?

We don’t need to create an object from the principal class in order to call the main method.

54) What is static block?

It is a bloc of code (instructions present between curl braces) marked with the static keyword.

It is used in a class to initialize static attributes in the class loading phase.

55) What is composition?

We have composition when we use an attribute of type ClassB inside a classA.

Now, you finished the top 55 Core java interview questions and answers and you are ready for the interview. We hope that you succeed in the interview and to get hired for your dream job.

If you have some core java interview questions that you need to answer. Please feel free to put it as a comment.

We also advice you to check our core java tutorial to master the java language.

You can get our latest interview questions by liking our how to program Facebook page or subscribing our mailing list.

method overriding in java

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 13:23:00 +0000

Method overriding in java: introduction

Method overriding is used when we want to define a method present in the parent class inside a subclass.

The two methods must have the same name and the same list of arguments:

Same order of arguments
Same types of arguments.
The return type should be assignment compatible (identical if it is a primitive type and subclass in the case of reference type) with the return type defined in the parent method. It can vary in the overloaded methods (not a good design choice).

The parent class contains generally a common behavior between its child classes.

Sometimes, the child class needs to change the behavior of the parent class.

This is where it comes the concept of method overriding. This concept allows changing the behavior of a method present in the parent class while keeping the name of the method defined in that parent class.

Method overriding in java example

We will show the code of the super class which the Employee class:

package sandbox;
public class Employee {
public void introduceYourself(){
System.out.println("I am an employee");
}
}

The code of the child class is the following:

package sandbox;
public class Doctor extends Employee {
 public void introduceYourself(){
 System.out.println("I am a doctor");
}          
}

The code of the main class is the following:

package sandbox;
public class TestInheritance {
public static void main(String[] args) {        
Doctor d = new Doctor();

d.introduceYourself();
}
}

The output of this program is the following:

I am a doctor

We notice that we have overridden the introduceYourSelf() method of the super class (Employee) in the child class (Doctor).

The method defined in the child class hides the correspondent method in the super class.

If we don’t override the method introduceYourSelf() in the child class, then the introduceYourSelf() method of the parent class will be called.

The method to call in the context of method overriding is determined at runtime. This is called the dynamic binding in opposition to the static binding.

In fact, in the context of the static binding, the method to call is determined at compile time.

The dynamic binding is related to the polymorphism. To know more about the polymorphism, please check the java polymorphism tutorial.

The method overriding in JAVA is a concept tightly related to inheritance unlike the method overloading in JAVA.

Method overriding in java rules

-static methods of the parent class cannot be overridden

-The methods present in the parent class and that can’t be accessed by the child class cannot be overridden:

private methods cannot be accessed outside the class where they are defined
final methods cannot be inherited

-We can’t decrease the visibility of the method of the parent class inside the child class:

If the method of the parent class is public, then we can’t put any access modifier other than public in the child class’s method.

If the method of the parent class is protected, then we can put the protected or the public access modifiers in the child class’s method.

- The method present in the child class cannot throw a checked exception which is not thrown in the parent class’s method.

- The method present in the child class can throw any unchecked exception.

This tutorial whose title is java method overriding arrives at its end.

Please don’t forget to subscribe to like our How to Program Facebook page or to subscribe to our newsletter to get our latest JAVA tutorials.

To check our core java tutorial, please check this link.

See you in the next core java tutorial.

method overloading in java

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 13:08:00 +0000

Method overloading in java: introduction

In the structured programming languages, like the C programming language, we can’t create two methods having the same name.

In JAVA, we can create two or more methods having the same name but respecting some conditions.

We speak about method overloading in JAVA inside the same class.

Method overloading in JAVA is different from method overriding.

The later concept (method overriding) is tightly related to inheritance.

Method overloading in java: conditions

We can create two or more methods having the same name in the same class.

But, we must respect these conditions:

The overloaded methods must have different arguments list:

Different arguments types
Different arguments number

Overloaded methods are considered as a static polymorphism.

Method overloading in java: example

public class Hello {
public void sayHello(){
System.out.println("Hello There");

public void sayHello(String name){
System.out.println("Hello"+name);
}
public void sayHello(String name , String otherName){
System.out.println("Hello"+name+" and "+ otherName);
}
}

We create a TestHello class the test the Hello class:

public class TestHello {
public static void main(String[] args) {
Hello h = new Hello();
 h.sayHello();
 h.sayHello("Jack");
 h.sayHello("Peter","Mary");

}
}

Here the overloaded methods are:

public void sayHello()
public void sayHello(String name){
public void sayHello(String name , String otherName)

We notice that all those overloaded methods have the same name (sayHello). But they differ by the arguments list (the number, type and order of the parameters).

The output of the TestHello class is the following:

Hello There

Hello Jack

Hello Peter and Mary

Method overloading in java: arguments match

The overloaded methods have the same name.

Method overloading in java: arguments exact match

The executed overloaded method is chose based on the exact match between the passed arguments and the formal arguments of the method.

Examples:

If we pass nothing to the sayHello method in the call, then the method sayHello() without arguments is called.

If we pass two strings to the sayHello method in the call, then the method sayHello(String name, String otherName) is called and so on.

Method overloading in java: arguments promotion

If there is no exact match between the passed arguments and the formal arguments of the overloaded method, arguments can be promoted to the required type.

Example:

public class Arithmetic {
public void add(int a) {          
System.out.println("sum= "+a+a);

}
public void add(long a, long b) {
System.out.println("sum = "+a+b);
}
}

The principal class is the following:

public class TestArithmetic {
public static void main(String[] args) {
Arithmetic a = new Arithmetic();
a.add(1,2);             
}
}

In the Arithmetic class, the overloaded method is the add method.

In the call of the add method in the TestArithmetic class, we passed two arguments of type int to the add method.

We notice, that the class Arithmetic doesn’t contain an add method that gets two arguments of type int

there is no exact match between the passed arguments (1 and 2) and the formal arguments of the add method : there is no add(int a, int b) method in the Arithmetic class

What happened in this case is what we call arguments promotion.

The argument promotion is representing a type as bigger type (wider range of values).

The order of numeric types based on the range of values that they can hold is the following: byte < short < char < long < float < double

Method overloading in java: arguments promotion problems

We will present an example that causes an ambiguity problem caused by arguments promotion.

public class Arithmetic {
public void add(int a) {
System.out.println("sum = "+a+a);
}
public void add(long a, int b) {
System.out.println("sum = "+a+b);

public void add(int a, long b) {
System.out.println("sum = "+a+b);
}
}

To put this class in action, we create the following class:

public class TestArithmetic {
public static void main(String[] args) {
Arithmetic a = new Arithmetic();

a.add(1,2);

}
}

Here, we create two methods in the Arithmetic class:

public void add(long a, int b)
public void add(int a, long b)

Then, we made this call in the TestArithmetic class: a.add(1,2);

There no add method that takes two arguments of type int in the Arithmetic class (there is no exact match).

In this case, the compiler tries to promote the int arguments (1 and 2 values) to match one of the add methods.

In this case there is an ambiguity.

which method to call:

We promote the first argument to long and we keep the second int argument as it is to match the method: public void add(long a, int b)

We promote the second parameter to long and we keep the first argument as it is to match the method: public void add(int a, long b)

So, we should avoid these situations when using method overloading in JAVA.

Method overloading in java and the return type

We shouldn’t create overloaded methods that differ only by the return type :

The methods have the same arguments list
The methods have different return types

public class Arithmetic {
public void add(long a, long b) {
System.out.println("sum = "+a+b);
}          
public long add(long a, long b) {
return a+b;

}          
}

Here, the overloaded methods differ only by the return type (void and long).

This is incorrect.

This tutorial whose title is java method overloading arrives at its end. You can also check the oracle java method overriding tutorial.

Please don’t forget to subscribe to like our How to Program Facebook page or to subscribe to our newsletter to get our latest JAVA tutorials.

To check our core java tutorial, please check this link.

See you in the next core java tutorial.

Java constructor tutorial for beginners

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 12:07:00 +0000

JAVA constructor tutorial: JAVA constructor introduction

As we said in the JAVA Object Tutorial, the constructor is a special method defined in a JAVA class.

The main reason of creating this method is to initialize the attributes of an object.

This method is called when creating new objects to initialize their attributes.

It is called constructor because it is called when constructing objects.

There are rules that should be respected when creating a java constructor.

We will mention those rules in the next section.

JAVA constructor tutorial: JAVA constructor characteristics

A JAVA constructor must respect these rules:

· JAVA constructor must have the same name of the class including capital letters

· JAVA constructor doesn’t have a return type (even void is not permitted)

· JAVA constructor is used mainly to assign values to the attributes of an object

The constructor gives an initial state to an object.

Then, when the program runs, this state will change.

There are other characteristics of java constructors that are related to concepts that we haven’t dealt with yet (inheritance,…).

We will deal with these concepts when we will deal with those concepts.

JAVA constructor tutorial: JAVA constructor types

We can define many constructors in a JAVA class by overloading constructors.

Check the java method overloading tutorial to know more about this subject.

But, in a class we have only one default constructor.

A Java class contains:

Only one default constructor
Zero or many overloaded constructors

The default constructor is the constructor which doesn’t have any parameter.

JAVA constructor tutorial: JAVA default constructor example

public class Vehicle {
String color;
int speed;
public Vehicle() {
this.color = "Black";
this.speed = 220;
}
}

The default constructor in the example above is the method: public Vehicle()

If we don’t create a default constructor, the JAVA compiler creates an empty default constructor for us automatically.

But, if we don’t create a default constructor and we create an overloaded constructor, then the compiler will not auto-generate a default constructor for us.

So, we should create it by ourselves.

JAVA constructor tutorial: JAVA overloaded constructors example

We can add other overloaded constructors as well to the Vehicle class:

public class Vehicle {
String color;
int speed;
public Vehicle() {
this.color = "Black";
this.speed = 220;
}
public Vehicle(String color, int speed) {
this.color = color;
this.speed = speed;
}
public Vehicle(int speed) {
this.color = "White";
this.speed = speed;
}
public Vehicle(String color) {
this.color = color;
this.speed = 300;
}          
}

The JAVA constructor example above contains in addition to the default constructor three overloaded constructors.

The overloaded constructors are:

public Vehicle(String color, int speed) : allows to initialize all the attributes of an object of type Vehicle using custom values
public Vehicle(int speed) : allows to initialize the speed attribute of a vehicle object and gives a default value (“white”) to the color attribute
public Vehicle(String color) : allows to initialize the color attribute of a vehicle object and gives a default value (300) to the speed attribute

JAVA constructor tutorial: Creating objects using JAVA constructors

JAVA calls the appropriate constructor when we use the new operator to create objects.

The appropriate constructor to call is chosen based on its argument list.

We will present a java constructor example that uses the default constructor of the Vehicle class to create an object:

public class TestVehicle {

public static void main(String[] args) {
Vehicle v = new Vehicle();
System.out.println("speed = "+v.speed);
System.out.println("color = "+v.color);
}
}

The output of this program is the following:

speed = 220

color = Black

The java constructor example below uses the constructor that initializes all the attributes of an object of type Vehicle

public class TestVehicle {
public static void main(String[] args) {                    
Vehicle v = new Vehicle("Gray", 120);
System.out.println("speed = "+v.speed);
System.out.println("color = "+v.color);
}
}

The output of this program is the following:

speed = 120

color = Gray

The final java constructor example uses the constructor that allows to initialize the speed of a vehicle and gives a default value to the color attribute.

public class TestVehicle {
public static void main(String[] args) {        
Vehicle v = new Vehicle(320);
System.out.println("speed = "+v.speed);
System.out.println("color = "+v.color);
}
}

The output of this program is the following:

speed = 320

color = White

This java constructor tutorial for beginners arrives at its end. You can also check the oracle java objects tutorial.

Please don’t forget to subscribe to like our How to Program Facebook page or to subscribe to our newsletter to get our latest JAVA tutorials.

To check our core java tutorial, please check this link.

See you in the next core java tutorial.

Java objects tutorial for beginners

noreply@blogger.com (Abderrahmen Ben Mariem) — Sat, 06 Jun 2020 11:46:00 +0000

JAVA objects tutorial for beginners: JAVA objects introduction

As we said in the JAVA class Tutorial, a class is a blueprint used to create identical JAVA objects that respect the blueprint.

This means that the JAVA objects created have all the attributes, methods and inner classes defined in the class.

The object contains two main elements:

Attributes: represent the state of an object. Each object has its own values for each attribute of a class. Those values represent the state of an object. The state of an object may or may not change during the execution of a JAVA Program.

Methods: represent the behavior of an object (what an object can do). Those methods may be used to change the state of an object, to manage another object of another type, to do some computation and return a useful result, etc

All the objects created from a class have the same methods but their states are different.

JAVA objects tutorial for beginners: JAVA objects creation

JAVA objects are created using the new operator.

When the new operator is called, a special method called constructor is called.

We will deal with constructors in depth in a separate tutorial.

JAVA objects may be created in any JAVA method including the principal method: public static void main (String [] args)

Example:

The class definition is the following:

class MyFirstClass {
//attribute declaration
int attributeName1;
//methods declarations
//The default constructor
MyFirstClass(){
attributeName1 = 5;
}
void display(){
System.out.println(“attributeName1 = ”+ attributeName1);
} 
}

We create a new object whose class is MyFirstClass using this single line of code:

MyFirstClass mfo = new MyFirstClass();

Here, we create an object of type MyFirstClass and we put its reference in the mfo variable.

mfo is called a reference type variable because it contains a reference to the newly created object.

A possible implementation of JAVA reference may be a pointer. But, JAVA itself doesn’t contain the concept of pointers.

The purpose of creating a class is to use it to create objects from that class. But, there is an exception (abstract classes) that we will deal with it later.

The MyFirstClass class contains a default constructor: MyFirstClass()

A constructor is a special method that:

Has the same name of the class
Doesn’t have a return type (not even void)

To know more about constructors, check the java constructor tutorial.

To test the creation of the object above, we should put for example the object creation line in the main method:

public class TestObjectCreation {
public static void
main(String[] args) {
MyFirstClass mfo = new MyFirstClass();
}
}

JAVA objects tutorial for beginners: calling methods on JAVA objects and accessing attributes

We call a method on java objects using the dot notation.

mfo.display();

We access the values of the attributes of an object using the dot notation.

An example of a write access is the following:

mfo. attributeName1 = 8;

or we can display it using this line (read access):

System.out.println(“displaying the value of attributeName1: ”+ mfo.attributeName1);

We should put the MyFirstClass and TestObjectCreation classes in the same package (default package for example) for an access problem.

We will explain this when we deal with access modifiers and packages.

The final version of the TestObjectCreation class is the following:

public class TestObjectCreation {

public static void main(String[] args) {
MyFirstClass mfo = new MyFirstClass();
mfo.display();
System.out.println(“displaying the value of attributeName1: ”+ mfo.attributeName1);
}
}

The output got when running the TestObjectCreation class is the following:

attributeName1 = 5

displaying the value of attributeName1 : 5

This java objects tutorial for beginners arrives at its end. You can also check the oracle java objects tutorial.

Please don’t forget to subscribe to like our How to Program Facebook page or to subscribe to our newsletter to get our latest JAVA tutorials.

To check our core java tutorial, please check this link.

See you in the next core java tutorial.

Java Beginners Tutorial - How to program in JAVA

Kafka multi broker cluster setup on windows 10 | kafka tutorials

Create Apache Kafka configurations for two brokers

Startup the tree Apache Kafka nodes

Create new topic replicated to all 3 brokers

Creating apache kafka topic

Visualizing apache kafka topic

Conclusion

Install apache kafka on windows 10 | kafka tutorials

Download and install Apache Kafka

Startup Apache Kafka

Creating and visualising Apache Kafka topics

Creating apache kafka topic

Visualizing apache kafka topic

Producing and consuming messages using Apache Kafka

Producing messages

Consuming messages

Stopping Apache Kafka server and the zookeeper

Conclusion

Spring boot spring data MongoDB reactive crud example | JAVASNEO

Adding Spring data MongoDB reactive and Spring webflux maven dependencies

Setting up Spring Data Mongo Reactive Repository using JAVA configuration class

Updating the REST API to use MongoDB database reactive

Rest API Repository

Rest API Service

Rest API controller

Conclusion

Spring boot spring data Cassandra crud example | JAVASNEO

Adding Spring data Cassandra maven dependency

Setting up Cassandra database using JAVA configuration file

Updating the REST API to use Cassandra database

Rest API Model

Rest API Repository

Rest API Service

Rest API controller

Cassandra table creation

Spring Boot REST API Testing

Spring boot Spring data MongoDB crud example | JAVASNEO

Adding Spring data Mongo maven dependency

Setting up MongoDB database using the application.properties file

Rest API Model

Rest API Repository

Rest API Service

Rest API controller

Spring Boot REST API Testing

conclusion

spring boot spring data jpa h2 database crud example tutorial | JAVASNEO

Adding Spring data JPA and h2 database maven dependencies

Setting up H2 database using the application.properties file

Accessing H2 database console

Updating the REST API to use H2 database

Rest API Model

Rest API Repository

Rest API controller

Conclusion

Spring Boot 2 REST API Example - JAVASNEO

Spring Boot 2 REST API maven dependencies

Spring Boot 2 REST API configuration

Spring Boot 2 REST API model

Spring Boot 2 REST API controller

Spring Boot 2 REST API main Class

Invoking Spring Boot 2 Rest API endpoints

HTTP GET /todos

HTTP POST /todos

HTTP PUT /todos

HTTP DELETE /todo/{id}

Conclusion :

Best React Books in 2020 | Best Programming Books

Book Details

About the Author

React Explained: Your Step-by-Step Guide to React (2020 Edition)

Book Details

About the Author

Table of Contents

React and React Native: Acomplete hands-on guide to modern web and mobile development with React.js, 3rdEdition

Book Details

About the Author

Table of Contents

Learning React js: Learn React JS From Scratch with Hands-OnProjects , 2nd Edition

Book Details

React Explained: Your Step-by-Step Guide
to React (2020 Edition)