30个类手写Spring核心原理之自定义ORM（下）（7）

value = Enum.valueOf(enumClass, (String) value);

}

//BeanUtils.setProperty(target, fieldName, value);

try {

if(value != null){

setter.invoke(target, setter.getParameterTypes()[0].cast(value));

}

} catch (Exception e) {

e.printStackTrace();

/**

• 出错原因如果是boolean字段、mysql字段类型，设置tinyint(1)

*/

System.err.println(fieldName + “–” + value);

}

}

}

3.3 QueryRuleSqlBuilder

QueryRuleSqlBuilder根据用户构建好的QueryRule来自动生成SQL语句，代码如下：

package com.tom.orm.framework;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.lang.ArrayUtils;

import com.tom.orm.framework.QueryRule.Rule;

import javax.core.common.utils.StringUtils;

/**

• 根据QueryRule自动构建SQL语句

*/

public class QueryRuleSqlBuilder {

private int CURR_INDEX = 0; //记录参数所在的位置

private List properties; //保存列名列表

private List values; //保存参数值列表

private List orders; //保存排序规则列表

private String whereSql = “”;

private String orderSql = “”;

private Object [] valueArr = new Object[]{};

private Map<Object,Object> valueMap = new HashMap<Object,Object>();

/**

• 获得查询条件

• @return

*/

public String getWhereSql(){

return this.whereSql;

}

/**

• 获得排序条件

• @return

*/

public String getOrderSql(){

return this.orderSql;

}

/**

• 获得参数值列表

• @return

*/

public Object [] getValues(){

return this.valueArr;

}

/**

• 获取参数列表

• @return

*/

public Map<Object,Object> getValueMap(){

return this.valueMap;

}

/**

• 创建SQL构造器

• @param queryRule

*/

public QueryRuleSqlBuilder(QueryRule queryRule) {

CURR_INDEX = 0;

properties = new ArrayList();

values = new ArrayList();

orders = new ArrayList();

for (QueryRule.Rule rule : queryRule.getRuleList()) {

switch (rule.getType()) {

case QueryRule.BETWEEN:

processBetween(rule);

break;

case QueryRule.EQ:

processEqual(rule);

break;

case QueryRule.LIKE:

processLike(rule);

break;

case QueryRule.NOTEQ:

processNotEqual(rule);

break;

case QueryRule.GT:

processGreaterThen(rule);

break;

case QueryRule.GE:

processGreaterEqual(rule);

break;

case QueryRule.LT:

processLessThen(rule);

break;

case QueryRule.LE:

processLessEqual(rule);

break;

case QueryRule.IN:

processIN(rule);

break;

case QueryRule.NOTIN:

processNotIN(rule);

break;

case QueryRule.ISNULL:

processIsNull(rule);

break;

case QueryRule.ISNOTNULL:

processIsNotNull(rule);

break;

case QueryRule.ISEMPTY:

processIsEmpty(rule);

break;

case QueryRule.ISNOTEMPTY:

processIsNotEmpty(rule);

break;

case QueryRule.ASC_ORDER:

processOrder(rule);

break;

case QueryRule.DESC_ORDER:

processOrder(rule);

break;

default:

throw new IllegalArgumentException(“type " + rule.getType() + " not supported.”);

}

}

//拼装where语句

appendWhereSql();

//拼装排序语句

appendOrderSql();

//拼装参数值

appendValues();

}

/**

• 去掉order

• @param sql

• @return

*/

protected String removeOrders(String sql) {

Pattern p = Pattern.compile(“order\sby[\w|\W|\s|\S]”, Pattern.CASE_INSENSITIVE);

Matcher m = p.matcher(sql);

StringBuffer sb = new StringBuffer();

while (m.find()) {

m.appendReplacement(sb, “”);

}

m.appendTail(sb);

return sb.toString();

}

/**

• 去掉select

• @param sql

• @return

*/

protected String removeSelect(String sql) {

if(sql.toLowerCase().matches(“from\s+”)){

int beginPos = sql.toLowerCase().indexOf(“from”);

return sql.substring(beginPos);

}else{

return sql;

}

}

/**

• 处理like

• @param rule

*/

private void processLike(QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

Object obj = rule.getValues()[0];

if (obj != null) {

String value = obj.toString();

if (!StringUtils.isEmpty(value)) {

value = value.replace(‘*’, ‘%’);

obj = value;

}

}

add(rule.getAndOr(),rule.getPropertyName(),“like”,“%”+rule.getValues()[0]+“%”);

}

/**

• 处理between

• @param rule

*/

private void processBetween(QueryRule.Rule rule) {

if ((ArrayUtils.isEmpty(rule.getValues()))

|| (rule.getValues().length < 2)) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“”,“between”,rule.getValues()[0],“and”);

add(0,“”,“”,“”,rule.getValues()[1],“”);

}

/**

• 处理 =

• @param rule

*/

private void processEqual(QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“=”,rule.getValues()[0]);

}

/**

• 处理 <>

• @param rule

*/

private void processNotEqual(QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“<>”,rule.getValues()[0]);

}

/**

• 处理 >

• @param rule

*/

private void processGreaterThen(

QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“>”,rule.getValues()[0]);

}

/**

• 处理>=

• @param rule

*/

private void processGreaterEqual(

QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“>=”,rule.getValues()[0]);

}

/**

• 处理<

• @param rule

*/

private void processLessThen(QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“<”,rule.getValues()[0]);

}

/**

• 处理<=

• @param rule

*/

private void processLessEqual(

QueryRule.Rule rule) {

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

add(rule.getAndOr(),rule.getPropertyName(),“<=”,rule.getValues()[0]);

}

/**

• 处理 is null

• @param rule

*/

private void processIsNull(QueryRule.Rule rule) {

add(rule.getAndOr(),rule.getPropertyName(),“is null”,null);

}

/**

• 处理 is not null

• @param rule

*/

private void processIsNotNull(QueryRule.Rule rule) {

add(rule.getAndOr(),rule.getPropertyName(),“is not null”,null);

}

/**

• 处理 <>‘’

• @param rule

*/

private void processIsNotEmpty(QueryRule.Rule rule) {

add(rule.getAndOr(),rule.getPropertyName(),“<>”,“‘’”);

}

/**

• 处理 =‘’

• @param rule

*/

private void processIsEmpty(QueryRule.Rule rule) {

add(rule.getAndOr(),rule.getPropertyName(),“=”,“‘’”);

}

/**

• 处理in和not in

• @param rule

• @param name

*/

private void inAndNotIn(QueryRule.Rule rule,String name){

if (ArrayUtils.isEmpty(rule.getValues())) {

return;

}

if ((rule.getValues().length == 1) && (rule.getValues()[0] != null)

&& (rule.getValues()[0] instanceof List)) {

List list = (List) rule.getValues()[0];

if ((list != null) && (list.size() > 0)){

for (int i = 0; i < list.size(); i++) {

if(i == 0 && i == list.size() - 1){

add(rule.getAndOr(),rule.getPropertyName(),“”,name + " (“,list.get(i),”)");

}else if(i == 0 && i < list.size() - 1){

add(rule.getAndOr(),rule.getPropertyName(),“”,name + " (“,list.get(i),”");

}

if(i > 0 && i < list.size() - 1){

add(0,“”,“,”,“”,list.get(i),“”);

}

if(i == list.size() - 1 && i != 0){

add(0,“”,“,”,“”,list.get(i),“)”);

}

}

}

} else {

Object[] list = rule.getValues();

for (int i = 0; i < list.length; i++) {

if(i == 0 && i == list.length - 1){

add(rule.getAndOr(),rule.getPropertyName(),“”,name + " (“,list[i],”)");

}else if(i == 0 && i < list.length - 1){

add(rule.getAndOr(),rule.getPropertyName(),“”,name + " (“,list[i],”");

}

if(i > 0 && i < list.length - 1){

add(0,“”,“,”,“”,list[i],“”);

}

if(i == list.length - 1 && i != 0){

add(0,“”,“,”,“”,list[i],“)”);

}

}

}

}

/**

• 处理 not in

• @param rule

*/

private void processNotIN(QueryRule.Rule rule){

inAndNotIn(rule,“not in”);

}

/**

• 处理 in

• @param rule

*/

private void processIN(QueryRule.Rule rule) {

inAndNotIn(rule,“in”);

}

/**

• 处理 order by

• @param rule 查询规则

*/

private void processOrder(Rule rule) {

switch (rule.getType()) {

case QueryRule.ASC_ORDER:

//propertyName非空

if (!StringUtils.isEmpty(rule.getPropertyName())) {

orders.add(Order.asc(rule.getPropertyName()));

}

break;

case QueryRule.DESC_ORDER:

//propertyName非空

if (!StringUtils.isEmpty(rule.getPropertyName())) {

orders.add(Order.desc(rule.getPropertyName()));

}

break;

default:

break;

}

}

/**

• 加入SQL查询规则队列

• @param andOr and 或者 or

• @param key 列名

• @param split 列名与值之间的间隔

• @param value 值

*/

private void add(int andOr,String key,String split ,Object value){

add(andOr,key,split,“”,value,“”);

}

/**

• 加入SQL查询规则队列

• @param andOr and 或则 or

• @param key 列名

• @param split 列名与值之间的间隔

• @param prefix 值前缀

• @param value 值

• @param suffix 值后缀

*/

private void add(int andOr,String key,String split,String prefix,Object value,String suffix){

String andOrStr = (0 == andOr ? “” :(QueryRule.AND == andOr ? " and " : " or "));

properties.add(CURR_INDEX, andOrStr + key + " " + split + prefix + (null != value ? " ? " : " ") + suffix);

if(null != value){

values.add(CURR_INDEX,value);

CURR_INDEX ++;

}

}

/**

• 拼装 where 语句

*/

private void appendWhereSql(){

StringBuffer whereSql = new StringBuffer();

for (String p : properties) {

whereSql.append§;

}

this.whereSql = removeSelect(removeOrders(whereSql.toString()));

}

/**

• 拼装排序语句

*/

private void appendOrderSql(){

StringBuffer orderSql = new StringBuffer();

for (int i = 0 ; i < orders.size(); i ++) {

if(i > 0 && i < orders.size()){

orderSql.append(“,”);

}

orderSql.append(orders.get(i).toString());

}

this.orderSql = removeSelect(removeOrders(orderSql.toString()));

}

/**

• 拼装参数值

*/

private void appendValues(){

Object [] val = new Object[values.size()];

for (int i = 0; i < values.size(); i ++) {

val[i] = values.get(i);

valueMap.put(i, values.get(i));

}

this.valueArr = val;

}

}

3.4 BaseDaoSupport

BaseDaoSupport主要是对JdbcTemplate的包装，下面讲一下其重要代码，请“小伙伴们” 关 注 公 众 号 『 Tom弹架构 』，回复 " Spring " 可下载全部源代码。先看全局定义：

package com.tom.orm.framework;

…

/**

• BaseDao 扩展类，主要功能是支持自动拼装SQL语句，必须继承方可使用

• @author Tom

*/

public abstract class BaseDaoSupport<T extends Serializable, PK extends Serializable> implements BaseDao<T,PK> {

private Logger log = Logger.getLogger(BaseDaoSupport.class);

private String tableName = “”;

private JdbcTemplate jdbcTemplateWrite;

private JdbcTemplate jdbcTemplateReadOnly;

private DataSource dataSourceReadOnly;

private DataSource dataSourceWrite;

private EntityOperation op;

@SuppressWarnings(“unchecked”)

protected BaseDaoSupport(){

try{

Class entityClass = GenericsUtils.getSuperClassGenricType(getClass(), 0);

op = new EntityOperation(entityClass,this.getPKColumn());

this.setTableName(op.tableName);

}catch(Exception e){

e.printStackTrace();

}

}

protected String getTableName() { return tableName; }

protected DataSource getDataSourceReadOnly() { return dataSourceReadOnly; }

protected DataSource getDataSourceWrite() { return dataSourceWrite; }

/**

• 动态切换表名

*/

protected void setTableName(String tableName) {

if(StringUtils.isEmpty(tableName)){

this.tableName = op.tableName;

}else{

this.tableName = tableName;

}

}

protected void setDataSourceWrite(DataSource dataSourceWrite) {

this.dataSourceWrite = dataSourceWrite;

jdbcTemplateWrite = new JdbcTemplate(dataSourceWrite);

}

protected void setDataSourceReadOnly(DataSource dataSourceReadOnly) {

this.dataSourceReadOnly = dataSourceReadOnly;

jdbcTemplateReadOnly = new JdbcTemplate(dataSourceReadOnly);

}

private JdbcTemplate jdbcTemplateReadOnly() {

return this.jdbcTemplateReadOnly;

}

private JdbcTemplate jdbcTemplateWrite() {

return this.jdbcTemplateWrite;

}

/**

• 还原默认表名

*/

protected void restoreTableName(){ this.setTableName(op.tableName); }

/**

• 获取主键列名称，建议子类重写

• @return

*/

protected abstract String getPKColumn();

protected abstract void setDataSource(DataSource dataSource);

//此处有省略

}

为了照顾程序员的一般使用习惯，查询方法的前缀命名主要有select、get、load，兼顾Hibernate和MyBatis的命名风格。

/**

• 查询函数，使用查询规则

• 例如以下代码查询条件为匹配的数据

• @param queryRule 查询规则

• @return 查询的结果List

*/

public List select(QueryRule queryRule) throws Exception{

QueryRuleSqlBuilder bulider = new QueryRuleSqlBuilder(queryRule);

String ws = removeFirstAnd(bulider.getWhereSql());

String whereSql = (“”.equals(ws) ? ws : (" where " + ws));

String sql = "select " + op.allColumn + " from " + getTableName() + whereSql;

Object [] values = bulider.getValues();

String orderSql = bulider.getOrderSql();

orderSql = (StringUtils.isEmpty(orderSql) ? " " : (" order by " + orderSql));

sql += orderSql;

log.debug(sql);

return (List) this.jdbcTemplateReadOnly().query(sql, this.op.rowMapper, values);

}

…

/**

• 根据SQL语句执行查询，参数为Object数组对象

• @param sql 查询语句

• @param args 为Object数组

• @return 符合条件的所有对象

*/

public List<Map<String,Object>> selectBySql(String sql,Object… args) throws Exception{

return this.jdbcTemplateReadOnly().queryForList(sql,args);

}

…

/**

• 分页查询函数，使用查询规则
  

• 例如以下代码查询条件为匹配的数据

• @param queryRule 查询规则

• @param pageNo 页号，从1开始

• @param pageSize 每页的记录条数

• @return 查询的结果Page

*/

public Page select(QueryRule queryRule,final int pageNo, final int pageSize) throws Exception{

QueryRuleSqlBuilder bulider = new QueryRuleSqlBuilder(queryRule);

Object [] values = bulider.getValues();

String ws = removeFirstAnd(bulider.getWhereSql());

String whereSql = (“”.equals(ws) ? ws : (" where " + ws));

String countSql = "select count(1) from " + getTableName() + whereSql;

long count = (Long) this.jdbcTemplateReadOnly().queryForMap(countSql, values).get (“count(1)”);

if (count == 0) {

return new Page();

}

long start = (pageNo - 1) * pageSize;

//在有数据的情况下，继续查询

String orderSql = bulider.getOrderSql();

orderSql = (StringUtils.isEmpty(orderSql) ? " " : (" order by " + orderSql));

String sql = “select " + op.allColumn +” from " + getTableName() + whereSql + orderSql + " limit " + start + “,” + pageSize;

List list = (List) this.jdbcTemplateReadOnly().query(sql, this.op.rowMapper, values);

log.debug(sql);

return new Page(start, count, pageSize, list);

}

…

/**

• 分页查询特殊SQL语句

• @param sql 语句

• @param param 查询条件

• @param pageNo 页码

• @param pageSize 每页内容

• @return

*/

public Page<Map<String,Object>> selectBySqlToPage(String sql, Object [] param, final int pageNo, final int pageSize) throws Exception {

String countSql = “select count(1) from (” + sql + “) a”;

long count = (Long) this.jdbcTemplateReadOnly().queryForMap(countSql,param).get(“count(1)”);

if (count == 0) {

return new Page<Map<String,Object>>();

}

long start = (pageNo - 1) * pageSize;

sql = sql + " limit " + start + “,” + pageSize;

List<Map<String,Object>> list = (List<Map<String,Object>>) this.jdbcTemplateReadOnly(). queryForList(sql, param);

log.debug(sql);

return new Page<Map<String,Object>>(start, count, pageSize, list);

}

/**

• 获取默认的实例对象

• @param

• @param pkValue

• @param rowMapper

• @return

*/

private T doLoad(Object pkValue, RowMapper rowMapper){

Object obj = this.doLoad(getTableName(), getPKColumn(), pkValue, rowMapper);

if(obj != null){

return (T)obj;

}

return null;

}

插入方法，均以insert开头：

/**

• 插入并返回ID

• @param entity

• @return

*/

public PK insertAndReturnId(T entity) throws Exception{

return (PK)this.doInsertRuturnKey(parse(entity));

}

/**

• 插入一条记录

• @param entity

• @return

*/

public boolean insert(T entity) throws Exception{

return this.doInsert(parse(entity));

}

/**

• 批量保存对象.
  

• @param list 待保存的对象List

• @throws InvocationTargetException

• @throws IllegalArgumentException

• @throws IllegalAccessException

*/

public int insertAll(List list) throws Exception {

int count = 0 ,len = list.size(),step = 50000;

Map<String, PropertyMapping> pm = op.mappings;

int maxPage = (len % step == 0) ? (len / step) : (len / step + 1);

for (int i = 1; i <= maxPage; i ++) {

Page page = pagination(list, i, step);

String sql = "insert into " + getTableName() + “(” + op.allColumn + ") values “;// (” + valstr.toString() + “)”;

StringBuffer valstr = new StringBuffer();

Object[] values = new Object[pm.size() * page.getRows().size()];

for (int j = 0; j < page.getRows().size(); j ++) {

if(j > 0 && j < page.getRows().size()){ valstr.append(“,”); }

valstr.append(“(”);

int k = 0;

for (PropertyMapping p : pm.values()) {

values[(j * pm.size()) + k] = p.getter.invoke(page.getRows().get(j));

if(k > 0 && k < pm.size()){ valstr.append(“,”); }

valstr.append(“?”);

k ++;

}

valstr.append(“)”);

}

int result = jdbcTemplateWrite().update(sql + valstr.toString(), values);

count += result;

}

return count;

}

private Serializable doInsertRuturnKey(Map<String,Object> params){

final List values = new ArrayList();

final String sql = makeSimpleInsertSql(getTableName(),params,values);

KeyHolder keyHolder = new GeneratedKeyHolder();

final JdbcTemplate jdbcTemplate = new JdbcTemplate(getDataSourceWrite());

try {

jdbcTemplate.update(new PreparedStatementCreator() {

public PreparedStatement createPreparedStatement(

Connection con) throws SQLException {

PreparedStatement ps = con.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);

for (int i = 0; i < values.size(); i++) {

ps.setObject(i+1, values.get(i)==null?null:values.get(i));

}

return ps;

}

}, keyHolder);

} catch (DataAccessException e) {

log.error(“error”,e);

}

if (keyHolder == null) { return “”; }

Map<String, Object> keys = keyHolder.getKeys();

if (keys == null || keys.size() == 0 || keys.values().size() == 0) {

return “”;

}

Object key = keys.values().toArray()[0];

if (key == null || !(key instanceof Serializable)) {

return “”;

}

if (key instanceof Number) {

//Long k = (Long) key;

Class clazz = key.getClass();

// return clazz.cast(key);

return (clazz == int.class || clazz == Integer.class) ? ((Number) key).intValue() : ((Number)key).longValue();

} else if (key instanceof String) {

return (String) key;

} else {

return (Serializable) key;

}

}

/**

• 插入

• @param params

• @return

*/

private boolean doInsert(Map<String, Object> params) {

String sql = this.makeSimpleInsertSql(this.getTableName(), params);

int ret = this.jdbcTemplateWrite().update(sql, params.values().toArray());

return ret > 0;

}

删除方法，均以delete开头：

/**

• 删除对象.
  

• @param entity 待删除的实体对象

*/

public boolean delete(T entity) throws Exception {

return this.doDelete(op.pkField.get(entity)) > 0;

}

/**

• 删除对象.
  

• @param list 待删除的实体对象列表

• @throws InvocationTargetException

• @throws IllegalArgumentException

• @throws IllegalAccessException

*/

public int deleteAll(List list) throws Exception {

String pkName = op.pkField.getName();

int count = 0 ,len = list.size(),step = 1000;

Map<String, PropertyMapping> pm = op.mappings;

int maxPage = (len % step == 0) ? (len / step) : (len / step + 1);

for (int i = 1; i <= maxPage; i ++) {

StringBuffer valstr = new StringBuffer();

Page page = pagination(list, i, step);

Object[] values = new Object[page.getRows().size()];

for (int j = 0; j < page.getRows().size(); j ++) {

if(j > 0 && j < page.getRows().size()){ valstr.append(“,”); }

values[j] = pm.get(pkName).getter.invoke(page.getRows().get(j));

valstr.append(“?”);

}

String sql = “delete from " + getTableName() + " where " + pkName + " in (” + valstr.toString() + “)”;

int result = jdbcTemplateWrite().update(sql, values);

count += result;

}

return count;

}

/**

• 根据id删除对象。如果有记录则删之，没有记录也不报异常
  

• 例如：删除主键唯一的记录

• @param id 序列化id

*/

protected void deleteByPK(PK id) throws Exception {

this.doDelete(id);

}

/**

• 删除实例对象，返回删除记录数

• @param tableName

• @param pkName

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
List list) throws Exception {

String pkName = op.pkField.getName();

int count = 0 ,len = list.size(),step = 1000;

Map<String, PropertyMapping> pm = op.mappings;

int maxPage = (len % step == 0) ? (len / step) : (len / step + 1);

for (int i = 1; i <= maxPage; i ++) {

StringBuffer valstr = new StringBuffer();

Page page = pagination(list, i, step);

Object[] values = new Object[page.getRows().size()];

for (int j = 0; j < page.getRows().size(); j ++) {

if(j > 0 && j < page.getRows().size()){ valstr.append(“,”); }

values[j] = pm.get(pkName).getter.invoke(page.getRows().get(j));

valstr.append(“?”);

}

String sql = “delete from " + getTableName() + " where " + pkName + " in (” + valstr.toString() + “)”;

int result = jdbcTemplateWrite().update(sql, values);

count += result;

}

return count;

}

/**

• 根据id删除对象。如果有记录则删之，没有记录也不报异常
  

• 例如：删除主键唯一的记录

• @param id 序列化id

*/

protected void deleteByPK(PK id) throws Exception {

this.doDelete(id);

}

/**

• 删除实例对象，返回删除记录数

• @param tableName

• @param pkName

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-eZMCf8u3-1714714354727)]

[外链图片转存中…(img-OaNTBP1I-1714714354727)]

[外链图片转存中…(img-rgK4KDpS-1714714354727)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！