精华内容
下载资源
问答
  • 在微服务系统中,为了保证微服务系统的安全,常常使用jwt来鉴权,但是服务内部的相互调用呢。经常有人在微信上问我,我给出一个解决办法,采用Feign的拦截器。 在Feign中开启了hystrix,hystrix默认采用的是线程池作...

    转载请标明出处:
    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...

    上一篇讲解了客户端给服务器发送消息,这一篇讲解客户端和服务器相互发送消息,客户端发送消息给服务器,服务器收到客户端的请求然后返回信息给客户端。

    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上,就可以互相调用,而且...
      
    
        基于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

    展开全文
  • 1、安全组里面,添加3306,授权ip 2、grant all privileges on *.* to root@"x.x.x.x" identified by "密码"; flush privileges; 执行以上命令。x.x.x.x为授权的ip.
  • 接着上一篇博客,客户端的创建我们知道了服务的注册与发现,那么,服务之间是怎么进行互相调用的呢? 我们先看一下服务列表,然后通过实例,来看一下怎么进行服务之间的调用,再稍微看一下源码,看看调用是怎么实现...
  • feign.RetryableException: Connection refused (Connection refused) instance: instance-id: ${spring.application.name}:${server.port} # 指定实例ID,就不会显示主机名了 ip-address: 10.21.19.86 ...
  • 其实不只是能两设备互相通信,只要连接在服务器下的客户端都可以通讯,即服务器可以与多个客户端通讯,这样的话就相当于组了一个局域网,在这个局域网内都是可以实现通讯的。       经过这几天的调试...
  • 前两天写了个简单的服务器和客户端之间的数据传送,主要是为了熟悉一下QTcpsocket和QTcpserver的用法,然后今天在此基础上实现多个客户端之间的相互通信以及利用服务器可以群发信息。(只是供大家参考,勿喷) 代码...
  • 2、若其他服务的接口未做权限处理,参照上文第1点的博文即可。 3、若其他服务的接口做了权限的处理(例如OAuth 2)时该如何访问? a、有做权限处理的服务接口直接调用会造成调用时出现http 401未授权的错误...
  • Android AIDL实现与服务相互调用

    千次阅读 2018-05-30 09:28:35
    问题4 实现与服务之间互相调用 1.在绑定服务时会返回一个实现了AIDL的对象,这样可以通过对象调用服务中对应实现, 2.可以在应用层实现一个AIDL接口的对象,通过绑定服务返回的AIDL对象回传给服务,这样可以在服务中...
  • (3)修改.ssh文件夹和其文件的权限,并重启SSH服务 chmod 700 ~/.ssh chmod 600 ~/.ssh/* service sshd restart (4)将.ssh文件夹中的id_rsa, id_rsa.pub, authorized_keys三个文件拷贝到服务器B的.ssh...
  • 多台Linux服务器SSH相互访问无需密码

    千次阅读 2016-04-11 22:06:52
    2、在每台服务器上将公钥复制到无需登录的服务器上,如192.168.4.200 /244/232/2014台做相互无需密码登录,在每台服务器生成密钥后,在每一台服务器上执行ssh-copy-id的命令;以192.168.4.200为例;其他三台服务器也...
  • 串口实现服务器和客户端相互连接

    千次阅读 2017-09-21 14:48:15
    指向sockaddr_in 的指针和指向sockaddr的指针可以相互转换,这意味着如果一个函数所需参数类型是sockaddr时,你可以在函数调用的时候将一个指向 sockaddr_in的指针转换为指向sockaddr的指针;或者相反。  使用bind...
  • Linux两台服务器相互同步数据方法

    千次阅读 2019-04-05 10:12:32
    使用cp命令的-n参数即可跳过相同的文件 ,但scp却没这个参数,如何实现呢? rsync 它比scp更强大,支持“不覆盖”原目录 例子:rsync -avz --progress /root/client/ root@202.112.23.12:/home/work/ ...
  • Dubbo框架下,服务间如何相互调用

    万次阅读 2018-08-14 00:27:17
    那么不同主机不同服务间是如何调用的? 解决思想:如果是All in one 结构的项目,我们要引用其他类,直接引用即可。但是如果不在同一个项目中如何引用咧。如果调用的类在本项目中没有,则会报语法错误。 有以下两...
  • linux服务器之间免秘钥互相访问

    千次阅读 2017-03-18 21:47:24
    1、在其中一台机器里输入ssh-keygen 一路回车就可以了 2、接下来是把公钥拷贝到另外一台机器里并且把公钥添加到authorized_keys,有一种笨方法是拷贝添加; 但是还有一个很简单的方式,这两步一次性完成,也是一...
  • CentOs虚拟机可以互相ping通,但无法访问虚拟机服务
  • SpringCloud底层服务之间是怎么相互调用的?

    万次阅读 多人点赞 2018-11-22 16:41:10
    这个时候如果别人请求订单服务,订单服务还是可以正常调用库存服务扣减库存,调用仓储服务通知发货。只不过调用积分服务的时候,每次都会报错。 但是如果积分服务都挂了,每次调用都要去卡住几秒钟干啥呢?有意义...
  • 今天更新服务器配置文件时,突然发现无法将本地文件成功粘贴到服务上。 处理办法:打开服务器的任务管理器,在进程中关闭rdpclip.exe。然后,运行-->输入:rdpclip.exe 重新运行这个程序就可以解决问题。 ...
  • // 创建服务器端服务 ServerSocket server = new ServerSocket(10004); // 获取连接过来的客户端,使用ServerSocket的accept方法,没有连接就会等待,阻塞式方法 Socket client = server.accept(); // 获取...
  • 1:加入一中保活唤醒机制,2个service在用户清理内存的时候相互唤醒。 2:消息通知,和唤醒机制一起保持连接,用户收到信息可以打开自己的app应用
  • 这个时候如果别人请求订单服务,订单服务还是可以正常调用库存服务扣减库存,调用仓储服务通知发货。只不过调用积分服务的时候,每次都会报错。但是如果积分服务都挂了,每次调用都要去卡住几秒钟干啥呢?有意义吗?...
  • 首先,整个课程系列需要同学们有一定的基础技能,分别是java、springboot、github以及...好了,大功告成了,其实基于Feign实现服务间调用还是件很容易的事的,希望各位同学可以自己手动实践,来完成服务间的调用。
  • 在我们进行分布式与大数据等学习的时候往往涉及到搭建服务器集群,...将IP设为静态,因为集群需要将IP固定,其中每台虚拟服务器都可以互相通信,包括和宿主主机,并且可以上网,这里用VMware 10和Ubuntu Server 14.0
  • 首先,我选择使用桥接模式,这样就拥有了两台电脑,实现两个电脑可以互相访问彼此的服务器, 在 编辑 -->虚拟网络编辑器中选择桥接模式(底下桥接模式的内容不要选择自动) 然后查看主机的IP地址,子网掩码,默认...
  • 条件:已经拥有一台有公网IP的服务器: user@xx.yy.zz.ww 在局域网A的计算机A1(你想访问的计算机,假设你的用户名为: lsl): ssh -R 2210:localhost:22 user@xx.yy.zz.ww 在局域网B的计算机B1(你想访问的计算机...
  • 我的宿主机是win7,在VM12 pro上安装了centOS7,网络设置为bridge模式主机与虚拟机互PING,但主机无法访问虚拟机服务解决: 1.主机能ping通虚拟机 2.虚拟机也能ping通主机 3.虚拟机能访问自己的服务(前提是虚拟机...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,896
精华内容 31,958
关键字:

互相服务还是相互服务