Spring Boot 集成 MyBatis、Redis、RabbitMQ 和 Elasticsearch 教程

1. 环境准备#

确保你的开发环境已经安装了以下软件：

Java Development Kit (JDK) 1.8 或更高版本
Apache Maven 或 Gradle 作为构建工具
一个文本编辑器或IDE（如IntelliJ IDEA或Eclipse）
Redis、RabbitMQ 和 Elasticsearch 服务器

2. 创建项目#

使用 Spring Initializr 创建一个新项目，并添加以下依赖：

Spring Web
MyBatis-Spring-Boot-Starter
Spring Boot Redis Starter
Spring Boot RabbitMQ Starter
Spring Data Elasticsearch

3. 配置数据库#

在 application.properties 文件中配置数据库连接信息：

1
spring.datasource.url=jdbc:mysql://localhost:3306/your_database
2
spring.datasource.username=your_username
3
spring.datasource.password=your_password
4
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
5

6
mybatis.configuration.map-underscore-to-camel-case=true
7
mybatis.configuration.use-generated-keys=true
8
mybatis.configuration.default-statement-timeout=30

4. 配置 MyBatis#

创建 mybatis-config.xml 文件在 src/main/resources 目录下，并配置 MyBatis 相关设置。

5. 配置 Redis#

在 application.properties 文件中添加 Redis 配置：

1
spring.redis.host=localhost
2
spring.redis.port=6379

6. 配置 RabbitMQ#

在 application.properties 文件中添加 RabbitMQ 配置：

1
spring.rabbitmq.host=localhost
2
spring.rabbitmq.port=5672
3
spring.rabbitmq.username=guest
4
spring.rabbitmq.password=guest

7. 配置 Elasticsearch#

在 application.properties 文件中添加 Elasticsearch 配置：

1
spring.elasticsearch.rest.uris=http://localhost:9200

8. 实体类定义#

定义一个简单的用户实体 User.java：

1
package com.example.demo.entity;
2

3
import javax.persistence.Entity;
4
import javax.persistence.Id;
5
import javax.persistence.Table;
6

7
@Entity
8
@Table(name = "user")
9
public class User {
10
    @Id
11
    private Long id;
12
    private String name;
13
    private String email;
14

15
    // Getters and Setters
16
}

9. MyBatis Mapper 接口#

创建一个 MyBatis Mapper 接口 UserMapper.java：

1
package com.example.demo.mapper;
2

3
import com.example.demo.entity.User;
4
import org.apache.ibatis.annotations.Mapper;
5
import org.apache.ibatis.annotations.Select;
6

7
import java.util.List;
8

9
@Mapper
10
public interface UserMapper {
11
    @Select("SELECT * FROM user")
12
    List<User> findAll();
13
}

10. Redis 配置#

创建一个配置类 RedisConfig.java 来配置 Redis 序列化：

1
package com.example.demo.config;
2

3
import org.springframework.context.annotation.Bean;
4
import org.springframework.context.annotation.Configuration;
5
import org.springframework.data.redis.connection.RedisConnectionFactory;
6
import org.springframework.data.redis.core.RedisTemplate;
7
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
8
import org.springframework.data.redis.serializer.StringRedisSerializer;
9

10
@Configuration
11
public class RedisConfig {
12
    @Bean
13
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
14
        RedisTemplate<String, Object> template = new RedisTemplate<>();
15
        template.setConnectionFactory(connectionFactory);
16
        template.setKeySerializer(new StringRedisSerializer());
17
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
18
        return template;
19
    }
20
}

11. RabbitMQ 配置#

创建一个配置类 RabbitMQConfig.java 来配置 RabbitMQ 交换机和队列：

1
package com.example.demo.config;
2

3
import org.springframework.amqp.core.*;
4
import org.springframework.context.annotation.Bean;
5
import org.springframework.context.annotation.Configuration;
6

7
@Configuration
8
public class RabbitMQConfig {
9

10
    @Bean
11
    public Queue userQueue() {
12
        return new Queue("userQueue");
13
    }
14

15
    @Bean
16
    public DirectExchange userExchange() {
17
        return new DirectExchange("userExchange");
18
    }
19

20
    @Bean
21
    public Binding userBinding(Queue userQueue, DirectExchange userExchange) {
22
        return BindingBuilder.bind(userQueue).to(userExchange).with("userRoutingKey");
23
    }
24
}

12. Elasticsearch 配置#

创建一个 Elasticsearch 配置类 ElasticsearchConfig.java：

1
package com.example.demo.config;
2

3
import org.springframework.context.annotation.Bean;
4
import org.springframework.context.annotation.Configuration;
5
import org.springframework.data.elasticsearch.client.ClientConfiguration;
6
import org.springframework.data.elasticsearch.client.ElasticsearchRestClient;
7
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
8
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
9
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
10

11
@Configuration
12
public class ElasticsearchConfig extends AbstractElasticsearchConfiguration {
13

14
    @Override
15
    @Bean
16
    public ClientConfiguration clientConfiguration() {
17
        return ClientConfiguration.builder()
18
                .connectedTo("localhost:9200")
19
                .build();
20
    }
21

22
    @Override
23
    @Bean
24
    public ElasticsearchRestClient elasticsearchClient(ClientConfiguration clientConfiguration) {
25
        return new ElasticsearchRestClientBuilder(clientConfiguration).build();
26
    }
27

28
    @Override
29
    @Bean
30
    public ElasticsearchOperations elasticsearchTemplate() {
31
        return new ElasticsearchRestTemplate(elasticsearchClient(clientConfiguration()));
32
    }
33
}

13. 业务逻辑实现#

创建业务服务 UserService.java 来集成 MyBatis、Redis、RabbitMQ 和 Elasticsearch：

1
package com.example.demo.service;
2

3
import com.example.demo.entity.User;
4
import com.example.demo.mapper.UserMapper;
5
import org.springframework.amqp.rabbit.core.RabbitTemplate;
6
import org.springframework.beans.factory.annotation.Autowired;
7
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
8
import org.springframework.data.redis.core.RedisTemplate;
9
import org.springframework.stereotype.Service;
10

11
import java.util.List;
12

13
@Service
14
public class UserService {
15
    @Autowired
16
    private UserMapper userMapper;
17
    @Autowired
18
    private RedisTemplate<String, Object> redisTemplate;
19
    @Autowired
20
    private RabbitTemplate rabbitTemplate;
21
    @Autowired
22
    private ElasticsearchOperations elasticsearchOperations;
23

24
    public List<User> findAll() {
25
        // 从 Redis 获取
26
        List<User> users = (List<User>) redisTemplate.opsForList().range("users", 0, -1);
27
        if (users == null || users.isEmpty()) {
28
            // 从数据库获取
29
            users = userMapper.findAll();
30
            // 存储到 Redis
31
            redisTemplate.opsForList().rightPushAll("users", users);
32
        }
33
        return users;
34
    }
35

36
    public void create(User user) {
37
        // 存储到数据库
38
        userMapper.insert(user);
39
        // 发送消息到 RabbitMQ
40
        rabbitTemplate.convertAndSend("userExchange", "userRoutingKey", user);
41
        // 索引到 Elasticsearch
42
        elasticsearchOperations.save(user);
43
    }
44
}

14. 控制器#

创建一个控制器 UserController.java 来处理 HTTP 请求：

1
package com.example.demo.controller;
2

3
import com.example.demo.entity.User;
4
import com.example.demo.service.UserService;
5
import org.springframework.beans.factory.annotation.Autowired;
6
import org.springframework.web.bind.annotation.*;
7

8
import java.util.List;
9

10
@RestController
11
@RequestMapping("/api/users")
12
public class UserController {
13
    @Autowired
14
    private UserService userService;
15

16
    @GetMapping
17
    public List<User> listAll() {
18
        return userService.findAll();
19
    }
20

21
    @PostMapping
22
    public void create(@RequestBody User user) {
23
        userService.create(user);
24
    }
25
}

15. 启动类#

DemoApplication.java 是Spring Boot的启动类：

1
package com.example.demo;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
@SpringBootApplication
7
public class DemoApplication {
8
    public static void main(String[] args) {
9
        SpringApplication.run(DemoApplication.class, args);
10
    }
11
}

16. 运行和测试#

运行 DemoApplication.java 类启动应用。
使用Postman或任何HTTP客户端测试API。

17. 打包和部署#

使用Maven或Gradle命令打包应用。
将打包好的JAR文件部署到服务器。

18. 进阶#

考虑使用Spring Security进行用户认证和授权。
优化RabbitMQ的消息处理逻辑，确保消息的可靠传递。
使用Elasticsearch进行全文搜索功能的实现。

这个教程提供了一个集成了MyBatis、Redis、RabbitMQ和Elasticsearch的Spring Boot应用的基础框架。你可以在此基础上扩展更多功能和特性。