A thread in Java at any point of time exists in any one of the 6 states. This article give a quick introduction of different Thread states and respective methods which results in threads state change.
A thread in Java at any point of time exists in any one of the 6 states. This article give a quick introduction of different Thread states and respective methods which results in threads state change.
Following are the states of a Java Thread
New: Thre thread is just created by using start() method on the tread
Runnable: Thread state for a runnable thread. A thread in the runnable state is executing in the Java virtual machine but it may be waiting for other resources from the operating system such as a processor.
Blocked: A thread in the blocked state is waiting for a monitor lock
Waiting: A thread is in the waiting state due to calling one of the following methods: Object.wait() with no timeout Thread.join() with no timeout LockSupport.park
Timed Waiting: A thread is in the timed waiting state due to calling one of the following methods with a specified positive waiting time:Thread.sleep (long) Object.wait (long) Thread.join (long) LockSupport.parkNanos LockSupport.parkUntil
In this article, we will explore a few different ways to rotate a matrix clock by 90 degrees.
Rotating Matrix to 90 Clockwise
Following is our Matrix.
[123]
[456]
[789]
We will explore multiple ways to rotate this matrix clockwise 90
With Matrix Transpose
Matrix transpose is a flipped version of the matrix along its diagonal. In short, it is the same as interchanging the rows with columns.
For the above matrix the transposed matrix will look like.
[147]
[258]
[369]
Also, the transposed matrix is equivalent to 90 Left rotation of the original array.
RoateMatrixWithTranspose
Here the Rotation of the matrix is done in two steps
1) We transpose the matrix
2) And we interchange the columns
public void rotateMatrixRight90Transpose(int[][] mat) {
int m = mat.length;
int n = mat[0].length;
for (int i = 0; i < m; i++) {
for (int j = i; j < n; j++) {
int x = mat[i][j];
mat[i][j] = mat[j][i];
mat[j][i] = x;
System.out.println("IC" + i + ":" + j);
}
}
// swap cols
for (int i = 0; i < m; i++) {
for (int j = 0; j < n / 2; j++) {
// swap mat[i][j] with mat[N-i-1][j]
int temp = mat[i][j];
mat[i][j] = mat[i][n - j - 1];
mat[i][n - j - 1] = temp;
}
}
}
Output
Matrix Rotation with Transpose
<= Original Matrix=>
[123]
[456]
[789]
<= After Transpose =>
[147]
[258]
[369]
<= After Rotation =>
[741]
[852]
[963]
Matrix Rotation in Single pass
MatrixRotation.java
The following code will rotate the matrix in a single pass.
public void rotate(int[][] matrix) {
int n = matrix.length;
for (int i = 0; i < (n + 1) / 2; i++) {
for (int j = 0; j < n / 2; j++) {
int temp = matrix[n - 1 - j][i];
matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1];
matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 - i];
matrix[j][n - 1 - i] = matrix[i][j];
matrix[i][j] = temp;
}
}
}
This article shows how to use the Google Java style with Eclipse IDE. Every organization has its own style guide, in the open-source community different projects have a slightly different style guide. In this article, we will see how to use the official google style guide in Eclipse IDE.
This article shows how to use the Google Java style with Eclipse IDE. Every organization has its own style guide, in the open-source community different projects have a slightly different style guide. In this article, we will see how to use the official google style guide in Eclipse IDE.
Get the Style Guide
Save the style guide which is a XML file to your local drive.
Junit 5 comes with some new annotations that were not available in previous releases. Understanding these Annotations will help in writing efficient tests.
This article covers some of the most commonly used annotations. In the next section, we will example of those annotations.
Junit 5 comes with some new annotations that were not available in previous releases. Understanding these Annotations will help in writing efficient tests.
This article covers some of the most commonly used annotations. In the next section, we will example of those annotations.
The following are some of the important annotations in JUnit 5.
@Test
@Test : Denotes that a method is a test method. Without this annotation, JUnit will ignore the method
@ParameterizedTest
Denotes a method to be a parameterized test method. Parameterized tests make it possible to run a test multiple times with different arguments.
@RepeatedTest
@RepeatedTest : Test methods marked with @RepeatedTest can be executed repeatedly
@TestMethodOrder
@TestMethodOrder: Helps maintain order in which test methods are executed.
@DisplayName
@DisplayName : Helps in using a custom name to be printed either in the console or test report for the test method.
@DisplayNameGeneration
@DisplayNameGeneration : Declares a custom display name generator for the test class
@BeforeEach
@BeforeEach: Analogous to JUnit 4 @Before. Denotes the annotated method should be executed before each test. The method should not return any value, should not be private.
@AfterEach
@AfterEach : Analogous to JUnit 4 @After. Denotes the annotated method should be executed after each test. The method should not return any value, should not be private.
@BeforeAll
@BeforeAll: Denotes that the annotated method should be executed before all @Test, @RepeatedTest, @ParameterizedTest, and @TestFactory methods in the current class; analogous to JUnit 4’s @BeforeClass. Such methods are inherited (unless they are hidden or overridden) and must be static (unless the "per-class" test instance lifecycle is used).
@AfterAll
@AfterAll: Denotes that the annotated method should be executed after all @Test, @RepeatedTest, @ParameterizedTest, and @TestFactory methods in the current class; analogous to JUnit 4’s @AfterClass.
A method marked with @AfterAll is inherited (unless they are hidden or overridden) and must be static.
@Nested
@Nested:Denotes that the annotated class is a non-static nested test class. @BeforeAll and @AfterAll methods cannot be used directly in a @Nested test class unless the "per-class" test instance lifecycle is used. Such annotations are not inherited.
@Tag
@Tag: Used to declare tags for filtering tests, either at the class or method level; analogous to test groups in TestNG or Categories in JUnit 4.
Such annotations are inherited at the class level but not at the method level.
@Disabled
@Disabled : Used to disable a test class or test method; analogous to JUnit 4’s @Ignore. Such annotations are not inherited.
@Timeout
@Timeout: Used to fail a test, test factory, test template, or lifecycle method if its execution exceeds a given duration. Such annotations are inherited.
The test suite is a container that has a set of tests that can be executed together. For instance, say we have multiple tests and want to execute all of them or subset of them under certain conditions. Like we want to run all the tests in the integration stage, a subset of tests in the developer environment before pushing code. All these can be done using Test Suite. Using JUnit 5 test suites, we can run tests spread into multiple test classes and different packages. JUnit 5 provides two annotations: @SelectPackages and @SelectClasses to create test suites. Additionally, you can use other annotations for filtering test packages, classes, or even test methods.
The test suite is a container that has a set of tests that can be executed together. For instance, say we have multiple tests and want to execute all of them or subset of them under certain conditions. Like we want to run all the tests in the integration stage, a subset of tests in the developer environment before pushing code. All these can be done using Test Suite. Using JUnit 5 test suites, we can run tests spread into multiple test classes and different packages. JUnit 5 provides two annotations: @SelectPackages and @SelectClasses to create test suites. Additionally, you can use other annotations for filtering test packages, classes, or even test methods.
Filtering Tests in Suites
Tests in JUnit5 can be executed with @RunWith. The same annotation is also used for Junit 4. The only difference Is in Junit 5 we pass JUnitPlatform as a parameter.
In this article we will go though some sample use cases of creating TestSuite in JUnit 5 and how to filter test classes, test methods in the test suite etc.
@SelectPackages
With this annotation, we can tell the Test Suite to scan all the mention packages and its sub-packages and execute all the Test Classes. We can also specify a signal package or multiple packages. Following example demonstrates this.
Select a single package
With @SelectPackages we can select test classes only from a specified package or list of packages. In the following example, all the Test classes from package com.bootng will be executed.
import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.suite.api.SelectPackages;
import org.junit.runner.RunWith;
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng" })
public class TestSuiteWithPackageSingle {
}
Select multiple packages
Similarly, if we want to support multiple packages then we can specify multiple package names. The following example will execute tests from the two packages.
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng.assertions", "com.bootng.display" })
public class TestSuiteWithPackageMultiple {
}
@SelectClasses
Select Two Classes
In this example rather than selecting packages, we can specify individual test classes that we want to include in the Test Suite.
In the following example essentially we will have only two Test classes in the Test Suite.
@RunWith(JUnitPlatform.class)
@SelectClasses({ DisplayExampleTest.class, DisplayGeneratorExampleTest.class })
public class TestSuiteWithSelectClass {
}
@IncludePackages and @ExcludePackages
@IncludePackages and @ExcludePackages work only at the specified package level and it won't scan sub-packages.
This annotation is used with @SelectPackages annotation to fine-tune the filtering. Son in the following example Test Classes from only com.bootng.assertions will be included.
IncludePackages Example
Here
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng" })
@IncludePackages({ "com.bootng.assertions" })
public class TestSuite_IncludePackage {
}
ExcludePackages Example
Includes all the test form package com.bootng, but excludes tests from sub package com.bootng.assertions.
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng" })
@IncludePackages({ "com.bootng.assertions" })
public class TestSuite_IncludePackage {
}
@IncludeClassNamePatterns and @ExcludeClassNamePatterns
Rather than filtering the test class from packages, we can also filter them based on the name of the Test Classes.
To specify test class names patterns to exclude or include, you can use @IncludeClassNamePatterns and @ExcludeClassNamePatterns annotations.
IncludeClassNamePatterns Example
In this example, we can including only the test whose name ends with "Test" from the package (and sub packages) of com.bootng
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng" })
@IncludeClassNamePatterns("^.*Test*$")
public class TestSuite_NamePattern {
}
@IncludeTags and @ExcludeTags
IncludeTags Example
With IncludeTags and Exclude Tags we can filter Classes or Methods that are Tagged with the specified tag. For Instance, the following example, we are scanning package com.bootng.assertions and then only interested in including Test Classes or Test Methods tagged with Weather.
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng.assertions" })
@IncludeTags({ "Weather" })
public class TestSuite_TagInclude {
}
ExcludeTags Example
Similar to IncludeTags tag to filter Test Methods or Test Classes but for exclusion. The following example will exclude all the Tests tagged with "Weather"
@RunWith(JUnitPlatform.class)
@SelectPackages({ "com.bootng.assertions" })
@ExcludeTags({ "Weather" })
public class TestSuite_TagExclude {
}
Summary
JUnit 5 provides powerful ways to filter Test cases in Test Suites. We have several options starting from including/excluding a specific packages to include/exclude specific
Classes to Include/Exclude specific methods.
JUnit 5 is the latest version of Junit. It has a brand new architecture and more capabilities compared to the previous generation of Junit. In this article, we will quickly go through some of the main features and concepts of JUnit 5. In this article we go over the high-level structural requirement for writing Unit Tests.
Generally, we write test method to represent a test case or a certain scenario which we want to validate. Such test methods would reside inside a Class. With Junit5 we don't need to mark or annotate the main class with any special JUnit specific annotations. Junit5 will be able to
JUnit 5 is the latest version of Junit. It has a brand new architecture and more capabilities compared to the previous generation of Junit. In this article, we will quickly go through some of the main features and concepts of JUnit 5. In this article we go over the high-level structural requirement for writing Unit Tests.
Generally, we write test method to represent a test case or a certain scenario which we want to validate. Such test methods would reside inside a Class. With Junit5 we don't need to mark or annotate the main class with any special JUnit specific annotations. Junit5 will be able to
Test Class
Any top-level class, static member class, or @Nested class that contains at least one test method. We don't need to annotate the Class, JUnit5 will be able to find test methods defined inside it.
Class Requirement
The Class should contain only one Constructor and the Class should not be an abstract Class.
Test Method
Any not abstract instance method that is annotated with @Test, @RepeatedTest, @ParameterizedTest, @TestFactory, or @TestTemplate.
Test Method
The test method should not return any value and should not be abstract.
Lifecycle Method
Any method that is directly annotated or meta-annotated with @BeforeAll, @AfterAll, @BeforeEach, or @AfterEach
Lifecycle methods can be inherited from parent class. Lifecycle methods should not be private and should not return any value.
Lifecycle Method
Should not be private and should not return value.
@BeforeAll and @AfterAll should be used on a static method
Example
Following Example shows a Test Class with one test method annotated with @Test and four Lifecylcle emthods
SimpleHelloTest3
package com.bootng.start;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
public class SimpleHelloTest3 {
@BeforeAll
public static void method1() {
System.out.println("method 1");
}
@BeforeEach
public void method2() {
System.out.println("method 2");
}
@AfterAll
public static void method3() {
System.out.println("method 3");
}
@AfterEach
public void method4() {
System.out.println("method 4");
}
@Test
public void test_hello() {
String msg = "hello";
assertEquals(msg, "hello", " message is equal Hello");
System.out.println("");
}
}
Running the above test would output the following. method1 and method2 would be executed before the actual test and then method4 and method3 would be executed.
JUnit 5 is the latest version of Junit. It has a brand new architecture and more capabilities compared to the previous generation of Junit. In this article, we will quickly go through some of the main features and concepts of JUnit 5. In this Article we will start with our first JUnit 5 Test.
Table of Content
JUnit5 Writing first Test
JUnit 5 is the latest version of Junit. It has a brand new architecture and more capabilities compared to the previous generation of Junit. In this article, we will quickly go through some of the main features and concepts of JUnit 5. In this Article we will start with our first JUnit 5 Test.
SimpleHelloTest
First Junit5 Test. This test has only one test method which asserts that the message string is equal to "hello"
package com.bootng.start;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class SimpleHelloTest {
@Test
public void test_hello() {
String msg = "hello";
assertEquals(msg, "hello", " message is equal Hello");
}
}
When running this test, the test will surely pass since the assert condition will be successfull.
JUnit 5 is the latest version of Junit. It has a brand new architecture and more capabilities compared to the previous generation of Junit. In this article, we will quickly go through some of the main features and concepts of JUnit 5.
JUnit 5 is the latest version of JUnit. It has a brand new architecture and more capabilities compared to the previous generation of JUnit. In this article, we will quickly go through some of the main features and concepts of JUnit 5 through hands on examples.
JUnit 5 Project
JUnit 5 is composed of mainly three sub-projects JUnit Platform, JUnit Jupiter, and JUnit Vintage.
junit-jupiter-api (JUnit Platform): JUnit Jupiter API for writing tests and extensions. junit-jupiter-engine(JUnit Jupiter) : JUnit Jupiter test engine implementation, only required atruntime. junit-vintage-engine:(JUnit Vintage): To run tests wittern in older version of JUnit on JUnit 5 Platform.
This article is focused on JUnit5 with maven as a build tool. Other than the maven related configurations information in this articles holds true for other build environments also.
Java 8
JUnit 5 requires a minimum Java 8 version
JUnit 5 Artifacts
If you’re using Maven you can add the corresponding subprojects in your pom file (juinit-jupiter-api, junit-jupiter-engine, junit-vintage-engine).
Starting with Juinit 5.4 we can also simply add aggregate artifact named junit-jupiter in our pom.xml to include all the JUnit 5 related dependencies to our project.
Supports Lambda expressions.
Nested Unit Tests
Parameterized Unit Tests
Conditional Test inclusion or exclusion
Extension Model
Main Annotations
Tests written in JUnit5 follow some standard approach and it is done by utilizing the capabilities provided by the JUnit 5 framework. The following are some of the annotations provided by JUnit 5. This is just to provide some quick pointers to the rich feature sets of JUnit 5.
Common annotations
@Test – denotes a test method, it does not take any arguments.
@DisplayName – specifies a custom name for the test class or method.
@DisplayNameGeneration - specify a generator to generate a custom name for method or class.
@Nested - it marks a class a nested test
@Disabled – prevents a test class or method from executing;
@BeforeEach,
@AfterEach – runs the annotated method before or after each test method in the same class.
@BeforeAll,
@AfterAll – runs the annotated method before any or after all of the test methods in the class.
An assertion is a java statement. An assertion statement is used in the code to ensures the correctness of any assumptions on which the program depends. When the java runtime executes the assert statement it will throw assertion exception.
Assertion helps in maintaining the invariants in a program under check.
We will explore how to use the assertion statement with an example.
An assertion is a java statement. An assertion statement is used in the code to ensures the correctness of any assumptions on which the program depends. When the java runtime executes the assert statement it will throw assertion exception.
Assertion helps in maintaining the invariants in a program under check.
We will explore how to use the assertion statement with an example.
Syntax for assertion
The following are the two different syntaxes for using assertion.
First way
If the expression is false the assert statement will throw java.lang.AssertionError
assert expression;
Second way
With two expressions where expression1 must be a boolean expression.
and expression2 must return a value (must not return void).
if exprerssion1 is false, the assert statement will throw java.lang.AssertError with expression2 as the message
assert expression1 : expression2;
By default assertion is disabled we can enable it by setting the jvm parameter ea or enableassertions.
Enabling assertion
By default, assertions are disabled in Java. If assertions are disabled, assertion statements do not have any effects. In order to enable them, we use the following command
In the following example, we have a Movie object containing movie name and minAge. From the main class we
create a movie object and call the play method only if the minimum age requirement is met.
Movie.java
class Movie {
private String title;
private int minAge;
public Movie(String title, int age) {
this.title = title;
this.minAge = age;
}
public void play() {
System.out.print("Playing movie: " + title);
}
public String getTitle() {
return title;
}
public int getAgeRestriction() {
return minAge;
}
}
JavaAssertionTest
public class JavaAssertionTest {
public static void main(String[] args) {
Movie movieA = new Movie("movie 007 James bond", 11);
Movie movieB = new Movie("movie Transformers", 18);
//We want to play only movies suitable for age 11 or under
assert (movieA.getAgeRestriction() <= 18);
movieA.play();
assert (movieB.getAgeRestriction() <= 11): "Underage for movie" + movieB.getTitle();
movieB.play();
System.out.println("played with all movies");
}
}
Running the above example will result in the following output.
Console Output
Playing movie movie 007 James bond
Exception in thread "main" java.lang.AssertionError: Underage for moviemovie Transformers
at JavaAssertionTest.main(JavaAssertionTest.java:12)
Note in the above case the moment the assertion error is thrown, the program will exit.
Handling AssertionErrror
If an assertion error occurs the program will throw exception and exit. If we want to handle the assertion error, we can put the assert statement within a try-catch block. And in the catch block, we can have our logic if assert statement. The following example shows the same.
With Try Catch block
public static void main(String[] args) {
Movie movieA = new Movie("movie 007 James bond", 11);
Movie movieB = new Movie("movie Transformers", 18);
System.out.println("Start playing movies");
//We want to play only movies suitable for age 11 or under
assert (movieA.getAgeRestriction() <= 18);
movieA.play();
try {
assert (movieB.getAgeRestriction() <= 11): "Underage for movie with title:: " + movieB.getTitle();
movieB.play();
}catch (AssertionError e) {
System.out.println("Oops this movie cannot be played because " + e.getMessage());
}
System.out.println("played with all movies");
}
Console output
Start playing movies
Playing movie: movie 007 James bond
Oops this movie cannot be played because Underage for movie with title:: movie Transformers
played with all movies
Summary
assertions are a great way to confirm program invariants hold true.
we have two different syntaxes for writing assertion in java.
by default assertions are turned off, we can turn on using JVM flag.
if an assert statement fails, the program will throw AssertionError and exit.
we can catch AssertionError, and still get hold control of the program.
In our earlier articles, we learned how to create rest full API's . In this article, we will learn how to invoke or call Rest full API's in spring boot. Essentially we are going to write a simple client to consume a few public RESTful API's. RESTTemplate is for just that, Spring's RESTTemplate is used to write client applications to consume RESTful API
In our earlier articles, we learned how to create rest full API's . In this article, we will learn how to invoke or call Rest full API's in spring boot. Essentially we are going to write a simple client to consume a few public RESTful API's. RESTTemplate is for just that, Spring's RESTTemplate is used to write client applications to consume RESTful API
In this article, we will consume two different public API. For that, we will write a standalone Spring Boot App, to consumes the REST API's as follows
API 1: Get all GitHub API's
GET https://api.github.com
API 2: Get all Github repositories for user bootng
GET https://api.github.com/users/bootng/repos
Technologies Used
Java 11
Apache Maven 3.5.0
Spring Boot 2.2.6
Eclipse IDE
Main Application Class
package com.javaexp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@SpringBootApplication
public class ResttemplateApplication {
private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class);
public static void main(String args[]) {
log.info("about to call ResttemplateApplication.run()");
SpringApplication.run(ResttemplateApplication.class, args);
log.info("completed executing ResttemplateApplication.run()");
}
}
Our first REST client is as bellow, which calls a REST endpoint and then displays results in the console.
LoadAllGithubEndpoints.java
package com.bootng;
import java.util.Iterator;
import java.util.Map.Entry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.core.annotation.Order;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.JsonNode;
/**
* This Class List all the endpoints from URL https://api.github.com
*
*/
@Component
@Order(1)
public class LoadAllGithubEndpoints implements CommandLineRunner {
private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class);
@Override
public void run(String... args) throws Exception {
log.info("about to call LoadAllEndpoint.run()");
RestTemplate restTemplate = new RestTemplateBuilder().build();
ResponseEntity<JsonNode> apis =
restTemplate.getForEntity("https://api.github.com", JsonNode.class);
StringBuilder result = new StringBuilder("\n List of Public API's");
apis.getBody().fields().next().getValue();
Iterator<Entry<String, JsonNode>> it = apis.getBody().fields();
while (it.hasNext()) {
result.append("\n").append(it.next().getValue().asText());
}
log.info(result.toString());
}
}
Our second REST client is as bellow, which calls a REST endpoint and then displays all the repositories for user bootng in the console.
LoadGithubRepo
package com.bootng;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.core.annotation.Order;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.JsonNode;
@Component
@Order(2)
public class LoadGithubRepo implements CommandLineRunner {
private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class);
@Override
public void run(String... args) throws Exception {
log.info("about to call LoadGithubRepo.run()");
RestTemplate restTemplate = new RestTemplateBuilder().build();
ResponseEntity<JsonNode> repos = restTemplate
.getForEntity("https://api.github.com/users/bootng/repos", JsonNode.class);
int counter = 1;
StringBuilder result = new StringBuilder("\n List of Repositories");
if (repos.getBody().isArray()) {
for(JsonNode jsonNode : repos.getBody()) {
result.append("\n Repo ").append(counter++).append("::");
result.append(jsonNode.get("name").asText());
}
}
log.info(result.toString());
}
}
Notice that LoadGithubRepo is marked with annotation Order(2) and LoadAllGithubEndpoints is marked with annotation Order(1). That means Spring will execute LoadAllGithubEndpoints first and then LoadGithubRepo.
Building and Running the application
mvn clean install
mvn spring-boot:run
Console Output
20-June-18 16:25:17:627 INFO main c.b.ResttemplateApplication:27 - about to call LoadAllEndpoint.run()
20-June-18 16:25:18:570 INFO main c.b.ResttemplateApplication:40 -
List of Public API's
https://api.github.com/user
https://github.com/settings/connections/applications{/client_id}
https://api.github.com/authorizations
https://api.github.com/search/code?q={query}{&page,per_page,sort,order}
https://api.github.com/search/commits?q={query}{&page,per_page,sort,order}
https://api.github.com/user/emails
https://api.github.com/emojis
https://api.github.com/events
https://api.github.com/feeds
https://api.github.com/user/followers
https://api.github.com/user/following{/target}
https://api.github.com/gists{/gist_id}
https://api.github.com/hub
https://api.github.com/search/issues?q={query}{&page,per_page,sort,order}
https://api.github.com/issues
https://api.github.com/user/keys
https://api.github.com/search/labels?q={query}&repository_id={repository_id}{&page,per_page}
https://api.github.com/notifications
https://api.github.com/orgs/{org}
https://api.github.com/orgs/{org}/repos{?type,page,per_page,sort}
https://api.github.com/orgs/{org}/teams
https://api.github.com/gists/public
https://api.github.com/rate_limit
https://api.github.com/repos/{owner}/{repo}
https://api.github.com/search/repositories?q={query}{&page,per_page,sort,order}
https://api.github.com/user/repos{?type,page,per_page,sort}
https://api.github.com/user/starred{/owner}{/repo}
https://api.github.com/gists/starred
https://api.github.com/users/{user}
https://api.github.com/user/orgs
https://api.github.com/users/{user}/repos{?type,page,per_page,sort}
https://api.github.com/search/users?q={query}{&page,per_page,sort,order}
20-June-18 16:25:18:570 INFO main c.b.ResttemplateApplication:21 - about to call LoadGithubRepo.run()
20-June-18 16:25:19:069 INFO main c.b.ResttemplateApplication:36 -
List of Repositories
Repo 1::angular-word-merger
Repo 2::hansini-static-deploy
Repo 3::JUnit5-examples
Repo 4::okhttp
Repo 5::spring-boot-web-start
Repo 6::springboot_docker
20-June-18 16:25:19:071 INFO main c.b.ResttemplateApplication:57 - Started ResttemplateApplication in 3.382 seconds (JVM running for 6.625)
20-June-18 16:25:19:071 INFO main c.b.ResttemplateApplication:17 - completed executing ResttemplateApplication.run()