搭建springboot+springcloud+mybatis+redis+rabbitmq项目框架

最新推荐文章于 2024-05-11 18:40:52 发布
最新推荐文章于 2024-05-11 18:40:52 发布
阅读量2.8k 收藏 22
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37664264/article/details/99300995
版权

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规范的工具集。

官网：https://swagger.io/

看官方的说明：

 

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

 

加温的啤酒
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
SpringBoot + Mybatis-plus + redis 项目练习
weixin_45506581的博客
03-24 1205
项目结构： 所需要的所有依赖坐标： <?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:.
Spring Boot项目搭建步骤（超详细）
11-26 2786
在 Spring Tools 4 for Eclipse 中依次选择 File->New->MavenProject，然后在出现的界面中按图 1 所示增加相关信息。 图 1创建 maven 项目 完了上述操作之后，在 pom.xml 中添加 Spring Boot 的依赖，代码如下所示。 <parent> <groupId>org.spr...
Java最新从零开始搭建springboot+springcloud+mybatis本地项目全过程，java面试mysql优化
最新发布
2401_84585155的博客
05-11 718
其它面试题（springboot、mybatis、并发、java中高级面试总结等）本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取其它面试题（springboot、mybatis、并发、java中高级面试总结等）[外链图片转存中…(img-YCjPIoQt-1715424030110)][外链图片转存中…(img-FPUrWiKQ-1715424030110)]
（四十五)springcloud+springboot+uniapp+vue b2b2c 分布式微服务电子商务商城之SpringCloud Smconf（分布式配置管理框架）概述
iteye_3750的博客
04-19 142
Smconf 专注于分布式环境下的配置的统一管理。采用 Java+Zookeeper+Mongodb+Spring Boot 开发。目前只支持 Java，其他的使用语言需要通过调用 REST API 来实现。 每个技术人都有一个开源的梦想，那就是自己也能开发出一个让很多人使用的框架。其实分享使用不是重点，重点是自己写的架构本身，你对它的各个方面都了如指掌，可以很方便添加新功能，比如加上一些适应公司内部需求的功能。 笔者之所以抛弃了 SpringCloud Config，一方面在于它的配置刷新这块不是很方便，
springcloud整合mybatis
m0_59092234的博客
04-27 1982
mybatis是用于连接MySQL的一个功能件，在微服架构中需要连接MySQL的就是充当原先dao层的服务器。 这个服务器中有接口，还有接口的实现类mapper.xml文件，连接数据库的文件可以是静态资源文件.xml文件，也可以是直接写入配置文件中的。 mybatis配置完成后应当有一下部件: jar包 ------------> 通过maven仓库进行加载，springcloud集成jar包 配置核心文件mybatis-config.XML(名字是其次) ----------> 通过配
CAS SSO单点登录实例
desperate025的博客
02-23 795
1.因为是本地模拟sso环境，而sso的环境测试需要域名，所以需要虚拟几个域名出来，步骤如下： 2.进入目录C:\Windows\System32\drivers\etc 3.修改hosts文件 127.0.0.1  jeesz.cn 127.0.0.1  sso1.jeesz.cn 127.0.0.1  sso2.jeesz.cn 4.生成认证证书 注意：我们可以根据sso单点登录的架构图可以看...
Seckill:基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统
03-11
基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统 开发工具 想法2017.2 开发环境 JDK 玛文 MySQL的 弹簧靴 Redis 兔子MQ 1.8 3.2.2 5.7 1.5.10发布 3.2 4倍 项目启动说明 1，启动前，请配置application....
基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip
12-17
基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip基于SpringBoot+Mybatis+Redis+RabbitMQ的商品秒杀系统源码+数据库.zip...
基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统.zip
10-16
基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统 基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统 基于SpringBoot+MyBatis+Redis+RabbitMQ 实现的秒杀系统 基于SpringBoot+MyBatis+Redis+RabbitMQ ...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
Springboot外卖系统 SpringBoot + Mybatis + RabbitMq + Redis.zip
03-09
Springboot外卖系统 SpringBoot + Mybatis + RabbitMq + Redis.zip
基于 SpringBoot+Mybatis+Redis+RabbitMQ 秒杀系统
05-29
1)、页面缓存、商品详情静态化、订单静态化（感兴趣可以把所有页面都做静态化） 2)、加入消息队列RabbitMQ，对秒杀接口进行优化。 3)、隐藏秒杀接口地址 4)、接口限流防刷 5)、解决超卖问题
（七十七)springcloud+springboot+uniapp+vue b2b2c 分布式微服务电子商务商城之Spring Cloud集成Spring Data Redis
iteye_3750的博客
04-28 208
Redis 是一个开源的使用 ANSI C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。 Redis 是一个高性能的 key-value 数据库，同时支持多种存储类型，包括 String（字符串）、List（链表）、Set（集合）、Zset（sorted set——有序集合）和 Hash（哈希类型）。 用 Redistemplate 操作 Redis 在 Java 中操作 Redis 我们可以用 Jedis，也可以用 Spring Data Red
springboot+redis整合rabbitmq
qq_40548741的博客
07-14 4540
MQ（IBM MQ）代表消息队列，是一种应用程序对应用程序的通信方法； 通过消息传递队列发送和接收消息数据，支持应用程序，系统，服务和文件之间的信息交换。 这简化了业务应用程序的创建和维护。 RabbitMQ是目前非常热门的一款消息中间件，不管是互联网大厂还是中小企业都在大量使用。 RabbitMQ中的交换机有Direct Exchange（直连交换机）、Topic Exchange（主题交换器）、Fanout Exchange（广播式交换机）、Headers Exchange（Headers交换机）四种
Java学习——springboot整合mysql、redis、mongodb
RX1125的博客
07-16 1183
springboot快速整合mysql,redis,mongodb
面试大揭秘！从技术面被“虐”到征服CTO,全凭这份强到离谱的pdf
AMSRY的博客
10-26 1237
程序员是最需要将终生学习贯彻到底的职业，一旦停止学习，离被淘汰，也就不远了。程序员工作都很忙，所以最好能在空闲的时候看看大厂的面试题，这些面试题的作用可能会超出你的想象，甚至能直接给你带来大厂的Offer。 这套面试题非常全面，包含了：Java基础、Java集合、JavaWeb、Java异常、OOP、IO与NIO、反射、注解、多线程、JVM、MySQL、MongoDB、Spring、SpringBoot、SpringCloud、SpringAOP、计算机网络（HTTP）、分布式架构、Redis、Linux
Spring Boot中使用Redis数据库
weixin_34064653的博客
04-15 260
Spring Boot中除了对常用的关系型数据库提供了优秀的自动化支持之外，对于很多NoSQL数据库一样提供了自动化配置的支持，包括：Redis, MongoDB, Elasticsearch, Solr和Cassandra。 使用Redis Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Ke...
商易通项目总结（三）（一款包含Spring+SpringBoot+SpringCloud+Mysql+Mybatis-plus+RabbitMq+Redis的医院挂号系统）
m0_46741750的博客
02-05 1599
java项目！！！
【项目】SpringCloud+Nginx+Redis+RabbitMQ秒杀系统
zmm__1377445292的博客
04-07 1438
文章目录秒杀系统前言系统架构图难题限流（一般都在接入层）三大接口限流算法计算器漏桶令牌桶其他限流策略分布式缓存可扩展超卖少卖（分布式锁）削峰遇到的问题前后端交互问题1.跨域问题2.前后端数据交换精度缺失问题JSON转换问题1.Redis中实体类和JSON互转问题消息中间件问题1.添加消息中间件的话，如何将秒杀系统处理的消息返回给用户？数据库问题1. 不能使用关键字做表名！ 秒杀系统 前言 当时写这个项目也只是一时兴起，后面看着性能不断的提高，测的QPS和延迟都不断的变优，发现还挺有意思的，感觉找到了乐趣所在
大众商城使用springboot+mybatis+redis+rabbitmq消息延迟+thymeleaf模板引擎+bootstrap前端框架技术，帮忙写出设计思路
04-19
使用Spring Cloud作为微服务框架，采用Eureka作为服务注册中心，Zuul作为网关来提供负载均衡、流量限制等功能。 2. 数据库设计 考虑到大众商城数据量较大，我们选用关系型数据库MySQL进行数据存储，采用主从复制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值