1.1创建父工程
创建统一的父工程:cloud,用来管理依赖及其版本,注意是创建project,而不是moudle
填写项目信息:
注意:
父工程不需要代码,只是管理依赖,因此我们不选择任何SpringCloud的依赖
跳过依赖选择。
填写保存的位置信息:
然后将pom文件修改成我这个样子:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.cloud.parent</groupId>
<artifactId>cloud</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>leyou</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-cloud.version>Finchley.RC1</spring-cloud.version>
<mybatis.starter.version>1.3.2</mybatis.starter.version>
<mapper.starter.version>2.0.2</mapper.starter.version>
<druid.starter.version>1.1.9</druid.starter.version>
<mysql.version>5.1.32</mysql.version>
<pageHelper.starter.version>1.2.3</pageHelper.starter.version>
<cloud.latest.version>1.0.0-SNAPSHOT</cloud.latest.version>
<fastDFS.client.version>1.26.1-RELEASE</fastDFS.client.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- springCloud -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- mybatis启动器 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis.starter.version}</version>
</dependency>
<!-- 通用Mapper启动器 -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>${mapper.starter.version}</version>
</dependency>
<!-- 分页助手启动器 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>${pageHelper.starter.version}</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--FastDFS客户端-->
<dependency>
<groupId>com.github.tobato</groupId>
<artifactId>fastdfs-client</artifactId>
<version>${fastDFS.client.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
</project>
可以发现,我们在父工程中引入了SpringCloud等很多以后需要用到的依赖,以后创建的子工程就不需要自己引入了。
最后,删除自动生成的CloudApplication启动类、测试类以及application.properties文件,我们不需要。
1.2.创建EurekaServer
这个大家应该比较熟悉了。
我们的注册中心,起名为:lc-registry
这次我们就不Spring使用提供的脚手架了。直接创建maven项目,自然会继承父类的依赖:
选择新建module:
选择maven安装,但是不要选择骨架:
然后填写项目坐标,我们的项目名称为lc-registry:
选择安装目录,因为是聚合项目,目录应该是在父工程cloud的下面:
1.2.2.添加依赖
添加EurekaServer的依赖:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>cloud</artifactId>
<groupId>com.cloud.parent</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.cloud.common</groupId>
<artifactId>lc-registry</artifactId>
<version>1.0.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
</project>
1.2.3.编写启动类
3.5.4.配置文件
server:
port: 10086
spring:
application:
name: lc-registry
eureka:
client:
fetch-registry: false
register-with-eureka: false
service-url:
defaultZone: http://127.0.0.1:${server.port}/eureka
server:
enable-self-preservation: false # 关闭自我保护
eviction-interval-timer-in-ms: 5000 # 每隔5秒进行一次服务列表清理
3.5.5.项目的结构:
目前,整个项目的结构如图:
1.3.创建Zuul网关
1.3.1.创建工程
与上面类似,选择maven方式创建Module,然后填写项目名称,我们命名为:lc-api-gateway
填写保存的目录:
1.3.2.添加依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>cloud</artifactId>
<groupId>com.cloud.parent</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.cloud.common</groupId>
<artifactId>lc-api-gateway</artifactId>
<version>1.0.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--是springboot提供的微服务检测接口,默认对外提供几个接口:/info-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
</project>
1.3.3.编写启动类
@SpringBootApplication
@EnableDiscoveryClient
@EnableZuulProxy
public class LcApiGateway {
public static void main(String[] args) {
SpringApplication.run(LcApiGateway.class,args);
}
}
1.3.4.配置文件
server:
port: 10010
spring:
application:
name: api-gateway
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
registry-fetch-interval-seconds: 5
instance:
prefer-ip-address: true
ip-address: 127.0.0.1
instance-id: ${spring.application.name}:${server.port}
zuul:
prefix: /api # 添加路由前缀
retryable: true
ribbon:
ConnectTimeout: 250 # 连接超时时间(ms)
ReadTimeout: 2000 # 通信超时时间(ms)
OkToRetryOnAllOperations: true # 是否对所有操作重试
MaxAutoRetriesNextServer: 1 # 同一服务不同实例的重试次数
MaxAutoRetries: 1 # 同一实例的重试次数
hystrix:
command:
default:
execution:
isolation:
thread:
timeoutInMillisecond: 10000 # 熔断超时时长:10000ms
1.3.5.项目结构
目前,leyou下有两个子模块:
-
lc-registry:服务的注册中心(EurekaServer)
-
lc-api-gateway:服务网关(Zuul)
目前,服务的结构如图所示:
截止到这里,我们已经把基础服务搭建完毕,为了便于开发,统一配置中心(ConfigServer)我们留待以后添加。
1.4.创建商品微服务
1.4.1.微服务的结构
因为与商品的品类相关,我们的工程命名为lc-item
需要注意的是,我们的lc-item是一个微服务,那么将来肯定会有其它系统需要来调用服务中提供的接口,因此肯定也会使用到接口中关联的实体类。
因此这里我们需要使用聚合工程,将要提供的接口及相关实体类放到独立子工程中,以后别人引用的时候,只需要知道坐标即可。
我们会在lc-item中创建两个子工程:
-
lc-item-interface:主要是对外暴露的接口及相关实体类
-
lc-item-service:所有业务逻辑及内部使用接口
3.7.2.创建父工程lc-item
依然是使用maven构建:
保存的位置:
不需要任何依赖,我们可以把项目打包方式设置为pom
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>cloud</artifactId>
<groupId>com.cloud.parent</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.cloud.service</groupId>
<artifactId>lc-item</artifactId>
<version>1.0.0-SNAPSHOT</version>
<!--打包方式为pom-->
<packaging>pom</packaging>
</project>
1.4.3.创建lc-item-interface
在lc-item工程上点击右键,选择new > module:
依然是使用maven构建,注意父工程是lc-item:
注意:接下来填写的目录结构需要自己手动完成,保存到lc-item
下的lc-item-interface
目录中:
点击Finish完成。
此时的项目结构:
1.4.4.创建lc-item-service
与lc-item-interface
类似,我们选择在lc-item
上右键,新建module,然后填写项目信息:
填写存储位置,是在/lc-item/lc-item-service
目录
点击Finish完成。
1.4.5.整个微服务结构
如图所示:
我们打开lc-item的pom查看,会发现lc-item-interface和lc-item-service都已经称为module了:
1.4.6.添加依赖
接下来我们给lc-item-service
中添加依赖:
思考一下我们需要什么?
-
Eureka客户端
-
web启动器
-
mybatis启动器
-
通用mapper启动器
-
分页助手启动器
-
连接池,我们用默认的Hykira
-
mysql驱动
-
千万不能忘了,我们自己也需要
lc-item-interface
中的实体类
这些依赖,我们在顶级父工程:cloud中已经添加好了。所以直接引入即可:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>lc-item</artifactId>
<groupId>com.cloud.service</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.cloud.service</groupId>
<artifactId>lc-item-service</artifactId>
<version>1.0.0-SNAPSHOT</version>
<dependencies>
<!--Eureka客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--web启动器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- mybatis启动器 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis.starter.version}</version>
</dependency>
<!-- 通用Mapper启动器 -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>${mapper.starter.version}</version>
</dependency>
<!-- 分页助手启动器 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>${pageHelper.starter.version}</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>com.cloud.service</groupId>
<artifactId>lc-item-pojo</artifactId>
<version>${cloud.latest.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
</project>
lc-item-interface中需要什么我们暂时不清楚,所以先不管。
3.7.7.编写启动和配置
在整个lc-item工程
中,只有lc-item-service
是需要启动的。因此在其中编写启动类即可:
@SpringBootApplication
@EnableDiscoveryClient
public class LcItemService {
public static void main(String[] args) {
SpringApplication.run(LcItemService.class,args);
}
}
然后是全局属性文件:
server:
port: 8081
spring:
application:
name: item-service
datasource:
url: jdbc:mysql://localhost:3306/cloud
username: root
password: 123456
hikari:
maximum-pool-size: 30
minimum-idle: 10
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
instance:
lease-renewal-interval-in-seconds: 5 # 每隔5秒发送一次心跳
lease-expiration-duration-in-seconds: 10 # 10秒不发送就过期
prefer-ip-address: true
ip-address: 127.0.0.1
instance-id: ${spring.application.name}:${server.port}
1.5.添加商品微服务的路由规则
既然商品微服务已经创建,接下来肯定要添加路由规则到Zuul中,我们不使用默认的路由规则。
zuul:
prefix: /api # 添加路由前缀
retryable: true
routes:
item-service: /item/** # 将商品微服务映射到/item/**
1.6.启动测试
我们分别启动:lc-registry,lc-api-gateway,lc-item-service
查看Eureka面板:
1.7.测试路由规则
为了测试路由规则是否畅通,我们是不是需要在item-service中编写一个controller接口呢?
其实不需要,Spring提供了一个依赖:actuator
只要我们添加了actuator的依赖,它就会为我们生成一系列的访问接口:
-
/info
-
/health
-
/refresh
-
...
添加依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
重启后访问Eureka控制台:
鼠标悬停在item-service上,会显示一个地址:
这就是actuator提供的接口,我们点击访问:
因为我们没有添加信息,所以是一个空的json,但是可以肯定的是:我们能够访问到item-service了。
接下来我们通过路由访问试试,根据路由规则,我们需要访问的地址是:
http://127.0.0.1:10010/api/item/actuator/info
1.4.通用工具模块
有些工具或通用的约定内容,我们希望各个服务共享,因此需要创建一个工具模块:lc-common
使用maven来构建module:
位置信息:
结构:
目前还不需要编码。
编写controller
@RestController
@RequestMapping("item")
@Api("商品服务接口")
public class ItemController {
@Autowired
private ItemService itemService;
@GetMapping("list")
public ResponseEntity<List<Item>> queryItemList(){
List<Item> list = itemService.queryItemList();
if(CollectionUtils.isEmpty(list)){
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
return ResponseEntity.ok(list);
}
}
编写service
public interface ItemService {
List<Item> queryItemList();
}
编写service实现类
@Service
public class ItemServiceImpl implements ItemService {
@Autowired
private ItemMapper itemMapper;
@Override
public List<Item> queryItemList() {
return itemMapper.selectAll();
}
}
编写mapper
@org.apache.ibatis.annotations.Mapper
public interface ItemMapper extends Mapper<Item> {
}
编写pojo
@Table(name = "tb_item")
public class Item {
private Long id;
private String title;
private Long price;
private String image;
//省略get和set方法
}
lc-item-interface引入jar包
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
启动类加包扫描
项目结构如下
1.5.Swagger-UI
为了方便测试,引入Swagger
1.5.1.什么是OpenAPI
随着互联网技术的发展,现在的网站架构基本都由原来的后端渲染,变成了:前端渲染、前后端分离的形态,而且前端技术和后端技术在各自的道路上越走越远。 前端和后端的唯一联系,变成了API接口;API文档变成了前后端开发人员联系的纽带,变得越来越重要。
没有API文档工具之前,大家都是手写API文档的,在什么地方书写的都有,而且API文档没有统一规范和格式,每个公司都不一样。这无疑给开发带来了灾难。
OpenAPI规范(OpenAPI Specification 简称OAS)是Linux基金会的一个项目,试图通过定义一种用来描述API格式或API定义的语言,来规范RESTful服务开发过程。目前V3.0版本的OpenAPI规范已经发布并开源在github上 。
官网:https://github.com/OAI/OpenAPI-Specification
1.5.2.什么是swagger?
OpenAPI是一个编写API文档的规范,然而如果手动去编写OpenAPI规范的文档,是非常麻烦的。而Swagger就是一个实现了OpenAPI规范的工具集。
看官方的说明:
Swagger包含的工具集:
-
Swagger编辑器: Swagger Editor允许您在浏览器中编辑YAML中的OpenAPI规范并实时预览文档。
-
Swagger UI: Swagger UI是HTML,Javascript和CSS资产的集合,可以从符合OAS标准的API动态生成漂亮的文档。
-
Swagger Codegen:允许根据OpenAPI规范自动生成API客户端库(SDK生成),服务器存根和文档。
-
Swagger Parser:用于解析来自Java的OpenAPI定义的独立库
-
Swagger Core:与Java相关的库,用于创建,使用和使用OpenAPI定义
-
Swagger Inspector(免费): API测试工具,可让您验证您的API并从现有API生成OpenAPI定义
-
SwaggerHub(免费和商业): API设计和文档,为使用OpenAPI的团队构建。
1.5.3.快速入门
SpringBoot已经集成了Swagger,使用简单注解即可生成swagger的API文档。
1)引入依赖
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.8.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.8.0</version>
</dependency>
2)编写配置
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket api() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.cloud.controller"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("商品系统")
.description("商品接口文档")
.version("1.0")
.build();
}
}
3)接口声明
在controller的每个handler上添加接口说明注解:
@RestController
@RequestMapping("item")
@Api("商品服务接口")
public class ItemController {
@Autowired
private ItemService itemService;
@ApiOperation(value = "获取商品列表", notes = "获取商品列表")
@GetMapping("list")
public ResponseEntity<List<Item>> queryItemList(){
List<Item> list = itemService.queryItemList();
if(CollectionUtils.isEmpty(list)){
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
return ResponseEntity.ok(list);
}
}
常用注解说明:
/**
@Api:修饰整个类,描述Controller的作用
@ApiOperation:描述一个类的一个方法,或者说一个接口
@ApiParam:单个参数描述
@ApiModel:用对象来接收参数
@ApiProperty:用对象接收参数时,描述对象的一个字段
@ApiResponse:HTTP响应其中1个描述
@ApiResponses:HTTP响应整体描述
@ApiIgnore:使用该注解忽略这个API
@ApiError :发生错误返回的信息
@ApiImplicitParam:一个请求参数
@ApiImplicitParams:多个请求参数
*/
4)启动测试
启动服务,然后访问:http://localhost:8081/swagger-ui.html
1.6添加rabbitmq和redis配置
完整配置:
server:
port: 8095
spring:
application:
name: item-service
rabbitmq:
host: 192.168.0.135
username: mceil
password: mceil
virtual-host: /mceil
template:
retry:
enabled: true
initial-interval: 10000ms
max-interval: 30000ms
multiplier: 2
exchange: mc.item.exchange
publisher-confirms: true
redis:
host: 192.168.0.135
datasource:
url: jdbc:mysql://localhost:3306/cloud
username: root
password: 123456
hikari:
maximum-pool-size: 30
minimum-idle: 10
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10087/eureka
instance:
lease-renewal-interval-in-seconds: 5 # 每隔5秒发送一次心跳
lease-expiration-duration-in-seconds: 10 # 10秒不发送就过期
prefer-ip-address: true
ip-address: 127.0.0.1
instance-id: ${spring.application.name}:${server.port}
添加Redis和rabbitmq依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1.6.2新建Redis接口
public interface RedisService {
public boolean set(final String key, Object value);
public boolean set(final String key, Object value, Long expireTime);
public void remove(final String... keys);
public void removePattern(final String pattern);
public void remove(final String key);
public boolean exists(final String key);
public Object get(final String key);
public void hmSet(String key, Object hashKey, Object value);
public Object hmGet(String key, Object hashKey);
public void lPush(String k,Object v);
public List<Object> lRange(String k, long l, long l1);
public void add(String key,Object value);
public Set<Object> setMembers(String key);
public void zAdd(String key,Object value,double scoure);
public Set<Object> rangeByScore(String key,double scoure,double scoure1);
}
实现Redis接口
@Service
public class RedisServiceImpl implements RedisService {
@Autowired
private RedisTemplate redisTemplate;
/**
* 写入缓存
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存设置时效时间
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value, Long expireTime) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 批量删除对应的value
* @param keys
*/
public void remove(final String... keys) {
for (String key : keys) {
remove(key);
}
}
/**
* 批量删除key
* @param pattern
*/
public void removePattern(final String pattern) {
Set<Serializable> keys = redisTemplate.keys(pattern);
if (keys.size() > 0)
redisTemplate.delete(keys);
}
/**
* 删除对应的value
* @param key
*/
public void remove(final String key) {
if (exists(key)) {
redisTemplate.delete(key);
}
}
/**
* 判断缓存中是否有对应的value
* @param key
* @return
*/
public boolean exists(final String key) {
return redisTemplate.hasKey(key);
}
/**
* 读取缓存
* @param key
* @return
*/
public Object get(final String key) {
Object result = null;
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
result = operations.get(key);
return result;
}
/**
* 哈希 添加
* @param key
* @param hashKey
* @param value
*/
public void hmSet(String key, Object hashKey, Object value){
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
hash.put(key,hashKey,value);
}
/**
* 哈希获取数据
* @param key
* @param hashKey
* @return
*/
public Object hmGet(String key, Object hashKey){
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
return hash.get(key,hashKey);
}
/**
* 列表添加
* @param k
* @param v
*/
public void lPush(String k,Object v){
ListOperations<String, Object> list = redisTemplate.opsForList();
list.rightPush(k,v);
}
/**
* 列表获取
* @param k
* @param l
* @param l1
* @return
*/
public List<Object> lRange(String k, long l, long l1){
ListOperations<String, Object> list = redisTemplate.opsForList();
return list.range(k,l,l1);
}
/**
* 集合添加
* @param key
* @param value
*/
public void add(String key,Object value){
SetOperations<String, Object> set = redisTemplate.opsForSet();
set.add(key,value);
}
/**
* 集合获取
* @param key
* @return
*/
public Set<Object> setMembers(String key){
SetOperations<String, Object> set = redisTemplate.opsForSet();
return set.members(key);
}
/**
* 有序集合添加
* @param key
* @param value
* @param scoure
*/
public void zAdd(String key,Object value,double scoure){
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
zset.add(key,value,scoure);
}
/**
* 有序集合获取
* @param key
* @param scoure
* @param scoure1
* @return
*/
public Set<Object> rangeByScore(String key, double scoure, double scoure1){
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
return zset.rangeByScore(key, scoure, scoure1);
}
}
将数据添加到缓存中
使用rabbitmq:
@Slf4j
@Service
public class ItemServiceImpl implements ItemService {
@Autowired
private ItemMapper itemMapper;
@Autowired
private RedisService redisService;
@Autowired
private AmqpTemplate amqpTemplate;
@Override
public List<Item> queryItemList() {
//获取缓存中的商品数据
List<Item> list = (List<Item>) redisService.get("item");
if(!CollectionUtils.isEmpty(list)){
return list;
}
List<Item> itemList = itemMapper.selectAll();
//将数据库中的数据添加到缓存中
redisService.set("item",itemList);
return itemList;
}
@Override
@Transactional
public void deleteItemById(Long id) {
itemMapper.deleteByPrimaryKey(id);
//删除时发送消息
sendMessage(id,"delete");
}
/**
* 封装发送到消息队列的方法
*
* @param id
* @param type
*/
private void sendMessage(Long id, String type) {
try {
amqpTemplate.convertAndSend("item." + type, id);
} catch (Exception e) {
log.error("{}商品消息发送异常,商品ID:{}", type, id, e);
}
}
}
1.5编写一个lc-cart监听rabbitmq的消息
项目信息:
位置信息:
pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>cloud</artifactId>
<groupId>com.cloud.parent</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.cloud.cart</groupId>
<artifactId>lc-cart</artifactId>
<version>1.0.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
<version>2.0.1.RELEASE</version>
</dependency>
<dependency>
<groupId>com.cloud.service</groupId>
<artifactId>lc-item-interface</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
编写启动类
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class LcCartApplication {
public static void main(String[] args) {
SpringApplication.run(LcCartApplication.class,args);
}
}
编写service
@Service
public class CartService {
}
service具体要做什么事根据自己的需求制定
编写rabbitmq监听器:
@Component
public class CartListener {
@Autowired
private CartService cartService;
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "lc.item.delete.queue", durable = "true"),
exchange = @Exchange(name = "lc.item.exchange",
type = ExchangeTypes.TOPIC,
ignoreDeclarationExceptions = "true"),
key = {"item.delete"}
))
public void listenDelete(String params) {
//监听到消息之后做某些事
//比如商品删除后,将购物车中的商品数据的状态设置成已删除
}
}
如果lc-item要提供接口给其他微服务调用,则需要在lc-item-interface中定义api接口
public interface ItemApi {
@GetMapping("list")
ResponseEntity<List<Item>> queryItemList();
}
项目lc-cart要调用lc-item的接口,则需要定义client:
@FeignClient(value = "item-service")
public interface ItemClient extends ItemApi {
}
直接在CartService注入ItemClient就可以调用ItemApi提供的接口了:
@Service
public class CartService {
@Autowired
private ItemClient itemClient;
public List<Cart> queryCartList(){
List<Item> itemList = itemClient.queryItemList().getBody();
return null;
}
}
lc-item-interface项目结构:
lc-cart项目结构:
源码后续会上传到github