精华内容
下载资源
问答
  • JDBC是Java数据连接技术(Java Database Connection)的简称,提供连接各种常用数据库的能力。 •JDBC驱动由数据库厂商提供 –在个人开发与测试中,可以使用JDBC-ODBC桥连方式 –在生产型开发中,推荐使用纯Java...

    目录

    文中储备知识:

    1.JDBC

    2.两种常见的JDBC

          (1)JDBC-ODBC桥方式

          (2)纯Java方式

    3.DSN

    4.JDBC操作的步骤

     

    一、JDBC配置问题

    1.JDBC-ODBC桥方式

    2.纯Java方式

    二、名字不匹配

    (1)数据库名

    (2)数据库对应的用户名

    (3)表名

    (4)表名中的属性名

             (5)与ODBC方法相关的数据源名

    三、数据库连接代码


    文中储备知识:

    1.JDBC

    JDBC是Java数据连接技术(Java Database Connection)的简称,提供连接各种常用数据库的能力。

    •JDBC驱动由数据库厂商提供
    –在个人开发与测试中,可以使用JDBC-ODBC桥连方式
    –在生产型开发中,推荐使用纯Java驱动方式

    2.两种常见的JDBC

    (1)JDBC-ODBC桥方式

    使用JDBC-ODBC桥方式连接数据库

    将对 JDBC API 的调用,转换为对另一组数据库连接 API 的调用
    优点:可以访问所有 ODBC 可以访问的数据库
    缺点:执行效率低、功能不够强大

    (2)纯Java方式

    使用纯Java方式连接数据库

    JDBC 驱动直接访问数据库
    优点: 100% Java ,快又可跨平台
    缺点:访问不同的数据库需要下载专用的 JDBC 驱动

    但是,经过实践操作,大多数同学都觉得纯Java方式连接数据库的成功率更高些,使用JDBC-ODBC桥常连接失败(不知道是不是操作流程的问题)。

    3.DSN

    • 数据源的定义:

    数据源的英文是DSN(Data Source Name),它是一种用来提高数据库连接性能的常规手段。

    • 数据源的作用:

    “数据库建立好之后,要设定系统的 DSN(数据来源名称),才能让网页可以知道数据库所在的位置以及数据库相关的属性。使用DSN的好处还有,如果移动数据库档案的位置,或是换成别种类型的数据库,只要重新设定 DSN 就好了,不需要去修改原来使用的程序。”

    4.JDBC操作的步骤:

      1、 加载驱动程序
      2、 连接数据库
      3、 操作数据库
      4、 关闭数据库,释放连接

    参考资料:

    https://blog.csdn.net/lxw1844912514/article/details/100028770

    https://www.cnblogs.com/cainame/p/10339294.html

    https://blog.csdn.net/cuiwjava/article/details/20202859


    一、JDBC配置问题

    1.JDBC-ODBC桥方式

    (1)配置ODBC桥的流程中出问题

    A.数据源(DSN)配置

    在电脑中的 “控制面板——系统和安全——管理工具——数据源(ODBC)” 中配置ODBC桥的数据源

    • 注1:数据源的英文DSN(Data Source Name)
    • 注2:配置过程中的DSN名称需要记住,用于后面用Java写数据库连接代码中的创建连接()

    private Connection conn; 

    conn=DriverManager.getConnection("jdbc:odbc:DSN名称","用户名","密码");

    • a. 没有选择与代码中相匹配的用户登录ID和密码

    因为在配置数据源的过程中,需要在

    “用户输入登录ID和密码的SQL Server 验证”下

    输入在数据库创建的用户及其对应密码

    • b. 没有选择与代码中相匹配的数据库

    因为在配置数据源的过程中,需要选择该用户操作的数据库

    数据源的配置过程可参考:

    https://blog.csdn.net/qq_41187714/article/details/103494367

     

    2.纯Java方式

    (1)JDBC驱动包与数据库不匹配

    比如 Microsoft SQL Server 2008 R2数据库可以下载sqljdbc4驱动包

    (2)添加驱动包的方法不正确

    可以右键项目名——Build Path——Config Build Path...——Java Build Path ——Libraries——Add JARs或AddExternal JARS——OK

    (3)驱动包路径不对

    常见于拷贝了别人的项目到自己的电脑里

    修改驱动包路径的方法:在项目中重新加载驱动包,即可以重新添加驱动包

    添加jar包方法可参考:
    https://www.cnblogs.com/yhmdjl/p/6485303.html

    注:

    JAR(Java Archive)是Java的一种压缩文档格式

     

    二、名字不匹配

    主要是数据库中的设置与代码中的不匹配

    (1)数据库名

    (2)数据库对应的用户名

    (3)表名

    比如 数据库中的表名是tblXyInfo,而 Java代码中写的是却是tblXyxx

    (4)表名中的属性名

    比如 数据库中的学院信息表 tblXyInfo 中有代码XyId、名称XyName、状态XyState、添加时间XyTime这几个属性。

    注意:

    (1)大小写的区分

    (2)“同义词”

    比如:学院信息表

    tblXyInfo ——table xue yuan information

    tblXyxx ——table xue yuan xin xi

    (5)与ODBC方法相关的数据源名

     

    三、数据库连接代码

    除了编译中报的语法错误外,还可能存在如下问题:

    1.没有实例化对象

    常会编写一个xxxHelper.java 然后再实例化这个类的对象。
     

    private OdbcHelper helper;//在类中定义成员
    
    //private MssHelper helper;
    
    
    
    helper = new OdbcHelper();//在类的方法中实例化这个成员
    //helper = new MssHelper();

    注:

    OdbcHelper.java中存放 ODBC桥连接数据库的代码。(需配置数据源)

    MssHelper.java中存放 直连数据库的代码。(需加载驱动包)

     

    本篇文章将会持续更新....

     

     

    展开全文
  • java 连接数据库以及常见错误

    万次阅读 2018-10-24 16:12:49
    最近在写一个Java小项目,用到了数据库连接的知识,一个多星期的使用也碰到了不少问题。这里把这一块总结一下。  本人使用的是eclipse编译器和MySQL数据库还有连接两个的数据库驱动。配置的话可以看我的另一篇连接...

        最近在写一个Java小项目,用到了数据库连接的知识,一个多星期的使用也碰到了不少问题。这里把这一块总结一下。

       本人使用的是eclipse编译器和MySQL数据库还有连接两个的数据库驱动。配置的话可以看我的另一篇连接:配置驱动

       接下来就是正常的链接操作了。Java语言和数据库的连接直接有相应的实现,之后对于数据库的操作语句也是直接使用字符串的形式通过类的使用来完成,主要的又一下几步:

    public class damen_01 {
     
        // JDBC 驱动名及数据库 URL
        static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
        static final String DB_URL = "jdbc:mysql://localhost:3306/day01";
     
        // 数据库的用户名与密码,需要根据自己的设置
        static final String USER = "root";
        static final String PASS = "";
     
        public static void main(String[] args) {
            Connection conn = null;
            Statement stmt = null;
            try{
                // 注册 JDBC 驱动
            	Class.forName(JDBC_DRIVER);
            	
                // 打开链接
                System.out.println("连接数据库...");
                conn = DriverManager.getConnection(DB_URL,USER,PASS);
                if(!conn.isClosed())
                	System.out.println("success");
                // 执行查询
                System.out.println(" 实例化Statement对象...");
                stmt = conn.createStatement();
                String sql;
                sql = "SELECT id, name, url FROM websites";
                ResultSet rs = stmt.executeQuery(sql);
            
                // 展开结果集数据库
                while(rs.next()){
                    // 通过字段检索
                    int id  = rs.getInt("id");
                    String name = rs.getString("name");
                    String url = rs.getString("url");
        
                    // 输出数据
                    System.out.print("ID: " + id);
                    System.out.print(", 站点名称: " + name);
                    System.out.print(", 站点 URL: " + url);
                    System.out.print("\n");
                }
                // 完成后关闭
                rs.close();
                stmt.close();
                conn.close();
            }catch(SQLException se){
                // 处理 JDBC 错误
                se.printStackTrace();
                System.out.println("<<<<<");
            }catch(Exception e){
                // 处理 Class.forName 错误
                e.printStackTrace();
                System.out.println("???????");
            }finally{
                // 关闭资源
                try{
                    if(stmt!=null) stmt.close();
                }catch(SQLException se2){
                }// 什么都不做
                try{
                    if(conn!=null) conn.close();
                }catch(SQLException se){
                    se.printStackTrace();
                }
            }
        }
    

    代码是在菜鸟教程上找到的,看着来入门写点东西还是很简单的,这里就我当时的疑惑和出现错误的地方再写点注释:

    一.注册驱动: 这里的注册驱动中是字符串形式,其中的字符串一般都是固定的,但是最先版的MySQL使用的不是 
              上面的那个,记得中间还需要加上点东西,具体的没记太清楚,不过百度一下很随意都可以搜到。一 
              般这里出错时间都是一下几种:
              1. 驱动版本和MySQL不对照
              
              2. 驱动没配置好
              
              3. 该句中的字符串写错
    
    二.打开连接: 这里主要是三给字符串代表的含义。代表意义如下:
              1.以斜杠为间隔,分别代表使用的驱动的数据库类型,地址以及端口,该数据库中需要访问的数据库 
                名称
    
              2.登陆的账户名称
            
              3.该账户登陆所需密码
    
    三.执行语句: 这里的MySQL操作命令都是以字符串命令的形式出现的,因此只需要将所需操作的命令传入一个字 
               符串类型的实例化对象即可,同样也可以使用 ‘+’ 符号来连接那些含有变量不确定的语句构成字符 
               串,例如:String sql ="select * from books where b_id='"+id+"'";
               这里的ResultSet所定义的类rs代表的是查询之后返回的数据集合。
    
    四.展开结果:使用rs.next()循环来递归得到相应数据。注意,以上这些使用过之后应该及时关闭,以免出现数 
               据泄露的可能。
    
    五.抛出异常:建议使用try....catch....来处理异常,这样可以直观的看到是何种异常,进而及时的更改

    大致的情况也就是这样了。接下来是一些常见的错误:

       一. 数据库语句出错,这种错误出现时间输出的异常是MySQL语句错误(很容易分辨),需要认真检查。

       二. 使用了PreparedStatement 类来替换 Statement类,该类方便了sql命令字符串的构造,但是需要多出预处理的过程,                   可以说有利有弊吧,不够需要清楚知道该类预处理时间的操作。

       三.该错误出去sql语句的错误,出现的次数可能是最多的了。是Statement类所对应SQL语句执行时使用的 executeQuery(),

            executeUpdate(),execute()这三种方法,方法是有所区别的,执行select语句时间直接使用第一个即可,但是insert需要使          用第三个,update需要使用第二个。使用不当也是会出现报错。

    行了,就这些吧,错误常见的目前感觉也就这些,其他的也遇到过,不过记不太清了,以后遇到了再添加吧

    展开全文
  • a)eclipse:开发java程序(配置环境变量方法自行查阅) b)mysql数据库:(官网下载,尽量不要下载最新版),注意开启服务, 开启服务的方法— —右键单击桌面"此电脑"——点击"管理"——按照下...

    1、开发工具 :
    a)eclipse:开发java程序(配置环境变量方法自行查阅)
    b)mysql数据库:(官网下载,尽量不要下载最新版),注意开启服务,
    开启服务的方法— —右键单击桌面"此电脑"——点击"管理"——按照下图找到MySQL,启动该服务
    在这里插入图片描述
    c)Navicat Premium开发工具(可到官网下载)
    d)mysql连接jar包:如图就是其一版本
    在这里插入图片描述
    2、Navicat Premium使用:
    点击"连接"——“MySQL”——输入密码——点击"连接测试"——连接成功
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    连接成功后,新建一个数据库,并新建一个表,以便之后用java连接数据库时调用!

    3、Eclipse连接MySQL:
    1)eclipse创建一个文件夹lib
    2)复制mysqlconn…jar(mysql连接jar包) 到 lib
    3)项目右键 build path —configure build path—接着如下图所示—Add JARs
    在这里插入图片描述
    4)创建连接,并测试是否连接成功:

    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/mysql1";//连接数据库mysql1
    this.conn=DriverManager.getConnection(url, "root", "123456");
    System.out.println(this.conn.isClosed());	//是否连接成功,false 代表成功
    

    4、操作数据库(实例):

    1)创建DB定制类:

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class DB {
    
    	private Connection conn;
    	private Statement stmt;
    	
    	public DB() {
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			String url="jdbc:mysql://localhost:3306/mysql1";
    			this.conn=DriverManager.getConnection(url, "root", "123456");
    			System.out.println(this.conn.isClosed());	//是否连接成功,false 代表成功
    			
    			
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	//增刪改
    	public int update(String sql) {
    		System.out.println("sql:"+sql);
    		try {
    			this.stmt=this.conn.createStatement();
    			return this.stmt.executeUpdate(sql);		//返回 影响 了几行	
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return -1;		
    	}
    	//查询方法
    	public ResultSet query(String sql) {
    		System.out.println("sql:"+sql);
    		try {
    			this.stmt=this.conn.createStatement();
    			return this.stmt.executeQuery(sql);
    		}catch(SQLException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    }
    

    2)测试——增删改、查询数据库中数据

    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Scanner;
    
    public class Main1 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner get=new Scanner(System.in);
    		DB db=new DB();
    		while(true) {
    			System.out.println("1.注册");
    			System.out.println("2.修改密码");
    			System.out.println("3.删除用户");
    			System.out.println("4.显示用户");
    			System.out.println("0.退出");
    			String t=get.next();
    			
    			if("1".equals(t)) {//添加
    				System.out.print("用户名:");
    				String uname=get.next();
    				System.out.print("密码:");
    				String upass=get.next();
    				String sql="INSERT INTO users VALUES (null,'"+uname+ "','" +upass+ "')";
    				int res=db.update(sql);
    				if(res==1) {
    					System.out.println("注册成功");
    				}else {
    					System.out.println("注册失败");
    				}
    			}else if("2".equals(t)) {//修改
    				System.out.print("用户名:");
    				String uname=get.next();
    				System.out.print("新密码:");
    				String newPass=get.next();
    				String sql="UPDATE users set upass='"  +newPass+  "' WHERE uname='"  +uname+  "' ";
    				int res=db.update(sql);
    				if(res>0) {
    					System.out.println("修改成功");
    				}else {
    					System.out.println("修改失败");
    				}
    			}else if("3".equals(t)) {//删除
    				System.out.println("输入id:");
    				String uid=get.next();
    				String sql="DELETE FROM users WHERE uid ="+uid+"";
    				int res=db.update(sql);
    				if(res>0) {
    					System.out.println("删除成功");
    				}else {
    					System.out.println("删除失败");
    				}
    			}else if("0".equals(t)) {
    				break;
    			}else if("4".equals(t)) { //显示用户
    				String sql="SELECT *FROM users";
    				ResultSet rs=db.query(sql);
    				try {
    					while(rs.next()) {
    						String deptno=rs.getString(1);
    						String dname=rs.getString(2);
    						String loc=rs.getString(3);
    						System.out.println(deptno+"\t"+dname+"\t"+loc);
    					}
    				}catch(SQLException e) {
    					e.printStackTrace();
    				}
    			}
    			
    		}
    		get.close();
    	}
    
    }
    
    
    展开全文
  • java创建数据库连接池代码

    千次阅读 2017-08-08 16:49:43
    数据库连接池(Connection pooling)是程序启动时建立足够的数据库连接,并将这些连接组成一个连接池,由程序动态地对池中的连接进行申请,使用,释放。  大家可以想一下,如果项目中没有数据库连接池会是一个什么...

           数据库连接池(Connection pooling)是程序启动时建立足够的数据库连接,并将这些连接组成一个连接池,由程序动态地对池中的连接进行申请,使用,释放。

           大家可以想一下,如果项目中没有数据库连接池会是一个什么样的结果?每访问一次数据库都会新建一个数据库连接,如果同事有成百上千的请求需要访问数据库那么项目会惨不忍睹。

           数据库连接池就是在项目启动是就已经创建了一定数量的数据库连接,有请求访问数据库时,不需要新建数据库连接,直接在连接池中拿就可以,用完了记得放到池子里面就行。这样的话,连接池中的数据库连接会不断的重复利用,大大提高了对数据库操作的性能。

    数据库连接池的运行机制有以下几点:

    1.程序启动时创建数据库连接池。

    2.使用连接时,从连接池中拿可用的数据库连接。

    3.使用完,将数据库连接放入数据库中。

    那么要想手动代码实现数据库连接池,需要哪些步骤了?下面会贴出源代码以及简单的注释。

    首先需要一个数据库连接池的配置文件jdbc.properties,内容如下:

    #驱动名称  
    jdbcDriver=com.mysql.jdbc.Driver  
    #连接URL  
    jdbcUrl=jdbc:mysql://localhost:3306/lcma  
    #数据库账户名  
    userName=root  
    #数据库密码  
    password=iflytek  
    #初始化连接数  
    initCount=10  
    #步进数量  
    stepSize=4  
    #最大连接池个数  
    poolMaxSize=150  
           既然是数据连接池,那么池子里面放的肯定是很多个数据库连接,一个数据库连接就是一个对象,建一个数据库连接类 PooledConnection.java代表数据库连接对象。类里面有个isBusy属性,用来表示该连接对象是否正在使用,若使用中用true表示,反之为false。代码如下:
    既然是数据连接池,那么池子里面放的肯定是很多个数据库连接,一个数据库连接就是一个对象,建一个数据库连接类 PooledConnection.java代表数据库连接对象。类里面有个isBusy属性,用来表示该连接对象是否正在使用,若使用中用true表示,反之为false。代码如下:

    package com.lcma.conn;
    
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    /**
     * <p>Title      : 存储连接池中对象属性</p>
     * <p>Description: [子应用名]_[模块名]</p>
     * <p>Copyright  : Copyright (c) 2016</p>
     * <p>Company    : 科大讯飞</p>
     * @author       : lcma
     * @version      : 1.0
     */
    public class PooledConnection {
    	
    	/**
    	 * 连接管道对象
    	 */
    	private Connection conn;
    	
    	/**
    	 * 连接状态,true-繁忙,false-空闲
    	 */
    	private boolean isBusy = false;
    	
    	public PooledConnection(Connection conn, boolean isBusy){
    		this.conn = conn;
    		this.isBusy = isBusy;
    	}
    	
    	public void close(){
    		this.isBusy = false;
    	}
    
    	public Connection getConn() {
    		return conn;
    	}
    
    	public void setConn(Connection conn) {
    		this.conn = conn;
    	}
    
    	public boolean isBusy() {
    		return isBusy;
    	}
    
    	public void setBusy(boolean isBusy) {
    		this.isBusy = isBusy;
    	}
    
    	/**
    	 * <p>Discription:创建查询方法,用于测试使用</p>
    	 * @param sql
    	 * @return
    	 * @author       : lcma
    	 * @update       : 2016年12月5日下午11:19:18
    	 */
    	public ResultSet queryBySql(String sql){
    		ResultSet rs = null;
    		Statement sm = null;
    		try {
    			sm = conn.createStatement();
    			rs = sm.executeQuery(sql);
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    		return rs;
    	}
    	
    	
    }
    创建连接池接口类,IMyPool.java
    package com.lcma.pools;  
      
    import com.lcma.conn.PooledConnection;  
      
    /** 
     * <p>Description: 连接池接口</p> 
     * <p>Copyright  : Copyright (c) 2017</p> 
     * @author       : lcma 
     * @version      : 1.0 
     */  
    public interface IMyPool {  
          
        /** 
         * <p>Discription:创建连接</p> 
         * @param count 
         * @author       : lcma 
         * @update       : 2016年12月4日下午1:11:46 
         */  
        public void createConnection(int count);  
          
        /** 
         * <p>Discription:获取连接</p> 
         * @return 
         * @author       : lcma 
         * @update       : 2016年12月4日下午1:11:34 
         */  
        public PooledConnection getConnection();  
      
    }
    实现连接池接口类,MyPoolImpl.java

    1.读取配置文件,创建连接池

    2.获取连接,判断是否有空闲的连接并且是有效的连接

    package com.lcma.pools.impl;  
      
    import java.io.IOException;  
    import java.io.InputStream;  
    import java.sql.Connection;  
    import java.sql.Driver;  
    import java.sql.DriverManager;  
    import java.sql.SQLException;  
    import java.util.Properties;  
    import java.util.Vector;  
      
    import com.lcma.conn.PooledConnection;  
    import com.lcma.pools.IMyPool;  
      
    /** 
     * <p>Title      : 连接池接口实现类</p> 
     * <p>Description: [子应用名]_[模块名]</p> 
     * <p>Copyright  : Copyright (c) 2016</p> 
     * <p>Company    : 科大讯飞</p> 
     * @author       : lcma 
     * @version      : 1.0 
     */  
    public class MyPoolImpl implements IMyPool {  
        /** 
         * 驱动名称 
         */  
        private String jdbcDriver;  
        /** 
         * 连接地址 
         */  
        private String jdbcUrl;  
        /** 
         * 用户名 
         */  
        private String userName;  
        /** 
         * 密码 
         */  
        private String password;  
        /** 
         * 初始化连接数 
         */  
        private int initCount;  
        /** 
         * 步进连接数 
         */  
        private int stepSize;  
        /** 
         * 最大连接数 
         */  
        private int poolMaxSize;  
          
        /** 
         * 连接池容器 
         */  
        private static Vector<PooledConnection> pooledConnections = new Vector<PooledConnection>();  
          
        /** 
         * 构造函数,执行初始化方法 
         */  
        public MyPoolImpl() {  
            init();  
        }  
          
        /** 
         * <p>Discription:初始化连接池</p> 
         * @author       : lcma 
         * @update       : 2016年12月5日下午8:42:37 
         */  
        private void init(){  
            InputStream is = this.getClass().getClassLoader().getResourceAsStream("jdbc.properties");  
            Properties pro = new Properties();  
            try {  
                pro.load(is);  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            jdbcDriver = pro.getProperty("jdbcDriver");  
            jdbcUrl = pro.getProperty("jdbcUrl");  
            userName = pro.getProperty("userName");  
            password = pro.getProperty("password");  
            initCount = Integer.parseInt(pro.getProperty("initCount"));  
            stepSize = Integer.parseInt(pro.getProperty("stepSize"));  
            poolMaxSize = Integer.parseInt(pro.getProperty("poolMaxSize"));  
              
            try {  
                Driver driver = (Driver)Class.forName(jdbcDriver).newInstance();  
                //将driver注册  
                DriverManager.registerDriver(driver);;  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            //创建连接  
            createConnection(initCount);  
        }  
      
        /** 
         * <p>Discription:创建连接</p> 
         * @param count 
         * @author       : lcma 
         * @update       : 2016年12月4日下午1:11:46 
         */  
        @Override  
        public void createConnection(int count) {  
            if(poolMaxSize<=0 || pooledConnections.size()+count > poolMaxSize){  
                System.out.println("创建连接失败,超过最大连接数");  
                throw new RuntimeException("创建连接失败,超过最大连接数");  
            }  
            try {  
                //循环创建连接  
                for(int i = 0; i < count; i++){  
                     //创建连接  
                    Connection connection = DriverManager.getConnection(jdbcUrl, userName, password);  
                    //实例化连接池中的连接  
                    PooledConnection pooledConnection = new PooledConnection(connection, false);  
                    //存入连接池容器  
                    pooledConnections.add(pooledConnection);  
                }  
             } catch (SQLException e) {  
                e.printStackTrace();  
            }  
              
        }  
      
        /** 
         * <p>Discription:获取连接</p> 
         * @return 
         * @author       : lcma 
         * @update       : 2016年12月4日下午1:11:34 
         */  
        @Override  
        public PooledConnection getConnection() {  
            if(pooledConnections.size()<=0){  
                System.out.println("获取连接失败,连接池为空");  
                throw new RuntimeException("获取连接失败,连接池为空");  
            }  
            PooledConnection connection = getRealConnection();  
            //判断是否为空  
            while(connection == null){  
                //创建connection,步进数  
                createConnection(stepSize);  
                //重新获取连接,有可能获取的还为空,采用while循环判断  
                getRealConnection();  
                //防止其他线程过来拿连接  
                try {  
                    Thread.sleep(300);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            return connection;  
        }  
          
        //判断我们是否拿到有效的连接对象  
        private synchronized PooledConnection getRealConnection(){  
            //先判断连接池是不是有我们需要的空闲连接对象  
            for(PooledConnection connection : pooledConnections){  
                //未处于繁忙状态  
                if(!connection.isBusy()){  
                    Connection conn = connection.getConn();  
                    try {  
                        //判断这个连接是不是有效,isValid就是创建了一个statement,执行sql语句,看是否成功  
                        if(!conn.isValid(2000)){  
                            Connection validConn = DriverManager.getConnection(jdbcUrl, userName, password);  
                            connection.setConn(validConn);  
                        }  
                    } catch (SQLException e) {  
                        e.printStackTrace();  
                    }  
                    //设置为繁忙  
                    connection.setBusy(true);  
                    return connection;  
                }  
            }  
            return null;  
        }  
      
        public String getJdbcDriver() {  
            return jdbcDriver;  
        }  
      
        public void setJdbcDriver(String jdbcDriver) {  
            this.jdbcDriver = jdbcDriver;  
        }  
      
        public String getJdbcUrl() {  
            return jdbcUrl;  
        }  
      
        public void setJdbcUrl(String jdbcUrl) {  
            this.jdbcUrl = jdbcUrl;  
        }  
      
        public String getUserName() {  
            return userName;  
        }  
      
        public void setUserName(String userName) {  
            this.userName = userName;  
        }  
      
        public String getPassword() {  
            return password;  
        }  
      
        public void setPassword(String password) {  
            this.password = password;  
        }  
      
        public int getInitCount() {  
            return initCount;  
        }  
      
        public void setInitCount(int initCount) {  
            this.initCount = initCount;  
        }  
      
        public int getStepSize() {  
            return stepSize;  
        }  
      
        public void setStepSize(int stepSize) {  
            this.stepSize = stepSize;  
        }  
      
        public int getPoolMaxSize() {  
            return poolMaxSize;  
        }  
      
        public void setPoolMaxSize(int poolMaxSize) {  
            this.poolMaxSize = poolMaxSize;  
        }  
      
      
    } 
    创建PoolManager类,利用内部类单例模式解决多线程问题, 多个线程在加载内部类的时候线程是互斥的 ,解决了线程安全问题。
    package com.lcma.manager;  
      
    import com.lcma.pools.impl.MyPoolImpl;  
      
    /** 
     * <p>Title      : 利用内部类单例模式解决多线程问题</p> 
     * <p>Description: [子应用名]_[模块名]</p> 
     * <p>Copyright  : Copyright (c) 2016</p> 
     * <p>Company    : 科大讯飞</p> 
     * @author       : lcma 
     * @version      : 1.0 
     */  
    public class PoolManager {  
          
        private static class creatPool{  
            private static MyPoolImpl poolImpl = new MyPoolImpl();  
        }  
          
        //多个线程在加载内部类的时候线程是互斥的,所以用单例模式的内部类形式避免线程混乱  
        public static MyPoolImpl getInstace(){  
            return creatPool.poolImpl;  
        }  
      
    } 
    测试类MyPoolMain,测试2000个线程同时请求数据库,程序应对自如,这就是数据库连接池的强大之处。
    package com.lcma.main;  
      
    import java.sql.ResultSet;  
    import java.sql.SQLException;  
      
    import com.lcma.conn.PooledConnection;  
    import com.lcma.manager.PoolManager;  
    import com.lcma.pools.impl.MyPoolImpl;  
      
    /**  
     * <p>Description: 测试类</p>  
     * <p>Copyright  : Copyright (c) 2017</p>  
     * @author       : lcma  
     * @version      : 1.0  
     */  
    public class MyPoolMain {  
          
        /**  
         * 获取连接池容器实现类  
         */  
        private static MyPoolImpl poolImpl = PoolManager.getInstace();  
          
        /**  
         * 单个连接查询测试  
         */  
        public synchronized static void selectData(){  
            PooledConnection connection = poolImpl.getConnection();  
            ResultSet rs = connection.queryBySql("select * from class");  
            try {  
                while(rs.next()){  
                    System.out.print(rs.getString("ID") + "\t\t");  
                    System.out.print(rs.getString("NAME") + "\t\t");  
                    System.out.print(rs.getString("TEACHER") + "\t\t");  
                    System.out.println();  
                }  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }finally {  
                try {rs.close();} catch (SQLException e) {e.printStackTrace();}  
                connection.close();  
            }  
        }  
          
        /**  
         * <p>Discription:测试2000个线程</p>  
         * @param args  
         * @author       : lcma  
         * @update       : 2016年12月5日下午11:44:18  
         */  
        public static void main(String[] args){  
            for (int i = 0; i < 2000; i++) {  
                new Thread(new Runnable() {  
                    public void run() {  
                        selectData();  
                        System.out.println();  
                    }  
                }).start();  
            }  
              
        }  
      
    } 

    注:上面代码只对功能做出实现,对代码规范性并没有做太高要求。


    展开全文
  • Java建立数据库连接

    千次阅读 2016-12-11 18:31:25
    这时就可以简单的在需要访问数据库是,就创建一个连接,用完后就关闭它,这样做也不会带来什么明显的性能上的开销。但是对于一个复杂的数据库引用,情况就完全不同了。频繁的建立、关闭连接,会极大的减低系统的性能...
  • 实现内容 通过idea开发工具实现对mysql数据库中某个数据库的某张表进行插入数据 操作步骤 ...2. 在官网中下载驱动包:mysql-connector-java-8.0.22.jar 3.将驱动包一般下载的zip压缩文件,解压后将m
  • Java进行数据库连接

    万次阅读 多人点赞 2017-10-20 12:48:55
    因为项目进展需要用到数据库,以前在使用C\C++进行数据库的操作的时候感觉还比较简单,但是在转到JAVA平台上的时候,发现步骤还比较繁琐,加之各种书本对JAVA安装数据库的步骤都写的模棱两可。 本教程针对已经安装好...
  • java获取数据库连接对象

    千次阅读 2016-11-06 13:29:25
    javaweb连接数据库
  • 第一步:创建数据库连接类 package com.dzsw.util; //先在lib下引入包:mysql-connector-java-5.1.39-bin.jar import java.sql.DriverManager; import java.sql.SQLException; import com.mysql.jdbc.Connectio...
  • Java数据库连接池实现原理

    万次阅读 多人点赞 2016-05-29 16:33:02
     ②通过jdbc建立数据库连接;  ③访问数据库,执行sql语句;  ④断开数据库连接。 public class DBConnection { private Connection con; //定义数据库连接类对象 private PreparedStatement pstm; pr
  • java JDBC数据库连接步骤

    千次阅读 2019-03-05 11:26:12
    JDBC(java database ...5.关闭数据库连接和数据集合 以上5点是连接数据库的一般步骤。 JDBC连接数据库: 1、JDBC所需的四个参数(user,password,url,driverClass) driverClass连接数据库所需的驱动。 什么是驱...
  • 本文详细演示FineReport客户端连接SQLServer(2000、2005等),常常会出现的错误:com.microsoft.sqlserver.jdbc.SQLServerException: 到主机的TCP/IP 连接失败的解决方案。
  • 如果你点开看到了这篇文章,说明你已经或多或少地通过学校学习亦或是自学了解了 oracle 数据库的基本用法。但是实际在开发程序的时候,我们是不可能手动地去操作...本文主要介绍的是Java连接数据库的技术 —— JDBC。
  • Java数据库连接工具类的编写

    千次阅读 2018-08-02 15:45:18
    Java数据库连接工具类的编写 步骤: 1. 定义变量 2. 通过反射进行读取配置文件 3. 实例化Properties读取配置文件中的各个属性 4. 关闭字节输入流 5. 类加载 6. 通过驱动管理的获取连接方法获取到连接...
  • java利用jdbc连接近程MySQL数据库详细步骤+数据库封装类 文章目录java利用jdbc连接近程MySQL数据库详细步骤+数据库封装类一、导connector包二、连接数据库1. 加载四大件之一 驱动(新版jdk可忽略)2. 连接数据库,三...
  • 众所周知,创建数据库连接需要消耗较多的资源,且创建时间也较长。如果网站一天100万PV(假设每个页面都有DB读取或修改操作),程序就需要创建100万次连接,极大的浪费资源。 事实上,同一时间需要创建数据库连接的...
  • JAVA访问数据库连接数据库

    千次阅读 2016-01-06 09:57:35
    只需要在第一次访问数据库时加载一次,然后每次运行时创建一个Connection实例,紧接着执行操作数据库的SQL语句,并处理返回的结果集,最后在完成完成此次操作时销毁前面创建的Connection,释放与数据库连接。...
  • 连接数据库的项目实例

    千次阅读 多人点赞 2018-08-14 22:37:35
    关键词:java,SQL Server 2012 后端 打开SQL Server 2012: 点击加号: 选中数据库,右键,新建数据库: 点击确定,等待片刻 选中数据库,右键,刷新,即可看到: 建表 ...
  • 连接步骤:步骤一创建数据库CREATE DATABASE line;CREATE TABLE customer( id INT, NAME VARCHAR(50), STATUS INT);INSERT INTO customer VALUES(1,'张三',0);INSERT INTO customer VALUES(2,'李四',0);INSERT ...
  • 连接数据库之前,首先要加载想要连接数据库的驱动到JVM 这通过java.lang.Class类的静态方法forName(String className)实现 成功加载后,会将Driver类的实例注册到DriverManager类中 二、提供JDBC连接的URL: ...
  • java数据库连接

    千次阅读 2017-01-04 17:31:33
    分享一段关于java数据库连接池的算法,希望对大家理解数据库连接池有帮助。大家也可以根据自身情况进行代码修改 (代码来源于网络) package com.csdn.test; import java.sql.Connection; import java.sql.Database...
  • 开始了, 第一步, 检查数据库判断账号是否存在并且密码...import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; /* 检查账号密码是否对, 实
  • Java DAO模式 数据库连接

    千次阅读 2018-04-17 00:01:23
    第一步:检查MySQL是否准备妥当首先检查mysql是否安装成功通过cmd进去mysql:以管理员身份运行cmd-&...查看MySQL中有哪些数据库以及表mysql 显示所有的数据库:https://blog.csdn.net/u01074636...
  • 通过读取配置文件中的数据库信息,该工具... * 获取数据库连接,返回一个Connection实例对象 */ import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverMan...
  • 创建lib目录, 导jar包, 添加为库,注意这个lib包, 一定要放在项目包下面, 我的放在QQQ下面, 暂时需要的jar包如下, ...连接数据库DriverManager 获得执行sql对象Statement 获得返回的结果集 释放连接 连接池用DBCP, .
  • Java 连接 MySQL 8.0 数据库

    千次阅读 2019-09-08 20:07:42
    Java 连接 MySQL 8.0 数据库 1. 准备 1.1 安装 Maven 的驱动包 首先在 pom.xml 的文件中添加如下内容。 <dependencies> <!-- 导入 MySQL 的Maven依赖 --> <dependency> <groupId>mysql...
  • Java实现数据库连接池例子

    千次阅读 2015-05-14 17:21:18
    Java实现数据库连接池例子 ====================== ConnectionPoolUtil.java package com.util; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.IOException; ...
  • java创建MySQL数据库连接

    千次阅读 2018-07-31 10:05:30
    注意,java接口是在win7下,MySQL是在RHEL下。 原理: 进程池的定义: 1、首先定义了一个...//存放连接池中数据库连接的向量。 2、connections=new Vector();connections.addElement(new PooledConnection(...
  • java maven项目连接mysql数据库

    千次阅读 2020-05-05 19:27:22
    在maven项目下新建class文件,...import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public static void main(String[] args) { Connection conn = null; ...
  • java web之数据库连接(使用JDBC连接sql server 2017)

    万次阅读 多人点赞 2018-06-08 15:35:53
    二、加载驱动程序并建立连接对象 一、安装JDBC驱动程序 下载SQL Server JDBC 驱动程序 6.0点击下载,这里我选择的是.exe版本,如下图: 点击Next-&amp;amp;amp;gt;下载完成后双击-&amp;amp;amp...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,046
精华内容 38,018
关键字:

java实例数据库连接失败

java 订阅