JDBC从工具类到增删查改操作

JDBC

什么是JDBC

就是java语言连接数据库的规范

针对每一个数据库厂商提供一个驱动jar包(就是一些核心的规范)

JDBC的本质就是提供了驱动的实现类

1)导入jar包---在java工程下创建lib目录---将所有第三方的jar包放入进来
2)注册驱动
3)获取数据库连接
4)准备sql语句
5)通过数据库连接对象获取执行对象Statement
6)执行sql语句,向数据库服务器发送指令
7)返回结果
8)释放资源

JDBC中设计相关的核心类以及核心接口的API

1.	com.mysql.jdbc.Driver   ---->class 驱动类 
			implements	java.sql.Driver 接口 (驱动程序)
  Class.forName("com.mysql.jdbc.Driver") ;为了保证向下兼容性(JDK6以前)
  com.mysql.jdbc.Drvier----->这个类一加载,静态代码也会随之加载
  
  	static{
  		 DriverManager.registerDriver(Driver driver) ---- 这里面已经注册过了
  	}
2.获取数据连接对象
	核心类
	DriverManager -------->驱动管理类----管理JDBC驱动程序服务!
		成员方法
				public static void registerDriver(Driver driver):注册驱动
				public static Connection getConnection(	
										String url,
       									String user,
                                       String password):获取数据库的连接对象
                                通过创建系统资源发送到数据库的一种url请求 
                参数1:
                	url:统一资源定位符
                	协议://域名或者ip地址:端口号/链接具体地址
                	jdbc:mysql://localhost:3306/数据库名称
                 参数2:用户名:root用户
                 参数3:密码                 
3.Connection---java.sql.Connection       
		与指定的数据库的一种会话!----通过系统资源获取
		 
		成员方法
			有关事务管理相关的方法
			void setAutoCommit(boolean autoCommit):设置数据库的提交方式 :
					参数为true:表示自动提交
					参数为false:表示禁用自动提交
			void rollback():事务的回滚
			void commit():事务的提交
			
			与数据库执行对象相关方法
				Statement createStatement():创建Statement对象,将指定sql发送到数据库中
				PreparedStatement prepareStatement(String sql):将
				
					类似于
							insert into account values(?,?,?) ; sql语句先进行预编译
4.Statement ----java.sql.Statement
	执行对象:执行静态sql语句
	静态的sql语句
			insert into account values(1,'张三',1000),(2,'李四',1000);
			update account set balance = balance -500 where id = 1 ;
			
			成员方法
			int executeUpdate(String sql) : 通过Statement将静态sql语句发送到数据库中进行操作
							执行增删该
			
			ResultSet executeQuery(String sql):执行查询语句select...
						select * from student ;
5.PreparedStatement ----java.sql.PreparedStatement:预编译对象
			insert into account values(?,?,?) ;
			
				int executeUpdate():对预编译对象中sql语句直接操作!
				
6.ResultSet ----java.sql.ResultSet:表示数据库结果集的数据表 	
				
				成员方法
					boolean next():判断下一行是否存在有效数据!
					
					XXX getXXX(int columnIndex):根据列的索引值获取表中结果数据:索引值1开始
						如果是第一列,则为1
						....第二列,则为2
					XXX getXXX(String columnLabel):根据列的名称获取

JDBC的基本使用

1.执行DDL语句  创建一个表
2.执行DMl语句 	
	insert into
	update
	delete

JDBC操作查询语句

ResultSet ----- java.sql.ResultSet: 查询数据表汇总的结果集
....

select * from ...

封装工具类: DButils

将重复性代码抽取出来  关闭资源,获取连接对象
--将url,user,password,驱动核心类 com.mysql.jdbc.driver---封装到jdbc.properites配置文件中

封装步骤:
	静态代码块{
		将jdbc.properites配置文件加载到属性集合类中properties
		
		获取参数信息
		driverClass
		user
		password
		url
		
		
		注册驱动
	}
	封装获取连接对象方法getConnection()
	
	封装释放资源的方法
	close(ResultSet rs,Statement stmt,Connection conn)
	close(Statement stmt,Connection conn)

手动jdbc工具类的封装–>针对原生Jdbc的封装

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcUtils {	
	//成员变量的位置
	public static String url = null ;
	public static String user = null ;
	public static String password = null ;	
	//提供一个属性
	public static String driverClass = null ;	
	//提供一个静态代码块
	//在加载JdbcUtils类的时候,静态代码中的内容优先执行	
	static {
		
		try {
			//创建一个属性集合类对象
			Properties prop = new Properties() ;
			
			//将jdbc.properties的配置文件内容加载到prop属性集合中
			 InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties") ;
			 
			 //load(Reader r) 
			 //load(InputStream in)
			 prop.load(inputStream);
			 //System.out.println(prop);
			 
			 //通过prop的键获取值
			  url = prop.getProperty("url") ;
			  user = prop.getProperty("user") ;
			  password = prop.getProperty("password") ;
			  driverClass = prop.getProperty("driverClass") ;
			  
			 //注册驱动
			  Class.forName(driverClass) ;
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}
	//构造方法私有化
	private JdbcUtils() {}	
	//静态功能
	//获取连接对象--封装
	public static Connection myGetConnection() {
		//需要通过驱动管理类获取 DriverManager
		//三个参数需要放在配置文件 xx.properites----将三个参数:jdbc.properties
		
		try {
			Connection conn  = DriverManager.getConnection(url, user, password);
			return conn ;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return null ;
	}
	//关闭资源---封装
	//针对DQL语句进行操作:释放资源
	public static void close(ResultSet rs,Statement stmt,Connection conn) {
		if(rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(stmt!=null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}	
	//针对DDL/DML:增删改 释放资源
	public static void close(Statement stmt,Connection conn) {
		
		close(null, stmt, conn);
	}
}

封装工具类----Druid连接池

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
/*
  封装工具类
  
  	1)使用连接池获取连接对象 ----Druid连接池
  		DruidDataSourceFactory.createDataSource(Properties prop)--->javax.sql.DataSource
  
  	2)封装获取连接的方法
  	  mygetConnection()-----DataSource对象可以调用getConnection()
  	3)释放资源

 */
public class MyJdbcUtils {
	//成员位置声明
	private static DataSource ds ;
	private MyJdbcUtils() {}
	
	static {
		try {
			//创建一个属性集合类对象
			Properties prop = new Properties() ;
			//读取druid.properties 核心配置文件
			InputStream inputStream = MyJdbcUtils.class.
						getClassLoader().getResourceAsStream("druid.properties") ;
			
			//加载到prop
			prop.load(inputStream);
			//通过Druid连接池提供 的工厂类创建物理数据源DataSource
			ds = DruidDataSourceFactory.createDataSource(prop) ;
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	//获取数据库连接
	public static Connection getConnection() {
		Connection conn = null ;
		try {
			conn = ds.getConnection() ;
			return conn ;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null ;
	}
	
	//获取DataSource的方法
	public static DataSource getDataSource() {
		return ds; 
	}
	
	//释放资源的方法
	public static void close(ResultSet rs,PreparedStatement stmt,Connection conn) {
		
		if(rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(stmt!=null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void close(PreparedStatement stmt,Connection conn) {
		close(null, stmt, conn);
	}
}

Statement/PreparedStatement的区别

后者比前者更安全,有效的方式sql注入

执行对象
	Statement操作静态的sql语句,执行效率低
		存在字符串拼接,造成sql注入
预编译对象		
	PreparedStatement
	通过连接对象获取预编译对象的同时将参数化的sql发送数据库进行预编译
	执行效率高,能够有效防止sql注入                                                                               

PreparedStatement执行DML和DQL的基本操作是什么

1)注册驱动
2)获取数据库连接
3)准备参数化的sql
4)通过连接对象获取预编译对象
5)参数赋值 setXXX(占位符的索引值,实际参数)
6)执行
	int executeUpdate()
	返回结果
	
	ResultSet executeQuery()
	遍历结果集

JDBC方式处理事务

Connection 对象
void setAutoCommit(boolean autoCommit): 是否启用自动提交 true 表示自动提交
void rollback():事务回滚
void commit()提交事务之后,持久更改

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import com.utils.JdbcUtils;
/*
 	模拟转账操作
 	将转账的操作看成一个整体,使用事务进行管理
 	
 	void setAutoCommit(boolean autoCommit):
 	 			是否启用自动提交 true 表示自动提交
	void rollback():事务回滚
	void commit()提交事务之后,持久更改
 */
public class Jdbc_TransactionDemo {
	public static void main(String[] args) {
		Connection conn =null;
		PreparedStatement stmt =null;
		try {
			//获取连接
			conn = JdbcUtils.getConnection();
			//管理实务
			//禁用自动提交
			conn.setAutoCommit(false);
            
			//准备sql
			String sql1 = "update account set balance = balance-? where id =?";
			//获取预编译对象
			stmt = conn.prepareStatement(sql1);
			//赋值
			stmt.setInt(1, 500);
			stmt.setInt(2,1);
			//执行更新
			int count1 = stmt.executeUpdate();
			System.out.println("共"+count1+"行受到了影响");
			//int i = 10/0;
			String sql2 = "update account set balance = balance+? where id =?";
			//获取预编译对象
			stmt = conn.prepareStatement(sql2);
			//赋值
			stmt.setInt(1, 500);
			stmt.setInt(2, 2);
			//执行更新
			int count2 = stmt.executeUpdate();
			System.out.println("共"+count2+"行受到了影响");
			//提交事务
			conn.commit();
			System.out.println("事务提交成功");
			
		} catch (SQLException e) {
			//回滚
			if(conn!=null) {
				try {
					conn.rollback();
				} catch (SQLException e1) {
					e1.printStackTrace();
				}
			}
			e.printStackTrace();
		}finally {
			JdbcUtils.close(conn, stmt);
		}
		
	}
}

连接池

连接池 :
	连接对象可以重复利用(固定的 /可重用的)-----使用完毕之后会再次归还到连接池中
自动参与连接 

sun提供了接口 java.sql.DataSource:物理数据源的链接----代替了DriverManager工具(jdbc的一组服务)
	成员方法
		Connection getConnection();

驱动类的厂商提供: 
    c3p0核心jar包  源码包		--- 日志记录
    druid核心jar包 源码包
    dbcp核心jar包...

c3p0 连接池

 c3p0连接池----相关的jar包
  
  1)导入jar包
  		c3p0-0.9.5.2.jar  -核心jar包
  		mchange-commons-java-0.2.12.jar  c3p0的依赖包
  2)需要将c3p0核心配置文件存储在src目录下  自动读取
  		两种方式
  			c3p0.properties
  			c3p0-config.xml ----- spring,springmvc,mybatis主流框架xml文件配置方式
  		
  
  3)配置文件中提了一些
  		基本参数
  			driverClass:数据库驱动实现
  			jdbcUrl 连接特定的数据库
  			user用户名
  			password 密码
  		
  
  连接池的参数信息
  initialPoolSize :初始化连接数量
  maxPoolSize:最大连接数量
  checkoutTimeout:超时时间 单位为毫秒  如果超过最大连接数量,在指定时间连接不上,就会出现问题了

public class C3p0Demo {
	public static void main(String[] args) throws SQLException {
		//创建c3p0连接池对象
		//无参构造方法:会默认读取 src目录下c3p0-config.xml 配置
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		//输出
		System.out.println(dataSource.getConnection());
		//com.mchange.v2.c3p0.impl.NewProxyConnection@2e222612 [wrapping: com.mysql.jdbc.JDBC4Connection@61386958]

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

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3p0Demo2 {
	public static void main(String[] args) throws SQLException {
		//创建c3p0连接对象
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		//获取连接对象
		Connection conn = null;
		for (int i = 1; i <= 11; i++) {
			if(i == 3) {
				//释放一个
				conn.close();//将第三个对象归还到连接池中
			}
			conn = dataSource.getConnection();
			System.out.println(conn+":"+i);
		}
	}
}

druid: 使用居多— 阿里巴巴开源项目 ‘特鲁伊’

连接池: 频繁的操作DML/DQL 
	获取连接Connection对象-->使用完毕-->释放资源(资源消耗大)
提供一些参数
	最大连接数量 10
	等待时间
	最小连接数量
	激活数量
	
	将连接对象创建以后,可以重复利用,他关闭释放资源连接对象归还到连接池中
	

连接速度很快----可以更有效的监控sql语句    查询语句的耗时以及并发时间

	1) 导入核心jar包  
	druid-1.0.9.jar		--- DruidDataSource
	
   2)在src目录执行核心配置文件
   	jdbc.properites (名称可以随便起)
   	有一些基本参数信息
   	连接池的信息  
   	
   	
druid里面内置的属性名字
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb_02
username=root
password=123456

连接池的默认配置信息
initialSize=5  初始化连接数量5
maxActive=10   最大激活数量10个
maxWait=3000    最大的等待时间


获取连接对象:
使DruidDataSourceFactory:德鲁伊的物理数据源的工厂类
静态方法
	 public static DataSource createDataSource(Properties properties){}
	 创建物理数据源对象

import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
public class DruidDemo {
	
	public static void main(String[] args) throws Exception {
		
		//测试下
		
		//创建属性集合类对象
		Properties prop = new Properties() ;
		//读取src下面的druid.properties文件
		ClassLoader classLoader = DruidDemo.class.getClassLoader() ;
		InputStream inputStream = classLoader.getResourceAsStream("druid.properties") ;
		
		//将文件内容加载到属性集合类中
		prop.load(inputStream);
		System.out.println(prop);
        
		//druid连接池获取连接对象
		//DruidDataSourceFactory
		// public static DataSource createDataSource(Properties properties){}
		DataSource dataSource = DruidDataSourceFactory.createDataSource(prop) ;
		//获取连接对象
		Connection conn = dataSource.getConnection() ;
		System.out.println(conn);
	}
}

Dbutils — apache开源项目(JDBC的封装工具)

apache提供的开源类库:工具类 对jdbc简单的封装
commons-dbutils-1.7.jar  核心jar包

1)导入包
2)执行对象:
QueryRunner  
 	ResultSetHandler:处理程序 接口
 		实现类
 			 需要将查询某条记录封装成对象  :BeanHandler<?>
 			需要将查询的多条记录(查询所有)封装List集合对象 :BeanListHandler<?>
 			查询的单行单列的数据:查询总记录数/....
 				聚合函数查询	ScalarHandler<>
 			qr.query(sql,new ScalarHandler<>())
 			因为返回值为int 所以 可以先使用int的父类 number 或者long来接收
 			再转换成int来返回。

JDBC增删改查–> DaoImpl类–原生JDBC操作

//新增
public int insert(Person person){
    Connection conn = null;
    PreparedStatement stmt = null;
	String sql = "insert into person(name,age,borndate,email,address) 									values(?,?,?,?,?)";
    try {
        conn = MyJdbcUtils.myGetConnection();
        stmt = conn.prepareStatement(sql);
        stmt.setString(1,person.getName());
        stmt.setInt(2,person.getAge());
        stmt.setDate(3,null);
        stmt.setString(4,person.getEmail());
        stmt.setString(5,person.getAddress());
        int result = stmt.executeUpdate();
   		return result;
    } catch (SQLException e) {
    	e.printStackTrace();
    }finally {
   	 	MyJdbcUtils.close(conn,stmt);
    }
    return 0;
}
//修改
public int update(Person person){
    Connection conn = null;
    PreparedStatement stmt = null;
String sql = "update person set name=?,age=?,borndate=?,email=?,address=? where id = ?";
	try {
 		conn = MyJdbcUtils.myGetConnection();
        stmt = conn.prepareStatement(sql);
		stmt.setString(1,person.getName());
        stmt.setInt(2,person.getAge());
        stmt.setDate(3,null);
        stmt.setString(4,person.getEmail());
        stmt.setString(5,person.getAddress());
		stmt.setInt(6,person.getId());
		int result = stmt.executeUpdate();
		return result;
    } catch (SQLException e) {
    	e.printStackTrace();
    }finally {
    	MyJdbcUtils.close(conn,stmt);
    }
    return 0;
}
//删除
public int delete(int id){
    Connection conn = null;
    PreparedStatement stmt = null;
	String sql = "delete from person where id= ?;";
	connn =MyJdbcUtils.myGetConnection();
    try {
        stmt = conn.prepareStatement(sql);
        stmt.setInt(1,id);
        int result = stmt.executeUpdate();
        return result;
    } catch (SQLException e) {
    	e.printStackTrace();
    }finally {
    	MyJdbcUtils.close(conn,stmt);
    }
    return 0;
}
//查单个
public Person select(int id){
    Connection conn = null;
    PreparedStatement stmt = null;
	ResultSet rs = null;
	String sql = "select * from person where id = ?;";
	Person person = null;
    try {
    	connn =MyJdbcUtils.myGetConnection();
    	stmt = conn.prepareStatement(sql);
        stmt.setInt(1,id);
    	rs = stmt.executeQuery();
        if(rs.next()){
            person = new Person();
            
            int pid= resultSet.getInt("id");
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            Date bornDate = resultSet.getDate("borndate");
            String email = resultSet.getString("email");
            String address = resultSet.getString("address");
            
            person.setId(pid);
            person.setName(name);
            person.setAge(age);
            person.setBornDate(bornDate);
            person.setEmail(email);
            person.setAddress(address);
        }
        return person;
    } catch (SQLException e) {
   	 	e.printStackTrace();
    }finally {
     	MyJdbcUtils.close(rs,stmt,conn);
    }
    return null;
}
//查所有
public List<Person> selectAll(){
    Connection conn = null;
    PreparedStatement stmt = null;
	ResultSet rs = null;
	String sql = "select * from person";
    Person person = null;
    List<Person> personList = new ArrayList<>();
    try {
        connn =MyJdbcUtils.myGetConnection();
    	stmt = conn.prepareStatement(sql);
        rs = stmt.executeQuery();
        while(rs.next()){
            
            int pid= resultSet.getInt("id");
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            Date bornDate = resultSet.getDate("borndate");
            String email = resultSet.getString("email");
            String address = resultSet.getString("address");
            
            person = new Person(pid,name,age,bornDate,email,address);
            
            personList.add(person);
        }
        return personList;
    } catch (Exception e) {
   		e.printStackTrace();
    }finally {
     	MyJdbcUtils.close(rs,stmt,conn);
    }
    return null;
}

JDBC增删改查–> DaoImpl类–DBUtils操作

public int addUser(User user) {
    try {
        QueryRunner qr = new QueryRunner(MyJdbcUtils.getDataSource());
        String sql = "insert into user (name,gender,address,phone) 
            		values 	(?,?,?,?)";
        //执行更新
        int count =qr.update(sql, user.getName(),
                   user.getGender(),user.getAddress(),user.getPhone());
        System.out.println("共"+count+"条数据被修改");
        System.out.println("添加成功");
        return count;
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return 0;
}
public void deleteUser(int id) {
    try {
        QueryRunner qr = new QueryRunner(MyJdbcUtils.getDataSource());
        String sql = "delete from user where id = ?";
        int count = qr.update(sql, id);
        System.out.println("共"+count+"条数据被修改");
        System.out.println("删除成功");

    } catch (SQLException e) {
        e.printStackTrace();
    }
}
public void updateUser(User user) {
    try {
        QueryRunner qr = new QueryRunner(MyJdbcUtils.getDataSource());
        String sql = "update user set username=?,password=?,email=?,birthday=? 				where id=? ";
        //执行更新
        int count =qr.update(sql, user.getUsername(),user.getPassword(),
                             user.getEmail(),user.getBirthday(),user.getId());
        System.out.println("共"+count+"条数据被修改");
        System.out.println("修改成功");
    } catch (SQLException e) {
        e.printStackTrace();
    }
}
public List<User> getAll() {
    try {
        QueryRunner qr = new QueryRunner(MyJdbcUtils.getDataSource());
        String sql = "select * from user";
        List<User> list = 
            qr.query(sql, new BeanListHandler<User>(User.class));
        //执行更新
        return list;
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}
//查询语句中存在聚合函数--使用ScalarHandler获取总的记录数
public int getCount() {
    QueryRunner qr = new QueryRunner(MyJdbcUtils.getDataSource());
    String sql = "select count(*) from user";
    try {
       // long l = qr.query(sql, new ScalarHandler<>());
       	 Number num = qr.query(sql, new ScalarHandler<>());
        //return ((Number) qr.query(sql, new ScalarHandler())).intValue();
       // return l.intValue();
          return num.intValue();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return 0;
}