大数据_RPC

package hdfs.proxy.java;

public interface MyService {

    //真正对象实现的接口：业务的逻辑
    public void method1();

    public void method2();
}

package hdfs.proxy.java;

public class MyServiceImpl implements MyService {

    @Override
    public void method1() {
        System.out.println("************ method1  ***************");
    }

    @Override
    public void method2() {
        System.out.println("************ method2  ***************");

    }

}

package hdfs.proxy.java;

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

public class TestMain {

    public static void main(String[] args) {
        //创建真正的对象
        MyService obj = new MyServiceImpl();

        //obj.method1();  ---> 都是直接调用真正对象
        //obj.method2();  ---> 都是直接调用真正对象

        /*
         * Object Proxy.newProxyInstance(ClassLoader loader, 类加载器，代理对象跟真正对象是同一个类加载器(java虚拟机就可以看做是类的加载器)
                                      Class<?>[] interfaces, 真正对象实现的接口
                                      InvocationHandler h) 如何处理客户端的调用

                返回值：就是代理对象
         */
        //生成obj的代理对象，并且重写method2的逻辑
        MyService proxy = (MyService) Proxy.newProxyInstance(TestMain.class.getClassLoader(), 
                               obj.getClass().getInterfaces(), 
                               new InvocationHandler() {

                                @Override
                                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                    // 表示如何处理客户端的调用
                                    if(method.getName().equals("method2")){
                                        //表示客户端调用了method2
                                        System.out.println("in proxy：method2");
                                        return null;
                                    }else{
                                        //其他方法：不感兴趣
                                        return method.invoke(obj, args);
                                    }
                                }
                            });

        //通过代理对象进行调用
        proxy.method1();
        proxy.method2();

    }

}

HDFS的底层原理
1、Java的动态代理对象
    再举一个例子：数据库的连接池 ----> 返回的Connection，不是真正的Connection，而是一个代理对象
                  实现一个接口：DataSource
                  准备环境：安装一个MySQL数据库 

                Hive的安装
                在虚拟机上安装MySQL：
                yum remove mysql-libs 
                rpm -ivh mysql-community-common-5.7.19-1.el7.x86_64.rpm
                rpm -ivh mysql-community-libs-5.7.19-1.el7.x86_64.rpm
                rpm -ivh mysql-community-client-5.7.19-1.el7.x86_64.rpm
                rpm -ivh mysql-community-server-5.7.19-1.el7.x86_64.rpm
                rpm -ivh mysql-community-devel-5.7.19-1.el7.x86_64.rpm  （可选）

                    启动MySQL：service mysqld start
                    或者：systemctl start mysqld.service

                    查看root用户的密码：cat /var/log/mysqld.log | grep password
                    登录后修改密码：alter user 'root'@'localhost' identified by 'Welcome_1';

                MySQL数据库的配置：
                创建一个新的数据库：create database hive;
                创建一个新的用户：
                  create user 'hiveowner'@'%' identified by 'Welcome_1';

                给该用户授权
                   grant all on hive.* TO 'hiveowner'@'%'; 
                   grant all on hive.* TO 'hiveowner'@'localhost' identified by 'Welcome_1';                  

2、RPC:RPC（Remote Procedure Call）——远程过程调用，类似Web Service

package hdfs.proxy.datasource;

import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.logging.Logger;

import javax.sql.DataSource;

public class MyDataSourcePool implements DataSource {

    //初始化一下：创建10个链接放入连接池
    private static String driver = "com.mysql.jdbc.Driver";
    private static String url = "jdbc:mysql://192.168.157.11:3306/hive";
    private static String user = "hiveowner";
    private static String password = "Welcome_1";

    //定义一个链表来保存10个链接
    private static LinkedList<Connection> dataSource = new LinkedList<>();
    static{
        try{
            //注册驱动
            Class.forName(driver);
            //获取连接
            for(int i=0;i<10;i++){
                dataSource.add(DriverManager.getConnection(url, user, password));
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }


    @Override
    public Connection getConnection() throws SQLException {
        // 表示从连接池中获取连接
//      if(dataSource.size() > 0){
//          //有连接，这里返回的链接是真正的对象，现在返回一个代理对象，并且重写close方法
//          return dataSource.removeFirst();//从链表的第一个头上面摘一个连接过来。
//      }else{
//          throw new SQLException("系统忙，请稍后......");
//      }

        if(dataSource.size() > 0){
            //真正对象
            Connection conn = dataSource.removeFirst();

            //生成代理对象
            Connection proxy = (Connection) Proxy.newProxyInstance(MyDataSourcePool.class.getClassLoader(), 
                                   conn.getClass().getInterfaces(), 
                                   new InvocationHandler() {

                                    @Override
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                        // 重写close方法
                                        if(method.getName().equals("close")){
                                            //将链接还池
                                            System.out.println("将链接还池");
                                            dataSource.add(conn);
                                            return null;
                                        }else{
                                            //其他方法直接 调用真正的对象完成
                                            return method.invoke(conn, args);
                                        }
                                    }
                                });

            return proxy;
        }else{
            throw new SQLException("系统忙，请稍后......");
        }

    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        // TODO Auto-generated method stub

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        // TODO Auto-generated method stub

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

}

package hdfs.proxy.datasource;

import java.sql.Connection;
import java.sql.SQLException;

public class TestDataSourceMain {

    public static void main(String[] args) throws Exception {
        //创建一个连接池
        MyDataSourcePool pool = new MyDataSourcePool();

        //取出链接使用
        for(int i=0;i<11;i++){
            Connection conn = pool.getConnection();

            System.out.println("第"+i + "个："+ conn);

            //关闭
            conn.close(); //----> 调用的是真正对象Connection.close方法  把该链接还给数据库，而不是还给连接池
        }

    }

}

package hdfs.rpc.server;

import org.apache.hadoop.ipc.VersionedProtocol;

public interface MyBusiness extends VersionedProtocol {

    //指定一个版本号，使用这个版本号来创建签名
    public static long versionID = 1;

    //定义自己的业务方法
    public String sayHello(String name);
}

package hdfs.rpc.server;

import java.io.IOException;

import org.apache.hadoop.ipc.ProtocolSignature;

public class MyBusinessImpl implements MyBusiness {

    @Override
    public ProtocolSignature getProtocolSignature(String arg0, long arg1, int arg2) throws IOException {
        // 使用versionID创建签名
        return new ProtocolSignature(MyBusiness.versionID, null);
    }

    @Override
    public long getProtocolVersion(String arg0, long arg1) throws IOException {
        // 返回ID
        return MyBusiness.versionID;
    }

    @Override
    public String sayHello(String name) {
        System.out.println("调用到了Server端的方法");
        // 业务方法
        return "Hello " + name;
    }
}

package hdfs.rpc.server;

import java.io.IOException;

import org.apache.hadoop.HadoopIllegalArgumentException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.ipc.RPC;
import org.apache.hadoop.ipc.RPC.Server;

public class RPCServer {

    public static void main(String[] args) throws Exception {
        // 创建一个RPC Server
        RPC.Builder builder = new RPC.Builder(new Configuration());

        //指定Server的地址和端口
        builder.setBindAddress("localhost");
        builder.setPort(7788);

        //发布我的程序
        builder.setProtocol(MyBusiness.class);//定义的接口
        builder.setInstance(new MyBusinessImpl());//发布接口的实现

        //创建Server
        Server server = builder.build();
        //启动Server
        server.start();
    }
}

package hdfs.rpc.client;

import java.io.IOException;
import java.net.InetSocketAddress;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.ipc.RPC;

import hdfs.rpc.server.MyBusiness;

public class RPCClient {

    public static void main(String[] args) throws Exception {
        // 调用Server的功能
        MyBusiness proxy = RPC.getProxy(MyBusiness.class,    //调用的接口
                                         MyBusiness.versionID,       //版本的ID ，必须跟服务器端一致
                                         new InetSocketAddress("localhost", 7788),    //服务器端的地址
                                         new Configuration());

        System.out.println(proxy.sayHello("Tom"));
    }

}