ecology
/
ebu_ecology_dev1
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

添加maper事务支持

main
youHong.ai 2022-12-21 23:02:27 +08:00
parent 242080e581
commit 958a9d7029
16 changed files with 998 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -43,6 +43,7 @@ DirectoryV2.xml
src/main/resources/WEB-INF/sqllog/
java.io.tempdir/
ecology-9-dev.iml
src/test/resources/font

37
src/main/java/aiyh/utils/Util.java
View File

@ -1976,6 +1976,43 @@ public class Util extends weaver.general.Util {
return recordsetUtil.getMapper(t);
}
/**
* <h2>getTransMapper 获取事务对象mapper</h2>
* <i>2022/12/21 22:45</i>
* ************************************************************
*
* @param t 类
* @param <T> 代理类
* @return T
* @author youHong.ai ******************************************
*/
public static <T> T getTransMapper(Class<T> t) {
return recordsetUtil.getMapper(t, false);
}
/**
* <h2>commitTransMapper 提交事务mapper的事务</h2>
* <i>2022/12/21 22:46</i>
* ************************************************************
*
* @return boolean 是否提交成功
* @author youHong.ai ******************************************
*/
public static boolean commitTransMapper() {
return recordsetUtil.getRsManager().commit();
}
/**
* <h2>rollbackTransMapper 回滚事务mapper 的事务</h2>
* <i>2022/12/21 22:46</i>
* ************************************************************
*
* @return boolean 是否回滚成功
* @author youHong.ai ******************************************
*/
public static boolean rollbackTransMapper() {
return recordsetUtil.getRsManager().rollback();
}
/**
* join方法

20
src/main/java/aiyh/utils/recordset/BooleanTypeHandler.java
View File

@ -6,23 +6,33 @@ import aiyh.utils.excention.CustomerException;
import com.google.common.base.Strings;
import org.jetbrains.annotations.NotNull;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.Field;
/**
* @author EBU7-dev1-ayh
* create 2021/12/21 0021 13:34
* @author EBU7-dev1-ayh create 2021/12/21 0021 13:34
*/
public class BooleanTypeHandler implements TypeHandler{
public class BooleanTypeHandler implements TypeHandler {
@Override
public Object getValue(RecordSet rs, String fieldName, Field declaredField) {
return getBoolean(declaredField, rs.getString(fieldName));
}
@Override
public Object getValue(RecordSet rs, int index,Field declaredField) {
public Object getValue(RecordSet rs, int index, Field declaredField) {
return getBoolean(declaredField, rs.getString(index));
}
@Override
public Object getValue(RecordSetTrans rs, String fieldName, Field declaredField) {
return getBoolean(declaredField, rs.getString(fieldName));
}
@Override
public Object getValue(RecordSetTrans rs, int index, Field declaredField) {
return getBoolean(declaredField, rs.getString(index));
}
@ -58,7 +68,7 @@ public class BooleanTypeHandler implements TypeHandler{
} else {
return defaultValue;
}
}else {
} else {
return defaultValue;
}
} catch (Exception e) {

42
src/main/java/aiyh/utils/recordset/DataTypeHandler.java
View File

@ -4,14 +4,14 @@ import aiyh.utils.annotation.DateFormatAn;
import aiyh.utils.excention.TypeNonsupportException;
import com.ibm.icu.text.SimpleDateFormat;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.Field;
import java.text.ParseException;
import java.util.Date;
/**
* @author EBU7-dev1-ayh
* create 2021/12/21 0021 13:35
* @author EBU7-dev1-ayh create 2021/12/21 0021 13:35
*/
@ -53,4 +53,42 @@ public class DataTypeHandler implements TypeHandler {
}
return date;
}
@Override
public Object getValue(RecordSetTrans rs, String fieldName, Field declaredField) {
if (declaredField == null) {
throw new TypeNonsupportException("An error occurred while trying to convert the query result field to type Date!");
}
DateFormatAn annotation = declaredField.getAnnotation(DateFormatAn.class);
Date date = null;
if (annotation != null) {
String value = annotation.value();
try {
date = new SimpleDateFormat(value).parse(rs.getString(fieldName));
} catch (ParseException e) {
e.printStackTrace();
throw new TypeNonsupportException("Failed to convert [" + rs.getString(fieldName) + "] to a Date object as [" + value + "]!!");
}
}
return date;
}
@Override
public Object getValue(RecordSetTrans rs, int index, Field declaredField) {
if (declaredField == null) {
throw new TypeNonsupportException("An error occurred while trying to convert the query result field to type Date!");
}
DateFormatAn annotation = declaredField.getAnnotation(DateFormatAn.class);
Date date = null;
if (annotation != null) {
String value = annotation.value();
try {
date = new SimpleDateFormat(value).parse(rs.getString(index));
} catch (ParseException e) {
e.printStackTrace();
throw new TypeNonsupportException("Failed to convert [" + rs.getString(index) + "] to a Date object as [" + value + "]!!");
}
}
return date;
}
}

17
src/main/java/aiyh/utils/recordset/FloatTypeHandler.java
View File

@ -2,6 +2,7 @@ package aiyh.utils.recordset;
import aiyh.utils.Util;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.Field;
@ -15,13 +16,25 @@ import java.lang.reflect.Field;
public class FloatTypeHandler implements TypeHandler {
@Override
public Object getValue(RecordSet rs, String fieldName, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(fieldName),"0.0");
String string = Util.null2DefaultStr(rs.getString(fieldName), "0.0");
return Float.parseFloat(string);
}
@Override
public Object getValue(RecordSet rs, int index, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(index),"0.0");
String string = Util.null2DefaultStr(rs.getString(index), "0.0");
return Float.parseFloat(string);
}
@Override
public Object getValue(RecordSetTrans rs, String fieldName, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(fieldName), "0.0");
return Float.parseFloat(string);
}
@Override
public Object getValue(RecordSetTrans rs, int index, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(index), "0.0");
return Float.parseFloat(string);
}
}

38
src/main/java/aiyh/utils/recordset/IntegerTypeHandler.java
View File

@ -2,30 +2,48 @@ package aiyh.utils.recordset;
import aiyh.utils.Util;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.Field;
/**
* @author EBU7-dev1-ayh
* create 2021/12/21 0021 13:10
* @author EBU7-dev1-ayh create 2021/12/21 0021 13:10
*/
public class IntegerTypeHandler implements TypeHandler{
public class IntegerTypeHandler implements TypeHandler {
@Override
public Object getValue(RecordSet rs, String fieldName, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(fieldName),"-1");
if(string.contains(".")){
string = string.substring(0,string.indexOf("."));
String string = Util.null2DefaultStr(rs.getString(fieldName), "-1");
if (string.contains(".")) {
string = string.substring(0, string.indexOf("."));
}
return Integer.parseInt(string);
}
@Override
public Object getValue(RecordSet rs, int index,Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(index),"-1");
if(string.contains(".")){
string = string.substring(0,string.indexOf("."));
public Object getValue(RecordSet rs, int index, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(index), "-1");
if (string.contains(".")) {
string = string.substring(0, string.indexOf("."));
}
return Integer.parseInt(string);
}
@Override
public Object getValue(RecordSetTrans rs, String fieldName, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(fieldName), "-1");
if (string.contains(".")) {
string = string.substring(0, string.indexOf("."));
}
return Integer.parseInt(string);
}
@Override
public Object getValue(RecordSetTrans rs, int index, Field declaredField) {
String string = Util.null2DefaultStr(rs.getString(index), "-1");
if (string.contains(".")) {
string = string.substring(0, string.indexOf("."));
}
return Integer.parseInt(string);
}

310
src/main/java/aiyh/utils/recordset/RecordsetUtil.java
View File

@ -7,10 +7,13 @@ import aiyh.utils.excention.CustomerException;
import aiyh.utils.sqlUtil.sqlResult.impl.BatchSqlResultImpl;
import aiyh.utils.sqlUtil.sqlResult.impl.PrepSqlResultImpl;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
/**
* @author EBU7-dev1-ayh create 2021/12/19 0019 14:39
@ -19,24 +22,43 @@ import java.lang.reflect.Proxy;
public class RecordsetUtil implements InvocationHandler {
private final RecordSet recordSet = new RecordSet();
private final RecordSet rs = new RecordSet();
public static final String SQL_LOG = "sql_log";
private final RsThreadLocalManager rsManager = new RsThreadLocalManager();
private boolean autoCommit = true;
public <T> T getMapper(Class<T> tClass) {
return getMapper(tClass, true);
}
public <T> T getMapper(Class<T> tClass, boolean autoCommit) {
if (tClass == null) {
throw new BindingException("class is null!");
}
if (tClass.getAnnotation(SqlMapper.class) == null) {
throw new BindingException("can not find SqlMapper annotation!");
}
this.autoCommit = autoCommit;
return (T) Proxy.newProxyInstance(tClass.getClassLoader(), new Class[]{tClass}, this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
if (autoCommit) {
return invokeRs(proxy, method, args);
}
return invokeRsTrans(proxy, method, args);
}
private Object invokeRs(Object proxy, Method method, Object[] args) {
RecordSet rs = rsManager.getRs();
if (rs == null) {
rsManager.setRecordSet();
rs = rsManager.getRs();
}
SqlHandler sqlHandler = new SqlHandler();
ResultMapper resultMapper = new ResultMapper();
Select select = method.getAnnotation(Select.class);
@ -48,7 +70,7 @@ public class RecordsetUtil implements InvocationHandler {
if (!handler.getSqlStr().trim().toLowerCase().startsWith("select ")) {
throw new CustomerException("The sql statement does not match, the @Select annotation can only getDataId the select statement, please check whether the sql statement matches!");
}
Util.getLogger("sql_log").info("解析sql===>" + handler);
Util.getLogger(SQL_LOG).info("解析sql===>" + handler);
if (handler.getArgs().isEmpty()) {
rs.executeQuery(handler.getSqlStr());
} else {
@ -57,7 +79,6 @@ public class RecordsetUtil implements InvocationHandler {
return resultMapper.mapperResult(rs, method, method.getReturnType());
}
Update update = method.getAnnotation(Update.class);
if (update != null) {
// 查询
String sql = update.value();
@ -66,13 +87,13 @@ public class RecordsetUtil implements InvocationHandler {
if (!handler.getSqlStr().trim().toLowerCase().startsWith("update ")) {
throw new CustomerException("The sql statement does not match, the @Update annotation can only getDataId the update statement, please check whether the sql statement matches!");
}
Util.getLogger("sql_log").info(handler.toString());
Util.getLogger(SQL_LOG).info(handler.toString());
Class<?> returnType = method.getReturnType();
boolean b;
if (handler.getArgs().isEmpty()) {
b = recordSet.executeUpdate(handler.getSqlStr());
b = rs.executeUpdate(handler.getSqlStr());
} else {
b = recordSet.executeUpdate(handler.getSqlStr(), handler.getArgs());
b = rs.executeUpdate(handler.getSqlStr(), handler.getArgs());
}
if (returnType.equals(void.class)) {
return null;
@ -97,13 +118,13 @@ public class RecordsetUtil implements InvocationHandler {
if (!handler.getSqlStr().trim().toLowerCase().startsWith("insert ")) {
throw new CustomerException("The sql statement does not match, the @Insert annotation can only getDataId the insert statement, please check whether the sql statement matches!");
}
Util.getLogger("sql_log").info(handler.toString());
Util.getLogger(SQL_LOG).info(handler.toString());
Class<?> returnType = method.getReturnType();
boolean b;
if (handler.getArgs().isEmpty()) {
b = recordSet.executeUpdate(handler.getSqlStr());
b = rs.executeUpdate(handler.getSqlStr());
} else {
b = recordSet.executeUpdate(handler.getSqlStr(), handler.getArgs());
b = rs.executeUpdate(handler.getSqlStr(), handler.getArgs());
}
if (returnType.equals(void.class)) {
return null;
@ -121,13 +142,13 @@ public class RecordsetUtil implements InvocationHandler {
if (!handler.getSqlStr().trim().toLowerCase().startsWith("delete ")) {
throw new CustomerException("The sql statement does not match, the @Delete annotation can only getDataId the delete statement, please check whether the sql statement matches!");
}
Util.getLogger("sql_log").info(handler.toString());
Util.getLogger(SQL_LOG).info(handler.toString());
Class<?> returnType = method.getReturnType();
boolean b;
if (handler.getArgs().isEmpty()) {
b = recordSet.executeUpdate(handler.getSqlStr());
b = rs.executeUpdate(handler.getSqlStr());
} else {
b = recordSet.executeUpdate(handler.getSqlStr(), handler.getArgs());
b = rs.executeUpdate(handler.getSqlStr(), handler.getArgs());
}
if (returnType.equals(void.class)) {
return null;
@ -143,14 +164,14 @@ public class RecordsetUtil implements InvocationHandler {
Class<?> returnType = method.getReturnType();
boolean custom = batchInsert.custom();
BatchSqlResultImpl batchSqlResult = sqlHandler.handlerBatch(sql, custom, method, args);
Util.getLogger("sql_log").info(batchSqlResult.toString());
Util.getLogger(SQL_LOG).info(batchSqlResult.toString());
if (batchSqlResult.getBatchList().isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
if (!batchSqlResult.getSqlStr().trim().toLowerCase().startsWith("insert ")) {
throw new CustomerException("The sql statement does not match, the @Insert annotation can only getDataId the insert statement, please check whether the sql statement matches!");
}
boolean b = recordSet.executeBatchSql(batchSqlResult.getSqlStr(), batchSqlResult.getBatchList());
boolean b = rs.executeBatchSql(batchSqlResult.getSqlStr(), batchSqlResult.getBatchList());
if (returnType.equals(void.class)) {
return null;
}
@ -166,14 +187,14 @@ public class RecordsetUtil implements InvocationHandler {
Class<?> returnType = method.getReturnType();
boolean custom = batchUpdate.custom();
BatchSqlResultImpl batchSqlResult = sqlHandler.handlerBatch(sql, custom, method, args);
Util.getLogger("sql_log").info(batchSqlResult.toString());
Util.getLogger(SQL_LOG).info(batchSqlResult.toString());
if (batchSqlResult.getBatchList().isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
if (!batchSqlResult.getSqlStr().trim().toLowerCase().startsWith("update ")) {
throw new CustomerException("The sql statement does not match, the @Update annotation can only getDataId the update statement, please check whether the sql statement matches!");
}
boolean b = recordSet.executeBatchSql(batchSqlResult.getSqlStr(), batchSqlResult.getBatchList());
boolean b = rs.executeBatchSql(batchSqlResult.getSqlStr(), batchSqlResult.getBatchList());
if (returnType.equals(void.class)) {
return null;
}
@ -189,14 +210,14 @@ public class RecordsetUtil implements InvocationHandler {
Class<?> returnType = method.getReturnType();
boolean custom = batchDelete.custom();
BatchSqlResultImpl batchSqlResult = sqlHandler.handlerBatch(sql, custom, method, args);
Util.getLogger("sql_log").info(batchSqlResult.toString());
Util.getLogger(SQL_LOG).info(batchSqlResult.toString());
if (batchSqlResult.getBatchList().isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
if (!batchSqlResult.getSqlStr().trim().toLowerCase().startsWith("delete ")) {
throw new CustomerException("The sql statement does not match, the @Delete annotation can only getDataId the delete statement, please check whether the sql statement matches!");
}
boolean b = recordSet.executeBatchSql(batchSqlResult.getSqlStr(), batchSqlResult.getBatchList());
boolean b = rs.executeBatchSql(batchSqlResult.getSqlStr(), batchSqlResult.getBatchList());
if (returnType.equals(void.class)) {
return null;
}
@ -208,4 +229,255 @@ public class RecordsetUtil implements InvocationHandler {
throw new CustomerException("该方法没有添加注解！请检查是否正确添加注解！@Select、@Update、@Insert、@Delete、@BatchUpdate、@BatchInsert、@BatchDelete");
}
private Object invokeRsTrans(Object proxy, Method method, Object[] args) {
RecordSetTrans rs = rsManager.getTrans();
if (rs == null) {
rsManager.setRecordSetTrans();
rs = rsManager.getTrans();
}
SqlHandler sqlHandler = new SqlHandler();
ResultMapper resultMapper = new ResultMapper();
Select select = method.getAnnotation(Select.class);
if (select != null) {
// 查询
String sql = select.value();
boolean custom = select.custom();
PrepSqlResultImpl handler = sqlHandler.handler(sql, custom, method, args);
if (!handler.getSqlStr().trim().toLowerCase().startsWith("select ")) {
throw new CustomerException("The sql statement does not match, the @Select annotation can only getDataId the select statement, please check whether the sql statement matches!");
}
Util.getLogger(SQL_LOG).info("解析sql===>" + handler);
try {
if (handler.getArgs().isEmpty()) {
rs.executeQuery(handler.getSqlStr());
} else {
rs.executeQuery(handler.getSqlStr(), handler.getArgs());
}
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
return resultMapper.mapperResult(rs, method, method.getReturnType());
}
Update update = method.getAnnotation(Update.class);
if (update != null) {
// 查询
String sql = update.value();
boolean custom = update.custom();
PrepSqlResultImpl handler = sqlHandler.handler(sql, custom, method, args);
if (!handler.getSqlStr().trim().toLowerCase().startsWith("update ")) {
throw new CustomerException("The sql statement does not match, the @Update annotation can only getDataId the update statement, please check whether the sql statement matches!");
}
Util.getLogger(SQL_LOG).info(handler.toString());
Class<?> returnType = method.getReturnType();
boolean b;
try {
if (handler.getArgs().isEmpty()) {
b = rs.executeUpdate(handler.getSqlStr());
} else {
b = rs.executeUpdate(handler.getSqlStr(), handler.getArgs());
}
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
if (returnType.equals(void.class)) {
return null;
}
if (returnType.equals(int.class) || returnType.equals(Integer.class)) {
if (b) {
return 1;
} else {
return 0;
}
}
if (returnType.equals(boolean.class) || returnType.equals(Boolean.class)) {
return b;
}
}
Insert insert = method.getAnnotation(Insert.class);
if (insert != null) {
// 查询
String sql = insert.value();
boolean custom = insert.custom();
PrepSqlResultImpl handler = sqlHandler.handler(sql, custom, method, args);
if (!handler.getSqlStr().trim().toLowerCase().startsWith("insert ")) {
throw new CustomerException("The sql statement does not match, the @Insert annotation can only getDataId the insert statement, please check whether the sql statement matches!");
}
Util.getLogger(SQL_LOG).info(handler.toString());
Class<?> returnType = method.getReturnType();
boolean b;
try {
if (handler.getArgs().isEmpty()) {
b = rs.executeUpdate(handler.getSqlStr());
} else {
b = rs.executeUpdate(handler.getSqlStr(), handler.getArgs());
}
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
if (returnType.equals(void.class)) {
return null;
}
if (returnType.equals(boolean.class) || returnType.equals(Boolean.class)) {
return b;
}
}
Delete delete = method.getAnnotation(Delete.class);
if (delete != null) {
// 查询
String sql = delete.value();
boolean custom = delete.custom();
PrepSqlResultImpl handler = sqlHandler.handler(sql, custom, method, args);
if (!handler.getSqlStr().trim().toLowerCase().startsWith("delete ")) {
throw new CustomerException("The sql statement does not match, the @Delete annotation can only getDataId the delete statement, please check whether the sql statement matches!");
}
Util.getLogger(SQL_LOG).info(handler.toString());
Class<?> returnType = method.getReturnType();
boolean b;
try {
if (handler.getArgs().isEmpty()) {
b = rs.executeUpdate(handler.getSqlStr());
} else {
b = rs.executeUpdate(handler.getSqlStr(), handler.getArgs());
}
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
if (returnType.equals(void.class)) {
return null;
}
if (returnType.equals(boolean.class) || returnType.equals(Boolean.class)) {
return b;
}
}
boolean hasBatchInsert = method.isAnnotationPresent(BatchInsert.class);
if (hasBatchInsert) {
BatchInsert batchInsert = method.getAnnotation(BatchInsert.class);
String sql = batchInsert.value();
Class<?> returnType = method.getReturnType();
boolean custom = batchInsert.custom();
BatchSqlResultImpl batchSqlResult = sqlHandler.handlerBatch(sql, custom, method, args);
Util.getLogger(SQL_LOG).info(batchSqlResult.toString());
List<List> batchList = batchSqlResult.getBatchList();
if (batchList.isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
List<List<Object>> batchListTrans = new ArrayList<>();
for (List list : batchList) {
List<Object> listItem = new ArrayList<>();
for (Object o : list) {
listItem.add(o);
}
batchListTrans.add(listItem);
}
if (!batchSqlResult.getSqlStr().trim().toLowerCase().startsWith("insert ")) {
throw new CustomerException("The sql statement does not match, the @Insert annotation can only getDataId the insert statement, please check whether the sql statement matches!");
}
boolean b = true;
try {
rs.executeBatchSql(batchSqlResult.getSqlStr(), batchListTrans);
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
if (returnType.equals(void.class)) {
return null;
}
if (returnType.equals(boolean.class) || returnType.equals(Boolean.class)) {
return b;
}
}
boolean hasBatchUpdate = method.isAnnotationPresent(BatchUpdate.class);
if (hasBatchUpdate) {
BatchUpdate batchUpdate = method.getAnnotation(BatchUpdate.class);
String sql = batchUpdate.value();
Class<?> returnType = method.getReturnType();
boolean custom = batchUpdate.custom();
BatchSqlResultImpl batchSqlResult = sqlHandler.handlerBatch(sql, custom, method, args);
Util.getLogger(SQL_LOG).info(batchSqlResult.toString());
if (batchSqlResult.getBatchList().isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
if (!batchSqlResult.getSqlStr().trim().toLowerCase().startsWith("update ")) {
throw new CustomerException("The sql statement does not match, the @Update annotation can only getDataId the update statement, please check whether the sql statement matches!");
}
List<List> batchList = batchSqlResult.getBatchList();
if (batchList.isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
List<List<Object>> batchListTrans = new ArrayList<>();
for (List list : batchList) {
List<Object> listItem = new ArrayList<>();
for (Object o : list) {
listItem.add(o);
}
batchListTrans.add(listItem);
}
try {
rs.executeBatchSql(batchSqlResult.getSqlStr(), batchListTrans);
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
if (returnType.equals(void.class)) {
return null;
}
if (returnType.equals(boolean.class) || returnType.equals(Boolean.class)) {
return true;
}
}
boolean hasBatchDelete = method.isAnnotationPresent(BatchDelete.class);
if (hasBatchDelete) {
BatchDelete batchDelete = method.getAnnotation(BatchDelete.class);
String sql = batchDelete.value();
Class<?> returnType = method.getReturnType();
boolean custom = batchDelete.custom();
BatchSqlResultImpl batchSqlResult = sqlHandler.handlerBatch(sql, custom, method, args);
Util.getLogger(SQL_LOG).info(batchSqlResult.toString());
if (batchSqlResult.getBatchList().isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
if (!batchSqlResult.getSqlStr().trim().toLowerCase().startsWith("delete ")) {
throw new CustomerException("The sql statement does not match, the @Delete annotation can only getDataId the delete statement, please check whether the sql statement matches!");
}
List<List> batchList = batchSqlResult.getBatchList();
if (batchList.isEmpty()) {
throw new CustomerException("getDataId batch sql error , batch sql args is empty!");
}
List<List<Object>> batchListTrans = new ArrayList<>();
for (List list : batchList) {
List<Object> listItem = new ArrayList<>();
for (Object o : list) {
listItem.add(o);
}
batchListTrans.add(listItem);
}
try {
rs.executeBatchSql(batchSqlResult.getSqlStr(), batchListTrans);
} catch (Exception e) {
Util.getLogger(SQL_LOG).error("execute sql error! " + Util.getErrString(e));
throw new CustomerException("execute sql error!" + e.getMessage());
}
if (returnType.equals(void.class)) {
return null;
}
if (returnType.equals(boolean.class) || returnType.equals(Boolean.class)) {
return true;
}
}
throw new CustomerException("该方法没有添加注解！请检查是否正确添加注解！@Select、@Update、@Insert、@Delete、@BatchUpdate、@BatchInsert、@BatchDelete");
}
public RsThreadLocalManager getRsManager() {
return rsManager;
}
}

233
src/main/java/aiyh/utils/recordset/ResultMapper.java
View File

@ -15,8 +15,7 @@ import java.lang.reflect.*;
import java.util.*;
/**
* @author EBU7-dev1-ayh
* create 2021/12/21 0021 11:03
* @author EBU7-dev1-ayh create 2021/12/21 0021 11:03
*/
@ -60,7 +59,7 @@ public class ResultMapper {
}
T t = tClass.newInstance();
if (t instanceof Collection) {
// 集合求出泛型
// 集合求出泛型
//获取返回值的类型
Type genericReturnType = method.getGenericReturnType();
Type actualTypeArgument = ((ParameterizedType) genericReturnType).getActualTypeArguments()[0];
@ -93,7 +92,7 @@ public class ResultMapper {
return t;
}
if (t instanceof Map) {
// map
// map
Type genericReturnType = method.getGenericReturnType();
Type actualTypeArgument = ((ParameterizedType) genericReturnType).getActualTypeArguments()[0];
Class<?> rawType = this.getRawType(actualTypeArgument);
@ -103,7 +102,7 @@ public class ResultMapper {
if (rawType.equals(Map.class)) {
rawType = HashMap.class;
}
// Object o = rawType.newInstance();
// Object o = rawType.newInstance();
Object o = null;
try {
Constructor<?> constructor = rawType.getConstructor();
@ -143,6 +142,222 @@ public class ResultMapper {
return null;
}
public <T> T mapperResult(RecordSetTrans rs, Method method, Class<T> tClass) {
if (tClass.equals(void.class)) {
return null;
}
if (tClass.equals(RecordSet.class) || tClass.equals(RecordSetTrans.class)) {
return (T) rs;
}
try {
if (tClass.equals(List.class)) {
tClass = (Class<T>) ArrayList.class;
}
if (tClass.equals(Map.class)) {
tClass = (Class<T>) HashMap.class;
}
if (ResultMapper.typeHandler.containsKey(tClass)) {
rs.next();
return (T) ResultMapper.typeHandler.get(tClass).getValue(rs, 1, null);
}
T t = tClass.newInstance();
if (t instanceof Collection) {
// 集合求出泛型
//获取返回值的类型
Type genericReturnType = method.getGenericReturnType();
Type actualTypeArgument = ((ParameterizedType) genericReturnType).getActualTypeArguments()[0];
Class<?> rawType = this.getRawType(actualTypeArgument);
if (rawType.equals(Map.class)) {
rawType = HashMap.class;
}
while (rs.next()) {
Object o = null;
try {
Constructor<?> constructor = rawType.getConstructor();
o = constructor.newInstance();
} catch (NoSuchMethodException | InvocationTargetException ignored) {
if (Number.class.isAssignableFrom(rawType)) {
Constructor<?> constructor;
try {
constructor = rawType.getConstructor(String.class);
o = constructor.newInstance("-1");
} catch (NoSuchMethodException | InvocationTargetException e) {
throw new CustomerException("can not Initialization " + t.getClass() + " [" + rawType + "]", e);
}
}
}
if (o == null) {
throw new CustomerException("can not Initialization " + t.getClass() + " [" + rawType + "]");
}
Object object = getObjectTrans(rs, o, method);
((Collection<? super Object>) t).add(object);
}
return t;
}
if (t instanceof Map) {
// map
Type genericReturnType = method.getGenericReturnType();
Type actualTypeArgument = ((ParameterizedType) genericReturnType).getActualTypeArguments()[0];
Class<?> rawType = this.getRawType(actualTypeArgument);
if (rawType.equals(List.class)) {
rawType = (Class<T>) ArrayList.class;
}
if (rawType.equals(Map.class)) {
rawType = HashMap.class;
}
// Object o = rawType.newInstance();
Object o = null;
try {
Constructor<?> constructor = rawType.getConstructor();
o = constructor.newInstance();
} catch (NoSuchMethodException | InvocationTargetException ignored) {
if (Number.class.isAssignableFrom(rawType)) {
Constructor<?> constructor;
try {
constructor = rawType.getConstructor(String.class);
o = constructor.newInstance("-1");
} catch (NoSuchMethodException | InvocationTargetException e) {
throw new CustomerException("can not Initialization " + t.getClass() + " [" + rawType + "]", e);
}
}
}
if (o == null) {
throw new CustomerException("can not Initialization " + t.getClass() + " [" + rawType + "]");
}
if (o instanceof Map || o instanceof Collection) {
throw new TypeNonsupportException("An unsupported return type!");
}
if (rs.next()) {
return (T) getObjectTrans(rs, t, method);
}
return null;
}
if (t.getClass().isArray()) {
throw new TypeNonsupportException("An unsupported return type!");
}
if (rs.next()) {
return (T) getObjectTrans(rs, t, method);
}
return null;
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
public Object getObjectTrans(RecordSetTrans rs, Object o, Method method) {
CaseConversion annotation = method.getAnnotation(CaseConversion.class);
boolean enable = annotation == null ? true : annotation.value();
String[] columnName = rs.getColumnName();
String[] columnTypeName = rs.getColumnTypeName();
int[] columnTypes = rs.getColumnType();
if (columnTypeName == null) {
columnTypeName = new String[columnTypes.length];
for (int i = 0; i < columnTypes.length; i++) {
int type = columnTypes[i];
switch (type) {
case -1:
columnTypeName[i] = "TEXT";
break;
case 4:
columnTypeName[i] = "INT";
break;
case 12:
columnTypeName[i] = "VARCHAR";
break;
default:
columnTypeName[i] = "VARCHAR";
}
}
}
try {
if (o instanceof Map) {
for (int i = 0; i < columnName.length; i++) {
String columnType = columnTypeName[i];
if ("int".equalsIgnoreCase(columnType) || "long".equalsIgnoreCase(columnType) || "number".equalsIgnoreCase(columnType) || "MEDIUMINT".equalsIgnoreCase(columnType) || "TINYINT".equalsIgnoreCase(columnType) || "SMALLINT".equalsIgnoreCase(columnType) || "BIGINT".equalsIgnoreCase(columnType) || "INTEGER".equalsIgnoreCase(columnType)) {
if (enable) {
((Map<? super Object, ? super Object>) o).put(Util.toCamelCase(columnName[i]), rs.getInt(i + 1));
continue;
}
((Map<? super Object, ? super Object>) o).put(columnName[i], rs.getInt(i + 1));
continue;
}
if ("FLOAT".equalsIgnoreCase(columnType) || "DOUBLE".equalsIgnoreCase(columnType) || "DECIMAL".equalsIgnoreCase(columnType)) {
if (enable) {
((Map<? super Object, ? super Object>) o).put(Util.toCamelCase(columnName[i]), rs.getFloat(i + 1));
continue;
}
((Map<? super Object, ? super Object>) o).put(columnName[i], rs.getFloat(i + 1));
continue;
}
if (enable) {
((Map<? super Object, ? super Object>) o).put(Util.toCamelCase(columnName[i]), rs.getString(i + 1));
continue;
}
((Map<? super Object, ? super Object>) o).put(columnName[i], rs.getString(i + 1));
continue;
}
return o;
}
if (o instanceof Collection) {
throw new TypeNonsupportException("An unsupported return type!");
}
if (o instanceof Number) {
for (int i = 0; i < columnName.length; i++) {
String columnType = columnTypeName[i];
if ("int".equalsIgnoreCase(columnType) || "long".equalsIgnoreCase(columnType) || "number".equalsIgnoreCase(columnType) || "MEDIUMINT".equalsIgnoreCase(columnType) || "TINYINT".equalsIgnoreCase(columnType) || "SMALLINT".equalsIgnoreCase(columnType) || "BIGINT".equalsIgnoreCase(columnType) || "INTEGER".equalsIgnoreCase(columnType)) {
return rs.getInt(i + 1);
}
if ("FLOAT".equalsIgnoreCase(columnType) || "DOUBLE".equalsIgnoreCase(columnType) || "DECIMAL".equalsIgnoreCase(columnType)) {
return rs.getFloat(i + 1);
}
}
return o;
}
if (o instanceof String) {
for (int i = 0; i < columnName.length; i++) {
return rs.getString(i + 1);
}
return o;
}
if (o instanceof Boolean) {
for (int i = 0; i < columnName.length; i++) {
return rs.getBoolean(i + 1);
}
return o;
}
// Util.getLogger().info("获取对象：" + o.toString());
BeanInfo beanInfo = Introspector.getBeanInfo(o.getClass(), Object.class);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
Class<?> propertyType = propertyDescriptor.getPropertyType();
Object value = null;
String fieldName = propertyDescriptor.getName();
if (Strings.isNullOrEmpty(fieldName)) {
fieldName = propertyDescriptor.getDisplayName();
}
// Util.getLogger().info("获取类字段：" + fieldName);
// Util.getLogger().info("获取类字段1：" + propertyDescriptor.getDisplayName());
// Util.getLogger().info("获取的数据库数据：" + rs.getString(fieldName));
Field declaredField = o.getClass().getDeclaredField(fieldName);
if (enable) {
value = ResultMapper.typeHandler.get(propertyType) == null ? null : ResultMapper.typeHandler.get(propertyType).getValue(rs, Util.toUnderlineCase(fieldName), declaredField);
} else {
value = ResultMapper.typeHandler.get(propertyType) == null ? null : ResultMapper.typeHandler.get(propertyType).getValue(rs, fieldName, declaredField);
}
propertyDescriptor.getWriteMethod().invoke(o, value);
}
} catch (Exception e) {
e.printStackTrace();
Util.getLogger().error("报错了，写入数据到实体类报错！\n" + Util.getErrString(e));
}
return o;
}
public Object getObject(RecordSet rs, Object o, Method method) {
CaseConversion annotation = method.getAnnotation(CaseConversion.class);
boolean enable = annotation == null ? true : annotation.value();
@ -226,7 +441,7 @@ public class ResultMapper {
return o;
}
// Util.getLogger().info("获取对象：" + o.toString());
// Util.getLogger().info("获取对象：" + o.toString());
BeanInfo beanInfo = Introspector.getBeanInfo(o.getClass(), Object.class);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
@ -237,9 +452,9 @@ public class ResultMapper {
if (Strings.isNullOrEmpty(fieldName)) {
fieldName = propertyDescriptor.getDisplayName();
}
// Util.getLogger().info("获取类字段：" + fieldName);
// Util.getLogger().info("获取类字段1：" + propertyDescriptor.getDisplayName());
// Util.getLogger().info("获取的数据库数据：" + rs.getString(fieldName));
// Util.getLogger().info("获取类字段：" + fieldName);
// Util.getLogger().info("获取类字段1：" + propertyDescriptor.getDisplayName());
// Util.getLogger().info("获取的数据库数据：" + rs.getString(fieldName));
Field declaredField = o.getClass().getDeclaredField(fieldName);
if (enable) {
value = ResultMapper.typeHandler.get(propertyType) == null ? null : ResultMapper.typeHandler.get(propertyType).getValue(rs, Util.toUnderlineCase(fieldName), declaredField);

209
src/main/java/aiyh/utils/recordset/RsThreadLocalManager.java Normal file
View File

@ -0,0 +1,209 @@
package aiyh.utils.recordset;
import aiyh.utils.excention.CustomerException;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* <h1>ThreadLocal管理类</h1>
*
* <p>create: 2022-12-21 21:31</p>
*
* @author youHong.ai
*/
public class RsThreadLocalManager {
private final ConcurrentHashMap<Long, RsThreadLocalMap> rsMap = new ConcurrentHashMap<>();
private final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
public RsThreadLocalManager() {
startMonitor();
}
/**
* <h2>定时清除过期的rs对象</h2>
* <i>2022/12/21 22:02</i>
* ************************************************************
*
* @author youHong.ai ******************************************
*/
private void startMonitor() {
executor.scheduleAtFixedRate(this::checkExpireRs, 0, 2, TimeUnit.MINUTES);
}
/**
* <h2>checkExpireRs 检查清除过期的rs对象</h2>
* <i>2022/12/21 22:02</i>
* ************************************************************
*
* @author youHong.ai ******************************************
*/
private void checkExpireRs() {
Iterator<Map.Entry<Long, RsThreadLocalMap>> iterator = rsMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Long, RsThreadLocalMap> entity = iterator.next();
RsThreadLocalMap value = entity.getValue();
if (System.currentTimeMillis() >= value.getExpireTime() || value.getExpireTime() != -1) {
iterator.remove();
}
}
}
/**
* <h2>setRecordSet 设置当前线程的rs对象</h2>
* <i>2022/12/21 22:03</i>
* ************************************************************
*
* @author youHong.ai ******************************************
*/
public void setRecordSet() {
RsThreadLocalMap rsThreadLocalMap = new RsThreadLocalMap(new RecordSet(), getExpireTime());
rsMap.put(Thread.currentThread().getId(), rsThreadLocalMap);
}
/**
* <h2>setRecordSet 设置当前线程的事务对象</h2>
* <i>2022/12/21 22:03</i>
* ************************************************************
*
* @author youHong.ai ******************************************
*/
public void setRecordSetTrans() {
RecordSetTrans recordSetTrans = new RecordSetTrans();
recordSetTrans.setAutoCommit(false);
RsThreadLocalMap rsThreadLocalMap = new RsThreadLocalMap(recordSetTrans, -1L);
rsMap.put(Thread.currentThread().getId(), rsThreadLocalMap);
}
/**
* <h2>getExpireTime 获取过期时间</h2>
* <i>2022/12/21 22:06</i>
* ************************************************************
*
* @return Long
* @author youHong.ai ******************************************
*/
public Long getExpireTime() {
return System.currentTimeMillis() + 1000L * 60 * 3;
}
/**
* <h2>getRs 获取当前线程的rs对象</h2>
* <i>2022/12/21 22:04</i>
* ************************************************************
*
* @return RecordSet
* @author youHong.ai ******************************************
*/
public RecordSet getRs() {
RsThreadLocalMap rsThreadLocalMap = rsMap.get(Thread.currentThread().getId());
if (Objects.isNull(rsThreadLocalMap)) {
return null;
}
rsThreadLocalMap.setExpireTime(getExpireTime());
return rsThreadLocalMap.getRecordSet();
}
/**
* <h2>getTrans 获取当前线程的事务rs</h2>
* <i>2022/12/21 22:04</i>
* ************************************************************
*
* @return RecordSetTrans 事务rs
* @author youHong.ai ******************************************
*/
public RecordSetTrans getTrans() {
RsThreadLocalMap rsThreadLocalMap = rsMap.get(Thread.currentThread().getId());
if (Objects.isNull(rsThreadLocalMap)) {
return null;
}
rsThreadLocalMap.setExpireTime(-1L);
return rsThreadLocalMap.getRecordSetTrans();
}
public boolean commit() {
RsThreadLocalMap rsThreadLocalMap = rsMap.get(Thread.currentThread().getId());
if (Objects.isNull(rsThreadLocalMap)) {
throw new CustomerException("can not find RecordSetTrans instance! please Contact the developer of RecordsetUtil.java！");
}
rsThreadLocalMap.setExpireTime(getExpireTime());
RecordSetTrans recordSetTrans = rsThreadLocalMap.getRecordSetTrans();
return recordSetTrans.commit();
}
public boolean rollback() {
RsThreadLocalMap rsThreadLocalMap = rsMap.get(Thread.currentThread().getId());
if (Objects.isNull(rsThreadLocalMap)) {
throw new CustomerException("can not find RecordSetTrans instance! please Contact the developer of RecordsetUtil.java！");
}
rsThreadLocalMap.setExpireTime(getExpireTime());
RecordSetTrans recordSetTrans = rsThreadLocalMap.getRecordSetTrans();
return recordSetTrans.rollback();
}
/**
* <h2>remove 删除当前线程的rs对象</h2>
* <i>2022/12/21 22:05</i>
* ************************************************************
*
* @author youHong.ai ******************************************
*/
public void remove() {
rsMap.remove(Thread.currentThread().getId());
}
static class RsThreadLocalMap {
private RecordSet recordSet;
private RecordSetTrans recordSetTrans;
private Long expireTime;
public RsThreadLocalMap(RecordSet recordSet, Long expireTime) {
this.recordSet = recordSet;
this.expireTime = expireTime;
}
public RsThreadLocalMap(RecordSetTrans recordSetTrans, Long expireTime) {
this.recordSetTrans = recordSetTrans;
this.expireTime = expireTime;
}
public RecordSetTrans getRecordSetTrans() {
return recordSetTrans;
}
public void setRecordSetTrans(RecordSetTrans recordSetTrans) {
this.recordSetTrans = recordSetTrans;
}
public RecordSet getRecordSet() {
return recordSet;
}
public void setRecordSet(RecordSet recordSet) {
this.recordSet = recordSet;
}
public Long getExpireTime() {
return expireTime;
}
public void setExpireTime(Long expireTime) {
this.expireTime = expireTime;
}
}
}

18
src/main/java/aiyh/utils/recordset/StringTypeHandler.java
View File

@ -1,23 +1,33 @@
package aiyh.utils.recordset;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.Field;
/**
* @author EBU7-dev1-ayh
* create 2021/12/21 0021 13:06
* @author EBU7-dev1-ayh create 2021/12/21 0021 13:06
*/
public class StringTypeHandler implements TypeHandler{
public class StringTypeHandler implements TypeHandler {
@Override
public Object getValue(RecordSet rs, String fieldName, Field declaredField) {
return rs.getString(fieldName);
}
@Override
public Object getValue(RecordSet rs, int index,Field declaredField) {
public Object getValue(RecordSet rs, int index, Field declaredField) {
return rs.getString(index);
}
@Override
public Object getValue(RecordSetTrans rs, String fieldName, Field declaredField) {
return rs.getString(fieldName);
}
@Override
public Object getValue(RecordSetTrans rs, int index, Field declaredField) {
return rs.getString(index);
}
}

11
src/main/java/aiyh/utils/recordset/TypeHandler.java
View File

@ -1,15 +1,20 @@
package aiyh.utils.recordset;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import java.lang.reflect.Field;
/**
* @author @author EBU7-dev1-ay
* create 2021/12/21 0021 13:05
* @author @author EBU7-dev1-ay create 2021/12/21 0021 13:05
*/
public interface TypeHandler {
Object getValue(RecordSet rs, String fieldName, Field declaredField);
Object getValue(RecordSet rs,int index,Field declaredField);
Object getValue(RecordSet rs, int index, Field declaredField);
Object getValue(RecordSetTrans rs, String fieldName, Field declaredField);
Object getValue(RecordSetTrans rs, int index, Field declaredField);
}

27
src/main/java/weaver/youhong/ai/fentian/renamefile/action/RenameDocFile.java Normal file
View File

@ -0,0 +1,27 @@
package weaver.youhong.ai.fentian.renamefile.action;
import aiyh.utils.Util;
import aiyh.utils.action.SafeCusBaseAction;
import aiyh.utils.annotation.ActionDesc;
import lombok.Setter;
import weaver.hrm.User;
import weaver.soa.workflow.request.RequestInfo;
import weaver.youhong.ai.fentian.renamefile.mapper.RenameDocFileMapper;
/**
* <h1>重命名流程字段中的附件字段</h1>
*
* <p>create: 2022-12-15 11:38</p>
*
* @author youHong.ai
*/
@ActionDesc(value = "重命名流程字段中的附件字段的附件名称",author = "youhong.ai")
@Setter
public class RenameDocFile extends SafeCusBaseAction {
private final RenameDocFileMapper mapper = Util.getMapper(RenameDocFileMapper.class);
@Override
public void doSubmit(String requestId, String billTable, int workflowId, User user, RequestInfo requestInfo) {
}
}

15
src/main/java/weaver/youhong/ai/fentian/renamefile/mapper/RenameDocFileMapper.java Normal file
View File

@ -0,0 +1,15 @@
package weaver.youhong.ai.fentian.renamefile.mapper;
import aiyh.utils.annotation.recordset.SqlMapper;
/**
* <h1></h1>
*
* <p>create: 2022-12-15 11:40</p>
*
* @author youHong.ai
*/
@SqlMapper
public interface RenameDocFileMapper {
}

33
src/test/java/youhong/ai/pcn/UtilTest.java Normal file
View File

@ -0,0 +1,33 @@
package youhong.ai.pcn;
import aiyh.utils.Util;
import basetest.BaseTest;
import ebu7common.youhong.ai.bean.Builder;
import org.junit.Test;
import youhong.ai.pcn.mapper.TransTestMapper;
import youhong.ai.pcn.pojo.Student;
/**
* <h1>测试</h1>
*
* <p>create: 2022-12-21 21:22</p>
*
* @author youHong.ai
*/
public class UtilTest extends BaseTest {
@Test
public void test() {
TransTestMapper transMapper = Util.getTransMapper(TransTestMapper.class);
Student student = Builder.builder(Student::new)
.with(Student::setName, "王小明")
.with(Student::setAge, 10)
.with(Student::setSex, 1).build();
boolean b = transMapper.insertStudent(student);
System.out.println(b);
System.out.println(Util.commitTransMapper());
}
}

20
src/test/java/youhong/ai/pcn/mapper/TransTestMapper.java Normal file
View File

@ -0,0 +1,20 @@
package youhong.ai.pcn.mapper;
import aiyh.utils.annotation.recordset.Insert;
import aiyh.utils.annotation.recordset.SqlMapper;
import youhong.ai.pcn.pojo.Student;
/**
* <h1></h1>
*
* <p>create: 2022-12-21 22:54</p>
*
* @author youHong.ai
*/
@SqlMapper
public interface TransTestMapper {
@Insert("insert into test_trans (name,age,sex) values (#{name},#{age},#{sex})")
boolean insertStudent(Student student);
}

21
src/test/java/youhong/ai/pcn/pojo/Student.java Normal file
View File

@ -0,0 +1,21 @@
package youhong.ai.pcn.pojo;
import lombok.Getter;
import lombok.Setter;
/**
* <h1></h1>
*
* <p>create: 2022-12-21 22:55</p>
*
* @author youHong.ai
*/
@Getter
@Setter
public class Student {
private int id;
private String name;
private int age;
private int sex;
}