通过调用DataBaseClass实现调用
DataBaseClass类
package com.lbf.database;
import java.sql.*;
import java.util.*;
/**
* 数据库访问操作类(操作数据库时使用)
* @author Wing.King
*/
public class DataBaseClass
{
private static final ThreadLocal<Connection> THREAD_LOCAL = new ThreadLocal<Connection>();//数据库连接集合
private static boolean isDriver=false;//数据库驱动是否加载成功(默认失败)
private static String errorDriver="NO";//数据库驱动是否加载成功(错误消息)
private static String DRIVER="";//加载数据库驱动
private static String DATABASE="";//数据库连接字符串
private static String USERNAME="";//数据库登录用户名
private static String PASSWORD="";//数据库登录密码
/**
* 静态构造函数:关联类。当首次使用该类时,该静态构造函数就会被系统调用。
* 当首次使用该类时,类中的代码才会被系统加载到代码区。
* 加载数据库的驱动
*/
static {
try {
//1.知道数据库的连接字符串:数据库IP地址,端口号码,数据库名称,登陆账户,密码(决定连接哪一个数据库)。
DataBaseClass.DRIVER=PropertiesReader.getConnectionKey("driver");//读取配置文件中的内容
DataBaseClass.DATABASE=PropertiesReader.getConnectionKey("dataBase");//读取配置文件中的内容
DataBaseClass.USERNAME=PropertiesReader.getConnectionKey("userName");//读取配置文件中的内容
DataBaseClass.PASSWORD=PropertiesReader.getConnectionKey("passWord");//读取配置文件中的内容
//2.加载数据库驱动(决定操作什么类型的数据库。是SQL还是Oracle)
Class.forName(DataBaseClass.DRIVER);//Class.forName()函数的本意不是用来加载数据库驱动。本意加载类,将类读取到内存中。
DataBaseClass.isDriver=true;
DataBaseClass.errorDriver="OK";
} catch(ClassNotFoundException e) {
DataBaseClass.isDriver=false;
DataBaseClass.errorDriver=e.getMessage();//System.err.println("加载数据库驱动失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
/**
* 构造函数:关联对象。每创建一个类的实例是会被系统自动调用(new创建对象时)。
* 私有构造函数,用于说明该类在类的外部不能被实例化
*/
private DataBaseClass() {
//
}
/**
* 创建并获取数据库连接
* @return 数据库连接
* @throws DataBaseException
*/
private static Connection getConnection() throws DataBaseException {
if (!DataBaseClass.isDriver) {
throw new DataBaseException("加载数据库驱动失败!Error:"+DataBaseClass.errorDriver);
}
//3.建立数据库连接
Connection conn=(Connection)DataBaseClass.THREAD_LOCAL.get();
try {
if (conn==null || conn.isClosed()) {
conn=DriverManager.getConnection(DataBaseClass.DATABASE,DataBaseClass.USERNAME,DataBaseClass.PASSWORD);//创建数据库连接
//通过DriverManager.getConnection()函数获得一个数据库连接对象,该对象根据加载的数据库驱动的不同而不同。
//不论Oralce,还是SQL所建立的这个对象都继承Connection。
DataBaseClass.THREAD_LOCAL.set(conn);
System.out.println("数据库连接已开启");
}
} catch (SQLException e) {
throw new DataBaseException("创建数据库连接失败!Error:"+e.getMessage());//System.err.println("创建数据库连接失败!Error:"+e.getMessage());//e.printStackTrace();
}
return conn;
}
/**
* 开始一个事务
* @throws DataBaseException
*/
public static void beginTransaction() throws DataBaseException {
Connection conn=DataBaseClass.getConnection();
try {
conn.setAutoCommit(false);
System.out.println("数据库事务已开启");
} catch (SQLException e) {
throw new DataBaseException("开始数据库事务失败!Error:"+e.getMessage());//System.err.println("开始数据库事务失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
/**
* 结束一个事务
* @throws DataBaseException
*/
private static void endTransaction() throws DataBaseException {
Connection conn=DataBaseClass.getConnection();
try {
conn.setAutoCommit(true);
System.out.println("数据库事务已结束");
} catch (SQLException e) {
throw new DataBaseException("结束数据库事务失败!Error:"+e.getMessage());//System.err.println("结束数据库事务失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
/**
* 提交事务
* @throws DataBaseException
*/
public static void commit() throws DataBaseException {
Connection conn=DataBaseClass.getConnection();
try {
conn.commit();
System.out.println("数据库事务已提交");
} catch (SQLException e) {
throw new DataBaseException("提交数据库事务失败!Error:"+e.getMessage());//System.err.println("提交数据库事务失败!Error:"+e.getMessage());//e.printStackTrace();
}
DataBaseClass.endTransaction();
DataBaseClass.closeConnection();
}
/**
* 回滚事务
* @throws DataBaseException
*/
public static void rollback() throws DataBaseException {
Connection conn=DataBaseClass.getConnection();
try {
conn.rollback();
System.out.println("数据库事务已回滚");
} catch (SQLException e) {
throw new DataBaseException("回滚数据库事务失败!Error:"+e.getMessage());//System.err.println("回滚数据库事务失败!Error:"+e.getMessage());//e.printStackTrace();
}
DataBaseClass.endTransaction();
DataBaseClass.closeConnection();
}
/**
* 创建SQL数据库操作对象
* @return 数据库操作对象
* @throws DataBaseException
*/
private static Statement createSqlCommand() throws DataBaseException {
Connection conn=DataBaseClass.getConnection();
try {
return conn.createStatement();//无参数创建文本
} catch (SQLException e) {
throw new DataBaseException("创建数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
/**
* 创建SQL数据库操作对象
* @param sql sql语句
* @param params sql参数
* @return 数据库操作对象
* @throws DataBaseException
*/
private static PreparedStatement createSqlCommand(String sql,Object[] params) throws DataBaseException {
Connection conn=DataBaseClass.getConnection();
try {
if (params!=null && params.length>0) {
PreparedStatement cmdTemp=conn.prepareStatement(sql);//有参数创建预编译操作对象
for (int i=0;i<params.length;i++) {
if (params[i] instanceof java.util.Date) {
java.util.Date temp=(java.util.Date)params[i];
java.sql.Date date=new java.sql.Date(temp.getTime());
cmdTemp.setDate(i+1, date);
} else {
cmdTemp.setObject(i+1, params[i]);
}
}
return cmdTemp;
} else {
throw new SQLException("操作参数不存在.");
}
} catch (SQLException e) {
throw new DataBaseException("创建数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
/**
* 执行数据库操作:添加,修改,删除
* @param sql 执行的SQL语句
* @return 执行语句所影响的行数(大于0执行成功)。
* @throws DataBaseException
*/
public static int executeUpdate(String sql) throws DataBaseException {
try {
return DataBaseClass.createSqlCommand().executeUpdate(sql);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:添加,修改,删除
* @param sql 执行的SQL语句
* @param params 执行SQL语句所需的参数
* @return 执行语句所影响的行数(大于0执行成功)。
* @throws DataBaseException
*/
public static int executeUpdate(String sql,Object[] params) throws DataBaseException {
try {
return DataBaseClass.createSqlCommand(sql, params).executeUpdate();
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:查询(通用集合)
* @param sql 执行的SQL语句
* @return 持久化后的查询结果
* @throws DataBaseException
*/
public static DataTable executeReader(String sql) throws DataBaseException {
try {
ResultSet rs=DataBaseClass.createSqlCommand().executeQuery(sql);
return new DataTable(rs);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:查询(通用集合)
* @param sql 执行的SQL语句
* @param params 执行SQL语句所需的参数
* @return 持久化后的查询结果
* @throws DataBaseException
*/
public static DataTable executeReader(String sql,Object[] params) throws DataBaseException {
try {
ResultSet rs=DataBaseClass.createSqlCommand(sql, params).executeQuery();
return new DataTable(rs);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:查询(类的反射)
* @param sql 执行的SQL语句
* @param className 持久化反射类
* @return 持久化后的查询结果
* @throws DataBaseException
*/
public static List<Object> executeQuery(String sql,String className) throws DataBaseException {
try {
ResultSet rs=DataBaseClass.createSqlCommand().executeQuery(sql);
return Persistence.loadResultToSet(rs, className);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:查询(类的反射)
* @param sql 执行的SQL语句
* @param params 执行SQL语句所需的参数
* @param className 持久化反射类
* @return 持久化后的查询结果
* @throws DataBaseException
*/
public static List<Object> executeQuery(String sql,Object[] params,String className) throws DataBaseException {
try {
ResultSet rs=DataBaseClass.createSqlCommand(sql, params).executeQuery();
return Persistence.loadResultToSet(rs, className);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:查询(函数回调)
* @param sql 执行的SQL语句
* @param handle 持久化操作类
* @return 持久化后的查询结果
* @throws DataBaseException
*/
public static List<Object> executeQuery(String sql,DataBaseListener handle) throws DataBaseException {
try {
ResultSet rs=DataBaseClass.createSqlCommand().executeQuery(sql);
return handle.entity(rs);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 执行数据库操作:查询(函数回调)
* @param sql 执行的SQL语句
* @param params 执行SQL语句所需的参数
* @param handle 持久化操作类
* @return 持久化后的查询结果
* @throws DataBaseException
*/
public static List<Object> executeQuery(String sql,Object[] params,DataBaseListener handle) throws DataBaseException {
try {
ResultSet rs=DataBaseClass.createSqlCommand(sql, params).executeQuery();
return handle.entity(rs);
} catch (DataBaseException e) {
throw e;
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
DataBaseClass.closeConnection();
}
}
/**
* 关闭数据库连接
* @param conn 数据库的连接
* @throws DataBaseException
*/
private static void closeConnection() throws DataBaseException {
Connection conn=(Connection)DataBaseClass.THREAD_LOCAL.get();
try {
//5.关闭数据库连接。
if (conn!=null && !conn.isClosed()) {
if (conn.getAutoCommit()) {
conn.close();
DataBaseClass.THREAD_LOCAL.set(null);
System.out.println("数据库连接已关闭");
}
}
} catch (SQLException e) {
throw new DataBaseException("执行数据库操作失败!Error:"+e.getMessage());//System.err.println("关闭数据库连接失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
}
DataBaseException类
package com.lbf.database;
import java.sql.SQLException;
/**
* 数据库访问异常类
* @author Wing.King
*/
public class DataBaseException extends SQLException {
/**
*
*/
private static final long serialVersionUID = -53992627346981792L;
public DataBaseException() {
super();
}
public DataBaseException(String message) {
super(message);
}
}
DataBaseListener类
package com.lbf.database;
import java.sql.*;
import java.util.*;
/**
* 数据持久化接口
* @author Wing.King
*/
public interface DataBaseListener {
/**
* 数据持久化函数
* @param rs 查询结果集
* @return 持久化的数据
*/
public List<Object> entity(ResultSet rs) throws SQLException;
}
DataTable类
package com.lbf.database;
import java.sql.*;
import java.util.*;
/**
* 持久化数据库表
* @author Wing.King
*/
public class DataTable {
private ArrayList<String> columnList=new ArrayList<String>();//保存表的列名
private ArrayList<ArrayList<Object>> dataList=new ArrayList<ArrayList<Object>>();//表的内容(每一行数据)
public DataTable(ResultSet rs) throws SQLException {
ResultSetMetaData rsmd=rs.getMetaData();//获取查询结果集的结构
for (int i=1;i<=rsmd.getColumnCount();i++) {
this.columnList.add(rsmd.getColumnName(i));
}
while(rs.next()) {
ArrayList<Object> row=new ArrayList<Object>();
for (int i=1;i<=rsmd.getColumnCount();i++) {
row.add(rs.getObject(i));
}
this.dataList.add(row);
}
}
/**
* 获取查询结果首行首列值
* @return Object数值
*/
public Object getFirstValue() {
return this.dataList.get(0).get(0);
}
/**
* 获取查询结果任意一行一列的值
* @param row 行的索引
* @param col 列的索引
* @return Object数值
*/
public Object getValue(int row,int col) {
return this.dataList.get(row).get(col);
}
/**
* 获取查询结果行的数量
* @return int行数
*/
public int getRowCount() {
return this.dataList.size();
}
/**
* 获取查询结果列的数量
* @return int列数
*/
public int getColumnCount() {
return this.columnList.size();
}
/**
* 获取查询结果列的名称
* @param index 列索引
* @return String列名
*/
public String getColumnName(int index) {
return this.columnList.get(index);
}
}
Persistence类
package com.guigu.macheng.database.core;
import java.sql.*;
import java.util.*;
import java.lang.reflect.*;
import com.guigu.macheng.database.core.map.*;
/**
* 持久化处理类(反射处理)
* @author Wing.King
*/
public class Persistence {
public static ArrayList<Object> loadResultToSet(ResultSet rs,String className) throws SQLException {
Class<?> demo = null;
ArrayList<MappingData> mapList=new ArrayList<MappingData>();
//=========================================================================
try {
demo = Class.forName(className);
Field[] field=demo.getDeclaredFields();
for (int i=0;i<field.length;i++) {
MappingData map=new MappingData();
map.getMappingClass().setName(field[i].getName());
map.getMappingClass().setType(field[i].getType().getName());
mapList.add(map);
}
} catch (Exception e) {
e.printStackTrace();
}
//=========================================================================
ResultSetMetaData rsmd=rs.getMetaData();//获取结果集的结构
for (int i=1;i<=rsmd.getColumnCount();i++) {
String name=rsmd.getColumnName(i);
String type=rsmd.getColumnTypeName(i);
for (int j=0;j<mapList.size();j++) {
if (mapList.get(j).getMappingClass().getName().equalsIgnoreCase(name)) {
mapList.get(j).getMappingTable().setName(name);
mapList.get(j).getMappingTable().setType(type);
break;
}
}
}
//=========================================================================
ArrayList<Object> dataSet=new ArrayList<Object>();
try {
while(rs.next()) {
Class<?> temp = Class.forName(className);
Object obj = temp.newInstance();
for (int i=0;i<mapList.size();i++) {
String name=mapList.get(i).getMappingClass().getName();
String type=mapList.get(i).getMappingClass().getType();
if(mapList.get(i).getMappingClass().getName().equalsIgnoreCase(mapList.get(i).getMappingTable().getName())){
Object value=rs.getObject(mapList.get(i).getMappingTable().getName());
Persistence.setter(obj,name,value,Class.forName(type));
}
}
dataSet.add(obj);
}
} catch(Exception e) {
dataSet=null;
e.printStackTrace();
}
return dataSet;
}
/**
* 执行实体Bean的get方法
* @param obj 操作的对象
* @param att 操作的属性
*/
public static void getter(Object obj, String att) {
try {
att=att.replaceFirst(att.substring(0,1),att.substring(0,1).toUpperCase());
Method method=obj.getClass().getMethod("get"+att);
System.out.println(method.invoke(obj));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 执行实体Bean的set方法
* @param obj 操作的对象
* @param att 操作的属性
* @param value 设置的值
* @param type 参数的属性
*/
public static void setter(Object obj, String att, Object value, Class<?> type) {
try {
att=att.replaceFirst(att.substring(0,1),att.substring(0,1).toUpperCase());
Method method=obj.getClass().getMethod("set"+att,type);
String[] strList=type.toString().split("\\.");
String strType=strList[strList.length-1];
if(strType.equals("Long")) {
method.invoke(obj,Long.parseLong(value.toString()));
} else if(strType.equals("Integer")) {
method.invoke(obj,Integer.parseInt(value.toString()));
} else if(strType.equals("Float")) {
method.invoke(obj,Float.parseFloat(value.toString()));
} else if(strType.equals("Double")) {
method.invoke(obj,Double.parseDouble(value.toString()));
} else {
method.invoke(obj,value);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
PropertiesReader类
package com.lbf.database;
import java.io.*;
import java.util.*;
/**
* 数据库配置文件读取类
* @author Wing.King
*/
class PropertiesReader {
/**
* 构造函数:关联对象。每创建一个类的实例是会被系统自动调用(new创建对象时)。
* 私有构造函数,用于说明该类在类的外部不能被实例化
*/
private PropertiesReader() {
//
}
/**
* 返回数据库连接字符串的数据
* @param KeyName连接名称(driver:数据库驱动;dataBase:数据库连接;userName:用户名称;passWord:用户密码;)
* @return 连接内容
*/
public static String getConnectionKey(String keyName) {
String keyValue="";
InputStream inputStream = null;
try {
//读取config.properties文本文件的内容,将其保存到inputStream对象中
inputStream = PropertiesReader.class.getClassLoader().getResourceAsStream("config.properties");//文件的读取对象,类似FileReader
//创建操作config.properties配置文件的对象
Properties format=new Properties();//文件的读取格式,类似BufferedReader
//将文件的内容和操作文件的对象相关联
format.load(inputStream);//将文件读取和文件读取格式相关联
//输入键名,返回对应的键值
keyValue=format.getProperty(keyName);//通过键名获取键值
} catch (FileNotFoundException e) {
System.err.println("数据库配置文件“config.properties”,不存在!");
e.printStackTrace();
} catch (IOException e) {
System.err.println("数据库配置文件“config.properties”,读取失败!");
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return keyValue;
}
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(PropertiesReader.getConnectionKey("driver"));
}
}
TransactionProxy类
package com.lbf.database;
import java.lang.reflect.*;
/**
* 数据库操作:事务代理
* @author macheng
*/
public class TransactionProxy implements InvocationHandler {
private Object action;//这个就是我们要代理的真实对象
/**
* 获取代理对象
* @param className 被代理对象的类名
* @param isProxy 是否返回代理对象(true代理对象,false源对象)
* @return 代理对象|源对象
* @throws Throwable
*/
public static Object getInstance(String className,boolean isProxy) throws DataBaseException {
if (isProxy) {
try {
return TransactionProxy.getInstance(Class.forName(className).newInstance());
} catch (InstantiationException e) {
throw new DataBaseException("获取事务代理对象失败!Error:"+e.getMessage());//e.printStackTrace();
} catch (IllegalAccessException e) {
throw new DataBaseException("获取事务代理对象失败!Error:"+e.getMessage());//e.printStackTrace();
} catch (ClassNotFoundException e) {
throw new DataBaseException("获取事务代理对象失败!Error:"+e.getMessage());//e.printStackTrace();
}
} else {
try {
return Class.forName(className).newInstance();
} catch (InstantiationException e) {
throw new DataBaseException("获取业务的源对象失败!Error:"+e.getMessage());//e.printStackTrace();
} catch (IllegalAccessException e) {
throw new DataBaseException("获取业务的源对象失败!Error:"+e.getMessage());//e.printStackTrace();
} catch (ClassNotFoundException e) {
throw new DataBaseException("获取业务的源对象失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
}
/**
* 获取代理对象
* @param className 被代理对象的类名
* @return 代理对象
* @throws Throwable
*/
public static Object getInstance(String className) throws DataBaseException {
return TransactionProxy.getInstance(className, true);
}
/**
* 获取代理对象
* @param action 被代理对象
* @return
*/
public static Object getInstance(Object action) throws DataBaseException {
/*
* 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数。
* 第一个参数 handler.getClass().getClassLoader(),我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象。
* 第二个参数realSubject.getClass().getInterfaces(),我们这里为代理对象提供的接口是真实对象所实行的接口,表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了。
* 第三个参数handler,我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上。
*/
//创建一个动态的代理对象
//loader:一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载。
//interfaces:一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了。
//h:一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上。
try {
Object proxy=Proxy.newProxyInstance(
action.getClass().getClassLoader(),//取得当前对象所属的Class对象后,在获取该Class对象的类装载器。
action.getClass().getInterfaces(), //获取当前对象的实现接口Class对象数组。
new TransactionProxy(action) //创建代理类的实例,并和被代理类关联。
);
return proxy;
} catch (Throwable e) {
throw new DataBaseException("创建事务代理对象失败!Error:"+e.getMessage());//e.printStackTrace();
}
}
/**
* 构造方法:给我们要代理的真实对象赋初值
* @param action 被代理的对象
*/
private TransactionProxy(Object action) {
this.action=action;
}
/**
* 执行函数的返回结果
* @param proxy 指代我们所代理的那个真实对象
* @param method 指代的是我们所要调用真实对象的某个方法的Method对象
* @param args 指代的是调用真实对象某个方法时接受的参数
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws DataBaseException {
try {
//在代理真实对象前我们可以添加一些自己的操作
this.doBefore();//代理前动作
//当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
Object object = method.invoke(action, args);//System.out.println("Method:" + method);
DataBaseClass.commit();
return object;
} catch (Throwable e) {
DataBaseClass.rollback();
throw new DataBaseException("执行事务代理操作失败!Error:"+e.getMessage());//e.printStackTrace();
} finally {
//在代理真实对象后我们也可以添加一些自己的操作
this.doAfter();//代理后动作
}
}
/**
* 代理前动作
* @throws Throwable
*/
public void doBefore() throws DataBaseException {
DataBaseClass.beginTransaction();//System.out.println("开始事务...");//代理前动作
}
/**
* 代理后动作
* @throws Throwable
*/
public void doAfter() throws DataBaseException {
//DataBaseClass类事务提交或事务回滚后自动结束事务//System.out.println("结束事务...");//代理后动作
}
}
MappingClass类
package com.lbf.database.map;
import java.io.Serializable;
/**
* 数据映射类(类)
*/
public class MappingClass implements Serializable {
/**
*
*/
private static final long serialVersionUID = 5374376991148428908L;
private String name=null;
private String type=null;
public MappingClass() {
this("","");
}
public MappingClass(String name,String type) {
this.name=name;
this.type=type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public String toString() {
return "Class:"+name+"-"+type;
}
}
MappingData类
package com.lbf.database.map;
import java.io.Serializable;
/**
* 数据映射类(类和表关联)
*/
public class MappingData implements Serializable {
/**
*
*/
private static final long serialVersionUID = 5051257007902027488L;
private MappingClass mappingClass=null;
private MappingTable mappingTable=null;
public MappingData() {
this(new MappingClass(),new MappingTable());
}
public MappingData(MappingClass mappingClass,MappingTable mappingTable) {
this.mappingClass=mappingClass;
this.mappingTable=mappingTable;
}
public MappingClass getMappingClass() {
return mappingClass;
}
public void setMappingClass(MappingClass mappingClass) {
this.mappingClass = mappingClass;
}
public MappingTable getMappingTable() {
return mappingTable;
}
public void setMappingTable(MappingTable mappingTable) {
this.mappingTable = mappingTable;
}
@Override
public String toString() {
return mappingClass.toString()+"="+mappingTable.toString();
}
}
MappingTable类
package com.lbf.database.map;
import java.io.Serializable;
/**
* 数据映射类(表)
*/
public class MappingTable implements Serializable {
/**
*
*/
private static final long serialVersionUID = -1864473153906695987L;
private String name=null;
private String type=null;
public MappingTable() {
this("","");
}
public MappingTable(String name,String type) {
this.name=name;
this.type=type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public String toString() {
return "Table:"+name+"-"+type;
}
}