rpc代码

CalculateRpcRequest类

private static final long serialVersionUID = 7503710091945320739L;

private String method;

private int  i;
private int  j;
public String getMethod() {
	return method;
}
public void setMethod(String method) {
	this.method = method;
}
public int getI() {
	return i;
}
public void setI(int i) {
	this.i = i;
}
public int getJ() {
	return j;
}
public void setJ(int j) {
	this.j = j;
}
public static long getSerialversionuid() {
	return serialVersionUID;
}

接口Calculator
public interface Calculator {

int sub(int i, int j) throws IOException, ClassNotFoundException;

}
实现接口类
public class CalculatorImpl implements Calculator {

public int sub(int i,int j) {
	return i-j;
}

}
ProviderApp类
package com.sexycode.simplerpc.provider.app;

import com.sexycode.simplerpc.provider.service.Calculator;
import com.sexycode.simplerpc.provider.service.CalculatorImpl;
import com.sexycode.simplerpc.reuqest.CalculateRpcRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**

• @author: hzy created on 2018/05/02
  */
  public class ProviderApp {
  private static Logger log = LoggerFactory.getLogger(ProviderApp.class);

  private Calculator calculator = new CalculatorImpl();

  public static void main(String[] args) throws IOException {
  new ProviderApp().run();
  }

  private void run() throws IOException {
  ServerSocket listener = new ServerSocket(9090);
  try {
  while (true) {
  Socket socket = listener.accept();
  try {
  // 将请求反序列化
  ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
  Object object = objectInputStream.readObject();

               log.info("request is {}", object);
  
               // 调用服务
               int result = 0;
               if (object instanceof CalculateRpcRequest) {
                   CalculateRpcRequest calculateRpcRequest = (CalculateRpcRequest) object;
                   if ("sub".equals(calculateRpcRequest.getMethod())) {
                       result = calculator.sub(calculateRpcRequest.getI(), calculateRpcRequest.getJ());
                   } else {
                       throw new UnsupportedOperationException();
                   }
               }
  
               // 返回结果
               ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
               objectOutputStream.writeObject(new Integer(result));
           } catch (Exception e) {
               log.error("fail", e);
           } finally {
               socket.close();
           }
       }
   } finally {
       listener.close();
   }
  

  }

}
Rpc实现类
package com.sexycode.simplerpc.comsumer.service;

import com.sexycode.simplerpc.provider.service.Calculator;
import com.sexycode.simplerpc.reuqest.CalculateRpcRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

public class CalculatorRemoteImpl implements Calculator {
public static final int PORT = 8080;
private static Logger log = LoggerFactory.getLogger(CalculatorRemoteImpl.class);
public int add(int a, int b) throws UnknownHostException, IOException {
List addressList = lookupProviders(“Calculator.sub”);
String address = chooseTarget(addressList);
Socket socket = new Socket(address, PORT);
// 将请求序列化
CalculateRpcRequest calculateRpcRequest = generateRequest(a, b);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
// 将请求发给服务提供方
objectOutputStream.writeObject(calculateRpcRequest);
// 将响应体反序列化
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
Object response = null;
try {
response = objectInputStream.readObject();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
log.info(“response is {}”, response);
if (response instanceof Integer) {
return (Integer) response;
} else {
throw new InternalError();
}

}
public int  sub(int  i,int  j) throws IOException, ClassNotFoundException {
	List<String> subList = lookupProviders("Calculator.sub");
	 String address = chooseTarget(subList);
     Socket socket = new Socket(address, PORT);
     // 将请求序列化
     CalculateRpcRequest calculateRpcRequest = generateRequest(i, j);
     ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
     // 将请求发给服务提供方
     objectOutputStream.writeObject(calculateRpcRequest);
     // 将响应体反序列化
     ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
     int response = (Integer) objectInputStream.readObject();
     log.info("response is {}", response);
      return   response;
     

}







private CalculateRpcRequest generateRequest(int  i,int j) {
	 CalculateRpcRequest calculateRpcRequest = new CalculateRpcRequest();
     calculateRpcRequest.setI(i);
     calculateRpcRequest.setJ(j);
     calculateRpcRequest.setMethod("sub");
     return calculateRpcRequest;
}

private String chooseTarget(List<String> providers) {
    if (null == providers || providers.size() == 0) {
        throw new IllegalArgumentException();
    }
    return providers.get(0);
}

public static List<String> lookupProviders(String name) {
    List<String> strings = new ArrayList();
    strings.add("127.0.0.1");
    return strings;
}

}
程序入口
public class ComsumerApp {
private static Logger log = LoggerFactory.getLogger(ComsumerApp.class);
public static void main(String[] args) throws UnknownHostException, IOException, ClassNotFoundException {

    Calculator calculator2 = new CalculatorRemoteImpl();
   int dataresult=calculator2.sub(5,3);
    log.info("result is {}", dataresult);
    
}

}