- \n
- Spring boot<\/em> is a module that provides rapid application development feature to the spring framework including auto-configuration<\/strong>, standalone-code<\/strong>, and production-ready<\/strong> code<\/li>\n
- It creates applications that are packaged as jar<\/em> and are directly started using embedded servlet container (such as Tomcat, Jetty or, Undertow). Thus, no need to deploy the war<\/em> files<\/li>\n
- It simplifies the maven configuration by providing the starter template and helps to resolve the dependency conflicts. It automatically identifies the required dependencies and imports them into the application<\/li>\n
- It helps in removing the boilerplate code, extra annotations, and xml configurations<\/li>\n
- It provides powerful batch processing and manages the rest endpoints<\/li>\n
- It provides an efficient jpa-starter library<\/em> to effectively connect the application with the relational databases<\/li>\n
- It offers a Microservice architecture and cloud configuration that manages all the application related configuration properties in a centralized manner<\/li>\n<\/ul>\n
1.2 MongoDB<\/h3>\n
- \n
- MongoDB is a high-performance NoSQL database<\/em> where each database has collections which in turn have documents. Each document has a different number of fields, size, content, and is stored in a JSON-like format (i.e. Binary JSON (BSN<\/a>)<\/li>\n
- The documents in MongoDB doesn\u2019t need to have a schema defined beforehand. Instead, the fields (i.e. records<\/em>) can be created on the go<\/li>\n
- Data model available within the MongoDB allows developers to represent the hierarchical relationships, store arrays, and other more complex structures easily<\/li>\n
- This NoSQL solution often comes with embedding, auto-sharding, and onboard replication for better scalability and high availability<\/li>\n<\/ul>\n
1.2.1 Why MongoDB?<\/h4>\n
- \n
- As a NoSQL type database, MongoDB stores the data in the form of a document. Thus, MongoDB offers more flexibility<\/li>\n
- This database supports search by field-name, range queries, and regular expressions. It often provides queries to return the particular fields inside the documents<\/li>\n
- MongoDB offers indexes<\/em> to improve the search performance<\/em> within the NoSQL database<\/li>\n
- To offer horizontal scalability, MongoDB uses sharding by splitting the data across the many MongoDB occurrences<\/li>\n
- Replication<\/strong>: MongoDB can give high availability with the replica sets<\/li>\n<\/ul>\n
Let us go ahead with the tutorial implementation but before going any further I\u2019m assuming that you\u2019re aware of the Spring boot basics.<\/p>\n
2. Spring Boot and MongoDB Sequence ID Generator<\/h2>\n
2.1 Application Pre-requisite<\/h3>\n
To start with this tutorial, I am hoping that you have the mongodb and mongodb graphical interface (i.e. mongo-express<\/em>) up and running in your localhost environment. For easy setup, I have these both up and running on the docker environment. You can execute the below script using the
docker-compose<\/code> command to get both containers running on docker in minutes. If you\u2019re doing it for the first time the mongodb and mongo-express docker images will be downloaded from the docker hub.<\/p>\ndocker-compose.yml<\/em><\/span><\/p>\n
services:\n mongodb:\n container_name: mongodb\n image: mongo\n environment:\n MONGO_INITDB_DATABASE: employees\n ports:\n - '27017:27017'\n express:\n container_name: express\n image: mongo-express\n ports:\n - '9001:8081'\n environment:\n - ME_CONFIG_MONGODB_SERVER=mongodb\n - ME_CONFIG_MONGODB_PORT=27017\n - ME_CONFIG_MONGODB_ENABLE_ADMIN=true\n depends_on:\n - mongodb\nversion: '3'\n<\/pre>\n
If everything goes well the containers would be started successfully as shown in Fig. 1. You can use the
docker ps -a<\/code> command to confirm that both the containers are started successfully. For further information on docker basics, you can navigate to this tutorial<\/a>.<\/p>\n\n![\"Spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/12\/docker-mongodb-up-img1.jpg\")
<\/a>Fig.1: MongoDB and Mongo-express containers on Docker<\/figcaption><\/figure>\n<\/div>\n Navigate to the following URL –
localhost:9001<\/code> to confirm that the mongo-express<\/em> is running and can bind with the mongodb successfully.<\/p>\n\n![\"Spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/12\/mongo-express-img1.jpg\")
<\/a>Fig. 2: Mongo express<\/figcaption><\/figure>\n<\/div>\n 2.2 Tools Used for Spring boot application and Project Structure<\/h3>\n
We are using Eclipse Kepler SR2, JDK 8, and Maven. In case you\u2019re confused about where you should create the corresponding files or folder, let us review the project structure of the spring boot application.<\/p>\n
\n![\"Spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/12\/springboot-and-mongodb-sequenceid-generator-project-guide-img1.jpg\")
<\/a>Fig. 3: Project structure<\/figcaption><\/figure>\n<\/div>\n Let us start building the application!<\/p>\n
3. Creating a Spring Boot application<\/h2>\n
Below are the steps involved in developing the application.<\/p>\n
3.1 Maven Dependency<\/h3>\n
Here, we specify the dependency for the Spring boot (Web and MongoDB), Lombok, and Java faker (for generating the mock data). Maven will automatically resolve the other dependencies. The updated<\/strong> file will have the following code.
<\/div> <\/div><\/p>\npom.xml<\/em><\/span><\/p>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\"\n xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 https:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n <modelVersion>4.0.0<\/modelVersion>\n <parent>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-parent<\/artifactId>\n <version>2.4.1<\/version>\n <relativePath\/> <!-- lookup parent from repository -->\n <\/parent>\n <groupId>com.springboot.mongodb<\/groupId>\n <artifactId>SpringbootandMongodbSequenceId<\/artifactId>\n <version>0.0.1-SNAPSHOT<\/version>\n <name>SpringbootandMongodbSequenceId<\/name>\n <description>Springboot and Mongodb SequenceId generator<\/description>\n\n <properties>\n <java.version>1.8<\/java.version>\n <\/properties>\n\n <dependencies>\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-data-mongodb<\/artifactId>\n <\/dependency>\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-web<\/artifactId>\n <\/dependency>\n\n <dependency>\n <groupId>com.github.javafaker<\/groupId>\n <artifactId>javafaker<\/artifactId>\n <version>1.0.2<\/version>\n <\/dependency>\n\n <dependency>\n <groupId>org.projectlombok<\/groupId>\n <artifactId>lombok<\/artifactId>\n <optional>true<\/optional>\n <\/dependency>\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-test<\/artifactId>\n <scope>test<\/scope>\n <\/dependency>\n <\/dependencies>\n\n <build>\n <plugins>\n <plugin>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-maven-plugin<\/artifactId>\n <configuration>\n <excludes>\n <exclude>\n <groupId>org.projectlombok<\/groupId>\n <artifactId>lombok<\/artifactId>\n <\/exclude>\n <\/excludes>\n <\/configuration>\n <\/plugin>\n <\/plugins>\n <\/build>\n\n<\/project>\n<\/pre>\n
3.2 Application properties file<\/h3>\n
Create a new properties file at the location:
SpringbootandMongodbSequenceId\/src\/main\/resources\/<\/code> and add the following code to it. Here we will define the application and mongo database configuration.<\/p>\napplication.properties<\/em><\/span><\/p>\n
# application configuration\nserver.port=9500\nspring.application.name=springboot-mongodb-sequence-id-example\n# spring boot and mongodb configuration\n# db name\nspring.data.mongodb.database=employees\n# hostname\nspring.data.mongodb.host=localhost\n# port number\nspring.data.mongodb.port=27017\n# sql query logging\nlogging.level.org.springframework.data.mongodb.core.MongoTemplate=debug\n<\/pre>\n
3.3 Java Classes<\/h3>\n
Let us write the important java class(es) involved in this application. For brevity, we will skip the following classes \u2013<\/p>\n
- \n
Employee.java<\/code> – The class contain the employee properties, constructor to set the properties, and getter methods<\/li>\nEmployeeRepo.java<\/code> – An interface that extends theMongoRepository<\/code> interface for the database operations<\/li>\nEmployeeService.java<\/code> – The class that calls the database layer methods<\/li>\nBeanConfig.java<\/code> – The class used to create the object for theFaker<\/code> class so that this class can be autowired<\/li>\n<\/ul>\n3.3.1 Implementation\/Main class<\/h4>\n
Add the following code to the main class to bootstrap the application from the main method. Always remember, the entry point of the spring boot application is the class containing
@SpringBootApplication<\/code> annotation and the static main method.<\/p>\nSpringbootandMongodbSequenceIdApplication.java<\/em><\/span><\/p>\n
package com.springboot.mongodb;\n\nimport lombok.extern.slf4j.Slf4j;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\n\n\/\/ Lombok annotation for logger\n@Slf4j\n\/\/ Spring annotation\n@SpringBootApplication\npublic class SpringbootandMongodbSequenceIdApplication {\n\n public static void main(String[] args) {\n SpringApplication.run(SpringbootandMongodbSequenceIdApplication.class, args);\n log.info(\"Springboot and mongodb sequence id generator started successfully.\");\n }\n\n}\n<\/pre>\n3.3.2 Database sequence model class<\/h4>\n
Add the following code to the sequence model class which will help store the sequence number in the mongodb collection (named –
db_sequence<\/code>).<\/p>\nDbSequence.java<\/em><\/span><\/p>\n
package com.springboot.mongodb.entity;\n\nimport lombok.AllArgsConstructor;\nimport lombok.Data;\nimport lombok.NoArgsConstructor;\nimport org.springframework.data.annotation.Id;\nimport org.springframework.data.mongodb.core.mapping.Document;\nimport org.springframework.data.mongodb.core.mapping.Field;\nimport org.springframework.stereotype.Component;\n\n\/\/ Mongodb annotation\n\/\/ marks a class for the domain object that we want to persist in the db\n@Document(collection = \"db_sequence\")\n\/\/ Lombok annotations\n@Data\n@NoArgsConstructor\n@AllArgsConstructor\n\/\/ Spring stereotype annotation\n@Component\npublic class DbSequence {\n\n @Id\n String id;\n \/\/ describes the field name as it will be represented in mongodb bson document\n \/\/ offers the name to be different than the field name of the class\n @Field(\"sequence_number\")\n int sequence;\n}\n<\/pre>\n3.3.3 Database sequence generator class<\/h4>\n
Add the following code to the service class which helps to generate the next
id<\/code> sequence for the employee record.<\/p>\nDbSequenceGenr.java<\/em><\/span><\/p>\n
package com.springboot.mongodb.service;\n\nimport com.springboot.mongodb.entity.DbSequence;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.data.mongodb.core.FindAndModifyOptions;\nimport org.springframework.data.mongodb.core.MongoOperations;\nimport org.springframework.data.mongodb.core.query.Criteria;\nimport org.springframework.data.mongodb.core.query.Query;\nimport org.springframework.data.mongodb.core.query.Update;\nimport org.springframework.stereotype.Service;\n\nimport java.util.Objects;\n\n@Service\npublic class DbSequenceGenr {\n\n @Autowired\n private MongoOperations operations;\n\n public int getNextSequence(final String sequenceName) {\n \/\/ get the sequence number\n final Query q = new Query(Criteria.where(\"id\").is(sequenceName));\n \/\/ increment the sequence number by 1\n \/\/ \"sequence\" should match the attribute value specified in DbSequence.java class.\n final Update u = new Update().inc(\"sequence\", 1);\n \/\/ modify in document\n final DbSequence counter = operations.findAndModify(q, u,\n FindAndModifyOptions.options().returnNew(true).upsert(true), DbSequence.class);\n\n return !Objects.isNull(counter) ? counter.getSequence() : 1;\n }\n}\n<\/pre>\n3.3.4 Default bootstrap class<\/h4>\n
Add the following code to the bootstrap class which helps to store the employee data into the mongodb collection (named –
employees<\/code>) at the application bootstrap.<\/p>\nDefaultEmployeeLoader.java<\/em><\/span><\/p>\n
package com.springboot.mongodb.bootstrap;\n\nimport com.github.javafaker.Faker;\nimport com.springboot.mongodb.entity.Employee;\nimport com.springboot.mongodb.service.DbSequenceGenr;\nimport com.springboot.mongodb.service.EmployeeService;\nimport lombok.extern.slf4j.Slf4j;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.CommandLineRunner;\nimport org.springframework.stereotype.Component;\n\nimport java.util.Random;\n\n\/\/ Lombok annotation for logger\n@Slf4j\n\/\/ Spring annotation\n@Component\npublic class DefaultEmployeesLoader implements CommandLineRunner {\n\n private static final String[] GENDER = {\"Male\", \"Female\", \"Transgender\"};\n private static final Random RANDOM = new Random();\n\n @Autowired\n private EmployeeService service;\n @Autowired\n private DbSequenceGenr sequenceGenr;\n @Autowired\n private Faker faker;\n\n \/\/ will add the dummy employee data in the mongodb collection\n \/\/ will be executed automatically on the application startup\n @Override\n public void run(String... args) {\n if (service.getCollectionCount() == 0) {\n log.info(\"Saving default employees in the collection\");\n for (int i=0; i<11; i++) {\n persist();\n }\n } else {\n log.info(\"Default employees are already present in the mongo collection\");\n }\n }\n\n \/\/ calls the service layer method which in turn calls the dao layer method\n \/\/ to save the employee record in the mongodb collection\n private void persist() {\n final Employee e = createEmployee();\n service.save(e);\n }\n\n \/\/ using the faker library to create some mock data for the employee model\n private Employee createEmployee() {\n final String firstName = faker.name().firstName();\n final String lastName = faker.name().lastName();\n final String gender = GENDER[RANDOM.nextInt(GENDER.length)];\n final String email = firstName.toLowerCase() + \".\" + lastName.toLowerCase() + \"@automation.com\";\n\n return Employee.builder()\n .id(sequenceGenr.getNextSequence(Employee.SEQUENCE_NUMBER))\n .firstName(firstName)\n .lastName(lastName)\n .gender(gender)\n .email(email)\n .phoneNumber(faker.phoneNumber().cellPhone())\n .homeAddress(faker.address().fullAddress())\n .build();\n }\n}\n<\/pre>\n3.3.5 Controller class<\/h4>\n
Add the following code to the controller class. The class has two methods that will fetch the employee’s information from the
employees<\/code> collection.<\/p>\nEmployeeCtrl.java<\/em><\/span><\/p>\n
package com.springboot.mongodb.controller;\n\nimport com.springboot.mongodb.entity.Employee;\nimport com.springboot.mongodb.service.EmployeeService;\nimport lombok.extern.slf4j.Slf4j;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.http.HttpStatus;\nimport org.springframework.http.ResponseEntity;\nimport org.springframework.web.bind.annotation.GetMapping;\nimport org.springframework.web.bind.annotation.PathVariable;\nimport org.springframework.web.bind.annotation.RequestMapping;\nimport org.springframework.web.bind.annotation.RestController;\n\nimport java.util.List;\n\n\/\/ Lombok annotation for logger\n@Slf4j\n\/\/ Spring annotations\n@RestController\n@RequestMapping(\"\/api\")\npublic class EmployeeCtrl {\n\n @Autowired\n private EmployeeService service;\n\n \/\/ Url - http:\/\/localhost:9500\/api\/employees\n @GetMapping(\"\/employees\")\n public ResponseEntity<List<Employee>> getAll() {\n log.info(\"Fetching all employees from the db\");\n return new ResponseEntity<>(service.getEmployees(), HttpStatus.OK);\n }\n\n \/\/ Url - http:\/\/localhost:9500\/api\/employees\/gender\/Female\n \/\/ where gender type can be - Male, Female, or Transgender\n @GetMapping(\"\/employees\/gender\/{type}\")\n public ResponseEntity<List<Employee>> getEmployeesByGender(@PathVariable(\"type\") String type) {\n log.info(\"Fetching all employees from the db where gender type = {}\", type);\n return new ResponseEntity<>(service.getEmployeesByGender(type), HttpStatus.OK);\n }\n}\n<\/pre>\n4. Run the Application<\/h2>\n
To execute the application, right-click on the
SpringbootandMongodbSequenceIdApplication.java<\/code> class,Run As -> Java Application<\/code>.<\/p>\n\n![\"Spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/12\/springboot-and-mongodb-sequenceid-generator-project-run-img1.jpg\")
<\/a>Fig. 4: Run the Application<\/figcaption><\/figure>\n<\/div>\n 5. Project Demo<\/h2>\n
When the application is started, the default data will be pushed to the mongodb collection (named –
employees<\/code>). You can hit the following URL –http:\/\/localhost:9001\/<\/code> to confirm that the default data has been successfully persisted in the mongodb collection.<\/p>\n![\"\"](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/12\/mongo-express-img2-1.jpg\")
<\/a>Fig. 5: Default data persisted successfully in employees collection<\/figcaption><\/figure>\n You are free to use postman<\/a> or any other tool of your choice to make a post request to the endpoint.<\/p>\n
Generate access token endpoint<\/em><\/span><\/p>\n
-- HTTP GET endpoint url \u2013\nhttp:\/\/localhost:9500\/api\/employees\n\n-- HTTP GET endpoint url (to fetch employees by gender)--\nhttp:\/\/localhost:9500\/api\/employees\/gender\/Female\n<\/pre>\n
That is all for this tutorial and I hope the article served you whatever you were looking for. Happy Learning and do not forget to share!<\/p>\n
6. Summary<\/h2>\n
In this section, you learned,<\/p>\n
- \n
- Spring boot and Mongodb introduction<\/li>\n
- Steps to run mongodb and mongo-express on Docker using the
docker-compose<\/code> command<\/li>\n- Steps to implement mongodb sequence id generator in Spring Boot<\/li>\n<\/ul>\n
You can download the sample application as an Eclipse project in the Downloads<\/a> section.<\/p>\n
<\/a>7. Download the Project<\/h2>\n
This was an example of implementing MongoDB sequence id generator in a Spring Boot application.<\/p>\n
- Steps to implement mongodb sequence id generator in Spring Boot<\/li>\n<\/ul>\n
- The documents in MongoDB doesn\u2019t need to have a schema defined beforehand. Instead, the fields (i.e. records<\/em>) can be created on the go<\/li>\n
- It creates applications that are packaged as jar<\/em> and are directly started using embedded servlet container (such as Tomcat, Jetty or, Undertow). Thus, no need to deploy the war<\/em> files<\/li>\n