首先先来理解一下几个概念：

服务器：能够提供信息的计算机或程序。 

客户机：请求信息的计算机或程序

当然，在现实生活中有时候区分客户机与服务器还是比较困难的。因为很多信息都是相互请求、互相提供信息的。

协议：为了保证两台以上的计算机可以顺利地通信，必须有某种相互都必须遵守的条约，计算机中称之为协议，例如我们平时所说的互联网协议。这种协议用四个字节来唯一的表示网络中的一台机器。

端口：网络设计程序中的端口并不是实际存在的，而是一个我们假想的连接器。端口被规定为0~65535之间的一个数。其中的1~1023段接口已经被系统所占用了，我们应该使用1024~65535之间的任意端口号，以免发生冲突。

套接字：网络程序中的套接字是将我们的应用程序与端口连接起来，这个也是一个假象的装置。

那么在JAVA中，我们怎样利用端口和套接字，在客户端和服务器端进行数据传递呢？

我们一般是创建Socket类的对象去使用套接字。接着我们可以利用Socket流对象进行数据传递。例如socket.getOutputStream()和socket.getInputStream();



1、服务器套接字应用

ServerSocket类表示服务器套接字。一般来说，服务器的套接字只可以与一个客户机的套接字相连，如果有多台客户机同时要求与服务器相连，则服务器套接字将会把客户机的套接字存进队列当中，从中按顺序连接。

ServerSocket类的常用构造函数有三个：

public ServerSocket(int port):使用指定的端口创建服务器套接字

public ServerSocket(int port,int backlog):使用指定的端口创建服务器套接字，backlog用来指定队列大小

public ServerSocket(int port,int backlog,InetAddress bindAddr):使用端口号，队列大小及指定的IP地址创建服务器套接字

ServerSocket类常用方法如下：

public Socket accept():等待客户机的请求，如果连接上了，就创建一个套接字，并且将其返回。

public void close():关闭服务器套接字



2、套接字实现

Socket类表示套接字，使用时要指定连接服务器的IP地址及端口号。这个是由客户机创建的，用于连接服务器。当客户机创建了Socket对象后，将立即向指定的端口号和IP地址发送请求连接。与此同时，服务器的套接字会创建新的套接字对象，然后与客户端的套接字连接起来。成功后便可以获取套接字的输入输出流，彼此进行数据交换。

Server类的构造函数有两个：

public Socket(string host,int port):创建指定连接的服务器的套接字，host为主机，port为端口号

public Socket(InetAddress address,int port):创建连接指定服务器的套接字，address表示IP地址对象，port为端口号

Server类常用方法如下：

public int getPort():获取端口号

public Inputstream getInputStream():获取套接字的输入流

public Outputstream getOutputStream():获取套接字的输出流

public synchorized void close():关闭套接字

这是一个关于服务器和客户端之间的输入输出流的关系图： 





3、总结



（1）服务器端程序的编写

1、创建ServerSocket类的对象，利用构造函数ServerSocket(int port)创建一个套接字，并绑定到指定的端口port上。如ServerSocket s = new ServerSocket(2222);2222为端口号

2、调用ServerSocket的函数accept()，监听是否有客户端请求连接。如果有，则接受请求，并返回通信套接字。如Socket sk= s.accept();

3.调用Socket类的输入输出流函数，获取输入流和输出流，开始数据的发送和接受。如PrintStream ps = new PrintStream(sk.getOutputStream())和br  = new BufferedReader(new InputStreamReader(sk.getInputStream()))；

4、关闭套接字。



（2）客户端程序的编写

1、调用socket类的构造函数，创建套接字，并且连接到服务器端。如：Socket sk =new Socket(“127.0.0.1”,2222);解释一下，127.0.0.1为我们本机的IP地址。，2222为端口号

2、调用Socket类的输入输出流函数，获取输入流和输出流，开始数据的发送和接受。如PrintStream ps = new PrintStream(sk.getOutputStream())和br  = new BufferedReader(new InputStreamReader(sk.getInputStream()))；

3、关闭套接字。



4、有关代码

客户端的代码



import java.net.*;
import java.io.*;
import java.util.Scanner;
public class Client 
{
    public static void main(String[] args) 
    {
        try{

        Socket sk =new Socket("127.0.0.1",2222);
        System.out.println("客户端正在开启");
        PrintStream p = new PrintStream(sk.getOutputStream());//将客户端套接字的输出流用printStream包装起来
        System.out.print("请输入需要发送的内容：");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();//输入数据
        p.println(str);//把控制台输入的内容送入被printstream类包装的输出流里面，发送到服务器里
        p.close();//关闭输出流
        sk.close();//关闭socket套接字
        }
        catch(Exception e){e.printStackTrace();}

    }
}

这是服务器端的代码：




import java.io.*;
import java.net.*;
class Server extends Thread
{
    Socket sk;

    public Server(Socket sk)
    {
    this.sk= sk;
    }

    public void run() 
    {     
        BufferedReader br=null;
        try{

        br  = new BufferedReader(new InputStreamReader(sk.getInputStream()));
        String str = br.readLine();
        System.out.println("客户端的数据："+str);
        br.close();
        sk.close();
        }
        catch(IOException e){e.printStackTrace();}
    }



    public static void main(String[] args) throws Exception
    {
        ServerSocket s = new ServerSocket(2222);//创建ServerSocket的套接字，准备与客户端进行连接
        System.out.println("服务器正在等待客户端的连接");
        //同时响应多个客户端的请求
        while(true){
             Socket sk= s.accept();//服务器监听输入
             Server  st = new Server(sk);//创建一个线程，用线程创建一个套接字
             st.start();
        }
    }
}


结果图如下： 



 

在客户端输入“王境泽说真香”，在服务器收到了数据

5、感想

在学习过程中，先后借鉴了很多网上大神的代码，在这里一一感谢这些大神们，没有他们我真的完成不了学校的java课程设计！！谢谢你们~笔芯！！

概述

    Hello,大家好,这篇是我工作记录中的其中一篇文章,在快要下班的时候,我的领导跟我说"对比一下某两个库中互相不存在的表"
像往常一样,我还是处于懵13状态,不过没关系,没有挑战就没有进步嘛,所以我找到了解决方案,并且成功实行了！下面就是我实现的
过程,如果对你有帮助的话帮我评论一下,或者点个赞,谢谢啦~




下载工具

1 首先我登录到其中一台服务器上,下载工具;
  [root@bogon ~]# yum list "mysql-util*"    #名字挺不好记的,所以安装之前可以先列出查看一下;
  [root@bogon ~]# yum install mysql-utilities #使用yum安装,因为会有依赖包,用yum直接解决依赖问题

2 安装完毕后系统就会拥有了"mysqldiff"这个工具,使用此工具来比对两个数据库的不同表
  [root@bogon ~]# mysqldiff --server1=<user>[:<password>]@<host>[:<port>] \
  --server2=<user>[:<password>]@<host>[:<port>] \
  "server1.databasename" "server2.databasename"

  # --server1:指定第一台数据库服务器,后方跟的是格式,"登陆的用户名:密码@主机地址:地址"
  # --server2:指定第二台数据库服务器,后方跟的是格式,"登陆的用户名:密码@主机地址:地址"
  # server1.databasename:指的是第一台数据库服务器中要对比的库
  # server2.databasename:指的是第二台数据库服务器中要对比的库

3 对比结果会直接输出在屏幕上,你可以直接将互相不存在的表全都导出成.sql文件,互相同步,这个工具也拥有同步功能,只不过我
没有使用,毕竟还不是特别熟练,生产环境不敢瞎动,如果有感兴趣的同学可以深入研究一下

ping不同原因：

tftpd32是一个tftp协议传输文件的服务器，主机与开发板连不通，代表两者并没有路由，可以先互相ping一下，如果真的不通，那就关闭Windows主机防火墙和关闭类似于360安全软件之类的软件。然后再ping，如果还是ping不通，可以先ping开发板自己的地址看看能不能ping通，如若不能，该重新配地址了。记得启动网口

====================== ==========

Ubuntu安装tftpd-hpa：


sudo apt-get install xinetd

sudo apt-get install tftp-hpa  // tftp客户端

sudo apt-get install tftpd-hpa  // tftp服务端


 创建tftp文件传输目录：并通过127.0.0.1在本地测试下tftp是否可用


mkdir /tftpboot   //服务器主目录

sudo chmod 777 /tftpboot //改变这个目录的属性可读可写可执行

touch /text1 //测试用的文件1，利用tftp把这个文件传输到tftp服务器的主目录

touch /tftpboot/text2 //测试用的文件2，从服务器中把这个文件取出来


配置tftp文件：


sudo gedit /etc/default/tftpd-hpa


文件修改如下： 

# /etc/default/tftpd-hpa

TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/tftpboot"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="-l -c -s"

 重启tftp服务器：


sudo service tftpd-hpa restart //要加sudo 避免出现stop:未知任务: tftpd-hpa


 开始本地测试：


ifconfig lo up  //先开启回环地址的网络接口，其中lo是我的接口名字，大家根据自己机子对应的127接口修改

root@ubuntu:/# tftp 127.0.0.1

tftp> put text1  //向服务器传送一个text1文件，自动保存在我们设置好的目录/tftpboot

tftp> get text2  //从服务器get一个text2文件, 自动从/tftpboot目录得到text2文件并保存到当前终端所在目录

tftp> q

root@ubuntu:/#


查看tftp是否开启：下面命令都有输出

lsof -i:69 //显示所有打开的端口号为69的服务

netstat -nlp | grep 69 //显示各种网络状态，端口号为69

netstat -a | grep tftp //显示各种tftp服务



 

在我们的cloud中，各个节点之间相互配合、互相支持，大家齐心协力完成工作，但是天佑不测风云，可能存在某一个微服务的某个时刻压力变大导致服务缓慢，甚至出现故障，导致服务不能响应，例如：我们的网站推出新的营销方案，注册即得200元现金，这个时候注册这个节点出现压力过大，服务响应速度变缓，进入瘫痪状态。
而这个时候产品微服务响应还是正常响应。但是如果出现产品微服务大量调用用户微服务，就会出现大量的等待，如果还是持续地调用，则会造成大量请求的积压，导致产品微服务最终也不可用
总结来说：如果一个服务不可用，而其他微服务还大量地调用这个不可用的微服务，也会导致其自身不可用，其自身不可用之后又可能继续蔓延到其他与之相关的微服务上，这样就会使得更多的微服务不可用，最终导致分布式服务瘫痪
那么怎么防止这种情况的发生呢？

Hystrix-断路器就是我们正确的选择了，断路器就如同电路中的保险丝，如果电器耗电大，导致电流过大，那么保险丝就会熔断，从而保证用电的安全。同样地，在微服务系统之间大量调用可能导致服务消费者自身出现瘫痪的情况下，断路器就会将这些积压的大量请求“熔断”，来保证其自身服务可用，而不会蔓延到其他微服务系统上。通过这样的断路机制可以保持各个微服务持续可用。

在Spring Cloud中断路器是由NetFlix的Hystrix实现的，它默认监控微服务之间的调用超时时间为2000 ms（2 s），如果超过这个超时时间，它就会根据你的配置使用其他方法进行响应。
我们做第一次实验，还在在user节点中，修改之前能正常调用的getUserById方法



新增了这段方法，就是让我们的程序休眠很长的时候以后在返回相应的结果值
 @GetMapping("/user/{id}")
    public User getUserById(@PathVariable("id")long id){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        User user=new User();
        user.setUserId(id);
        user.setUserName("user1");
        user.setUserPwd("admin");
        return user;
    }

再观测product节点中相应的调用



我们这里使用Feign访问user节点下边的 @GetMapping("/user/{id}")这个方法

在浏览器中访问结果如下



我们看product后台打印的错误信息



我们发现，并不是程序有错误(在没加入睡眠代码之前，这个程序是能正常运行的)，发生的错误是Read timed out错误(访问超时)
这里没做任何操作，是因为ribbon有个默认的超时机制(好像是1.5S什么的，记不清了)，但是有时候我们的服务本身就需要容许一点超时，我们可以自己配置一下，在product节点的配置文件中添加如下配置
ribbon:
  ReadTimeout: 6000
  ConnectTimeout: 3000

(idea打死没有提示，直接放上去就好了)

这样我们配置了ReadTimeout: 6000为6s，然后在user节点中是睡眠5s，再次测试，经历很长时间等待之后(大概5s之后)，我们得到了我们的需求结果



这样可以避免了ribbon默认超时的困扰(特殊情况比如容许3s的情况也有)

我们继续修改为：
ribbon:
  ReadTimeout: 3000
  ConnectTimeout: 3000

超过3s就真的有点过分了，所以设置为3s

然后在项目中引入我们的断路器—Hystrix
第一步：引入pom文件
 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
  </dependency>

第二步：在你的spring cloud项目中启用Hystrix

启用的方式非常简单，就是在你的main入口文件处加入这样一句配置
@EnableCircuitBreaker



第三部：在需要降级服务的方法位置制定相应的规则

我们现在设置全局ribbon超时时间是3000ms，而Hystrix的默认超时时间是1000ms所以我们可以直接配置一下：



在getUser方法上边标记位置设置

@HystrixCommand(fallbackMethod = “error”)

意思就是说，在断路情况发生的时候，麻烦去找error方法处理断路情况

代码如下
 // 测试
    @GetMapping("product/getUser/{id}")
    @HystrixCommand(fallbackMethod = "error")
    public User getUser(@PathVariable int id) {
        User user = service.getUser(id);
        return user;
    }

PS：这里请忽略返回值，一般情况下我们不会直接返回对象，而应该是封装的response信息，里边包含data、status等信息，这里为了做实验直接写的返回user
然后我们这里规定了断路情况下去找error方法处理，所以我们先写一个error方法
 /**
     * 降级服务调用方法
     * @return
     */
    public String error() {
        return "超时";
    }

然后重启，运行服务，并且访问该方法，然后结果报错，错误信息如下：



这里的错误原因是我们做实验引发的必要错误，原因是我们的getUser这个方法，参数是public User getUser(@PathVariable int id) {  但是我们的error方法没有任何参数，这里需要两边保持一样的参数，我们修改为



然后再次执行，依旧报错：



重点是这句话：

com.bigsoft.bigsoftproduct.controller.UserController.error(int)’ must

return: class com.bigsoft.bigsoftproduct.pojo.User or its subclass

也就是error方法的返回值也必须和getUser方法保持一直(再次说，一般返回值我们会统一封装的，这里做实验随意写的返回值出错了)

这里强行让返回值统一一下



这里强行返回了和getUser方法一直的(为了做实验)，再次执行

这里我们user节点提供的服务睡眠了5000s，而Hystrix默认1000ms会启用断路，所以实验结果如下



这里返回到了error方法里边返回的空的User，证明实验完成了。
这里我们的Hystrix默认的断路时间是1000ms，我们也可以对这个时间做修改,即认为设置段榕时间(根据我们的服务器的实际工作性能来设置)，设置方式有两种，一种是注解的方式，注解方式如下：
 // 测试
    @GetMapping("product/getUser/{id}")
    @HystrixCommand(fallbackMethod = "error",
            commandProperties = { //设置属性
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3200")
            })
    public User getUser(@PathVariable int id) {
        User user = service.getUser(id);
        return user;
    }

这里我们在注解中设置了断熔属性，设置断熔时间为3200ms

第二种方式是配置的方式，代码如下，在我们配置文件appliocation.yml文件中：
hystrix:
  command:
    default:
      execution:
        timeout:
          #如果enabled设置为false，则请求超时交给ribbon控制,为true,则超时作为熔断根据
          enabled: true
        isolation:
          thread:
            timeoutInMilliseconds: 5000 #断路器超时时间，默认1000ms

这里设置timeoutInMilliseconds的时间为5000ms（当两种方式同时设置的时候，注解方式有限）
特别注意：

这里有个小坑，就是当你单独使用Hystrix的时候上边的代码已经可以生效了，但是当我们fegin+Hystrix一起的时候，我们会发现上述代码失效，原因就是这里一共同时有两个超时时间，一为Hystrix的超时时间，二为fegin的超时时间
那他们俩以哪个为主主要是看上述文件中我们配置的

enabled: true

这个配置了，原则如下：

如果hystrix.command.default.execution.timeout.enabled为true,则会有两个执行方法超时的配置,一个就是ribbon的ReadTimeout,一个就是熔断器hystrix的timeoutInMilliseconds, 此时谁的值小谁生效

如果hystrix.command.default.execution.timeout.enabled为false,则熔断器不进行超时熔断,而是根据ribbon的ReadTimeout抛出的异常而熔断,也就是取决于ribbon

所以我们配置的最终代码如下：
ribbon:
  OkToRetryOnAllOperations: false #对所有操作请求都进行重试,默认false
  ReadTimeout: 3000   #负载均衡超时时间
  ConnectTimeout: 2000 #ribbon请求连接的超时时间
  MaxAutoRetries: 0     #对当前实例的重试次数，默认0
  MaxAutoRetriesNextServer: 1 #对切换实例的重试次数，默认1

hystrix:
  command:
    default:
      execution:
        timeout:
                   #如果enabled设置为false，则请求超时交给ribbon控制,为true,则超时作为熔断根据(两个值一起生效，谁的值小谁生效)
          enabled: true

代码中配置如下：
 // 测试
    @GetMapping("product/getUser/{id}")
    @HystrixCommand(fallbackMethod = "error",
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3200")
            })
    public User getUser(@PathVariable int id) {
        User user = service.getUser(id);
        return user;
    }

在我们user节点代码如下
  @GetMapping("/user/{id}")
    public User getUserById(@PathVariable("id")long id){
        try {
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        User user=new User();
        user.setUserId(id);
        user.setUserName("user1");
        user.setUserPwd("admin");
        return user;
    }


现在我们的配置就是user节点休眠2500ms做出响应，而我们的projuct节点在3200ms的时候才出发熔断，我们来测试，根据刚才的结论，我们现在说过当设置hystrix.command.default.execution.timeout.enabled为true时候，ribbon的timneout和execution.isolation.thread.timeoutInMilliseconds这两个值一起生效，而且谁的值小谁生效，这里ribbon的值为3000，理应ribbon的值生效

所以我们看实验1：(ribbon3000，Hystrix3200，服务延时2500)



发现正常执行，然后我们进行实验2：



设置Hystrix的时间为2600ms



设置ribbon的超时时间为2000ms



user节点延时时间为2500ms

实验结果如下：



我们发现被熔断了，这符合我们上述的规律，当我们同时设置ribbon超时时间和Hystrix的超时时间，hystrix.command.default.execution.timeout.enabled为true时候谁的超时时间短算谁的