In this lesson, we will study how easy it is to set up a Spring Boot project and make some RESTful services which interact with a database in under 20 minutes! Exactly, that’s how easy it is with Spring Boot. Spring Boot allows us to make production-grade Spring-based applications that you can \u201cjust run\u201d. The best part of a Spring boot application is that it needs very little configuration.<\/p>\n
2. Making the Spring Boot Project with Maven<\/h2>\n
We will be using one of the many Maven archetypes to create a sample project for our example. To create the project execute the following command in a directory that you will use as workspace:<\/p>\n
mvn archetype:generate -DgroupId=com.javacodegeeks.example -DartifactId=JCG-SpringBoot-example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false\n<\/pre>\nIf you are running maven for the first time, it will take a few seconds to accomplish the generate command because maven has to download all the required plugins and artifacts in order to make the generation task.<\/p>\n
Once you have created the project, feel free to open it in your favourite IDE. Next step is to add appropriate Maven Dependencies to the project. We will work with four dependencies in our project:<\/p>\n
- \n
spring-boot-starter-web<\/code>: This dependency marks this project as a Web project and it adds dependencies in order to create controllers and make Web-related classes.<\/li>\nspring-boot-starter-data-jpa<\/code>: This dependency provides the project with the JPA support where we can perform many Database related operations<\/li>\nh2<\/code>: H2 is an in-memory database which we will use to demonstrate DB operations in this lesson<\/li>\nspring-boot-starter-test<\/code>: This dependency collects all test related JARs into the project like JUnit<\/a> and Mockito<\/a>.<\/li>\n<\/ul>\nHere is the
pom.xml<\/code> file with the appropriate dependencies:<\/p>\npom.xml<\/em><\/span><\/p>\n
<parent>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-parent<\/artifactId>\n <version>1.5.10.RELEASE<\/version>\n <relativePath\/> <!-- lookup parent from repository -->\n<\/parent>\n\n<properties>\n <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\n <project.reporting.outputEncoding>UTF-8<\/project.reporting.outputEncoding>\n <java.version>1.8<\/java.version>\n<\/properties>\n\n<dependencies>\n\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-data-jpa<\/artifactId>\n <\/dependency>\n\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-web<\/artifactId>\n <\/dependency>\n\n <dependency>\n <groupId>com.h2database<\/groupId>\n <artifactId>h2<\/artifactId>\n <scope>runtime<\/scope>\n <\/dependency>\n \n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-test<\/artifactId>\n <scope>test<\/scope>\n <\/dependency>\n \n<\/dependencies>\n<\/pre>\n
To package the code into a JAR, we will make use of
spring-boot-maven-plugin<\/code> which is an excellent tool to manage packaging of the application itself into a JAR or a WAR. Here is how we can add into our dependency file:<\/p>\npom.xml<\/em><\/span><\/p>\n
<build>\n <plugins>\n <plugin>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-maven-plugin<\/artifactId>\n <\/plugin>\n <\/plugins>\n<\/build>\n<\/pre>\n
Find the latest Maven dependencies on Maven Central<\/a>.<\/p>\n
Finally, to understand all the JARs which are added to the project when we added this dependency, we can run a simple Maven command which allows us to see a complete Dependency Tree for a project when we add some dependencies to it. Here is a command which we can use:<\/p>\n
Check Dependency Tree<\/em><\/span><\/p>\n
mvn dependency:tree<\/pre>\n
When we run this command, it will show us the following Dependency Tree:<\/p>\n
Dependency Tree<\/em><\/span><\/p>\n
[INFO] --------------------\n[INFO] Building JCG-SpringBoot-example 1.0-SNAPSHOT\n[INFO] --------------------------------[ jar ]---------------------------------\n[INFO]\n[INFO] --- maven-dependency-plugin:2.10:tree (default-cli) @ JCG-SpringBoot-example ---\n[INFO] com.javacodegeeks.example:JCG-SpringBoot-example:jar:1.0-SNAPSHOT\n[INFO] +- org.springframework.boot:spring-boot-starter-data-jpa:jar:1.5.10.RELEASE:compile\n[INFO] | +- org.springframework.boot:spring-boot-starter:jar:1.5.10.RELEASE:compile\n[INFO] | | +- org.springframework.boot:spring-boot:jar:1.5.10.RELEASE:compile\n[INFO] | | +- org.springframework.boot:spring-boot-autoconfigure:jar:1.5.10.RELEASE:compile\n[INFO] | | +- org.springframework.boot:spring-boot-starter-logging:jar:1.5.10.RELEASE:compile\n[INFO] | | | +- ch.qos.logback:logback-classic:jar:1.1.11:compile\n[INFO] | | | | \\- ch.qos.logback:logback-core:jar:1.1.11:compile\n[INFO] | | | +- org.slf4j:jul-to-slf4j:jar:1.7.25:compile\n[INFO] | | | \\- org.slf4j:log4j-over-slf4j:jar:1.7.25:compile\n[INFO] | | \\- org.yaml:snakeyaml:jar:1.17:runtime\n[INFO] | +- org.springframework.boot:spring-boot-starter-aop:jar:1.5.10.RELEASE:compile\n[INFO] | | +- org.springframework:spring-aop:jar:4.3.14.RELEASE:compile\n[INFO] | | \\- org.aspectj:aspectjweaver:jar:1.8.13:compile\n[INFO] | +- org.springframework.boot:spring-boot-starter-jdbc:jar:1.5.10.RELEASE:compile\n[INFO] | | +- org.apache.tomcat:tomcat-jdbc:jar:8.5.27:compile\n[INFO] | | | \\- org.apache.tomcat:tomcat-juli:jar:8.5.27:compile\n[INFO] | | \\- org.springframework:spring-jdbc:jar:4.3.14.RELEASE:compile\n[INFO] | +- org.hibernate:hibernate-core:jar:5.0.12.Final:compile\n[INFO] | | +- org.jboss.logging:jboss-logging:jar:3.3.1.Final:compile\n[INFO] | | +- org.hibernate.javax.persistence:hibernate-jpa-2.1-api:jar:1.0.0.Final:compile\n[INFO] | | +- org.javassist:javassist:jar:3.21.0-GA:compile\n[INFO] | | +- antlr:antlr:jar:2.7.7:compile\n[INFO] | | +- org.jboss:jandex:jar:2.0.0.Final:compile\n[INFO] | | +- dom4j:dom4j:jar:1.6.1:compile\n[INFO] | | \\- org.hibernate.common:hibernate-commons-annotations:jar:5.0.1.Final:compile\n[INFO] | +- org.hibernate:hibernate-entitymanager:jar:5.0.12.Final:compile\n[INFO] | +- javax.transaction:javax.transaction-api:jar:1.2:compile\n[INFO] | +- org.springframework.data:spring-data-jpa:jar:1.11.10.RELEASE:compile\n[INFO] | | +- org.springframework.data:spring-data-commons:jar:1.13.10.RELEASE:compile\n[INFO] | | +- org.springframework:spring-orm:jar:4.3.14.RELEASE:compile\n[INFO] | | +- org.springframework:spring-context:jar:4.3.14.RELEASE:compile\n[INFO] | | +- org.springframework:spring-tx:jar:4.3.14.RELEASE:compile\n[INFO] | | +- org.springframework:spring-beans:jar:4.3.14.RELEASE:compile\n[INFO] | | +- org.slf4j:slf4j-api:jar:1.7.25:compile\n[INFO] | | \\- org.slf4j:jcl-over-slf4j:jar:1.7.25:compile\n[INFO] | \\- org.springframework:spring-aspects:jar:4.3.14.RELEASE:compile\n[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:1.5.10.RELEASE:compile\n[INFO] | +- org.springframework.boot:spring-boot-starter-tomcat:jar:1.5.10.RELEASE:compile\n[INFO] | | +- org.apache.tomcat.embed:tomcat-embed-core:jar:8.5.27:compile\n[INFO] | | | \\- org.apache.tomcat:tomcat-annotations-api:jar:8.5.27:compile\n[INFO] | | +- org.apache.tomcat.embed:tomcat-embed-el:jar:8.5.27:compile\n[INFO] | | \\- org.apache.tomcat.embed:tomcat-embed-websocket:jar:8.5.27:compile\n[INFO] | +- org.hibernate:hibernate-validator:jar:5.3.6.Final:compile\n[INFO] | | +- javax.validation:validation-api:jar:1.1.0.Final:compile\n[INFO] | | \\- com.fasterxml:classmate:jar:1.3.4:compile\n[INFO] | +- com.fasterxml.jackson.core:jackson-databind:jar:2.8.10:compile\n[INFO] | | +- com.fasterxml.jackson.core:jackson-annotations:jar:2.8.0:compile\n[INFO] | | \\- com.fasterxml.jackson.core:jackson-core:jar:2.8.10:compile\n[INFO] | +- org.springframework:spring-web:jar:4.3.14.RELEASE:compile\n[INFO] | \\- org.springframework:spring-webmvc:jar:4.3.14.RELEASE:compile\n[INFO] | \\- org.springframework:spring-expression:jar:4.3.14.RELEASE:compile\n[INFO] +- com.h2database:h2:jar:1.4.196:runtime\n[INFO] \\- org.springframework.boot:spring-boot-starter-test:jar:1.5.10.RELEASE:test\n[INFO] +- org.springframework.boot:spring-boot-test:jar:1.5.10.RELEASE:test\n[INFO] +- org.springframework.boot:spring-boot-test-autoconfigure:jar:1.5.10.RELEASE:test\n[INFO] +- com.jayway.jsonpath:json-path:jar:2.2.0:test\n[INFO] | \\- net.minidev:json-smart:jar:2.2.1:test\n[INFO] | \\- net.minidev:accessors-smart:jar:1.1:test\n[INFO] | \\- org.ow2.asm:asm:jar:5.0.3:test\n[INFO] +- junit:junit:jar:4.12:test\n[INFO] +- org.assertj:assertj-core:jar:2.6.0:test\n[INFO] +- org.mockito:mockito-core:jar:1.10.19:test\n[INFO] | \\- org.objenesis:objenesis:jar:2.1:test\n[INFO] +- org.hamcrest:hamcrest-core:jar:1.3:test\n[INFO] +- org.hamcrest:hamcrest-library:jar:1.3:test\n[INFO] +- org.skyscreamer:jsonassert:jar:1.4.0:test\n[INFO] | \\- com.vaadin.external.google:android-json:jar:0.0.20131108.vaadin1:test\n[INFO] +- org.springframework:spring-core:jar:4.3.14.RELEASE:compile\n[INFO] \\- org.springframework:spring-test:jar:4.3.14.RELEASE:test\n[INFO] ------------------------------------------------------------------------\n[INFO] BUILD SUCCESS\n[INFO] ------------------------------------------------------------------------\n<\/pre>\n
Noticed something? So many dependencies were added by just adding four dependencies to the project. Spring Boot collects all related dependencies itself and leave nothing for us in that matter. The biggest advantage is that all these dependencies are guranteed to be copatible with each other<\/strong>.
<\/div> <\/div><\/p>\n3. Gradle equivalent for the build file<\/h2>\n
Although Maven is an excellent build-system, if you prefer Gradle, here is the Gradle equivalent for the
pom.xml<\/code> build file:<\/p>\nbuild.gradle<\/em><\/span><\/p>\n
buildscript {\n\text {\n\t\tspringBootVersion = '1.5.10.RELEASE'\n\t}\n\trepositories {\n\t\tmavenCentral()\n\t}\n\tdependencies {\n\t\tclasspath(\"org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}\")\n\t}\n}\n\napply plugin: 'java'\napply plugin: 'eclipse'\napply plugin: 'org.springframework.boot'\n\ngroup = 'com.javacodegeeks.example'\nversion = '0.0.1-SNAPSHOT'\nsourceCompatibility = 1.8\n\nrepositories {\n\tmavenCentral()\n}\n\n\ndependencies {\n\tcompile('org.springframework.boot:spring-boot-starter-data-jpa')\n\tcompile('org.springframework.boot:spring-boot-starter-web')\n\truntime('com.h2database:h2')\n\ttestCompile('org.springframework.boot:spring-boot-starter-test')\n}\n<\/pre>\nWe have exhibited exactly the same dependencies and versions to provide an exact equivalent.<\/p>\n
4. Project Structure<\/h2>\n
Before we move on and start working on the code for the project, let\u2019s present here the projet structure we will have once we\u2019re finished adding all the code to the project:<\/p>\n
![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/project-structure.png\")
<\/a>Spring Boot project Structure<\/figcaption><\/figure><\/p>\n We have divided the project into multiple packages so that the principle of separation of concern<\/a> is followed and code remains modular.<\/p>\n
5. Defining an Entity<\/h2>\n
Let\u2019s look at how this can be done:<\/p>\n
Person.java<\/em><\/span><\/p>\n
package com.javacodegeeks.example.model;\n\nimport javax.persistence.Entity;\nimport javax.persistence.GeneratedValue;\nimport javax.persistence.Id;\n\n@Entity\npublic class Person {\n\n @Id\n @GeneratedValue\n private Long id;\n private String name;\n private int age;\n\n \/\/standard getters and setters\n \n @Override\n public String toString() {\n return String.format(\"Person{id=%d, name='%s', age=%d}\", id, name, age);\n }\n}\n<\/pre>\nWe omitted standard getters and setters for brevity but they are necessary to be made as Jackson uses them during Serialization and Deserialization<\/a> of an Object.<\/p>\n
The
@Entity<\/code> annotation marks this POJO as an object which will be managed by the Spring Data APIs and its fields will be treated as table columns (unless marked transient<\/a>).<\/p>\nFinally, we added a custom implementation for the
toString()<\/code> method so that we can print-related data when we test our application.<\/p>\n6. Defining JPA Repository to access H2 Database<\/h2>\n
JPA provides us with a very simple way of defining a JPA Repository interface.<\/p>\n
Before getting to know how to define a JPA Repository, we need to remember that each JPA interface is only made to interact with a single Entity of Database Table when JPA-related functionality is leveraged. We will understand this deeply if we have a look at the interface definition:<\/p>\n
PersonRepository.java<\/em><\/span><\/p>\n
package com.javacodegeeks.example.repository;\n\nimport com.javacodegeeks.example.model.Person;\nimport org.springframework.data.jpa.repository.JpaRepository;\nimport org.springframework.stereotype.Repository;\n\n@Repository\npublic interface PersonRepository extends JpaRepository<Person, Long> { }\n<\/pre>\nAlthough above interface definition is empty, we still have some points which we need to understand:<\/p>\n
- \n
@Repository<\/code> annotation marks this interface as a Spring Bean which is initialised on application startup. With this annotation, Spring takes care of managing exception database interaction throws gracefully<\/li>\n- We used
Person<\/code> as a parameter to signify that this JPA interface will manage thePerson<\/code> Entity<\/li>\n- Finally, we also passed the data type
Long<\/code> as a parameter. This signifies that thePerson<\/code> Entity contains a unique identifier which is for the typeLong<\/code>.<\/li>\n<\/ul>\n7. Making a RESTful Controller<\/h2>\n
A RESTful Controller where we expose the application’s data to a client. We will make use of several HTTP verbs like GET, POST, PUT and DELETE to support features associated with them.<\/p>\n
To start, let’s define a
PersonController<\/code> class which is marked as@RestController<\/code>. The@RestController<\/code> annotation signals the Spring Container that any exceptions which are raised in this class are Ok to be passed on to the client itself. This is a different behaviour in comparison to a Repository bean.<\/p>\nPersonController.java<\/em><\/span><\/p>\n
package com.javacodegeeks.example.controller;\n\nimport com.javacodegeeks.example.model.Person;\nimport com.javacodegeeks.example.repository.PersonRepository;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.web.bind.annotation.*;\n\nimport java.util.List;\n\n@RestController\npublic class PersonController {\n\n private final Logger LOG = LoggerFactory.getLogger(getClass().getName());\n\n private final PersonRepository personRepository;\n\n @Autowired\n public PersonController(PersonRepository personRepository) {\n this.personRepository = personRepository;\n }\n\n ...\n}\n<\/pre>\nLet’s provide some power to this Controller by adding specific APIs which perform actual operations.<\/p>\n
7.1 Inserting data with POST<\/h3>\n
We will start by adding an API through which we can add data to the H2 Database. As this method accepts a
Person<\/code> Object in its@RequestBody<\/code>, the JSON for Person object must be passed to the API in the request.<\/p>\nPersonController.java<\/em><\/span><\/p>\n
@RequestMapping(value = \"\", method = RequestMethod.POST)\npublic Person createPerson(@RequestBody Person person) {\n LOG.info(\"Saving Person: {}.\", person);\n personRepository.save(person);\n LOG.info(\"Person saved: {}.\", person);\n return person;\n}\n<\/pre>\nWe made use of the
Personrepository<\/code> bean to access a method which is pre-defined in theJpaRepository<\/code> interface we defined earlier to deal withPerson<\/code> Entity.<\/p>\nIn the coming section, we will try this API in a REST client, Postman.<\/p>\n
7.2 Constructing a GET API<\/h3>\n
Now that we have an API to insert data into the Database, we can ow construct an API to Get the Person Object with its ID. Here, the
personId<\/code> is passed as aPathVariable<\/code>:<\/p>\nPersonController.java<\/em><\/span><\/p>\n
@RequestMapping(value = \"\/{personId}\", method = RequestMethod.GET)\npublic Person getPerson(@PathVariable Long personId) {\n Person person = personRepository.findOne(personId);\n LOG.info(\"Got person from DB: {}.\", person);\n return person;\n}\n<\/pre>\nTo get all data which is present in the database, we will make yet another GET API to get all data from the database:<\/p>\n
PersonController.java<\/em><\/span><\/p>\n
@RequestMapping(value = \"\/all\", method = RequestMethod.GET)\npublic List<Person> getAllPerson() {\n List<Person> persons = personRepository.findAll();\n LOG.info(\"Getting all Data: {}.\", persons);\n return persons;\n}\n<\/pre>\nIt just makes use of the JPA Repository’s
findAll<\/code> method to get all data ofPerson<\/code> in DB and collect it into a List.<\/p>\n7.3 Updating data with PUT<\/h3>\n
We will now allow a client to update the existing data from the database. For this, we make use of
save<\/code> method again. Whensave<\/code> method sees that the JSON object is populated with theid<\/code> field, it first finds the Object with that ID and then it updates the fields provided.<\/p>\nPersonController.java<\/em><\/span><\/p>\n
@RequestMapping(value = \"\", method = RequestMethod.PUT)\npublic Person editPerson(@RequestBody Person person) {\n LOG.info(\"Updating Person: {}.\", person);\n personRepository.save(person);\n LOG.info(\"Person updated: {}.\", person);\n return person;\n}\n<\/pre>\n7.4 Deleting data with DELETE<\/h3>\n
We will now have a final operation of deleting the data when a person’s ID is passed as a
PathVariable<\/code>:<\/p>\nPersonController.java<\/em><\/span><\/p>\n
@RequestMapping(value = \"\/{personId}\", method = RequestMethod.DELETE)\npublic void deletePerson(@PathVariable Long personId) {\n LOG.info(\"Deleting Person with ID {}.\", personId);\n personRepository.delete(personId);\n LOG.info(\"Person deleted.\");\n}\n<\/pre>\n8. Including a Request Interceptor<\/h2>\n
Although this is not strictly needed, we will include a Request Interceptor in this example as well. A Request Interceptor allows us to do something with the request object before it reaches the Controller. Once the Controller is done with the request and returns the response, that response object again passes through the Request Interceptor. Let’s define the Request Interceptor here:<\/p>\n
JCGRequestInterceptor.java<\/em><\/span><\/p>\n
package com.javacodegeeks.example.interceptor;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport org.springframework.stereotype.Component;\nimport org.springframework.web.servlet.ModelAndView;\nimport org.springframework.web.servlet.handler.HandlerInterceptorAdapter;\n\nimport javax.servlet.http.HttpServletRequest;\nimport javax.servlet.http.HttpServletResponse;\n\n@Component\npublic class JCGRequestInterceptor extends HandlerInterceptorAdapter {\n\n private final Logger LOG = LoggerFactory.getLogger(getClass().getName());\n\n @Override\n public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {\n LOG.info(\"Incoming request.\");\n return super.preHandle(request, response, handler);\n }\n\n @Override\n public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {\n LOG.info(\"Outgoing request.\");\n super.postHandle(request, response, handler, modelAndView);\n }\n}\n<\/pre>\n9. Running the Project with Maven<\/h2>\n
Before we run the project, we need to define a main class for the project as well. Here is the main class definition with the Request Interceptor bean:<\/p>\n
Running the Project<\/em><\/span><\/p>\n
package com.javacodegeeks.example;\n\nimport com.javacodegeeks.example.interceptor.JCGRequestInterceptor;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.context.annotation.Bean;\n\n@SpringBootApplication\npublic class BootApp {\n\n public static void main(String[] args) {\n SpringApplication.run(BootApp.class, args);\n }\n\n @Bean\n public JCGRequestInterceptor requestInterceptor() {\n return new JCGRequestInterceptor();\n }\n}\n<\/pre>\nNow that it is done, we can run our project. Running the application is easy with maven, just use the following command:<\/p>\n
Running the Project<\/em><\/span><\/p>\n
mvn spring-boot:run\n<\/pre>\n
Now that the project is running, we can use Postman tool to access APIs and see if they are working as expected.<\/p>\n
10. Accessing APIs in Postman<\/h2>\n
We will start by inserting some data into the H2 Database wth the
POST<\/code> API we made:<\/p>\n![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-post-data.png\")
<\/a>Inserting Data into H2<\/figcaption><\/figure><\/p>\n Now, we can get this Person object with ID JPA assigned it, i.e. 1:<\/p>\n
![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-get-by-id.png\")
<\/a>Get Object by ID<\/figcaption><\/figure><\/p>\n We can also try the Get All data API to see if this Object is returned or not:<\/p>\n
![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-get-all-data.png\")
<\/a>Get All Data<\/figcaption><\/figure><\/p>\n Let’s update one of the field of the object we created:<\/p>\n
![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-update-data.png\")
<\/a>Update Data<\/figcaption><\/figure><\/p>\n Finally, we try to delete the data by passing the ID in the URL as a
PathVariable<\/code>:<\/p>\n![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-delete.png\")
<\/a>Delete Data<\/figcaption><\/figure>
\n[ulp id=’oiCtu6x3AwpaVNPI’]
\n <\/p>\n11. Including and Running Unit Tests<\/h2>\n
Any Spring application is incomplete without at least one unit-test case. In this example, we will include a single unit-test case which is production ready. Here it goes:<\/p>\n
ControllerTests.java<\/em><\/span><\/p>\n
package com.javacodegeeks.example;\n\nimport com.javacodegeeks.example.controller.PersonController;\nimport com.javacodegeeks.example.repository.PersonRepository;\nimport org.junit.Before;\nimport org.junit.Test;\nimport org.junit.runner.RunWith;\nimport org.mockito.InjectMocks;\nimport org.mockito.Mock;\nimport org.mockito.MockitoAnnotations;\nimport org.springframework.test.context.junit4.SpringJUnit4ClassRunner;\nimport org.springframework.test.web.servlet.MockMvc;\nimport org.springframework.test.web.servlet.setup.MockMvcBuilders;\n\nimport static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;\nimport static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;\n\n@RunWith(SpringJUnit4ClassRunner.class)\npublic class ControllerTest {\n\n private MockMvc mockMvc;\n\n @InjectMocks\n private PersonController controller;\n\n @Mock\n private PersonRepository repository;\n\n @Before\n public void setUp() {\n MockitoAnnotations.initMocks(this);\n controller = new PersonController(repository);\n mockMvc = MockMvcBuilders.standaloneSetup(controller).build();\n }\n\n @Test\n public void getAllPerson_Pass() throws Exception {\n mockMvc.perform(\n get(\"\/all\"))\n .andExpect(status().is2xxSuccessful());\n }\n}\n<\/pre>\nWe did several things in above sample test-case. Let’s understand these one at a time:<\/p>\n
- \n
- I marked this class a
@RunWith(SpringJUnit4ClassRunner.class)<\/code> annotation which provides the test case with a runner.<\/li>\n- When we use Mockito, we need to enable its annotations. This is done by the
initMocks(...)<\/code> method call.<\/li>\n- We used the
mockMvc<\/code> object’sget<\/code> nethod to check the status code returned by the\/all<\/code> GET API and compared it to any2XX<\/code> status code.<\/li>\n<\/ul>\nWhen we ran this test-case in IntelliJ, we see the following output:<\/p>\n
![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-test-case-pass.png\")
<\/a>Running Spring Boot test case<\/figcaption><\/figure><\/p>\n Seeing a test-case with green on it is an excellent feeling, isn’t it?<\/p>\n
12. Using Spring Boot CLI<\/h2>\n
Spring Boot Command Line Interface is a software which we can use to run and test Spring Boot applications from the command line. Spring Boot CLI internally makes use of Spring Boot starters and AutoConfiguration components to collect the required dependencies and run the application.<\/p>\n
To start using CLI, quickest way is to download the ZIP<\/a> and change into the bin directory and check the command as shown:<\/p>\n
- When we use Mockito, we need to enable its annotations. This is done by the
- We used
![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/spring-cli.png\")
<\/a>![\"\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/springboot-running-helloworld.png\")
<\/a>