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

72 阅读 0 评论 48 点赞

我是靠谱客的博主洁净枫叶，最近开发中收集的这篇文章主要介绍Java数据库连接大全-基础版Java数据库连接大全-基础版，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

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

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%3Awwwrootdoc.huitoushian.cnjar&filename=c3p0-0.9.5.2.jar

mchange-commons-java-0.2.12.jar

http://download.huitoushian.cn/index.jsp?path=D%3Awwwrootdoc.huitoushian.cnjar&filename=mchange-commons-java-0.2.12.jar

mysql-connector-java-5.1.0-bin.jar

http://download.huitoushian.cn/index.jsp?path=D%3Awwwrootdoc.huitoushian.cnjar&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%3Awwwrootdoc.huitoushian.cnjar&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);   
  }   
}

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复如有侵权，请私信联系我感谢,配合,希望我的努力对你有帮助^_^

最后

以上就是洁净枫叶为你收集整理的Java数据库连接大全-基础版Java数据库连接大全-基础版的全部内容，希望文章能够帮你解决Java数据库连接大全-基础版Java数据库连接大全-基础版所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Java
浏览次数：72 次浏览
发布日期：2023-09-12 09:35:41
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_6_f1_14__23__10_y.html

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

概述

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

JDBC

查询

增删改

事务的用法

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

连接池

什么是连接池?

使用c3p0连接池

使用druid连接池(常用)

使用DBCP连接池

jdbc-Template(推荐)

基础配置

增删改

查询

模糊查询

分页查询

兼容模糊和分页

存储过程

最后

评论列表共有 0 条评论

发表评论取消回复

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

概述

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

JDBC

查询

增删改

事务的用法

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

连接池

什么是连接池?

使用c3p0连接池

使用druid连接池(常用)

使用DBCP连接池

jdbc-Template(推荐)

基础配置

增删改

查询

模糊查询

分页查询

兼容模糊和分页

存储过程

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复