转载请标明出处：
 http://blog.csdn.net/forezp/article/details/78676036
 本文出自方志朋的博客
 
 
个人博客纯净版：https://www.fangzhipeng.com/architecture/2018/01/01/springcloud-jwt.html
 
在微服务系统中，为了保证微服务系统的安全,常常使用jwt来鉴权，但是服务内部的相互调用呢。经常有人在微信上问我，我给出一个解决办法，采用Feign的拦截器。
 
在Feign中开启了hystrix，hystrix默认采用的是线程池作为隔离策略。线程隔离有一个难点需要处理，即隔离的线程无法获取当前请求线程的Jwt，这用ThredLocal类可以去解决，但是比较麻烦，所以我才用的是信号量模式。
 在application.yml配置文件中使用一下配置：
 
hystrix.command.default.execution.isolation.strategy: SEMAPHORE
 
写一个Feign的拦截器，Feign在发送网络请求之前会执行以下的拦截器，代码如下：
 

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.stereotype.Component;

/**
 * Created by fangzhipeng on 2017/7/28.
 */
@Component
public class JwtFeignInterceptor implements RequestInterceptor {

    private final String key = "Authorization";


    @Override
    public void apply(RequestTemplate template) {

        if (!template.headers().containsKey(key)) {
            String currentToken = UserUtils.getCurrentToken();
            if (!StrUtil.isEmpty(currentToken)){
                template.header(key, currentToken);
            }
        }
    }
}
 
也可以参考这篇文章：http://www.spring4all.com/article/948
 
更多阅读
 
史上最简单的 SpringCloud 教程汇总
 
SpringBoot教程汇总
 
Java面试题系列汇总
 
 
 
  
 扫码关注公众号有惊喜 
 
 
 （转载本站文章请注明作者和出处 方志朋的博客） 
 

上一篇讲解了客户端给服务器发送消息，这一篇讲解客户端和服务器相互发送消息，客户端发送消息给服务器，服务器收到客户端的请求然后返回信息给客户端。
 
1.服务器代码：
 
**
 * @author: njb
 * @Date: 2020/11/28 18:49
 * @desc: 服务器socket
 */
public class ServerSocket {

    //客户端发送信息
    public static void main(String[] args) {
        OutputStream out = null;
        Socket socket = null;
        try {
            //绑定到本地端口
            socket = new Socket("127.0.0.1", 8090);
            //发送消息
            while (true) {
                System.out.println("==========");
                out = socket.getOutputStream();
                //输入文字，从控制台输入
                Scanner san = new Scanner(System.in);
                String str = san.next();
                System.out.println("我:" + str);
                out.write(str.getBytes());
                out.flush();
                //接收信息
                InputStream in = socket.getInputStream();
                //获取输入流里面数据并存储数据
                byte[] b = new byte[1024];
                StringBuffer sb = new StringBuffer();
                String s;
                if (in.read(b) != -1) {
                    s = new String(b);
                    System.out.println(s);
                    sb.append(s);
                }
                System.out.println("来自服务器的数据:" + sb);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
2.客户端代码：
 
/**
 * @author: njb
 * @Date: 2020/11/28 18:49
 * @desc: 客户端socket
 */
public class ClientSocket {
    public static void main(String[] args) {
        ServerSocket server;
        try {
            server = new ServerSocket(8090);
            Socket socket=server.accept();
            while(true){
                System.out.println("----------");
                InputStream in;
                try {
                    in = socket.getInputStream();
                    byte [] b=new byte[1024];
                    StringBuffer sb=new StringBuffer();
                    String s;
                    if(in.read(b) !=-1){
                        s=new String(b);
                        sb.append(s);
                    }
                    OutputStream out=socket.getOutputStream();
                    System.out.println("客户端信息:"+sb);
                    Scanner sc=new Scanner(System.in);
                    String str=sc.next();
                    System.out.println("我："+str);
                    out.write(str.getBytes());
                    out.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 
3.启动服务器，客户端发送消息给服务器。
 
 
4.服务器收到客户端的请求并且发送消息给客户端。
 
 
5.更多的收发消息：
 
 
 
6.以上就是服务器和客户端相互发送消息的简单实现，后面会写一篇利用websocket实现简单的聊天和通信.

在分布式系统中基本没有绝对的服务提供者也没有绝对的服务消费者，即便有那也是极少极少的情况。什么时候会出现这种情况呢？比如说一个分布式系统中有一个日志处理的子系统，那么好了这个子系统基本上就是一个服务的提供者，它基本不会去调用其他的系统。那么对于大多数的分布式系统而言还是存在这种服务的提供者和消费者角色互换的情况。下面就来以上一篇的案例来大概实现一下服务消费者和提供者的角色互换问题。
 
说明一下以下的谈的这个例子，都是以我上一篇博客写的为基础，如果君有兴趣可以看我的上一篇博客地址为：https://blog.csdn.net/CDW2328/article/details/94590383
 
既然这里要实现服务的消费者变成服务的提供者，那么我这里首先要开始着手操作服务的消费者。好了接下来就是具体的实现的方法：
 
1：在原来的maven项目的基础上，先创建一个对外提供的接口，然后在服务的消费者里面创建对象实现这个接口。
 
1.1：创建一个对外提供服务的接口：
 
package com.alibaba.model;
 
/**
  * 
  *@description: 商品管理的模块
  *@author chendawei
  */
 public interface CommodityManagerModel {
 
    /**
      * 更新用户的商品
      * @param userMassage 用户信息
      * @return
      */
     public String updateCommodityUser(String userMassage);
 }
 1.2：实现这个接口：
 
package com.alibaba.model.Impl;
 
import com.alibaba.model.CommodityManagerModel;
 
/**
  * 
  *@description:  商品管理的模块
  *@author chendawei
  */
 public class CommodityManagerModelImpl implements CommodityManagerModel{
 
    public String updateCommodityUser(String userMassage) {
         return userMassage;
     }
 
}
 2、到此对外提供服务的接口和这个接口的实现类我就写好了，那么接下来我们要创建一个application.xml用于配置向服务注册中心zookeeper提交的信息。
 
<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
        xmlns="http://www.springframework.org/schema/beans"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://code.alibabatech.com/schema/dubbo 
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
 
        <!-- 服务提供方某一个功能的具体实现，这个功能供消费者调用 -->
           <bean id="CommodityManagerModel" class="com.alibaba.model.Impl.CommodityManagerModelImpl"></bean>
           
           <!-- 服务提供者的信息,以便计算依赖关系 -->
           <dubbo:application name="DubboServerConsumerToProvider"></dubbo:application>
           
           <!-- 将服务提供者的地址暴露出去。这个过程通过zookeeper实现服务注册中心，进行注册暴露 -->
           <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>
           
           <!-- 将服务提供者的端口号暴露出去 -->
           <dubbo:protocol name="dubbo" port="20002"></dubbo:protocol>
           
           <!-- 将服务提供者需要对外提供的功能暴露出去 -->
           <dubbo:service interface="com.alibaba.model.CommodityManagerModel" ref="CommodityManagerModel"></dubbo:service>
 </beans>
 
最后一步就是创建一个启动的对象：
 
package com.alibaba.run;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class RunServerProvider {
 
    public static void main(String[] args) {
         try {
             //加载主配置文件
             ClassPathXmlApplicationContext ac = new  ClassPathXmlApplicationContext("application.xml");
             //一直让启动的第一种方式
             /*
              * while(true) { ac.start(); System.out.println("注册成功"); }
              */
             //一直让启动的第二种方式,推荐
             ac.start();
             System.in.read();
         } catch (Exception e) {
             System.out.println(e);
         }
     }
 }
 好了到此我们服务的消费者就具有了服务提供者的角色。接下来开始在服务提供者里面创建一个服务的消费者。
 
1：创建一个包然后在这个包里面创建一个接口。注意：此时创建的这个包的命名必须和这个接口的命名一定要和上面服务的提供者向外暴露的接口所在的包名和接口名称一致。下面是在服务的提供者里面创建一个和上面服务的提供者相同包名和接口名的示例：
 
package com.alibaba.model;
 
public interface CommodityManagerModel {
 
    /**
        *    更新用户的商品
      * @param userMassage 用户信息
      * @return
      */
     public String updateCommodityUser(String userMassage);
 }
 
2：再创建一个application.xml用户向Dubbo的注册中心注册并生成调用服务的代理对象。
 
<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
        xmlns="http://www.springframework.org/schema/beans"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://code.alibabatech.com/schema/dubbo 
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd">
 
    <!-- 服务消费者的应用程序的名称，用于计算依赖关系 -->
     <dubbo:application name="DubboServerProviderToConsumer"/>
     
     <!-- 服务消费者同时也向注册中心进行注册 -->
     <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
     
     <!-- 生成服务代理 -->
     <dubbo:reference id="CommodityManagerModel" interface="com.alibaba.model.CommodityManagerModel"/>
 </beans>
 
最后一步就是创建一个消费者的启动的对象：
 
package com.alibaba.run;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.alibaba.model.CommodityManagerModel;
 import com.alibaba.moudel.UserManagerModel;
 
/**
  *  运行服务的消费者
  *@description:
  *@author chendawei
  */
 public class RunServerConsumer {
 
    public static void main(String[] args) {
         try {
             ClassPathXmlApplicationContext cs =  new ClassPathXmlApplicationContext("application.xml");
             cs.start();
             System.out.println("开始调用服务的消费者");
             CommodityManagerModel um = (CommodityManagerModel)cs.getBean("CommodityManagerModel");
             String userMassage = um.updateCommodityUser("你好");
             System.out.println(userMassage);
             System.in.read();
         } catch (Exception e) {
             // TODO: handle exception
         }
     }
 }
 然后分别启动服务提供者中的服务提供测试对象和服务消费测试对象，服务消费者里面也是一样启动服务提供测试对象和服务消费测试对象。然后就可以去Dubbo的可视化界面中进行查看了。
 
提供者这里面已经有两个提供者，一个是本来的服务提供者另外一个是服务消费者启动一个服务的提供者
 
 
 
 
消费者这里面已经有两个消费者，一个是本来的服务消费者另外一个是服务提供者者启动一个服务的消费者
 
 
好了，这里面我们看到无论是服务的提供者还是服务的消费者都绑定到了169.254.120.125这个IP上，这个IP是我的以太网适配器 VMware Network Adapter VMnet8上IV4的IP地址。为啥会绑定到VMnet8的这个网卡上呢？下次再说
 
 

  

     基于springcloud的2个sprigboot项目分别部署在2台服务器上，然后用restTemplate在这2个sprigboot项目互相调用，结果调用不通！可是根据springcloud的架构，只要springboot应用注册在eureka上，就可以互相调用，而且eureka还做了负载均衡。但是为什么在2台服务器就调用不到呢？


 
eureka.instance.prefer-ip-address=true
结果关键之处就在于这个配置项。那么这个配置是什么意思呢？


 配置
 eureka.instance.prefer-ip-address = true
  就可以将IP注册到Eureka Server上，而如果不配置就是机器的主机名。原来只需要配置eureka.instance.prefer-ip-address = true，Spring就会自动为我们获取第一个非回环IP地址。
 



 



 连接地址：http://cloud.spring.io/spring-cloud-static/Camden.SR3/#ignore-network-interfaces