SpringCloud 微服务分布式 笔记(一)

<?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>org.example</groupId>
    <artifactId>SpringCloudBJ</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    
    <!-- Maven父工程包含管理的子工程... -->
    <modules>
        <module>common_api</module>
        <module>common_orderService</module>
        <module>common_userService</module>
    </modules>

    <!-- SpringBoot父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

    <!-- 统一设置Maven项目编码 jdk环境 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- spring-boot的web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- spring-boot的应用日志依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <!-- spring-boot的单元测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- lombok的依赖组件,别忘了要下载Idea  lombok的插件哦~ -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <!-- 指定SpringCloud配置必要！！ -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.RELEASE</version>                <!-- 版本... -->
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- maven的默认下载资源.. -->
    <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>

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
@Data
@AllArgsConstructor
@RequiredArgsConstructor
//创建一个实体类: 并根据lombok 及其注解生产对应的 构造函数,toString(); get/set...
public class Order {
    private Integer id;
    private String title;
    private Double price;
    private Integer uid;
}

<?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>SpringCloudBJ</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>common_api</artifactId>
</project>

<?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>SpringCloudBJ</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common_orderService</artifactId>

    <!-- 关键！！ -->
    <dependencies>
        <!-- common_orderService工程引入common_api -->
        <dependency>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
            <artifactId>common_api</artifactId>
        </dependency>
    </dependencies>
</project>

import com.wsm.entity.Order;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
public class OrderService {
    //模拟假订单集合...
    private static List<Order> orders = new ArrayList<>();
    //类加载时候默认获取一些数据..模拟假订单..
    static {
        orders.add(new Order(1, "订单11", 10.0, 1));
        orders.add(new Order(2, "订单21", 10.0, 2));
        orders.add(new Order(3, "订单31", 10.0, 1));
        orders.add(new Order(4, "订单41", 10.0, 2));
    }
    //根据输入用户id获取当然用订单集合..
    public List<Order> findOrderByUser(Integer uid) {
        List<Order> myorders = new ArrayList<>();
        //遍历集合从中获取 uid一致的数据存放在集合中返回...
        for (Order order : orders) {
            if (order.getUid() == uid) {
                myorders.add(order);
            }
        }
        return myorders;
    }
}

import com.wsm.entity.Order;
import com.wsm.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
public class OrderController {
    @Autowired
    private OrderService os;
    //REST风格进行请求..
    @GetMapping("/findOrderByUser/{uid}")   //参数是以 /请求名/{参数1}/{参数2} 进行访问的...
    public List<Order> findOrderByUser(@PathVariable Integer uid){
        //REST风格参数需要使用 @PathVariable获取！！
        return  os.findOrderByUser(uid);
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyOrderServer {
    public static void main(String[] args) {
        SpringApplication.run(MyOrderServer.class, args);
    }
}

server:
  port: 6001            #设置端口6001 当有多个微服务时候注意端口号可别冲突了..
spring:
  application:
    name: order-server  #设置当然微服务名,后面的 注册/调用服务,都是根据这个来的;

<?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>SpringCloudBJ</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>common_userService</artifactId>

    <dependencies>
        <!-- common_userService工程引入common_api -->
        <dependency>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
            <artifactId>common_api</artifactId>
        </dependency>
    </dependencies>
</project>

@Service
@Slf4j                  //加载lo4g使用...
public class UserService {
    @Autowired
    private RestTemplate restTemplate;
    //通过restTemplate进行网络通信,返回..其它远程模块的数据(虽然现在都是本地的不过就是模拟了..)

    public List<Order> currentUserOrder(Integer uid) {
        log.info("用户服务调用订单服务");
        //硬编码的调用！！ 这里的请求都写死的...这好吗？这不好...后面修改;
        String myurl = "http://localhost:6001/findOrderByUser/" + uid;
        log.info(myurl
        );
        List<Order> list = restTemplate.getForObject(myurl, List.class);
        return list;
    }
}

//编程控制层,接受请求响应结果
@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/showUserOrder")
    public List<Order> showUserOrder(Integer uid){
        return userService.currentUserOrder(uid);   //调用Service层
        //Service又是通过网络调用  订单模块来响应的结果,因此在此基础上要缺点订单模块是运行中的...
    }
}

@SpringBootApplication
public class MyUserServer {
    public static void main(String[] args) {
        SpringApplication.run(MyUserServer.class, args);
    }

    @Bean
    //实例化 RestTemplate 方便Service
    //可别忘了@SpringBootApplication复合注解底层可以有@SpringBootConfiguration 它也是一个Spring的配置类！
    public RestTemplate createRestTemplate() {
        return new RestTemplate();
    }
}

server:
  port: 6002            #设置端口6002 当有多个微服务时候注意端口号可别冲突了..
spring:
  application:
    name: user-server   #设置当然微服务名,后面的 注册/调用服务,都是根据这个来的;

<?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>SpringCloudBJ</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>eureka-server</artifactId>
    <!-- Eureka-server服务依赖,必须！  -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
</project>

server:
  port: 7001                #设置注册中心的 端口;
spring:
  application:
    name: eureka-server     #注册中心应用名称;
#配置注册中心....
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/   #注册中心对外暴漏的注册地址...
    #要不要去注册中心获取其他服务的地址,默认为true  (目前只有一个注册中心而且,当前就是注册中心..)
    fetch-registry: false
    #是否将允许自己注入注册中心,默认为true   (目前只有一个注册中心而且,当前就是注册中心..自己注册自己？)
    register-with-eureka: false        #如果一个应用中有两个注册中心可以开启,达到集群注册中心的目的...

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer            //注解主程序开启 Eureka服务
public class MyEurekaServer {
    public static void main(String[] args) {
        SpringApplication.run(MyEurekaServer.class, args);
    }
}

	<!--- 注册服务的依赖.. -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

@SpringBootApplication
@EnableEurekaClient
public class MyOrderServer {
    public static void main(String[] args) {
        SpringApplication.run(MyOrderServer.class, args);
    }
}

server:
  port: 6001            #设置端口6001 当有多个微服务时候注意端口号可别冲突了..
spring:
  application:
    name: order-server  #设置当然微服务名,后面的 注册/调用服务,都是根据这个来的;
eureka:
  client:
    service-url:		  #修改注册中心不上本地的ip 更改为无线网的ip 实现多设备连接...
      defaultZone: http://localhost:7001/eureka/    #指定服务注册的注册中心;
  instance:
    prefer-ip-address: true                         #在Eureka上使用ip号..
    instance-id: ${spring.cloud.client.ip-address}:${server.port}	#在Eureka上显示ip号..

import com.wsm.entity.Order;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;      //这个DiscoveryClient别搞错
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.List;
@Service
@Slf4j                  //加载lo4g使用...
public class UserService {
    @Autowired
    private RestTemplate restTemplate;
    //通过restTemplate进行网络通信,返回..其它远程模块的数据(虽然现在都是本地的不过就是模拟了..)

    @Autowired              //实现动态调用...
    private DiscoveryClient discoveryClient;

    public List<Order> currentUserOrder(Integer uid) {
        //获取注册中心上的微服模块实例                                                根据服务名;
        //返回一个集合: 有可能这个服务在多个注册中心上存在,`负载均衡~` 所以是一个集合;
        List<ServiceInstance> instances = discoveryClient.getInstances("order-server");
        ServiceInstance serviceInstance = instances.get(0); //而本次只有一个...
        log.info("用户服务调用订单服务");
        //动态调用服务                服务的host                         服务端口号                 这个就是服务controller请求    给其参数uid
        String myurl = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/findOrderByUser/" + uid;

        log.info(myurl);
        List<Order> list = restTemplate.getForObject(myurl, List.class);
        return list;
    }
}

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/    #指定服务注册的注册中心;
  instance:
    prefer-ip-address: true                         #在Eureka上显示ip号..
    instance-id: ${spring.cloud.client.ip-address}:${server.port}	#在Eureka上显示ip号..
    lease-renewal-interval-in-seconds: 5            #客户端向注册中心发送心跳时间
    lease-expiration-duration-in-seconds: 10        #如果没有发送心跳的延迟续约时间...

#配置注册中心....
eureka:
  client:
    service-url:			
      defaultZone: http://localhost:7001/eureka/   #注册中心对外暴漏的注册地址...跟随注册中心 提供的一致~
    #要不要去注册中心获取其他服务的地址,默认为true  (目前只有一个注册中心而且,当前就是注册中心..)
    fetch-registry: false
    #是否将允许自己注入注册中心,默认为true   (目前只有一个注册中心而且,当前就是注册中心..自己注册自己？)
    register-with-eureka: false        #如果一个应用中有两个注册中心可以开启,达到集群注册中心的目的...
  server:
    enable-self-preservation: false      #默认是ture 开启的
    eviction-interval-timer-in-ms: 4000  #默认是0 从不剔除！