实现了如下接口:
HelloServices 代码如下:
package consumer.service;
public interface HelloServices {
String sayHi(String name);
}
HelloServiceImpl 代码如下:
public class HelloServiceImpl implements HelloServices {
@Override
public String sayHi(String name) {
return "Hello "+name+" ^_^";
}
}
上部分的代码,是声明微服务的接口规范(HelloServices)以及对应接口规范的具体实现(HelloServiceImpl )
通过上面的分析我们可以知道,微服务本身,是不具备任何底层的能力。
他只与业务相关
他主要是实现了如下接口
Service.class代码如下:功能说明参考注释
public interface Service {
//停止服务
public void stop();
//开始服务
public void start() throws IOException;
//注册服务,注册服务,就是讲接口,以及对应的实现,放到了一个Map中
public void register(Class serviceInterface, Class impl);
//判断当前服务是否在运行
public boolean isRunning();
//获取使用的端口
public int getPort();
}
FactoryService.class的成员变量
private static ExecutorService executorService=
Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private static final HashMap serviceRegistry=
new HashMap<>();
private static int port;
private static boolean isRunning = false;
1、ExecutorService是Java提供的线程池,也就是说,每次我们需要使用线程的时候,可以通过ExecutorService获得线程。它可以有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞,同时提供定时执行、定期执行、单线程、并发数控制等功能,也不用使用TimerTask了。
2、serviceRegistry 本质上是一个Map,存放的key是服务的全路径名称(接口),value是具体类(接口实现类)
相关的put操作如下:
serviceServer.register(HelloServices.class, HelloServiceImpl.class);
@Override
public void register(Class serviceInterface, Class impl) {
print("Map key>"+serviceInterface.getName());
print("Map value>"+impl);
serviceRegistry.put(serviceInterface.getName(), impl);
}
start方法,是所有接口中最核心的接口
@Override
public void start() throws IOException{
ServerSocket serverSocket=new ServerSocket();
serverSocket.bind(new InetSocketAddress(port));
try {
while (true){
executorService.execute(new ServiceTask(serverSocket.accept()));
}
}finally {
serverSocket.close();
}
}
start的相关类以及方法说明:
1、ServerSocket类
ServerSocket(int port):创建绑定到特定端口的服务器套接字。
accept():侦听并接受到此套接字的连接。
getInetAddress():返回此服务器套接字的本地地址。
2、executorService.execute(new Runable());
启动一个线程 ,加入线程池
具体线程如下:
public ServiceTask(Socket client){this.client=client;}
@Override
public void run() {
//将对象作为输入输出流
ObjectInputStream input=null;
ObjectOutputStream output=null;
try {
input=new ObjectInputStream(client.getInputStream());
String serviceName=input.readUTF();
String methodName=input.readUTF();
Class>[] paramterTypes= (Class>[]) input.readObject();
Object[] arguments=(Object[]) input.readObject();
Class serviceClass=serviceRegistry.get(serviceName);
if(serviceClass==null){throw new ClassNotFoundException();}
Method method=serviceClass.getMethod(methodName,paramterTypes);
Object result=method.invoke(serviceClass.newInstance(),arguments);
output = new ObjectOutputStream(client.getOutputStream());
output.writeObject(result);
}
...
}
相关方法说明:
readUTF():readUTF读取的必须是writeUTF写下的字符串。
扩展【read()、readLine()】与readUTF()的区别于联系。
Method getMethod(String name, Class>… parameterTypes)
//返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。
//getMethod第一个参数是方法名,第二个参数是该方法的参数类型,
//因为存在同方法名不同参数这种情况,所以只有同时指定方法名和参数类型才能唯一确定一个方法
Method method = XXX.getClass().getMethod(methodName,new Class[0]);
获取该类的Class Type,通过getMethod方法获取Method对象,通过调用invoke方法来执行对象的某个方法;
构造方法,传递socket连接的client
这个client,会被【消费者】连接,消费者连接到端口之后,进行请求。
run方法执行说明:
1、获取client中,客户端中输入流。(按照消费者中心的消息发送规则,获取到相关的输入流)
/*
参数 proxy 指代理类,
method表示被代理的方法,
args为 method 中的参数数组,
返回值Object为代理实例的方法调用返回的值
*/
output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(serviceInterface.getName());
output.writeUTF(method.getName());
output.writeObject(method.getParameterTypes());
output.writeObject(args);
3、获取到serviceName即,serviceInterface.getName()
获取到methodName即,method.getName()
获取到 Class>[] paramterTypes 即 method.getParameterTypes()【参数类型数组】
获取到 Object[] arguments 即、args【参数对象数组】
4、通过客户端在socket中传输的serviceName,
在注册中心的注册列表【HashMap
可以获取到注册列表中,以及被注册了的该服务名称,所对应的具体类
5、得到了具体类之后,使用
serviceClass.getMethod(methodName,paramterTypes);
可以获取到具体的方法,因为java语言中,有重载的存在,此方法的参数中除了需要方法名称以外,还需要方法的具体参数
6、得到具体的方法之后,可以代理执行此方法
method.invoke(serviceClass.newInstance(),arguments);
invoke参数中的arguments,是传递到此方法的参数
7、通过步骤6,可以获取到方法执行后的结果。再讲结果写入socket,返回到消费者。
消费者如何接受的呢?这里我们就要讲到消费者中心的动态代理的实现。
public class RPCClient {
public static T getRemoteProxyObj(final Class> serviceInterface
, final InetSocketAddress addr) {
return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class>[]{serviceInterface},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = null;
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
socket = new Socket();
socket.connect(addr);
output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(serviceInterface.getName());
output.writeUTF(method.getName());
output.writeObject(method.getParameterTypes());
output.writeObject(args);
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
}
......
}
});
}
}
getRemoteProxyObj方法,是客户端调用远程服务的核心原理。
该方法有两个参数
Class> serviceInterface。需要远程服务的接口。消费者只关心服务的接口是什么,接口中定义有哪些方法,并不关心方法的具体实现。
InetSocketAddress addr。与服务通信的连接地址
/*
参数 proxy 指代理类,
method表示被代理的方法,
args为 method 中的参数数组,
返回值Object为代理实例的方法调用返回的值
*/
这里,再写一遍invoke方法的参数说明
然后,我们再来看此方法内部究竟实现了什么。
【扩展:Proxy 动态代理的原理】
通过如下代码实现对象的创建:
HelloServices service = RPCClient.
getRemoteProxyObj(HelloServices.class,
new InetSocketAddress("localhost", 8088));
通过如下代码实现方法调用:
String str=service.sayHi("test")
请求流程简述:
1、客户端得到接口,以及和服务器通信的地址
2、声明动态代理。
3、当客户端,请求调用接口的方法时,实际执行的是invoke内的代码。
4、在invoke中,会通过socket向服务器发送输入流
5、在invoke中,等待服务器响应输出流(参考service部分,请求的业务实现是在service层,service层执行了方法,并写入了执行结果到输出流)
6、在invoke中,返回输出流中的Object对象,到调用的方法。
(T) Proxy.newProxyInstance(
serviceInterface.getClassLoader(),
new Class>[]{serviceInterface},
new InvocationHandler() {}
);
动态代理说明:
1、在java中规定,要想产生一个对象的代理对象,那么这个对象必须要有一个接口
2、参数说明
loader: 用哪个类加载器去加载代理对象
interfaces:动态代理类需要实现的接口
Handler:动态代理方法在执行时,会调用Handler里面的invoke方法去执行
参考
https://www.cnblogs.com/codingexperience/p/5930752.html#4098476