精华内容
下载资源
问答
  • 详细记载了数据的引用,java连接数据库步骤,让小白的你更好学习!要执行SQL语句,必须获得java.sql.Statement实例,Statement实例分为以下3 种类型: 1、执行静态SQL语句。通常通过Statement实例实现。 2、...
  • 以下的文章主要描述的是java连接MYSQL数据库的正确操作步骤,在此篇文章里我们主要是以实例列举的方式来引出其具体介绍
  • java连接数据库步骤

    万次阅读 多人点赞 2019-03-17 19:51:08
    Class.forname(数据库驱动名); 2.建立数据库连接 使用DriverManager类的getConnection()静态方法来获取数据库连接对象,其语法格式如下所示: Connection conn=DriverManager.getConnection(String url,String ...

    1.加载驱动

    Class.forname(数据库驱动名);

    2.建立数据库连接

    使用DriverManager类的getConnection()静态方法来获取数据库连接对象,其语法格式如下所示:

    Connection conn=DriverManager.getConnection(String url,String user,String pass);

    其中url--数据库连接字符串.

    user---数据库的用户名

    pass---数据库密码

    3.创建Statement对象

    对数据库进行操作或访问时,需要使用sql语句,在Java语言中,sql语句通过Statement对象进行封装,发送给数据库。Statement对象不是通过Statement类直接创建的,而是通过Connection对象所提供的方法来创建各种Statement对象。

    Statement smt=Connection.createStatement();

    4.执行sql语句

    获取Statement对象之后,就可以调用该对象的不同方法来执行sql语句,所有Statement都有以下三种执行sql语句的方法,具体哪一种方法由sql语句所产生的结果来决定。

    如果sql语句运行后能产生结果集,Statement对象则将结果集封装成ResultSet查询语句,并返回一个ResultSet结果集对象。

    5.关闭数据库

    (1)关闭结果集

    (2)关闭Statement对象

    (3)关闭连接

    连接mysql数据库代码如下:

    package practice;
    import java.sql.*;
    import java.util.Collection;
    public class test1 {
    	public static void main(String args[])
    	{
    		String driver="com.mysql.jdbc.Driver";
    		String user="root";
    		String password="数据库密码";
    		String url="jdbc:mysql://localhost:3306/typesql";
    		try{
    			//加载数据库驱动
    			Class.forName(driver);
    			//连接数据库
    			Connection conn=DriverManager.getConnection(url,user,password);
    			System.out.println("连接成功!");
    			//创建Statement对象
    			Statement stmt=conn.createStatement();
    			//建立结果集
    			ResultSet rs=stmt.executeQuery("SELECT id,username FROM userdetails");
    			System.out.println("查询成功!");
    			while(rs.next()) {
    				System.out.println(rs.getString(1)+" "+rs.getString("username"));
    			}
    			//关闭结果集
    			rs.close();
    			//关闭Statement对象
    			stmt.close();
    			//关闭数据库
    			conn.close();
    		}catch(ClassNotFoundException e){
    			e.printStackTrace();
    		}catch(SQLException e) {
    			e.printStackTrace();
    		}
    	}
    }

     

    展开全文
  • 写这个文章的原因是为了巩固自己连接数据库步骤 二.MySQL数据库连接 数据库连接步骤加载驱动程序,获取数据库连接对象 2.1驱动jar包 2.2代码 package cn.sg.xx.test; import java.sql.Connection; import java.sql....
  • 本文主要介绍了Java连接Oracle数据库和MySQL数据库步骤解析。具有很好的参考价值,需要的朋友一起来看下吧
  • 以下是对java连接mysql数据库的具体详细步骤进行了分析介绍,需要的朋友可以过来参考下
  • java连接数据库步骤详情,适合学习数据库的新手使用
  • 该总结主要是总结了java数据库的应用,并介绍了java数据库的增、删、改、查等操作功能。并且文档清楚步骤明确易懂,很适合开始学的人。总结内也有各种关键代码适用于一些之前学过又忘了一些代码的人。
  • Java连接MySQL数据库步骤

    万次阅读 多人点赞 2019-08-31 17:10:47
    Java连接MySQL数据库步骤 声明,只推荐你看代码学会我的步骤,逻辑,还有用的所有方法 第一, ​ 安装mysql数据库配置(https://www.jianshu.com/p/ea4accd7afb4),安装还有配置教程,按照步骤来肯定没错,里面是...

    Java连接MySQL数据库步骤

    声明,只推荐你看代码学会我的步骤,逻辑,还有用的所有方法

    第一,

    ​ 安装mysql数据库配置(https://www.jianshu.com/p/ea4accd7afb4),安装还有配置教程,按照步骤来肯定没错,里面是win10的mysql解压版安装教程,设置账号密码是一定要注意 :账号一般为root,密码一般为 123456 ,如果你要更改的话一定要记住,因为后面连接需要用到(切记),如果忘了会很麻烦。

    第二,

    ​ 如果是新手的话推荐学一下mysql的语法,认真的话一个星期学会绝对没问题(菜鸟教程网站),学会基本的查询当前电脑有的数据库,使用数据库,创建数据库,创建表,查看数据库中的表,还有对表的增删改查语法,新手不推荐使用视图软件,要记住操作mysql的代码,可以先在 cmd 黑框框中写操作数据库的代码。

    如果要用视图软件的话推荐下一个navicat破解版,自己用可以,不能商用。

    第三,

    ​ 下来就要用java编译器连接数据库了(java连接数据库又叫JDBC)。

    mysql提供的第三方java包,里面配置了连接java连接mysql的默认配置和驱动

    链接:https://pan.baidu.com/s/1Z_ztiTEGloX7r3ilZoZsCg
    提取码:0f1s

    创建项目->

    在这里插入图片描述

    创建文件夹起名为lib(把上面下载的包复制到lib文件夹下,直接复制粘贴就好了)->

    在这里插入图片描述

    鼠标右击复制过来的包导入项目导为jar包(在后面写连接代码时可以直接用)->

    在这里插入图片描述
    在这里插入图片描述

    导入成功是这样子
    在这里插入图片描述

    创建两个包,一个存放连接数据库的代码,一个存放数据库中的表信息(pojo)

    com.pojo在这个包里创建的类用来存放你的表中字段,存放实体类,必须满足javaBean(一个表就是一个类,类中属性就是表中字段)
    在这里插入图片描述

    连接步骤(这个很重要)(代码中都有注释):

    1.导jar包,前面已经导过了

    2.在连接类里写代码,加载mysql驱动(要写在代码块里,因为要连接必须最先加载驱动),代码块在加载类时就执行,在构造方法之前(注意是代码块{},不是方法)

    //连接信息	
    private String userName = "root";//这里是你最开始刚下载mysql是输入的账号
    	private String password = "123456";//这里是你最开始mysql设置的密码,
    	private String url = "jdbc:mysql://localhost:3306/testdatabase";
    //数据库连接信息,
    //第一个是java连接数据库协议,中间的是要连接的ip地址和端口号,localhost是本地ip,后面的是你要连接的数据库的名字,我要连接数据库的名字叫testdatabase
    	
    
    
    {
    		try {
        	//这里不用更改,如果你要连的不是mysql的话再换这个括号内的代码
    			Class.forName("com.mysql.jdbc.Driver");
    			System.out.println("驱动加载成功!");
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			System.out.println("加载失败!");
    			e.printStackTrace();
    		}
    
    }

    3.创建连接数据库(这里在构造方法里连接)

    public DataBaseConnection() {
    		// TODO Auto-generated constructor stub
    		try {
    			this.connection =  DriverManager.getConnection(url, userName, password);//把上面的三个属性传过来,应该就连接成功了,不成功的话应该就是你的账号密码不正确
    			System.out.println("数据库连接成功!");
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			System.out.println("连接失败!");
    		}
    	}

    4.第四步就是操作数据库了

    这里写一个往数据库里增加数据的代码

    创建方法名叫insert

    先想步骤

    ​ 1.写sql语句(就是你们在菜鸟教程里学的sql语句),菜鸟教程是个非常好的网站

    ​ 2.从连接中获得操作数据库句柄

    ​ 3.设置参数

    ​ 4.就是执行sql语句了

    //这里传一个类对象参数Emp emp,就相当于String str 差不多
    //都是引用数据类型,类,数组,接口
    public void insert(Emp emp){
    		//1.写sql语句
    		String str = "INSERT emp VALUES (?,?,?,?,?,?,?,?)";
    		PreparedStatement ps = null;
    		//2.获取操作数据库句柄
    		try {
    			//把操作数据库返回的结果保存到ps中
    			ps = connection.prepareStatement(str);

    		//3.设置参数
    		ps.setInt(1, emp.getEmpno());
    		ps.setString(2, emp.getEname());
    		ps.setString(3, emp.getJob());
    		ps.setInt(4, emp.getMgr());
    		ps.setDate(5, emp.getDate());
    		ps.setInt(6, emp.getSal());
    		ps.setInt(7, emp.getComm());
    		ps.setInt(8, emp.getDeptno());
    		
    		//4.执行sql语句
    		int len = ps.executeUpdate();
    		System.out.println("修改成功,共影响了"+ len +"行!");
    	} catch (SQLException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}finally{
    		if(ps != null){
    			try {
    				ps.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    
    	//关闭数据库的方法
    	public void closeConnection(){
    		if(connection != null){
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    

    我的Emp类,就是我存放数据库中emp表中字段的类(你要按照你的数据库中字段来创建类)

    ​ private Integer empno;//因为Integer类型可以判断是否为空
    ​ private String ename;
    ​ private String job;
    ​ private Integer mgr;
    ​ private Date hiredate;
    ​ private Integer sal;
    ​ private Integer comm;
    ​ private Integer deptno;

    public Emp() {
    	// TODO Auto-generated constructor stub
    }
    
    //创建有参构造方法,方便赋值
    public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Integer sal, Integer comm,
    		Integer deptno) {
    	super();
    	this.empno = empno;
    	this.ename = ename;
    	this.job = job;
    	this.mgr = mgr;
    	this.hiredate = hiredate;
    	this.sal = sal;
    	this.comm = comm;
    	this.deptno = deptno;
    }
    
    
    public Integer getEmpno() {
    	return empno;
    }
    
    public void setEmpno(Integer empno) {
    	this.empno = empno;
    }
    
    public String getEname() {
    	return ename;
    }
    
    public void setEname(String ename) {
    	this.ename = ename;
    }
    
    public String getJob() {
    	return job;
    }
    
    public void setJob(String job) {
    	this.job = job;
    }
    
    public Integer getMgr() {
    	return mgr;
    }
    
    public void setMgr(Integer mgr) {
    	this.mgr = mgr;
    }
    
    public Date getHiredate() {
    	return hiredate;
    }
    
    public void setHiredate(Date hiredate) {
    	this.hiredate = hiredate;
    }
    
    public Integer getSal() {
    	return sal;
    }
    
    public void setSal(Integer sal) {
    	this.sal = sal;
    }
    
    public Integer getComm() {
    	return comm;
    }
    
    public void setComm(Integer comm) {
    	this.comm = comm;
    }
    
    public Integer getDeptno() {
    	return deptno;
    }
    
    public void setDeptno(Integer deptno) {
    	this.deptno = deptno;
    }
    //重写toString方法,方便测试,因为输出的是一个对象的话,java默认调用toString方法
    @Override
    public String toString() {
    	return "Emp [empno=" + empno + ", ename=" + ename + ", job=" + job + ", mgr=" + mgr + ", date=" + hiredate
    			+ ", sal=" + sal + ", comm=" + comm + ", deptno=" + deptno + "]";
    }

    最后创建一个测试类(Test),包含main方法,在main方法里写

    在这里插入图片描述

    
    
    	DataBaseConnection dbs = null;
    
    try{
    
    	//创建连接数据库类对象
    
    	dbs = new DataBaseConnection();
    
    	//创建你的表类对象,表类对象就是你存放在pojo中的类,存放表中字段的类,例如我的类为Emp
    
    	//把类中的属性赋值
    
    	Emp emp = new Emp8889, "刘备", "股东", 0, new    							Date(System.currentTimeMillis()), 110, 1000000, 100);                   
    
    	//调用你写的insert类,里面把类对象传进去
    
    	 dbs.insert(emp);
    
    }finally{
    
    //奥,对了,为了防止资源浪费,不管你程序执没执行成功,你都必须关闭数据库
    
    	//需要在你的连接类中写一个关闭数据库的方法
    
    	//上面的代码中我又添加上了,就不用你写了
    
    	dbs.closeConnection();
    
    }

    最后你再查看你数据库中表中数据应该就插入了一条记录。

    ​ 再次强调,只推荐你看代码学会我的步骤,逻辑,还有用的所有方法,千万不要拷贝拿去用,因为就算你跟我的一模一样,你还是不懂。

    ​ 如果学习过程中有什么麻烦就请加我qq交流。

    作者qq:1271224158

    展开全文
  • 主要为大家介绍了Java连接MYSQL数据库的详细步骤,感兴趣的小伙伴们可以参考一下
  • java JDBC连接数据库步骤及代码

    万次阅读 多人点赞 2018-12-06 09:34:01
    JDBC连接数据库,包含7个步骤 (1)加载JDBC驱动程序 在连接数据库之前,首先要加载想要连接的数据库的驱动到JVM(Java虚拟机), 这通过java.lang.Class类的静态方法forName(String className)实现,成功加载后...

    JDBC连接数据库,包含7个步骤

    (1)加载JDBC驱动程序   

        在连接数据库之前,首先要加载想要连接的数据库的驱动到JVM(Java虚拟机),   这通过java.lang.Class类的静态方法forName(String className)实现,成功加载后,会将Driver类的实例注册到DriverManager类中。

    代码如下:

    static{
    		try {
    			Class.forName("com.mysql.jdbc.Driver");//加载数据库驱动
    			}
    		catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}

    (2)提供JDBC连接的URL

        书写形式:协议:子协议:数据源标识   。 其中:

         协议:在JDBC中总是以jdbc开始 。子协议:是桥连接的驱动程序或是数据库管理系统名称。   数据源标识:标记找到数据库来源的地址与连接端口。

    代码如下:

    //连接MySql数据库,用户名和密码都是root   
         String url = "jdbc:mysql://localhost:3306/test" ;    
         String username = "root" ;   
         String password = "root" ;   

    (3)创建数据库的连接   

    代码如下:

     public static Connection getConn(){
        	 Connection conn = null;
        	 try {
        		conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root","root");//连接数据库	
        		 }
             catch(SQLException e){
        		 e.printStackTrace();
        	 }
        	 return conn;
     }

    (4)创建一个Statement

        要执行SQL语句,必须获得java.sql.Statement实例,Statement实例分为以下3 种类型:

    •     执行静态SQL语句。通常通过Statement实例实现。
    •     执行动态SQL语句。通常通过PreparedStatement实例实现。
    •     执行数据库存储过程。通常通过CallableStatement实例实现。

    代码如下:

     public static Statement getStmt(Connection conn){
    	   Statement stmt = null;
    	   try {
    		stmt = conn.createStatement();
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
    	   return stmt;
       }

    (5)执行SQL语句

        Statement接口提供了三种执行SQL语句的方法:executeQuery 、executeUpdate   和execute  

    •     ResultSet executeQuery(String sqlString):执行查询数据库的SQL语句   ,返回一个结果集(ResultSet)对象。
    •     int executeUpdate(String sqlString):用于执行INSERT、UPDATE或   DELETE语句以及SQL DDL语句,如:CREATE TABLE和DROP TABLE等  
    •     execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的   语句。

    代码如下:

     public static ResultSet executeQuery(Statement stmt,String sql){
    	 ResultSet rs = null;
    	 try {
    		rs = stmt.executeQuery(sql);
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
    	return rs; 
     }
     

    (6)处理结果   

        两种情况:  

    •     执行更新返回的是本次操作影响到的记录数。  
    •     执行查询返回的结果是一个ResultSet对象。  

         ResultSet包含符合SQL语句中条件的所有行,并且它通过一套get方法提供了对这些行中数据的访问。

        使用结果集(ResultSet)对象的访问方法获取数据,代码如下:

    while(rs.next()){             
        String name = rs.getString("name") ;        
        String pass = rs.getString(1) ; // 此方法比较高效         
    }

    (7)关闭JDBC对象

        操作完成以后要把所有使用的JDBC对象全都关闭,以释放JDBC资源,关闭顺序和声明顺序相反:

    •     关闭记录集
    •     关闭声明  
    •     关闭连接对象

    代码如下:

    //关闭结果集
     public static void closeRs(ResultSet rs){
    	   try {
    			if(rs != null ){
    				 rs.close();
    				 rs = null;
    			   }
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} 
     }
    //关闭执行方法
     public static void closeStmt(Statement stmt){
    	   try {
    			if(stmt != null ){
    				 stmt.close();
    				 stmt = null;
    			   }
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} 
    	   
       }
    //关闭连接
     public static void closeConn(Connection conn){
    	   try {
    		if(conn != null ){
    			 conn.close();
    			 conn = null;
    		   }
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
     }

    JDBC连接数据库工具类代码

    package com.njau.allnetitem;
    
    import java.sql.*;
    
    public class DB {
    	static{
    		try {
    			Class.forName("com.mysql.jdbc.Driver");//加载数据库驱动
    			}
    		catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}
    	
     private DB() {}
     
     public static Connection getConn(){
        	 Connection conn = null;
        	 try {
        		conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db_baima", "root","123456");//连接数据库	
        		 }
             catch(SQLException e){
        		 e.printStackTrace();
        	 }
        	 return conn;
     }
     
     public static void closeConn(Connection conn){
    	   try {
    		if(conn != null ){
    			 conn.close();
    			 conn = null;
    		   }
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
     }
       
     public static Statement getStmt(Connection conn){
    	   Statement stmt = null;
    	   try {
    		stmt = conn.createStatement();
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
    	   return stmt;
       }
       
     public static PreparedStatement getPStmt(Connection conn,String sql){
    	   PreparedStatement pstmt = null;
    	   try {
    		pstmt = conn.prepareStatement(sql);
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
    	   return pstmt;
       }
       
     public static void closeStmt(Statement stmt){
    	   try {
    			if(stmt != null ){
    				 stmt.close();
    				 stmt = null;
    			   }
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} 
    	   
       }
       
     public static ResultSet executeQuery(Statement stmt,String sql){
    	 ResultSet rs = null;
    	 try {
    		rs = stmt.executeQuery(sql);
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
    	return rs; 
     }
     
     public static void closeRs(ResultSet rs){
    	   try {
    			if(rs != null ){
    				 rs.close();
    				 rs = null;
    			   }
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} 
     } 
     
     public static ResultSet executeQuery(Connection conn,String sql){//重载
    	 ResultSet rs = null;
    	 try {
    		rs = conn.createStatement().executeQuery(sql);
    	} catch (SQLException e) {
    		e.printStackTrace();
    	}
    	return rs;  
       } 
     }

    工具类使用说明代码

    //插入数据
    public static void saveinfo(Object[] data) throws ParseException{
    	Connection conn = null;
    	PreparedStatement pstmt = null;
    try {
        conn= DB.getConn();
    	String sql = "insert into information value (null,?,?,?,?,?,?,?) ";
        pstmt = DB.getPStmt(conn, sql);
    	pstmt.setString(1,(String) data[0]);
    	pstmt.setString(2, (String) data[1]);
    	pstmt.setString(3,(String) data[2]);
    	pstmt.setString(4,(String) data[3]); 
    	pstmt.setString(5,(String) data[4]);
    	pstmt.setString(6,(String) data[5]);
    	pstmt.setTimestamp(7 ,(Timestamp)data[6]);
    	pstmt.executeUpdate();
    	} 
    	catch (SQLException e) {
    		e.printStackTrace();
    	}
        finally{
        	DB.closeStmt(pstmt);
        	DB.closeConn(conn);
        }
    }

    参考:

    http://www.cnblogs.com/hongten/archive/2011/03/29/1998311.html

    表示感谢!!

    展开全文
  • java操作数据库的几种方式

    千次阅读 2020-04-21 09:44:18
    历史就是一面镜子 回顾自己开发的历程,见证了...Java数据库连接,全称是Java Database Connectivity,简称JDBC,是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中...

    历史就是一面镜子

    回顾自己开发的历程,见证了时代变迁史记,下面我针对java连接数据库的方式说起

    0 原生jdbc

    先普及下jdbc,怕新入行的人早已沉浸在包装库和框架中,甚至都没用过原生jdbc。

    Java数据库连接,全称是Java Database Connectivity,简称JDBC,是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。百科这样解释的Java数据库连接

    开发人员要做的几个步骤:

    开发步骤:

      1、注册驱动.,告知JVM使用的是哪一个数据库的驱动

      2、获得连接.,使用JDBC中的类,完成对MySQL数据库的连接

      3、获得语句执行平台,通过连接对象获取对SQL语句的执行者对象

      4、执行sql语句,使用执行者对象,向数据库执行SQL语句  获取到数据库的执行后的结果

      5、处理结果

      6、释放资源.

    注意写代码之前,要导入数据库驱动包,连接不同厂商的数据库要用不同的驱动包

    对应的驱动包 

    新建项目,普通的java项目就行,导入第三方jar太简单了,自行百度

    示例代码如下:

    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Properties;
    
    import com.mysql.jdbc.ResultSetMetaData;
    
    /**
     * 
     * @author dgm
     * @describe "原生jdbc"
     * @date 2020年4月13日
     */
    public class MysqlTest {
    	// JDBC 驱动名及数据库 URL
    	static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
    	static final String DB_URL = "jdbc:mysql://192.168.8.200:3306/bdrackdemo?useUnicode=true&characterEncoding=utf8&autoReconnect=true";
    	// 数据库的用户名与密码,需要根据自己的设置
    	static final String USER = "root";
    	static final String PASS = "cstorfs";
    	static Properties prop = new Properties();
    
    	//读取数据库配置文件
    	static void readDBSetting(String path) {
    		// Properties prop = new Properties();
    		// 读取属性文件mysql.properties
    		InputStream in = null;
    		try {
    			in = new BufferedInputStream(new FileInputStream(path));
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		try {
    			prop.load(in);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} // /加载属性列表
    		Iterator<String> it = prop.stringPropertyNames().iterator();
    		while (it.hasNext()) {
    			String key = it.next();
    			System.out.println(key + "=" + prop.getProperty(key));
    		}
    		try {
    			in.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		// return prop;
    	}
    
    	public static void main(String[] args) {
    		// 读取mysql 配置信息
    		readDBSetting("conf/mysql.properties");
    
    		Connection conn = null;
    		Statement stmt = null;
    		ResultSet rs = null;
    		try {
    			// 注册 JDBC 驱动
    			Class.forName(prop.getProperty("dbDriver")).newInstance();
    
    			// 打开链接
    			System.out.println("连接数据库...");
    			conn = DriverManager
    					.getConnection(
    							"jdbc:mysql://"
    									+ prop.getProperty("mysqlhost")
    									+ ":"
    									+ prop.getProperty("mysqlport")
    									+ "/"
    									+ prop.getProperty("dbname")
    									+ "?useUnicode=true&characterEncoding=utf8&autoReconnect=true",
    							prop.getProperty("mysqluser"),
    							prop.getProperty("mysqlpwd"));
    
    			// 执行查询
    			System.out.println(" 实例化Statement对象...");
    			stmt = conn.createStatement();
    			String sql = "SELECT id, username, number FROM student";
    			rs = stmt.executeQuery(sql);
    
    			// 展开结果集数据库
    			while (rs.next()) {
    				// 输出数据
    				System.out.print("用户id: " + rs.getInt("id"));
    				System.out.print(", 用户名: " + rs.getString("username"));
    				System.out.print(", 学号: " + rs.getString("number"));
    				System.out.print("\n");
    			}
    		} catch (SQLException se) {
    			// 处理 JDBC 错误
    			se.printStackTrace();
    		} catch (Exception e) {
    			// 处理 Class.forName 错误
    			e.printStackTrace();
    		} finally {
    			// 关闭资源
    			try {
    				if (rs != null)
    					rs.close();
    			} catch (SQLException se3) {
    			}// 什么都不做
    			// 关闭资源
    			try {
    				if (stmt != null)
    					stmt.close();
    			} catch (SQLException se2) {
    			}// 什么都不做
    			try {
    				if (conn != null)
    					conn.close();
    			} catch (SQLException se) {
    				se.printStackTrace();
    			}
    		}
    	}
    }

    查询结果

    恩早期开发就是这么过来,只是自己封装成了JDBC工具,于具体的业务开发人员要写大量的SQL语句,调用时这样的

     看上去此种开发模式也很好,只要规模不大,此方式还很好,瓶颈在于数据库连接,现在也不是问题了,社会在进步,池化技术出现了。

    池化简单点说就是预先连接好一定数量的连接,等需要时随意从中选择一个进行操作。略了,当时主要用的tomcat自带的池化技术,此时获取数据库连接的代码就变成了这样核心伪代码(tomcat要做些配置):

    //构造函数
    	public DataAccess(String poolName) 
    	{
    		this.poolName = poolName;
    		
    		this.JNDI = "java:comp/env/" + poolName;
    	}
    
    	//获取数据库连接
    	private void setConnection() throws Exception 
    	{
    		Config config = Config.getConfig();
    
    		if ( config.getWebserver().equals("tomcat")  )
    		{
    			Context ctx = new InitialContext();
    
    			DataSource ds = (DataSource)ctx.lookup(JNDI);
               
                //获取数据库连接
    			this.conn = ds.getConnection();
    		} else
             {
            //其他server
           }
    		
    	}

    普及下JNDIhttps://baike.baidu.com/item/JNDI/3792442?fr=aladdin,现在也难见到了,很多框架越来越傻瓜式了

     

    1.  hibernate来了

    Hibernate是一种ORM框架,全称为 Object_Relative DateBase-Mapping,在Java对象与关系数据库之间建立某种映射,以实现直接存取Java对象。

    想不明白为啥没有mybatis发展的好,看来拉拢技术人员搞社区还是很重要的。

    很遗憾,没有保留以前的老项目,没有自己的电脑,也没有申请github。

    看了下网上已有很多教程了:https://www.w3cschool.cn/hibernate/skzl1idz.html,就不多说什么,重点关注架构、缓存、事务和拦截器。重点代码

           //获取加载配置管理类
            Configuration configuration = new Configuration();
    
            //不给参数就默认加载hibernate.cfg.xml文件,
            configuration.configure();
    
            //创建Session工厂对象
            SessionFactory factory = configuration.buildSessionFactory();
    
            //得到Session对象
            Session session = factory.openSession();
    
            //使用Hibernate操作数据库,都要开启事务,得到事务对象
            Transaction transaction = session.getTransaction();
    
            //开启事务
            transaction.begin();
    
            //把对象添加到数据库中
            //session.save(user);
            //数据库操作略
    
            //提交事务
            transaction.commit();
    
            //关闭Session
            session.close();

     

    2. mybatis也来了,来的更猛

    用的时间稍微长久些,没办法,谁让它势头发展的好,也有大厂强烈支持。

    mybatis简介https://baike.baidu.com/item/MyBatis/2824918?fr=aladdin,算是hibernate的竞争者

    我看网上也有了类似教程,MyBatis 教程 https://www.w3cschool.cn/mybatis/

    重点也是关注架构、缓存和事务

    简单demo如下:

    package spring.dao
    
    public interface MybatisDao {
    	List<HashMap> selectUser();
    }
    
    public class MybatisDaoImpl implements MybatisDao {
    
    	public SqlSession sqlSession;
    
        public MybatisDaoImpl(SqlSession sqlSession) {
            this.sqlSession = sqlSession;
        }
        
    	@Override
    	public List<HashMap> selectUser() {
    		// TODO Auto-generated method stub
    		return this.sqlSession.selectList("spring.dao.MybatisDao.selectUser");
    	}
    }
    
    //测试代码
    public class MybatisTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try {
    
    			System.out.println("开始mybatis实验");
    			MybatisDao userDao;
    			SqlSession sqlSession;
    
    			String resource = "conf/mybatis-config.xml";
    			InputStream inputStream = Resources.getResourceAsStream(resource);
    			SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
    					.build(inputStream);
    			sqlSession = sqlSessionFactory.openSession();
    			userDao = new MybatisDaoImpl(sqlSession);
    			List<HashMap> userList = userDao.selectUser();
    			for (HashMap user : userList) {
    				System.out.println(user);
    			}
    			sqlSession.close();
    
    			System.out.println("结束mybatis实验");
    
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    }

    配置文件三个如下

     mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    
    <!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
    
        <properties resource="conf/mysql.properties" />
        
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC" />
                <dataSource type="POOLED">
                    <property name="driver" value="${mybatis.driver}" />
                    <property name="url" value="${mybatis.url}" />
                    <property name="username" value="${mybatis.username}" />
                    <property name="password" value="${mybatis.password}" />
                </dataSource>
            </environment>
        </environments>
    
        <mappers>
            <mapper resource="conf/mybatisMapper.xml" />
        </mappers>
    
    </configuration>

    myBatisMapper.xml文件内容

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <!-- mapper:根标签,namespace:命名空间,一般保证命名空间唯一 -->
    <mapper namespace="spring.dao.MybatisDao">
       <!-- statement,内容:sql语句。id:唯一标识,在同一个命名空间下保持唯一
          resultType:sql语句查询结果集的封装类型
        -->
       <select id="selectUser" resultType="java.util.Map">
         SELECT id, username, number FROM student
       </select>
    </mapper>

     数据库配置mysql.properties

    #MySQL for mybatis
    mybatis.driver=com.mysql.jdbc.Driver
    mybatis.url=jdbc:mysql://192.168.8.200:3306/bdrackdemo?useUnicode=true&characterEncoding=utf8&autoReconnect=true
    mybatis.username=root
    mybatis.password=cstorfs

    执行测试代码效果:

    注意配置型的文件不能放错位置,要么就改加载属性文件的代码,记得导入数据库驱动包和mybatis.jar

     

    缓存分两种,一级缓存和二级缓存。

    一级缓存 Mybatis的一级缓存是指SQLSession,一级缓存的作用域是SQlSession, Mabits默认开启一级缓存。 在同一个SqlSession中,执行相同的SQL查询时;第一次会去查询数据库,并写在缓存中,第二次会直接从缓存中取。 当执行SQL时候两次查询中间发生了增删改的操作,则SQLSession的缓存会被清空。 每次查询会先去缓存中找,如果找不到,再去数据库查询,然后把结果写到缓存中。 Mybatis的内部缓存使用一个HashMap,

     public class PerpetualCache implements Cache {
    
      private final String id;
    
      //是个map对象
      private final Map<Object, Object> cache = new HashMap<>();
    
      public PerpetualCache(String id) {
        this.id = id;
      }
    
      @Override
      public String getId() {
        return id;
      }
    
      @Override
      public int getSize() {
        return cache.size();
      }
    
      @Override
      public void putObject(Object key, Object value) {
        cache.put(key, value);
      }
    }
    

    key为hashcode+statementId+sql语句。Value为查询出来的结果集映射成的java对象。 SqlSession执行insert、update、delete等操作commit后会清空该SQLSession缓存。

    一级缓存的几种情况:

    第一种情况:同个session进行两次相同查询

    结论:MyBatis只进行1次数据库查询。

     

     第二种情况:同个session进行两次不同的查询

    结论:MyBatis进行两次数据库查询。

    第三种:不同session,进行相同查询。

    结论:MyBatis进行两次数据库查询。

    第四种情况:同个session,查询之后更新数据,再次查询相同的语句

    直接下结论了:更新操作之后缓存会被清除

    小结:一级缓存是SqlSession级别的缓存,Mybatis默认是开启一级缓存的,当调用SqlSession的修改、添加、删除、commit()、close()等方法时,就会清空一级缓存。

    二级缓存

    之所以称之为“二级缓存”,是相对于“一级缓存”而言的。既然有了一级缓存,那么为什么要提供二级缓存呢?我们知道,在一级缓存中,不同session进行相同SQL查询的时候,是查询两次数据库的。显然这是一种浪费,既然SQL查询相同,就没有必要再次查库了,直接利用缓存数据即可,这种思想就是MyBatis二级缓存的初衷。

    另外,Spring和MyBatis整合时,每次查询之后都要进行关闭sqlsession,关闭之后数据被清空。所以MyBatis和Spring整合之后,一级缓存是没有意义的。如果开启二级缓存,关闭sqlsession后,会把该sqlsession一级缓存中的数据添加到mapper namespace的二级缓存中。这样,缓存在sqlsession关闭之后依然存在。

    默认情况下,MyBatis只启用了本地的会话缓存,它仅仅对一个会话中的数据进行缓存,见: MyBatis一级缓存介绍 。要启用全局的二级缓存,只需要在SQL映射文件中添加一行:

    <cache/>

    二级缓存是Mapper级别的缓存,多个SqlSession去操作同一个Mapper的sql语句,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的。

    上面这个简单语句的效果如下:

    映射语句文件中的所有 select 语句的结果将会被缓存。
    映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
    缓存会使用最近最少使用算法(LRU, Least Recently Used)算法来清除不需要的缓存。
    缓存不会定时进行刷新(也就是说,没有刷新间隔)。
    缓存会保存列表或对象的1024个引用。
    缓存会被视为读/写缓存,这意味着获取到的对象并不是共享的,可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。

    这些属性可以通过 cache 元素的属性来修改。比如:

    <cache
      eviction="FIFO"
      flushInterval="60000"
      size="512"
      readOnly="true"/>

    这个更高级的配置创建了一个 FIFO 缓存,每隔 60 秒刷新,最多可以存储结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此对它们进行修改可能会在不同线程中的调用者产生冲突。

    可用的清除策略有:

    LRU – 最近最少使用:移除最长时间不被使用的对象。
    FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
    SOFT – 软引用:基于垃圾回收器状态和软引用规则移除对象。
    WEAK – 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象。
    默认的清除策略是 LRU。

    flushInterval(刷新间隔)属性可以被设置为任意的正整数,设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置,也就是没有刷新间隔,缓存仅仅会在调用语句时刷新。

    size(引用数目)属性可以被设置为任意正整数,要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

    readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会(通过序列化)返回缓存对象的拷贝。 速度上会慢一些,但是更安全,因此默认值是 false。

    提示:二级缓存是事务性的。这意味着,当 SqlSession 完成并提交时,或是完成并回滚,但没有执行 flushCache=true 的 insert/delete/update 语句时,缓存会获得更新。

    小结: 二级缓存是mapper映射级别的缓存,默认是不开启的,多个SqlSession去操作同一个Mapper映射的sql语句是共用二级缓存的,二级缓存是跨SqlSession的。

    框架前几部分都是属性文件解析,构造工厂,生产产品做真正的事

    记一次使用mybatis使用出现的排序问题: ${}和 #{}的区别

    由于开始时排序字段,特别是分页查询时,传的参数有第几页,每页几条记录,排序字段,是动态设置的,有时从前端传来,按某些个字段排序

    /**
    	 * 学生查询考试任务列表
    	 * @param user
    	 * @param pageSize
    	 * @param pageNumber
    	 * @param status,试卷状态(0-N, 1. 未发布,可编辑修改和删除, 2. 已发布,可查看和停用, 3. 已结束,可审阅, 默认为0代表所有状态)
    	 * @param name, 试卷名字模糊查询
          * @param sortOrder, 排序字段
    	 * @return
    	 */
    	@SuppressWarnings({ "rawtypes", "unchecked" })
    	@RequestMapping(value = "/list", method = RequestMethod.GET, produces = "application/json; charset=utf-8")
    	@LoginRequired
    	@CrossOrigin
    	public JSONObject list(@CurrentUser User user,
    			@RequestParam(value = "pageSize", required = false, defaultValue = "10")Integer pageSize, 
    			@RequestParam(value = "pageNumber", required = false, defaultValue = "1")Integer pageNumber, 
    			Integer status, 
    			@RequestParam(value = "name", required = false, defaultValue = "") String name,
    			@RequestParam(value = "sortOrder", required = false, defaultValue = " cp.id desc ") String sortOrder)

    就是这个sortOrder 

     

    大致就这样了,每个人都可以接着扩展开发。框架性迭代总是这样,xml到json,sql写在xml文件里到如今通过注解实现(spring也是如此,早期都是xml大量配置,如今也转换到注解配置),框架越来越包装了,愿每个码农都把基础学好,再学框架,不要一上来就mybatis,据说新码农都没写过原生servlet,更别提开发了。。。

    总结:

    自己早年封装的jdbc组件,简单易用,适合小规模化开发,主要当时技术受限,大量数据库连接没处理好,没有池化和缓存策略,且对码农的sql功底很强,其实面向SQL编程

    hibernate,个人觉得一个很不错得到orm框架,脱离了部分sql,只是没推广好

    mybatis ,从架构上来说和hibernate雷同,生态圈建立的好,也有大厂光环。

    汇总一句话:再好的orm,也脱离不了最最最基本的JDBC,劝扎进框架圈里的人,务必打好基础,框架各有千秋,没有最好,只要合适!!!

     

    参考:

    0. Develop Java applications with Oracle Database   https://www.oracle.com/database/technologies/appdev/jdbc.html

    1.  程序员的SQL金典https://github.com/dongguangming/java/blob/master/%E7%A8%8B%E5%BA%8F%E5%91%98%E7%9A%84SQL%E9%87%91%E5%85%B8.pdf

    2.  JNDI数据库连接池配置 https://www.iteye.com/blog/xiaoliang330-978823

    3   Hibernate入门这一篇就够了  

    4. Java Mybatis框架入门教程  http://c.biancheng.net/mybatis/

    5. JDBC Example – MySQL, Oracle https://www.journaldev.com/2471/jdbc-example-mysql-oracle

    展开全文
  • 一个在线2k的游戏,每秒钟并发都吓死人。传统的hibernate直接插库基本上是不可行的。我就一步步推导出一个无锁的数据库操作,详情看下
  • Java访问数据库的具体步骤

    千次阅读 2018-06-08 15:28:40
    1.加载(注册)数据库驱动加载就是把各个数据库提供的访问数据库的API加载到我们程序...下面看一下一些主流数据库的JDBC驱动加裁注册的代码://Oracle8/8i/9iO数据库(thin模式)Class.forName("oracle.jdbc.driv...
  • 1、加载JDBC驱动程序 2、提供JDBC连接的URL 3、创建数据库的连接 4、创建一个Statement 5、执行SQL语句 6、处理结果 7、关闭JDBC对象
  • Java - 阐述JDBC操作数据库步骤

    万次阅读 2019-03-16 10:47:30
    分享一个大牛的人工智能...下面的代码以连接本机的Oracle数据库为例,演示JDBC操作数据库步骤。 加载驱动。 Class.forName("oracle.jdbc.driver.OracleDriver"); 创建连接。 Connection con = Dr...
  • 该rar包中包括MOngoDB数据库操作基本的增删改查,以及在CMD命令行中怎么配置MOngodb和增删改查,还有就是连接mongoDB的jar包和详细的操作文档,本来想上传NOde.js来着,可是只能上传60兆,只能放弃了,不过这些已经...
  • java JDBC数据库连接步骤

    千次阅读 2019-03-05 11:26:12
    JDBC(java database connect)顾名思义:是一种java连接数据库的方式 1.定义驱动和数据库字符串 2.注册驱动 3.连接数据库 4.数据库操作 5.关闭数据库连接和数据集合 以上5点是连接数据库的一般步骤。 JDBC连接...
  • java访问数据库主要用的方法是JDBC,它是java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法, 1.加载(注册)数据库 Class.forName(...
  • 是连接数据库操作,及连接代码,处理异常的方法。
  • 主要介绍了Java中使用JDBC操作数据库简单实例,本文以Mysql为例介绍使用Java JDBC操作数据库的6个步骤,需要的朋友可以参考下
  • java访问数据库步骤

    千次阅读 2019-03-15 20:30:48
    第二部:通过驱动管理器获得与数据库的连接对象(该对象为与数据库相通的管道) 第三步:通过Connection对象获取封装了sql的PreparedStatement对象(封装了已经预编译的sql语句,效率高) 第四步:执行sql语句 第五...
  • 很详细的java连接数据库的步骤Java数据库 数据库连接 jdbc
  • java 中访问数据库步骤

    千次阅读 2018-03-15 18:44:09
    1.导入连接数据库的Jar包2.创建连接数据库对象Connection3.创建Statement对象4.执行SQL语句5.返回结果集6.对结果集用对象封装7.关闭数据库连接
  • Eclipse:java连接数据库MySQL 首先我们需要下载连接数据库所需要的桥JDBC。然后将其导入到项目中,其次编写连接数据库类。 下载MySQL JDBC 打开MySQL JDBC下载地址,然后根据自己电脑系统下载相对应的JDBC版本。...
  • java如何连接数据库的五步骤(图文讲解)

    万次阅读 多人点赞 2019-10-29 00:12:18
    JDBC的全称是Java DataBase Connectivity,是一套面向对象的连接数据库的程序接口。JDBC技术主要完成以下几个任务: 1、与数据库建立一个连接。 2、向数据库发送SQL语句。 3、处理从数据库返回的结果。 事实上,JDBC...
  • java连接数据库步骤

    千次阅读 2015-11-14 20:11:53
    •创建一个以JDBC连接数据库的程序,包含7个步骤:  1、加载JDBC驱动程序:  在连接数据库之前,首先要加载想要连接的数据库的驱动到JVM(Java虚拟机),  这通过java.lang.Class类的静态方法forName...
  • JDBC操作数据库步骤

    千次阅读 2019-01-05 09:19:40
    JDBC操作数据库步骤 1.加载JDBC驱动程序 在连接数据库前,首先要加载要连接数据库的驱动到Java虚拟机,通过java.lang.Class类的静态方法forName(String className)实现。例如,通过构造方法加载SQL Server2000: ...
  • a)eclipse:开发java程序(配置环境变量方法自行查阅) b)mysql数据库:(官网下载,尽量不要下载最新版),注意开启服务, 开启服务的方法— —右键单击桌面"此电脑"——点击"管理"——按照下...
  • Java——JDBC连接数据库步骤详解!!!)

    万次阅读 多人点赞 2020-05-30 17:17:28
    JDBC的全称是:Java Database Connectivity,即Java数据库连接。 JDBC可以通过载入不同的数据库的“驱动程序”而与不同的数据库进行连接。 那么,在数据库连接的时候,我使用的是MySQL,Java集成开发环境是Eclipse...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 312,067
精华内容 124,826
关键字:

java操作数据库的步骤

java 订阅