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

    <!-- Maven父工程包含管理的子工程... -->
    <modules>
        <module>common_api</module>
        <module>common_orderService</module>
        <module>common_userService</module>
        <module>eureka-server</module>
        <module>eureka-server2</module>		<!-- 手动添加刷新Maven以将copy的工程添加至项目中... -->
        <module>import-demo</module>
    </modules>

server:
  port: 7002                #修改...注册中心的端口; (要知道端口是唯一的...)
spring:
  application:
    name: eureka-server     #注册中心应用名称,这里不需要修改...

#配置注册中心....
eureka:
  client:
    service-url:            #注册中心对外暴漏的注册地址... 逗号分隔,不要有空格！！
      defaultZone: http://localhost:7002/eureka/,http://localhost:7001/eureka/
    fetch-registry: false
    register-with-eureka: false      

server:
  port: 7001                #注册中心的端口;
spring:
  application:
    name: eureka-server     #注册中心应用名称,这里不需要修改...
#配置注册中心....
eureka:
  client:
    service-url:    #注册中心对外暴漏的注册地址...
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/
    fetch-registry: false
    register-with-eureka: false

public interface ImportSelector { 
	//实现接口需要重写方法, 返回值是一个数组... 存放 class类名的数据;
	//在一个@Configuration类中使用@Import引入该接口的实现类;
	//会将实现类,实现方法的返回值所有的 class名都定义为Bean...
   String[] selectImports(AnnotationMetadata var1); 
}

public interface DeferredImportSelector extends ImportSelector {
	....
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})	//进入AutoConfigurationImportSelector.class
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

public class User {
    String name;
    String age;
	//省略get/set/toString....
}

//类并没有通过@Configuration 声明一个配置类,但内部已经使用@Bean 进行加载注入;
public class UserConfig {
    @Bean
    public User createUser() {
        User u = new User();
        u.setName("张三");
        u.setAge("12");
        return u;
    }
}
//虽然不会立刻加载至Spring容器中,但后面类通过 ImportSelector 来进行统一加载...

//UserImportSelector 实现 ImportSelector接口,重写方法...
public class UserImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{UserConfig.class.getName()};       //返回一个String数组,里存放着要加载的类名..
    }
    //方法返回值 字符数组[] 中存放着要通过 @import来加载实现的类...
}

@Retention(RetentionPolicy.RUNTIME)     //类加载时候完成类执行
@Documented
@Target(ElementType.TYPE)
//-------以上都是Java注解
@Import(UserImportSelector.class)   //通过import(UserImportSelector.Class)    引入实现类..
public @interface EnableUser {
    //使用 @interface 自定义一个注解: @EnableUser;
    //它是一个绑定注解内部包含一个: @Import(UserImportSelector.class)
    //使用 @EnableUser 就等于使用了 @Import(UserImportSelector.class)!!!
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
import org.springframework.context.ConfigurableApplicationContext;
import wsm.config.EnableUser;  //这是刚才自定义的注解！！通过它就可以启动User类的加载了...
import wsm.entity.User;

@SpringBootApplication         //而且要知道@SpringBootApplication注解下有一个@SpringBootConfiguration
@EnableEurekaServer            //注解主程序开启 Eureka服务
@EnableUser                    //引入自定义的注解即可完成下面 User
public class MyEurekaServer2 {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(MyEurekaServer2.class, args);

        User u = (User) run.getBean("uu");     //根据 @Bean("uu") 以加载至Spring容器; 通过@EableUser实现！
        System.out.println(u);

    }
}

<?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>
        <!-- 直接注释掉: Eureka-server服务依赖  -->
<!--        <dependency>-->
<!--            <groupId>org.springframework.cloud</groupId>-->
<!--            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>-->
<!--        </dependency>-->

        <!-- 基于consul的服务注册篇~ -->
        <!--SpringCloud提供的基于Consul的服务发现-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
        <!--actuator用于心跳检查-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
</project>

server:
  port: 6001            #设置端口6001 当有多个微服务时候注意端口号可别冲突了..
spring:
  application:
    name: order-server  #设置当然微服务名,后面的 注册/调用服务,都是根据这个来的;
#consul的相关配置; 
  cloud:
    consul:                 #server.cloud中添加: consul的相关配置;
      host: 127.0.0.1       #表示Consul的Server的请求地址
      port: 8500            #表示Consul的Server的端口
      discovery:            #服务注册与发现的相关配置
        register: true
        instance-id: ${spring.application.name}-${server.port}  #实例的唯一id (推荐必填,cloud官网推荐,为了保证生成唯一的id可以使用: ${spring.application.name}-${server.port}
        service-name: ${spring.application.name}
        port: ${server.port}
        ip-address: ${spring.cloud.client.ip-address}           #当前微服务的请求ip
        prefer-ip-address: true                                 #开启ip地址注册 就是展示ip
#原Eureka的注册服务配置...
#eureka:
#  client:
#    service-url:
#      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/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        #如果没有发送心跳的延迟续约时间...

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
//import org.springframework.cloud.netflix.eureka.EnableEurekaClient;       //注释 Eureka的引用

@SpringBootApplication
//@EnableEurekaClient       //Eureka专用注解启动 客户端注册~
@EnableDiscoveryClient      //通用注册中心注解~
public class MyOrderServer {
    public static void main(String[] args) {
        SpringApplication.run(MyOrderServer.class, args);
    }
}

@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));
    }

    //获取主机号ip post------------------------------------------------------------------负载均衡~
    //@Value("可以通过${} 来获取 属性文件中的值..并赋值到对象上~")
    @Value("${spring.cloud.client.ip-address}")
    private String ip;
    @Value("${server.port}")
    private String post;

    //根据输入用户id获取当然用订单集合..
    public List<Order> findOrderByUser(Integer uid) {
        //为了区分负载均衡的调用~打印 ip 和 post----------------------------------------------负载均衡~
        System.out.println(ip+":"+post);

        List<Order> myorders = new ArrayList<>();
        //遍历集合从中获取 uid一致的数据存放在集合中返回...
        for (Order order : orders) {
            if (order.getUid() == uid) {
                myorders.add(order);
            }
        }
        return myorders;
    }
}

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

    @LoadBalanced           //给RestTemplate类加上 @LoadBalanced 注解,及通过给RestTemplate来调用服务默认采用------负载均衡来使用！
    @Bean
    //实例化 RestTemplate 方便Service
    //可别忘了@SpringBootApplication复合注解底层可以有@SpringBootConfiguration 它也是一个Spring的配置类！
    public RestTemplate createRestTemplate() {
        return new RestTemplate();
    }
}

@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("用户服务调用订单服务");


        //ribbon的负载均衡调用-----------------------------------------------------------------
        //应为你现在已经有两个相同的 order-server 的微服务了,还使用ip+端口是固定的了,要通过负载均衡来完成动态调用~所以直接使用模块服务名来表示微服！
        String myurl = "http://order-server/findOrderByUser/" + uid;


        //动态调用服务                服务的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;
    }
}

order-server:	#这里的order-server是我服务的名称...目前的我的订单模块~
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #修改负载均衡的策略  随机方法服务

<dependency>
       <groupId>org.springframework.retry</groupId>
       <artifactId>spring-retry</artifactId>
</dependency>

order-server:
  ribbon:
    ConnectTimeout: 250 				#连接超时时间
    ReadTimeout: 1000 					#数据读取超时时间
    OkToRetryOnAllOperations: true 		#是否对所有操作进行重试
    MaxAutoRetries: 1 					#对当前实例的重试次数
    MaxAutoRetriesNextServer: 1			#切换实例的重试次数

<?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_fegin</artifactId>

    <dependencies>
        <!-- Maven子工程api实体 -->
        <dependency>
            <artifactId>common-api</artifactId>
            <groupId>com.zb</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- Eureka依赖~ -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- fegin依赖！！ -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>
</project>

server:
  port: 6004				  #更改端口 6004 
spring:
  application:
    name: user-server—fegin   #设置当然微服务名,后面的 注册/调用服务,都是根据这个来的;
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.cloud.client.ip-address}:${server.port}	#在Eureka上显示ip号..

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients                 //启动类添加Feign的支持
public class MyUserFeginServer {
    public static void main(String[] args) {
        SpringApplication.run(MyUserFeginServer.class, args);
    }
}

import com.zb.entity.Order;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import java.util.List;

//@FeignClient指定需要调用的微服务名称
@FeignClient("order-server")
public interface OrderFeginClient {

    //调用的请求路径,要注意这里尽量要和 提供者的实现方法一模一样包括参数,参数类型！！
    @GetMapping("/findOrderByUser/{uid}")
    public List<Order> findOrderByUser(@PathVariable("uid") Integer uid);
}

import com.wsm.client.OrderFeginClient;
import com.zb.entity.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {

    @Autowired
    private OrderFeginClient ofc;           //获取接口对象,@feginClient 会自动将类注入Spring

    public List<Order> currentUserOrder(Integer uid){
        return ofc.findOrderByUser(uid);    //调用接口的方法,fegin底层会默认调用,对于服务的方法...
    }
}

@RestController
public class UserController {

    @Autowired
    private UserService us;

    @GetMapping("/showUserOrder")
    public List<Order> showUserOrder(Integer uid){
        return us.currentUserOrder(uid);
    }
}

feign:
  httpclient:
    connection-timeout: 10000
  client:
    config:
      default: # 指定feignclients对应的名称 如果指定的是default 表示全局所有的client 的超时时间设置
        connectTimeout: 10000
        readTimeout: 10000
        loggerLevel: basic

spring:
  main:
    allow-bean-definition-overriding: true