澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:浅谈Mybatis连接原理,Dao格

2019-07-07 作者:数据库网络   |   浏览(196)

       众所周知数据库连接的过程,但是最近面试的人(菜面菜),都说用的SSM框架,但是我问了一下,mybatis是怎么连接上mysql的,基本上都会说:配置好的,直接用了,今天我来抛砖引玉一下,欢迎拍砖!

原文链接:

这两天复习了一下JDBC操作MySQL,把crud操作的例子记一下,

JDBC入门(1),jdbc入门

   JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序,同时,JDBC也是个商标名。

一、Java连接数据库示例:

1、步骤:

  • 导jar包:驱动。
  • 加载驱动类:Class.forName("类名");
  • 给出url、username、password,其中url背下来。
  • 使用DriverManager类来得到Connection对象。
 1 public class Demo1 {
 2     /**
 3      * ClassNotFoundException:
 4      * 没有导入驱动包
 5      *
 6      * SQLException:
 7      *  检查三个参数:url、username、password是否正确
 8      *  检查是否开启了mysql服务器。
 9      *
10      */
11     @Test
12     public void fun1() throws ClassNotFoundException,SQLException{
13         /**
14          * jdbc四大配置参数
15          *   driverClassName:com.mysql.jdbc.Driver
16          *   url:jdbc:mysql://localhost:3306/数据库名
17          *   username:root
18          *   password:
19          */
20         Class.forName("com.mysql.jdbc.Driver");//加载驱动类(注册驱动)
21 
22         //使用url、username、password,得到连接对象
23         Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb_1","root","");
24         System.out.println(con);
25     }
26 }

2、基本异常

未导驱动包:java.lang.ClassNotFoundException: com.mysql.jdbc.Driver ;

数据库不存在:com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown database 'mydb';

端口错误:com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure;

密码错误:java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES);

用户不存在:java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES);

二、JDBC原理

Class.forName("com.mysql.jdbc.Driver");//此据等同于以下面两句,与最后一句的逻辑关系
com.mysql.jdbc.Driver driver = new com.mysql.jdbc.Driver;
DriverManager.registerDriver(driver);
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb_1","root","");

  所有的java.sql.Driver实现类,都提供了static块,块内的代码就是把自己注册到DriverManage中,如com.mysql.jdbc.Driver中的部分源码:

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    //
    // Register ourselves with the DriverManager
    //
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

    /**
     * Construct a new driver and register it with DriverManager
     * 
     * @throws SQLException
     *             if a database error occurs.
     */
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

  JDBC 4.0之后,每个驱动jar包中,在META-INF/services目录下提供了一个名为java.sql.Driver的文件,文件的内容就是该接口的实现类名称。连接数据库例子中,第20行“Class.forName("com.mysql.jdbc.Driver");”可省略不写。

三、使用JDBC对数据库进行简单的增删改查操作示例

  1 package demo2;
  2 
  3 import org.junit.Test;
  4 import java.sql.*;
  5 
  6 public class Demo2 {
  7     /*
  8     * 对数据库进行增、删、改操作
  9     * */
 10     @Test
 11     public void fun1() throws ClassNotFoundException,SQLException {
 12         /*
 13         * 一、得到Connection
 14         * 1、准备四个参数
 15         * 2、加载驱动类
 16         * 3、得到Connection
 17         * */
 18 
 19         String driverClassName = "com.mysql.jdbc.Driver";
 20         //jdbc协议的格式,jdbc:工商的名称:子协议(由工商自己来规定)
 21         //对mysql而言,它的子协议结构://主机:端口号/数据库名称
 22         String url = "jdbc:mysql://localhost:3306/mydb1";
 23         String username = "root";
 24         String password = "";
 25         //加载驱动类
 26         Class.forName(driverClassName);
 27         //使用DriverManager,以及剩下的三个参数,得到Connection
 28         Connection con = DriverManager.getConnection(url, username, password);
 29         /*
 30         * 二、对数据库做增删改
 31         *1、通过Connection对象创建Statement
 32         *  Statement 语句的发送器,它的功能就是向数据库发送sql语句,
 33         *2、调用它的int executeUpdate(String sql),它可以发送DML、DDL
 34         * */
 35         Statement stmt = con.createStatement();
 36 //        String sql = "INSERT INTO stu VALUES('0003','wangwu',88,'male')";
 37 //        String sql = "UPDATE stu SET name='zhaoliu',age=22,gender='female' WHERE "  
 38 //                "number='0003'";
 39         String sql = "DELETE FROM stu";
 40         int r = stmt.executeUpdate(sql);
 41         System.out.println(r);
 42     }
 43     /*
 44      * 执行查询操作
 45      * */
 46      @Test
 47     public void fun2() throws ClassNotFoundException,SQLException {
 48 
 49          /*
 50          * 一、得到Connection
 51          * 二、得到Statement,发送select语句
 52          * 三、对查询返回的"表格"进行解析
 53          * */
 54          /*
 55          * 一、得到连接
 56          * */
 57          String driverClassName = "com.mysql.jdbc.Driver";
 58          String url = "jdbc:mysql://localhost:3306/mydb1";
 59          String username = "root";
 60          String password = "";
 61 
 62          Class.forName(driverClassName);
 63          Connection con = DriverManager.getConnection(url,username,password);
 64          /*
 65          * 二、得到Statement,执行select语句
 66          * */
 67          Statement stmt = con.createStatement();
 68          /*
 69          *调用Statement的ResultSet rs = executeQuery(String querySql);
 70          * */
 71          ResultSet rs = stmt.executeQuery("SELECT * FROM emp");
 72          /*
 73          * 三、解析ResultSet
 74          * 1、把行光标移动到第一行,可以调用next()方法完成。
 75          * */
 76          while (rs.next()) { //把光标向下移动一行,并判断下一行是否存在
 77              int empno = rs.getInt(1);//通过列编号来获取该列的值
 78              String ename = rs.getString("ename");//通过列名称来获取该列的值
 79              double sal = rs.getDouble("sal");
 80 
 81              System.out.println(empno "," ename "," sal);
 82          }
 83          /*
 84          * 四、关闭资源
 85          * 倒关
 86          * */
 87          rs.close();
 88          stmt.close();
 89          con.close();//必须关,不关就死。
 90     }
 91     //规范化
 92     @Test
 93     public void fun3() throws Exception {
 94         Connection con = null;//定义引用
 95         Statement stmt = null;
 96         ResultSet rs = null;
 97         try {
 98             //一、得到Connection
 99             String driverClassName  = "com.mysql.jdbc.Driver";
100             String url = "jdbc:mysql://localhost:3306/mydb1";
101             String username = "root";
102             String password = "";
103             Class.forName(driverClassName);
104             con = DriverManager.getConnection(url,username,password);//实例化
105             //二、创建Statement
106             stmt = con.createStatement();
107             String sql = "SELECT * FROM emp";
108             rs = stmt.executeQuery(sql);//实例化
109             //三、循环遍历rs,打印其中数据
110             //getString()和getObject()是通用的
111             int count = rs.getMetaData().getColumnCount();
112             while (rs.next()) {
113                 for (int i = 1; i <= count; i  ) {
114                     System.out.print(rs.getString(i));
115                     if (i<count) {
116                         System.out.print(",");
117                     }
118                 }
119                 System.out.println();
120             }
121 
122         } catch (Exception e) {
123             throw new RuntimeException(e);
124         } finally {
125             //为了防止空指针异常发生,使用判断语句
126             if(rs != null) rs.close();
127             if(stmt != null) stmt.close();
128             if(con != null) con.close();
129         }
130     }
131 }

 

JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,...

Java Dao模式通过JDBC连接数据库的操作,daojdbc

Java程序访问数据库:

1、获取数据库厂商提供的驱动(jdbc接口的实现类)

如ojdbc14.jar——Oracle数据库驱动jar包

mysql-connector-java-5.1.8-bin.jar——MySQL数据库驱动jar包

自己去网上下载就行。

2、使用JDBC的API访问数据库

连接、SQL语句执行、结果

java.sql.Driver:各个数据库厂商需要实现该接口,驱动的标记

java.sql.Connection:封装和数据库的连接

java.sql.Statement:封装需要执行的SQL语句

java.sql.ResultSet:封装查询的结果集

3、JDBC编程步骤 

step1——加载驱动

step2——获取连接对象

step3——执行SQL语句

step4——处理结果集

step5——关闭资源

4、下面给出连接数据库的工具类(自己写的连接MySql数据库,如要连接Oeacle可修改对应参数)

package com.day03;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
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 ConnectionUtils {

    // 线程单例
    private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    private static String url;
    private static String driver;
    private static String username;
    private static String password;

    static {
        Properties props = new Properties();
        try {
            // 从属性文件中读取数据库配置信息,以加载类的方式加载配置文件
            props.load(
                    ConnectionUtils.class.getClassLoader()
                    .getResourceAsStream("com/day03/db_mysql.properties"));

        } catch (IOException e) {
        }
        if (props != null) {
            url = props.getProperty("url");
            driver = props.getProperty("driver");
            username = props.getProperty("username");
            password = props.getProperty("password");

            // 装载并注册数据库驱动
            try {
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    public static Connection getConnection() throws SQLException {
        Connection con = tl.get();
        if (con == null) {
            con = DriverManager.getConnection(url, username, password);
            tl.set(con);
        }
        return con;
    }

    public static void closeConnection() {
        Connection con = tl.get();
        try {
            if (con != null) {
                con.close();
                tl.set(null);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void closeStatement(Statement stmt) {
        try {
            if (stmt != null) {
                stmt.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void closeResultSet(ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void closeAll(Statement stmt, ResultSet rs){
        closeConnection();
        closeStatement(stmt);
        closeResultSet(rs);
    }

    public static void main(String[] args) throws Exception{
        System.out.println(ConnectionUtils.getConnection());
    }

}

5、配置参数文件db_mysql.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=root

6、Dao模式操作数据库下面是代码示例

1)Emp.java

//实体类
public class Emp {
    private int id;
    private String name;
    private double salary;
    public int getId() {
        return id;
    }
    @Override
    public String toString() {
        return "Emp [id="   id   ", name="   name   ", salary="   salary   "]";
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public Emp(int id, String name, double salary) {
        super();
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
    public Emp() {
        super();
    }
    public Emp(String name, double salary) {
        super();
        this.name = name;
        this.salary = salary;
    }
}

2)Dao接口类

import java.util.List;

public interface EmpDao {
    List<Emp> findAllEmp() throws Exception;
}

3)工厂类

public class EmpDaoFactory {
    // 读取文件中实现类的类名,通过反射实例化
    public static EmpDao getEmpDao(){
        return new EmpDaoMySQL();
    }
}

4)Dao接口实现类

public class EmpDaoMySQL implements EmpDao{
    public static final String FIND_ALL_EMP = "select * from t_emp";//查询语句

    public List<Emp> findAllEmp() throws Exception{
        List<Emp> empList = new ArrayList<Emp>();
        Connection conn = ConnectionUtils.getConnection();
        PreparedStatement stmt = conn.prepareStatement(FIND_ALL_EMP);
        ResultSet rs = stmt.executeQuery();
        while(rs.next()){
            int id = rs.getInt(1);
            String name = rs.getString(2);
            double salary = rs.getDouble(3);
            Emp emp = new Emp(id, name, salary);
            empList.add(emp);
        }
        ConnectionUtils.closeAll(stmt, rs);
        return empList;
    }
}

5)测试类

public class EmpBiz {
    public static void main(String[] args) throws Exception{
        EmpDao dao = EmpDaoFactory.getEmpDao();
        List<Emp> empList = dao.findAllEmp();
        for(Emp e : empList){
            System.out.println(e);
        }
    }
}

到此基本实现了Dao模式通过JDBC操做数据库了。

 

Dao模式通过JDBC连接数据库的操作,daojdbc Java程序访问数据库: 1、获取数据库厂商提供的驱动(jdbc接口的实现类) 如 ojdbc14.jar Oracle 数...

       什么是JDBC?

什么是JDBC?

类库链接(mysql-connector-java-5.1.37-bin.jar):

       Java语言访问数据库的一种规范,是一套API。JDBC (Java Database Connectivity) API,即Java数据库编程接口,是一组标准的Java语言中的接口和类,使用这些接口和类,Java客户端程序可以访问各种不同类型的数据库。JDBC规范采用接口和实现分离的思想设计了Java数据库编程的框架。接口包含在java.sql及javax.sql包中,其中java.sql属于JavaSE,javax.sql属于JavaEE。为了使客户端程序独立于特定的数据库驱动程序,JDBC规范建议开发者使用基于接口的编程方式,即尽量使应用仅依赖java.sql及javax.sql中的接口和类。

Java语言访问数据库的一种规范,是一套API

1.1 JDBC概述

JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范

JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序。

JDBC需要连接驱动,驱动是两个设备要进行通信,满足一定通信数据格式,数据格式由设备提供商规定,设备提供商为设备提供驱动软件,通过软件可以与该设备进行通信。

今天我们使用的是mysql的驱动mysql-connector-java-5.1.39-bin.jar

        JAVA使用JDBC访问数据库的步骤:

JDBC (Java Database Connectivity) API,即Java数据库编程接口,是一组标准的Java语言中的接口和类,使用这些接口和类,Java客户端程序可以访问各种不同类型的数据库。比如建立数据库连接、执行SQL语句进行数据的存取操作。

1.2 JDBC原理

Java提供访问数据库规范称为JDBC,而生产厂商提供规范的实现类称为驱动。

 澳门新萄京官方网站 1

 

 

 

 

 

 

 

 

 

JDBC是接口,驱动是接口的实现,没有驱动将无法完成数据库连接,从而不能操作数据库!每个数据库厂商都需要提供自己的驱动,用来连接自己公司的数据库,也就是说驱动一般都由数据库生成厂商提供。

 

        1.得到数据库驱动程序

 

1.3 JDBC开发步骤

    1. 澳门新萄京官方网站,注册驱动.
    2. 获得连接.
    3. 获得语句执行平台
    4. 执行sql语句
    5. 处理结果
    6. 释放资源.

        2.创建数据库连接

   JDBC规范采用接口和实现分离的思想设计了Java数据库编程的框架。接口包含在java.sql及javax.sql包中,其中java.sql属于JavaSE,javax.sql属于JavaEE。这些接口的实现类叫做数据库驱动程序,由数据库的厂商或其它的厂商或个人提供。

1.3.1 导入驱动jar包

创建lib目录,用于存放当前项目需要的所有jar包

选择jar包,右键执行build path / Add to Build Path

澳门新萄京官方网站 2

        3.执行SQL语句

 

1.4.1 API详解:注册驱动

代码:Class.forName("com.mysql.jdbc.Driver");

JDBC规范定义驱动接口:java.sql.Driver,MySql驱动包提供了实现类:com.mysql.jdbc.Driver

DriverManager工具类,提供注册驱动的方法 registerDriver(),方法的参数是java.sql.Driver,所以我们可以通过如下语句进行注册:

DriverManager.registerDriver(new com.mysql.jdbc.Driver());

以上代码不推荐使用,存在两方面不足

    1. 硬编码,后期不易于程序扩展和维护
    2. 驱动被注册两次。

通常开发我们使用Class.forName() 加载一个使用字符串描述的驱动类。

如果使用Class.forName()将类加载到内存,该类的静态代码将自动执行。

通过查询com.mysql.jdbc.Driver源码,我们发现Driver类“主动”将自己进行注册

public class Driver extends NonRegisteringDriver implements java.sql.Driver {

static {

try {

java.sql.DriverManager.registerDriver(new Driver());

} catch (SQLException E) {

throw new RuntimeException("Can't register driver!");

}

……

}

 

        4.得到结果集

   为了使客户端程序独立于特定的数据库驱动程序,JDBC规范建议开发者使用基于接口的编程方式,即尽量使应用仅依赖java.sql及javax.sql中的接口和类。

1.4.2 API详解:获得链接

代码:Connection con = DriverManager.getConnection
(“jdbc:mysql://localhost:3306/mydb”,”root”,”root”);

获取连接需要方法 DriverManager.getConnection(url,username,password),三个参数分别表示,url 需要连接数据库的位置(网址) user用户名  password 密码

url比较复杂,下面是mysql的url:

jdbc:mysql://localhost:3306/mydb

JDBC规定url的格式由三部分组成,每个部分中间使用冒号分隔。

l 第一部分是jdbc,这是固定的;

l 第二部分是数据库名称,那么连接mysql数据库,第二部分当然是mysql了;

l 第三部分是由数据库厂商规定的,我们需要了解每个数据库厂商的要求,mysql的第三部分分别由数据库服务器的IP地址(localhost)、端口号(3306),以及DATABASE名称(mydb)组成。

 

        5.对结果集做相应的处理(增,删,改,查)

澳门新萄京官方网站 3

1.4.3 API详解:获得语句执行平台

String sql = "某SQL语句";

获取Statement语句执行平台:Statement stmt = con.createStatement();

常用方法:

n int executeUpdate(String sql); --执行insert update delete语句.

n ResultSet executeQuery(String sql); --执行select语句.

n boolean execute(String sql); --执行select返回true 执行其他的语句返回false.

        6.关闭资源:这里释放的是DB中的资源

 

1.4.4 API详解:处理结果集(执行insert、update、delete无需处理)

ResultSet实际上就是一张二维的表格,我们可以调用其boolean next()方法指向某行记录,当第一次调用next()方法时,便指向第一行记录的位置,这时就可以使用ResultSet提供的getXXX(int col)方法(与索引从0开始不同个,列从1开始)来获取指定列的数据:

rs.next();//指向第一行

rs.getInt(1);//获取第一行第一列的数据

常用方法:

n Object getObject(int index) / Object getObject(String name) 获得任意对象

n String getString(int index) / Object getObject(String name) 获得字符串

n int getInt(int index) / Object getObject(String name) 获得整形

n double getDouble(int index) / Object getObject(String name) 获得双精度浮点型

 

        mysql的驱动包提供了java.sql.Driver这个SPI的实现,实现类是com.mysql.jdbc.Driver,在mysql-connector-java-5.1.6.jar中,我们可以看到有一个META-INF/services目录,目录下有一个文件名为java.sql.Driver的文件,其中的内容是com.mysql.jdbc.Driver。
在运行DriverManager.getDriver并传入参数“com.mysql.jdbc.Driver”时,DriverManager会从mysql-connector-java-5.1.6.jar中找到com.mysql.jdbc.Driver并实例化返回一个com.mysql.jdbc.Driver的实例。而SPI(Service Provider Interface)是指一些提供给你继承、扩展,完成自定义功能的类、接口或者方法。

JDBC驱动程序:

1.4.5 API详解:释放资源

与IO流一样,使用后的东西都需要关闭!关闭的顺序是先得到的后关闭,后得到的先关闭。

rs.close();

stmt.close();

con.close();

澳门新萄京官方网站 4

什么是JDBC驱动程序?

1.5 SQL注入问题

假设有登录案例SQL语句如下:

SELECT * FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户输的密码;

此时,当用户输入正确的账号与密码后,查询到了信息则让用户登录。但是当用户输入的账号为XXX 密码为:XXX’  OR ‘a’=’a时,则真正执行的代码变为:

SELECT * FROM 用户表 WHERE NAME = ‘XXX’ AND PASSWORD =’ XXX’  OR ’a’=’a’;

此时,上述查询语句时永远可以查询出结果的。那么用户就直接登录成功了,显然我们不希望看到这样的结果,这便是SQL注入问题。

为此,我们使用PreparedStatement来解决对应的问题。

       SPI是一种回调的思想,回调是指我们在使用api时,我们可以向API传入一个类或者方法,API在合适的时间调用类或者方法。SPI是在一些通用的标准中,为标准的实现产商提供的扩展点。标准在上层提供API,API内部使用了SPI,当API被客户使用时,会动态得从当前运行的classpath中寻找该SPI的实现,然后使用该SPI的实现来完成API的功能。

这些是各个数据库厂家根据JDBC的规范制作的JDBC实现类

1.6 API详解:预处理对象

使用PreparedStatement预处理对象时,建议每条sql语句所有的实际参数,都使用逗号分隔。

String sql = "insert into sort(sid,sname) values(?,?)";;

PreparedStatement预处理对象代码:

PreparedStatement psmt = conn.prepareStatement(sql)

常用方法:

    1. 执行SQL语句:

l int executeUpdate(); --执行insert update delete语句.

l ResultSet executeQuery(); --执行select语句.

l boolean execute(); --执行select返回true 执行其他的语句返回false.

    1. 设置实际参数

l void setXxx(int index, Xxx xx) 将指定参数设置为给定Java的xx值。在将此值发送到数据库时,驱动程序将它转换成一个 SQL Xxx类型值。

例如:

setString(2, "家用电器") 把SQL语句中第2个位置的占位符? 替换成实际参数 "家用电器"

       SPI的实现方式是:提供实现的实现类打包成Jar文件,这个Jar文件里面必须有META-INF目录,其下又有services目录,其下有一个文本文件,文件名即为SPI接口的全名,文件的内容该jar包中提供的SPI接口的实现类名。

JDBC驱动程序的四种类型:

1.7 预处理对象executeUpdate方法

通过预处理对象的executeUpdate方法,完成记录的insertupdatedelete语句的执行。操作格式统一如下:

  1. 注册驱动

  2. 获取连接

  3. 获取预处理对象

  4. SQL语句占位符设置实际参数

  5. 执行SQL语句

  6. 释放资源

 

       大家看项目中Mybaits的jar包会发现:

1.       第一种类型的驱动程序的实现是通过将JDBC的调用全部委托给其它编程接口来实现的,比如ODBC。这种类型的驱动程序需要安装本地代码库,即依赖于本地的程序,所以便携性较差。比如JDBC-ODBC桥驱动程序

2.1 使用properties配置文件

开发中获得连接的4个参数(驱动、URL、用户名、密码)通常都存在配置文件中,方便后期维护,程序如果需要更换数据库,只需要修改配置文件即可。

通常情况下,我们习惯使用properties文件,此文件我们将做如下要求:

    1. 文件位置:任意,建议src下
    2. 文件名称:任意,扩展名为properties
    3. 文件内容:一行一组数据,格式是“key=value”.

a) key命名自定义,如果是多个单词,习惯使用点分隔。例如:jdbc.driver

b) value值不支持中文,如果需要使用非英文字符,将进行unicode转换。

private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      SqlSession sqlSession = getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

2.       第二种类型的驱动程序的实现是部分基于Java语言的。即该驱动程序一部分是用Java语言编写,其它部分委托本地的数据库的客户端代码来实现。同类型1的驱动一样,该类型的驱动程序也依赖本地的程序,所以便携性较差

1.2 创建配置文件

在项目跟目录下,创建文件,输入“db.properties”文件名。

l 文件中的内容

driver=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:3306/mydb

user=root

password=root

 

      sqlSessionTemplate.SqlSessionInterceptor源码,有没有一种很熟悉的感觉?至于getConnection自己去看;用过ElasticSearch和Redis的童鞋,细心的童鞋会发现连接字符串都大同小异,连接都是类似的,标准的连接方式,提高效率,有效控制连接;

3.       第三种类型的驱动程序的实现是全部基于JAVA语言的。该类型的驱动程序通常由某个中间件服务器提供,这样客户端程序可以使用数据库无关的协议和中间件服务器进行通信,中间件服务器再将客户端的JDBC调用转发给数据库进行处理

1.3 加载配置文件:Properties对象

对应properties文件处理,开发中也使用Properties对象进行。我们将采用加载properties文件获得流,然后使用Properties对象进行处理。

l JDBCUtils.java中编写代码

澳门新萄京官方网站 5澳门新萄京官方网站 6

 1 public class JDBCUtils {
 2 
 3     private static String driver;
 4     private static String url;
 5     private static String user;
 6     private static String password;
 7     // 静态代码块
 8     static {
 9         try {
10             // 1 使用Properties处理流
11             // 使用load()方法加载指定的流
12             Properties props = new Properties();
13             Reader is = new FileReader("db.properties");
14             props.load(is);
15             // 2 使用getProperty(key),通过key获得需要的值,
16             driver = props.getProperty("driver");
17             url = props.getProperty("url");
18             user = props.getProperty("user");
19             password = props.getProperty("password");
20         } catch (Exception e) {
21             throw new RuntimeException(e);
22         }
23     }
24 
25     /**
26      * 获得连接
27      */
28     public static Connection getConnection() {
29         try {
30             // 1 注册驱动
31             Class.forName(driver);
32             // 2 获得连接
33             Connection conn = DriverManager.getConnection(url, user, password);
34             return conn;
35         } catch (Exception e) {
36             throw new RuntimeException(e);
37         }
38     }
39 }

View Code

 

      ElasticSearch的连接字符串:

4.       第四种类型的驱动程序的实现是全部基于JAVA语言的。该类型的驱动程序中包含了特定数据库的访问协议,使得客户端可以直接和数据库进行通信

3案例分析

澳门新萄京官方网站 7澳门新萄京官方网站 8

  1 package com.xujingyang.jdbc;
  2 
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
  5 import java.sql.PreparedStatement;
  6 import java.sql.ResultSet;
  7 import java.sql.SQLException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 
 11 import com.xujingyang.bean.Floor;
 12 
 13 public class JdbcDemo {
 14     public static void main(String[] args) {
 15         delete();
 16     }
 17     public static void delete(){
 18         Connection con=null;
 19         PreparedStatement state=null;
 20         try {
 21             Class.forName("com.mysql.jdbc.Driver");
 22             con=DriverManager.getConnection("jdbc:mysql://localhost:3306/gz","root","920606");
 23             state=con.prepareStatement("delete from t_room where id=?");
 24             state.setInt(1, 123);
 25             int num = state.executeUpdate();
 26             System.out.println("删除成功!删除了" num "条");
 27         } catch (Exception e) {
 28             e.printStackTrace();
 29             // TODO: handle exception
 30         }finally{
 31             try {
 32                 if(con!=null){
 33                     con.close();
 34                 }
 35                 if(state!=null){
 36                     state.close();
 37                 }
 38             } catch (Exception e2) {
 39                 // TODO: handle exception
 40             }
 41         }
 42     }
 43     
 44     
 45     public static void update(){
 46         Connection connection=null;
 47         PreparedStatement statement=null;
 48         try {
 49             Class.forName("com.mysql.jdbc.Driver");
 50             connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/gz","root","920606");
 51             statement=connection.prepareStatement("update t_room set roomtype=? where id=123");
 52             statement.setInt(1, 1);
 53             int num = statement.executeUpdate();
 54             System.out.println("更新成功!更新了 " num "条");
 55         } catch (Exception e) {
 56             e.printStackTrace();
 57             // TODO: handle exception
 58         }finally{
 59             try {
 60                 if(connection!=null){
 61                     connection.close();
 62                 }
 63                 if(statement!=null){
 64                     statement.close();
 65                 }
 66             } catch (Exception e2) {
 67                 // TODO: handle exception
 68             }
 69         }
 70     }
 71     
 72     public static void insert(){
 73         Connection con=null;
 74         PreparedStatement statement=null;
 75         try {
 76             Class.forName("com.mysql.jdbc.Driver");
 77             con = DriverManager.getConnection("jdbc:mysql://localhost:3306/gz","root","920606");
 78             statement = con.prepareStatement("insert into t_room values(?,?,?,?,?,?,?)");
 79             Floor floor=new Floor(123, 0, "room1", "30", 123, 0,50f);
 80             statement.setInt(1, floor.getId());
 81             statement.setInt(2, floor.getType());
 82             statement.setString(3, floor.getName());
 83             statement.setString(4, floor.getNum());
 84             statement.setInt(5, floor.getFloorId());
 85             statement.setInt(6, floor.getState());
 86             statement.setDouble(7, floor.getArea());
 87             int num = statement.executeUpdate();
 88             System.out.println("更新成功!更新了" num "条");
 89         } catch (Exception e) {
 90             e.printStackTrace();
 91         }finally{
 92             try {
 93                 if(con!=null){
 94                     con.close();
 95                 }
 96                 if (statement!=null) {
 97                     statement.close();
 98                 }
 99             } catch (SQLException e) {
100                 // TODO Auto-generated catch block
101                 e.printStackTrace();
102             }
103             
104         }
105     }
106     
107 
108     private static void query() {
109         Connection con = null;
110         PreparedStatement statement = null;
111         ResultSet resultSet = null;
112         try {
113             // 1.注册驱动
114             Class.forName("com.mysql.jdbc.Driver");
115             // 2.获得链接
116             con = DriverManager.getConnection(
117                     "jdbc:mysql://localhost:3306/gz", "root", "920606");                          
118             statement = con
119                     .prepareStatement("select * from t_room");
120             resultSet = statement.executeQuery();
121             List<Floor> lists = new ArrayList<Floor>();
122             while (resultSet.next()) {
123                 int id = resultSet.getInt(1);
124                 int type = resultSet.getInt(2);
125                 String name = resultSet.getString(3);
126                 String num = resultSet.getString(4);
127                 int floorId = resultSet.getInt(5);
128                 int state = resultSet.getInt(6);
129                 double area = resultSet.getDouble(7);
130                 Floor floor = new Floor(id, type, name, num, floorId, state,
131                         area);
132                 lists.add(floor);
133             }
134             
135             for (Floor floor : lists) {
136                 System.out.println(floor);
137             }
138 
139         } catch (Exception e) {
140             e.printStackTrace();
141         }finally{
142             try {
143                 resultSet.close();
144                 statement.close();
145                 con.close();
146             } catch (SQLException e) {
147                 // TODO Auto-generated catch block
148                 e.printStackTrace();
149             }
150         }
151     }
152 }

View Code

实例中用到的Javabean

澳门新萄京官方网站 9澳门新萄京官方网站 10

 1 package com.xujingyang.bean;
 2 
 3 
 4 public class Floor {
 5     private int id;
 6     private int type;
 7     private String name;
 8     private String num;
 9 
10     private int floorId;
11     private int state;
12     private double area;
13 
14     public Floor() {
15     }
16 
17     public Floor(int id, int type, String name, String num, int floorId,
18             int state, double area) {
19         super();
20         this.id = id;
21         this.type = type;
22         this.name = name;
23         this.num = num;
24         this.floorId = floorId;
25         this.state = state;
26         this.area = area;
27     }
28 
29     public int getId() {
30         return id;
31     }
32 
33     public void setId(int id) {
34         this.id = id;
35     }
36 
37     public int getType() {
38         return type;
39     }
40 
41     public void setType(int type) {
42         this.type = type;
43     }
44 
45     public String getName() {
46         return name;
47     }
48 
49     public void setName(String name) {
50         this.name = name;
51     }
52 
53     public String getNum() {
54         return num;
55     }
56 
57     public void setNum(String num) {
58         this.num = num;
59     }
60 
61     public int getFloorId() {
62         return floorId;
63     }
64 
65     public void setFloorId(int floorId) {
66         this.floorId = floorId;
67     }
68 
69     public int getState() {
70         return state;
71     }
72 
73     public void setState(int state) {
74         this.state = state;
75     }
76 
77     public double getArea() {
78         return area;
79     }
80 
81     public void setArea(double area) {
82         this.area = area;
83     }
84 
85     @Override
86     public String toString() {
87         return "Floor [id="   id   ", type="   type   ", name="   name
88                   ", num="   num   ", floorId="   floorId   ", state="   state
89                   ", area="   area   "]";
90     }
91     
92 }

View Code

 

protected SearchResponse getSearchResponse(String fieldName, String indexName) {
    client = null;
    SearchResponse response = null;
    try {
        getClient();
        MaxAggregationBuilder aggregation =
                AggregationBuilders
                        .max("agg")
                        .field(fieldName);
        SearchRequestBuilder request = client.prepareSearch(indexName).addAggregation(aggregation);
        response = request.execute().actionGet();
    } catch (Exception ex) {
        logger.error("getSearchResponse", ex);
    } finally {
        if (client != null) {
            client.close();
        }
        return response;
    }
}

 

     Jedis连接字符串:

JDBC类结构:

执行命令如下:
Jedis jedis = null;
try {
    jedis = jedisPool.getResource();
    //具体的命令
    jedis.executeCommand()
} catch (Exception e) {
    logger.error("op key {} error: "   e.getMessage(), key, e);
} finally {
    //注意这里不是关闭连接,在JedisPool模式下,Jedis会被归还给资源池。
    if (jedis != null) 
        jedis.close(); 
}

                           DriverManager

       拦截器的实现都是基于代理的设计模式实现的,简单的说就是要创造一个目标类的代理类,在代理类中执行目标类的方法并在方法之前执行拦截器代码,拦截器一般有登陆拦截器——验证会话信息,权限拦截器——验证权限信息,那么SqlSessionInterceptor是干什么的?

 

       Mybatis拦截器设计的一个初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。打个比方,对于Executor,Mybatis中有几种实现:BatchExecutor、ReuseExecutor、SimpleExecutor和CachingExecutor。
这个时候如果你觉得这几种实现对于Executor接口的query方法都不能满足你的要求,那怎么办呢?是要去改源码吗?当然不。我们可以建立一个Mybatis拦截器用于拦截Executor接口的query方法,在拦截之后实现自己的query方法逻辑,之后可以选择是否继续执行原来的query方法。允许你在已映射语句执行过程中的某一点进行拦截调用。有的用Mybatis拦截器统封装分页,有的用它实现读写分离等,如果读写分离还是建议配置多数据源;

Driver                               Driver

       spring整合mybatis之后,通过动态代理的方式,使用SqlSessionTemplate持有的sqlSessionProxy属性来代理执行sql操作,由spring管理的sqlSeesion在sql方法(增删改查等操作)执行完毕后就自行关闭了sqlSession,不需要我们对其进行手动关闭。

 

       愿你有情人终成眷属,愿你有个有趣的灵魂,愿你拍我一砖!

Connection                         Connection

 

Statement                                  Statement

 

Resultset                                    Resultset

 

DriverManager:这个是一个实现类,它是一个工厂类,用来生产Driver对象的

这个类的结构设计模式为工厂方法

Driver:这是驱动程序对象的接口,它指向一个实实在在的数据库驱动程序对象,那么这个数据库驱动程序对象是从哪里来的呢?

DriverManager工厂中有个方法:getDriver(String URL),通过这个方法可以得到驱动程序对象,这个方法是在各个数据库厂商按JDBC规范设计的数据库驱动程序包里的类中静态实现的,也就是在静态块中

Connection:这个接口可以制向一个数据库连接对象,那么如何得到这个连接对象呢?

是通过DriverManager工厂中的getConnection(String URL)方法得到的

Statement:用于执行静态的SQL语句的接口,通过Connection中的createStatement方法得到的

Resultset:用于指向结果集对象的接口,结果集对象是通过Statement中的execute等方法得到的

 

JAVA使用JDBC访问数据库的步骤:

1.     得到数据库驱动程序

2.     创建数据库连接

3.     执行SQL语句

4.     得到结果集

5.     对结果集做相应的处理(增,删,改,查)

6.     关闭资源:这里释放的是DB中的资源

澳门新萄京官方网站 11 

  

设置classpath:

1.     在java文件中起的包名一定要是工程基目录下的子目录,classpath:基目录

2.     .jar包,需要将这个.jar包的路径包括这个文件的全名添加到classpath中来

Oracle连接字符串的书写格式:

“oracle:jdbc:thin:@ip:1521: 数据库名”,”数据库用户名”,”数据库密码”

 

简单的例子:

澳门新萄京官方网站 12

package moudule1.first;



import java.sql.*;



public class FirstJdbc

{

      public static void main(String[] args)

      {

                 String sql="select * from yuchen_user";

                 Connection con=null;

                 Statement st=null;

                 ResultSet rs=null;



       try

       { 

                 Class.forName("oracle.jdbc.driver.OracleDriver");

                 con=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:name", "scott","tiger");

                 st=con.createStatement();

                 rs=st.executeQuery(sql);

                 while(rs.next())

                 {

                            System.out.println(rs.getInt("id"));

                            System.out.println(rs.getString("name"));

                 }

       }catch(Exception e)

       {

                 e.printStackTrace();

       }finally

       {

                 try

                 {

                      con.close();

                 }catch(Exception e)

                 {}



                 try

                 {

                      st.close();

                 }catch(Exception e)

                 {

                 }



                 try

                 {

                      rs.close();

                 }catch(Exception e)

                 {

                 }



       }





      }



}

澳门新萄京官方网站 13

 

 

常用数据库的驱动程序及JDBC URL:

Oracle数据库:

驱动程序包名:ojdbc14.jar

 驱动类的名字:oracle.jdbc.driver.OracleDriver

 JDBC URL:jdbc:oracle:thin:@dbip:port:databasename

 说明:驱动程序包名有可能会变

       JDBC URL中黑色字体部分必须原封不动的保留,为该驱动识别的URL格式。红色字体部分需要根据数据库的安装情况填写。其中各个部分含义如下:

        dbip –为数据库服务器的IP地址,如果是本地可写:localhost或127.0.0.1。

        port –为数据库的监听端口,需要看安装时的配置,缺省为1521。

        databasename –为数据库的SID,通常为全局数据库的名字。

        举例如果要访问本地的数据库allandb,端口1521,那么URL写法如下:

       jdbc:oracle:thin:@localhost:1521:allandb 下载地址如下:

 

SQL Server数据库

   驱动程序包名:msbase.jar mssqlserver.jar msutil.jar

   驱动类的名字:com.microsoft.jdbc.sqlserver.SQLServerDriver

   JDBC URL:jdbc:microsoft:sqlserver://dbip:port;DatabaseName=databasename

   说明:驱动程序包名有可能会变

        JDBC URL中黑色字体部分必须原封不动的保留,为该驱动识别的URL格式。红色字体部需要根据数据库的安装情况填写。其中各个部分含义如下:

       dbip –为数据库服务器的IP地址,如果是本地可写:localhost或127.0.0.1。

        port –为数据库的监听端口,需要看安装时的配置,缺省为1433。

       databasename –数据库的名字。

       举例如果要访问本地的数据库allandb,端口1433,那么URL写法如下:

       jdbc: microsoft: sqlserver:@localhost:1433; DatabaseName =allandb

       下载地址:

 

 MySQL数据库

   驱动程序包名:mysql-connector-java-3.1.11-bin.jar

   驱动类的名字:com.mysql.jdbc.Driver

   JDBC URL:jdbc:mysql://dbip:port/databasename

   说明:驱动程序包名有可能会变

        JDBC URL中黑色字体部分必须原封不动的保留,为该驱动识别的URL格式。红色字体部需要根据数据库的安装情况填写。其中各个部分含义如下:

        dbip –为数据库服务器的IP地址,如果是本地可写:localhost或127.0.0.1。

澳门新萄京官方网站:浅谈Mybatis连接原理,Dao格局通过JDBC连接数据库的操作。        port –为数据库的监听端口,需要看安装时的配置,缺省为3306。

        databasename –数据库的名字。

        举例如果要访问本地的数据库allandb,端口1433,那么URL写法如下:

       jdbc:mysql://localhost:3306/allandb

   下载地址:

 

Access数据库

   驱动程序包名:该驱动程序包含在JavaSE中,不需要额外安装。

   驱动类的名字:sun.jdbc.odbc.JdbcOdbcDriver

   JDBC URL:jdbc:odbc:datasourcename

   说明:该驱动只能工作在Windows系统中,首先需要在操作系统中建立一个可以访问Access数据库的本地数据源(ODBC),如果名字为allandb,那么URL写法如下:

        jdbc:odbc:allandb

 

PreparedStatement接口:

预编译的sql语句对象

作用: 解决了书写sql语句时一些特殊的字符与sql保留字符冲突的问题,非常方便

澳门新萄京官方网站 14

/**

*知识点:

*PreparedStatement接口及方法的使用

*程序目标:

*java文件:

*PreparedInsert.java:连接数据库,插入一条数据

*JdbcUtil.java:实现一个工具类,功能:1.连接数据库 2.关闭资源

*/



package moudule1.preparedstatement;



import java.sql.*;

import moudule1.com.*;



public class PreparedInsert

{

      public static void main(String[] args)

      {

           String sql="insert into yuchen_user (id,name) values (?,?)";

           System.out.println(sql);



           Connection con=null;

           PreparedStatement ps=null;



           try{

                 con=JdbcUtil.getConnection();

                 ps=con.prepareStatement(sql);



                 ps.setInt(1,2);

                 ps.setString(2,"zhangsan");

                 ps.executeUpdate();



                 ps.setInt(1,3);

                 ps.setString(2,"lisi");

                 ps.executeUpdate();



           }catch(Exception e){

                 e.printStackTrace();

           }finally{

                 JdbcUtil.close(con,ps);

                 }

           }

      }

澳门新萄京官方网站 15

 

 

澳门新萄京官方网站 16

package moudule1.com;



import java.sql.*;



public class JdbcUtil{



      public static Connection getConnection() throws Exception{

           Class.forName("oracle.jdbc.driver.OracleDriver");

       return DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:name", "scott","tiger");

           }



      public static void close(Connection con,Statement st){



           close(con);

           close(st);



           }



      public static void close(Connection con,Statement st,ResultSet rs){





           close(con,st);

           close(rs);



           }



      public static void close(Connection con){

           try{



                 con.close();



           }catch(Exception e){





                 }



           }



      public static void close(Statement st){



           try{



                 st.close();



           }catch(Exception e){



                 }

           }



      public static void close(ResultSet rs){



           try{



                 rs.close();



           }catch(Exception e){



                 }



           }



      }

澳门新萄京官方网站 17

 

数据库的增删改查的例子:

澳门新萄京官方网站 18

/**

*知识点:

*JDBC SQL ORACLE

*程序目标:

*UserDao.java:实现了数据库的增删改查

*JdbcUtil.java:工具类,有连库和关闭资源的方法

*/



package moudule1.idus;



import java.sql.*;

import moudule1.com.*;



public class UserDao{



      private String sql;

      private Connection con;

      private Statement st;

      private ResultSet rs;



      public UserDao(){

           sql=null;

           con=null;

           st=null;

           rs=null;

           }



      public void insert(){



           sql="insert into yuchen_user (id,name) values(";

           sql ="4,'zhouwu')";

           System.out.println(sql);



           try{



           con=JdbcUtil.getConnection();

           st=con.createStatement();

           st.executeUpdate(sql);



           }catch(Exception e){



                 e.printStackTrace();



           }finally{



                 JdbcUtil.close(con,st);



                 }



           }





      public void delete(){



           sql="delete from yuchen_user where id=2";

           System.out.println(sql);



           try{



                 con=JdbcUtil.getConnection();

            st=con.createStatement();

            st.executeUpdate(sql);



           }catch(Exception e){



                 e.printStackTrace();



           }finally{



                 JdbcUtil.close(con,st);



                 }

           }





      public void update(){



           sql="update yuchen_user set name='liumang' where id=1";

           System.out.println(sql);



           try{



                 con=JdbcUtil.getConnection();

            st=con.createStatement();

            st.executeUpdate(sql);



           }catch(Exception e){



                 e.printStackTrace();



           }finally{



                 JdbcUtil.close(con,st);



                 }

           }





      public void select(){



           sql="select * from yuchen_user";

           System.out.println(sql);



           try{



                 con=JdbcUtil.getConnection();

            st=con.createStatement();

             rs=st.executeQuery(sql);



            while(rs.next()){



               System.out.println(rs.getInt(1));

               System.out.println(rs.getString(2));



               }



           }catch(Exception e){



                 e.printStackTrace();



           }finally{



                 JdbcUtil.close(con,st,rs);



                 }



           }





      public static void main(String[] args){



           UserDao ud=new UserDao();

           ud.select();

           ud.insert();

           ud.select();

           ud.update();

           ud.select();

           ud.delete();

           ud.select();

           }

      }

澳门新萄京官方网站 19

 

一些常用的方法:

澳门新萄京官方网站 20

/**

*知识点:

*execute方法,getResultSet(),getUpdateCount()

*程序目标:

*JdbcUtil.java:工具类,连接数据库,关闭资源

*sqlExecutor.java:命令行参数输入sql语句,并执行该语句

*/

package moudule1.fangfa;



import java.sql.*;

import moudule1.com.*;



public class sqlExecutor{



      public static void main(String[] args){



           Connection con=null;

           Statement st=null;



           try{



                 con=JdbcUtil.getConnection();

                 st=con.createStatement();

                 boolean str=st.execute(args[0]);



                 if(str){



                      ResultSet rs=st.getResultSet();



                      while(rs.next()){

                            System.out.println(rs.getInt("id") ":" rs.getString("name"));

                            }



                            rs.close();



                 }else{

                      int row=st.getUpdateCount();

                      System.out.println(row);

                      }



           }catch(Exception e){



                 e.printStackTrace();



           }finally{



                 JdbcUtil.close(con,st);



                 }

           }

      }

澳门新萄京官方网站 21

 

  1. 补充
      JDBC连接MySQL

加载及注册JDBC驱动程序

Class.forName("com.mysql.jdbc.Driver");

Class.forName("com.mysql.jdbc.Driver").newInstance();

JDBC URL 定义驱动程序与数据源之间的连接

标准语法:

<protocol(主要通讯协议)>:<subprotocol(次要通讯协议,即驱动程序名称)>:<data source identifier(数据源)>

MySQL的JDBC URL格式:

jdbc:mysql//[hostname][:port]/[dbname][?param1=value1][¶m2=value2]….

 

示例:jdbc:mysql://localhost:3306/sample_db?user=root&password=your_password

 

常见参数:

user                       用户名

password                  密码

autoReconnect                  联机失败,是否重新联机(true/false)

maxReconnect              尝试重新联机次数

initialTimeout               尝试重新联机间隔

maxRows                   传回最大行数

useUnicode                 是否使用Unicode字体编码(true/false)

characterEncoding          何种编码(GB2312/UTF-8/…)

relaxAutocommit            是否自动提交(true/false)

capitalizeTypeNames        数据定义的名称以大写表示

建立连接对象

String url="jdbc:mysql://localhost:3306/sample_db?user=root&password=your_password";

Connection con = DriverManager.getConnection(url);

建立SQL陈述式对象(Statement Object)

Statement stmt = con.createStatement();

执行SQL语句

executeQuery()

String query = "select * from test";

ResultSet rs=stmt.executeQuery(query);

结果集ResultSet

while(rs.next())

{rs.getString(1);rs.getInt(2);}

executeUpdate()

String upd="insert into test (id,name) values(1001,xuzhaori)";

int con=stmt.executeUpdate(upd);

execute()

示例:

try{
}

catch(SQLException sqle)

{

}

finally

{

}

 

Java类型和SQL类型 技术手册P421

PreparedStatement(预编语句)

PreparedStatement stmt = conn.prepareStatement("insert into test(id,name)values(?,?)");

stmt.setInt(1,id);

stmt.setString(2,name);

注:一旦设定语句的参数值后,就可以多次执行改语句,直到调用clearParameters()方法将他清除为止

CallableStatement(预储程序)技术手册P430

JDBC2.0使用

ResultSet对象中的光标上下自由移动

Statement stmt = con.createStatement (ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);

ResultSet rs=stmt.executeQuery("select * from test");

 

public Statement createStatement(int resultSetType,int resultSetConcuttency) throws SQLException

 

resultSetType

TYPE_FORWARD_ONLY            只能使用next()方法。

TYPE_SCROLL_SENSITIVE        可以上下移动,可以取得改变后的值。

TYPE_SCROLL_INSENSITIVE      可以上下移动。

resultSetConcuttency

CONCUR_READ_ONLY        只读

CONCUR_UPDATABLE        ResultSet对象可以执行数据库的新增、修改、和移除

 

直接使用ResultSet对象执行更新数据

新增数据

澳门新萄京官方网站 22

Statement stmt=con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_PUDATABLE);

ResultSet uprs=stmt.executeQuery("select * from test");

uprs.moveToInsertRow();

uprs.updateInt(1,1001);

uprs.updateString(2,"许召日");

uprs.insertRow;

澳门新萄京官方网站 23

 

更新数据

澳门新萄京官方网站 24

Statement stmt=con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_PUDATABLE);

ResultSet uprs=stmt.executeQuery("select * from test");

uprs.last();

uprs.updateString("name","xuzhaori");

uprs.updateRow;

澳门新萄京官方网站 25

 

删除数据

澳门新萄京官方网站 26

Statement stmt=con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_PUDATABLE);

ResultSet uprs=stmt.executeQuery("select * from test");

uprs.absolute(4);

uprs.deleteRow();

澳门新萄京官方网站 27

 

 

批处理

con.setAutoCommit(false);  关闭自动认可模式

Statement stmt=con.createStatement();

int[] rows;

stmt.addBatch("insert into test values(1001,xuzhaori)");

stmt.addBatch("insert into test values(1002,xuyalin)");

rows=stmt.executeBatch();

con.commit();  没有任何错误,执行批处理stmt.executeBatch();

 

JNDI-数据源(Data Source)与连接池(Connection Pool)

Tomcat的JDBC数据源设置  技术手册P439

连接池工具-Proxool Var 0.8.3 技术手册P446

设置web.xml

澳门新萄京官方网站 28

<?xml version="1.0" encoding="ISO-8859-1"?>

<!--<?xml version="1.0" encoding="GB2312"?>-->



<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

version="2.4">

….

<servlet>

<servlet-name>ServletConfigurator</servlet-name>

<servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class>



<init-param>

<param-name>propertyFile</param-name>

<param-value>WEB-INF/classes/Proxool.properties</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

澳门新萄京官方网站 29

 

后端统计端口添加下列

澳门新萄京官方网站 30

<servlet>

<servlet-name>Admin</servlet-name>

<servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>

</servlet>



<servlet-mapping>

<servlet-name>Admin</servlet-name>

<url-pattern>/Admin</url-pattern>

</servlet-mapping>



….



</web-app>

澳门新萄京官方网站 31

 

配置Proxool.properties

澳门新萄京官方网站 32

jdbc-0.proxool.alias=JSPBook

jdbc-0.proxool.driver-class=com.mysql.jdbc.Driver

jdbc-0.proxool.driver-url=jdbc:mysql://localhost:3306/sample_db?user=root&password=browser&useUnicode=true&characterEncoding=UTF-8

jdbc-0.proxool.maximum-connection-count=10

jdbc-0.proxool.prototype-count=4

jdbc-0.proxool.house-keeping-test-sql=select CURRENT_DATE

jdbc-0.proxool.verbose=true

jdbc-0.proxool.statistics=10s,1m,1d    后端统计接口添加此行

jdbc-0.proxool.statistics-log-level=DEBUG

澳门新萄京官方网站 33

 

使用Proxool连接池

澳门新萄京官方网站 34

Connection con = DriverManager.getConnection("proxool.JSPBook");

Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);

String query = "SELECT * FROM employee";

ResultSet rs = stmt.executeQuery(query);

澳门新萄京官方网站 35

 

 

 

 

使用JDBC时,我们都会很自然得使用下列语句:

 

Class.forName("com.mysql.jdbc.Driver");        
String url = "jdbc:mysql://127.0.0.1/test?useUnicode=true&characterEncoding=utf-8";        
String user = "";        
String psw = "";        
Connection con = DriverManager.getConnection(url,user,psw);      

 

 

 

    为什么说很自然呢,因为无论是网上还是书本教程上得例子都是这样的,而且程序也确实正常运行了,于是大家也就心安理得的找葫芦画瓢下去了。

    一定要有这一句吗?不是的,我们完全可以用这样一句代替它:

 

 

 

澳门新萄京官方网站 36

com.mysql.jdbc.Driver driver = new com.mysql.jdbc.Driver();        
//or:        
//new com.mysql.jdbc.Driver();        
String url = "jdbc:mysql://127.0.0.1/test?useUnicode=true&characterEncoding=utf-8";        
String user = "";        
String psw = "";        
Connection con = DriverManager.getConnection(url,user,psw);       

澳门新萄京官方网站 37

 

        大家可能都看出个大概来了,我们只需要在调用DriverManager的getConnection方法之前,保证相应的Driver类已经被加载到jvm中,并且完成了类的初始化工作就行了,而具体是怎样实现这个功能却是没有讲究的。

    谈到类的初始化,这里不得不提,在什么样的情况下类才能够初始化?

 

 

  1. 创建类的实例
  2. 访问某个类或接口的静态变量,或者对该静态变量赋值
  3. 调用类的静态方法
  4. 反射(如Class.forName("com.lang.String")
  5. 初始化一个类的子类
  6.  Java虚拟机启动时被标为启动类的类

    上面两种方法都可以实现这个功能,因此程序可以正常运行。注意了,如果我们进行如下操作,程序是不能正常运行的,因为这样仅仅使Driver类被装载到jvm中,却没有进行相应的初始化工作。具体关于类的加载和初始化详细,可以阅读我的这篇博文《JVM虚拟机和类加载器》。

 

com.mysql.jdbc.Driver driver = null;        
//or:        
ClassLoader cl = new ClassLoader();        
cl.loadClass("com.mysql.jdbc.Driver");      

 

 

         我们都知道JDBC是使用Bridge模式进行设计的,DriverManager就是其中的Abstraction,java.sql.Driver是Implementor,com.mysql.jdbc.Driver是Implementor的一个具体实现(请参考GOF的Bridge模式的描述)。大家注意了,前一个Driver是一个接口,后者却是一个类,它实现了前面的Driver接口。

         Bridge模式中,Abstraction(DriverManager)是要拥有一个Implementor(Driver)的引用的,但是我们在使用过程中,并没有将Driver对象注册到DriverManager中去啊,这是怎么回事呢?jdk文档对Driver的描述中有这么一句:

        When a Driver class is loaded, it should create an instance of itself and register it with the DriverManager 

        哦,原来是com.mysql.jdbc.Driver在装载完后自动帮我们完成了这一步骤。源代码是这样的:

 

 

    可以看到DriveManager里面定义了静态方法,而mysql等驱动类都是内部用静态数据块的方式来初始化,完成Driver对象注册到DriverManager中,所以只要jvm装载了这些驱动类就会将Driver对象注册到DriverManager中去(Class.forName(xxx.xx.xx) 返回的是一个类;Class.forName(xxx.xx.xx);的作用是要求JVM查找并加载指定的类,也就是说JVM会执行该类的静态代码段 。静态代码是和class绑定的,class装载成功就表示执行了你的静态代码了。而且以后不会再走这段静态代码了。),后面就可以直接使用了。

本文由澳门新萄京官方网站发布于数据库网络,转载请注明出处:澳门新萄京官方网站:浅谈Mybatis连接原理,Dao格

关键词: