ORM使用容器存放数据库查询数据

最新推荐文章于 2022-07-15 15:24:25 发布

秋水•长天

最新推荐文章于 2022-07-15 15:24:25 发布

阅读量362

点赞数

分类专栏：数据库笔记笔记文章标签： mysql sql 数据库

本文链接：https://blog.csdn.net/weixin_42891528/article/details/107291315

版权

笔记同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

数据库笔记

5 篇文章 0 订阅

订阅专栏

滴滴滴,新司机专用车道
如文章有不当之处,还请各位老司机多多指教.

*本文主要是说说如何利用容器来存放查询数据库的数据的,是一个比较简单的例子

一般来说有下面三种方式来进行存放数据:
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());
	}
	
}

上面代码,打印出的精神小伙的信息如下:
在这里插入图片描述

好了,本文也该到此结束了,需要改进的地方还请大家不吝赐教哈,最后给大家来一张靓图养养眼,放松放松,嘿嘿
在这里插入图片描述

秋水•长天

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
ORM使用容器存放数据库查询数据

滴滴滴,新司机专用车道如文章有不当之处,还请各位老司机多多指教.*本文主要是说说如何利用容器来存放查询数据库的数据的,是一个比较简单的例子一般来说有下面三种方式来进行存放数据:1.封装到Object数组中2.封装到List或者Map容器中(可以结合Object数组)3.JavaBean对象中有个好处就是,只需执行一遍查询操作即可一直存储查询到的数据,后期需要用什么数据,直接在JavaBean对象中,容器或者数组中取即可,比较方便首先,在下面的例子中使用了一个JDBCUtils工具类和配置文件
复制链接

扫一扫