springboot+dubbo+redis+RabbitMQ 项目整合实例

来源:https://blog.csdn.net/qq_28125445

作者:夏佐

关于springboot，之前零零碎碎地写了一些，今天从项目实战角度给大家分享一下我的一点经验。

话不多说，先从项目的目录结构讲起。（文章最后贴了源码下载地址）

如图：

项目分层：

parent（顶级）pom

-- api（公共API、DTO等）jar

-- foundation（公共基设）jar

-- modules（前端consumer）pom

-- www（官网）jar

-- admin（后台）jar

-- ......

-- service(provider，本应该拆分，我这里只写了一个) pom

-- user（用户中心）jar

-- order（订单中心）jar

-- ......

所用技术： springboot、dubbo、zookeeper、mybatis、redis、RabbitMQ、druid、swagger等

效果截图：

自动生成的swagger接口文档，可直接测试：

使用druid的SQL监控，记录慢SQL：

dubbo admin：

RabbitMQ admin：

项目截图：

部分代码：

消费者（暴露给前端的controller）

package com.ysk.admin.controller;
import java.util.List;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.dubbo.config.annotation.Reference;
import com.ysk.api.model.User;
import com.ysk.api.service.UserService;
@RestController
@RequestMapping("/")
public class TestController {
@Reference(version = "1.0.0")
private UserService testService;
@GetMapping("hello")
public String hello() {
return testService.sayHello("Hello springboot and dubbo!");
}
@GetMapping("user")
public User user() {
return testService.findUser();
}
@GetMapping("list")
public List<User> list(@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int pageSize) {
return testService.getUser(page, pageSize);
}
@RequestMapping(value = "add", method = RequestMethod.POST)
public List<User> add(@RequestBody User user) {
System.out.println(user.toString());
return null;
}
// 从redis获取某个用户
@RequestMapping(value = "getuserfromredis", method = RequestMethod.GET)
public User getRedis(@RequestParam String key) {
return testService.getUserForRedis(key);
}
}

package com.ysk.admin;
import org.apache.log4j.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;
@SpringBootApplication
@ImportResource({ "classpath:config/spring-dubbo.xml" })
public class App {
private static Logger logger = Logger.getLogger(App.class);
public static void main(String[] args) {
SpringApplication.run(App.class, args);
logger.info("SpringBoot Start Success");
}
}

提供者（具体的实现与逻辑）

package com.ysk.service.impl;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.alibaba.dubbo.config.annotation.Service;
import com.github.pagehelper.PageHelper;
import com.ysk.api.model.User;
import com.ysk.api.service.UserService;
import com.ysk.resource.UserMapper;
import com.ysk.service.RedisService;
@Service(version = "1.0.0", interfaceClass = UserService.class)
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Autowired
private RedisService redisService;
@Override
public String sayHello(String str) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
return dateFormat.format(new Date()) + ": " + str;
}
@Override
public User findUser() {
User user = new User();
user.setId(1001);
user.setName("张三");
user.setAge(20);
user.setAddress("上海徐汇");
return user;
}
@Override
public List<User> getUser(int page, int pageSize) {
PageHelper.startPage(page, pageSize);
return userMapper.getUsers();
}
@Override
public User getUserForRedis(String key) {
User user = new User();
user.setId(1008);
user.setName("刘德华");
user.setAge(60);
user.setAddress("中国香港");
redisService.set(user.getId() + "", user);
return (User) redisService.get(key);
}
}

package com.ysk.config;
import java.util.Properties;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.interceptor.TransactionInterceptor;
@Configuration
public class TransactionConfiguration {
@Bean(name = "transactionInterceptor")
public TransactionInterceptor transactionInterceptor(PlatformTransactionManager platformTransactionManager) {
TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
// 事务管理器
transactionInterceptor.setTransactionManager(platformTransactionManager);
Properties transactionAttributes = new Properties();
// 新增
transactionAttributes.setProperty("insert*", "PROPAGATION_REQUIRED,-Throwable");
// 修改
transactionAttributes.setProperty("update*", "PROPAGATION_REQUIRED,-Throwable");
// 删除
transactionAttributes.setProperty("delete*", "PROPAGATION_REQUIRED,-Throwable");
// 查询
transactionAttributes.setProperty("select*", "PROPAGATION_REQUIRED,-Throwable, readOnly");
transactionInterceptor.setTransactionAttributes(transactionAttributes);
return transactionInterceptor;
}
// 代理到ServiceImpl的Bean
@Bean
public BeanNameAutoProxyCreator transactionAutoProxy() {
BeanNameAutoProxyCreator transactionAutoProxy = new BeanNameAutoProxyCreator();
transactionAutoProxy.setProxyTargetClass(true);
transactionAutoProxy.setBeanNames("*ServiceImpl");
transactionAutoProxy.setInterceptorNames("transactionInterceptor");
return transactionAutoProxy;
}
}

package com.ysk.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfiguration {
// 声明队列
@Bean
public Queue queue1() {
return new Queue("hello.queue1", true); // true表示持久化该队列
}
@Bean
public Queue queue2() {
return new Queue("hello.queue2", true);
}
// 声明交互器
@Bean
TopicExchange topicExchange() {
return new TopicExchange("topicExchange");
}
// 绑定
@Bean
public Binding binding1() {
return BindingBuilder.bind(queue1()).to(topicExchange()).with("key.1");
}
@Bean
public Binding binding2() {
return BindingBuilder.bind(queue2()).to(topicExchange()).with("key.#");
}
}

package com.ysk.config;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
@Bean
public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
CacheManager cacheManager = new RedisCacheManager(redisTemplate);
return cacheManager;
}
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
}

spring.datasource.url = jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driverClassName = com.mysql.jdbc.Driver
#连接池的配置信息
spring.datasource.initial-size=5
spring.datasource.min-idle=5
spring.datasource.max-idle=8
spring.datasource.max-active=20
spring.datasource.max-wait=60000
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.filters=stat,wall,log4j
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=200
server.port=8082
server.context-path=/
logging.level.com.ysk.resource=debug
# MyBatis 配置
mybatis.mapper-locations=classpath:/mapper/*Mapper.xml
mybatis.type-aliases-package=com.ysk.api.model
#druid 配置
druid.username=admin
druid.password=admin
druid.allow=127.0.0.1
druid.reset.enable=true
#redis
spring.redis.hostName=127.0.0.1
spring.redis.port=6379
spring.redis.pool.maxActive=8
spring.redis.pool.maxWait=-1
spring.redis.pool.maxIdle=8
spring.redis.pool.minIdle=0
spring.redis.timeout=0
#rabbitMQ
spring.rabbitmq.host=10.99.2.10
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin123
spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.publisher-returns=true
spring.rabbitmq.template.mandatory=true
# 最小消息监听线程数
spring.rabbitmq.listener.concurrency=2
spring.rabbitmq.listener.max-concurrency=2

附上源码：https://pan.baidu.com/s/1FRyL2sWJxx29DaJ0YWhcvQ

springboot+dubbo+redis+RabbitMQ 项目整合实例

猜你喜欢