JDBC—ORM基本思想

ORM(Object Relationship Mapping)的基本思想
 
– 表结构跟类对应； 表中字段和类的属性对应；表中记录和对象对应；

– 让javabean的属性名和类型尽量和数据库保持一致！

– 一条记录对应一个对象。将这些查询到的对象放到容器中(List,Set,Map)

• 将表中的一条记录封装到Object数组中

• 将表中的一条记录封装到map中

• 将表中一条记录封装到javabean对象中

资源文件：db.properties

mysqlDriver=com.mysql.jdbc.Driver
mysqlURL=jdbc\:mysql\://localhost\:3306/sorm?useUnicode\=true&characterEncoding\=UTF-8
mysqlUser=123456
mysqlPwd=123456

oracleDriver=oracle.jdbc.driver.OracleDriver
oracleURL=jdbc\:oracle\:thin\:@localhost\:1521\:orcl
oracleUser=scott
oraclePwd=tiger

JDBC连接的封装

public class JDBCUtil {
	
	// 读取资源文件，借助 Properties 类
	static Properties pros = null;	 // 可以帮助读取和处理资源文件中的信息
	
	// 静态代码块：JDBCUtil类被加载时只会执行一次
	// 因为整个应用读取一次资源文件就可以了，所以写一个静态代码块(因为这个JDBCUtil类只会被加载一次)
	static {	// 加载JDBCUtil类的时候调用
		pros = new Properties();
	
		try {
		
			// 获得资源文件的输入流(通过输入流读取进来)
			pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
//	// 获取连接，不使用资源文件
//	public static Connection getMysqlConn() {
//		try {
//			Class.forName("com.mysql.jdbc.Driver");
//			return DriverManager.getConnection(
//					"jdbc:mysql://localhost:3306/testjdbc?useUnicode=true&characterEncoding=UTF-8", "root", "root");
//		} catch (Exception e1) {
//			e1.printStackTrace();
//			return null;
//		}
//	}
	
	// 通过使用资源文件(db.properties)获取连接
	// 使用资源文件的好处：以后如果数据库有变动(比如库要改、用户密码要改，源码这里就不用动了，只用改资源文件就可以了)
	public static Connection getMysqlConn() {
		try {
			Class.forName(pros.getProperty("mysqlDriver"));
			return DriverManager.getConnection(pros.getProperty("mysqlURL"),
					pros.getProperty("mysqlUser"), pros.getProperty("mysqlPwd"));
		} catch (Exception e1) {
			e1.printStackTrace();
			return null;
		}
	}
	
	// 获取 Oracle 连接
	public static Connection getOracleConn() {
		try {
			Class.forName(pros.getProperty("oracleDriver"));
			return DriverManager.getConnection(pros.getProperty("oracleURL"),
					pros.getProperty("oracleUser"), pros.getProperty("oraclePwd"));
		} catch (Exception e1) {
			e1.printStackTrace();
			return null;
		}
	}
	
	// 写三个重载关闭的方法，方便以后重用
	public static void close(ResultSet rs,Statement ps,Connection conn) {
		try {
			if (ps != null) {
				ps.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			if (rs != null) {
				rs.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	public static void close(Statement ps,Connection conn) {
		try {
			if (ps != null) {
				ps.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	public static void close(Connection conn) {
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

将表中的一条记录封装到Object数组中

使用Object[]来封装一条记录

/*
 * 使用Object[]来封装一条记录
 */
public class Demo01 {
	public static void main(String[] args) {
		Connection conn = JDBCUtil.getMysqlConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		Object[] objs = null;
		try {
			ps = conn.prepareStatement("select empname,salary,age from emp where id=?");
			ps.setObject(1, 1);
			rs = ps.executeQuery();
			objs = new Object[3];	// 一个Object数组封装了一条记录的信息！
			while(rs.next()) {
				// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//				System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
			
				// 经过一个循环后一条记录就放到 Object 数组中了
				objs[0] = rs.getString(1);
				objs[1] = rs.getString(2);
				objs[2] = rs.getString(3);
			}
			// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
			
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JDBCUtil.close(rs, ps, conn);
		}
		System.out.println(""+objs[0]+objs[1]+objs[2]);
	}
}

使用List<Object[]>存储多条记录

/*
 * 使用List<Object[]>存储多条记录
 */
public class Demo01_1 {
	public static void main(String[] args) {
		Connection conn = JDBCUtil.getMysqlConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		List<Object[]> list = new ArrayList<Object[]>();
		try {
			ps = conn.prepareStatement("select empname,salary,age from emp where id>?");
			ps.setObject(1, 1);
			rs = ps.executeQuery();
			
			while(rs.next()) {
				Object[] objs = new Object[3];	// 一个Object数组封装了一条记录的信息！
				// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//				System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
			
				// 经过一个循环后一条记录就放到 Object 数组中了
				objs[0] = rs.getString(1);
				objs[1] = rs.getString(2);
				objs[2] = rs.getString(3);
				
				list.add(objs);
			}
			// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.close(rs, ps, conn);
		}
		for (Object[] objs : list) {
			System.out.println("" + objs[0] + objs[1] + objs[2]);
		}
	}
}

将表中的一条记录封装到map中

使用Map来封装一条记录
使用List

/*
 * 使用Map来封装一条记录
 * 使用List<Map>，Map<Map>存储多条记录
 */
public class Demo02 {
	
	// 使用Map来封装一条记录
	public static void test01() {
		Connection conn = JDBCUtil.getMysqlConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		Map<String, Object> row = new HashMap<String, Object>();  // 使用一个Map封装一条记录
		try {
			ps = conn.prepareStatement("select empname,salary,age from emp where id=?");
			ps.setObject(1, 1);
			rs = ps.executeQuery();
			
			while(rs.next()) {
				// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//				System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
				
				row.put("empname", rs.getObject(1));
				row.put("salary", rs.getObject(2));
				row.put("age", rs.getObject(3));
			}
			// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.close(rs, ps, conn);
		}
		
		// 遍历Map,就是遍历这一行的多列的信息
		for (String key : row.keySet()) {
			System.out.print(key+"--"+row.get(key)+"\t");
		}
		System.out.println();
	}
	
	// 使用List<Map>存储多条记录
	public static void test02() {
		Connection conn = JDBCUtil.getMysqlConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		try {
			ps = conn.prepareStatement("select empname,salary,age from emp where id>?");
			ps.setObject(1, 1);
			rs = ps.executeQuery();
			
			while(rs.next()) {
				// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//				System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
				Map<String, Object> row = new HashMap<String, Object>();  // 使用一个Map封装一条记录
				row.put("empname", rs.getObject(1));
				row.put("salary", rs.getObject(2));
				row.put("age", rs.getObject(3));
				list.add(row);
			}
			// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.close(rs, ps, conn);
		}
		
		// 一个Map就是一条记录
		for (Map<String, Object> row : list) {
			// 遍历Map,就是遍历这一行的多列的信息
			for (String key : row.keySet()) {
				System.out.print(key + "--" + row.get(key) + "\t");
			}
			System.out.println();
		}
	}
	
	// 使用Map<Map>存储多条记录
		public static void test03() {
			Connection conn = JDBCUtil.getMysqlConn();
			PreparedStatement ps = null;
			ResultSet rs = null;
			// 用列名做key
			Map<String,Map<String, Object>> maps = new HashMap<String,Map<String, Object>>();
			try {
				ps = conn.prepareStatement("select empname,salary,age from emp where id>?");
				ps.setObject(1, 1);
				rs = ps.executeQuery();
				
				while(rs.next()) {
					// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//					System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
					Map<String, Object> row = new HashMap<String, Object>();  // 使用一个Map封装一条记录
					row.put("empname", rs.getObject(1));
					row.put("salary", rs.getObject(2));
					row.put("age", rs.getObject(3));
					maps.put(rs.getString(1), row);
				}
				// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
				
			} catch (SQLException e) {
				e.printStackTrace();
			} finally {
				JDBCUtil.close(rs, ps, conn);
			}
			
			// 一个Map就是一条记录
			for (String empname:maps.keySet()) {
				// 遍历Map,就是遍历这一行的多列的信息
				Map<String, Object> row = maps.get(empname);
				for (String key:row.keySet()) {
					System.out.print(key + "--" + row.get(key) + "\t");
				}
				System.out.println();
			}
		}
	public static void main(String[] args) {
		// 使用Map来封装一条记录
		System.out.println("使用Map来封装一条记录,如下！");
		test01();
		
		// 使用List<Map>存储多条记录
		System.out.println("使用List<Map>存储多条记录,如下！");
		test02();
		System.out.println("使用Map<Map>存储多条记录,如下！");
		test03();
	}
}

将表中一条记录封装到javabean对象中

// 表结构对应类结构，方便维护
public class Dept {	  //表结构和类对应
	
	// 每一个字段对应一个对象的属性
	// 类型也对应
	private Integer id;
	private String dname;
	private String address;
	
	// 一个完整的Javabean构造器。要有set和get方法，以及无参的构造器！
	public Dept() {
		
	}
	
	public Dept(String dname, String address) {
		super();
		this.dname = dname;
		this.address = address;
	}

	public Dept(Integer id, String dname, String address) {
		super();
		this.id = id;
		this.dname = dname;
		this.address = address;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDname() {
		return dname;
	}
	public void setDname(String dname) {
		this.dname = dname;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	
}

//表结构对应类结构，方便维护
public class Emp {	 //表结构和类对应
	// 每一个字段对应一个对象的属性
	// 类型也对应
	private Integer id;
	private String empname;
	private Double salary;
	private Date birthday;
	private Integer age;
	private Integer deptId;
	
	// 构造器
	// 一个完整的Javabean构造器。要有set和get方法，以及无参的构造器！
	public Emp() {
		
	}
	
	public Emp(String empname, Double salary, Integer age) {
		super();
		this.empname = empname;
		this.salary = salary;
		this.age = age;
	}

	public Emp(String empname, Double salary, Date birthday, Integer age, Integer deptId) {
		super();
		this.empname = empname;
		this.salary = salary;
		this.birthday = birthday;
		this.age = age;
		this.deptId = deptId;
	}
	
	public Emp(Integer id, String empname, Double salary, Date birthday, Integer age, Integer deptId) {
		super();
		this.id = id;
		this.empname = empname;
		this.salary = salary;
		this.birthday = birthday;
		this.age = age;
		this.deptId = deptId;
	}

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getEmpname() {
		return empname;
	}
	public void setEmpname(String empname) {
		this.empname = empname;
	}
	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Integer getDeptId() {
		return deptId;
	}
	public void setDeptId(Integer deptId) {
		this.deptId = deptId;
	}
	
}

使用Javabean对象来封装一条记录
使用List存储多条记录

/*
 * 使用Javabean对象来封装一条记录
 * 使用List<Javabean>存储多条记录
 */
public class Demo03 {
	
	// 使用Javabean对象来封装一条记录
	public static void test01() {
		Connection conn = JDBCUtil.getMysqlConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		// 定义一个对象Emp;
		Emp emp = null;
		try {
			ps = conn.prepareStatement("select empname,salary,age from emp where id=?");
			ps.setObject(1, 1);
			rs = ps.executeQuery();
			
			while(rs.next()) {
				// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//				System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
				
				emp = new Emp(rs.getString(1),rs.getDouble(2),rs.getInt(3));
			}
			// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.close(rs, ps, conn);
		}
		
		System.out.println(emp.getEmpname()+"-"+emp.getSalary()+"-"+emp.getAge());
	}
	
	// 通过Emp对象把一行记录封装到一个bean对象里面，在放到list里
	public static void test02() {
		Connection conn = JDBCUtil.getMysqlConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		List<Emp> list = new ArrayList<Emp>();
		try {
			ps = conn.prepareStatement("select empname,salary,age from emp where id>?");
			ps.setObject(1, 1);
			rs = ps.executeQuery();
			
			while(rs.next()) {
				// 不管是 rs.getString还是rs.getDouble还是rs.getInt都是一个对象
//				System.out.println(rs.getString(1)+"--"+rs.getDouble(2)+"--"+rs.getInt(3));
				
				Emp emp = new Emp(rs.getString(1),rs.getDouble(2),rs.getInt(3));
				list.add(emp);
			}
			// 把数据放到数组里面就可以进行管理引用了(尽管这个连接关闭了，不过还是可以从数组中获取信息)
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.close(rs, ps, conn);
		}
		
		// 遍历List,就是遍历这一行的多列的信息
		// 每一行对应一个emp对象
		for (Emp emp : list) {
			System.out.println(emp.getEmpname()+"-"+emp.getSalary()+"-"+emp.getAge());
		}
	}
	
	public static void main(String[] args) {
		// 使用Javabean对象来封装一条记录
		test01();
		// 通过Emp对象把一行记录封装到一个bean对象里面，在放到list里
		test02();
	}
}