员工管理系统-3-01-04-2015
一、理论知识
1、dao层设计：接口设计
dao层：定义
http://blog.csdn.net/zdwzzu2006/article/details/6053006
http://zhidao.baidu.com/link?url=g1DQfQmFLNZ7cwq2s-4V30nIOk_jCzzQUNYTkepV1w6F_1aBioNrFbwG97KxwwWAeSwvPUF4Nd87LaDlg21E1q
2、反射的作用：单独一篇
a、JAVA的反射是指，可以通过一个类名来探察这个类里面的信息，比如说类的属性名，属性名的修饰符，方法名，方法返回值，方法修饰符等等，反正除了方法体得不到，其他都可以用反射得到；反射还可以生成类的实例，通过这个实例定义属性，调用方法，特别是能调用私有的属性和私有的方法，是不是很强大啊
b、JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：在运行时判定任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判定任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
http://blog.csdn.net/ritterliu/article/details/7764849
3、StringBuilder：
StringBuffer：
我的理解是用来拼接字符串的，由两个方法：append() 和 insert() 方法
http://blog.csdn.net/rmn190/article/details/1492013
备注：substring；
4、XML文件：用于存储数据。比如今天的例子：表与操作的关系、类的名称和表的名称、类属性的名称和表的列名关系。
5、在对数据库进行操作的时候，要尽量延迟获取数据库连接（准备好所有准备工作在获取连接），尽早释放数据连接。
6、再次提一下吧：jdbc是根据现有的数据库技术所提炼出来的java访问数据库标准，而不是java提供技术数据库实现。数据库根据java标准接口所实现的是驱动程序。
jdbc不会对数据库的性能所带来提高，因为jdbc仅仅是java访问数据库的标准。
7、事物：数据库的概念
a、特性：原子性：要么都执行要么都不执行，不存在一半执行一半不执行。比如我们选择的几条一起执行的sql语句就有原子性
一致性：同一条语句在所有的情况下执行的结果是一致的
隔离性：
持续性：对数据库的影响是持续的
jdbc采用的是默认的事务提交方式。
conn.setAutoCommit(false); conn.rollback();//数据库事务b、查询一般不加事务，因为查询不会影响数据库内部的数据，加了事务会使数据库的性能要下降。
c、connection对数据库操作：API介绍：与特定数据库的连接（会话）。在连接上下文中执行 SQL 语句并返回结果。
D、事务保存点（save point）：
Savepoint sp = conn.SetSavepoint; connection.rollback(sp); conn.commit();//回滚保存点后要提交(一定要加提交事务的语句，否则将不会回滚)数据库的事务概念8、事务（JTA）：跨多个数据源的事务，使用JTA容器。
9、可串行化、可序列化：serializable
应该是关于文件这块的内容，可序列化就是将其转换成字节码形式，或者是流文件
http://blog.csdn.net/yakihappy/article/details/3979373
二、今天所写的代码
建立与数据库表对应的类：员工表
public class Stuff {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
部门表：
public class Dept {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
建立一个数据库连接的类：
import java.sql.*;
public class JdbcUtils {
static String url = "jdbc:mysql://localhost:3306/StuffInformation";
static String user = "root";
static String password = "root";
static{
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static Connection getConnection() throws SQLException{
return DriverManager.getConnection(url, user, password);
}
public static void close(Connection conn,Statement st,ResultSet rs) throws SQLException {
try {
if(rs!=null)
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
if(st!=null)
st.close();
} catch (SQLException e) {
<span style="white-space:pre"> </span> <span style="white-space:pre"> </span>e.printStackTrace();
}finally{
conn.close();
<span style="white-space:pre"> </span>}
}
}
}dao层：流程、规范设计，即接口设计
import java.sql.SQLException;
public interface IBaseDao {
// public static void add_1(){};
// 静态函数与抽象函数不可以同时使用？接口中的函数体默认是抽象函数的，这里上下两个函数区别。
// 可以在试着看看上面的函数实现接口时要不要重写
public void add(Object o) throws IllegalArgumentException, IllegalAccessException, SQLException;
public void delete();
public void select();
public void selectById();
public void update();
}
实现dao层规范：
import java.lang.reflect.Field;
import java.sql.*;
public class BaseDao{
public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, SQLException {
Dept d = new Dept();
d.setName("123");
add(d);
// select(d);
// delete(d);
}
// @Override
public static void add(Object o) throws IllegalArgumentException, IllegalAccessException, SQLException {
StringBuilder sb = new StringBuilder("insert into ");
StringBuilder val = new StringBuilder(") values (");
Class clazz = o.getClass();//getClass()获得当前对象的类型;Class theClass="hello".getClass();得到的就是字符串的类型。
sb.append(clazz.getSimpleName());//java.lang.Class.getSimpleName()返回的源代码中的基础类的简单名称。如果是匿名的基础类，则返回一个空字符串。
sb.append("(");
Field[] fs = o.getClass().getDeclaredFields();//反射的应用：Field的类数组——全是Field的成员
/*java.lang.Class.getDeclaredFields() 方法返回一个数组的Field对象包括 public, protected，default（包）访问和private 字段，但不包括继承的字段。
* 该方法返回一个长度为0的数组的类或接口不声明任何字段，如果此Class对象表示一个基本类型，数组类或者无效。
* 此方法返回的数组，Field对象，这个类的所有声明。
* */
//遍历上面反射的对象：
for(int i = 0; i < fs.length - 1; i++){
Field f = fs[i];
f.setAccessible(true);//暴力反射：http://blog.sina.com.cn/s/blog_53b58e7c01017g1d.html
if(!"id".equals(f.getName())){
sb.append(f.getName());//StringBuilder拼接字符串
sb.append(", ");
val.append(f.get(o));
val.append(", ");
}else{
sb.append(fs[fs.length - 1].getName());
fs[fs.length - 1].setAccessible(true);
val.append(fs[fs.length - 1].get(o));
}
val.append(")");
System.out.println(sb);
System.out.println(val);
sb.append(val);
}
System.out.println("BaseDao.add():" + sb.toString());
JdbcUtils.getConnection();//调用函数：连接数据库
Connection conn = null;
PreparedStatement st =null;//Statement的子类——预编译
ResultSet rs = null;//结果集
String sql = sb.toString();
try{
conn = JdbcUtils.getConnection();
st = conn.prepareStatement(sql);
for(int i = 0; i < 10; i++){
st.executeUpdate();//http://blog.csdn.net/colin_fantasy/article/details/3898070
}
} catch (Exception ex) {
ex.printStackTrace();
}finally{
JdbcUtils.close(conn, st, rs);
}
}
// @Override
public static void delete(Object o) throws SQLException, IllegalArgumentException, IllegalAccessException {
StringBuilder sb = new StringBuilder("delete from ");
StringBuilder val = new StringBuilder(" where ");
Class clazz = o.getClass();
sb.append(clazz.getSimpleName());
Field[] fs = o.getClass().getDeclaredFields();//反射的应用：Field的类数组——全是Field的成员
//遍历上面反射的对象：
for(int i = 0; i < fs.length - 1; i++){
Field f = fs[i];
f.setAccessible(true);
if(!"id".equals(f.getName())){
val.append(f.getName());
val.append(", ");
}else{
// sb.append(fs[fs.length - 1].getName());
fs[fs.length - 1].setAccessible(true);
val.append(fs[fs.length - 1].get(o));//获得对象的值?
}
System.out.println(sb);
System.out.println(val);
sb.append(val);
}
System.out.println("BaseDao.delete():" + sb.toString());
JdbcUtils.getConnection();//调用函数：连接数据库
Connection conn = null;
PreparedStatement st =null;//Statement的子类——预编译
ResultSet rs = null;//结果集
String sql = sb.toString();
try{
conn = JdbcUtils.getConnection();
st = conn.prepareStatement(sql);
st.executeUpdate();
} catch (Exception ex) {
ex.printStackTrace();
}finally{
JdbcUtils.close(conn, st, rs);
}
}
// @Override
public static void select(Object o) throws IllegalArgumentException, IllegalAccessException, SQLException {
StringBuilder sb = new StringBuilder("select * from ");
Class clazz = o.getClass();//getClass()获得当前对象的类型;Class theClass="hello".getClass();得到的就是字符串的类型。
sb.append(clazz.getSimpleName());//java.lang.Class.getSimpleName()返回的源代码中的基础类的简单名称。如果是匿名的基础类，则返回一个空字符串。
System.out.println("BaseDao.select():" + sb.toString());
JdbcUtils.getConnection();//调用函数：连接数据库
Connection conn = null;
PreparedStatement st =null;//Statement的子类——预编译
ResultSet rs = null;//结果集
String sql = sb.toString();
try{
conn = JdbcUtils.getConnection();
st = conn.prepareStatement(sql);
rs =st.executeQuery();
Field[] fs = o.getClass().getDeclaredFields();//反射的应用：Field的类数组——全是Field的成员
for(int i = 0; i < fs.length; i++){
Field f = fs[i];
f.setAccessible(true);
System.out.println(f.getName().toString());
// 66666666666666666换个思路换个想法
// 首先要明确结果集返回的是一个表，然后我利用上一个例子中的介绍写出来的只打印表的第一个列一个列；说明我可以读出数据只是读不出来后面的数据这个时候不应该继续想
// 数据读的方面问题了，应该想想为什么没读出来。最后发现是我吧哪个把循环弄反了，没有理解老师代码的真正含义。下面为错误代码:
// for(int j = 1; j <= fs.length; j++){
// while(rs.next()){//遍历结果集
// System.out.println(rs.getObject(j));
// //上面是对与字符串变量进行连接
// }
// }
// 下面为正确的代码：
while(rs.next()){//遍历结果集
for(int j = 1; j <= fs.length; j++){
System.out.print(rs.getObject(j) + " ");
}
System.out.println();
}
}
} catch (Exception ex) {
ex.printStackTrace();
}finally{
JdbcUtils.close(conn, st, rs);
}
}
// @Override
// public void selectById() {
// }
//
// @Override
// public void update() {
// }
}