简介：这个框架封装的JDBC,实体类的属性跟数据库表的字段名保持一致，然后实体类继承Model<实体类>类，就会自动调用实体类的set方法填充数据，自动调用get方法获取数据。
API:这里只封装了用到的4个方法
1：public List<实体类> findAll(String sql){};
调用这个方法会根据sql返回查询表符合条件的数据，返回值是实体类类型的集合。
2：public 实体类 findFirst(String sql){};
调用这个方法会根据sql返回查询表符合条件的第一条数据，返回值是是个实体类类型。
3：public void save(“表名”,”String...”);
插入方法，由于没有映射表名，所以第一个参数要指定表名，第二个参数是String类型的可变形参，可以写多个参数，这些参数要写自增长的字段。
4：public void update(“表名”，“key”);
更改方法，第二个参数是作为更改条件的字段。
实体类 数据库表
public class Depts extends Model<Depts>{ depts
private Integer id; - - id
private String name; - - name
}
package com.sduept.model;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.sduept.oms.JDBCConfig;
public class Model<T extends Model<T>>{
/**
* 保存表数据 第一个参数是表名 剩下的参数是填写自增长字段的字段名
*/
public boolean save(String tableName,String... string){
String sql = "insert into "+tableName+" (";
String value = " values (";
Field[] field = this.getClass().getDeclaredFields(); //获取所有字段
for(int i=0;i<field.length;i++){
String nameLower = field[i].getName();
//将属性的首字符大写，方便构造get，set方法
String nameUpper = nameLower.substring(0,1).toUpperCase() +nameLower.substring(1);
String type = field[i].getGenericType().toString(); //获取属性的类型
boolean boo = isType(type);
boolean grow = true;
if( boo == true ){
try {
grow = isGrow(nameLower,string);
if( grow==true ){
Object object = getMethod(type,this,nameUpper);
if( object==null ){
continue;
}
String str = object.toString();
sql+=nameLower+",";
value+=str+",";
}
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
e.printStackTrace();
}
}
}
sql = sql.substring(0,sql.length()-1)+")";
value = value.substring(0,value.length()-1)+")";
sql += value;
return JDBCConfig.me.insert(sql);
}
/*
* 判断是不是自增长字段
*/
private boolean isGrow(String nameLower,String[] string){
for(int j=0;j<string.length;j++){
if(string[j].equals(nameLower)){
return false;
}
}
return true;
}
/**
* 更改表数据 前提是根据更改的字段必须有值
* 第一个参数是表名 第二个参数是根据哪个字段更改
*/
public boolean update(String tableName,String id){
String sql = "update "+tableName+" set ";
String value = "";
Field[] field = this.getClass().getDeclaredFields(); //获取所有字段
for(int i=0;i<field.length;i++){
String nameLower = field[i].getName();
//将属性的首字符大写，方便构造get，set方法
String nameUpper = nameLower.substring(0,1).toUpperCase() +nameLower.substring(1);
String type = field[i].getGenericType().toString(); //获取属性的类型
boolean boo = isType(type);
if( boo == true ){
try {
Object object = getMethod(type,this,nameUpper);
if( object==null ){ //如果字段没有值 那么不更改
continue;
}
String str = object.toString();
if(!id.equals(nameLower)){ //如果不是主键
sql+=nameLower+"="+str+",";
}else{
value = str;
}
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
e.printStackTrace();
}
}
}
sql = sql.substring(0,sql.length()-1)+" where "+id+"="+value;
return JDBCConfig.me.update(sql);
}
/**
* 查询单个表的所有数据
*/
public List<T> findAll(String sql){
List<T> list = new ArrayList<T>();
T t = getnstance();
Field[] field = t.getClass().getDeclaredFields();
ResultSet rs = JDBCConfig.me.find(sql);
try {
while(rs.next()){
T model = insertField(rs,field);
list.add(model);
}
rs.close();
} catch (SQLException e) {
e.printStackTrace();
} finally{
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return list;
}
/**
* 查询第一条数据 返回一个实体类
*/
public T findFirst(String sql){
T t = getnstance();
Field[] field = t.getClass().getDeclaredFields();
ResultSet rs = JDBCConfig.me.find(sql);
try {
while(rs.next()){
return t = insertField(rs,field);
}
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/*
* 返回一个赋值后的实体类 取数据是一个字段一个字段的取
*/
private T insertField(ResultSet rs,Field[] field){
T t = getnstance();
for(int i=0;i<field.length;i++){
String nameLower = field[i].getName();
String nameUpper = nameLower.substring(0,1).toUpperCase() +nameLower.substring(1);
String type = field[i].getGenericType().toString(); //获取属性的类型
boolean boo = isType(type);
if( boo == true ){
try {
Object o = rs.getObject(nameLower);
setMethod(type,t,nameUpper,o);
} catch(NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e){
e.printStackTrace();
} catch (SQLException e){
continue;
}
}
}
return t;
}
/*
* 返回泛型的实体类 每次调用这个方法返回的都是一个新的实例
*/
private T getnstance(){
Type genType = getClass().getGenericSuperclass();
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
@SuppressWarnings("unchecked")
Class<T> entityClass = (Class<T>) params[0];
T t = null;
try {
t = entityClass.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
return t;
}
/*
* 获得泛型的get方法并执行
*/
private Object getMethod(String type,Model<T> model,String name) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
//如果type是类类型，则前面包含"class "，后面跟类名
if(type.equals("class java.lang.String")){
//调用getter方法获取属性值
Method m = model.getClass().getMethod("get"+name);
String value = (String) m.invoke(model);
if( value==null ){
return null;
}
return "'"+value+"'";
}else if(type.equals("class java.lang.Integer")){
Method m = model.getClass().getMethod("get"+name);
Integer value = (Integer) m.invoke(model);
return value;
}else if(type.equals("class java.lang.Short")){
Method m = model.getClass().getMethod("get"+name);
Short value = (Short) m.invoke(model);
return value;
}else if(type.equals("class java.lang.Double")){
Method m = model.getClass().getMethod("get"+name);
Double value = (Double) m.invoke(model);
return value;
}else if(type.equals("class java.lang.Boolean")){
Method m = model.getClass().getMethod("get"+name);
Boolean value = (Boolean) m.invoke(model);
return value;
}else if(type.equals("class java.util.Date")){
Method m = model.getClass().getMethod("get"+name);
Date value = (Date) m.invoke(model);
if(value==null){
return null;
}
//把长整形转换为字符串日期类型
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");
String date = sdf.format(value);
return "'"+date+"'";
}
return null;
}
/*
* 获得泛型的set方法并执行
*/
private void setMethod(String type,T t,String name,Object o) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
if(type.equals("class java.lang.String")){
Method m = t.getClass().getMethod("set"+name,String.class);
m.invoke(t,o); //调用setter方法
}else if(type.equals("class java.lang.Integer")){
Method m = t.getClass().getMethod("set"+name,Integer.class);
m.invoke(t,isNumber(o));
}else if(type.equals("class java.lang.Short")){
Method m = t.getClass().getMethod("set"+name,Short.class);
m.invoke(t,o);
}else if(type.equals("class java.lang.Double")){
Method m = t.getClass().getMethod("set"+name,Double.class);
m.invoke(t,o);
}else if(type.equals("class java.lang.Boolean")){
Method m = t.getClass().getMethod("set"+name,Boolean.class);
m.invoke(t,o);
}else if(type.equals("class java.util.Date")){
Method m = t.getClass().getMethod("set"+name,Date.class);
m.invoke(t,o);
}
}
private Integer isNumber(Object o){
if( o!=null && !"".equals(o.toString())){
return Integer.parseInt(o.toString());
}
return null;
}
/*
* 判断泛型的属性需不需要获取
*/
private boolean isType(String type){
boolean boo = false;
if(type.equals("class java.lang.String")){
boo = true;
}else if(type.equals("class java.lang.Integer")){
boo = true;
}else if(type.equals("class java.lang.Short")){
boo = true;
}else if(type.equals("class java.lang.Double")){
boo = true;
}else if(type.equals("class java.lang.Boolean")){
boo = true;
}else if(type.equals("class java.util.Date")){
boo = true;
}
return boo;
}
1045
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
