1 Commits

Author SHA1 Message Date
asm 12b04beb1e 取其精华去其糟粕 2026-04-19 03:47:47 +08:00
38 changed files with 318 additions and 515 deletions
+8
View File
@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="AdditionalModuleElements">
<content url="file://$MODULE_DIR$" dumb="true">
<excludeFolder url="file://$MODULE_DIR$/src/main/java/core/handers/news" />
</content>
</component>
</module>
@@ -1,4 +1,4 @@
package core.handers;
package core;
import javax.sql.DataSource;
import java.sql.*;
@@ -1,7 +1,5 @@
package core;
import core.handers.ResultSetHandler;
import core.parameter.ParameterExtractor;
import core.proxy.*;
import javax.sql.DataSource;
-2
View File
@@ -1,7 +1,5 @@
package core;
import core.handers.ResultSetHandler;
import javax.sql.DataSource;
import java.sql.*;
@@ -1,4 +1,4 @@
package core.handers;
package core;
import java.sql.ResultSet;
import java.sql.SQLException;
+1
View File
@@ -11,4 +11,5 @@ import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Id {
String value() default "";
}
@@ -1,7 +1,8 @@
package core.handers;
import core.ResultSetHandler;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
@@ -12,39 +13,15 @@ import java.util.Map;
*
* @param <T> 列表元素类型
*/
public abstract class AbstractListHandler<T> implements ResultSetHandler<List<T>> {
/** 共享的行处理器实例 */
protected static final RowProcessor ROW_PROCESSOR = new BasicRowProcessor();
/** 自定义行处理器(可选) */
private final RowProcessor convert;
/**
* 使用默认BasicRowProcessor
*/
public AbstractListHandler() {
this(ROW_PROCESSOR);
}
/**
* 使用自定义RowProcessor
*
* @param convert 行处理器
*/
public AbstractListHandler(RowProcessor convert) {
this.convert = convert;
}
public abstract class AbstractListHandler<T> extends AbstractResultSetHandler implements ResultSetHandler<List<T>> {
@Override
public List<T> handle(ResultSet rs) throws SQLException {
ResultSetMetaData metaData = rs.getMetaData();
int columnCount = metaData.getColumnCount();
Map<String, Integer> columnIndexMap = ColumnIndexCache.getOrCreate(metaData, columnCount);
List<T> list = createList();
while (rs.next()) {
T row = handleRow(rs, columnIndexMap);
T row = handleRow(rs, getColumnIndexMap(rs));
list.add(row);
}
return list;
@@ -56,18 +33,12 @@ public abstract class AbstractListHandler<T> implements ResultSetHandler<List<T>
* @return 空的List实例
*/
protected List<T> createList() {
return new ArrayList<>();
}
/**
* 获取行处理器
*
* @return RowProcessor实例
*/
protected RowProcessor getRowProcessor() {
return convert;
}
/**
* 处理单行数据
*
@@ -1,7 +1,8 @@
package core.handers;
import core.ResultSetHandler;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
@@ -12,58 +13,26 @@ import java.util.Map;
* @param <K> 键类型
* @param <V> 值类型
*/
public abstract class AbstractMapHandler<K, V> implements ResultSetHandler<Map<K, V>> {
/** 共享的行处理器实例 */
protected static final RowProcessor ROW_PROCESSOR = new BasicRowProcessor();
/** 自定义行处理器(可选) */
private final RowProcessor convert;
/**
* 使用默认BasicRowProcessor
*/
public AbstractMapHandler() {
this(ROW_PROCESSOR);
}
/**
* 使用自定义RowProcessor
*
* @param convert 行处理器
*/
public AbstractMapHandler(RowProcessor convert) {
this.convert = convert;
}
public abstract class AbstractMapHandler<K, V> extends AbstractResultSetHandler implements ResultSetHandler<Map<K, V>> {
@Override
public Map<K, V> handle(ResultSet rs) throws SQLException {
if (rs == null) {
throw new SQLException("ResultSet不能为null");
}
ResultSetMetaData metaData = rs.getMetaData();
int columnCount = metaData.getColumnCount();
Map<String, Integer> columnIndexMap = ColumnIndexCache.getOrCreate(metaData, columnCount);
Map<K, V> map = createMap();
while (rs.next()) {
K key = extractKey(rs, columnIndexMap);
V value = extractValue(rs, columnIndexMap);
K key = extractKey(rs, getColumnIndexMap(rs));
V value = extractValue(rs, getColumnIndexMap(rs));
map.put(key, value);
}
return map;
}
/**
* 获取行处理器
*
* @return RowProcessor实例
*/
protected RowProcessor getRowProcessor() {
return convert;
}
/**
* 创建Map实例
*
@@ -0,0 +1,35 @@
package core.handers;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
/**
* 抽象处理器基类
* 提供通用的RowProcessor管理和列索引缓存功能,消除子类重复代码
*/
public abstract class AbstractResultSetHandler {
private static volatile RowProcessor defaultRowProcessor = new BasicRowProcessor();
protected static void setDefaultRowProcessor(RowProcessor rowProcessor) {
defaultRowProcessor = rowProcessor; // 写 volatile
}
protected RowProcessor getRowProcessor() {
return defaultRowProcessor; // 读 volatile
}
/**
* 获取列索引映射(带缓存)
*
* @param rs ResultSet对象
* @return 列名->索引映射
* @throws SQLException SQL异常
*/
protected Map<String, Integer> getColumnIndexMap(ResultSet rs) throws SQLException {
return ColumnIndexCache.getOrCreate(rs);
}
}
@@ -1,7 +1,8 @@
package core.handers;
import core.ResultSetHandler;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Map;
@@ -10,50 +11,18 @@ import java.util.Map;
*
* @param <T> 对象类型
*/
public abstract class AbstractSingleHandler<T> implements ResultSetHandler<T> {
/** 共享的行处理器实例 */
protected static final RowProcessor ROW_PROCESSOR = new BasicRowProcessor();
/** 自定义行处理器(可选) */
private final RowProcessor convert;
/**
* 使用默认BasicRowProcessor
*/
public AbstractSingleHandler() {
this(ROW_PROCESSOR);
}
/**
* 使用自定义RowProcessor
*
* @param convert 行处理器
*/
public AbstractSingleHandler(RowProcessor convert) {
this.convert = convert;
}
public abstract class AbstractSingleHandler<T> extends AbstractResultSetHandler implements ResultSetHandler<T> {
@Override
public T handle(ResultSet rs) throws SQLException {
if (rs.next()) {
ResultSetMetaData metaData = rs.getMetaData();
int columnCount = metaData.getColumnCount();
Map<String, Integer> columnIndexMap = ColumnIndexCache.getOrCreate(metaData, columnCount);
return handleRow(rs, columnIndexMap);
return handleRow(rs, getColumnIndexMap(rs));
}
return null;
}
/**
* 获取行处理器
*
* @return RowProcessor实例
*/
protected RowProcessor getRowProcessor() {
return convert;
}
/**
* 处理单行数据
*
@@ -1,37 +0,0 @@
package core.handers;
/**
* 数据聚合器接口
* 用于将多行数据聚合成一个结果,支持自定义聚合逻辑
*
* @param <A> 累加器类型,用于在聚合过程中保存中间状态
* @param <T> 输入元素类型,每一行数据转换后的对象
* @param <R> 最终结果类型,聚合完成后的返回值
*/
public interface Aggregator<A, T, R> {
/**
* 创建累加器
* 初始化聚合过程的中间状态容器
*
* @return 新的累加器实例
*/
A createAccumulator();
/**
* 累加元素
* 将单个元素合并到累加器中
*
* @param accumulator 累加器
* @param item 待累加的元素
*/
void accumulate(A accumulator, T item);
/**
* 获取最终结果
* 从累加器中提取并返回最终的聚合结果
*
* @param accumulator 累加器
* @return 聚合结果
*/
R result(A accumulator);
}
@@ -1,23 +0,0 @@
package core.handers;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
/**
* 数组转换策略
* 将ResultSet行数据转换为Object数组
*/
@FunctionalInterface
public interface ArrayConverter {
/**
* 转换为Object数组
*
* @param rs ResultSet对象
* @param columnIndexMap 列名->索引映射
* @return Object数组
* @throws SQLException SQL异常
*/
Object[] toArray(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException;
}
+1 -12
View File
@@ -9,19 +9,8 @@ import java.util.Map;
* 将ResultSet第一行转换为Object数组
*/
public class ArrayHandler extends AbstractSingleHandler<Object[]> {
private final RowProcessor convert;
public ArrayHandler() {
this(AbstractListHandler.ROW_PROCESSOR);
}
public ArrayHandler(RowProcessor convert) {
this.convert = convert;
}
@Override
protected Object[] handleRow(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException {
return convert.toArray(rs, columnIndexMap);
return getRowProcessor().toArray(rs, columnIndexMap);
}
}
@@ -10,20 +10,9 @@ import java.util.Map;
* 将ResultSet所有行转换为Object数组列表
*/
public class ArrayListHandler extends AbstractListHandler<Object[]> {
private final RowProcessor convert;
public ArrayListHandler() {
this(ROW_PROCESSOR);
}
public ArrayListHandler(RowProcessor convert) {
super(convert);
this.convert = convert;
}
@Override
protected Object[] handleRow(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException {
return convert.toArray(rs, columnIndexMap);
return getRowProcessor().toArray(rs, columnIndexMap);
}
}
+44 -176
View File
@@ -2,209 +2,77 @@ package core.handers;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
/**
* 基础行处理器实现
* 提供标准的ResultSet行数据转换功能
*/
public class BasicRowProcessor implements RowProcessor, ArrayConverter, MapConverter, BeanConverter {
// 本质就是不同加载器加载的同名类在内存地址不同,key 必须能反映这个差异,否则就会错乱和泄漏。
//最适合做 Key 的类型(按推荐度排序)
// 类型 优点 注意事项
// Class<?> 天然不可变,hashCode/equals 基于 ClassLoader + 类名,能唯一标识一个类 无
// String 不可变,广泛使用,hashCode 已缓存 当需要区分不同类加载器的同名类时不适用(这就是你遇到的问题)
// 基本类型的包装类(Integer, Long, Boolean 等) 不可变,有缓存池 适用场景有限
// 枚举 Enum 单例,hashCode/equals 基于 ordinal() 和 class 完美,但只能用于固定常量集合
// UUID 全局唯一,不可变 适合分布式标识
// 不可变值对象(如 LocalDate, LocalDateTime, BigDecimal) 线程安全,标准实现 注意 BigDecimal 的 equals 会比较精度(1.0 不等于 1.00)
// 绝对不适合做 Key 的类型
// 普通 Java Bean(Person, User 等)—— 属性可变,且通常未正确覆写 hashCode/equals
//
// 数组(int[], String[])—— 数组的 equals 比较的是引用,不是内容;且数组可变
//
// List、Map、Set 等集合—— 内容可变,且 hashCode 会随内容变化
//
// Thread、ThreadLocal —— 生命周期短暂,且身份不固定
//
// ResultSet、Connection 等资源对象 —— 一次性、可变、不可重用
//Key 必须保证 “唯一且稳定地标识一个逻辑对象
// 总结就是只要key存在就必须调用或者销毁,我感觉我已经掌握java的内存泄漏了
/** 方法缓存:类名 -> (属性名 -> Setter方法) */
private static final Map<String, Map<String, Method>> methodCache = new ConcurrentHashMap<>();
@Override
public ArrayConverter getArrayConverter() {
return this;
}
@Override
public MapConverter getMapConverter() {
return this;
}
@Override
public BeanConverter getBeanConverter() {
return this;
}
public class BasicRowProcessor implements RowProcessor {
private static final Map<Class<?>, Map<String, Method>> setterCache = new ConcurrentHashMap<>();
@Override
public Object[] toArray(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException {
int columnCount = columnIndexMap.size();
Object[] result = new Object[columnCount];
for (Map.Entry<String, Integer> entry : columnIndexMap.entrySet()) {
int index = entry.getValue() - 1; // 转换为0-based索引
result[index] = rs.getObject(entry.getValue());
Object[] result = new Object[columnIndexMap.size()];
for (Map.Entry<String, Integer> e : columnIndexMap.entrySet()) {
result[e.getValue() - 1] = rs.getObject(e.getValue());
}
return result;
}
@Override
public Map<String, Object> toMap(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException {
Map<String, Object> row = new LinkedHashMap<>(columnIndexMap.size());
for (Map.Entry<String, Integer> entry : columnIndexMap.entrySet()) {
row.put(entry.getKey(), rs.getObject(entry.getValue()));
Map<String, Object> map = new LinkedHashMap<>(columnIndexMap.size());
for (Map.Entry<String, Integer> e : columnIndexMap.entrySet()) {
map.put(e.getKey(), rs.getObject(e.getValue()));
}
return row;
return map;
}
@Override
public <T> T toBean(ResultSet rs, Class<T> type, Map<String, Integer> columnIndexMap) throws SQLException {
if (type == null) {
throw new SQLException("Bean类型不能为null");
}
try {
T bean = type.getDeclaredConstructor().newInstance();
Map<String, Method> setters = getSetterMethods(type);
for (Map.Entry<String, Integer> entry : columnIndexMap.entrySet()) {
String columnName = entry.getKey();
int columnIndex = entry.getValue();
Object value = rs.getObject(columnIndex);
if (value != null) {
invokeSetter(bean, columnName, value, setters);
Map<String, Method> setters = setterCache.computeIfAbsent(type, this::findSetters);
for (Map.Entry<String, Integer> e : columnIndexMap.entrySet()) {
Object val = rs.getObject(e.getValue());
if (val != null) {
Method setter = setters.get(e.getKey());
if (setter != null) {
setter.invoke(bean, convert(val, setter.getParameterTypes()[0]));
}
}
}
return bean;
} catch (Exception e) {
throw new SQLException("无法创建Bean实例: " + type.getName(), e);
} catch (Exception ex) {
throw new SQLException("Bean处理失败: " + type.getName(), ex);
}
}
private Map<String, Method> getSetterMethods(Class<?> type) {
return methodCache.computeIfAbsent(type.getName(), k -> buildSetterMethodMap(type));
}
private Map<String, Method> buildSetterMethodMap(Class<?> type) {
Map<String, Method> setterMap = new ConcurrentHashMap<>();
for (Method method : type.getMethods()) {
if (isSetterMethod(method)) {
String propertyName = extractPropertyName(method.getName());
setterMap.put(propertyName, method);
private Map<String, Method> findSetters(Class<?> type) {
Map<String, Method> map = new ConcurrentHashMap<>();
for (Method m : type.getMethods()) {
if (m.getName().startsWith("set") && m.getParameterCount() == 1 && m.getReturnType() == void.class) {
String prop = Character.toLowerCase(m.getName().charAt(3)) + m.getName().substring(4);
map.put(prop, m);
}
}
return setterMap;
return map;
}
private boolean isSetterMethod(Method method) {
return method.getName().startsWith("set")
&& method.getParameterCount() == 1
&& void.class.equals(method.getReturnType());
private Object convert(Object val, Class<?> target) {
if (target.isInstance(val)) return val;
// 仅保留最常见的数值转换
if (val instanceof Number && Number.class.isAssignableFrom(target)) {
Number n = (Number) val;
if (target == Integer.class || target == int.class) return n.intValue();
if (target == Long.class || target == long.class) return n.longValue();
if (target == Double.class || target == double.class) return n.doubleValue();
if (target == Float.class || target == float.class) return n.floatValue();
}
return val;
}
private String extractPropertyName(String methodName) {
return Character.toLowerCase(methodName.charAt(3)) + methodName.substring(4);
}
private void invokeSetter(Object bean, String propertyName,
Object value, Map<String, Method> setters) {
Method setter = setters.get(propertyName);
if (setter != null && value != null) {
try {
// 类型转换:处理数据库类型与Java类型的差异
Class<?> paramType = setter.getParameterTypes()[0];
Object convertedValue = convertType(value, paramType);
setter.invoke(bean, convertedValue);
} catch (Exception e) {
// 忽略设置失败的属性
}
}
}
/**
* 类型转换:处理数据库返回类型与Java setter参数类型的匹配
*/
private Object convertType(Object value, Class<?> targetType) {
if (value == null || targetType.isInstance(value)) {
return value;
}
// BigDecimal -> Double/Float/Long/Integer
if (value instanceof java.math.BigDecimal) {
java.math.BigDecimal bd = (java.math.BigDecimal) value;
if (targetType == Double.class || targetType == double.class) {
return bd.doubleValue();
} else if (targetType == Float.class || targetType == float.class) {
return bd.floatValue();
} else if (targetType == Long.class || targetType == long.class) {
return bd.longValue();
} else if (targetType == Integer.class || targetType == int.class) {
return bd.intValue();
}
}
// Number -> 其他数值类型
if (value instanceof Number) {
Number num = (Number) value;
if (targetType == Double.class || targetType == double.class) {
return num.doubleValue();
} else if (targetType == Float.class || targetType == float.class) {
return num.floatValue();
} else if (targetType == Long.class || targetType == long.class) {
return num.longValue();
} else if (targetType == Integer.class || targetType == int.class) {
return num.intValue();
}
}
// Timestamp -> LocalDateTime
if (value instanceof java.sql.Timestamp && targetType == java.time.LocalDateTime.class) {
return ((java.sql.Timestamp) value).toLocalDateTime();
}
// Date -> LocalDateTime
if (value instanceof java.util.Date && targetType == java.time.LocalDateTime.class) {
return ((java.util.Date) value).toInstant()
.atZone(java.time.ZoneId.systemDefault())
.toLocalDateTime();
}
// String -> 日期时间
if (value instanceof String && !targetType.equals(String.class)) {
String str = (String) value;
try {
if (targetType == java.time.LocalDateTime.class) {
return java.time.LocalDateTime.parse(str);
} else if (targetType == java.time.LocalDate.class) {
return java.time.LocalDate.parse(str);
} else if (targetType == java.sql.Timestamp.class) {
return java.sql.Timestamp.valueOf(str);
} else if (targetType == java.sql.Date.class) {
return java.sql.Date.valueOf(str);
}
} catch (Exception e) {
// 解析失败,返回原值
}
}
return value;
}
}
}
@@ -1,25 +0,0 @@
package core.handers;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
/**
* Bean转换策略
* 将ResultSet行数据转换为JavaBean
*/
@FunctionalInterface
public interface BeanConverter {
/**
* 转换为Bean
*
* @param rs ResultSet对象
* @param type Bean类型
* @param columnIndexMap 列名->索引映射
* @param <T> Bean类型
* @return Bean对象
* @throws SQLException SQL异常
*/
<T> T toBean(ResultSet rs, Class<T> type, Map<String, Integer> columnIndexMap) throws SQLException;
}
+1 -1
View File
@@ -11,7 +11,7 @@ import java.util.Map;
*/
public class BeanHandler<T> extends AbstractSingleHandler<T> {
private final Class<T> beanClass;
public BeanHandler(Class<T> beanClass) {
this.beanClass = beanClass;
}
@@ -1,5 +1,6 @@
package core.handers;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
@@ -11,53 +12,25 @@ import java.util.concurrent.ConcurrentHashMap;
* 提供列名到索引的映射缓存功能,优化ResultSet访问性能
*/
public class ColumnIndexCache {
/** 列索引映射缓存:列名组合签名 -> 列名->索引映射 */
private static final Map<String, Map<String, Integer>> cache = new ConcurrentHashMap<>();
/**
* 构建或从缓存获取列名到索引的映射
*
* @param metaData ResultSet元数据
* @param columnCount 列数量
* @return 列名->索引映射
* @throws SQLException SQL异常
*/
public static Map<String, Integer> getOrCreate(ResultSetMetaData metaData, int columnCount) throws SQLException {
// 生成缓存键:使用列名组合作为签名
String cacheKey = buildCacheKey(metaData, columnCount);
// 从缓存获取或构建新映射
return cache.computeIfAbsent(cacheKey, key -> {
Map<String, Integer> map = new HashMap<>(columnCount);
private static final Map<ResultSetMetaData, Map<String, Integer>> cache = new ConcurrentHashMap<>();
public static Map<String, Integer> getOrCreate(ResultSet rs) throws SQLException {
ResultSetMetaData metaData = rs.getMetaData();
// computeIfAbsent 保证原子性,避免重复构建
return cache.computeIfAbsent(metaData, md -> {
try {
int columnCount = md.getColumnCount();
Map<String, Integer> map = new HashMap<>(columnCount);
for (int i = 1; i <= columnCount; i++) {
map.put(metaData.getColumnLabel(i), i);
map.put(md.getColumnLabel(i), i);
}
return map;
} catch (SQLException e) {
throw new RuntimeException("构建列索引映射失败", e);
}
return map;
});
}
/**
* 生成缓存键
*
* @param metaData ResultSet元数据
* @param columnCount 列数量
* @return 缓存键
* @throws SQLException SQL异常
*/
private static String buildCacheKey(ResultSetMetaData metaData, int columnCount) throws SQLException {
StringBuilder keyBuilder = new StringBuilder();
for (int i = 1; i <= columnCount; i++) {
if (i > 1) keyBuilder.append(',');
keyBuilder.append(metaData.getColumnLabel(i));
}
return keyBuilder.toString();
}
/**
* 清空缓存(用于测试或内存管理)
*/
@@ -1,23 +0,0 @@
package core.handers;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
/**
* Map转换策略
* 将ResultSet行数据转换为Map
*/
@FunctionalInterface
public interface MapConverter {
/**
* 转换为Map
*
* @param rs ResultSet对象
* @param columnIndexMap 列名->索引映射
* @return Map键值对
* @throws SQLException SQL异常
*/
Map<String, Object> toMap(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException;
}
+6 -30
View File
@@ -11,27 +11,7 @@ import java.util.Map;
*/
public interface RowProcessor {
/**
* 获取数组转换策略
*
* @return 数组转换策略
*/
ArrayConverter getArrayConverter();
/**
* 获取Map转换策略
*
* @return Map转换策略
*/
MapConverter getMapConverter();
/**
* 获取Bean转换策略
*
* @return Bean转换策略
*/
BeanConverter getBeanConverter();
/**
* 将ResultSet当前行转换为Object数组
*
@@ -40,9 +20,8 @@ public interface RowProcessor {
* @return Object数组
* @throws SQLException SQL异常
*/
default Object[] toArray(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException {
return getArrayConverter().toArray(rs, columnIndexMap);
}
Object[] toArray(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException;
//
/**
* 将ResultSet当前行转换为Map
@@ -52,9 +31,7 @@ public interface RowProcessor {
* @return Map键值对
* @throws SQLException SQL异常
*/
default Map<String, Object> toMap(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException {
return getMapConverter().toMap(rs, columnIndexMap);
}
Map<String, Object> toMap(ResultSet rs, Map<String, Integer> columnIndexMap) throws SQLException;
/**
* 将ResultSet当前行转换为Bean
@@ -66,7 +43,6 @@ public interface RowProcessor {
* @return Bean对象
* @throws SQLException SQL异常
*/
default <T> T toBean(ResultSet rs, Class<T> type, Map<String, Integer> columnIndexMap) throws SQLException {
return getBeanConverter().toBean(rs, type, columnIndexMap);
}
<T> T toBean(ResultSet rs, Class<T> type, Map<String, Integer> columnIndexMap) throws SQLException ;
}
@@ -0,0 +1,51 @@
package core.handers.news;
// 本质就是不同加载器加载的同名类在内存地址不同,key 必须能反映这个差异,否则就会错乱和泄漏。
//最适合做 Key 的类型(按推荐度排序)
// 类型 优点 注意事项
// Class<?> 天然不可变,hashCode/equals 基于 ClassLoader + 类名,能唯一标识一个类 无
// String 不可变,广泛使用,hashCode 已缓存 当需要区分不同类加载器的同名类时不适用(这就是你遇到的问题)
// 基本类型的包装类(Integer, Long, Boolean 等) 不可变,有缓存池 适用场景有限
// 枚举 Enum 单例,hashCode/equals 基于 ordinal() 和 class 完美,但只能用于固定常量集合
// UUID 全局唯一,不可变 适合分布式标识
// 不可变值对象(如 LocalDate, LocalDateTime, BigDecimal) 线程安全,标准实现 注意 BigDecimal 的 equals 会比较精度(1.0 不等于 1.00)
// 绝对不适合做 Key 的类型
// 普通 Java Bean(Person, User 等)—— 属性可变,且通常未正确覆写 hashCode/equals
//
// 数组(int[], String[])—— 数组的 equals 比较的是引用,不是内容;且数组可变
//
// List、Map、Set 等集合—— 内容可变,且 hashCode 会随内容变化
//
// Thread、ThreadLocal —— 生命周期短暂,且身份不固定
//
// ResultSet、Connection 等资源对象 —— 一次性、可变、不可重用
//Key 必须保证 “唯一且稳定地标识一个逻辑对象
// 总结就是只要key存在就必须调用或者销毁,我感觉我已经掌握java的内存泄漏了
/**
* 数据聚合器接口
* 用于将多行数据聚合成一个结果,支持自定义聚合逻辑
*
* @param <A> 累加器类型,用于在聚合过程中保存中间状态
* @param <T> 输入元素类型,每一行数据转换后的对象
* @param <R> 最终结果类型,聚合完成后的返回值
*/
public interface Aggregator<A, T, R> {
/**
* 创建累加器
* 初始化聚合过程的中间状态容器
*
* @return 新的累加器实例
*/
A createAccumulator();
void accumulate(A accumulator, T item);
/**
* 获取最终结果
* 从累加器中提取并返回最终的聚合结果
*
* @param accumulator 累加器
* @return 聚合结果
*/
R result(A accumulator);
}
@@ -1,9 +1,12 @@
package core.handers;
import core.handers.news.RowData;
import core.handers.news.RowExtractor;
import core.handers.news.RowTransformer;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;
/**
* 去重处理器
@@ -2,9 +2,9 @@ package test;
import core.QueryRunner;
import core.handers.Aggregator;
import core.handers.news.Aggregator;
import core.handers.FlexibleResultSetHandler;
import core.handers.RowData;
import core.handers.news.RowData;
import data.DataSourceFactory;
import test.entity.Product;
@@ -61,8 +61,6 @@ public class FlexibleHandlerExamples {
rowData.addColumn("name", rs.getString("name"));
rowData.addColumn("price", rs.getDouble("price"));
return rowData;
},
// RowTransformer: 转换为Product对象(简化版)
rowData -> {
Product p = new Product();
@@ -1,5 +1,10 @@
package core.handers;
import core.handers.news.Aggregator;
import core.handers.news.RowData;
import core.handers.news.RowExtractor;
import core.handers.news.RowTransformer;
import java.sql.ResultSet;
import java.sql.SQLException;
@@ -1,10 +1,11 @@
package core.handers;
import core.ResultSetHandler;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 分组处理器
@@ -1,5 +1,10 @@
package core.handers;
import core.ResultSetHandler;
import core.handers.news.RowData;
import core.handers.news.RowExtractor;
import core.handers.news.RowTransformer;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
@@ -1,7 +1,5 @@
package core.handers;
package core.handers.news;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
@@ -1,4 +1,4 @@
package core.handers;
package core.handers.news;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
@@ -1,4 +1,4 @@
package core.handers;
package core.handers.news;
@FunctionalInterface
public interface RowTransformer<T> {
@@ -1,4 +1,6 @@
package core.handers;
package core.handers.news;
import core.handers.ResultSetHandler;
import java.sql.ResultSet;
import java.sql.SQLException;
@@ -1,4 +1,6 @@
package core.handers;
package core.handers.news;
import core.handers.ResultSetHandler;
import java.sql.ResultSet;
import java.sql.SQLException;
+1 -1
View File
@@ -1,6 +1,6 @@
package core.proxy;
import core.handers.ResultSetHandler;
import core.ResultSetHandler;
import core.handers.MapHandler;
import core.handers.ScalarHandler;
@@ -1,5 +1,6 @@
package core.proxy;
import core.ResultSetHandler;
import core.handers.*;
import java.lang.reflect.*;
+1 -1
View File
@@ -1,7 +1,7 @@
package core.proxy;
import core.QueryRunner;
import core.handers.ResultSetHandler;
import core.ResultSetHandler;
import java.sql.Connection;
import java.sql.SQLException;
@@ -17,6 +17,7 @@ public class InsertStrategy implements SqlGenerationStrategy {
};
@Override
public String generate(String tableName, Method method, Object[] args) {
Class<?> entityClass = inferEntityClass(args);
if (entityClass == null) {
+28
View File
@@ -0,0 +1,28 @@
明白了,你是接着刚才问的“额无人”继续问“特委”这个词的意思。
在刚才“额无人”(可能意为“屋里没人”)的语境下,突然提到“特委”,大概率是指历史上的一个特定机构简称:
“特委” = 特别委员会
在中国近代史、革命史或地方党史中,“特委”是一个常见的缩写。通常指在特定时期(如土地革命战争、抗日战争时期),在某个战略区域或重要城市设立的、级别高于一般县委的党组织领导机构。
结合“额无人”(屋里没人)的场景,可能的含义有:
接头暗号或对话内容的一部分:如果这是一个谍战、革命历史或地方故事里的对话,“屋里没人”可能是在确认环境安全,然后接下来要谈论与“特委”相关的事情,比如“特委的同志”、“特委的指示”。
特定地区的指代:例如“闽粤赣边特委”、“浙江特委”等。说话人可能在说“(这里)屋里没人,(我们可以谈)特委的事情了”。
非正式的机构称呼:在某些单位、项目或临时组织中,为了解决某个特定问题而成立的“特别委员会”,也会被简称为“特委”。
最可能的解释:
如果你是在阅读中国近现代史、地方志、革命回忆录,或者在看相关的影视剧、小说,“特委”几乎可以确定指的就是中国共产党在某个历史时期设立的“特别委员会”。
总结一下你这两句话构成的对话:
A:“额无人。”(确认环境:屋里没人,安全。)
B:“特委。”(接下来可以谈关于“特别委员会”的机密事情了。)
或者,如果这是一个人的独白或笔记,可能是:“(确认)屋里没人,(讨论/想起了关于)特委(的事)。”
为了确认,请问你是在什么具体内容(比如哪本书、哪部剧、哪段对话)里看到这两个词的?
+72
View File
@@ -0,0 +1,72 @@
import tkinter as tk
from tkinter import scrolledtext
from pathlib import Path
from playwright.sync_api import sync_playwright
URL = "https://chat.deepseek.com/"
USER_TOKEN = {"value": "zCADbX0I0p4gV/wTigZ0nUq5p+Bl4gKZt4BB5QURFpsGiHwgvHbL4bWmswPRSs2Z", "__version": "0"}
browser = page = pw = None
def init():
global browser, page, pw
if not pw:
pw = sync_playwright().start()
browser = pw.chromium.launch(channel="msedge", headless=True)
if not page or page.is_closed():
ctx = browser.new_context()
page = ctx.new_page()
page.goto(URL)
page.evaluate("(t) => localStorage.setItem('userToken', JSON.stringify(t))", USER_TOKEN)
page.reload()
page.wait_for_selector("textarea")
return page
def fetch(q, delay):
p = init()
esc = q.replace('`', '\\`').replace('$', '\\$')
p.evaluate(f"(() => {{ const t=`{esc}`; const ta=document.querySelector('textarea'); Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value').set.call(ta,t); ta.dispatchEvent(new Event('input',{{bubbles:true}})); }})()")
p.locator('div._52c986b.ds-icon-button.ds-icon-button--l[role="button"]').click()
import time; time.sleep(2)
p.wait_for_function("()=>{const b=document.querySelector('div._52c986b.ds-icon-button.ds-icon-button--l[role=\"button\"]');return b&&b.getAttribute('aria-disabled')==='false';}", timeout=120000)
p.wait_for_selector('div.db183363.ds-icon-button.ds-icon-button--m[role="button"]', timeout=120000)
time.sleep(delay)
return p.evaluate("(()=>{const m=document.querySelector('.ds-markdown');if(!m)return'';const r=document.createRange();r.selectNodeContents(m);const s=window.getSelection();s.removeAllRanges();s.addRange(r);document.execCommand('copy');return m.innerText;})()")
class App:
def __init__(self, root):
root.title("DeepSeek"); root.geometry("800x600")
self.ans_frame = tk.Frame(root); self.ans_frame.pack(fill="both", expand=True, padx=5, pady=5)
self.ans_text = scrolledtext.ScrolledText(self.ans_frame, state="disabled", wrap=tk.WORD); self.ans_text.pack(fill="both", expand=True)
self.loading = tk.Label(self.ans_frame, text="⏳ 加载中...", font=("Arial", 16), fg="gray")
inp = tk.Frame(root); inp.pack(fill="x", padx=5, pady=5)
self.txt = scrolledtext.ScrolledText(inp, height=6, wrap=tk.WORD); self.txt.pack(side="left", fill="both", expand=True, padx=(0, 5))
self.txt.bind('<Return>', lambda e: self.go())
btns = tk.Frame(inp); btns.pack(side="right", fill="y")
df = tk.Frame(btns); df.pack(pady=2)
tk.Label(df, text="延时:").pack(side="left")
self.dv = tk.IntVar(value=45)
tk.Spinbox(df, from_=5, to=180, increment=5, textvariable=self.dv, width=6).pack(side="left", padx=2)
self.btn = tk.Button(btns, text="发送\n⚡", command=self.go, width=8, height=3); self.btn.pack(pady=2)
self.show_load(False)
def show_load(self, s):
if s: self.loading.pack(expand=True); self.ans_text.pack_forget()
else: self.loading.pack_forget(); self.ans_text.pack(fill="both", expand=True)
def go(self):
q = self.txt.get("1.0", "end").strip()
if not q: return
self.btn.config(state="disabled"); self.show_load(True)
try:
ans = fetch(q, self.dv.get())
Path("log/answer.md").parent.mkdir(exist_ok=True)
Path("log/answer.md").write_text(ans, encoding="utf-8")
self.ans_text.config(state="normal"); self.ans_text.delete("1.0", tk.END); self.ans_text.insert("1.0", ans); self.ans_text.config(state="disabled")
self.show_load(False)
except Exception as e:
self.show_load(False); print(f"❌ {e}")
finally: self.btn.config(state="normal")
if __name__ == "__main__":
root = tk.Tk(); App(root); root.mainloop()