搭建项目环境
ide:idea
jdk:jdk1.8
操作系统:mac
工程目录
创建父工程(其他模块都为父工程的子模块)
1.新建一个空工程: File -> New -> New Project
2.创建完成有弹出框 新建modules,点击 + 号,新建一个父工程,也就是一个父 module。然后我们选择 maven 工程,选择 jdk 版本和模板,模板也可以不选择,我这里就没有选择,自己搭建即可。
4. 在pom文件中设置spring boot的parent
<?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.demo</groupId>
<artifactId>microservice</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<spring-cloud.version>Edgware.SR1</spring-cloud.version>
<spring-boot.version>1.5.10.RELEASE</spring-boot.version>
<mysql.version>5.1.46</mysql.version>
<mybatis.version>1.3.2</mybatis.version>
<lombok.version>1.16.18</lombok.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- 定义 spring cloud 版本 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- 定义 spring boot 版本 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- 定义 mysql 版本 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!-- 定义 mybatis 版本 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!-- 定义 lombok 版本 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
父工程配置完了,子模块可以直接通过<parent>标签引用父工程的依赖包
创建microservice-common模块(公共模块)供其子模块调用
1.在父工程中添加common子模块,右键microservice - new - module
创建步骤和上面的一样,项目名:microservice-common
2.在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>microservice</artifactId>
<groupId>com.demo</groupId>
<version>1.0-SNAPSHOT</version>
<relativePath>../microservice/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>microservice-common</artifactId>
<packaging>jar</packaging>
<!-- 当前Module需要用到的依赖,按自己需求添加,版本号在父类已经定义了,这里不需要再次定义 -->
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>
3. 在scr/main/java/下创建实体类,添加公共实体类供其他服务调用
package com.demo.springcloud.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
/**
* 订单实体
*@AllArgsConstructor 注解:表示生成带有所有属性的构造方法
*@NoArgsConstructor 注解:表示生成不带参数的构方法
*@Data 注解:表示生成get和set方法
*/
@AllArgsConstructor
@NoArgsConstructor
@Data
public class TOrder {
/**
* 主键id
*/
private Long id;
/**
* 商品名称
*/
private String name;
/**
* 商品价格
*/
private Double price;
/**
* 所存的数据库名称
*/
private String dbSource;
}
4. 将common打包成jar文件,点击maven 分别 clean和 install一下
公共模块初步搭建完成,稍后测试一下~
创建服务提供者模块microservice-provider
创建服务提供者模块,添加方式和microservice-common一样。服务提供模块,主要负责在表中查询出订单信息,然后将信息通过接口提供给调用方,所以在该模块中,我们需要整合一下 mybatis
1.在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>microservice</artifactId>
<groupId>com.demo</groupId>
<version>1.0-SNAPSHOT</version>
<relativePath>../microservice/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>microservice-provider</artifactId>
<packaging>jar</packaging>
<!-- 当前Module需要用到的依赖,按自己需求添加,版本号在父类已经定义了,这里不需要再次定义 -->
<dependencies>
<!-- 引入自己定义的 microservice-common 通用包,可以使用common模块中的TOrder类 -->
<dependency>
<groupId>com.demo</groupId>
<artifactId>microservice-common</artifactId>
<version>${project.version}</version>
</dependency>
<!-- spring boot web 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!-- mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<!-- mysql 依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
</dependencies>
</project>
2.配置application.yml
# 服务端口号
server:
port: 8001
# 数据库地址
datasource:
url: localhost:3306/demo
spring:
application:
name: microservice-order # 对外暴露的服务名称
datasource: # 数据库配置
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://${datasource.url}?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
username: root
password: root
hikari:
maximum-pool-size: 10 # 最大连接池数
max-lifetime: 1770000
3.创建数据持久层接口
public interface OrderMapper {
@Select("select * from microservice where id = #{id}")
TOrder findById(Long id);
@Select("select * from microservice")
List<TOrder> findAll();
}
4.创建业务层接口以及实现类
//业务层接口
public interface OrderService {
TOrder findById(Long id);
List<TOrder> findAll();
}
//接口实现类
@Service
public class OrderServiceImpl implements OrderService {
@Resource
private OrderMapper orderMapper;
public TOrder findById(Long id) {
return orderMapper.findById(id);
}
public List<TOrder> findAll() {
return orderMapper.findAll();
}
}
5.创建服务控制层
@RestController
@RequestMapping("/provider/order")
public class OrderProviderController {
@Resource
private OrderService orderService;
@GetMapping("/get/{id}")
public TOrder getOrder(@PathVariable Long id) {
return orderService.findById(id);
}
@GetMapping("/get/list")
public List<TOrder> getAll() {
return orderService.findAll();
}
}
6.创建服务启动类
@SpringBootApplication
@MapperScan("com.itcodai.springcloud.dao")
public class OrderProvider {
public static void main(String[] args) {
SpringApplication.run(OrderProvider.class, args);
}
}
数据库结构:
服务提供者模块搭建完了可以启动测试,浏览器输入:localhost:8001/provider/order/get/list
创建订单消费者模块microservice-consumer
新建子模块的方法和上面两个子 模块一模一样,在命名的时候命名为 microservice-consumer
即可。 microservice-consumer 模块主要是用来调用 microservice-provider模块提供的订单信息,所以在 microservice-consumer 模块中我们不需要引入 mybatis 和 mysql 相关的依赖
1.在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>microservice</artifactId>
<groupId>com.demo</groupId>
<version>1.0-SNAPSHOT</version>
<relativePath>../microservice/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>microservice-consumer</artifactId>
<packaging>jar</packaging>
<!-- 当前Module需要用到的依赖,按自己需求添加,版本号在父类已经定义了,这里不需要再次定义 -->
<dependencies>
<!-- 引入自己定义的 microservice-common 通用包,可以使用common模块中的Order类 -->
<dependency>
<groupId>com.demo</groupId>
<artifactId>microservice-common</artifactId>
<version>${project.version}</version>
</dependency>
<!-- spring boot web 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
</dependencies>
</project>
2.创建RestTmplate类。在微服务都是以 HTTP 接口的形式暴露自身服务的,因此在调用远程服务时就必须使用 HTTP 客户端。Spring Boot 中使用的是 RestTemplate,首先,我们写一个配置类,将 RestTemplate 作为一个 Bean 交给 Spring 来管理
@Configuration
public class RestTmplateConfig {
@Bean
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
}
3.有了RestTmplate,接下来我们可以在 Controller 中注入该 RestTemplate 来调用 microservice-provider
提供的服务了
//@RestController 相当于Controller注释加ResponesBody注释
@RestController
@RequestMapping("/consumer/order")
public class OrderConsumerController {
// 订单服务提供者模块的 url 前缀
private static final String ORDER_PROVIDER_URL_PREFIX = "http://localhost:8001";
@Resource
private RestTemplate restTemplate;
@GetMapping("/get/{id}")
public TOrder getOrder(@PathVariable Long id) {
return restTemplate.getForObject(ORDER_PROVIDER_URL_PREFIX + "/provider/order/get/" + id, TOrder.class);
}
@GetMapping("/get/list")
public List<TOrder> getAll() {
return restTemplate.getForObject(ORDER_PROVIDER_URL_PREFIX + "/provider/order/get/list", List.class);
}
}
订单消费者模块搭建完了可以启动测试一下
浏览器访问:http://localhost:8080/consumer/order/get/list
返回结果,说明服务调用成功
可以看到通过订单消费者调用服务提供者暴露的服务,实现了每个服务专注于自身的逻辑,服务之间解耦合。
总结流程
订单消费模块不直接请求数据库,而是通过 http 远程调用订单提供模块的服务来获取订单信息。也就是说,在微服务里,每个服务只关注自身的逻辑和实现,不用管其他服务的实现,需要获取某个服务的数据时,只要调用该服务提供的接口即可获取相应的数据。实现了每个服务专注于自身的逻辑,服务之间解耦合。