Spring Boot - CRUD Operations using MongoDB

Creating CRUD operations with MongoDB in Spring Boot is quite similar to using relational databases with Spring Data JPA. However, instead of JPA, you'll use Spring Data MongoDB. Here's how you can set it up:

1. Setup Dependencies

Firstly, add the necessary dependencies to your pom.xml:

<!-- Spring Boot Starter Data MongoDB -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

2. Configure MongoDB

Specify MongoDB properties in application.properties or application.yml:

# For local MongoDB instance
spring.data.mongodb.uri=mongodb://localhost:27017/mydatabase

3. Create Document

Instead of @Entity, use @Document for MongoDB:

@Document(collection = "users")
public class User {

    @Id
    private String id;
    private String name;
    private String email;

    // Getters, Setters, Constructors, hashCode, equals, toString
}

4. Create Repository

Just like JPA, Spring Data MongoDB offers a MongoRepository:

public interface UserRepository extends MongoRepository<User, String> {
}

5. Create Service

The service layer remains largely the same:

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(String id) {
        return userRepository.findById(id).orElse(null);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(String id, User user) {
        if (userRepository.existsById(id)) {
            user.setId(id);
            return userRepository.save(user);
        } else {
            return null;
        }
    }

    public void deleteUser(String id) {
        userRepository.deleteById(id);
    }
}

6. Create Controller

The controller remains the same as the previous CRUD example:

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable String id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable String id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable String id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

Once you've set up all of these components, you'll have a basic CRUD API backed by MongoDB in a Spring Boot application. Remember to run a MongoDB instance, either locally or via a cloud provider, so your Spring Boot application can connect to it.

MongoDB repository in Spring Boot CRUD operations:
- Create a MongoDB repository interface extending MongoRepository for CRUD operations.
- Example:
```
public interface UserRepository extends MongoRepository<User, String> {
    // Custom query methods if needed
}
```

RESTful CRUD operations with Spring Boot and MongoDB:

Implement RESTful CRUD operations using Spring Boot and MongoDB.

Example:

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserRepository userRepository;

    // Implement CRUD operations using UserRepository
}

Connecting Spring Boot to MongoDB for CRUD operations:
- Configure MongoDB connection properties in application.properties or application.yml.
- Example (application.properties):
```
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
```

MongoTemplate for custom MongoDB CRUD operations in Spring Boot:

Use MongoTemplate for custom MongoDB CRUD operations.

Example:

@Autowired
private MongoTemplate mongoTemplate;

public void customMongoOperation() {
    // Implement custom MongoDB operation using mongoTemplate
}

Handling relationships in Spring Boot MongoDB CRUD operations:
- Define and manage relationships between MongoDB entities using @DBRef or other annotations.
- Example:
```
public class Order {
    @DBRef
    private User user;
    // Other fields and methods
}
```

Querying and filtering data in Spring Boot MongoDB CRUD:

Use query methods or @Query annotations in the repository for customized queries.

Example:

public interface UserRepository extends MongoRepository<User, String> {
    List<User> findByAgeGreaterThan(int age);
    // Custom query methods
}

Transaction management with MongoDB in Spring Boot:
- Handle transactions for MongoDB operations using @Transactional or TransactionTemplate.
- Example:
```
@Transactional
public void performTransaction() {
    // MongoDB operations within a transaction
}
```