用反射写的BaseDao

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量112 收藏 1
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/u/1413786/blog/180437
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.bjsxt.wuye.util.DBUtil;
import com.bjsxt.wuye.util.GetNameUtil;
import com.bjsxt.wuye.util.PageUtil;

@SuppressWarnings("unchecked")
public class BaseDao{
	/**
	 * 拼接oracle  分页sql语句
	 * @param sql
	 * @return
	 */
	public String getOraclePageSql(String sql){
		StringBuffer sqlBuffer = new StringBuffer("select * from (select a_tab_01.*,rownum a_row_num_r  from (");
		sqlBuffer.append(sql);
		sqlBuffer.append("	) a_tab_01 where rownum<=?) b_tab_02 where a_row_num_r>=?");
		return sqlBuffer.toString();
	}
	/**
	 * 单表 等值查询   分页
	 * @param objVo
	 * @param pageNumStr
	 * @param pageSize
	 * @return
	 */
	public PageUtil queryListByPage(Object objVo,String pageNumStr,String pageSize) 
	throws ClassNotFoundException, SQLException, SecurityException, 
	IllegalArgumentException, InstantiationException, 
	IllegalAccessException, NoSuchFieldException, 
	NoSuchMethodException, InvocationTargetException{
		List  sqlAndParamList = getSqlAndParam(objVo, "");
		if(sqlAndParamList != null&&sqlAndParamList.size()>0){
			StringBuffer sql = (StringBuffer) sqlAndParamList.get(0);
			List paramList = (List) sqlAndParamList.get(1);
			return queryListByPage(sql.toString(),objVo.getClass(),pageNumStr,pageSize,paramList.toArray());
		}
		return null;
	}
	/**分页查询
	 * @param sql
	 * @param c
	 * @param pageNumStr
	 * @param pageSize
	 * @param param
	 * @return
	 */
	public PageUtil queryListByPage(String sql,Class c,String pageNumStr,String pageSize,Object...param) 
	throws ClassNotFoundException, SQLException, SecurityException, 
	IllegalArgumentException, InstantiationException, 
	IllegalAccessException, NoSuchFieldException, 
	NoSuchMethodException, InvocationTargetException{
		if(c!=null){
			String totalSql = "select count(*)  from "+sql.split("from")[1];//获取统计记录总数的sql语句
			int totalCount = getTotalCount(totalSql,param);
			//创建 PageUtil对象
			PageUtil pageUtil = new PageUtil(pageSize,pageNumStr,totalCount);
			//获取连接
			Connection conn = DBUtil.getConn();
			//获取Oracle 分页的查询语句
			sql = getOraclePageSql(sql);
			//预处理sql语句
			PreparedStatement ps = conn.prepareStatement(sql);
			//填坑
			setPsValue(ps, param);
			//把分页条件 从第几条记录到第几条记录数据补充到PreparedStatement对象
			ps.setObject(param==null?1:param.length+1, pageUtil.getRowEnd());
			ps.setObject(param==null?2:param.length+2, pageUtil.getRowStart());
			//获取结果集
			ResultSet rs = ps.executeQuery();
			//将结果集放入vo，再放入list容器
			List resultList = addList(rs, c);
			//关闭对象
			DBUtil.close(conn, ps, rs);
			pageUtil.setList(resultList);
			return pageUtil;
		}else{
			System.out.println("反射对象不能为null");
			return null;
		}
	}

	/**
	 * 查询并返回对象结果集 
	 * @param sql  输入的sql语句
	 * @param c   相对应的类
	 * @param param  准备填坑的参数
	 * @return  返回查询到的对象结果集List
	 */
	public List queryList(String sql,Class c,Object...param) throws ClassNotFoundException, 
			SQLException, InstantiationException, IllegalAccessException, 
			SecurityException, NoSuchFieldException, NoSuchMethodException,
			IllegalArgumentException, InvocationTargetException {
		if(c != null){
			//第一步：  获取连接
			Connection conn = DBUtil.getConn();
			//第二步：  sql 语句 挖坑    预处理sql语句
			PreparedStatement  ps  = conn.prepareStatement(sql);
			//第三步：  给sql语句填坑
			setPsValue(ps,param);
			//第四步： 执行查询
			ResultSet  rs = ps.executeQuery();
			//根据输入的sql语句和对应的填坑参数返回查询到的对象List
			List resultList = addList(rs, c);  
			DBUtil.close(conn, ps, rs);  //关闭与数据库的链接
			return resultList;
		}else{
			System.out.println("反射对象不能为null");
			return null;
		}
    }
	
	/**
	 * 填坑
	 * @param ps 预处理对象
	 * @param param  准备填坑的参数
	 */
	private void setPsValue(PreparedStatement ps,Object...param) throws SQLException{
		if(param !=null&&param.length>0){
			for(int i = 0;i<param.length;i++){
				ps.setObject(i+1,param[i]);
			}
		}
	}

	/**
	 * 查询并返回对象结果集 
	 * @param rs  查询到的结果集
	 * @param c   结果集要赋值给的相关类
	 * @return  返回查询到的对象List
	 */
	public List addList(ResultSet rs,Class c) throws SQLException, InstantiationException, 
	IllegalAccessException, SecurityException, NoSuchFieldException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException{
		List resultList  = new ArrayList();
		//遍历rs中的结果集
		while(rs.next()){
			//把rs结果集赋给对应的类对象,然后获取相对应的类对象
			Object obj = setObjectFieldValue(rs,c);
			resultList.add(obj);  
		}
		return resultList;
	}
	
	/**
	 * 给vo对象属性赋值
	 * @param rs  查询到的结果集
	 * @param c  结果集要插入的对应类
	 * @return  获取对应的类对象
	 */
	private Object setObjectFieldValue(ResultSet rs,Class c) throws SQLException, SecurityException, NoSuchFieldException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException{
		ResultSetMetaData rsmd = rs.getMetaData();  //获取rs中的元数据
		int colCount = rsmd.getColumnCount();   //获取rs中有多少列
		Object obj = c.newInstance();          //创建vo对象
		for(int i = 1;i<=colCount;i++){
			String colName = rsmd.getColumnName(i);  //获取sql语句中字段名
			if(!colName.toLowerCase().equals("a_row_num_r")){
				String fieldName = GetNameUtil.getFieldNameByColName(colName);  //根据sql语句中字段名获取属性名
				String setter = GetNameUtil.getSetter(fieldName);  //通过属性名获取设定器名
				Field field = c.getDeclaredField(fieldName);   //获取VO类中的属性名
				//获取设定器对应的映射方法
				Method m = c.getDeclaredMethod(setter, field.getType());
				Object value = rs.getObject(i);  //获取rs中查询到和属性名对应的值
				//调用设定器
				invokeSetter(value,field,m,obj);
			}
		}
		return obj;
	}
	
	/**
	 * 不同类型下调用设定器
	 * @param value  属性名对应的值
	 * @param field  属性名
	 * @param m  和属性吗对应的方法
	 * @param obj  和属性名对应的类对象
	 */
	private void invokeSetter(Object value,Field field,Method m,Object obj) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		if(value !=null){
			if(value.getClass()==BigDecimal.class){//判断 字段结果类型是否是BigDecimal
				BigDecimal bd = (BigDecimal)value;  //强制类型转换
				if(field.getType()==Integer.class||field.getType()==int.class){//属性类型是Integer
					m.invoke(obj, bd.intValue());
				}else if(field.getType()==Double.class||field.getType()==double.class){
					m.invoke(obj, bd.doubleValue());
				}else if(field.getType()==Float.class||field.getType()==float.class){
					m.invoke(obj, bd.floatValue());
				}else if(field.getType()==Byte.class||field.getType()==byte.class){
					m.invoke(obj, bd.byteValue());
				}else if(field.getType()==long.class||field.getType()==Long.class){
					m.invoke(obj, bd.longValue());
				}else if(field.getType()==Short.class||field.getType()==short.class){
					m.invoke(obj, bd.shortValue());
				}
			}else{
				m.invoke(obj,value);
			}
		}
	}
	
	/**
	 * 根据条件进行单表查询 
	 * @param objVo  类对象
	 * @return 得到查询到的对象结果集
	 */
	public List queryList(Object objVo) throws SecurityException, NoSuchMethodException,
	IllegalArgumentException, IllegalAccessException,
	InvocationTargetException, ClassNotFoundException, 
	SQLException, InstantiationException, NoSuchFieldException{
		//获取sql语句和参数聚合集
		List sqlAndParamList = getSqlAndParam(objVo,"");
		if(sqlAndParamList != null&&sqlAndParamList.size()>0){
			String sql = sqlAndParamList.get(0).toString();
			List paramList = (List) sqlAndParamList.get(1);
			//调用  查询结果集的方法
			return queryList(sql,objVo.getClass(),paramList.toArray());
		}
		return null;
	}
	/**
	 * 获取属性值
	 * @param field 属性名
	 * @param objVo 属性名对应类对象
	 * @return  得到获取的属性值
	 */
	private  Object getFieldValue(Field field,Object objVo) throws SecurityException, 
			NoSuchMethodException, IllegalArgumentException, 
			IllegalAccessException, InvocationTargetException{
		String getter = GetNameUtil.getGetter(field);   //获取取值器名
		Method m = objVo.getClass().getDeclaredMethod(getter);  //获取取值器
		Object value = m.invoke(objVo);
		return value;
	}
	
	/**
	 * 获取sql语句和参数聚合集
	 * @param objVo  sql语句对应的类对象
	 * @return 得到sql语句和参数聚合集
	 */
	private List  getSqlAndParam(Object objVo,String remark) throws SecurityException, 
			NoSuchMethodException, IllegalArgumentException,
			IllegalAccessException, InvocationTargetException{
		List resultList = new ArrayList();
		List paramList = new ArrayList();
		Class c = objVo.getClass();  //根据对象名获取类名
		String tabName = GetNameUtil.getTabOrColName(c.getSimpleName());  //根据类名获取表明
		String sqlPre = remark.equals("totalCount")?"select count(*) from  ":"select * from ";
		StringBuffer sql = new StringBuffer(sqlPre+"  "+tabName+"  t where 1=1");
		//获取 参数对象属性名数组
		Field[]  fieldArray = c.getDeclaredFields();  
		//遍历属性名数组获取每个属性值
		for(int i = 0;i<fieldArray.length;i++){
			Object value = getFieldValue(fieldArray[i],objVo);  //获取属性值
			if(value!=null){
				if(value.getClass()!=String.class){
					sql.append("	and  t."+GetNameUtil.getTabOrColName(fieldArray[i].getName())+"=?");  //获取列明
					paramList.add(value);
				}else{
					if(!((String)value).trim().equals("")){
						sql.append("	and  t."+GetNameUtil.getTabOrColName(fieldArray[i].getName())+"=?"); //获取列明
						paramList.add(value);  //把参数置入参数聚合集
					}
				}
			}
		}
		resultList.add(sql);  //得到sql语句
		resultList.add(paramList);  //将参数聚合集放入结果聚合集中
		return resultList;
	}

	/**
	 * 获取记录总数
	 * @param sql  输入的sql语句
	 * @param param  参数集
	 * @return  得到记录总数
	 */
	private int getTotalCount(String sql,Object...param) throws ClassNotFoundException, SQLException{
		//获取连接
		Connection conn = DBUtil.getConn();
		//预处理sql语句
		PreparedStatement ps = conn.prepareStatement(sql);
		//填坑
		setPsValue(ps, param);
		//获取rs结果集
		ResultSet  rs = ps.executeQuery();
		//获取记录总数
		int count = rs.next()?rs.getInt(1):0;
		DBUtil.close(conn, ps, rs);
		return count;	
	}
	/**
	 * 获取记录总数
	 * @param objVo 类对象
	 * @return  得到查询记录数
	 */
	public int getTotalCount(Object objVo) throws SecurityException, IllegalArgumentException,
	NoSuchMethodException, IllegalAccessException,
	InvocationTargetException, ClassNotFoundException, SQLException{
		List sqlAndParamList = getSqlAndParam(objVo,"totalCount");  //获取sql语句和参数聚合集
		if(sqlAndParamList != null&&sqlAndParamList.size()>0){
			String sql = sqlAndParamList.get(0).toString();
			List paramList = (List) sqlAndParamList.get(1);
			//调用  查询结果集的方法
			return getTotalCount(sql,paramList.toArray());
		}
		return 0;
	}
	
	/**
	 * 根据Id获取单条记录
	 * @param objVo  对象
	 * @return  得到查询到的对象
	 */
	public  Object queryObjectById(Object objVo) throws SecurityException, IllegalArgumentException,
	NoSuchMethodException, IllegalAccessException,
	InvocationTargetException, ClassNotFoundException, 
	SQLException, InstantiationException, 
	NoSuchFieldException{
		List list = queryList(objVo); //查询到对应的对象结果集
		if(list!=null&&list.size()>0){
			return list.get(0);
		}
		return null;
	}
	
	/**
	 * 向数据库中插入数据
	 * @param objVo  对应 插入数据的类对象
	 * @param preKeyField  sql语句中的对应相关表的主键
	 */
	public void  addVo(Object objVo,String preKeyField) throws SecurityException, 
	NoSuchMethodException, IllegalArgumentException, IllegalAccessException, 
	InvocationTargetException, ClassNotFoundException, SQLException{
			//创建装参数的集合
			List paramList = new ArrayList();
			//获取反射对象
		  	Class c = objVo.getClass();
			String tabName = GetNameUtil.getTabOrColName(c.getSimpleName());  //获取表名
			StringBuffer sql = new StringBuffer("insert into "+tabName+"  values(");
			//获取类对象中的属性名数组
			Field[] fieldArray = c.getDeclaredFields();
			//遍历属性名
			for(int i = 0;i<fieldArray.length;i++){
				String fieldName = fieldArray[i].getName();
				if(!fieldName.equals(preKeyField)){
					sql.append("?,");
					Object value = getFieldValue(fieldArray[i], objVo);  //获取属性值
					paramList.add(value);  //把属性值装入参数聚合集
				} else{
					sql.append("seq_"+tabName+".nextval,");  //获取sql语句中的递增值
				}
			}
			sql.deleteCharAt(sql.length()-1);  //去掉sql语句中最后一个逗号
			sql.append(")");
			//添加数据
			modifyVo(sql.toString(),paramList.toArray());
	}
	
	/**
	 * 更新数据库相关记录
	 * @param objVo    要修改的vo对象
	 * @param preKeyField   必写   主键对应的属性名
	 */
	public void updateVo(Object objVo,String... preKeyFields) throws SecurityException, 
			IllegalArgumentException, NoSuchMethodException,
			IllegalAccessException, InvocationTargetException, NoSuchFieldException,
			ClassNotFoundException, SQLException{
		List paramList = new ArrayList();  //创建装参数的集合
	  	Class c = objVo.getClass();  //获取反射对象
		String tabName = GetNameUtil.getTabOrColName(c.getSimpleName()); //获取表名
		//拼接sql
		StringBuffer sql = new StringBuffer("update "+tabName+" t  set ");
		Field[] fieldArray = c.getDeclaredFields();  //获取属性名
		//遍历属性名数组
		for(int i = 0;i<fieldArray.length;i++){
			String fieldName = fieldArray[i].getName();
			int j =0 ;
			for (j = 0; j < preKeyFields.length; j++) {
				if(fieldName.equals(preKeyFields[j])){
					break;
				}	
			}
			Object value = getFieldValue(fieldArray[i], objVo);  //获取属性值
			if(j>=preKeyFields.length && null != value && !"".equals(value)){
				sql.append("t."+GetNameUtil.getTabOrColName(fieldName)+"=? ,");
					paramList.add(value);  //将得到的属性值装入参数聚合集
			}
		}
		sql.deleteCharAt(sql.length()-1);
		sql.append(" where t."+GetNameUtil.getTabOrColName(preKeyFields[0])+"=? ");	
		for(int i=1; i<preKeyFields.length;i++){
			sql.append(" and "+GetNameUtil.getTabOrColName(preKeyFields[i])+"=? ");
		}
		System.out.println(sql);
		//根据传进来的主键名字  获取主键对应的属性名 
		for(String preKeyField:preKeyFields){
			Field preKeyFieldObj = c.getDeclaredField(preKeyField);
			//获取主键对应的属性值
			Object keyValue = getFieldValue(preKeyFieldObj, objVo);
			//将主键的值装入参数聚合
			paramList.add(keyValue);
			//修改信息	
		}
		modifyVo(sql.toString(),paramList.toArray());
	}
	/**
	 * 删除数据库单条记录
	 * @param objVo  装有主键参数值的对象
	 * @param preKeyField  主键对应的名字
	 */
	public void deleteVo(Object objVo,String preKeyField) throws SecurityException, NoSuchFieldException, 
	IllegalArgumentException, NoSuchMethodException,
	IllegalAccessException, InvocationTargetException, ClassNotFoundException, SQLException{
		//获取反射对象
	  	Class c = objVo.getClass();
		String tabName = GetNameUtil.getTabOrColName(c.getSimpleName());//获取表名
		//拼接sql
		StringBuffer sql = new StringBuffer("delete from "+tabName+" t  where t. "+GetNameUtil.getTabOrColName(preKeyField)+"=?");
		//根据传进来的主键名字  获取主键对应的对像中的属性名
		Field preKeyFieldObj = c.getDeclaredField(preKeyField);
		//获取主键对应的属性值
		Object keyValue = getFieldValue(preKeyFieldObj, objVo);
		//删除单条记录
		modifyVo(sql.toString(),keyValue);
	}
	
	/**
	 * 增删改公用的方法
	 * @param sql 输入的sql语句
	 * @param param  参数聚合集
	 */
	private void modifyVo(String sql,Object...param) throws ClassNotFoundException, SQLException{
		//获取连接
		Connection conn = DBUtil.getConn();
		//预处理sql语句
		PreparedStatement ps = conn.prepareStatement(sql);
		//填坑
		setPsValue(ps, param);
		//执行
		ps.executeUpdate();
		//关闭
		DBUtil.close(conn, ps, null);
	}
}




转载于:https://my.oschina.net/u/1413786/blog/180437

weixin_34261739
关注
Java利用自定义注解、反射实现简单BaseDao实例
08-29
下面小编就为大家带来一篇Java利用自定义注解、反射实现简单BaseDao实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
BaseDao Java利用反射技术原生实现BaseDao<T>，自动拼装SQL语句
Linux下配置Tomcat
05-31 1276
Java利用反射技术原生实现BaseDao，自动拼装SQL语句这里我用了注解+反射首先声明三个注解： import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.R...
反射写的BaseDAO
weixin_30312659的博客
02-04 107
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import jav...
使用注解反射实现BaseDao(代替XML配置)
u013905744的专栏
09-13 1697
java 注解 代替 XML配置
利用反射写BaseDao
weixin_50995341的博客
11-14 117
package com.lyl.dao; import com.lyl.entity.Question; import com.lyl.util.EntityUtil; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.sql.*; import java.util.ArrayList; i
基于注解反射封装的BaseDao（支持一对多查询）
01-26
本篇将深入探讨如何利用注解和反射机制来封装一个支持一对多查询的 `BaseDao`。 首先，我们需要了解注解（Annotation）。注解是Java提供的一种元数据，它为编译器和工具提供了信息，可以用于代码验证、代码生成、...
基于反射和元数据强大BaseDao(JDBC),无需遍历结果集,超方便的
08-20
可以将从数据库中查到的数据直接封到实体类！！！基于反射和元数据
基于JDBC封装的BaseDao(实例代码)
09-02
在构造函数中，通过`JdbcUtil.getConnection()`获取数据库连接，并通过反射机制获取`BaseDao`的父类泛型类型，从而得到`persistentClass`，这样我们就可以知道这个`BaseDao`实例对应的是哪个实体类。 `BaseDao`的...
BaseDao代码
12-04
然后，利用反射机制加载数据库驱动，并通过`DriverManager`的`getConnection`方法创建数据库连接。如果在加载驱动或创建连接时发生异常，方法将返回`false`，表示连接失败；否则返回`true`，表示连接成功。 #### 2....
java泛型详解和反射泛型通用BaseDao实现
nwpu_geeker的博客
12-05 5217
一 泛型的基本概念 1.1什么是泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。1.2泛型的作用？ JDK5中的泛型允许程序员在编写集合代码时，就限制集合
java反射机制运用到BaseDao等通用基类
q739404976的博客
01-17 895
反射中主要应用的方法： 1.获取类的Class对象  推荐使用： 第一种。通过Class.forName获取Class对象.     //方式1：通过Class.forName获取Class对象. Class clazz1 = Class.forName("cn.itcast.reflect.Person"); // System.out.println("clazz1:"+cla
Java利用自定义注解、反射实现简单BaseDao
weixin_30480651的博客
08-29 144
在常见的ORM框架中，大都提供了使用注解方式来实现entity与数据库的映射，这里简单地使用自定义注解与反射来生成可执行的sql语句。 这是整体的目录结构，本来是为复习注解建立的项目^.^ 好的，首先我们来确定思路。 1. 自定义@Table @Column注解， 我们稍微模仿hibernate，让@Table作用于类上，来表明实体类与数据表的映射关系，且让@Table中的属性val...
使用反射机制写一个通用Dao类对数据库进行增删改查操作
qq_40180411的博客
08-10 2191
通用DAO类： package com.xintouyun.dao; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; im...
JDBC使用Java反射万能查询Oracle表数据、插入数据——【JDBC编程】
Cool.R的博客
08-03 771
JDBC使用Java反射获取Oracle表数据——【JDBC编程】 只要提供与表对应的实际类，将该类实例对象作为容器， 记录表中数据并填入list集合容器中遍历输出。
增强版basedao java 反射和映射
y2332879081的博客
07-10 399
public class BaseDao{  String DBUser;  String DBPwd;  String DBHost;//服务器地址  String DBName;  int Port;  int Port2;  int DBType;//1 mysql 2 sqlserver 3 oracle;  Connection conn;  PreparedState
java 使用反射编写通用DAO<T>
阿璐4r的博客
06-28 1105
前言   反射在框架中的应用还是很多的，比如spring框架里面AOP用到的动态代理，而动态代理就是基于反射的。本文主要通过学习java的反射，最后编写通用的DAO类。最近在复习java web，在做数据库访问的时候做了一个事情。   写一个CustomerDAO类（获取数据库连接，执行sql，获取resultSet，获取对象，关闭数据库等操作），用于根据用户名来获取一个用户对象。这个时候有一个新...
Java-网络
最新发布
2301_81543552的博客
09-14 440
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 485
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 599
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
帮我用java写一个 basedao
03-29
这是一个基本的BaseDao类，它使用Java的泛型来支持不同类型的实体对象。它包括以下方法： - `findAll()` - 返回一个包含所有实体对象的列表。 - `findById(int id)` - 根据ID返回一个实体对象。 - `save(T entity)`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值