Spring Cloud Netflix笔记

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

# 给当前服务取一个名字
spring.application.name=eureka
# 设置端口号
server.port=1111
# 默认情况下，Eureka Server 也是一个普通的微服务，所以当它还是一个注册中心的时候，他会有两层
身份：1.注册中心；2.普通服务，即当前服务会自己把自己注册到自己上面来
# register-with-eureka 设置为 false，表示当前项目不要注册到注册中心上
eureka.client.register-with-eureka=false
# 表示是否从 Eureka Server 上获取注册信息
eureka.client.fetch-registry=false

<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>

# 给当前服务取一个名字
spring.application.name=eureka
# 设置端口号
server.port=1111
eureka.instance.hostname=eurekaA
# 默认情况下，Eureka Server 也是一个普通的微服务，所以当它还是一个注册中心的时候，他会有两层
身份：1.注册中心；2.普通服务，即当前服务会自己把自己注册到自己上面来
# register-with-eureka 设置为 false，表示当前项目不要注册到注册中心上
eureka.client.register-with-eureka=true
# 表示是否从 Eureka Server 上获取注册信息
eureka.client.fetch-registry=true
# A 服务要注册到 B 上面
eureka.client.service-url.defaultZone=http://eurekaB:1112/eureka

# 给当前服务取一个名字
spring.application.name=eureka
# 设置端口号
server.port=1112
eureka.instance.hostname=eurekaB
# 默认情况下，Eureka Server 也是一个普通的微服务，所以当它还是一个注册中心的时候，他会有两层
身份：1.注册中心；2.普通服务，即当前服务会自己把自己注册到自己上面来
# register-with-eureka 设置为 false，表示当前项目不要注册到注册中心上
eureka.client.register-with-eureka=true
# 表示是否从 Eureka Server 上获取注册信息
eureka.client.fetch-registry=true
eureka.client.service-url.defaultZone=http://eurekaA:1111/eureka

java -jar eureka-0.0.1-SNAPSHOT.jar --spring.profiles.active=a
java -jar eureka-0.0.1-SNAPSHOT.jar --spring.profiles.active=b

eureka.instance.lease-renewal-interval-in-seconds=30
eureka.instance.lease-expiration-duration-in-seconds=90

eureka.client.fetch-registry=true

eureka.client.registry-fetch-interval-seconds=30

spring.application.name=provider
server.port=1113
eureka.client.service-url.defaultZone=http://localhost:1111/eureka

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String Hello(){
        return "hello lunanboy";
    }
}

@GetMapping("/hello1")
public String hello1() {
    HttpURLConnection con = null;
    try {
        URL url = new URL("http://localhost:1113/hello");
        con = (HttpURLConnection) url.openConnection();
        if (con.getResponseCode() == 200) {
            BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String s = br.readLine();
            br.close();
            return s;
        }
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "error";
}

//导springcloud的
@Autowired
DiscoveryClient discoveryClient;

@GetMapping("/hello2")
public String hello2() {
    // provider在部署时可能是一个集群化的
    List<ServiceInstance> list = discoveryClient.getInstances("provider");
    // 现在仅有一项
    ServiceInstance serviceInstance = list.get(0);
    String host = serviceInstance.getHost();
    int port = serviceInstance.getPort();
    HttpURLConnection conn = null;
    StringBuffer sb = new StringBuffer();
    sb.append("http://")
        .append(host)
        .append(":")
        .append(port)
        .append("/hello");

    try {
        URL url = new URL(sb.toString());
        conn = (HttpURLConnection) url.openConnection();
        if (conn.getResponseCode() == 200) {
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String s = br.readLine();
            br.close();
            return s;
        }
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "error";
}

@RestController
public class HelloController {
@Value("${server.port}")
Integer port;
@GetMapping("/hello")
public String hello() {
return "hello javaboy:" + port;
}
}

java -jar provider-0.0.1-SNAPSHOT.jar --server.port=1113
java -jar provider-0.0.1-SNAPSHOT.jar --server.port=1116

int count = 0;
@GetMapping("/hello3")
public String hello3() {
List<ServiceInstance> list = discoveryClient.getInstances("provider");
ServiceInstance instance = list.get((count++) % list.size());
String host = instance.getHost();
int port = instance.getPort();
StringBuffer sb = new StringBuffer();
sb.append("http://")
.append(host)
.append(":")
.append(port)
.append("/hello");
HttpURLConnection con = null;
try {
URL url = new URL(sb.toString());
con = (HttpURLConnection) url.openConnection();
if (con.getResponseCode() == 200) {
BufferedReader br = new BufferedReader(new
InputStreamReader(con.getInputStream()));
String s = br.readLine();
br.close();
return s;
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return "error";
}

  @SpringBootApplication
  public class ConsumerApplication {
  public static void main(String[] args) {
  SpringApplication.run(ConsumerApplication.class, args);
  }
  @Bean
  RestTemplate restTemplateOne() {
  return new RestTemplate();
  }
  }

//导springcloud的
    @Autowired
    DiscoveryClient discoveryClient;

    @Autowired
    RestTemplate restTemplate;

    @GetMapping("/hello2")
    public String hello2() {
        // provider在部署时可能是一个集群化的
        List<ServiceInstance> list = discoveryClient.getInstances("provider");
        // 现在仅有一项
        ServiceInstance serviceInstance = list.get(0);
        String host = serviceInstance.getHost();
        int port = serviceInstance.getPort();
        HttpURLConnection conn = null;
        StringBuffer sb = new StringBuffer();
        sb.append("http://")
                .append(host)
                .append(":")
                .append(port)
                .append("/hello");
        String s = restTemplate.getForObject(sb.toString(), String.class);
        return s;
    }

@Bean
@LoadBalanced
RestTemplate restTemplate() {
return new RestTemplate();
}

@GetMapping("/hello3")
    public String hello3() {
        // 给定一个模糊的provider 随机出一个
        // 既有负载均衡又有调用
        return restTemplate.getForObject("http://provider/hello", String.class);
    }

@GetMapping("/hello2")
    public String Hello2(String name){
        return "hello " + name;
    }

@GetMapping("/hello4")
    public void hello4(){
        String s1 = restTemplate.getForObject("http://provider/hello2?name={1}", String.class,"javaboy");
        System.out.println(s1);
        ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://provider/hello2", String.class);
        //服务端返回的具体数据
        String body = responseEntity.getBody();
        //状态码
        HttpStatus statusCode = responseEntity.getStatusCode();
        System.out.println("HttpStatus = " + statusCode);
        //
        int statusCodeValue = responseEntity.getStatusCodeValue();
        System.out.println("statusCodeValue = " + statusCodeValue);
        //响应头
        HttpHeaders headers = responseEntity.getHeaders();
        //header里有很多种 需要遍历以下
        Set<String> keySet  = headers.keySet();
        System.out.println("--------------header----------------");
        for (String s : keySet) {
            System.out.println(s+":" + headers.get(s));
        }

    }

@GetMapping("/hello5")
    public void hello5() throws UnsupportedEncodingException {
        String s1 = restTemplate.getForObject("http://provider/hello2?name={1}", String.class,"javaboy");
        System.out.println(s1);
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "zhangsan");
        s1 = restTemplate.getForObject("http://provider/hello2?name={name}", String.class, map);
        System.out.println(s1);
        String url = "http://provider/hello2?name=" + URLEncoder.encode("张三", "UTF-8");
        URI uri = URI.create(url);
        s1 = restTemplate.getForObject(uri, String.class);
        System.out.println(s1);

    }

@PostMapping("/user1")
public User addUser1(User user) {
return user;
}
@PostMapping("/user2")
public User addUser2(@RequestBody User user) {
return user;
}

@GetMapping("/hello6")
public void hello6() {
MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
map.add("username", "javaboy");
map.add("password", "123");
map.add("id", 99);
User user = restTemplate.postForObject("http://provider/user1", map,
User.class);
System.out.println(user);
user.setId(98);
user = restTemplate.postForObject("http://provider/user2", user,
User.class);
System.out.println(user);
}

@Controller
public class RegisterController {
@PostMapping("/register")
public String register(User user) {
return "redirect:http://provider/loginPage?username=" +
user.getUsername();
}
@GetMapping("/loginPage")
@ResponseBody
public String loginPage(String username) {
return "loginPage:" + username;
}
}

@GetMapping("/hello7")
public void hello7() {
MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
map.add("username", "javaboy");
map.add("password", "123");
map.add("id", 99);
URI uri = restTemplate.postForLocation("http://provider/register", map);
String s = restTemplate.getForObject(uri, String.class);
System.out.println(s);
}

@PutMapping("/user1")
public void updateUser1(User user) {
System.out.println(user);
}
@PutMapping("/user2")
public void updateUser2(@RequestBody User user) {
System.out.println(user);
}

@GetMapping("/hello8")
public void hello8() {
MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
map.add("username", "javaboy");
map.add("password", "123");
map.add("id", 99);
restTemplate.put("http://provider/user1", map);
User user = new User();
user.setId(98);
user.setUsername("zhangsan");
user.setPassword("456");
restTemplate.put("http://provider/user1", user);
}

@DeleteMapping("/user1")
public void deleteUser1(Integer id) {
System.out.println(id);
}
@DeleteMapping("/user2/{id}")
public void deleteUser2(@PathVariable Integer id) {
System.out.println(id);
}

@GetMapping("/hello9")
public void hello9() {
restTemplate.delete("http://provider/user1?id={1}", 99);
restTemplate.delete("http://provider/user2/{1}", 99);
}

wget https://releases.hashicorp.com/consul/1.6.2/consul_1.6.2_linux_amd64.zip

unzip consul_1.6.2_linux_amd64.zip

./consul agent -dev -ui -node=consul-dev -client=192.168.91.128

spring.application.name=consul-provider
server.port=2000
# Consul 相关配置
spring.cloud.consul.host=192.168.91.128
spring.cloud.consul.port=8500
spring.cloud.consul.discovery.service-name=consul-provider

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

@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "hello";
}
}

@RestController
public class HelloController {
@Value("${server.port}")
Integer port;
@GetMapping("/hello")
public String hello() {
return "hello>>" + port;
}
}

java -jar consul-provider-0.0.1-SNAPSHOT.jar --server.port=2000
java -jar consul-provider-0.0.1-SNAPSHOT.jar --server.port=2001

spring.application.name=consul-consumer
server.port=2002
spring.cloud.consul.host=192.168.91.128
spring.cloud.consul.port=8500
spring.cloud.consul.discovery.service-name=consul-consumer

@SpringBootApplication
@EnableDiscoveryClient
public class ConsulConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsulConsumerApplication.class, args);
}
@Bean
RestTemplate restTemplate() {
return new RestTemplate();
}
}

@RestController
public class HelloController {
@Autowired
LoadBalancerClient loadBalancerClient;
@Autowired
RestTemplate restTemplate;
@GetMapping("/hello")
public void hello() {
ServiceInstance choose = loadBalancerClient.choose("consul-provider");
System.out.println("服务地址：" + choose.getUri());
System.out.println("服务名称:" + choose.getServiceId());
String s = restTemplate.getForObject(choose.getUri() + "/hello",
String.class);
System.out.println(s);
}
}

spring.application.name=hystrix
server.port=3000
eureka.client.service-url.defaultZone=http://localhost:1111/eureka

@SpringBootApplication
@EnableCircuitBreaker
public class HystrixApplication {
public static void main(String[] args) {
SpringApplication.run(HystrixApplication.class, args);
}
@Bean
@LoadBalanced
RestTemplate restTemplate() {
return new RestTemplate();
}
}

@SpringCloudApplication
public class HystrixApplication {
public static void main(String[] args) {
SpringApplication.run(HystrixApplication.class, args);
}
@Bean
@LoadBalanced
RestTemplate restTemplate() {
return new RestTemplate();
}
}

@Service
public class HelloService {
@Autowired
RestTemplate restTemplate;
/**
* 在这个方法中，我们将发起一个远程调用，去调用 provider 中提供的 /hello 接口
*
* 但是，这个调用可能会失败。
*
* 我们在这个方法上添加 @HystrixCommand 注解，配置 fallbackMethod 属性，这个属性表示
该方法调用失败时的临时替代方法
* @return
*/
@HystrixCommand(fallbackMethod = "error")
public String hello() {
return restTemplate.getForObject("http://provider/hello", String.class);
}
/**
* 注意，这个方法名字要和 fallbackMethod 一致
* 方法返回值也要和对应的方法一致
* @return
*/
public String error() {
return "error";
}
}
@RestController
public class HelloController {
@Autowired
HelloService helloService;
@GetMapping("/hello")
public String hello() {
return helloService.hello();
}
}

public class HelloCommand extends HystrixCommand<String> {
RestTemplate restTemplate;
public HelloCommand(Setter setter, RestTemplate restTemplate) {
super(setter);
this.restTemplate = restTemplate;
}
@Override
protected String run() throws Exception {
return restTemplate.getForObject("http://provider/hello", String.class);
}
}

@GetMapping("/hello2")
public void hello2() {
HelloCommand helloCommand = new
HelloCommand(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.a
sKey("javaboy")), restTemplate);
String execute = helloCommand.execute();//直接执行
System.out.println(execute);
HelloCommand helloCommand2 = new
HelloCommand(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.a
sKey("javaboy")), restTemplate);
try {
Future<String> queue = helloCommand2.queue();
String s = queue.get();
System.out.println(s);//先入队，后执行
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

@HystrixCommand(fallbackMethod = "error")
public Future<String> hello2() {
return new AsyncResult<String>() {
@Override
public String invoke() {
return restTemplate.getForObject("http://provider/hello",
String.class);
}
};
}

@GetMapping("/hello3")
public void hello3() {
Future<String> hello2 = helloService.hello2();
try {
String s = hello2.get();
System.out.println(s);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

public class HelloCommand extends HystrixCommand<String> {
RestTemplate restTemplate;
public HelloCommand(Setter setter, RestTemplate restTemplate) {
super(setter);
this.restTemplate = restTemplate;
}
@Override
protected String run() throws Exception {
return restTemplate.getForObject("http://provider/hello", String.class);
}
/**
* 这个方法就是请求失败的回调
*
* @return
*/
@Override
protected String getFallback() {
return "error-extends";
}
}

@Service
public class HelloService {
@Autowired
RestTemplate restTemplate;
/**
* 在这个方法中，我们将发起一个远程调用，去调用 provider 中提供的 /hello 接口
* <p>
* 但是，这个调用可能会失败。
* <p>
* 我们在这个方法上添加 @HystrixCommand 注解，配置 fallbackMethod 属性，这个属性表示
该方法调用失败时的临时替代方法
*
* @return
*/
@HystrixCommand(fallbackMethod = "error")
public String hello() {
int i = 1 / 0;
return restTemplate.getForObject("http://provider/hello", String.class);
}
/**
* 注意，这个方法名字要和 fallbackMethod 一致
* 方法返回值也要和对应的方法一致
*
* @return
*/
public String error(Throwable t) {
return "error:" + t.getMessage();
}
}

public class HelloCommand extends HystrixCommand<String> {
RestTemplate restTemplate;
public HelloCommand(Setter setter, RestTemplate restTemplate) {
super(setter);
this.restTemplate = restTemplate;
}
@Override
protected String run() throws Exception {
int i = 1 / 0;
return restTemplate.getForObject("http://provider/hello", String.class);
}
/**
* 这个方法就是请求失败的回调
*
* @return
*/
@Override
protected String getFallback() {
return "error-extends:"+getExecutionException().getMessage();
}
}

@HystrixCommand(fallbackMethod = "error",ignoreExceptions =
ArithmeticException.class)
public String hello() {
int i = 1 / 0;
return restTemplate.getForObject("http://provider/hello", String.class);
}

@GetMapping("/hello2")
public String hello2(String name) {
System.out.println(new Date() + ">>>" + name);
return "hello " + name;
}

@HystrixCommand(fallbackMethod = "error2")
    @CacheResult//这个注解表示该方法的请求结果会被缓存起来，默认情况下，缓存的 key 就是方法的参
    public String hello3(String name) {
        return restTemplate.getForObject("http://provider/hello2?name={1}", String.class, name);
    }

@GetMapping("/hello4")
public void hello4() {
HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
String javaboy = helloService.hello3("javaboy");
javaboy = helloService.hello3("javaboy");
ctx.close();
}

public String error2(String name){
        return "error:lunanboy";
    }

@HystrixCommand(fallbackMethod = "error2")
@CacheResult//这个注解表示该方法的请求结果会被缓存起来，默认情况下，缓存的 key 就是方法的参
数，缓存的 value 就是方法的返回值。
public String hello3(String name,Integer age) {
return restTemplate.getForObject("http://provider/hello2?name={1}",
String.class, name);
}

@HystrixCommand(fallbackMethod = "error2")
@CacheResult//这个注解表示该方法的请求结果会被缓存起来，默认情况下，缓存的 key 就是方法的参
数，缓存的 value 就是方法的返回值。
public String hello3(@CacheKey String name, Integer age) {
return restTemplate.getForObject("http://provider/hello2?name={1}",
String.class, name);
}

@HystrixCommand(fallbackMethod = "error2")
@CacheResult//这个注解表示该方法的请求结果会被缓存起来，默认情况下，缓存的 key 就是方法的参数，缓存的 value 就是方法的返回值。
public String hello3(String name) {
return restTemplate.getForObject("http://provider/hello2?name={1}",
String.class, name);
}
@HystrixCommand
@CacheRemove(commandKey = "hello3")
public String deleteUserByName(String name) {
return null;
}

@GetMapping("/hello4")
public void hello4() {
HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
//第一请求完，数据已经缓存下来了
String javaboy = helloService.hello3("javaboy");
//删除数据，同时缓存中的数据也会被删除
helloService.deleteUserByName("javaboy");
//第二次请求时，虽然参数还是 javaboy，但是缓存数据已经没了，所以这一次，provider 还是会收到请求
javaboy = helloService.hello3("javaboy");
ctx.close();
}

public class HelloCommand extends HystrixCommand<String> {
RestTemplate restTemplate;
String name;
public HelloCommand(Setter setter, RestTemplate restTemplate,String name) {
super(setter);
this.name = name;
this.restTemplate = restTemplate;
}
@Override
protected String run() throws Exception {
return restTemplate.getForObject("http://provider/hello2?name={1}",
String.class, name);
}
@Override
protected String getCacheKey() {
return name;
}
/**
* 这个方法就是请求失败的回调
*
* @return
*/
@Override
protected String getFallback() {
return "error-extends:"+getExecutionException().getMessage();
}
}

@GetMapping("/hello2")
public void hello2() {
HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
HelloCommand helloCommand = new
HelloCommand(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.a
sKey("javaboy")), restTemplate,"javaboy");
String execute = helloCommand.execute();//直接执行
System.out.println(execute);
HelloCommand helloCommand2 = new
HelloCommand(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.a
sKey("javaboy")), restTemplate,"javaboy");
try {
Future<String> queue = helloCommand2.queue();
String s = queue.get();
System.out.println(s);//先入队，后执行
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
ctx.close();
}

@RestController
public class UserController {
@GetMapping("/user/{ids}")//假设 consumer 传过来的多个 id 的格式是 1,2,3,4....
public List<User> getUserByIds(@PathVariable String ids) {
String[] split = ids.split(",");
List<User> users = new ArrayList<>();
for (String s : split) {
User u = new User();
u.setId(Integer.parseInt(s));
users.add(u);
}
return users;
}
}

@Service
public class UserService {
@Autowired
RestTemplate restTemplate;
public List<User> getUsersByIds(List<Integer> ids) {
User[] users = restTemplate.getForObject("http://provider/user/{1}",
User[].class, StringUtils.join(ids, ","));
return Arrays.asList(users);
}
}

public class UserBatchCommand extends HystrixCommand<List<User>> {
private List<Integer> ids;
private UserService userService;
public UserBatchCommand(List<Integer> ids, UserService userService) {
super(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("
batchCmd")).andCommandKey(HystrixCommandKey.Factory.asKey("batchKey")));
this.ids = ids;
this.userService = userService;
}
@Override
protected List<User> run() throws Exception {
return userService.getUsersByIds(ids);
}
}

public class UserCollapseCommand extends HystrixCollapser<List<User>, User, Integer> {

    private UserService userService;
    private Integer id;

    public UserCollapseCommand(UserService userService, Integer id) {
        super(HystrixCollapser.Setter.withCollapserKey(HystrixCollapserKey.Factory.asKey("UserCollapseCommand")).andCollapserPropertiesDefaults(HystrixCollapserProperties.Setter().withTimerDelayInMilliseconds(200)));
        this.userService = userService;
        this.id = id;
    }


    /**
     * 请求参数
     *
     * @return
     */
    @Override
    public Integer getRequestArgument() {
        return id;
    }

    /**
     * 请求合并的方法
     *
     * @param collection
     * @return
     */
    @Override
    protected HystrixCommand<List<User>> createCommand(Collection<CollapsedRequest<User, Integer>> collection) {
        List<Integer> ids = new ArrayList<>(collection.size());
        for (CollapsedRequest<User, Integer> userIntegerCollapsedRequest : collection) {
            ids.add(userIntegerCollapsedRequest.getArgument());
        }
        return new UserBatchCommand(ids, userService);
    }

    /**
     * 请求结果转发
     *
     * @param users
     * @param collection
     */
    @Override
    protected void mapResponseToRequests(List<User> users, Collection<CollapsedRequest<User, Integer>> collection) {
        int count = 0;
        for (CollapsedRequest<User, Integer> userIntegerCollapsedRequest : collection) {
            userIntegerCollapsedRequest.setResponse(users.get(count++));
        }
    }
}

@GetMapping("/hello5")
    public void hello5() throws ExecutionException, InterruptedException {
        HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
        UserCollapseCommand cmd1 = new UserCollapseCommand(userService, 99);
        UserCollapseCommand cmd2 = new UserCollapseCommand(userService, 98);
        UserCollapseCommand cmd3 = new UserCollapseCommand(userService, 97);
        Future<User> q1 = cmd1.queue();
        Future<User> q2 = cmd2.queue();
        Future<User> q3 = cmd3.queue();
        User u1 = q1.get();
        User u2 = q2.get();
        User u3 = q3.get();
        System.out.println(u1);
        System.out.println(u2);
        System.out.println(u3);
        Thread.sleep(1000);
        UserCollapseCommand cmd4 = new UserCollapseCommand(userService, 96);
        Future<User> q4 = cmd4.queue();
        User u4 = q4.get();
        System.out.println(u4);
        ctx.close();
    }

@Service
public class UserService {
    @Autowired
    RestTemplate restTemplate;

    @HystrixCollapser(batchMethod = "getUsersByIds", collapserProperties =
            {@HystrixProperty(name = "timerDelayInMilliseconds", value = "200")})
    public Future<User> getUserById(Integer id) {
        return null;
    }

    @HystrixCommand
    public List<User> getUsersByIds(List<Integer> ids) {
        User[] users = restTemplate.getForObject("http://provider/user/{1}",
                User[].class, StringUtils.join(ids, ","));
        return Arrays.asList(users);
    }
}

@GetMapping("/hello6")
public void hello6() throws ExecutionException, InterruptedException {
    HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
    Future<User> q1 = userService.getUserById(99);
    Future<User> q2 = userService.getUserById(98);
    Future<User> q3 = userService.getUserById(97);
    User u1 = q1.get();
    User u2 = q2.get();
    User u3 = q3.get();
    System.out.println(u1);
    System.out.println(u2);
    System.out.println(u3);
    Thread.sleep(2000);
    Future<User> q4 = userService.getUserById(96);
    User u4 = q4.get();
    System.out.println(u4);
    ctx.close();
}

spring.application.name=openfeign
server.port=4000
eureka.client.service-url.defaultZone=http://localhost:1111/eureka

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

@FeignClient("provider")
public interface HelloService {
    //这里的方法名无所谓，随意取
    @GetMapping("/hello")
    String hello();
}

@RestController
public class HelloController {
@Autowired
HelloService helloService;
@GetMapping("/hello")
public String hello() {
return helloService.hello();
}
}

@FeignClient("provider")
public interface HelloService {
@GetMapping("/hello")
String hello();//这里的方法名无所谓，随意取
@GetMapping("/hello2")
String hello2(@RequestParam("name") String name);
@PostMapping("/user2")
User addUser(@RequestBody User user);
@DeleteMapping("/user2/{id}")
void deleteUserById(@PathVariable("id") Integer id);
@GetMapping("/user3")
void getUserByName(@RequestHeader("name") String name);
}

@GetMapping("/hello")
public String hello() throws UnsupportedEncodingException {
String s = helloService.hello2("江南一点雨");
System.out.println(s);
User user = new User();
user.setId(1);
user.setUsername("javaboy");
user.setPassword("123");
User u = helloService.addUser(user);
System.out.println(u);
helloService.deleteUserById(1);
helloService.getUserByName(URLEncoder.encode("江南一点雨", "UTF-8"));
return helloService.hello();
}

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.javaboy</groupId>
<artifactId>commons</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

public interface IUserService {
@GetMapping("/hello")
String hello();//这里的方法名无所谓，随意取
@GetMapping("/hello2")
String hello2(@RequestParam("name") String name);
@PostMapping("/user2")
User addUser(@RequestBody User user);
@DeleteMapping("/user2/{id}")
void deleteUserById(@PathVariable("id") Integer id);
@GetMapping("/user3")
void getUserByName(@RequestHeader("name") String name);
}

<dependency>
<groupId>org.javaboy</groupId>
<artifactId>hello-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

@RestController
public class HelloController implements IUserService {
@Value("${server.port}")
Integer port;
@Override
public String hello() {
return "hello javaboy:" + port;
}
@Override
public String hello2(String name) {
System.out.println(new Date() + ">>>" + name);
return "hello " + name;
}
@PostMapping("/user1")
public User addUser1(User user) {
return user;
}
@Override
public User addUser2(@RequestBody User user) {
return user;
}
@PutMapping("/user1")
public void updateUser1(User user) {
System.out.println(user);
}
@PutMapping("/user2")
public void updateUser2(@RequestBody User user) {
System.out.println(user);
}
@DeleteMapping("/user1")
public void deleteUser1(Integer id) {
System.out.println(id);
}
@Override
public void deleteUser2(@PathVariable Integer id) {
System.out.println(id);
}
@Override
public void getUserByName(@RequestHeader String name) throws
UnsupportedEncodingException {
System.out.println(URLDecoder.decode(name, "UTF-8"));
}
}

@FeignClient("provider")
public interface HelloService extends IUserService {
}

@SpringBootApplication
@EnableFeignClients
public class OpenfeignApplication {
public static void main(String[] args) {
SpringApplication.run(OpenfeignApplication.class, args);
}
@Bean
Logger.Level loggerLevel() {
return Logger.Level.FULL;
}
}