package com.demo.dynamic.provide;

public interface HiService {
    public String hi(String username);
}

package com.demo.dynamic.provide.impl;

import com.demo.dynamic.provide.HiService;

public class HiServiceImpl implements HiService {

    @Override
    public String hi(String username) {
        System.out.println("username: " + username);
        return "hi " + username;
    }
}

package com.demo.dynamic.client;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicHiSubject implements InvocationHandler {
    // 需要代理的真實對象
    private Object target = null;

    public DynamicHiSubject(Object object) {
        // 綁定真實對象
        this.target = object;
    }

    // 調(diào)用真實對象的方法并執(zhí)行
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("start now ......");

        Object retObj = method.invoke(target, args);

        System.out.println("end over");

        return retObj;
    }
}

package com.demo.dynamic.test;

import com.demo.dynamic.client.DynamicHiSubject;
import com.demo.dynamic.provide.HiService;
import com.demo.dynamic.provide.impl.HiServiceImpl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args){
        // 聲明一個真實的服務(wù)端對象
        HiService hiService = new HiServiceImpl();
        // 聲明一個代理類對象，并在構(gòu)造器中進行代理對象和真實對象的綁定
        InvocationHandler handler = new DynamicHiSubject(hiService);
        // 生成代理對象實例
        // 第一個參數(shù)加載代理對象，第二個參數(shù)指定服務(wù)端接口，第三個參數(shù)將代理對象關(guān)聯(lián)到InvocationHandler
        HiService hiServiceProxy = (HiService) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
                hiService.getClass().getInterfaces(),
                handler);

        String retStr = hiServiceProxy.hi("lilei");

        System.out.println(retStr);
    }
}

start now ......
username: lilei
end over
hi lilei

package com.demo.serial.domain;

import java.io.Serializable;

public class Person implements Serializable {

    String name = "zhangsan";
}

package com.demo.serial.test;

import com.demo.serial.domain.Person;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class PersonTest {

    public static void main(String args[]) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp_person.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(new Person());
        oos.close();
    }
}

package com.demo.rpc.service;

public interface HiService {
    public String sayHi(String username);
}

package com.demo.rpc.service.impl;

import com.demo.rpc.service.HiService;

public class HiServiceImpl implements HiService {
    @Override
    public String sayHi(String username) {
        return username != null ? "hi, " + username : "hi";
    }
}

package com.demo.rpc;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class RpcRegister {

    static Executor executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public static void register(String host, int port) throws Exception {
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(host, port));

        try{
            while (true) {
                executor.execute(new RegisterTask(serverSocket.accept()));
            }
        } finally {
            serverSocket.close();
        }
    }

    private static class RegisterTask implements Runnable {

        Socket socket = null;

        public RegisterTask(Socket client) {
            this.socket = client;
        }

        @Override
        public void run() {
            ObjectInputStream inputStream = null;
            ObjectOutputStream outputStream = null;
            try {
                inputStream = new ObjectInputStream(socket.getInputStream());
                // 第一個字符串是接口名
                String interfaceName = inputStream.readUTF();
                // 類加載
                Class service = Class.forName(interfaceName);
                // 第二個字符串是方法名
                String methodName = inputStream.readUTF();
                // 第三個對象是參數(shù)類型
                Class[] parameterTypes = (Class[])inputStream.readObject();
                // 第四個對象是參數(shù)值
                Object[] arguments = (Object[])inputStream.readObject();
                // 使用反射機制，調(diào)用業(yè)務(wù)邏輯
                Method method = service.getMethod(methodName, parameterTypes);
                Object result = method.invoke(service.newInstance(), arguments);
                // 返回數(shù)據(jù)
                outputStream = new ObjectOutputStream(socket.getOutputStream());
                outputStream.writeObject(result);

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (outputStream != null) {
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

package com.demo.rpc;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;

public class RpcClient {
    public T call(final Class serviceClass, final InetSocketAddress addr) {
        return (T) Proxy.newProxyInstance(serviceClass.getClassLoader(),
                new Class[]{serviceClass.getInterfaces()[0]},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Socket socket = null;
                        ObjectOutputStream outputStream = null;
                        ObjectInputStream inputStream = null;
                        try {
                            socket = new Socket();
                            socket.connect(addr);
                            outputStream = new ObjectOutputStream(socket.getOutputStream());
                            // 設(shè)置請求代理的類名稱
                            outputStream.writeUTF(serviceClass.getName());
                            // 設(shè)置請求方法名
                            outputStream.writeUTF(method.getName());
                            // 設(shè)置請求方法參數(shù)類型
                            outputStream.writeObject(method.getParameterTypes());
                            // 設(shè)置請求方法參數(shù)
                            outputStream.writeObject(args);
                            inputStream = new ObjectInputStream(socket.getInputStream());
                            return inputStream.readObject();
                        } finally {
                            if (socket != null) {
                                socket.close();
                            }
                            if (outputStream != null) {
                                outputStream.close();
                            }
                            if (inputStream != null) {
                                inputStream.close();
                            }
                        }
                    }
                });
    }
}

package com.demo.rpc;

public class ServerStart {
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    RpcRegister.register("127.0.0.1", 8088);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

package com.demo.rpc;

import com.demo.rpc.service.HiService;
import com.demo.rpc.service.impl.HiServiceImpl;

import java.net.InetSocketAddress;

public class ClientStart {
    public static void main(String[] args){
        RpcClient rpcClient = new RpcClient<>();

        HiService hiService = rpcClient.call(HiServiceImpl.class, new InetSocketAddress("127.0.0.1", 8088));

        System.out.println(hiService.sayHi("China Qingdao"));
    }
}

hi, China Qingdao