滴滴滴,新司机专用车道
如文章有不当之处,还请各位老司机多多指教.
*本文主要是说说如何利用容器来存放查询数据库的数据的,是一个比较简单的例子
一般来说有下面三种方式来进行存放数据:
1.封装到Object数组中
2.封装到List或者Map容器中(可以结合Object数组)
3.JavaBean对象中
有个好处就是,只需执行一遍查询操作即可一直存储查询到的数据,后期需要用什么数据,直接在JavaBean对象中,容器或者数组中取即可,比较方便
首先,在下面的例子中使用了一个JDBCUtils工具类和配置文件:db.properties,JDBCUtils工具类有建立数据库连接和关闭连接的功能,我先把这个工具类的代码和配置文件贴出来吧
配置文件如下,注意在配置时末尾不要有空格哦
工具类代码如下:
package com.jdbccnnection.test;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* JDBC工具类
* @author
*
*/
public class JDBCUtils {
public static Properties pros;
static {//加载配置文件,使用静态代码块,在类加载的时候此代码块只加载一次
pros = new Properties();
try {
pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 测试用的,测试是否能获取响应配置文件数据
* @return
*/
public static String getMysqlDriver() {
return pros.getProperty("mysqlDriver");
}
/**
* 建立并返回数据库连接对象
* @return
* @throws Exception
*/
public static Connection getConnection() throws Exception {
Class.forName(pros.getProperty("mysqlDriver"));
return DriverManager.getConnection(pros.getProperty("mysqlURL"), "mysqlUser", "mysqlPWD");
}
/**
* 关闭相应资源,下面使用重载
* @param r
* @param s
* @param c
*/
public static void close(ResultSet r,Statement s,Connection c) {
try {
if(r!=null)
r.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(s!=null)
s.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(c!=null)
c.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
*关闭相应资源, 重载
* @param r
* @param ps
* @param c
*/
public static void close(ResultSet r,PreparedStatement ps,Connection c) {
try {
if(r!=null)
r.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(ps!=null)
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(c!=null)
c.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void close(ResultSet r,PreparedStatement ps) {
try {
if(r!=null)
r.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(ps!=null)
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void close(ResultSet r,Statement s) {
try {
if(r!=null)
r.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(s!=null)
s.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
接下来我们就直接进入上面描述的第二种方式吧,结合了Object[]
一.封装到List或者Map容器中
废话不多说了,直接上例子:
package com.orm.test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 对数据库进行查询操作,并对查询的数据通过Object数组或者容器进行存储
* @author
*
*/
public class SimpleORM {
public static Connection conn = null;
public static PreparedStatement ps = null;
public static ResultSet rs = null;
/**
* 通过List容器和Object[]结合,存储查询到的数据库数据
*/
public static void firstDemo() {
List<Object[]> list = new ArrayList<>();
try {
//建立数据库连接
conn = JDBCUtils.getConnection();
//创建一个 PreparedStatement对象,用于将参数化的SQL语句发送到数据库。
ps = conn.prepareStatement("select st_id,st_name,st_age,st_info,st_time from studentstable where st_age>?");
//对占位符?进行赋值,这里是查询学生表中年龄大于16岁的学生信息
ps.setObject(1, 16);
//获取查询数据
rs = ps.executeQuery();
while(rs.next()) {
//由于查询的一组数据里面是5个数据,所以在Object[]数组的大小设为5
Object[] objs = new Object[5];
//把每一组数据都存到objs数组
objs[0] = rs.getObject(1);
objs[1] = rs.getObject(2);
objs[2] = rs.getObject(3);
objs[3] = rs.getObject(4);
objs[4] = rs.getObject(5);
//把每一个objs数组存放到list容器
list.add(objs);
}
//测试数据库数据是否添加到list容器,利用FOR循环遍历
for(Object[] objs :list) {
System.out.println("学生编号:"+objs[0]+"\t姓名:"+objs[1]
+"\t年龄:"+objs[2]+
"\t学生信息:"+objs[3]+
"\t入学时间:"+objs[4]);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//关闭连接
JDBCUtils.close(rs, ps,conn);
}
}
/**
*通过Map容器和Object[]结合,存储查询到的数据库数据
*/
public static void seconedDemo() {
Map<String,Object[]> map = new HashMap<String,Object[]>();
try {
//建立数据库连接
conn = JDBCUtils.getConnection();
//创建一个 PreparedStatement对象,用于将参数化的SQL语句发送到数据库。
ps = conn.prepareStatement("select st_id,st_name,st_age,st_info,st_time from studentstable where st_age>?");
//对占位符?进行赋值
ps.setObject(1, 16);
//获取查询数据
rs = ps.executeQuery();
while(rs.next()) {
//由于查询的一组数据里面是5个数据,所以在Object[]数组的大小设为5
Object[] objs = new Object[5];
//把每一组数据都存到objs数组
objs[0] = rs.getObject(1);
objs[1] = rs.getObject(2);
objs[2] = rs.getObject(3);
objs[3] = rs.getObject(4);
objs[4] = rs.getObject(5);
//把每一个objs数组存放到map容器,把st_name对应值作为key
map.put(rs.getString(2), objs);
}
//测试数据库数据是否添加到map容器,利用FOR循环遍历
for(String key:map.keySet()) {
Object[] objs = map.get(key);
System.out.println("学生编号:"+objs[0]+"\t姓名:"+objs[1]
+"\t年龄:"+objs[2]+
"\t学生信息:"+objs[3]+
"\t入学时间:"+objs[4]);
}
}catch (Exception e) {
// TODO: handle exception
}finally {
//关闭连接
JDBCUtils.close(rs, ps,conn);
}
}
public static void main(String[] args) {
SimpleORM.seconedDemo();
}
}
上面代码查询到的数据如下:
上面说了数组和容器的结合,那咱们接着来,试一试容器嵌套容器的方式来进行储存数据,老规矩,直接上代码,有图有真相
二.利用List和Map进行容器嵌套的形式储存
package com.orm.test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 使用容器嵌套容器来实现数据库数据的存储
* 比如:List容器里面嵌套Map
* Map容器里面嵌套Map
* @author 谭大川 Email:15281492615@163.com
*
*/
public class ORMContainer {
public static Connection conn = null;
public static PreparedStatement ps = null;
public static ResultSet rs = null;
/**
* List嵌套Map
*/
public static void firstTest() {
List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement("select st_id,st_name,st_age,st_info,st_time from studentstable where st_age>?");
//这里是查询学生表中年龄大于16岁的学生信息
ps.setObject(1, 16);
rs = ps.executeQuery();
while(rs.next()) {
Map<String,Object> row = new HashMap<>();
row.put("st_id", rs.getObject(1));
row.put("st_name", rs.getObject(2));
row.put("st_age", rs.getObject(3));
row.put("st_info", rs.getObject(4));
row.put("st_time", rs.getObject(5));
list.add(row);
}
/**
* 遍历循环的方式打印查询到的所有数据
* 在List容器中,一个Map对象代表一条查询信息
* 在Map容器中,存在多个键值对,分别对应表中的列
*/
for(Map<String,Object> row:list) {
for(String key:row.keySet()) {
System.out.print(key+":"+row.get(key)+"\t");
}
System.out.println();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
JDBCUtils.close(rs, ps, conn);
}
}
/**
* Map容器嵌套Map容器
*/
public static void secondTest() {
Map<String,Map<String,Object>> map = new HashMap<String,Map<String,Object>>();
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement("select st_id,st_name,st_age,st_info,st_time from studentstable where st_age>?");
ps.setObject(1, 16);
rs = ps.executeQuery();
while(rs.next()) {
Map<String,Object> row = new HashMap<String,Object>();
row.put("st_id", rs.getObject(1));
row.put("st_name", rs.getObject(2));
row.put("st_age", rs.getObject(3));
row.put("st_info", rs.getObject(4));
row.put("st_time", rs.getObject(5));
map.put(rs.getString(2), row);
}
for(String key:map.keySet()) {
Map<String,Object> row = map.get(key);
for(String rowKey:row.keySet()) {
System.out.print(rowKey+":"+row.get(rowKey)+"\t");
}
System.out.println();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//关闭连接
JDBCUtils.close(rs, ps,conn);
}
}
public static void main(String[] args) {
ORMContainer.firstTest();
}
}
上面代码查询到的数据如下:
接下来就用咱们开发中常用的JavaBean对象进行储存吧,废话不多说,有图有真相,直接上代码
三.封装到JavaBean对象中
1)根据需要查询的数据,建一个有相应属性的类,我mysql数据库中的表叫做studentstable,那这个类咱就叫做StudentsTable吧
package com.javabean.test;
import java.sql.Date;
/**
* bean对象,类成员属性和咱们sql查询语句的查询数据(或者数据库表中的数据)要对应上
* @author
*
*/
public class StudentsTable {
private int st_id;
private Date st_time;
private String st_name;
private String st_info;
private int age;
//根据需要添加对应的构造器
public StudentsTable(int st_id, String st_name, int age,String st_info,Date st_time) {
super();
this.st_id = st_id;
this.st_time = st_time;
this.st_name = st_name;
this.st_info = st_info;
this.age = age;
}
//添加set/get方法
public int getSt_id() {
return st_id;
}
public void setSt_id(int st_it) {
this.st_id = st_it;
}
public Date getSt_time() {
return st_time;
}
public void setSt_time(Date st_time) {
this.st_time = st_time;
}
public String getSt_name() {
return st_name;
}
public void setSt_name(String st_name) {
this.st_name = st_name;
}
public String getSt_info() {
return st_info;
}
public void setSt_info(String st_info) {
this.st_info = st_info;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
2)上面完成了bean对象,下面咱们可以进行数据操作了,对bean对象通过构造器进行赋值,也就是打数据储存在bean对象中,然后再把bean对象添加到map容器中就大功告成!
废话不多说,老规矩上代码,有图有真相:
package com.javabean.test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;
/**
* 一般查询的数据都是多条,因此也需要通过容器存储多个bean对象来实现多数据的储存
* @author
*
*/
public class JavaBeanTest {
//引入studentstable对象
private static StudentsTable st;
//创建容器,存储st对象,可以List,可以Map
private static Map<String,StudentsTable> map = new HashMap<String,StudentsTable>();
private static Connection conn= null;
private static PreparedStatement ps= null;
private static ResultSet rs = null;
public static Map<String,StudentsTable> getMap(){
try {
//1.建立连接
conn = JDBCUtils.getConnection();
//2.创建一个 PreparedStatement对象,用于将参数化的SQL语句发送到数据库。
ps = conn.prepareStatement("select st_id,st_name,st_age,st_info,st_time from studentstable where st_age>?");
//设置占位符?参数
ps.setObject(1, 16);
//3.获取查询数据
rs = ps.executeQuery();
while(rs.next()) {
st = new StudentsTable(rs.getInt(1), rs.getString(2), rs.getInt(3), rs.getString(4), rs.getDate(5));
map.put(rs.getString(2), st);//把学生的名字作为key
}
return map;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//关闭连接
JDBCUtils.close(rs, ps,conn);
}
return null;
}
public static void main(String[] args) {
//测试一下,map容器中是否已经将带有查询数据的bean对象添加进来
Map<String,StudentsTable> test = JavaBeanTest.getMap();
//在容器中获取名字叫:精神小伙 的学生的信息
StudentsTable student = test.get("精神小伙");
//打印精神小伙的信息
System.out.println("st_id:"+student.getSt_id()+
"\tst_name:"+student.getSt_name()
+"\tst_age:"+student.getAge()
+"\tst_info:"+student.getSt_info()
+"\tst_time:"+student.getSt_time());
}
}
上面代码,打印出的精神小伙的信息如下:
好了,本文也该到此结束了,需要改进的地方还请大家不吝赐教哈,最后给大家来一张靓图养养眼,放松放松,嘿嘿