Java数据库连接大全-基础版

转x33g5p2x  于2021-09-27 转载在 Java  
字(42.8k)|赞(0)|评价(0)|浏览(658)

JDBC

不废话了直接上封装好的类你拿去用就行了

maven

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.10</version>
    </dependency>

加载驱动

Class.forName(“com.mysql.jdbc.Driver”);

Connection connection=DriverManager.getConnection(“jdbc:mysql://localhost:3306/myschool”,“root”,“root”);
System.out.println(“建立连接成功”);

说明

jdbc:mysql: 是默认的 根据你使用的数据库类型 而不同

localhost:3306/myschool 是链接地址 和 数据库

在实际开发中为了避免数据库 乱码 就需要指定数据库 将编码指定为 utf-8

localhost:3306/myschool?useUnicode=true&charactetEncoding=utf-8

“root”,“root” 第一是用户 第二个是密码

connection.close();
System.out.println(“关闭连接”);

以上代码看看就行了 下面是完全版

Statement接口 和 PreparedStatement接口 ,但是Statement有sql注入风险所以 我们使用PreparedStatement接口中的方法,

创建配置文件database.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false
username=root
password=root

注意这个: ?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false 特别重要

useUnicode 指定以Unicode编码格式

是否使用Unicode字符集，如果参数characterEncoding设置为gb2312或gbk或者utf8，本参数值必须设置为true

characterEncoding 指定编码类型

autoReconnect 是否使用针对数据库连接池的重连策略

failOverReadOnly 自动重连成功后，连接是否设置为只读？

创建JDBC_Util工具类 支持并发编程无需同步(牺牲一点内存,增加速度)

package cn.htsa.www.dao;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import  java.sql.PreparedStatement;
import  java.sql.ResultSet;
//可以实现多线程并发操作
public class JDBC_Util {

    private static final ThreadLocal<ResultSet> resultSet=new ThreadLocal<ResultSet>(){
        @Override
        protected ResultSet initialValue() {
            return super.initialValue();
        }
    };

    private static final ThreadLocal<PreparedStatement> prepareStatement=new ThreadLocal<PreparedStatement>(){
        @Override
        protected PreparedStatement initialValue() {
            return super.initialValue();
        }
    };
    private static final ThreadLocal<Connection> connection=new ThreadLocal<Connection>(){
        @Override
        protected Connection initialValue() {
            Connection    connection=null;
            Properties properties=new Properties();

            InputStream is= JDBC_Util.class.getClassLoader().getResourceAsStream("database.properties");
            try {
                properties.load(is);
            } catch (IOException e) {

                e.printStackTrace();
            }

            try {
                Class.forName(properties.getProperty("driver"));
            } catch (ClassNotFoundException e) {

                e.printStackTrace();
            }
            try {
                connection=DriverManager.getConnection(properties.getProperty("url"),properties.getProperty("username"),properties.getProperty("password"));
            } catch (SQLException e) {

                e.printStackTrace();
            }

            return  connection;
        }
    };

    //事务增删改
    public static int  transaction_INSERT_DELECT_UPDATE(List<String> sqlString,List<Object[]> objects) {

        int num=0;
        List<PreparedStatement> preparedStatements = null;
        if(sqlString==null||objects==null||sqlString.size()==0||objects.size()==0){
            System.out.println("集合不能为空");
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
            return num;
        }
        try {

            preparedStatements = new ArrayList<PreparedStatement>();
            for (int i = 0; i < sqlString.size(); i++) {
                if (sqlString.get(i).trim().length() == 0 ||sqlString.get(i)==null &&objects.get(i)==null||objects.get(i).length==0){
                    System.out.println("sql语句 和 参数 不能为空");
                    try {
                        prepareStatement.get().close();
                        connection.get().close();
                    } catch (SQLException e) {

                        e.printStackTrace();
                    }
                    return num;
                }
                prepareStatement.set(connection.get().prepareStatement(sqlString.get(i)));

                for (int j = 0; j < objects.get(i).length; j++) {

                    prepareStatement.get().setObject(j+1, objects.get(i)[j]);
                }

                preparedStatements.add(prepareStatement.get());
            }
            connection.get().setAutoCommit(false);
  
            for (int i = 0; i <preparedStatements.size(); i++) {

                num+=preparedStatements.get(i).executeUpdate();
            }
            System.out.println("提交成功");
            connection.get().commit();
        } catch (SQLException e) {

            e.printStackTrace();

            try {
                System.out.println("执行事务异常--回滚数据");
                connection.get().rollback();
                num=0;

            } catch (SQLException e1) {

                e1.printStackTrace();

            }

        }finally{
            try {
                connection.get().setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            closeAll();//释放连接
        }

        return num;

    }


    //不加事务的增删改
    public static int INSERT_DELETE_UPDATE(String sqlString,Object[] objects){

        int num=0;
        try {
            prepareStatement.set(connection.get().prepareStatement(sqlString));
            if(objects!=null){
                for (int i = 0; i < objects.length; i++) {

                    prepareStatement.get().setObject(i+1, objects[i]);
                }
            }

            num= prepareStatement.get().executeUpdate();

        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            closeAll();//释放连接
        }
        return num;
    }

    //查询 返回 ResultSet对象
    public static ResultSet SELECT(String  sqlString,Object[] objects){
        try {
            prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString));
            if(objects!=null){
                for (int i = 0; i < objects.length; i++) {
                    prepareStatement.get().setObject(i+1, objects[i]);
                }
            }

            resultSet.set(prepareStatement.get().executeQuery());

        } catch (SQLException e) {

            e.printStackTrace();
        }
        return resultSet.get();

    }



    //关闭数据库连接 内部方法
    public    static void closeAll(){
        if(resultSet.get()!=null){
            try {
                resultSet.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        if(prepareStatement.get()!=null){
            try {
                prepareStatement.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }

        }

        if(connection.get()!=null){
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        resultSet.remove();
        prepareStatement.remove();
        connection.remove();

    }

}

以上代码没有加日志 如果 需要自行添加 还有就是里面的参数你也可以自己修改成可变参数 根据爱好 自己看着改就行了 也不难

使用教程 简单的演示一下

查询

//不带条件的
@Test
public void show1(){
    String sql="select * from books";
    ResultSet select = JDBC_Util.SELECT(sql, null);
    try {
        while (select.next()){
            System.out.print(select.getInt(1));
            System.out.print(select.getString(2));
            System.out.println(select.getDouble(3));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBC_Util.closeAll();
    }
}

//带条件的
 @Test
    public  void show2(){
     String sql1="select * from books where id=? and price>?";
     Object[] object={1,30};
     ResultSet select1 = JDBC_Util.SELECT(sql1, object);
     try {
         while (select1.next()){
             System.out.print(select1.getInt("id"));
             System.out.print(select1.getString("name"));  
             System.out.println(select.getDouble("price"));
         }
     } catch (SQLException e) {
         e.printStackTrace();
     }finally {
           JDBC_Util.closeAll();
     }
 }

注意 如果使用 下标来获取 对应字段的值 下标的位置从1开始

也就是1=第一个字段 (是查询出来的结果 第一个 从左边开始)

增删改

只演示一个 删除 其他的都一样

@Test
    public  void show3(){
    String sql="delete from books where id=?";
    Object[] objects={1};
        int i = JDBC_Util.INSERT_DELETE_UPDATE(sql, objects);
        if (i>0){
            System.out.println("删除成功");
        }
    }

//无需关闭连接 在工具类中帮你关闭了

事务的用法

@Test
    public  void show4(){
        List<String> list=new ArrayList<>();
        String sql="delete from books where id=?";
        String sql1="delete from books where id_1=?";
        list.add(sql);
        list.add(sql1);
        List<Object[]> list_obj=new ArrayList<>();
        Object[] objects={5};
        Object[] objects1={4};
        list_obj.add(objects);
        list_obj.add(objects1);
        int i = JDBC_Util.transaction_INSERT_DELECT_UPDATE(list,list_obj);
        if (i>=1){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }

    }

注意事项

注意: ? 不能作用于 列 只能作用于条件和值 否则 编译异常

比如select ?,?from 表 就会报错

select /* from 表 where 列=? 这就可以

或者 insert into表 values(?,?,?,?) 也可以

添加数据时候 自增列使用default

还有?周围不要加 ’ ’ 符号 否则解析不出来

使用模糊查询 这种情况也解析不出来 “%” +id+ “%” 只能在传值之前的时候给他补上Object[] object3={"%"+"abc"+"%"};

JDBC调用存储过程/存储函数

需要的配置

// 数据库驱动
    public static final String DRIVER_CLASS = "com.mysql.cj.jdbc.Driver";

    // 数据库连接地址
    public static final String DB_URL = "jdbc:mysql://localhost:3306/voidme?serverTimezone=Hongkong&useUnicode=true&characterEncoding=utf8&useSSL=false";

    // 数据库用户名称
    public static final String DB_USER = "root";

    // 数据库用户密码
    public static final String DB_PASSWORD = "root";

    /** * 获取数据库连接 * * @author pan_junbiao * @return 数据库连接对象 */
    public static Connection getConnection()
    {
        Connection conn = null;

        try
        {
            // 加载数据库驱动类
            Class.forName(DRIVER_CLASS);
            System.out.println("数据库驱动加载成功");

            // 获取数据库连接对象
            conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
            System.out.println("数据库连接成功");

        } catch (ClassNotFoundException cnfe)
        {
            cnfe.printStackTrace();
        } catch (SQLException sqle)
        {
            sqle.printStackTrace();
        } catch (Exception ex)
        {
            ex.printStackTrace();
        }

        return conn;
    }

    /** * 关闭数据库操作对象 * * @author pan_junbiao * @param res ResultSet对象 * @param stmt Statement对象 * @param conn Connection对象 */
    public static void closeOperate(ResultSet res, Statement stmt, Connection conn)
    {
        try
        {
            // 关闭ResultSet对象
            if (res != null)
            {
                res.close();
            }

            // 关闭Statement对象
            if (stmt != null)
            {
                stmt.close();
            }

            // 关闭Connection对象
            if (conn != null)
            {
                conn.close();
            }

            System.out.println("关闭数据库操作对象完成");

        } catch (SQLException sqle)
        {
            sqle.printStackTrace();
        }
    }

存储过程sql代码

-- 存储过程：分页查询用户列表
  -- 输入参数：page_index：当前页码
  -- 输入参数：page_size：分页大小
  -- 输出参数：total_count：数据总数
  -- 输出参数：total_page：总页数

DROP PROCEDURE IF EXISTS proc_search_user;
CREATE PROCEDURE proc_search_user(IN page_index INT,IN page_size INT, OUT total_count INT, OUT total_page INT)
BEGIN
		DECLARE begin_no INT;

		SET begin_no = (page_index-1)*page_size; -- 起始页
 
		-- 分页查询列表
		SELECT * FROM t_user WHERE id >= (
			SELECT id FROM t_user   -- 优化查询直接获取起始位置
			ORDER BY id ASC
			LIMIT begin_no,1
		)
		ORDER BY id ASC
		LIMIT page_size;   -- 结束位置
	
		-- 计算数据总数
		SELECT COUNT(*) INTO total_count FROM t_user;
 
		-- 计算总页数
		SET total_page = FLOOR((total_count + page_size - 1) / page_size);
	
 
END;

SET @total_count=0;
SET @total_page=0;

CALL proc_search_user(1,5,@total_count,@total_page)

SELECT  @total_count as  数据总数 ,  @total_page  as 总页数

存储函数sql代码

-- 存储函数：根据用户编号，获取用户姓名
    -- 输入参数：用户编号
    -- 返回结果：用户姓名
    
DROP FUNCTION IF EXISTS func_get_user_name;
CREATE FUNCTION func_get_user_name(in_id INT)
RETURNS VARCHAR(30)
BEGIN
	DECLARE out_name VARCHAR(30);
 
	SELECT name INTO out_name FROM t_user
	WHERE id = in_id;
 
	RETURN out_name;
END;

SELECT  func_get_user_name(6) as 名称
/** * 调用存储过程 * * @author pan_junbiao */
    public static void execProcedure(String sql)
    {
        Connection conn = null; // 数据库连接对象
        CallableStatement clbStmt = null; // CallableStatement对象
        ResultSet res = null; // 结果集对象
        try
        {
            // 获取数据库连接
            conn = getConnection();

            // 创建CallableStatement对象 {CALL proc_search_user(?,?,?,?)}
            clbStmt = conn.prepareCall(sql);

            // 设置输入参数
            clbStmt.setInt(1, 2); // 查询第2页数据
            clbStmt.setInt(2, 5); // 每页5条数据

            // 注册输出参数 (out)
            clbStmt.registerOutParameter(3, Types.INTEGER);
            clbStmt.registerOutParameter(4, Types.INTEGER);

            // 执行调用存储过程，并获取结果集
            res = clbStmt.executeQuery();

            // 循环遍历结果集
            while (res.next())
            {
                // 获取列值
                int id = res.getInt("id");
                // 输出列值
                System.out.println("编号：" + id);
            }

            // 获取输出参数值
            int totalCount = clbStmt.getInt(3);
            int totalPage = clbStmt.getInt(4);
            System.out.println("数据总数：" + totalCount + " 总页数：" + totalPage);

        } catch (SQLException sqle)
        {
            sqle.printStackTrace();
        } finally
        {
            // 关闭数据库操作对象
            closeOperate(res, clbStmt, conn);
        }
    }



    /** * 调用存储函数,实际中还可以是SELECT 代替 * * @author pan_junbiao */
    public static void execFunction(String sql)
    {
        Connection conn = null; // 数据库连接对象
        CallableStatement clbStmt = null; // CallableStatement对象
        try
        {
            // 获取数据库连接
            conn = getConnection();
            // 创建CallableStatement对象 {?=CALL func_get_user_name(?)}
            clbStmt = conn.prepareCall(sql);
            // 设置输出结果参数 ? 是站位符 第一个?
            clbStmt.registerOutParameter(1, Types.VARCHAR);
            // 设置输入参数 第二个?号
            clbStmt.setInt(2, 6);
            // 执行调用存储函数
            clbStmt.execute();
            // 获取输出参数值
            String userName = clbStmt.getString(1);
            System.out.println("用户名称：" + userName);

        } catch (SQLException sqle)
        {
            sqle.printStackTrace();
        } finally
        {
            // 关闭数据库操作对象
            closeOperate(null, clbStmt, conn);
        }
    }


    public static void main(String[] args) {
// execProcedure("{CALL proc_search_user(?,?,?,?)}"); //调用存储过程
          execFunction("{?=CALL func_get_user_name(?)}");//调用存储函数
    }

连接池

什么是连接池?

连接，是我们的编程语言与数据库交互的一种方式。我们经常会听到这么一句话“数据库连接很昂贵“。

有人接受这种说法，却不知道它的真正含义。因此，下面我将解释它究竟是什么。[如果你已经知道了，你可以跳到它的工作原理部分]

创建连接的代码片段：

Class.forName("com.mysql.jdbc.Driver");
2.Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool","root","root");

当我们创建了一个Connection对象，它在内部都执行了什么：

1.“DriverManager”检查并注册驱动程序，
2.“com.mysql.jdbc.Driver”就是我们注册了的驱动程序，它会在驱动程序类中调用getConnection方法。
3.com.mysql.jdbc.Driver的getConnection方法根据我们请求的“字符串”，创建一个“Socket连接”，连接到IP为“localhost”，默认端口3306的myschool数据库。
4.创建的Socket连接将被用来查询我们指定的数据库，并最终让程序返回得到一个结果。

为什么昂贵？

现在让我们谈谈为什么说它“昂贵“。

如果创建Socket连接花费的时间比实际的执行查询的操作所花费的时间还要更长。

这就是我们所说的“数据库连接很昂贵”，因为连接资源数是1，它需要每次创建一个Socket连接来访问数据库。

因此，我们将使用连接池。

连接池初始化时创建一定数量的连接，然后从连接池中重用连接，而不是每次创建一个新的。

使用c3p0连接池

需要的依赖

c3p0-0.9.5.2.jar

http://download.huitoushian.cn/index.jsp?path=D%3A\wwwroot\doc.huitoushian.cn\jar&filename=c3p0-0.9.5.2.jar

mchange-commons-java-0.2.12.jar

http://download.huitoushian.cn/index.jsp?path=D%3A\wwwroot\doc.huitoushian.cn\jar&filename=mchange-commons-java-0.2.12.jar

mysql-connector-java-5.1.0-bin.jar

http://download.huitoushian.cn/index.jsp?path=D%3A\wwwroot\doc.huitoushian.cn\jar&filename=mysql-connector-java-5.1.0-bin.jar

如果点不开(可能解析问题) 直接复制链接到 游览器URL上

Maven

<dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.10</version>
    </dependency>

配置文件名称c3p0-config.xml (必须是这个名称)

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<!-- 默认配置信息 default -->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
        <property name="user">root</property>
        <property name="password">root</property>
<!-- 连接池 初始化的时候 有多少个连接数量-->
        <property name="initialPoolSize">10</property>
<!-- 最大连接数量 也就是当连接的用户同时达到100以上那么就报错了-->
        <property name="maxPoolSize">100</property>
    </default-config>

    <!-- 也可以指定使用下面的配置信息 (也就是多一个选择)-->
    <named-config name="intergalactoApp">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <!-- 连接池 第一次创建多少个 连接对象-->
        <property name="initialPoolSize">10</property>
        <!-- 最大连接数量 也就是当连接的用户同时达到100以上那么就报错了-->
        <property name="maxPoolSize">100</property>
    </named-config>

<!-- 可以定义多个 named-config -->
</c3p0-config>

工具类JDBC_c3p0_Util 支持并发编程无需同步(牺牲一点内存,增加速度)

package cn.htsa.www.dao;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class JDBC_c3p0_Util {

    private static final ThreadLocal<Connection> connection = new ThreadLocal<Connection>() {
        @Override
        protected Connection initialValue() {
            Connection connection = null;
            //使用默认的 <default-config>
            //DataSource ds=new ComboPooledDataSource();
            //还可以使用 非默认的 <named-config name=" ">
            //获取配置文件中的数据
            DataSource ds1 = new ComboPooledDataSource("intergalactoApp");
            try {
                connection = ds1.getConnection();  //返回Connection对象

                System.out.println("aaa" + connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return connection;
        }
    };
    private static final ThreadLocal<ResultSet> resultSet = new ThreadLocal<ResultSet>() {
        @Override
        protected ResultSet initialValue() {
            return super.initialValue();
        }
    };

    private static final ThreadLocal<PreparedStatement> prepareStatement = new ThreadLocal<PreparedStatement>() {
        @Override
        protected PreparedStatement initialValue() {
            return super.initialValue();
        }
    };



    //事务增删改
    public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString, List<Object[]> objects) {
       
        int num = 0;
        List<PreparedStatement> preparedStatements = null;
        if (sqlString == null || objects == null || sqlString.size() == 0 || objects.size() == 0) {
            System.out.println("集合不能为空");
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
            return num;
        }
        try {

            preparedStatements = new ArrayList<PreparedStatement>();
            for (int i = 0; i < sqlString.size(); i++) {
                if (sqlString.get(i).trim().length() == 0 || sqlString.get(i) == null && objects.get(i) == null || objects.get(i).length == 0) {
                    System.out.println("sql语句 和 参数 不能为空");
                    try {
                        prepareStatement.get().close();
                        connection.get().close();
                    } catch (SQLException e) {

                        e.printStackTrace();
                    }
                    return num;
                }
                prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString.get(i)));

                for (int j = 0; j < objects.get(i).length; j++) {

                    prepareStatement.get().setObject(j + 1, objects.get(i)[j]);
                }

                preparedStatements.add(prepareStatement.get());
            }
            connection.get().setAutoCommit(false);

            for (int i = 0; i < preparedStatements.size(); i++) {

                num += preparedStatements.get(i).executeUpdate();
            }
            System.out.println("提交成功");
            connection.get().commit();
        } catch (SQLException e) {

            e.printStackTrace();

            try {
                System.out.println("执行事务异常--回滚数据");
                connection.get().rollback();
                num = 0;

            } catch (SQLException e1) {

                e1.printStackTrace();

            }

        } finally {
            try {
                connection.get().setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            closeAll();//释放连接
        }

        return num;

    }

    //不加事务的增删改
    public static int INSERT_DELETE_UPDATE(String sqlString, Object[] objects) {
        int num = 0;
        try {
            prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString));
            if (objects != null) {

                for (int i = 0; i < objects.length; i++) {

                    prepareStatement.get().setObject(i + 1, objects[i]);
                }
            }

            num = prepareStatement.get().executeUpdate();

        } catch (SQLException e) {

            e.printStackTrace();
        } finally {
            closeAll();//释放连接
        }
        return num;
    }

    //查询 返回 ResultSet对象
    public static ResultSet SELECT(String sqlString, Object[] objects) {

        try {
            prepareStatement.set(connection.get().prepareStatement(sqlString));
            if (objects != null) {
                for (int i = 0; i < objects.length; i++) {
                    prepareStatement.get().setObject(i + 1, objects[i]);
                }
            }

            resultSet.set(prepareStatement.get().executeQuery());

        } catch (SQLException e) {

            e.printStackTrace();
        }
        return resultSet.get();

    }

    //关闭数据库连接 内部方法
    public static void closeAll() {
        if (resultSet.get() != null) {
            try {
                resultSet.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        if (prepareStatement.get() != null) {
            try {
                prepareStatement.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }

        }

        if (connection.get() != null) {
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        resultSet.remove();
        prepareStatement.remove();
        connection.remove();

    }
    

}

使用方请参考JDBC工具类的使用 没什么区别 就是把调用的类名换了 (JDBC_c3p0_Util)

@Test
public void show1(){
    String sql="select * from books";
    ResultSet select = JDBC_c3p0_Util.SELECT(sql, null);
    try {
        while (select.next()){
            System.out.print(select.getInt(1));
            System.out.print(select.getString(2));
            System.out.println(select.getDouble(3));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBC_Util.closeAll();
    }
}

使用druid连接池(常用)

需要的依赖

druid-1.0.9.jar

mysql-connector-java-5.1.0-bin.jar

maven

<!--java druid 连接-->    
	<dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>

<!--java JDBC-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.10</version>
    </dependency>

配置文件druid.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false
username=root
password=root
# 初始化连接数量
initialSize=5
#最小空闲连接
minIdle=3
# 最大连接数
maxActive=10
# 最大超时时间  3秒
maxWait=3000

工具类JDBC_druid_Util 支持并发编程无需同步(牺牲一点内存,增加速度)

package cn.htsa.www.dao;

import cn.htsa.www.test.test;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import  java.sql.PreparedStatement;
import  java.sql.ResultSet;

public class JDBC_druid_Util {

    private static final ThreadLocal<ResultSet> resultSet=new ThreadLocal<ResultSet>(){
        @Override
        protected ResultSet initialValue() {
            return super.initialValue();
        }
    };

    private static final ThreadLocal<PreparedStatement> prepareStatement=new ThreadLocal<PreparedStatement>(){
        @Override
        protected PreparedStatement initialValue() {
            return super.initialValue();
        }
    };
    private static final ThreadLocal<Connection> connection=new ThreadLocal<Connection>(){
        @Override
        protected Connection initialValue() {
            Connection    connection=null;
            //1.创建一个Propertis 集合
            Properties pro=new Properties();
            try {
                pro.load(test.class.getClassLoader().getResourceAsStream("druid.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            //创建一个DataSource
            try {
                DataSource ds= DruidDataSourceFactory.createDataSource(pro);
                connection=ds.getConnection();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return  connection;
        }
    };

    //事务增删改
    public static int  transaction_INSERT_DELECT_UPDATE(List<String> sqlString,List<Object[]> objects) {

        int num=0;
        List<PreparedStatement> preparedStatements = null;
        if(sqlString==null||objects==null||sqlString.size()==0||objects.size()==0){
            System.out.println("集合不能为空");
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
            return num;
        }
        try {

            preparedStatements = new ArrayList<PreparedStatement>();
            for (int i = 0; i < sqlString.size(); i++) {
                if (sqlString.get(i).trim().length() == 0 ||sqlString.get(i)==null &&objects.get(i)==null||objects.get(i).length==0){
                    System.out.println("sql语句 和 参数 不能为空");
                    try {
                        prepareStatement.get().close();
                        connection.get().close();
                    } catch (SQLException e) {

                        e.printStackTrace();
                    }
                    return num;
                }
                prepareStatement.set(connection.get().prepareStatement(sqlString.get(i)));

                for (int j = 0; j < objects.get(i).length; j++) {

                    prepareStatement.get().setObject(j+1, objects.get(i)[j]);
                }

                preparedStatements.add(prepareStatement.get());
            }
            connection.get().setAutoCommit(false);
 
            for (int i = 0; i <preparedStatements.size(); i++) {

                num+=preparedStatements.get(i).executeUpdate();
            }
            System.out.println("提交成功");
            connection.get().commit();
        } catch (SQLException e) {

            e.printStackTrace();

            try {
                System.out.println("执行事务异常--回滚数据");
                connection.get().rollback();
                num=0;

            } catch (SQLException e1) {

                e1.printStackTrace();

            }

        }finally{
            try {
                connection.get().setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            closeAll();//释放连接
        }

        return num;

    }


    //不加事务的增删改
    public static int INSERT_DELETE_UPDATE(String sqlString,Object[] objects){

        int num=0;
        try {
            prepareStatement.set(connection.get().prepareStatement(sqlString));
            if(objects!=null){
                for (int i = 0; i < objects.length; i++) {

                    prepareStatement.get().setObject(i+1, objects[i]);
                }
            }

            num= prepareStatement.get().executeUpdate();

        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            closeAll();//释放连接
        }
        return num;
    }

    //查询 返回 ResultSet对象
    public static ResultSet SELECT(String  sqlString,Object[] objects){
        try {
            prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString));
            if(objects!=null){
                for (int i = 0; i < objects.length; i++) {
                    prepareStatement.get().setObject(i+1, objects[i]);
                }
            }

            resultSet.set(prepareStatement.get().executeQuery());

        } catch (SQLException e) {

            e.printStackTrace();
        }
        return resultSet.get();

    }



    //关闭数据库连接 内部方法
    public    static void closeAll(){
        if(resultSet.get()!=null){
            try {
                resultSet.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        if(prepareStatement.get()!=null){
            try {
                prepareStatement.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }

        }

        if(connection.get()!=null){
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        resultSet.remove();
        prepareStatement.remove();
        connection.remove();

    }
}

使用方请参考JDBC工具类的使用 没什么区别 就是把调用的类名换了 (JDBC_druid_Util)

@Test
public void show1(){
    String sql="select * from books";
    ResultSet select = JDBC_druid_Util.SELECT(sql, null);
    try {
        while (select.next()){
            System.out.print(select.getInt(1));
            System.out.print(select.getString(2));
            System.out.println(select.getDouble(3));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBC_Util.closeAll;
    }
}

使用DBCP连接池

需要的依赖在Tomcat里基本都有 一般使用IDEA都会默认给你导入

你就需要导入一个

mysql-connector-java-5.1.0-bin.jar

http://download.huitoushian.cn/index.jsp?path=D%3A\wwwroot\doc.huitoushian.cn\jar&filename=mchange-commons-java-0.2.12.jar

如果点不开(可能解析问题) 直接复制链接到 游览器URL上

maven

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.10</version>
    </dependency>

DBCP主要就是用语在Tomcat中搭建连接池的(如果没有启动Tomcat服务器是无法使用的) ,当然使用上面的连接池也可以看你自己

而且只能在jsp 和Servlet 这二个地方使用 也就是服务端 不能直接在本地测试

在自己项目webapp下META-INF目录(没有就创建)下context.xml 文件

或者Tomcat安装目录下面conf目录下的 context.xml(如果,没用就 只能在自己项目中创建了)

在项目

context.xml文件内容

<Context>
	<Resource name="jdbc/news" auth="Container" type="javax.sql.DataSource" maxActive="100" maxIdle="30" maxWait="10000" username="root" password="root" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false" />

</Context>

context.xml 内容 解析

name 是Resource标签 名称

auth 是 有两个属性 一个 是Container**由容器创建Resource 第二个是Application由web应用创建和管理Resource

type 是Resource 所属的类型

maxActive 活动状态下 最大同时连接数量 (正在连接还在使用中 )

maxIdle 空闲连接最大数量 (使用连接完成 现在连接处于空闲状态的 最大 数量)

maxWait 指定连接的最大空闲时间 毫秒

username 代表数据库 账户

password 代表密码

driverClassName 代表jdbc连接驱动

url 连接数据库 字符

jdbc:mysql 是Mysql数据库

127.0.0.1 和localhost都是一样的连接本地

test**数据库名称

*useUnicode=true&characterEncoding=utf-8"*是字符编码

(当正在使用的连接超过了 空闲连接(maxIdle)的最大数量,就会创建新连接但是不能超过最大连接数量(maxActive) 当新创建的连接使用完毕后 处于空闲连接状态,在一定的连接空闲期间未被在次使用 就会被释放连接 ,空闲连接数量不能超过最大空闲连接的多余的就会被释放连接 ) 空闲最大连接<最大连接数量

比如: 当前连接 40人 最大连接数量50 最大空闲连接30 最大空闲时间10秒

40-30=10; 这多出的10人就不在 最大空连接的范围内 属于 溢出创建的连接 当用户使用完后就会 在空闲连接时间后 释放连接 直到空闲连接小于等于30

在比如: 打电话10086 日常可维持 在30个人 同时打电话 最大不能超过100

否则 其他人就需要进行等待 等 这100个人中其中 某些人打完 其他人才能 打进去电话 否则就会提示正在忙碌中请稍后在播

如果只有 10个人同时打 剩下的20个客服就处于空闲状态

如果忙碌时间 同时 有40个打电话 那么就需要在加上10个临时客服 等通话结束后

这加上来的10个客服 就要撤走

最大可同时100 也就是 忙碌的时候 在原有的基础上 在加70个临时客服 等空闲的时候在撤走

在自己项目webapp下WEB-INF目录下web.xml 文件 修改

或者Tomcat安装目录下面conf目录下的web.xml (如果,没用就 只能在自己项目中创建了)

web.xml 文件内容

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">

  <resource-ref>
    <res-ref-name>jdbc/news</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
  </resource-ref>

</web-app>

文本中的<resource-ref>标签内的这些参数必须****对应context.xml 文件内Resource 的参数否则就会创建数据库连接池失败

工具类JDBC_DBCP_Util 支持并发编程无需同步(牺牲一点内存,增加速度)

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class JDBC_DBCP_Util {

private static final ThreadLocal<ResultSet> resultSet = new ThreadLocal<ResultSet>() {
        @Override
        protected ResultSet initialValue() {
            return super.initialValue();
        }
    };

    private static final ThreadLocal<PreparedStatement> prepareStatement = new ThreadLocal<PreparedStatement>() {
        @Override
        protected PreparedStatement initialValue() {
            return super.initialValue();
        }
    };
    private static final ThreadLocal<Connection> connection = new ThreadLocal<Connection>() {
        @Override
        protected Connection initialValue() {
            Connection connection = null;
            try { //获取与逻辑名相关联的数据源对象
                Context ctx = new InitialContext();
                DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/news");
                connection = ds.getConnection();
//通过web.xml文件内jdbc/news名称获取conntext.xml文件内的连接数据
            } catch (SQLException | NamingException exception) {
                exception.printStackTrace();
            }
            return connection;
        }

    };

    //事务增删改
    public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString, List<Object[]> objects) {

        int num = 0;
        List<PreparedStatement> preparedStatements = null;
        if (sqlString == null || objects == null || sqlString.size() == 0 || objects.size() == 0) {
            System.out.println("集合不能为空");
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
            return num;
        }
        try {

            preparedStatements = new ArrayList<PreparedStatement>();
            for (int i = 0; i < sqlString.size(); i++) {
                if (sqlString.get(i).trim().length() == 0 || sqlString.get(i) == null && objects.get(i) == null || objects.get(i).length == 0) {
                    System.out.println("sql语句 和 参数 不能为空");
                    try {
                        prepareStatement.get().close();
                        connection.get().close();
                    } catch (SQLException e) {

                        e.printStackTrace();
                    }
                    return num;
                }
                prepareStatement.set(connection.get().prepareStatement(sqlString.get(i)));

                for (int j = 0; j < objects.get(i).length; j++) {

                    prepareStatement.get().setObject(j + 1, objects.get(i)[j]);
                }

                preparedStatements.add(prepareStatement.get());
            }
            connection.get().setAutoCommit(false);

            for (int i = 0; i < preparedStatements.size(); i++) {

                num += preparedStatements.get(i).executeUpdate();
            }
            System.out.println("提交成功");
            connection.get().commit();
        } catch (SQLException e) {

            e.printStackTrace();

            try {
                System.out.println("执行事务异常--回滚数据");
                connection.get().rollback();
                num = 0;

            } catch (SQLException e1) {

                e1.printStackTrace();

            }

        } finally {
            try {
                connection.get().setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            closeAll();//释放连接
        }

        return num;

    }

    //不加事务的增删改
    public static int INSERT_DELETE_UPDATE(String sqlString, Object[] objects) {

        int num = 0;
        try {
            prepareStatement.set(connection.get().prepareStatement(sqlString));
            if (objects != null) {
                for (int i = 0; i < objects.length; i++) {

                    prepareStatement.get().setObject(i + 1, objects[i]);
                }
            }

            num = prepareStatement.get().executeUpdate();

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeAll();//释放连接
        }
        return num;
    }

    //查询 返回 ResultSet对象
    public static ResultSet SELECT(String sqlString, Object[] objects) {
        try {
            prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString));
            if (objects != null) {
                for (int i = 0; i < objects.length; i++) {
                    prepareStatement.get().setObject(i + 1, objects[i]);
                }
            }

            resultSet.set(prepareStatement.get().executeQuery());

        } catch (SQLException e) {

            e.printStackTrace();
        }
        return resultSet.get();

    }

    //关闭数据库连接 内部方法
    public static void closeAll() {
        if (resultSet.get() != null) {
            try {
                resultSet.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        if (prepareStatement.get() != null) {
            try {
                prepareStatement.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }

        }

        if (connection.get() != null) {
            try {
                connection.get().close();
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
        resultSet.remove();
        prepareStatement.remove();
        connection.remove();
    }
}

使用方请参考JDBC工具类的使用 没什么区别 就是把调用的类名换了 (JDBC_DBCP_Util)

jsp页面

<%@ page import="java.sql.ResultSet" %>
<%@ page import="java.sql.SQLException" %>
<%@ page import="cn.htsa.www.dao.JDBC_DBCP_Util" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    String sql="select * from books";
    ResultSet select = JDBC_DBCP_Util.SELECT(sql, null);
    try {
        while (select.next()){
            System.out.print(select.getInt(1));
            System.out.print(select.getString(2));
            System.out.println(select.getDouble(3));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        JDBC_DBCP_Util.closeAll();
    }
%>

</body>
</html>

Servlet

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.sql.ResultSet;
import java.sql.SQLException;

@WebServlet(name = "Servlet")
public class Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//设置 请求 和响应 的格式都是 utf-8
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
//告诉游览器 要用utf-8来解析
        response.setContentType("text/html; charset=utf-8");


        String sql="select * from books";
        ResultSet select = JDBC_DBCP_Util.SELECT(sql, null);
        try {
            while (select.next()){
                System.out.print(select.getInt(1));
                System.out.print(select.getString(2));
                System.out.println(select.getDouble(3));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBC_DBCP_Util.close(select);
        }
    }
}

jdbc-Template(推荐)

需要使用的依赖 maven

<dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.3</version>
    </dependency>

<!--java druid 连接-->

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>

<!--java JDBC-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.10</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

jdbcTemp 是基于jdbc进行封装的

拥有了实体类自动映射的功能和映射List,Map,等功能非常强大

添加druid.properties配置文件 上面有

添加工具类Jdbc_Template

我使用的是druid连接池来完成的jdbc_template工具类 支持并发编程无需同步

基础配置

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceUtils;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class Jdbc_Template {

	public   static JdbcTemplate JdbcTemp=null;
	private static   DataSource  dataSource=null;

	//调用properties 文件的 数据库连接
	static {
		//1.创建一个Propertis 集合
		Properties pro=new Properties();
		try {
			pro.load(Jdbc_Template.class.getClassLoader().getResourceAsStream("druid.properties"));
		} catch (IOException e) {
			e.printStackTrace();
		}
		//创建一个DataSource
		try {
			dataSource= DruidDataSourceFactory.createDataSource(pro);
			JdbcTemp=new JdbcTemplate((DataSource) dataSource);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		//不用 管连接的创建 因为 JdbcTemplate 他内部 会自动给你 创建 和关闭的 
		//除非 你手动 去调用 Connection

	}


	private static Connection Connec(){

		return  DataSourceUtils.getConnection(dataSource);
	}


	public static int  transaction_INSERT_DELECT_UPDATE(List<String> sqlString, List<Object[]> objects) {
		Connection connection= Connec();
		PreparedStatement prepareStatement=null;
		List<PreparedStatement> preparedStatements = null;
		int num=0;
		if(sqlString==null||objects==null||sqlString.size()==0||objects.size()==0){
			System.out.println("集合不能为空");
			try {
				connection.close();
			} catch (SQLException e) {

				e.printStackTrace();
			}
			return num;
		}
		try {

			preparedStatements = new ArrayList<PreparedStatement>();
			for (int i = 0; i < sqlString.size(); i++) {
				if (sqlString.get(i).trim().length() == 0 ||sqlString.get(i)==null &&objects.get(i)==null||objects.get(i).length==0){
					System.out.println("sql语句 和 参数 不能为空");
					try {
						prepareStatement.close();
						connection.close();
					} catch (SQLException e) {

						e.printStackTrace();
					}
					return num;
				}
				prepareStatement=(PreparedStatement) connection.prepareStatement(sqlString.get(i));

				for (int j = 0; j < objects.get(i).length; j++) {

					prepareStatement.setObject(j+1, objects.get(i)[j]);
				}

				preparedStatements.add(prepareStatement);
			}
			connection.setAutoCommit(false);
		} catch (SQLException e) {

			e.printStackTrace();
		}


		try {
			for (int i = 0; i <preparedStatements.size(); i++) {

				num+=preparedStatements.get(i).executeUpdate();
			}
			System.out.println("提交成功");
			connection.commit();
		} catch (SQLException e) {

			e.printStackTrace();

			try {
				System.out.println("执行事务异常--回滚数据");
				connection.rollback();
				num=0;

			} catch (SQLException e1) {

				e1.printStackTrace();

			}

		}finally{
			try {
				connection.setAutoCommit(true);
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				prepareStatement.close();
				connection.close();

			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return  num;
	}
}

增删改

都是调用update() 这个方法 第二个参数是可变参数 能直接传Object[]

//添加
String sql = "insert into xinwen VALUES(default,?,?,?)";
//上面?号 对应下面的参数
int num=  Jdbc_Template.JdbcTemp.update(sql,"尼玛安安1","哪啊2","2019-01-02");
  System.out.println(num);

//修改
  String sql = "update xinwen set title=? where id=?";
  //上面?号 对应下面的参数
int num=  Jdbc_Template.JdbcTemp.update(sql,"哈洗车12","2");
  System.out.println(num);

  //删除
  String sql = "delete from xinwen where id=?";
  //上面?号 对应下面的参数
int num=  Jdbc_Template.JdbcTemp.update(sql,"1");
  System.out.println(num);

查询

查询就不一样了

单条数据 Map<String,Object> queryForMap(sql , …)

public Map<String,Object> update_show(String name) {
    //查询
    String sql = "select * from day_1 where name =?";
    //上面?号 对应下面的参数
    Map<String,Object> map= null;
    try {
        map = Jdbc_Template.JdbcTemp.queryForMap(sql,name);
    } catch (DataAccessException e) {
       e.printStackTrace();
    }
    return map;
}

//map内 : key 对应的 字段 value 对应 值
//如果查询不到 就会报错将程序停了 所以最好 用 异常检查

多条查询: List<Map<String,Object>> queryForList(sql , …)

List<Map<String,Object>> list= Jdbc_Template.JdbcTemp.queryForList("select * from province");

结果:
[{id=1, NAME=北京}, {id=2, NAME=上海}, {id=3, NAME=广州}, {id=4, NAME=陕西}]
//map内 : key 对应的 字段 value 对应 值

查询指定列 List<T> queryForList(sql, T.class, …)

List<String> list= Jdbc_Template.JdbcTemp.queryForList("select NAME from province", String.class);
结果:
[北京, 上海, 广州, 陕西]

查询数据条数 T queryForObject(sql , T.class , …)

//查询
String sql = "select count(*) from xinwen ";
//上面?号 对应下面的参数
 int num=  Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class);
System.out.println(num);

//当然还可以有条件的
String sql="select count(*) from user where username=? and password=? ";
int num = Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class,username,password);

查询 一条数据存映射到 对象里

T queryForObject(sql , new BeanPropertyRowMapper<>(T.class) , …)

封装好get set 进行映射
映射的属性 要和数据库 中的字段名一样 否则 无法映射成功

String sql="select * from user where username=?";
bean  ben1=Jdbc_Template.JdbcTemp.queryForObject(sql,new BeanPropertyRowMapper<bean>(bean.class),"huanmin");

查询多条数据映射到对象里 并且保存在 List<对象>

List<T> query(sql, new BeanPropertyRowMapper<>(T.class) , …)

封装好get set 进行映射
映射的属性 要和数据库 中的字段名一样 否则 无法映射成功
    
    //查询
String sql = "select * from xinwen where author=?";
BeanPropertyRowMapper  Bean =  new BeanPropertyRowMapper<>(Entity.class);
//上面?号 对应下面的参数
 List<Entity> list=Jdbc_Template.JdbcTemp.query(sql,Bean,"哪啊");
for (Entity en:list){
    System.out.println(en.toString());
}

模糊查询

不能在?的前后添加 任何符号 所以 需要在最后 传参的时候 将%给他拼接进去

完整版的sql 语句:

select /* from user where 1=1 and name like ? and address like ? and email like ?

Map<String, String[]>  是前端传递来的url参数

@Override
public List<User> findUser(Map<String, String[]> a) {
    String sql="select * from user where 1=1";
    StringBuilder stringBuilder=new StringBuilder(sql);
    List<Object> par=new ArrayList<>();
    Set<String> keys=a.keySet();
    for (String key:keys) {
        stringBuilder.append(" and "+key+" like ?");
        String value=a.get(key)[0];
        par.add("%"+value+"%");
    }
    sql=stringBuilder.toString();
    System.out.println(sql);
    return Jdbc_Template.JdbcTemp.query(sql,new BeanPropertyRowMapper<>(User.class),par.toArray()) ;
}

par.toArray()将集合转变成 数组 因为query这个方法最后是一个可变Object参数

分页查询

当前页数 3

每页多少显示条数据 4

select /* from user where limit (3-1)/*4,4

关键代码

//求出一共多少条
  public static int count(){
      String sql="select count(*) from day_1";
      int num=  Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class);
      return num;
  }

  @Override
  public List<Entity> select_fenye(int num) {
     //每页只显示4条 所以/4 然后如果多余的在另起一页
     int ye_num=Math.ceil( (double) count()/4)
   //判断页码 和 传进来的页数
      if (ye_num<num){ 
          return null;
      }
      String sql="select * from day_1 LIMIT ?,4 ";  //每页只显示4条数据
      BeanPropertyRowMapper Bean=  new BeanPropertyRowMapper<>(Entity.class);
      
      List<Entity> list=  Jdbc_Template.JdbcTemp.query(sql,Bean,(num-1)*4);
      return list;
  }

兼容模糊和分页

也就是你模糊查询出来的数据太多了 利用分页给拆分下

private  int mohu(String name ,String address,String email){
    String sql="select count(*) from user where name like ? and address like ? and email like ?";
    return Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class,"%"+name+"%","%"+address+"%","%"+email+"%");
}

@Override
public PageBean<User> Fenye(String name ,String address,String email,int currentPage) {
    PageBean<User> pageBean=new PageBean<>();
    String sql="select * from user where name like ? and address like ? and email like ? LIMIT ?,?";
    Object[] objects={"%"+name+"%","%"+address+"%","%"+email+"%",(currentPage-1)*pageBean.getRows(),pageBean.getRows()};
    List<User> users=Jdbc_Template.JdbcTemp.query(sql,new BeanPropertyRowMapper<>(User.class),objects);
    pageBean.setCurrentPage(currentPage);
    pageBean.setList(users);//数据
    int num=mohu( name,address,email);
    pageBean.setPageConunt(num);//总条数
    pageBean.setTotalPage(num%pageBean.getRows()==0?num/pageBean.getRows():(num/pageBean.getRows())+1);//种页码
    pageBean.setName(name);
    pageBean.setAddress(address);
    pageBean.setEmail(email);
    return pageBean;
}

pageBean 类自己定义

Rows每页显示的条数 使用前就定义好

CurrentPage 当点击的页数

List 查询出来的 数据

PageConunt 数据总条数

TotalPage 分页的总页数

Name 保存模糊查询的name数据

Address保存模糊查询的address数据

Email保存模糊查询的Email数据

为什么要保存 模糊查询的数据

因为如果我点击下一页了 那么他怎么找到你要模糊查询的下一页数据 是不是还是要通过模糊查询的数据 来算出来 的要查询的第几页 具体怎么操作那么就看你自己了有很多办法 , 师傅领进门,代码看个人

事务的用法 参考JDBC (将名称换成Jdbc_Template)

存储过程

获取连接的方法上面有

无返回值的存储过程调用：

public void test(){   
     this.jdbcTemplate.execute("call testpro('p1','p2')");   
  }

有返回值的存储过程（非结果集）

public void test() {   
  String param2Value = (String) jdbcTemplate.execute(   
     new CallableStatementCreator() {   
        public CallableStatement createCallableStatement(Connection con) throws SQLException {   
           String storedProc = "{call testpro(?,?)}";// 调用的sql 
           CallableStatement cs = con.prepareCall(storedProc);   
           cs.setString(1, "p1");// 设置输入参数的值 
           cs.registerOutParameter(2, Java.Sql.Types.VARCHAR);// 注册输出参数的类型 
           return cs;   
        }   
     }, new CallableStatementCallback() {   
         public Object doInCallableStatement(CallableStatement cs) throws SQLException, DataAccessException {   
           cs.execute();   
           return cs.getString(2);// 获取输出参数的值 
     }   
  });   
}

有返回值的存储过程（结果集）

public void test() {   
  List resultList = (List) jdbcTemplate.execute(   
     new CallableStatementCreator() {   
        public CallableStatement createCallableStatement(Connection con) throws SQLException {   
           String storedProc = "{call testpro(?,?)}";// 调用的sql 
           CallableStatement cs = con.prepareCall(storedProc);   
           cs.setString(1, "p1");// 设置输入参数的值 
           cs.registerOutParameter(2, OracleTypes.CURSOR);// 设置输出参数的类型 
           return cs;   
        }   
     }, new CallableStatementCallback() {   
        public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException {   
           List resultsMap = new ArrayList();   
           cs.execute();   
           ResultSet rs = (ResultSet) cs.getObject(2);// 获取游标一行的值 
           while (rs.next()) {// 转换每行的返回值到Map中 
              Map rowMap = new HashMap();   
              rowMap.put("id", rs.getString("id"));   
              rowMap.put("name", rs.getString("name"));   
              resultsMap.add(rowMap);   
           }   
           rs.close();   
           return resultsMap;   
        }   
  });   
  for (int i = 0; i < resultList.size(); i++) {   
     Map rowMap = (Map) resultList.get(i);   
     String id = rowMap.get("id").toString();   
     String name = rowMap.get("name").toString();   
     System.out.println("id=" + id + ";name=" + name);   
  }   
}

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_45203607/article/details/120238916

内容来源于网络，如有侵权，请联系作者删除！

Javajdbc数据库数据库连接池

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com