大数据正式12

最新推荐文章于 2022-11-09 16:15:53 发布
最新推荐文章于 2022-11-09 16:15:53 发布
阅读量307 收藏
点赞数
分类专栏： 达内实训 大数据学习痕迹
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eieiei438/article/details/78615446
版权

大数据正式12

JDBC

  • JDBC概述
    • 数据库驱动：数据库厂商提供的用来操作数据库的jar包
    • 传统的数据库连接与jdbc的支持
  • JDBC简介
    • 由于各大数据库厂商提供的数据库驱动各不相同, 导致了开发人员的学习成本十分的高. SUN公司为了简化数据库的操作, 提供了一套规范, 本质上就是一大堆的接口, 要求各大数据库厂商在提供驱动时都要实现JDBC这套接口, 实现之后, 只要学会JDBC这套接口, 所有的数据库驱动就都会使用了!
    • JDBC由两个包组成, 分别是java.sql和javax.sql, 目前已经被集成到javase规范中!
    • 需要注意的是: JDBC中包含的就是一段接口, 真实操作数据库的代码都在具体的数据库驱动中. 也就是说在开发数据库程序时, 除了要导入JDBC相关的包之外, 还需要导入具体的数据库驱动包.
  • 在开发之前，首先要导入驱动jar包 

    Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //1.注册数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取数据库连接
            conn = DriverManager.getConnection("jdbc:mysql:///mydb5", "root", "root");
            //3.获取传输器
            stat = conn.createStatement();
            //4.利用传输器，发送sql到数据库执行，返回执行结果
            rs = stat.executeQuery("select * from account");
            //5.处理结果
            while(rs.next()){
                int id = rs.getInt(1);
                String name = rs.getString("name");
                double money = rs.getDouble("money");
                System.out.println(id+name+money);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            //6.释放资源
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    rs = null;
                }
            }
            if(stat!=null){
                try {
                    stat.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    stat = null;
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    conn = null;
                }
            }
        }

JDBC API详解

  • 注册数据库驱动：
    • 使用DriverManager.registerDriver(new Driver());注册数据库有两个缺点，首先，通过观察mysql的中Driver接口的实现类发现在静态代码块中注册驱动的逻辑，所以这种方式会造成驱动被注册两次。另外，这种方式导致了程序和具体的数据库驱动绑死在了一起，程序的灵活性比较低。
    • 所以推荐使用：Class.forName(“com.mysql.jdbc.Driver”);的方式注册数据库驱动。
    • 获取数据库连接
      • Connection conn = DriverManager.getConnection(url,name,psw);

  • 数据库URL

    • URL用于标识数据库的位置，程序员通过URL地址告诉JDBC程序连接哪个数据库，URL的写法为： jdbc:mysql://localhost:3306/test ?参数名=参数值
    • 常用数据库URL地址的写法： 

      Oracle写法：jdbc:oracle:thin:@localhost:1521:sid
SqlServer写法:jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=sid
MySql:jdbc:mysql://localhost:3306/sid
Mysql的url地址的简写形式： jdbc:mysql:///sid

  • Connection

    • Jdbc程序中的Connection，它用于代表数据库的链接，Connection是数据库编程中最重要的一个对象，客户端与数据库所有交互都是通过connection对象完成的，这个对象的常用方法： 

      createStatement()：创建向数据库发送sql的statement对象。
prepareStatement(sql):创建向数据库发送预编译sql的PreparedSatement对象。
prepareCall(sql)：创建执行存储过程的callableStatement对象。 
setAutoCommit(boolean autoCommit)：设置事务是否自动提交。 
commit()：在链接上提交事务。
rollback()：在此链接上回滚事务。
  • Statement
    • Jdbc程序中的Statement对象用于向数据库发送SQL语句， Statement对象常用方法： 

      executeQuery(String sql) ：用于向数据库发送查询语句。
executeUpdate(String sql)：用于向数据库发送insert、update或delete语句
execute(String sql)：用于向数据库发送任意sql语句
addBatch(String sql)：把多条sql语句放到一个批处理中。
executeBatch()：向数据库发送一批sql语句执行。
  • ResultSet
    • Jdbc程序中的ResultSet用于代表Sql语句的执行结果。Resultset封装执行结果时，采用的类似于表格的方式。ResultSet 对象维护了一个指向表格数据行的游标，初始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。
    • ResultSet既然用于封装执行结果的，所以该对象提供的都是用于获取数据的get方法： 

      获取任意类型的数据
getObject(int index)
getObject(string columnName)
获取指定类型的数据，例如：
getString(int index)
getString(String columnName)
getInt(columnIndex)
getInt(columnLabel)
getDouble(columnIndex)
getDouble(columnLabel)
...
操作游标的方法,例如:
next()：移动到下一行
Previous()：移动到前一行
absolute(int row)：移动到指定行
beforeFirst()：移动resultSet的最前面。
afterLast() ：移动到resultSet的最后面。
...
  • 释放资源
    • Jdbc程序运行完后，切记要释放程序在运行过程中，创建的那些与数据库进行交互的对象，这些对象通常是ResultSet, Statement和Connection对象。
    • 特别是Connection对象，它是非常稀有的资源，用完后必须马上释放，如果Connection不能及时、正确的关闭，极易导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。
    • 为确保资源释放代码能运行，资源释放代码也一定要放在finally语句中。

JDBC的增删改查

  • 增：

    Connection conn = null;
Statement stat = null;
ResultSet rs = null;
try {
    //1.注册驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2.获取连接
    conn = DriverManager.getConnection("jdbc:mysql:///mydb5","root","root");
    //3.获取传输器
    stat = conn.createStatement();
    //4.利用传输器，发送sql，返回结果
    String sql = "insert into account value(null,'张飞',888)";
    int rows = stat.executeUpdate(sql);
    //5.处理结果
    System.out.println("影响了"+rows+"行");
} catch (Exception e) {
    e.printStackTrace();
    throw new RuntimeException();
}finally{
    //6.释放资源
    if(rs!=null){
        try {
            rs.close();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            rs = null;
        }
    }
    if(stat!=null){
        try {
            stat.close();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            stat = null;
        }
    }
    if(conn!=null){
        try {
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            conn = null;
        }
    }
}

  • 改

    • 1.创建JDBCUtils类，并添加如下代码：

      public static void close(Connection conn,Statement stat,ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                rs = null;
            }
        }
        if(stat!=null){
            try {
                stat.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                stat = null;
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                conn = null;
            }
        }
    }

    • 2.改的代码变为：

      Connection conn = null;
Statement stat = null;
ResultSet rs = null;
try {
    Class.forName("com.mysql.jdbc.Driver");
    conn = DriverManager.getConnection("jdbc:mysql:///mydb5","root","root");
    stat = conn.createStatement();
    int rows = stat.executeUpdate("update account set money=666 where name='张飞'");
    System.out.println("影响了"+rows+"行");
} catch (Exception e) {
    e.printStackTrace();
    throw new RuntimeException();
}finally{
    //释放资源
    JDBCUtils.close(conn, stat, rs);
}

  • 删

    • 1.在src下创建config.properties配置文件，并添加如下内容：

      driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql:///mydb5
user=root
password=root

    • 2.在JDBCUtils中添加如下代码：

      private static Properties prop = new Properties();

static{
    //读取配置文件
    try {
        //String path = "bin/config.properties";
        //通过类加载器获取路径
        ClassLoader loader = JDBCUtils.class.getClassLoader();
        String path = loader.getResource("config.properties").getPath();
        prop.load(new FileInputStream(path));
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }
}

public static Connection getConnection(){
    Connection conn;
    try {
        String driverClass = prop.getProperty("driverClass");
        String jdbcUrl = prop.getProperty("jdbcUrl");
        String user = prop.getProperty("user");
        String password = prop.getProperty("password");

        Class.forName(driverClass);
        conn = DriverManager.getConnection(jdbcUrl,user,password);
        return conn;
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }
}

    • 3.删除代码变为：

      Connection conn = null;
Statement stat = null;
ResultSet rs = null;
try {
    conn = JDBCUtils.getConnection();
    stat = conn.createStatement();
    int rows = stat.executeUpdate("delete from account where name='张飞'");
    System.out.println("影响了"+rows+"行");
} catch (Exception e) {
    e.printStackTrace();
    throw new RuntimeException();
}finally{
    //释放资源
    JDBCUtils.close(conn, stat, rs);
}

PreparedStatement

  • Sql注入攻击演示

    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    //提示用户登陆
    System.out.println("请登陆");
    //提示输入用户名
    System.out.println("请输入用户名:");
    String username = scan.nextLine();
    //提示输入密码
    System.out.println("请输入密码:");
    String password = scan.nextLine();

    login(username,password);
}

private static void login(String username, String password) {
    Connection conn = null;
    Statement stat = null;
    ResultSet rs = null;
    try {
        conn = JDBCUtils.getConnection();
        stat = conn.createStatement();
        String sql = "select * from user where username='"+username+"' and password='"+password+"'";
        //当输入“张三'#”后，sql变为：
        //select * from user where username='张三'#' and password=''
        //当输入“张三' or '2=2”后，sql变为：
        //select * from user where username='张三' or '2=2' and password=''
        rs = stat.executeQuery(sql);
        if(rs.next()){
            System.out.println("恭喜，登陆成功");
        }else{
            System.out.println("用户名或密码错误");
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }finally{
        JDBCUtils.close(conn, stat, rs);
    }
}
    • 由于后台的SQL是拼接而来的, 其中的参数是用户提交的, 如果用户在提交参数时, 参杂了一些SQL关键字或者特殊符号, 就有可能会导致SQL语句语意的改变, 从而造成一些意外的操作!

  • PreparedStatement

    • PreparedStatement优点:
      • 可以防止sql注入攻击:通过PreparedStatement对象发送sql, 是先把sql语句的骨架发送给数据库编译并确定下来, 后面发送的只能是参数的值, 不能影响sql语句的骨架, 即使参数中包含sql关键字或特殊符号, 也只会当成普通的文本来处理!
      • 通过方法来设置参数, 省去了拼接SQL语句的麻烦!
      • 可以提高程序的效率:PreparedStatement对象发送的sql语句(骨架)到数据库编译后会被数据缓存下来, 如果下次执行的sql与缓存中的相匹配, 就不再编译而是直接使用缓存中的语句, 可以减少sql语句编译的次数, 提高程序执行的效率!

    • Statement对象发送的sql语句到数据库之后也会编译, 但是Statement对象是先拼接好再发送sql到数据库, 如果每次参数不同, 整条sql也就不同. 所以每次都需要编译!

    • 代码改造：

      private static void login(String username, String password) {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        conn = JDBCUtils.getConnection();
        String sql = "select * from user where username=? and password=?";
        ps = conn.prepareStatement(sql);
        ps.setString(1, username);
        ps.setString(2, password);
        rs = ps.executeQuery();

        if(rs.next()){
            System.out.println("恭喜，登陆成功");
        }else{
            System.out.println("用户名或密码错误");
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }finally{
        JDBCUtils.close(conn, ps, rs);
    }
}

批处理

  • 批处理概述

    • 假设现有一大堆的sql要到数据库执行, 如果一条一条发送, 有多少条就 需要发送多少次, 效率低下
    • 可以通过批处理提高发送sql语句的效率: 可以将这一大堆的sql添加到 一个批中, 一次性将批发送给数据库, 数据库收到后打开批, 依次执行其中 sql语句, 这样可以减少sql语句发送的次数, 从而提高程序执行的效率!

  • Statement方式来实现批处理

    • 优点:可以在一次批处理中添加结构不同的sql语句
    • 缺点:
      1. 不能防止sql注入攻击
      2. 没有预编译机制, 效率略低
      3. 当发送结构相同的sql语句时, sql语句的骨架每次都需要编写。

    • 例如：

      public static void main(String[] args) {
    Connection conn = null;
    Statement stat = null;
    ResultSet rs = null;
    try {
        conn = JDBCUtils.getConnection();
        stat = conn.createStatement();
        stat.addBatch("use mydb1");
        stat.addBatch("create table tb_batch(id int primary key auto_increment, name varchar(20))");
        stat.addBatch("insert into tb_batch values(null,'a')");
        stat.addBatch("insert into tb_batch values(null,'b')");
        stat.addBatch("insert into tb_batch values(null,'c')");
        stat.addBatch("insert into tb_batch values(null,'d')");

        stat.executeBatch();
        System.out.println("执行完成");
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }finally{
        JDBCUtils.close(conn, stat, rs);
    }
}

  • PreparedStatement方式实现批处理

    • 优点:
      1. 可以防止sql注入攻击
      2. 采用预编译机制, 可以提高程序执行的效率
      3. 当发送多条结构相同的sql时, sql语句的骨架可以只发送一次。

    • 缺点:

      1. 不能在一次批处理中添加结构不同的sql语句

    • 例如：

      public static void main(String[] args) {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        Long a = System.currentTimeMillis();
        conn = JDBCUtils.getConnection();
        ps = conn.prepareStatement("insert into tb_batch values(null,?)");
        for(int i=0;i<100;i++){
            ps.setString(1,"b1");
            ps.addBatch();
        }
        ps.executeBatch();
        System.out.println("执行完成");
        Long b = System.currentTimeMillis();
        System.out.println(b-a);
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }finally{
        JDBCUtils.close(conn, ps, rs);
    }
}

连接池

  • 连接池概述
    • 用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、宕机。
    • 频繁的开关连接相当的耗费资源,所以我们可以设置一个连接池,在程序启动时就初始化一批连接,在程序中共享,需要连接时从池中获取,用完再还回池中,通过池共享连接,减少开关连接的次数,提高程序的效率。

  • 自定义连接池

    package cn.tedu.pool;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Logger;
import javax.sql.DataSource;

public class MyPool implements DataSource{
    private static List<Connection> list = new LinkedList<Connection>();
    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
            for (int i = 0; i < 5; i++) {
                Connection conn = DriverManager.getConnection("jdbc:mysql:///mydb5","root","root");
                list.add(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    @Override
    public Connection getConnection() throws SQLException {
        if(list.isEmpty()){
            for (int i = 0; i < 3; i++) {
                Connection conn = DriverManager.getConnection("jdbc:mysql:///mydb1");
                list.add(conn);
            }
        }
        Connection conn = list.remove(0);
        System.out.println("成功从数据库中获取一个连接，连接池中还剩"+list.size()+"个连接..");
        return conn;
    }

    public void returnConn(Connection conn){
        try {
            if(conn != null && !conn.isClosed()){
                list.add(conn);
                System.out.println("成功向数据库还回一个连接，连接池中还剩"+list.size()+"个连接..");
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }



    @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 cn.tedu.pool;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestMyPool {
    public static void main(String[] args) {
        MyPool pool = new MyPool();
        Connection conn= null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            conn = pool.getConnection();
            stat = conn.createStatement();
            rs = stat.executeQuery("select * from account where id=1");
            if(rs.next()){
    System.out.println(rs.getInt("id")+":"+rs.getString("name")+":"+rs.getDouble("money"));
            }
            System.out.println("执行完毕");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    rs = null;
                }
            }
            if(stat!=null){
                try {
                    stat.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    stat = null;
                }
            }
            pool.returnConn(conn);
        }
    }
}
    • 如上代码写的连接池，还需要在使用完连接后记得不能关闭连接，而是要调用returnConn方法将连接还回池中。
    • 我们想能不能想办法改造conn的close方法，使close方法不会真的关闭连接而是将连接还回池中。

  • close方法的改造

    • 继承
      • 写一个类继承要改造的类，对于不想改造的方法不覆盖，对于想要改造的方法复写该方法，将代码改造为自己需要的逻辑代码。
      • 这种方式只能在还没有对象的情况下使用，现在Connection对象已经存在了，再用继承复写的方式是不行的，所以我们不采用。

    • .装饰

      • 实现装饰设计模式:

        （1）写一个装饰类, 要求装饰类和被装饰者所属的类实现同一个接口或者继承同一个父类
（2）装饰类必须提供构造方法接收被装饰者, 并将被装饰者保存在类的内部
（3）对于想要改造的方法直接进行改造, 对于不想改造的方法, 直接调用原有对象(被装设者)上的方法

      • 代码改造：创建装饰者类ConnectionDecorate：只改造close方法。（不想改造的方法，右键conn->Source->Generate Delegate Methods，选中不行改造的即可)

        public class ConnectionDecorate implements Connection{
private Connection conn = null;
private MyPool pool = null;
public ConnectionDecorate(Connection conn,MyPool pool){
    this.conn = conn;
    this.pool = pool;
}

@Override
public void close() throws SQLException {
    pool.returnConn(conn);
}

      • 修改MyPool类：在获取连接方法中，return前加入如下代码：

        //先进行包装
Connection connDecorate = new ConnectionDecorate(conn,this);
return connDecorate;

      • 测试类最后只需关闭连接即可

开源数据库连接池c3p0

  • c3p0概述
    • 我们手写的连接池是比较简陋的，是为了讲解连接池的原理。其实在真实开发中可以使用开源的数据库连接池。其中C3P0是比较常用的一种。

  • C3P0连接池应用

    (1)导入c3p0的jar包：c3p0-0.9.1.2.jar
(2)创建测试类TestC3p0，并添加如下代码：
public static void main(String[] args) {
        Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //创建连接池
            ComboPooledDataSource cpds = new ComboPooledDataSource();
            //设置连接数据库的基本信息
            cpds.setDriverClass("com.mysql.jdbc.Driver");
            cpds.setJdbcUrl("jdbc:mysql:///mydb5");
            cpds.setUser("root");
            cpds.setPassword("root");
            //从连接池中获取连接
            conn = cpds.getConnection();
            stat = conn.createStatement();
            rs = stat.executeQuery("select * from account where id=1");
            if(rs.next()){
                System.out.println(rs.getInt("id")+" : "
                        +rs.getString("name")+" : "
                        +rs.getDouble("money"));
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            JDBCUtils.close(conn, stat, rs);
        }   
    }

  • (3)但是发现此种方式将数据写死在代码中，所以需要进行改造

    • C3p0会默认读取一个配置文件，为c3p0-config.xml，（注意，名字不能改变，否则c3p0将无法读取）我们在src或者类似的源码目录下，创建一个c3p0-config.xml文件, 配置内容如下: 

      <?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///mydb5</property>
        <property name="user">root</property>
        <property name="password">root</property>
    </default-config>
</c3p0-config>

  • (4)另一种方式：在src或者类似的源码目录下, 创建一个c3p0.properties文件, 配置内容如下:

    c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql:///mydb5
c3p0.user=root
c3p0.password=root
乘风御浪云帆之上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
大数据原理
weixin_48475751的博客
12-22 1754
一、数据核心原理 从“流程”核心转变为“数据”核心 大数据时代，计算模式也发生了转变，从“流程”核心转变为“数据”核心。Hadoop体系的分布式计算框架已经是“数据”为核心的范式。非结构化数据及分析需求，将改变IT系统的升级方式：从简单增量到架构变化。大数据下的新思维——计算模式的转变。 例如：IBM将使用以数据为中心的设计，目的是降低在超级计算机之间进行大量数据交换的必要性。大数据下，云计算找到了破茧重生的机会，在存储和计算上都体现了数据为核心的理念。大数据和云计算的关系：云计算为大数据提供了有力的工具和
大数据学习笔记-------------------(12_1)
WEL测试
09-29 759
第11章 zookeeper应用程序接口          Zookeeper有一个官方的API绑定的Java和C。 ZooKeeper Community提供大多数语言（.NET，Python等）的API。使用ZooKeeper的API，应用程序可以连接、交互、操纵数据、协调，最终从ZooKeeper ensemble断开。          ZooKeeper API具有丰富的功能集来获得
大数据完结正式步入项目阶段
小坏说后端
11-09 586
争取30天搞完d第一个实时数仓项目。争取30天搞完d第二个实时数仓项目。
信创大数据平台容灾项目
.
08-27 1534
对于实时性要求不高的如hive等组件采用批处理式容灾机制，生产集群内批处理作业产生的数据，充分考虑了批处理生成增量数据规模大，数据结构复杂多样，业务的实时性要求不高因素，综合集群的可用资源及带宽压力的因素，将该类数据的容灾控制RPO
大数据学习笔记-------------------(12_2)
WEL测试
09-30 360
11.7 setData方法 zookeeper类提供setData方法来修改附着在指定znode的数据。setData方法： setData(String path, byte[] data, int version)   参数解释说明： path-----------znode路径 data-----------存储在指定znode路径的数据 version-------znode
2021年高职技能大赛-大数据技术与应用赛项正式赛卷及评分标准.zip
10-02
这份"2021年高职技能大赛-大数据技术与应用赛项正式赛卷及评分标准.zip"压缩包文件，包含了该赛事的重要资料，对于参赛者以及对此感兴趣的学习者来说，具有极高的参考价值。 首先，我们需要理解大数据技术的核心...
大数据学习-正式课视频.zip
10-10
很全面的大数据公开课，课件+视频+代码
国家技术标准创新基地(贵州大数据)正式成立.pdf
07-04
国家技术标准创新基地（贵州大数据）的成立标志着大数据技术标准化领域迈出了重要一步，其重要性在于推动了大数据技术、产品和服务的规范化、专业化发展。贵州省作为大数据产业的先行者，凭借其独特的地理环境和政策...
阿里巴巴大数据实践之路-9.pdf
06-26
阿里巴巴自2009年开始定位为一家数据公司，2012年成立数据事业部，并在2014年正式推出大数据产品。阿里巴巴的大数据发展历程可以分为三个阶段：Data 1.0、Data 2.0和Data 3.0。Data 1.0阶段主要是基于DW和BI的看，...
GZ033 大数据应用开发赛项赛题（师生同赛）
最新发布
10-26
全国职业院校技能大赛（高职组）“大数据应用开发”赛项是针对大数据技术与应用的一次重要竞赛，旨在提升学生和教师对大数据处理、分析和应用的实际操作能力。该赛题GZ033涵盖了大数据领域的核心知识点，下面将详细...
大数据预科班作业8
菜鸟零号 kungfu~peng
09-12 7177
大数据预科班作业8（一二套） (第一套) 1. （static 属性）有如下代码 class MyClass{ static int a; int b; } public class TestMain{ public static void main(String args[]){ MyClass mc1 = new MyClass(); MyClass mc2 = new MyClas
大数据预科班作业7
菜鸟零号 kungfu~peng
09-12 6794
大数据预科班作业7 1. （继承、this 和super 关键字）有以下代码 class Super{ public Super(){ System.out.println("Super()"); } public Super(String str){ System.out.println("Super(String)");
大数据预科班1~4天习题
菜鸟零号 kungfu~peng
09-06 6053
第一、第二天作业 1.（标识符命名）下面几个变量中，那些是对的？那些是错的？错的请说明理由 A. ILoveJava B. $20 C. learn@java D. antony.lee E. Hello_World F. 2tige 正确的：A B E  错误的：C(@符号不满足) D(.符号不满足) F(数字不能开头) 2.假设有如下程序： package com.corej
京淘项目总结
菜鸟零号 kungfu~peng
02-12 5796
京淘项目总结项目整体结构项目设计初衷--有一套高可用、高并发的系统架构代码下载地址http://download.csdn.net/download/eieiei438/10250016
大数据预科班作业13
菜鸟零号 kungfu~peng
09-27 5562
大数据预科班作业13 1. （File 类）以下关于 File 类说法正确的是： A． 一个 File 对象代表了操作系统中的一个文件或者文件夹 B． 可以使用 File 对象创建和删除一个文件 C． 可以使用 File 对象创建和删除一个文件夹 D． 当一个 File 对象被垃圾回收时，系统上对应的文件或文件夹也被删除 ABC 2. （File 类）有如下代码：
大数据预科班作业10
菜鸟零号 kungfu~peng
09-22 4758
大数据预科班作业10 1. 填空 Collection 接口的特点是元素是_________；List 接口的特点是元素_____（有 |无）顺序，______（可以|不可以）重复； Set 接口的特点是元素_____（有| 无）顺序，______（可以|不可以）重复； Map 接口的特点是元素是__________, 其中_____可以重复，________不可以重复。
大数据预科班作业5~6
菜鸟零号 kungfu~peng
09-06 4007
大数据预科班作业5、6 1. 写一个函数add，接受两个整数作为参数，返回这两个整数的和。 package com.peng.demo; public class Demo01 { public static void main(String[] args) { // 测试 System.out.println(add(1, 2));
大数据预科班作业9
菜鸟零号 kungfu~peng
09-13 3288
大数据预科班作业9 1. （Object 类）在Object 类中，定义的finalize 方法在______时调用，toString()方法返回值表示，equals 方法的作用为，getClass 方法作用为__________ 1. 被垃圾回收时 2. 对象的字符串表现形式 3. 比较两个对象的值是否相等 4. 获得对象的实际类型 2. （toString 方法，equ
大数据正式京淘附加爬虫
菜鸟零号 kungfu~peng
01-31 2687
大数据正式京淘附加爬虫 爬虫技术 httpClient：抓取整个页面 htmlUnit：可以二次提交 jsoup：可以获取以上两个技术的所有内容 jsoup 爬取整个页面 爬取整个网站 爬取页面中的某一个定位信息 爬取二次提交--ajax 爬取jsonp数据 例子 测试之前的准备 private ObjectMapper om; @o
大数据时代：行业变革与创新
IBM等企业也开始强调大数据概念，而美国国家科学基金也发布了大数据研究指南，标志着大数据时代的正式到来。大数据被定义为具有4V特征的数据：大规模（Volume）、多样化（Variety）、快速增长（Velocity）和潜在价值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乘风御浪云帆之上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值