JDBC基础

JDBC是一个独立于特定数据库管理系统，通用的sql数据库存储和操作的公共接口

jar包链接：https://pan.baidu.com/s/1UptJS2Q74f02KTEJpw1JzA?pwd=3rk8

JDBC数据库连接

package com.test.jdbc;
​
import org.junit.Test;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/*
1.确定数据库是否正常使用(Mysql服务)
2.确定数据库账号密码
3.jar包和mysql版本
4.创建目录，将驱动包放入目录
5.jar包右键->悬着add as library
 */
public class JDBCdemo {
    @Test
    public void test() throws SQLException {
        //方式一
        //1.创建Driver对象
        Driver driver=new com.mysql.jdbc.Driver();
        //2.调用方法
        /*connect(String url,java.util.Properties info)
        url:mysql的链接地址 jdbc:mysql://localhost:3306/test
        jdbc:mysql:协议
        localhost:mysql服务器地址
        3306:端口号
        test:库名
         */
        String s="jdbc:mysql://localhost:3306/myemployees";
        Properties p = new Properties();
        p.setProperty("user","root");
        p.setProperty("password","Li1234");
        Connection connect = driver.connect(s, p);
        System.out.println(connect);
    }
    //方式二 通过DriverManager获取Connection对象
    @Test
    public void test2() throws SQLException {
        //创建对象
        Driver driver=new com.mysql.jdbc.Driver();
        //将driver注册到DriverManager中
        DriverManager.registerDriver(driver);
        //获取Connection对象
        String s="jdbc:mysql://localhost:3306/myemployees";
        Connection connection = DriverManager.getConnection(s, "root", "Li1234");
        System.out.println(connection);
    }
    //优化方式二
    @Test
    public void test3() throws ClassNotFoundException, SQLException {
        //1.让Driver类中的静态方法执行
        /*
            static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
         */
        Class.forName("com.mysql.jdbc.Driver");
        //获取Connection对象
        String s="jdbc:mysql://localhost:3306/myemployees";
        Connection connection = DriverManager.getConnection(s, "root", "Li1234");
        System.out.println(connection);
    }
    //完善，将变量放入配置文件
    @Test
    public void test4() throws Exception {
        //创建properties对象
        Properties p = new Properties();
        //创建流
        FileInputStream fil = new FileInputStream("jdbc.properties");
        //加载流
        p.load(fil);
        //通过properties读取文件中的内容
        String ClassName=p.getProperty("ClassName");
        String url=p.getProperty("url");
        String user=p.getProperty("user");
        String password=p.getProperty("password");
        //关闭资源
        System.out.println(ClassName+"\n"+url+"\n"+user+"\n"+password);
        fil.close();
        Class.forName(ClassName);
        String s=url;
        Connection connection = DriverManager.getConnection(s, user, password);
        System.out.println(connection);
    }
}

jdbc.properties{
ClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/myemployees
user=root
password=Li1234
}

JDBC操作数据库

连接Mysql静态方法

package com.test;
​
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Properties;
​
public class JDBC {
    private static String ClassName;
    private static String url;
    private static String user;
    private static String password;
    static {
        //创建properties对象
        Properties p = new Properties();
        //创建流
        FileInputStream fil=null;
        try {
            fil = new FileInputStream("jdbc.properties");
            //加载流
            p.load(fil);
            //通过properties读取文件中的内容
             ClassName=p.getProperty("ClassName");
             url=p.getProperty("url");
             user=p.getProperty("user");
             password=p.getProperty("password");
        } catch (Exception e) {
            //将编译时异常转为运行时异常----终止程序的运行
            e.printStackTrace();//打印异常信息
            throw new RuntimeException(e.getMessage());//getMessage():获取异常信息
        }finally {
            if (fil != null){
                //关闭资源
                try {
                    fil.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static Connection GetConnection(){
        try {
            Class.forName(ClassName);
            //获取Connection对象
            Connection connection = DriverManager.getConnection(url, user, password);
            return connection;
        }catch (Exception e){
            e.printStackTrace();
            //终止程序运行
            throw new RuntimeException(e.getMessage());
        }
    }
​
    public static void close(PreparedStatement ps, Connection connection) {
        if(connection !=null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(ps != null){
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    //方法重载
       public static void close(PreparedStatement ps, Connection conn, ResultSet result){
        close(ps,conn);
        if (result != null){
            try {
                result.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}
​

插入数据

/*
CREATE TABLE student(
id int,
name VARCHAR(20),
sid int
)*/
package com.test.jdbc2;
​
import com.test.JDBC;
import org.junit.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
​
public class CRUDDemo {
    @Test
    //插入数据
    public void test() throws SQLException {
        //1.获取Connection
        Connection connection= JDBC.GetConnection();
        //?:占位符
        String sql="insert into student(id,name,sid) values(?,?,?)";
        //预编译
        //调用prepareStatement返回preparedStatement对象，有了该对象就可以给占位符赋值,执行SQl语句
        PreparedStatement ps = connection.prepareStatement(sql);
        //给占位符赋值
        ps.setInt(1,1);
        ps.setString(2,"Alex");
        ps.setInt(3,1000);
        int result=ps.executeUpdate();//只用来执行增删改
        System.out.println("受到影响行数："+result);
        //关闭资源
        JDBC.close(ps,connection);
    }
}
​

修改数据

@Test   
public void test2() throws SQLException {
        //1.获取Connection
        Connection connection= JDBC.GetConnection();
        String sql="update student set id=? where name=?";
        PreparedStatement ps=connection.prepareStatement(sql);
        ps.setInt(1,2);
        ps.setString(2,"Alex");
        int result=ps.executeUpdate();
        System.out.println("受到影响行数："+result);
        JDBC.close(ps,connection);
 }

删除数据

    @Test
    public void test3()throws SQLException{
        //1.获取Connection
        Connection connection= JDBC.GetConnection();
        String sql="delete from student where id=?";
        PreparedStatement ps=connection.prepareStatement(sql);
        ps.setInt(1,1);
        int result=ps.executeUpdate();
        System.out.println("受到影响行数："+result);
        JDBC.close(ps,connection);
    }

查询数据

    @Test
    public void test() throws SQLException {
        //查询数据
        Connection conn=JDBC.GetConnection();
        String sql="select id,name,sid from student where id=?";
        PreparedStatement ps = conn.prepareStatement(sql);
        ps.setInt(1,18);
        ResultSet result = ps.executeQuery();//执行查询
        //通过ResultSet遍历数据
        while (result.next()){//next()布尔类型 如果有数据为true
            //获取数据
            int id = result.getInt("id");
            String name = result.getString("name");
            int sid = result.getInt("sid");
            System.out.println("id="+id+"\nname="+name+"\nsid="+sid);
        }
        //关闭资源
        JDBC.close(ps,conn,result);
    }

获取表中所有数据

通过调用方法获取表中所有数据

//student对象
package com.test.jdbc2;
​
public class student {
    private int id;
    private String name;
    private int sid;
​
    public student() {
    }
​
    public student(int id, String name, int sid) {
        this.id = id;
        this.name = name;
        this.sid = sid;
    }
​
    @Override
    public String toString() {
        return id+"==="+name+"==="+sid;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getSid() {
        return sid;
    }
​
    public void setSid(int sid) {
        this.sid = sid;
    }
}
​

    public List<student> getStudents() throws SQLException {
        //创建集合,存放对象
        List<student> list=new ArrayList<>();
        //查询数据
        Connection conn=JDBC.GetConnection();
        String sql="select id,name,sid from student";
        PreparedStatement ps = conn.prepareStatement(sql);
        ResultSet result = ps.executeQuery();//执行查询
        //通过ResultSet遍历数据
        while (result.next()){//next()布尔类型 如果有数据为true
            //获取数据
            int id = result.getInt("id");
            String name = result.getString("name");
            int sid = result.getInt("sid");
            //封装
            student s = new student(id, name, sid);
            list.add(s);
        }
        //关闭资源
        JDBC.close(ps,conn,result);
        //返回集合
        return list;
    }
    @Test
    public void test5() throws SQLException {
        List<student> stu=getStudents();
        //遍历集合中的数据
        for (student student : stu) {
            System.out.println(student.toString());
        }
    }

事务

特性

原子性:是指事务是一个不可分割的工作单位，事务的操作要么发生要么不发生

一致性:事务必须使数据库从一个一致性状态变换到另外一个一致性状态

隔离性:事务的隔离性是指一个事务的执行不能被其他事务干扰，既一个事务内部的操作及使用的数据对并未发生的其他事务是隔离的，并发执行的各个事务之间不能互相干扰

持久性:持久性是指一个事务一旦被提交，它对数据库中的数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响

案例

//AA给CC转账
/*
CREATE TABLE IF NOT EXISTS account(
`name` varchar(20),
money INT
)
insert into account values('aa',2000),('cc',2000)
*/
package com.test;
​
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
​
public class shiwu {
    public static void main(String[] args) throws SQLException {
        //1.获取Connection对象
        Connection connection = JDBC.GetConnection();
        //2.sql语句
        String sql="update account set money=? where name=?";
        //3.预编译
        PreparedStatement ps = connection.prepareStatement(sql);
        try {
            //====开启事务  禁止事务提交
            connection.setAutoCommit(false);
            //给占位符赋值
            //aa减钱
            ps.setInt(1,1000);
            ps.setString(2,"aa");
            //执行SQl语句
            ps.executeUpdate();
            //cc加钱
            ps.setInt(1,3000);
            ps.setString(2,"cc");
            //执行sql
            ps.executeUpdate();
            //====提交事务
            connection.commit();
        }catch (Exception e){
            //====事务回滚
            connection.rollback();
            //=打印异常信息
            e.printStackTrace();
        }finally {
            //允许事务提交
            connection.setAutoCommit(true);
            //关闭资源
            JDBC.close(ps,connection);
        }
​
    }
​
}
​

数据库连接池

druid 德鲁伊(阿里)

jar包链接：https://pan.baidu.com/s/1WR0cZk0zans4tQHSgX4r1w?pwd=0awj

//方式一
        public void test() throws SQLException {
            //创建数据库连接池对象
            DruidDataSource ds = new DruidDataSource();
            //给属性赋值
            ds.setUsername("root");//mysql账号
            ds.setPassword("Li1234");//mysql密码
            ds.setDriverClassName("com.mysql.jdbc.Driver");//Driver类的全类名
            ds.setUrl("jdbc:mysql://localhost:3306/myemployees");
            //获取Connection对象
            DruidPooledConnection connection = ds.getConnection();
            //关闭资源
            connection.close();
        }

//创建druid.properties文件
/*
url=jdbc:mysql://localhost:3306/myemployees ?rewriteBatchedStatements=true
username=root
password=Li1234
dricerClassName=com.mysql.jdbc.Driver
*/
//方式二
        public void test2() throws Exception {
            //创建properties对象
            Properties pro = new Properties();
            //加载/创建流
      pro.load(DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties"));
            //创建流
            //FileInputStream fs = new FileInputStream("druid.properties");
            //加载流
            //pro.load(fs);
            DataSource ds = DruidDataSourceFactory.createDataSource(pro);
            Connection connection = ds.getConnection();
            connection.close();
        }

DBUtils工具类

jar包链接：https://pan.baidu.com/s/1KoETMDUAsVsXGpJZWXsjbA?pwd=38xj

//增删改
public void test() throws SQLException {
        //1.创建QueryRunner对象
        QueryRunner queryRunner = new QueryRunner();
        //2.进行增删改操作
        /*
        update(Connection conn, String sql, Object param)
        conn:Connection对象
        sql:sql语句
        param:给占位符赋值的内容
         */
        String sql="insert into student values(?,?,?)";
        //JDBC.GetConnection()见上面代码
        int result = queryRunner.update(JDBC.GetConnection(), sql, 21, "wangwei", 1500);
        System.out.println("受到影响数据条数:"+result);
    }
//查
    public void test2() throws SQLException {
        //1.创建QueryRunner对象
        QueryRunner qr = new QueryRunner();
​
        /*
        query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
        conn:Connection对象
        sql:sql语句
        ↓↓ResultSetHandler:接口↓↓
        BeanHandler:把结果集转换为一个Bean
        BeanListHandler:把结果集转换成一个Bean集合
        MapHandler:把结果集转换为一个Map
        MapListHandler:把结果集转换成一个Map的List
        ScalarHandler:把结果集转换为一个类型的数据返回,该类型通常指String或其他8种基本数据类型
        params:给占位符赋值的内容
         */
        //student对象见上行代码
        //一行数据//
        //====String sql="select * from student where id =?";
        //====student stu = qr.query(JDBC.GetConnection(), sql, new BeanHandler<student>(student.class), 5);
        //====System.out.println(stu);
        //多行数据//
        String sql="select * from student";
        List<student> stu = qr.query(JDBC.GetConnection(), sql, new BeanListHandler<student>(student.class));
        for (student student : stu) {
            System.out.println(student);
        }
​
    }
​