JDBC学习-ORM、DAO、数据库连接池

最新推荐文章于 2024-04-16 14:29:14 发布
最新推荐文章于 2024-04-16 14:29:14 发布
阅读量595 收藏 3
点赞数 2
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oldwangold/article/details/95629179
版权

ORM

  • ORM = Object Relationship Database Mapping
  • 对象和关系数据库的映射
  • 简单说，一个对象，对应数据库里的一条记录。

1. 根据id返回一个hero对象

  • 提供方法get(int id)
  • 返回一个Hero对象

Hero类

package charactor;

public class Hero {
	//增加id属性
	public int id;
	public String name;
	public float hp;
	public int damage;
}

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

import charactor.Hero;
 
public class TestJDBC {
    public static Hero get(int id) {
    	Hero hero = null; 
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        try (
            Connection c = DriverManager.getConnection(
                  "jdbc:mysql://127.0.0.1:3306/jdbcTest?serverTimezone=Asia/Shanghai&characterEncoding=utf8",
                  "root", "admin");
        		Statement s = c.createStatement();){  	
        	String sql = "select * from hero where id=" + id;
        	ResultSet rs = s.executeQuery(sql);
        	//因为id是唯一的，ResultSet最多只能有一条记录，所以使用if代替while
        	if(rs.next()) {
        		hero = new Hero();
        		String name = rs.getString(2);
        		float hp = rs.getFloat("hp");
        		int damage = rs.getInt(4);
        		hero.name = name;
        		hero.hp = hp;
        		hero.damage = damage;
        		hero.id = id;
        	}
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return hero;
    }
    
    public static void main(String[] args) {
    	Hero h = get(6);
    	System.out.println(h.name);
    }
}

DAO

  • DAO = Data Access Object
  • 数据访问对象
  • 实际上就是运用了ORM中的思路，把数据库相关的操作都封装在这个类里面，其他地方看不到JDBC的代码。

1. DAO接口

import java.util.List;
import charactor.Hero;

public interface DAO {
	//增加
	public void add(Hero hero);
	//修改
	public void update(Hero hero);
	//删除
	public void delete(Hero hero);
	//获取
	public void get(Hero hero);
	//查询
	public List<Hero> list();
	//分页查询
	public List<Hero> list(int start,int count);

}

2. HeroDAO

设计类HeroDAO，实现接口DAO

2.1 把驱动的初始化放在构造方法HeroDAO里：

public HeroDAO() {
	try {
		Class.forName("com.mysql.cj.jdbc.Driver");
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}
}

因为驱动初始化只需要执行一次，所以放在这里更合适，其他方法也不需要写了，代码更简洁。 

2.2 提供了一个getConnection方法返回连接 

所有的数据库操作都需要事先拿到一个数据库连接Connection，以前的做法是每个方法里都对写一个，如果要改动密码，那么每个地方都需要修改。通过这种方式，只需要修改一个地方就可以了。代码变得更容易维护，而且也更加简洁。

import java.sql.Connection;
 
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
  
import charactor.Hero;
  
public class HeroDAO implements DAO{
  
    public HeroDAO() {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
  
    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection(
                  "jdbc:mysql://127.0.0.1:3306/jdbcTest?serverTimezone=Asia/Shanghai&characterEncoding=utf8",
                  "root", "admin");
    }
  
    public int getTotal() {
        int total = 0;
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "select count(*) from hero";
  
            ResultSet rs = s.executeQuery(sql);
            while (rs.next()) {
                total = rs.getInt(1);
            }
  
            System.out.println("total:" + total);
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return total;
    }
  
    public void add(Hero hero) {
  
        String sql = "insert into hero values(null,?,?,?)";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setString(1, hero.name);
            ps.setFloat(2, hero.hp);
            ps.setInt(3, hero.damage);
  
            ps.execute();
  
            ResultSet rs = ps.getGeneratedKeys();
            if (rs.next()) {
                int id = rs.getInt(1);
                hero.id = id;
            }
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
    }
  
    public void update(Hero hero) {
  
        String sql = "update hero set name= ?, hp = ? , damage = ? where id = ?";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setString(1, hero.name);
            ps.setFloat(2, hero.hp);
            ps.setInt(3, hero.damage);
            ps.setInt(4, hero.id);
  
            ps.execute();
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
  
    }
  
    public void delete(int id) {
  
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "delete from hero where id = " + id;
  
            s.execute(sql);
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
    }
  
    public Hero get(int id) {
        Hero hero = null;
  
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "select * from hero where id = " + id;
  
            ResultSet rs = s.executeQuery(sql);
  
            if (rs.next()) {
                hero = new Hero();
                String name = rs.getString(2);
                float hp = rs.getFloat("hp");
                int damage = rs.getInt(4);
                hero.name = name;
                hero.hp = hp;
                hero.damage = damage;
                hero.id = id;
            }
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return hero;
    }
  
    public List<Hero> list() {
        return list(0, Short.MAX_VALUE);
    }
  
    public List<Hero> list(int start, int count) {
        List<Hero> heros = new ArrayList<Hero>();
  
        String sql = "select * from hero order by id desc limit ?,? ";
  
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setInt(1, start);
            ps.setInt(2, count);
  
            ResultSet rs = ps.executeQuery();
  
            while (rs.next()) {
                Hero hero = new Hero();
                int id = rs.getInt(1);
                String name = rs.getString(2);
                float hp = rs.getFloat("hp");
                int damage = rs.getInt(4);
                hero.id = id;
                hero.name = name;
                hero.hp = hp;
                hero.damage = damage;
                heros.add(hero);
            }
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return heros;
    }
  
}

数据库连接池

1. 数据库连接池原理-传统方式

  • 当有多个线程，每个线程都需要连接数据库执行SQL语句的话，那么每个线程都会创建一个连接，并且在使用完毕后，关闭连接。
  • 创建连接和关闭连接的过程也是比较消耗时间的，当多线程并发的时候，系统就会变得很卡顿。
  • 同时，一个数据库同时支持的连接总数也是有限的，如果多线程并发量很大，那么数据库连接的总数就会被消耗光，后续线程发起的数据库连接就会失败。

数据库连接池原理-传统方式

2. 数据库连接池原理-使用池

与传统方式不同，连接池在使用之前，就会创建好一定数量的连接。

如果有任何线程需要使用连接，那么就从连接池里面借用，而不是自己重新创建。使用完毕后，又把这个连接归还给连接池供下一次或者其他线程使用。

倘若发生多线程并发情况，连接池里的连接被借用光了，那么其他线程就会临时等待，直到有线程被归还回来，再继续使用。

整个过程，这些连接都不会关闭，而是不断的被循环使用，从而节约了启动和关闭连接的时间。

数据库连接池原理-使用池

 3. ConnectionPool构造方法和初始化

  1. ConnectionPool()构造方法约定了这个连接池一共有多少连接
  2. 在init()初始化方法中，创建了size条连接。注意，这里不能使用try-with-resource这种自动关闭连接的方式，因为连接恰恰需要保持不关闭状态，供后续循环使用。
  3. getConnection，判断是否为空，如果是空的就wait等待，否则就借用一条连接出去。
  4. returnConnection，在使用完毕后，归还这个连接到连接池，并且在归还完毕后，调用notifyAll，通知那些等待的线程，有新的连接就可以借用了。

注：连接池设计用到了多线程的wait和notifyAll。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class ConnectionPool {
	List<Connection> cs = new ArrayList<Connection>();
	
	int size;
	public ConnectionPool(int size) {
		this.size = size;
		init();
	}
	public void init(){
		//这里恰恰不能使用try-with-resource的方式，因为这些连接都需要是"活"的，不要被自动关闭了
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            for (int i = 0; i < size; i++) {
                Connection c = DriverManager
                        .getConnection(
                                "jdbc:mysql://127.0.0.1:3306/jdbcTest?serverTimezone=Asia/Shanghai&characterEncoding=utf8",
                                "root", "admin");
                cs.add(c);
            }
        } catch(ClassNotFoundException e) {
        	e.printStackTrace();        	
        } catch(SQLException e) {
        	e.printStackTrace();
        } 
	}
	
	public synchronized Connection getConnection() {
		while (cs.isEmpty()) {
			try {
				this.wait();
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Connection c = cs.remove(0);
		return c;
	}
	
	public synchronized void returnConnection(Connection c) {
		cs.add(c);
		this.notifyAll();
	}
}

 4. 测试类

首先初始化一个有3条连接的数据库连接池

然后创建100个线程，每个线程都会从连接池中借用连接，并且在借用之后，归还连接。拿到连接之后，执行一个耗时1秒的SQL语句。

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

public class TsetConnectionPool {
	public static void main(String[] args) {
		ConnectionPool cp = new ConnectionPool(3);
		for(int i=0;i<100;i++) {
			new WorkingThread("working thread"+i,cp).start();
		}
	}
}
class WorkingThread extends Thread{
	private ConnectionPool cp;
	public WorkingThread(String name,ConnectionPool cp) {
		super(name);
		this.cp = cp;
	}
	public void run() {
		Connection c = cp.getConnection();
		System.out.println(this.getName()+":\t 获得了一根连接，并开始工作");
		try(Statement st = c.createStatement()){
			Thread.sleep(1000);
			st.execute("select * from hero");
		}catch(SQLException | InterruptedException e) {
			e.printStackTrace();
		}
		cp.returnConnection(c);
	}
}

 

王加油
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用C3P0连接池和DButils进Dao模式的数据库操作
10-25
下面将详细介绍如何利用C3P0连接池和DBUtils进行Dao模式的数据库操作。 C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。其主要特点包括自动检测、测试和回收数据库连接，...
【转载】关于DAO和ORM
qingning1的专栏
03-18 1135
原文地址：http://www.iteye.com/problems/9994 我个人的理解是这样的：  1.所谓DAO层一般是从系统分层结构出发来说的，即把数据存取操作到集中到DAO层，以便于维护和逻辑清晰，而且通常移植数据库的时候，如果系统合理分层了，则大部分工作将会集中在DAO层，这样比较容易操作  2.而ORM是针对开发而言的，就像面向过程和面向对象开发一样，是一种处理问题的方式。O
DAO与ORM区别
最新发布
JY_2000的博客
04-16 223
ORM是DAO层的一种处理方式
JDBC之DAO,ORM详解(必知必会)
高高冷的博客
06-16 1388
引言 说出来都不好意思，~ ^ ~,JDBC前前后后学了两次，都没认真学，直到最近开始搞项目才意识到它的重要性，尤其时之前以为鸡肋的知识点(ORM,DAO)这俩很重要！ 知识点 ORM与DAO都是自己建的Java类，重要的是思想 ORM (个人对ORM,DAO的认识,欢迎指正) ORM=Object Relationship Database Mapping 把数据库中的一个记录当一个对象来处理。 从程序员的角度来理解，ORM类相当于在编译器中操作数据库。 DAO DAO=DataAccess Obj
DAO模式与ORM概念
自由理想的足迹
04-15 748
DAO模式：在核心J2EE模式中是这样介绍DAO模式的：为了建立一个健壮的J2EE应用，应该将所有对数据源的访问操作抽象封装在一个公共API中。用程序设计的语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口在逻辑上对应这个特定的数据存储。 DAO模式是标准的J2EE设计模...
JPA规范
云端飞翔
07-09 855
1、持久化，DAO和ORM三个概念以及他们的关系。 1.1.1持久化 数据在计算机中的两种状态：  瞬时状态：保存在内存中的程序数据，程序退出后，数据就消失了，成为瞬时状态  持久状态：保存在磁盘上的程序数据，程序退出后依然存在，成为程序数据的持久状态  持久化：将程序数据在瞬时状态和持久状态之间的相互装换机制 1.1.2DAO  DAO的全称为Data Access Object（数据访问对象）
计算机软件-商业源码-实例124-利用DAO创建数据库.zip
05-23
4. **数据库连接管理**：为了管理数据库连接，通常会有一个Connection池，如Apache的DBCP或C3P0，它可以高效地重复使用数据库连接，避免频繁创建和关闭连接带来的性能损耗。 5. **事务管理**：对于涉及多条数据库...
支持多数据库的ORM框架ef-orm.zip
07-19
该框架对应用环境、连接池、 是否为J2EE应用等没有特殊要求。可以和EJB集成，也可与Spring集成，也可以单独使用。整个框架只有两个JAR包，模块和功能都较为轻量。依赖少 整个框架只有三个jar库。间接依赖仅有...
demo-dao-jdbc
03-13
5. **工具类**：可能包含`JDBCUtil.java`，用于管理数据库连接，如连接池的配置和管理，以及异常处理等。 此外，为了简化JDBC的使用和提高性能，项目可能引入了ORM（Object-Relational Mapping）框架，如Hibernate...
spring-jdbc-dao
01-24
1. DataSource：数据源是连接数据库的关键，Spring支持多种DataSource实现，如Apache Commons DBCP、C3P0等，它们负责管理数据库连接池。 2. JdbcTemplate：它是Spring JDBC的核心，提供了执行SQL语句和处理结果集的...
辛星浅析围绕数据操作的几个名词即model、dal、dao、orm和ar
辛星，前进的路上.
08-27 2119
第一，model       首先，model是mvc中的m，也就是模型。它指的是读取数据和改变数据的操作，它是与业务逻辑息息相关的操作。比如一个简单的功能"把学生添加到班组"，就可以理解为一个数据处理过程，它向外暴露一个接口，外面的数据不需要知道这个接口具体是怎么实现的，也不需要知道它在各个数据库下的不同表现，我们只需要知道模型层暴露出来的接口即可。      第二，dal和dao   
什么是orm和Dao
坚定的锡兵
01-27 2568
Object Relational Mapping，从对象到关系数据的映射。Data Access Object   数据访问接口ORM（Object Relational Mapping）简单的说，就是对象与关系的映射，对于实际应用来讲，对象一般指面向对象中的对象，关系指关系型数据库，对于我们具体的项目来说，就是将java中的对象与关系型数据库（oracle，mysql）中的表联系起
mybatis通用dao层封装_中式 dao 和 orm 框架 MicroDao
weixin_39616071的博客
12-04 240
micro-dao中式dao和orm框架MicroDao为了解决mybatis固有缺陷，进行全新封装的dao框架，功能覆盖mybatis，且比mybatis更灵活。MicroDao同时支持mysql和oracleMicroDao相对mybatis的优点：1，sql脚本支持修改后热部署实时生效。2，bean与数据库字段映射关系，通过注解设置到bean中，不必在sql脚本中体现。3，sql脚本支持类似...
JDBC-ORM-DAO-实体类-工具类思想
weixin_45878630的博客
05-25 72
Spring DAO vs Spring ORM vs Spring JDBC
热门推荐
Defonds 的专栏
08-12 1万+
Pat 的疑惑最近关注于 Spring 提供的数据访问技术，对于 Spring 相关的这几个项目有何不同我不是太明白：Spring-DAO (http://docs.spring.io/spring/docs/2.0.8/reference/dao.html)Spring-ORM (http://docs.spring.io/spring/docs/3.0.x/spring-framework-r
OrmLite__数据库框架
SkylakeXun的博客
12-26 245
导包http://ormlite.com/releases/ 将core和android的jar各自下载一份并导入//或者 compile 'com.j256.ormlite:ormlite-android:5.0'创建实例化bean类//表名 @DatabaseTable(tableName = "People") public class People { /* * column
Java 模拟数据库连接池 + 模拟ORM框架
Zhangguohao666的博客
07-28 639
模拟数据库连接池 JDBC六部曲中，获取连接的步骤是最为耗时的，最慢的；所以，数据库连接池就是为了解决这个很慢的问题 先想一下下面的问题： 一个连接Connection不能被多个用户同时共用（以防产生数据紊乱）【锁】 对于某一个连接，用户如何知道当前这个连接是否可用？【标记：给连接标记一个状态】 但是怎么把连接和标记放在一起呢？ 第一个方案：创建一个类（有Connection属性和状态属性） 第二个方案：创建一个数组Connection[]，在创建一个数组byte[]，两者分别存放连接和状态，并且互相对应
Java数据库连接(JDBC)详解与DAO实现
- 数据库连接池：通过连接池（如C3P0, HikariCP, DBCP等）管理数据库连接，减少创建和销毁连接的开销。 -批处理：对于大量相似的SQL操作，使用批处理可以显著提升性能。 - DAO接口与实现分离：通过定义DAO接口，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值