Java_JDBC

最新推荐文章于 2021-12-16 08:18:25 发布
最新推荐文章于 2021-12-16 08:18:25 发布
阅读量161 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44333294/article/details/114847095
版权

JDBC：用于执行SQL语句的java API，为多种数据库提供统一的访问，不需要具体了解每种数据库的驱动的写法，只需要了解JDBC的接口规范，每种数据库的具体驱动都需要实现JDBC的规范

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

jdbc程序运行完后，必须释放程序在运行过程中，创建的那些与数据库交互的对象。ResultSet、Statement、Connection对象：Connection是数据库的连接对象，往往会有一个最大的访问个数，如果没有把对象及时释放掉，可能导致别人无法访问数据库

在这里插入图片描述

import com.mysql.jdbc.Driver;
import org.junit.Test;

import java.sql.*;

public class JDBCDemo1 {
    @Test
    public void demo1(){
        Connection conn=null;
        Statement stmt=null;
        ResultSet rs=null;
        //1.加载驱动
        try {
           // DriverManager.registerDriver(new Driver());会导致驱动注册两次，源代码中静态代码块包含注册驱动的语句，当Driver类被加载时会注册驱动
            //加上以上语句手动注册一次，会注册驱动两次
            Class.forName("com.mysql.jdbc.Driver");//加载Driver类，类一旦被加载，就会执行静态代码块，注册驱动

        //2.获得连接
            conn=DriverManager.getConnection("jdbc:mysql:///jdbctest","root","1984");
        //3.创建执行SQL语句的对象，并且执行SQL
            //3,1创建执行SQL的对象
            String sql="select * from user";
            stmt=conn.createStatement();
            //3.2执行SQL语句
             rs=stmt.executeQuery(sql);
            while(rs.next()){
                int uid=rs.getInt("uid");
                String username=rs.getString("username");
                String password=rs.getString("password");
                String name=rs.getString("name");
                System.out.println(uid+" "+username+" "+password+" "+name);

            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //为了保证程序异常时，仍然可以正确释放资源，将释放资源放到finally代码块内（不管是否发生异常都会执行）
            //4.释放资源
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
                rs=null;

            }

            if(stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt=null;

            }

            if(conn!=null){
                try {
                    conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn=null;//手动置为null，垃圾回收机制会更早地回收对象

            }
        }
    }
}

JDBC的增删改查：增删改操作基本一致

import org.junit.Test;

import java.sql.*;

public class JDBCDemo2 {
    //增删改操作基本类似
    @Test
    /**
     * 保存操作
     */
    public void demo1() {
        Connection conn = null;
        Statement stmt = null;
        //1.加载驱动
        try {
            // DriverManager.registerDriver(new Driver());会导致驱动注册两次，源代码中静态代码块包含注册驱动的语句，当Driver类被加载时会注册驱动
            //加上以上语句手动注册一次，会注册驱动两次
            Class.forName("com.mysql.jdbc.Driver");//加载Driver类，类一旦被加载，就会执行静态代码块，注册驱动

            //2.获得连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8", "root", "1984");
            //3.创建执行SQL语句的对象，并且执行SQL
            //3,1创建执行SQL的对象
            String sql = "insert into user values (null,'eee','123','张三')";
            stmt = conn.createStatement();
            //3.2执行SQL语句
            int i = stmt.executeUpdate(sql);//返回所影响的行数，i>0说明操作成功
            if (i > 0) {
                System.out.println("保存成功!");
            }
            } catch(Exception e){
                e.printStackTrace();
            }finally{
                //为了保证程序异常时，仍然可以正确释放资源，将释放资源放到finally代码块内（不管是否发生异常都会执行）
                //4.释放资源

                if (stmt != null) {
                    try {
                        stmt.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    stmt = null;

                }

                if (conn != null) {
                    try {
                        conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    conn = null;//手动置为null，垃圾回收机制会更早地回收对象

                }
            }

        }


    @Test
    /**
     * 修改操作
     */
    public void demo2() {
        Connection conn = null;
        Statement stmt = null;
        //1.加载驱动
        try {
            // DriverManager.registerDriver(new Driver());会导致驱动注册两次，源代码中静态代码块包含注册驱动的语句，当Driver类被加载时会注册驱动
            //加上以上语句手动注册一次，会注册驱动两次
            Class.forName("com.mysql.jdbc.Driver");//加载Driver类，类一旦被加载，就会执行静态代码块，注册驱动

            //2.获得连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8", "root", "1984");
            //3.创建执行SQL语句的对象，并且执行SQL
            //3,1创建执行SQL的对象
            String sql = "update user set username='qqq',password='234',name='刘三' where uid=4";
            stmt = conn.createStatement();
            //3.2执行SQL语句
            int i = stmt.executeUpdate(sql);//返回所影响的行数，i>0说明操作成功
            if (i > 0) {
                System.out.println("修改成功!");
            }
        } catch(Exception e){
            e.printStackTrace();
        }finally{
            //为了保证程序异常时，仍然可以正确释放资源，将释放资源放到finally代码块内（不管是否发生异常都会执行）
            //4.释放资源

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt = null;

            }

            if (conn != null) {
                try {
                    conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;//手动置为null，垃圾回收机制会更早地回收对象

            }
        }

    }
    @Test
    /**
     * 删除操作
     */
    public void demo3() {
        Connection conn = null;
        Statement stmt = null;
        //1.加载驱动
        try {
            // DriverManager.registerDriver(new Driver());会导致驱动注册两次，源代码中静态代码块包含注册驱动的语句，当Driver类被加载时会注册驱动
            //加上以上语句手动注册一次，会注册驱动两次
            Class.forName("com.mysql.jdbc.Driver");//加载Driver类，类一旦被加载，就会执行静态代码块，注册驱动

            //2.获得连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8", "root", "1984");
            //3.创建执行SQL语句的对象，并且执行SQL
            //3,1创建执行SQL的对象
            String sql = "delete from user where uid=7";
            stmt = conn.createStatement();
            //3.2执行SQL语句
            int i = stmt.executeUpdate(sql);//返回所影响的行数，i>0说明操作成功
            if (i > 0) {
                System.out.println("删除成功!");
            }
        } catch(Exception e){
            e.printStackTrace();
        }finally{
            //为了保证程序异常时，仍然可以正确释放资源，将释放资源放到finally代码块内（不管是否发生异常都会执行）
            //4.释放资源

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt = null;

            }

            if (conn != null) {
                try {
                    conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;//手动置为null，垃圾回收机制会更早地回收对象

            }
        }

    }

    @Test
    /**
     * 查询所有记录/一条记录
     */
    public void demo4() {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs=null;
        //1.加载驱动
        try {
            // DriverManager.registerDriver(new Driver());会导致驱动注册两次，源代码中静态代码块包含注册驱动的语句，当Driver类被加载时会注册驱动
            //加上以上语句手动注册一次，会注册驱动两次
            Class.forName("com.mysql.jdbc.Driver");//加载Driver类，类一旦被加载，就会执行静态代码块，注册驱动

            //2.获得连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8", "root", "1984");
            //3.创建执行SQL语句的对象，并且执行SQL
            //3,1创建执行SQL的对象
            String sql = "select * from user";
            //String sql="select * from user where uid=2";//一条记录
            stmt = conn.createStatement();
            //3.2执行SQL语句
            rs=stmt.executeQuery(sql);
            //if(rs.next()){//一条记录
            while(rs.next()){
                int uid=rs.getInt("uid");
                String username=rs.getString("username");
                String password=rs.getString("password");
                String name=rs.getString("name");
                System.out.println(uid+" "+username+" "+password+" "+name);

            }
        } catch(Exception e){
            e.printStackTrace();
        }finally{
            //为了保证程序异常时，仍然可以正确释放资源，将释放资源放到finally代码块内（不管是否发生异常都会执行）
            //4.释放资源

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt = null;

            }

            if (conn != null) {
                try {
                    conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;//手动置为null，垃圾回收机制会更早地回收对象

            }

            if (rs != null) {
                try {
                    rs.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                rs = null;//手动置为null，垃圾回收机制会更早地回收对象

            }
        }

    }
}

抽取重复代码封装成工具类（使用静态成员）

import jdbc.utils.JDBCUtils;
import org.junit.Test;

import java.sql.Connection;
import java.sql.Statement;

public class JDBCDemo3 {
    @Test
    /**
     * 保存记录
     */
    public void demo(){
        Connection conn=null;
        Statement stmt=null;
        try {
            //获得连接
            conn= JDBCUtils.getConnection();
            //创建执行SQL语句的对象
            stmt=conn.createStatement();
            String sql="insert into user values(null,'fff','123','王四')";
            int i=stmt.executeUpdate(sql);
            if(i>0){
                System.out.println("保存成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(conn,stmt);
        }

    }
}

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC的工具类，想修改参数时，需要修改工具类的源代码，所以将参数提取到配置文件中，在工具类中只需要解析配置文件,在配置文件中修改参数
 */

public class JDBCUtils {
    //static final，全局变量，随着类加载而产生，在程序运行过程中不允许被修改，修饰配置信息
    private static final String driverClass;
    private static final String url;
    private static final String username;
    private static final String password;

    static{//静态代码块，无论类实例多少次，只执行一次，只能调用静态成员
        //加载属性文件并解析
        Properties props=new Properties();
        //如何获得属性文件的输入流
        //通常使用类的加载器的方式进行获取：FileInputStream("src/jdbc.properties")：在java项目中可行，Web项目不可行,没有src路径
        InputStream inputStream=JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        try {
            props.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
//        driverClass="com.mysql.jdbc.Driver";
//        url="jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8";
//        username="root";
//        password="1984";
        driverClass=props.getProperty("driverClass");
        url=props.getProperty("url");
        username=props.getProperty("username");
        password=props.getProperty("password");
    }
    /**
     * 注册驱动的方法
     */
    public static void loadDriver() throws ClassNotFoundException {
        Class.forName(driverClass);
    }

    /**
     * 获得连接的方法
     * 静态方法，静态方法不能直接访问同一个类中的非静态成员，只能直接调用同一个类中的静态成员
     * 静态方法中不能使用this，this代表当前类实例，static代表类共享冲突，静态变量与静态方法属于一类，可直接访问
     * 通过对象实例化后，对象.成员方法的方式访问非静态成员
     */
    public static Connection getConnection() throws Exception {
        loadDriver();
        Connection conn= DriverManager.getConnection(url, username, password);
        return conn;
    }
    /**
     * 资源释放
     */
    public static void release(Connection conn, Statement stmt){
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            stmt = null;

        }

        if (conn != null) {
            try {
                conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;//手动置为null，垃圾回收机制会更早地回收对象

        }
    }

    public static void release(Connection conn, Statement stmt, ResultSet rs){

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            stmt = null;

        }

        if (conn != null) {
            try {
                conn.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;//手动置为null，垃圾回收机制会更早地回收对象

        }

        if (rs != null) {
            try {
                rs.close();//遵循晚创建，早释放，虽然释放了，但还没有被垃圾回收机制回收掉
            } catch (SQLException e) {
                e.printStackTrace();
            }
            rs = null;//手动置为null，垃圾回收机制会更早地回收对象

        }
    }


}

配置文件

driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8
username=root
password=1984

SQL注入的漏洞：一个网站需要登陆的功能，需要输入用户名和密码进行登陆，SQL注入漏洞是指已知用户名，不知道密码的情况下，也可以登陆到系统中，对账号进行破坏，原因：在输入用户名时输入了SQL语句的关键字

import jdbc.utils.JDBCUtils;
import org.junit.Test;

import java.sql.*;

/**
 * 演示JDBC注入的漏洞
 */

public class JDBCDemo4 {
    @Test
    /**
     * 测试SQL注入漏洞的方法：注入漏洞，在输入用户名时输入了SQL语句的关键字
     */
    public void demo(){
        //已知用户名，对账号进行破坏，显示登陆成功
        //boolean flag=JDBCDemo4.login("aaa' or '1=1","111hdjgjio");//输入了SQL的关键字or
        //String sql="select * from user where username = 'aaa' or '1=1'and password ='111hdjgjio'";//true or false为true
        //boolean flag=JDBCDemo4.login("aaa' -- ","111hdjgjio");
        //String sql="select * from user where username = 'aaa' -- 'and password ='111hdjgjio'";//--是注释，后面被注释掉了
       boolean flag=JDBCDemo4.login("aaa","111");
        if(flag)
            System.out.println("登陆成功");
        else
            System.out.println("登陆失败");
    }
    /**
     * 判断是否登陆成功
     * 根据输入的用户名和密码到数据库中查询，查询到了就返回，没查询到则登陆失败(JDBC的查询操作)
     */
    public static boolean login(String username,String password){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs=null;
        boolean flag=false;
        try {
            conn = JDBCUtils.getConnection();
            //创建执行SQL的语句
            stmt = conn.createStatement();
            //编写SQL语句
            String sql="select * from user where username = '" +username +"'and password ='"+password+"'";
            //执行SQL语句
            rs=stmt.executeQuery(sql);
            //判断结果集中是否有数据（查询到了）
            if(rs.next()){
                flag=true;
            }
            else
                flag=false;
        } catch(Exception e){
            e.printStackTrace();
        }finally{
           JDBCUtils.release(conn,stmt,rs);
        }
        return flag;


    }
}

SQL注入漏洞的解决：根本在SQL语句的拼接上，Statement对象执行SQL语句时，SQL语句是字符串拼接的，因此不能使用Statement对象，而使用PreparedStatement（预处理对象）：使用占位符将SQL语句中变量的地方占住，SQL语句格式固定，再传来的SQL的关键字也不识别了，将关键字当作普通的字符串处理

在这里插入图片描述

/**
 * 避免SQL注入漏洞的方法
 */
public static boolean login2(String username, String password) {
    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    boolean flag=false;

    try {
        conn = JDBCUtils.getConnection();
        //编写SQL语句
        String sql = "select * from user where username = ? and password =?";
        //预处理SQL
        pstmt=conn.prepareStatement(sql);
        //设置参数
        pstmt.setString(1,username);
        pstmt.setString(2,password);
        //执行SQL语句，SQL已经预处理了，执行时不需要传入SQL
        rs = pstmt.executeQuery();
        //判断结果集中是否有数据（查询到了）
        if (rs.next()) {
            flag = true;
        } else
            flag = false;
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtils.release(conn, pstmt, rs);
    }
    return flag;

}

@Test//注解
/**
 * 保存数据
 */
public void demo1()  {
    Connection conn=null;
    PreparedStatement pstmt=null;

    try {
        //获得连接
        conn= JDBCUtils.getConnection();
        //编写SQL语句
        String sql="insert into user values (null,?,?,?)";
        //预处理SQL
        pstmt= conn.prepareStatement(sql);
        //设置参数的值
        pstmt.setString(1,"111");//或直接setObject()
        pstmt.setString(2,"ddd");
        pstmt.setString(3,"李四");
        //执行SQL
        int i= pstmt.executeUpdate();
        if(i>0){
            System.out.println("保存成功！");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        JDBCUtils.release(conn,pstmt);

    }

}

数据库连接池（一块内存）：很多用户通过服务器端的程序，调用数据访问对象，创建连接，跟数据库进行交互，用户每次请求都需要向数据库获得连接（用户访问请求->JDBC(从数据库连接池获得连接)->数据库）

在这里插入图片描述

访问时不需要再创建连接，而是从连接池中拿一个出来，用完以后再归还

在这里插入图片描述

C3P0连接池

package jdbcDemo3;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import utils.JDBCUtils;
import org.junit.Test;
import utils.JDBCUtils2;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**
 * 连接池的测试类
 */
public class DataSourceDemo1 {
    @Test
    /**
     * 使用配置文件的方式,属性文件或xml文件（放在src路径下，默认就会查找）
     * 将创建连接池抽取成工具类
     *
     */
    public void demo2(){
        //获得连接
        Connection conn=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;
        try {

            conn=JDBCUtils2.getConnection();
            //编写SQL
            String sql="select * from user";
            //预编译SQL
            pstmt=conn.prepareStatement(sql);
            //设置参数
            //执行SQL
            rs= pstmt.executeQuery();
            while(rs.next()){
                int uid=rs.getInt("uid");
                String username=rs.getString("username");
                String password=rs.getString("password");
                String name=rs.getString("name");
                System.out.println(uid+" "+username+" "+password+" "+name);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //连接池内部已经增强了Connection的close(),原有的销毁变成归还了，不用管归还的操作
            JDBCUtils2.release(conn,pstmt,rs);
        }
    }


    @Test
    /**
     * 手动设置连接池
     */
    public void demo1(){

        //获得连接
        Connection conn=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;
        try {
            //创建连接池
            ComboPooledDataSource dataSource=new ComboPooledDataSource();
            //设置连接池的相关参数
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbctest?useUnicode=true&characterEncoding=utf8");
            dataSource.setUser("root");
            dataSource.setPassword("1984");
            dataSource.setMaxPoolSize(20);
            dataSource.setInitialPoolSize(3);
            //从连接池中获得连接
            conn= dataSource.getConnection();
            //编写SQL
            String sql="select * from user";
            //预编译SQL
            pstmt=conn.prepareStatement(sql);
            //设置参数
            //执行SQL
            rs= pstmt.executeQuery();
            while(rs.next()){
                int uid=rs.getInt("uid");
                String username=rs.getString("username");
                String password=rs.getString("password");
                String name=rs.getString("name");
                System.out.println(uid+" "+username+" "+password+" "+name);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
        //连接池内部已经增强了Connection的close(),原有的销毁变成归还了，不用管归还的操作
        JDBCUtils2.release(conn,pstmt,rs);
    }
    }
}

抽取工具类


/**
 * 抽取工具类
 */

public class JDBCUtils2 {
    private static final ComboPooledDataSource dataSource = new ComboPooledDataSource();//，保证一个程序内，连接池只被初始化一次


    /**
     * 获得连接的方法
     */
    public static Connection getConnection() throws Exception {

        Connection conn = dataSource.getConnection();
        return conn;
    }
}

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://localhost:3306/jdbctest</property>
   <property name="user">root</property>
   <property name="password">1984</property>
   <property name="initialPoolSize">5</property>
   <property name="maxPoolSize">20</property>
  </default-config>
  
</c3p0-config>
novleeooo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java jdbc datetime_jdbc 日期时间相关的类型
weixin_42103128的博客
02-24 2019
1、sql.Datesql包中的日期类Date是util包中Date类的子类，实际上也是util.Date类的子集。它只处理年月日，而忽略小时和分秒，用以代表SQL的DATE信息。Date类的构造方法为：public Date(int year, int mouth, int day)其中参数格式同util.Date类的构造方法一样，年参数为所需设定的年份减去1900所得的整数值，月参数为0至11...
Java----JDBC
Maktub_J的博客
09-27 152
JDBC JDBC(Java DataBase Connection) Java数据库连接，可以通过Java语言（代码）连接到数据库（My SQL/Oracle/BD2…），从而达到数据化的持久化处理。 SQL指令（DML、DDL、存储过程、触发器、函数、程序包） JDBC步骤 建立Java代码与数据库之间的连接 导包（驱动包：封装好的与数据库连接的Java代码）：可以帮...
官网下载java mysql_jdbc驱动包（图文）
秋楓的博客
11-10 3740
1.打开下载地址：https://dev.mysql.com/downloads/connector/j/ 根据自己的需要选择要下载的版本，官网默认是8版本，如果要下载5版本，点击下图红色框右边的 Looking for previous GA versions? 链接即可 2.点击Download 3.跳转到的页面再点击跳过 3.下载完后是个压缩包，...
Spark2 Sql + es 遇到 Caused by: java.lang.NoSuchFieldError: HIVE_STATS_JDBC_TIMEOUT
xiaoyan5686670的博客
12-16 1758
百度所有的方法都不对，其实就是依赖冲突问题。 把ES HADOOP依赖放到SPARK相应依赖之后，就可以了 <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch-hadoop</artifactId> <version>7.13.2</version&...
Java JDBC
vianoz
04-01 1850
1.JDBC-ODBC Bridge Java Jar:None Driver Name: sun.jdbc.odbc.JdbcOdbcDriver DB URL:jdbc.odbc: User Name:xxxx Password:xxxx 2.Java DB(Network)(Derby) Java Jar: derbyclient.jar Dri
java_jdbc 　
11-15
Java JDBC（Java Database Connectivity）是Java编程语言中用于与数据库交互的一组接口和类，它提供了标准的API，使得开发者可以使用Java编写数据库应用程序。在Java应用中，JDBC是连接到各种数据库的重要桥梁，无论...
java_JDBC.rar_jdbc
09-21
Java JDBC（Java Database Connectivity）是Java编程语言中用于与各种数据库进行交互的一组接口和类。JDBC提供了一个标准的API，使得Java开发者能够通过编写Java代码来访问、操作数据库，无论底层数据库是Oracle、...
Java_JDBC.rar_JDBC入门
09-24
Java数据库接口（JDBC）是Java编程语言中用于与各种类型数据库交互的一组标准API。JDBC为开发者提供了一个统一的接口，使得他们能够通过Java代码执行SQL语句，进行数据查询、插入、更新和删除等操作。在这个“Java_...
java_jdbc_banking_project_jdbc_
10-01
这个项目"java_jdbc_banking_project_jdbc_"显然是一个使用JDBC技术实现的银行管理系统的实例。在这个项目中，开发者可能使用了JDBC来执行SQL语句，创建、读取、更新和删除（CRUD）数据库中的数据，如账户信息、交易...
Java_JDBC.docx
10-12
java之JDBC的运用 互联网主流技术实践，自动化，性能，CI集成，AI。 菜鸟入门，职场分享，高阶宝库。
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
最新发布
07-19
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
【BP回归预测】龙格库塔算法优化BP神经网络RUN-BP光伏数据预测（多输入单输出）【含Matlab源码 5171期】.zip
07-19
CSDN海神之光上传的全部代码均可运行，亲测可用，直接换数据就行，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化BP神经网络分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化BP 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化BP 4.4.3 灰狼算法GWO/狼群算法WPA优化BP 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化BP 4.4.5 萤火虫算法FA/差分算法DE优化BP 4.4.6 其他优化算法优化BP
在UCA上结合DOA估计算法和自适应波束形成matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【信号分解】基于海鸥优化算法SOA-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
毕业设计javajspKTV包房管理系统(ssh)-qkrp源码含文档
07-19
毕业设计javajspKTV包房管理系统(ssh)-qkrp源码含文档 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 采用全新的计算机网络和管理系统，将成为提高KTV管理效率，改善服务水准的重要手段之一。所以城市KTV包房信息管理系统是KTV经营不可缺少的现代工具。系统的主要功能包括：会员管理、类别管理、包房管理、预订管理。 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
基于Springboot的图书管理系统论文
07-19
传统信息管理主要依赖管理人员的手工登记与管理。然而，近年来信息技术的快速进步促使许多陈旧的信息管理方式得以更新。特别是图书信息，因其管理内容复杂且数量庞大，手工处理方式已难以满足广大用户的需求，于是图书管理系统应运而生。 本图书管理系统设有管理员和用户两种权限。管理员负责管理用户基本信息、公告信息及图书信息，并能与用户进行交流等。用户则可以查看图书信息、公告以及管理员的回复等。 该系统采用WEB应用程序开发中流行的小程序结构模式，使用空间占用小但功能全面的MySQL数据库进行数据存储，并运用了JSP技术进行开发。该图书管理系统有效解决了传统手工操作中的诸多问题，如数据查询耗时长、管理步骤繁琐等。总体而言，该图书管理系统性能稳定、功能完备，且具有较高的性价比。
自监督学习：YOLO模型性能提升的新前沿
07-19
YOLO（You Only Look Once）是一种流行的实时对象检测系统，最初由 Joseph Redmon 等人在 2015 年提出。它的核心思想是将对象检测任务视为一个回归问题，直接从图像像素到边界框坐标和类别概率的映射。YOLO 以其快速和高效而闻名，特别适合需要实时处理的应用场景。 以下是 YOLO 的一些关键特点： 1. **单次检测**：YOLO 模型在单次前向传播中同时预测多个对象的边界框和类别概率，不需要多次扫描图像。 2. **速度快**：YOLO 非常快速，能够在视频帧率下进行实时检测，适合移动设备和嵌入式系统。 3. **端到端训练**：YOLO 模型可以从原始图像直接训练到最终的检测结果，无需复杂的后处理步骤。 4. **易于集成**：YOLO 模型结构简单，易于与其他视觉任务（如图像分割、关键点检测等）结合使用。 5. **多尺度预测**：YOLO 可以通过多尺度预测来检测不同大小的对象，提高了检测的准确性。 YOLO 已经发展出多个版本，包括 YOLOv1、YOLOv2（也称为 YOLO9000）、YOLOv3、YOLOv4 和 YOLOv5 等。
【信号分解】基于粒子群优化算法PSO-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
读书笔记：LeanCloud 知识库 用户使用常见问题.zip
07-19
读书笔记：LeanCloud 知识库 用户使用常见问题
Java JDBC编程：Connection接口详解
"Java_JDBC编程" 在Java中，JDBC（Java Database Connectivity）是用于连接Java应用程序和各种类型的数据库的API。它提供了一个统一的接口，使得开发人员无需关心底层数据库的具体实现，就能实现对数据库的访问。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值