动态代理技术与RPC架构解析

 //方式一：使用Class.forName方法进行包名+类名的定位 
 Class c1=Class.forName("zk.reflect.Person"); 
 //方式二：采用类名.class方法获取反射 
 Class c2=Person.class; 
 //方式三：采用对象名.class方法获取反射（运行过程中） 
 Person ps=new Person(); 
 Class c3 = ps.getClass(); 

//获取类的方法 
Method[] m =c.getMethods(); //获得本类和其父类的全部public方法 
Method[] m2=c.getDeclaredMethods(); //仅获取本类的全部方法(包括私有方法) 
//获取指定方法，并使用 
 //通过实例对象获取反射 
 //Person p =new Person(); 
 //获取Person类对象 
 //Class c=p.getClass(); 
 Class c=Person.class; 
 Person p= (Person) c.newInstance(); 
 //获取该类实例对象中的具体方法--第一个参数要写Person类的方法名称才能匹配上；后面参数是方法参数类型 
 Method m=c.getDeclaredMethod("eat",String.class); 
 //使用invoke方法对反射获取的方法进行激活---第一个参数是实例化对象，后面参数是方法对应参数值 
 String s= (String) m.invoke(p,"zhangkai"); 
 System.out.println(s); 
//获取指定方法，必须加入参数，没有加null；因为存在重载，只有方法名和参数个数两个才能精确定位方法 
Method getid=c.getMethod("getid",null); 
Method setid=c.setMethod("setid",,int.class);    

//User的一些方法 
public interface UserService { 
 String login(String s,String p) throws InterruptedException; 
 void selectById(int id); 
 void delect(); 
} 
//Order的一些方法 
public interface OrderService { 
 String zhuyi(); 
 void select(); 
 String delectById(int id); 
} 

//UserServiceImpl实现类 
public class UserServiceImpl implements UserService { 

 @Override 
 public String login(String name,String password) { 
 String resword="用户名或密码错误！"; 
 if(name.equals("admin") && password.equals("123456")){ 
 resword="登录成功"; 
 } 
 try { 
 Thread.sleep(2000); 
 } catch (InterruptedException e) { 
 e.printStackTrace(); 
 } 
 return resword; 
 } 

 @Override 
 public void selectById(int id) { 
 try { 
 Thread.sleep(1500); 
 } catch (InterruptedException e) { 
 e.printStackTrace(); 
 } 
 System.out.println(id+"的信息如下：----"); 
 } 

 @Override 
 public void delect() { 
 try { 
 Thread.sleep(3000); 
 } catch (InterruptedException e) { 
 e.printStackTrace(); 
 } 
 System.out.println("信息正在删除。。。。。"); 
 } 
} 
//OrderServiceImpl实现类 
public class OrderServiceImpl implements OrderService{ 

 @Override 
 public String zhuyi() { 
 return "订单功能区：---------"; 
 } 

 @Override 
 public void select() { 
 System.out.println("全部订单如下所示--------"); 
 } 

 @Override 
 public String delectById(int id) { 
 String s=id+"的信息正在删除。。。。。"; 
 return s; 
 } 
} 

public class ProxyTest { 
 public static void main(String[] args) throws Exception { 
 //创建一个User类的代理对象，代理对象中也传入了一个新建的User实现类对象 
 UserService userService=ProxyUtils.proxyService(new UserServiceImpl()); 
 String rs = userService.login("admin", "123456"); 
 System.out.println(rs); 
 userService.selectById(2); 
 userService.delect(); 
 //创建一个Order类的代理对象 
 OrderService orderService=ProxyUtils.proxyService(new OrderServiceImpl()); 
 String ss = orderService.delectById(9); 
 System.out.println(ss); 
 } 
} 

//服务端接口 
public interface HelloService { 
 String hello(String name); 
 String hi(String msg); 
} 

//服务实现类 
public class HelloServiceImpl implements HelloService{ 
 @Override 
 public String hello(String name) { 
 return "Hello " + name; 
 } 

 @Override 
 public String hi(String msg) { 
 return "Hi, " + msg; 
 } 
} 

//（重要）服务暴露 
public class RpcProvider { 
 public static void main(String[] args) throws Exception { 
 HelloService service = new HelloServiceImpl(); 
 // 自实现的RpcFramework，RPC框架使用export()方法将服务暴露出来，供客户端消费 
 RpcFramework.export(service, 1234); 
 } 
} 

//(服务引用)消费端通过RPC框架进行远程调用，这也是RPC框架功能之一 
public class RpcConsumer { 
 public static void main(String[] args) throws Exception { 
 // 由RpcFramework类中refer()方法生成的HelloService接口的代理 
 HelloService service = RpcFramework.refer(HelloService.class, "127.0.0.1", 1234); 
 //使用代理对象进行实现类中hello()方法的调用 
 String hello = service.hello("World"); 
 System.out.println("客户端收到远程调用的结果 ： " + hello); 
 } 
} 
//与服务端共享同一个服务接口
public interface HelloService {
 String hello(String name);
 String hi(String msg);
}

public class RpcFramework { 
 /** 
 * 暴露服务 
 * @param service 服务实现 
 * @param port 服务端口 
 * @throws Exception 
 */ 
 public static void export(final Object service, int port) throws Exception { 
 //如果服务和端口存在问题，抛出异常 
 if (service == null) { 
 throw new IllegalArgumentException("service instance == null"); 
 } 
 if (port <= 0 || port > 65535) { 
 throw new IllegalArgumentException("Invalid port " + port); 
 } 
 System.out.println("Export service " + service.getClass().getName() + " on port " + port); 
 // 建立Socket服务端 
 ServerSocket server = new ServerSocket(port); 
 for (; ; ) { 
 try { 
 // 监听Socket请求 
 final Socket socket = server.accept(); 
 new Thread(new Runnable() { 
 @Override 
 public void run() { 
 try { 
 try { 
 /* 获取请求流，Server解析并获取请求*/ 
 // 构建对象输入流，从源中读取对象到程序中 
 ObjectInputStream input = new ObjectInputStream( 
 socket.getInputStream()); 
 try { 

 System.out.println("\nServer解析请求 ： "); 
 String methodName = input.readUTF(); 
 System.out.println("methodName : " + methodName); 
 // 泛型与数组是不兼容的，除了通配符作泛型参数以外 
 Class<?>[] parameterTypes = (Class<?>[])input.readObject(); 
 System.out.println( 
 "parameterTypes : " + Arrays.toString(parameterTypes)); 
 Object[] arguments = (Object[])input.readObject(); 
 System.out.println("arguments : " + Arrays.toString(arguments)); 


 /* Server 处理请求，进行响应*/ 
 ObjectOutputStream output = new ObjectOutputStream( 
 socket.getOutputStream()); 
 try { 
 // service类型为Object的(可以发布任何服务)，故只能通过反射调用处理请求 
 // 反射调用，处理请求 
 Method method = service.getClass().getMethod(methodName, 
 parameterTypes); 
 //invoke方法调用对应方法，得到处理返回值保存在result中 
 Object result = method.invoke(service, arguments); 
 System.out.println("\nServer 处理并生成响应 ："); 
 System.out.println("result : " + result); 
 //将请求处理结果写回socket信息 
 output.writeObject(result); 
 } catch (Throwable t) { 
 output.writeObject(t); 
 } finally { 
 output.close(); 
 } 
 } finally { 
 input.close(); 
 } 
 } finally { 
 socket.close(); 
 } 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 }).start(); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 } 


 /** 
 * 引用服务 
 * 
 * @param <T> 接口泛型 
 * @param interfaceClass 接口类型 
 * @param host 服务器主机名 
 * @param port 服务器端口 
 * @return 远程服务，返回代理对象 
 * @throws Exception 
 */ 
 @SuppressWarnings("unchecked") 
 public static <T> T refer(final Class<T> interfaceClass, final String host, final int port) throws Exception { 
 if (interfaceClass == null) { 
 throw new IllegalArgumentException("Interface class == null"); 
 } 
 // JDK 动态代理的约束，只能实现对接口的代理 
 if (!interfaceClass.isInterface()) { 
 throw new IllegalArgumentException( 
 "The " + interfaceClass.getName() + " must be interface class!"); 
 } 
 if (host == null || host.length() == 0) { 
 throw new IllegalArgumentException("Host == null!"); 
 } 
 if (port <= 0 || port > 65535) { 
 throw new IllegalArgumentException("Invalid port " + port); 
 } 
 System.out.println( 
 "Get remote service " + interfaceClass.getName() + " from server " + host + ":" + port); 

 // JDK 动态代理,使用泛型实现广泛代理 
 T proxy = (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), 
 new Class<?>[] {interfaceClass}, new InvocationHandler() { 
 // invoke方法本意是对目标方法的增强，在这里用于发送RPC请求和接收响应 
 @Override 
 public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable { 
 // 创建Socket客户端，并与服务端建立链接 
 Socket socket = new Socket(host, port); 
 try { 
 /* 客户端向服务端进行请求，并将请求参数写入流中*/ 
 // 将对象写入到对象输出流，并将其发送到Socket流中去 
 ObjectOutputStream output = new ObjectOutputStream( 
 socket.getOutputStream()); 
 try { 
 // 发送请求 
 System.out.println("\nClient发送请求 ： "); 
 output.writeUTF(method.getName()); 
 System.out.println("methodName : " + method.getName()); 
 output.writeObject(method.getParameterTypes()); 
 System.out.println("parameterTypes : " + Arrays.toString(method 
 .getParameterTypes())); 
 output.writeObject(arguments); 
 System.out.println("arguments : " + Arrays.toString(arguments)); 
 /* 客户端读取并返回服务端的响应*/ 
 ObjectInputStream input = new ObjectInputStream( 
 socket.getInputStream()); 
 try { 
 Object result = input.readObject(); 
 //如果result是一个异常说明服务端返回没成功,客户端只能抛出异常 
 if (result instanceof Throwable) { 
 throw (Throwable)result; 
 } 
 System.out.println("\nClient收到响应 ： "); 
 System.out.println("result : " + result); 
 return result; 
 } finally { 
 input.close(); 
 } 
 } finally { 
 output.close(); 
 } 
 } finally { 
 socket.close(); 
 } 
 } 
 }); 
 //给消费端返回代理对象，供使用 
 return proxy; 
 }