Day—04 JDBC

最新推荐文章于 2023-07-10 18:04:46 发布
最新推荐文章于 2023-07-10 18:04:46 发布
阅读量88 收藏
点赞数
文章标签： sqlserver 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t17246/article/details/122989262
版权

1

程序语言有多种，比如Java、Python、C/C++等，程序语言如果想执行SQL语句，也必须要先与数据库进行连接，数据库也有多种，比如MySQL、Oracle、SQL Server等。

不同的程序语言去连接不同的数据库，如果没有一个统一的标准或者规范，肯定是相当混乱的。Java语言对此的解决方案就是JDBC。

JDBC定义了一套规范标准，它对应的是各种接口与抽象类（通常对应java.sql包下面的各种类与接口），具体实现交给各数据库厂商去完成，MySQL的有自己的实现类并打成jar包发布，供程序开发人员使用；Oracle也有自己的实现jar包。如果我们要想操作数据库,就需要把厂商开发的实现类,导入进来

JDBC: java DataBase Connectivity (Java数据库链接) 是让java链接数据库的API

API:  Application Programming Intergace （应用程序接口）  就是函数库

2        JDBC 使用步骤

        第 0 步： 导包

        第1 步 ： 注册驱动（仅仅做一次）

        第 2 步： 建立连接（Connection）

        第 3 步： 创建运行SQL 的语句对象（Statement）

        第 4 步： 运行语句

        第 5 步： 处理运行结构（ResultSet）

        第 6 步： 释放资源

3  导包！！!

1)创建java x项目

2） 创建lib 文件夹

3）把mysql-connector-java-5.1.38-bin.jar复制到lib中

 Idea右上角，项目的结构化配置

 添加自己拖动到lib包中的jar包

// java 初识
public class Jdbc_01 {
    public static void main(String[] args) throws Exception {
        //第0步：导包
        //第一步： 建立驱动（仅仅做一次）
        //第2步： 建立连接（Connection）
        //第3步 ：创建运行SQL的语句对象（Statement）
        //第4步： 运行语句
        //第5步： 处理运行结果 （ResultSet）
        //第6步： 释放资源

        //第1 步： 注册驱动（仅做一次）
        Class.forName("com.mysql.jdbc.Driver");
        //第2步：建立连接（Connection）
        Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
        //Connection conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
        //第3步 ： 创建运行SQL的语句对象（Statement）
        String sql = "select * from student";
        Statement statement = conn.createStatement();
        //第4步： 运行语句，得到结果集
        ResultSet resultSet = statement.executeQuery(sql);
        //第5步： 处理运行结果（ResultSet）
        while(resultSet.next()){
            System.out.println("索引打印" + resultSet.getString(2));
            System.out.println("标签打印" + resultSet.getString("name"));
        }
        //第6步   释放资源
        resultSet.close();
        statement.close();
        conn.close();
    }
}

4 JDBC 初识

 public static void main(String[] args) throws Exception {
        //第0步：导包
        //第一步： 建立驱动（仅仅做一次）
        //第2步： 建立连接（Connection）
        //第3步 ：创建运行SQL的语句对象（Statement）
        //第4步： 运行语句
        //第5步： 处理运行结果 （ResultSet）
        //第6步： 释放资源

        //第1 步： 注册驱动（仅做一次）
        Class.forName("com.mysql.jdbc.Driver");
        //第2步：建立连接（Connection）
        Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
        //Connection conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
        //第3步 ： 创建运行SQL的语句对象（Statement）
        String sql = "select * from student";
        Statement statement = conn.createStatement();
        //第4步： 运行语句，得到结果集
        ResultSet resultSet = statement.executeQuery(sql);
        //第5步： 处理运行结果（ResultSet）
        while(resultSet.next()){
            System.out.println("索引打印" + resultSet.getString(2));
            System.out.println("标签打印" + resultSet.getString("name"));
        }
        //第6步   释放资源
        resultSet.close();
        statement.close();
        conn.close();
    }

5代码优化 （关闭资源优化,  如果值不为空，关闭操作必须进行）

 public static void main(String[] args) throws Exception {
        ResultSet resultSet = null;
        Statement statement = null;
        Connection conn = null;
        try{
            //第1 步： 注册驱动（仅做一次）
            Class.forName("com.mysql.jdbc.Driver");
            //第2步：建立连接（Connection）
           conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //Connection conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //第3步 ： 创建运行SQL的语句对象（Statement）
            String sql = "select * from student";
             statement = conn.createStatement();
            //第4步： 运行语句，得到结果集
             resultSet = statement.executeQuery(sql);
            //第5步： 处理运行结果（ResultSet）
            while(resultSet.next()){
                System.out.println("索引打印" + resultSet.getString(2));
                System.out.println("标签打印" + resultSet.getString("name"));
            }
//            //第6步   释放资源
//            resultSet.close();
//            statement.close();
//            conn.close();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                //释放资源，必须执行的    进行优化
                if(resultSet != null){
                    resultSet.close();
                }
                if(statement != null){
                    statement.close();
                }
                if(conn !=null){
                    conn.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

6  DML ： Data   Manipulation Language： 数据操作语言

涉及的关键字：delete,insert,update

  public static void main(String[] args) throws Exception {
        ResultSet resultSet =null;
        Statement statement = null;
        Connection conn = null;

        try{
            //第一步： 注册启动
            Class.forName("com.mysql.jdbc.Driver");
            //第二步： 建立连接
             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //第三步  创建sql的语句对象Statement
            String sql = "delete from student where id =6";
            statement = conn.createStatement();
            //第四步 运行语句，得到结果集
            // resultSet = statement.executeQuery(sql);
         int i =   statement.executeUpdate(sql);
            //第五步 ： 处理运行结果
            System.out.println("影响了"+ i +"条");
//            while(resultSet.next()){
//                System.out.println("索引打印" + resultSet.getString(2));
//                System.out.println("标签打印" + resultSet.getString("name"));
//            }

        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            try{
                if(resultSet !=null){
                    resultSet.close();
                }
                if(statement !=null){
                    statement.close();
                }
                if(conn !=null){
                    conn.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

6 PreparedStatement 

在进行添加或者 更新的时候，尽量使用  PreparedStatement   而不是Statement

区别：

  1）Statement用于执行静态SQL语句,在执行的时候,必须指定一个事先准备好的SQL语句,并且相对不安全,会有SQL注入的风险

2）PrepareStatement  是预编译的SQL语句对象，sql语句被预编译并保存在对象中，被封装的sql语句中可以使用动态包含的参数？           在执行的时候，可以为？ 传递参数

3）使用 PrepareStatement 对象执行sql的时候，sql被数据库进行预编译和预解析，然后被放到缓冲区

4）每当执行同一个PreparedStatement对象时,他就会被解析一次,但不会被再次编译 可以重复使用,可以减少编译次数,提高数据库性能，并且能够避免SQL注入,相对安全(把’ 单引号 使用 \ 转义,避免SQL注入 )

7 DQL

public static void load(int id) {

		Connection conn = null;
		PreparedStatement prst = null;
		ResultSet rs = null;
		try {
			// 1 加载驱动
			Class.forName("com.mysql.jdbc.Driver");
			// 2 创建数据库连接对象
			conn = DriverManager.getConnection(
					"jdbc:mysql://127.0.0.1:3306/_06_", "root", "root");

			// 这里我们用? 问号代替值,可以叫占位符,也可以叫通配符
			String sql = "select * from test_jdbc where id = ?";
			// 3 语句传输对象
			prst = conn.prepareStatement(sql);
			// 设置第一个?的值
			prst.setInt(1, id);
			rs = prst.executeQuery();
			while (rs.next()) {
				System.out.print(rs.getInt("id") + "   ");
				System.out.print(rs.getString("name") + "   ");
				System.out.println(rs.getString("money") + "   ");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭资源,从上到下依次关闭,后打开的先关闭
				if (rs != null) {
					rs.close();
				}
				if (prst != null) {
					prst.close();
				}
				if (conn != null) {
					conn.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}

8       新的SQL 对象

  public static void main(String[] args) {
        Connection conn =null;
        Statement statement =null;
        ResultSet resultSet = null;
        PreparedStatement preparedStatement=null;
        try{
            // 1注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2建立连接
           // conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //3 创建运行SQL的语句对象
            String sql = "insert into student (id,name,teacher_id,score) values(12,'王',7,61)";
            preparedStatement = conn.prepareStatement(sql);
            //4 运行语句
            int i = preparedStatement.executeUpdate();
            //5 处理运行结果
            System.out.println("影响了" +i + '条');
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            try {
                if(preparedStatement != null){
                    preparedStatement.close();
                }
                if(statement != null){
                    statement.close();
                }
                if(conn != null){
                    conn.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

9俩个SQL 语句对象的区别

 public static void main(String[] args) {
  //  sta("2");
    pre("1");
    }
    public static void sta(String id){
        ResultSet resultSet = null;
        Statement statement = null;
        Connection conn = null;
        try{
            //第1 步： 注册驱动（仅做一次）
            Class.forName("com.mysql.jdbc.Driver");
            //第2步：建立连接（Connection）
            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //Connection conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //第3步 ： 创建运行SQL的语句对象（Statement）
            String sql = "delete from student where id = " +id;
            statement = conn.createStatement();
            System.out.println(sql);
            //第4步： 运行语句，得到结果集
            //  resultSet = statement.executeQuery(sql);
            int i = statement.executeUpdate(sql);
            System.out.println("影响了" +i+ "条");
            //第5步： 处理运行结果（ResultSet）
//            while(resultSet.next()){
//                System.out.println("索引打印" + resultSet.getString(2));
//                System.out.println("标签打印" + resultSet.getString("name"));
//            }
//            //第6步   释放资源
//            resultSet.close();
//            statement.close();
//            conn.close();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                //释放资源，必须执行的    进行优化
                if(resultSet != null){
                    resultSet.close();
                }
                if(statement != null){
                    statement.close();
                }
                if(conn !=null){
                    conn.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void pre(String id){
        ResultSet resultSet = null;
        Statement statement = null;
        Connection conn = null;
        PreparedStatement preparedStatement = null;
        try{
            //第1 步： 注册驱动（仅做一次）
            Class.forName("com.mysql.jdbc.Driver");
            //第2步：建立连接（Connection）
            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //Connection conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //第3步 ： 创建运行SQL的语句对象（Statement）
            String sql = "select * from student where id =?";
            preparedStatement = conn.prepareStatement(sql);
            System.out.println(sql);
            preparedStatement.setString(1,id);
            //第4步： 运行语句，得到结果集
            resultSet = preparedStatement.executeQuery();
            //第5步： 处理运行结果（ResultSet）
            while(resultSet.next()){
                System.out.println("索引打印" + resultSet.getString(2));
                System.out.println("标签打印" + resultSet.getString("name"));
            }
//            //第6步   释放资源
//            resultSet.close();
//            statement.close();
//            conn.close();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                //释放资源，必须执行的    进行优化
                if(resultSet != null){
                    resultSet.close();
                }
                if(statement != null){
                    statement.close();
                }
                if(conn !=null){
                    conn.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }

9封装 

将 第一步  第二步 放入封装类， 可以使用 Resource Bundle  将 数据库，账号 密码保存，

url=    "jdbc:mysql://127.0.0.1:3306/_02","root","041036"
username = root
password =041036

工具类

public class Jdbc_Util {
    public  static Connection getConnection() throws Exception {
        //第1 步： 注册驱动（仅做一次）
        Class.forName("com.mysql.jdbc.Driver");
        Properties properties=new Properties();
        properties.load(Jdbc_Util.class.getClassLoader().getResourceAsStream("jdbc.properties"));
//        properties.getProperty("url");
//        //第2步：建立连接（Connection）
//        return  DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
      String url = properties.getProperty("url");
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        return DriverManager.getConnection(url,username,password);
    }

//    public static void main(String[] args) throws Exception {
//        Properties properties = new Properties();
//       // properties.load(Jdbc_Util.class.getClassLoader().getResourceAsStream("jdbc.properties"));
//        properties.load(Jdbc_Util.class.getClassLoader().getResourceAsStream("jdbc.properties"));
//        System.out.println(properties.getProperty("url"));
//        System.out.println(properties.getProperty("password"));
//    }
    //关闭工具类的方法
//    public static void closeResultSet(ResultSet resultSet) throws SQLException {
//        resultSet.close();
//    }
//    public static void closeResultSet(Statement statement) throws SQLException {
//        statement.close();
//    }
//    public static void closeResultSet(Connection connection) throws SQLException {
//        connection.close();
//    }
    public  static  void closeResultSet(AutoCloseable autoCloseable){
        try {
            if(autoCloseable!=null){
                autoCloseable.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    }

封装后 

  public static void main(String[] args) {
        ResultSet resultSet = null;
        Statement statement = null;
        Connection conn = null;
        try{
          conn = Jdbc_Util.getConnection();
            //Connection conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/_02","root","041036");
            //第3步 ： 创建运行SQL的语句对象（Statement）
            String sql = "select * from student";
            statement = conn.createStatement();
            //第4步： 运行语句，得到结果集
            resultSet = statement.executeQuery(sql);
            //第5步： 处理运行结果（ResultSet）
            while(resultSet.next()){
                System.out.println("索引打印" + resultSet.getString(2));
                System.out.println("标签打印" + resultSet.getString("name"));
            }
//            //第6步   释放资源
//            resultSet.close();
//            statement.close();
//            conn.close();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                //释放资源，必须执行的    进行优化
                if(resultSet != null){
                    resultSet.close();
                }
                if(statement != null){
                    statement.close();
                }
                if(conn !=null){
                    conn.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

10 Batch  多语句操作      

        在一次任务中，执行多条数据

	Connection conn = null;
		Statement stmt = null;
		try {
			conn = DBUtil.getConnection();
			stmt = conn.createStatement();
			stmt.addBatch("insert into test_jdbc (id,name,money) values(21,'stmt多条测试1',99.12)");
			stmt.addBatch("insert into test_jdbc (id,name,money) values(22,'stmt多条测试2',99.22)");
			stmt.addBatch("insert into test_jdbc (id,name,money) values(23,'stmt多条测试3',99.32)");
			stmt.addBatch("insert into test_jdbc (id,name,money) values(24,'stmt多条测试4',99.42)");
			stmt.executeBatch();
			System.out.println("执行成功");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			DBUtil.close(stmt);
			DBUtil.close(conn);
		}

11 SQ 注入

        所谓SQL注入，就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来说，它是利用现有应用程序，将（恶意的）SQL命令注入到后台数据 库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句

12 事物

在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)

四大特性：

原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的操作要么都做，要么都不做。

一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

持久性（durability）。持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

13连接池（拓展）

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能

13.2 应用场景

场景一：电商网站如淘宝、京东每年都会有双11这种活动，同一时刻，会有上亿甚至上十亿的用户访问数据库（因为要生成订单等数据），如果我们还使用上面的思路，显然是捉襟见肘。

场景二：某服务器上除了运行MYSQL服务，还有其他一些服务比如WEB服务。我们知道，数据库连接的创建维持不只消耗我们客户端（个人PC）的系统资源（CPU、内存、IO设备），更消耗服务器的系统资源，而假如我们在周末时并不会去访问数据库，这时候服务器上依然还维持着一条空闲的连接，假设占用了2M内存，现在服务器上内存已经都被分配出去了，WEB服务却要求新申请1M内存，很显然，由于内存不足，WEB服务就无法正常运行了。

连接池的引入，则主要解决了以上2类问题：

  1. 能给多用户分配连接或者给一个用户分配多个连接；
  2. 在适当的时候回收空闲连接以节省系统资源。

JDBC连接池有一个对应的接口javax.sql.DataSource。它也是一个标准一个规范，目前实现了这套规范的连接池产品主要有：

DBCP（MyBatis通常使用这个连接池）、C3P0（Hibernate通常使用这个连接池）、JNDI（Tomcat的默认连接池）。

我们使用DBCP来讲解。

DBCP内部提供了一个“池子”，程序启动的时候，先创建一些连接对象放到这个池子中，备用，当调用连接池的getConnection()方法时，就从池子取出连接对象分配给多个用户/线程。使用完毕调用close()方法时，DBCP重写了close方法，它并不真正关闭连接，而是返还到池子中，由DBCP自动管理池子中的连接对象，在适当的时候真正关闭这些连接。

优点 :

  1. 资源复用 : 数据库连接得到重用,避免了频繁创建释放链接引起的大量性能开销

在减少系统消耗的基础上,也增进了系统运行环境的平稳性

  1. 更快的系统响应速度 : 数据库连接池在初始化过程中,往往就已经创建了若干个数据库连接对象放到池中备用

这时,连接的初始化工作已完成,对于业务请求处理而言,直接利用现有的可用连接,避免了数据库连接初始化和释放过程的时间,从而缩减了系统整体的响应时间

  1. 统一的连接管理,避免数据库连接遗漏 : 在较为完备数据库连接池中,可以根据预先的连接占用超时设定,强制回收占用连接,从而避免了常规数据库连接操作中可能出现的资源泄露情况

13.2 创建连接池工具类  和测试连接池

public class BasicDataSourceUtil {
	private BasicDataSource bds;
	private static BasicDataSourceUtil bdsu;

	/**
	 * 把初始化数据库链接的代码,放到了 单例模式的构造方法中
	 * 
	 * 因为当前类是单例的,所以构造方法只能被执行一次,那么链接池对象也就成了单例
	 */
	private BasicDataSourceUtil() {
		bds = new BasicDataSource();
		Properties properties = PropertiesUtil.getProperties();
		bds.setDriverClassName(properties.getProperty("driver"));
		bds.setUrl(properties.getProperty("url"));
		bds.setUsername(properties.getProperty("username"));
		bds.setPassword(properties.getProperty("password"));
	}

	/**
	 * 主要为了解决高并发,所以需要线程安全的单例模式
	 * 
	 * @return
	 */
	public static BasicDataSourceUtil getInstance() {
		if (bdsu == null) {
			synchronized (BasicDataSourceUtil.class) {
				if (bdsu == null) {
					bdsu = new BasicDataSourceUtil();
				}
			}
		}
		return bdsu;
	}

	/**
	 * 提供一个获取链接对象的方法
	 * 
	 * @return
	 */
	public BasicDataSource getBasicDataSource() {
		return bds;
	}
}

public class DBCPTest {
	public static void main(String[] args) throws SQLException {
		for (int i = 0; i < 10; i++) {
			System.out.println(BasicDataSourceUtil.getInstance()
					.getBasicDataSource());
		}
		// 10次对象一样,已经单例模式
		BasicDataSourceUtil bdsu = BasicDataSourceUtil.getInstance();
		BasicDataSource bds = bdsu.getBasicDataSource();
		System.out.println(bds.getConnection());

	}

t17246
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDBC-第四天
qq_40703471的博客
03-16 157
JDBC4 .equalsIngoreCase（）：忽略大小写的比较 判断一个变量是否与某个字符串相等： 一般使用: 这里，select为要比较的对象 if("a".equalsIngoreCase(select)){ } 而不使用： if(select.equalsIngoreCase("a")){ } 这是因为，“a”放在前面可以避免空指针异常（因为select是未知的） PreparedStatement操作Blob的数据，而Statement做不到。 MySQL BLOB是一个二进制大型对象
Day 37 JDBC高级
01-21
JDBC高级 1. Statement操作SQL语句 1.1 Statement查询SQL数据操作 // 查询指定的一个数据行，转换成对应的User对象 @Test public void testSelectOne() { ResultSet resultSet = null; Statement statement = null...
性能测试：数据库连接池问题分析
weixin_43865008的博客
08-09 2046
前言 今天我们来压测一个支付的接口，10个并发，压测5分钟。下面我们可以看到tps大概在200多，响应时间在40ms左右。 下面我们来看一下服务器的性能，应用服务器的cpu使用率大概在60%左右。 再来看一下数据库服务器，数据库服务器的性能还算正常，cpu使用率大概在25%左右，而且我们支付的接口，还是在做一个写库的操作，下单的时候，会往订单表中插入数据。 并且我们不断加压，新增并发，cpu仍然没有大概100%，tps也没有新增，响应时间整体越来越长。通常这种现象我们应该怎么排查呢？ 可以从下面两方面
数据库连接池
qq_41504815的博客
02-23 143
一、概述 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个； 释放,空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。 这项技术能明显提高对数据库操作的性能。 二、应用场景 场景一：电商网站如淘宝、京东每年都会有双11这种活动，同一时刻，会有上亿甚至上十亿的用户访问数据库（因为要生成订单等数据），如果我们还使用上面的思路，显然是捉襟见肘。 场景二：某服务器上除了运行MYSQL服务，还有其他一些服务比如WEB服务
数据库连接池大小
xiaokanfuchen86的博客
01-02 888
数据库连接池究竟应该设置多大？ 首先是CPU，如果我们不考虑磁盘，网络和内存等等其它因素，那么我们的连接数和CPU的核数相等是效率最高的，比如我有8核CPU，那我的连接池就只有8个连接，这样是效率最高的，但是我们考虑到，我们有磁盘去磁盘上读取数据，那么这个磁盘就会涉及到一个IO的读取和等待，那么在磁盘读取等待的过程中，这个CPU是处于空闲状态，那么为了让CPU可以得到充分的利用，那这个时候我们可以把这个连接数再加大一点，所以它乘以2，那么同理还有网络，那么网络的连接也会消耗一些时间，在这个网络连接过程...
JAVA线程池
一名在校大三学习JAVA
06-29 959
目录池的思想JDK中线程池的使用线程池的核心父接口ExecutorService ThreadPoolExecutor子类的核心构造方法参数
详解数据库连接池概念、原理、运行机制等
weixin_30485379的博客
06-16 686
概述 　　数据库连接池是负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。那么其中的运行机制又是怎样的呢？今天主要介绍一下数据库连接池原理和常用的连接池。 01 为什么要使用连接池 　　数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。 一个数据库连接对象均对应一个物理数据库连接，每次操作都打开一个物理连接，...
Jdbc_Day01.zip_jdbc
09-24
在"Jdbc_Day01.zip_jdbc"这个压缩包中，我们可以预期找到一些关于JDBC基础使用和数据库连接的教程资料。 JDBC的核心组件包括以下几个部分： 1. **Driver Manager**：这是JDBC的入口点，负责管理所有已注册的数据库...
day01_jdbc基础.md
06-15
JDBC的定义，JDBCUtils,JDBC HelloWorld，什么情况会触发类加载，DriverManager，Connetion，Statement，ResultSet，三层结构，对象创建过程，配置Tomcat步骤
day02_jdbc高级.md
06-15
数据库连接池的概念，自定义数据库连接池，开源数据库连接池，自定义JDBC框架， DataSource 接口，归还数据库连接的方式，继承，装饰设计模式，适配器设计模式，动态代理
spring_day04
01-10
这个接口的存在使得Spring能够适配多种底层的事务管理系统，如JDBC、Hibernate、JPA或者其他的ORM框架。通过实现`PlatformTransactionManager`，Spring可以灵活地在不同的事务策略间切换，无需改动事务管理的代码...
（五）优化数据库连接
weixin_38970751的博客
02-03 329
数据库在建立连接和释放连接都会消耗较大的cpu资源，为了性能，引入连接池的概念： public class DbUtil implements DataSource{ private static DbUtil dbUtil = new DbUtil(); public static DbUtil getInstance(){ return dbUtil; }...
什么是池化技术
极客神殿
09-20 8453
什么是池化技术 池化技术 (Pool) 是一种很常见的编程技巧，在请求量大时能明显优化应用性能，降低系统频繁建连的资源开销。我们日常工作中常见的有数据库连接池、线程池、对象池等，它们的特点都是将 “昂贵的”、“费时的” 的资源维护在一个特定的 “池子” 中，规定其最小连接数、最大连接数、阻塞队列等配置，方便进行统一管理和复用，通常还会附带一些探活机制、强制回收、监控一类的配套功能。 池化技术 简介 提前保存大量的资源，以备不时之需以及重复使用。池化技术应用广泛，如内存池，线程池，连接池等等。内存池相关的内
面试官：为什么数据库连接很消耗资源，资源都消耗在哪里？
java思维导图
04-08 231
编辑：业余草blog.csdn.net/lmy86263推荐：https://www.xttblog.com/?p=5329❝开发应用程序久了，总想刨根问底，尤其对一些有公共答案的问题。大家都能解释，但是追根究底，都解释不清。凡是都有为什么，而且用数字说明问题是最直观的。❞本文主要想探究一下连接数据库的细节，尤其是在Web应用中要使用数据库来连接池，以免每次发送一次请求就...
MySQL JDBC详解
梁辰兴的博客
06-06 1740
JDBC 的顶层是开发人员自己编写的 Java 应用程序，如下图所示。Java 应用程序可以通过集成在 JDK 中的 java.sql 及 javax.sql 包中的 JDBC API 来访问数据库。下面讲解上图中出现的一些 JDBC 重要组件，思维导图如下。JDBC API 包含了 Java 应用程序与各种不同数据库交互的标准接口，如Connection连接接口、Statement操作接口、ResultSet结果集接口、预处理操作接口等，使用这些JDBC接口可以操作各种关系型数据库；
MySQL | JDBC连接数据库详细教程【全程干货】
热门推荐
做技术人 · 产优质博客 · 找好工作
05-28 2万+
如何使用JDBC连接MySQL数据库详细教程
MySQL-JDBC详细介绍
小小鱼
11-18 7406
JDBC全称Java database connectivity，是Java和数据库连接的一个桥梁，是一种使用Java操作数据库的规范。 JDBC编程步骤一、JDBC准备工作二、初始化资源类三、执行sql语句类四、实现JDBC操作数据库 一、JDBC准备工作 1、因为访问数据库需要用到专门的第三方工具类的jar包，所以我们在使用时需要引入外部jar包，以IDEA编辑器和mysql为例，这里我们需要使用Maven工程，新建Maven工程，在maven官网(https://mvnrepository.com/)
JDBC连接Mysql数据库详解
最新发布
2301_77478553的博客
07-10 8249
今天讲述了如何在jdbc连接mysql数据库详解，可以对数据进行基本操作，但是由于代码比较多，我们要实现封装代码的功能，让我们的代码看上去更加清晰明了，高大上，并且同时实现查询一条数据和多条数据的功能，还需要更多的努力。明天会具体探究JDBC连接后mysql的增删改查数据的操作，会牵扯到反射，多态，封装，SSM框架等知识点的学习，有兴趣的可以等待一下，明天准时发布！因为JDBC是通过接口来调用方法的，当你导入了驱动jar包（实现类）后，那调用的方法肯定是实现类里面的方法。
Mysql数据库——JDBC
虚知
10-08 2612
JDBC 全称为Java Database Connectivity，他可以使java通过程序操作关系型数据库，JDBC基于驱动程序实现与数据库的连接与操作类似电脑的USB接口，可以链接鼠标，键盘，打印机，摄像头等不同的设备，只需要通过驱动来识别判断使用属于哪一种设备，JDBC驱动程序也可以通过驱动来使得Java程序使用数据库。
Java JDBC与XML技术 DAY03
Java JDBC/XML-Day03知识点总结 一、Java JDBC/XML概述 Java JDBC/XML是一种Java标准的数据库连接API，允许开发者使用Java语言与各种数据库管理系统（DBMS）进行交互。JDBC/XML提供了一种通用的数据库连接方式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值