代码来源于高淇JAVA教学视频 谢谢高淇老师的教学。
因为自己在学习的过程中发现了很多困难点，总结下希望对自己接下来学框架提升。给像我一样得初学者方便。
SORM框架是一个简单的ORM，关系对象映射，可以通过这个框架方便的更改和操作一些数据库的东西，在框架运行的时候也会根据数据库中的表生成相应的Javabean在po包下。通过直接对po包下的操作在运用query中的一些操作就可以实现对数据库的操作。思路会在代码中注释。
QueryFactory直接生产出Query给用的人调用，Query作为一个接口是更好的让多种数据库提供各自的操作。实现mySQLQuery或者OracleQuery，conventor是个转换不同语言数据类型的工具
TableContext就是核心的程序连接数据库表的类。DBManager钟放的是一些配置资源文件和一些加载处理。
明确主要思路，就是通过factory制作一个query，然后直接set方法然后将对象传入query的方法实现功能。查询的话也是通过queryrows方法传入select语句进行查询，因为查询语句的多样性简单的框架没有进一步封装。
先从最底层的tablecontext和DBManage说起：
解释会在代码中标识
public class DBManager {
private static Configuration conf; //这是在bean包下定义的一个类用来把从配置文件提取出来方便用get set
private static List pool=new ArrayList(); //这是连接池的定义，我在老师的基础上做了些更改，我把连接池全部放到了这个类里
static{ //静态代码块初始化资源文件中的数据， 注意静态块是和类一起加载的，大量用静态影响内存
Properties pro=new Properties(); //这个类是用来从资源文件中提取数据的类
try {
pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("database.properties"));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
conf=new Configuration();
conf.setDriver(pro.getProperty("driver"));
conf.setPoPackage(pro.getProperty("poPackage"));
conf.setPwd(pro.getProperty("pwd"));
conf.setScrPath(pro.getProperty("srcPath"));
conf.setUser(pro.getProperty("user"));
conf.setUrl(pro.getProperty("url"));
conf.setUsingDB(pro.getProperty("usingDB"));
conf.setQueryClass(pro.getProperty("queryClass"));
conf.setMAX_POOL(Integer.parseInt(pro.getProperty("max_pool")));
conf.setMIN_POOL(Integer.parseInt(pro.getProperty("min_pool")));
System.out.println(TableContext.class);//加载类 //这是用来加载表信息的，用于表连接也可以用反射来加载，但是要trycatch选择输出加载
initPool(); //加载连接池
}
public static void initPool(){ //连接池的初始化
if(pool==null){
pool=new ArrayList();
}
while(pool.size()[span style="color: rgba(0, 0, 0, 1)">conf.getMIN_POOL()){
pool.add(DBManager.createConn());
//初始化
}
}
public static Connection getConn(){ //连接池取连接
int last_index=pool.size()-1;
Connection conn=pool.get(last_index);
pool.remove(last_index);
return conn;
}
public static void CloseConn(Connection conn){ //连接池关闭
if(pool.size()>conf.getMAX_POOL()){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
pool.add(conn);
}
}
public static Connection createConn(){
try { //真正的建立一个连接
Class.forName(conf.getDriver());
//代码效果参考：http://www.zidongmutanji.com/bxxx/453368.html
return DriverManager.getConnection(conf.getUrl(),conf.getUser(),conf.getPwd());//直接建立连接
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
return null;
}
}
//get用于配置信息的哪个类，很好理解
public static Configuration getConf(){
return conf;
}
//之后的关闭就不说了，主要是要记得把关闭改变成从线程池中假关闭
public static void close(ResultSet rs,Statement ps,Connection conn){
try {
if(rs!=null){
rs.close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(ps!=null){
ps.close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(conn!=null){
CloseConn(conn);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void close(Statement ps,Connection conn){
try {
if(ps!=null){
ps.close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(conn!=null){
CloseConn(conn);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
然后现在有配置文件和连接了
接下来是表连接tablecontect
/
管理数据库所有表结构和类结构的关系，并可以根据表结构生成类结构
@author NodeRed
*/
public class TableContext { //最核心的 可以根据表生成类。
/
表名为key，信息对对象为value
/
public static Map tables=new HashMap(); //这个表中的tableInfo也是定义的一个类大概意思就是能够记录下整张表，这里这个map就能记录整个database
/
将po的class对象和表关联
/
public static Map poClassTableMap=new HashMap(); //这个表用来记录这个表后来会产生哪个类，这后面会说
private TableContext(){};
//无参构造很重要
static{
try {
Connection con=DBManager.getConn(); //这里就获得了和数据库的连接了
DatabaseMetaData dbmd=con.getMetaData(); //这里原视频中没有说，大概是 可以从连接中搜索获取一些元数据，%是类似所有
ResultSet tableRet=dbmd.getTables(null, "%", "%",new String【】{"TABLE"}); //TABLE那就是要查询的就是表了，但是这里出现了问题，意外的搜索出了创建表的时间
System.out.println(tableRet); //记录的那个表，捯饬了半天也没解决。 然后之后是放到了一个结果集里
while(tableRet.next()){ //遍历查找出来的结果
String tableName=(String)tableRet.getObject("TABLE_NAME"); //获得表名
TableInfo ti=new TableInfo(tableName, new ArrayList(), // 然后把表名先把上说的可以记录下整个表的new出来，具体的后面再说
new HashMap());
tables.put(tableName, ti); //放到记录整个数据库的那个表里
ResultSet set=dbmd.getColumns(null, "%", tableName ,"%"); //这里根据表名获取字段集，
while(set.next()){
ColumnInFo ci=new ColumnInFo(set.getString("COLUMN_NAME"),set.getString("TYPE_NAME"),0);//可以看出这里获取了字段的名字和类型
ti.getColumns().put(set.getString("COLUMN_NAME"),ci); //这里是放到表映射，加载表的字段
}
ResultSet set2=dbmd.getPrimaryKeys(null, "%", tableName);
while(set2.next()){ //这里加载主键
ColumnInFo ci2=(ColumnInFo)ti.getColumns().get(set2.getObject("COLUMN_NAME"));
ci2.setKeyType(1);
ti.getPriKeys().add(ci2);
}
if(ti.getPriKeys().size()>0){
ti.setOnlyPrivate(ti.getPriKeys().get(0));
}
} //如果这里没有懂得话，不要急，后面结合javabean
//这里就可以理解为，你在java中建立了一个表格，不是完全填好数据得表格，只是单纯得有每个数据类型在哪个表是不是主键得表示
有了这个标识以后可以在query中找出数据库要操作得是哪个，再从query中操作数据库。
} catch (Exception e) {
// TODO: handle exception
}
updataJavaPOFile(); //因为我们要再数据库中操作，程序事先是不知道你表中得每一项叫什么名字就没办法根据数据可定义好类，在用类来操作数据库
loadPOTables(); //这里我们就可以根据数据库中获取的表框架，获取表的名字，表中字段类型，生成这个数据库的java类
//然后是每次加载这个类的时候更新
}
//一下是实现方法
public static void updataJavaPOFile(){
Map map= TableContext.tables; 这里就通过这个tables表然后用后面的一个java类实现了在项目中构造java类
// TableInfo t=map.get("new_table");
for(TableInfo t:map.values()){
JavaFileUtils.createJavaPOFile(t, new MysqlTypeConventor());
}
}
public static void loadPOTables(){
// Class c=Class.forName("com.cy.sorm.New_table");
// poClassTableMap.put(c, TableInfo); //这里就是用反射把这个类和产生自哪个表放在了一个表里，在后面的操作有用
for(TableInfo tableInfo:tables.values()){
try{
Class c=Class.forName(DBManager.getConf().getPoPackage()+
"."+StringUTils.firstChar2UpCase(tableInfo.getTname()));
poClassTableMap.put(c, tableInfo);
}catch(Exception e){
e.printStackTrace();
}
}
}
// public static void main(String【】 args) {
// Map tables=TableContext.tables;
// System.out.println(tables);
// }
}
这里也是orm的核心了，从数据库中复制了一个映射表过来。但是老师说在工作中用的很少。接下来说一下字段映射和表映射吧，可以从以上的javabean包中可以看出，除了很容易理解的配置configuration，javasetget也就是在上面说的拼接我们自己产生的java类的简单结构。
private String name;
private String Datatype;
private int keyType;
字段就是在mysql建表时候的每一列
private String tname;
/
key 字段名 value字段类
/
private Map columns;
private ColumnInFo onlyPrivate;
private List priKeys;
这个表呢也就可以记录下整个表了 map中也就是整个表，记录下主键 很好理解这样我们只要有足够多的数据传入我们就可以在java中改了整张表，但是我们必去得做一个query类，用来我把这个数据类传入就可以在数据库中同步更改。
然后大概思路也就成型了，用户可以提供数据库 ，我自动给他生成他表中得类，他调用query中方法，对数据库进行更改。但是怎么通过我生成类对这个映射相联系，然后再映射到数据库呢，我们藏了一个map。
先说一点简单得把tables中获得得数据进行生成java类
这里实现了一个接口，可以处理不同数据库到java得翻译数据类型这里很好懂
public class MysqlTypeConventor implements TypeConvertor{
@Override
public String databaseType2JavaType(String columnType) {
if("varchar".equalsIgnoreCase(columnType)||"char".equalsIgnoreCase(columnType)){
return "String";
}else if("int".equalsIgnoreCase(columnType)
||"tinyint".equalsIgnoreCase(columnType)){
return "Integer";
}else if("double".equalsIgnoreCase(columnType)){
return "double";
}else if("timestamp".equalsIgnoreCase(columnType)){
return "Timestamp";
}
return null;
}
@Override
public String javaType2databaseType(String javaDataType) {
// TODO Auto-generated method stub
return null;
}
}
然后我们把转换器和传进去的字段封装成一个java生成类的工具，就是上面代码提到的哪个工具类
public class JavaFileUtils {
public static JavaFieldGetSet createFieldGetSetSRC(ColumnInFo column,TypeConvertor convertor){
JavaFieldGetSet jfgs= new JavaFieldGetSet();
String javaFieldType = convertor.databaseType2JavaType(column.getDatatype());
jfgs.setFieldInfo("\tprivate "+javaFieldType+" "+column.getName());
StringBuilder getSrc=new StringBuilder();
getSrc.append("\tpublic "+javaFieldType+" get"+StringUTils.firstChar2UpCase(column.getName())+"(){\n");
getSrc.append("\t\treturn "+column.getName()+";\n");
getSrc.append("\t}\n");
jfgs.setGetInfo(getSrc.toString());
StringBuilder setSrc=new StringBuilder();
setSrc.append("\tpublic void set"+StringUTils.firstChar2UpCase(column.getName())+"(");
setSrc.append(javaFieldType+" "+column.getName()+"){\n");
setSrc.append("\t\tthis."+column.getName()+"="+column.getName()+";\n");
setSrc.append("\t}\n");
jfgs.setSetInfo(setSrc.toString());
return jfgs;
}
public static String createJavaSrc(TableInfo tableInfo,TypeConvertor convertor){
Map columns=tableInfo.getColumns();//表装入map
List javaFields=new ArrayList();
for(ColumnInFo c:columns.values()){
javaFields.add(createFieldGetSetSRC(c, convertor));
}
StringBuilder src=new StringBuilder();
src.append("package "+DBManager.getConf().getPoPackage()+";\n\n");
src.append("import java.util.;\n\n");
src.append("import java.sql.;\n\n");
src.append("public class "+StringUTils.firstChar2UpCase(tableInfo.getTname())+"{\n\n");
for(JavaFieldGetSet f:javaFields){
src.append(f.getFieldInfo()+";\n");
}
src.append("\n\n");
for(JavaFieldGetSet f:javaFields){
src.append(f.getSetInfo());
}
src.append("\n");
for(JavaFieldGetSet f:javaFields){
src.append(f.getGetInfo());
}
src.append("}\n");
// System.out.println(src);
return src.toString();
}
