Merge pull request #18 from VonChange/develop

Develop

Author: VonChange

README.md

@@ -26,10 +26,19 @@ SELECT  [@id column] FROM user_base
 </where>
 ```
 ## see  [easy-dynamic-sql.md](easy-dynamic-sql.md)
+
+* extend findByExample,findByBeanProperties [UserExample.java](spring-data-jdbc-mybatis-demo%2Fsrc%2Ftest%2Fjava%2Fcom%2Fvonchange%2Fnine%2Fdemo%2Fdao%2FUserExample.java)
+```
+userInfoMethodDao.findAll(UserExample.builder()
+.userCodeIn(Arrays.asList("u001","u002"))
+.userNameLike("ch%")
+.createTimeDesc(true).build());
+```
+
 ## Features
 * method name query [method-name-query.md](method-name-query.md)
 * @Id @Table @Column
-* extend CrudJdbcRepository not CrudRepository,because [curd-repository.md](curd-repository.md)
+* recommend CrudExtendRepository not CrudRepository,because [curd-repository.md](curd-repository.md)
 * not support @Query or QueryDSL, sql must be written in markdown
 * batch update [bach-update.md](bach-update.md)
 * [multi-datasource.md](multi-datasource.md)
@@ -38,7 +47,7 @@ SELECT  [@id column] FROM user_base
 
 [UserInfoRepository.java](spring-data-jdbc-mybatis-demo%2Fsrc%2Fmain%2Fjava%2Fcom%2Fvonchange%2Fnine%2Fdemo%2Fdao%2FUserInfoRepository.java)
 ```java
-public interface UserInfoRepository extends CrudJdbcRepository<UserInfoDO, Long> {
+public interface UserInfoRepository extends CrudExtendRepository<UserInfoDO, Long> {
     List<UserInfoDO> findByUserCodes(@Param("userCodes") List<String> userCodes);
     List<UserInfoDO> findUserBySearchParam(@Param("param") SearchParam searchParam);
 }

README.zh-CN.md

@@ -9,13 +9,15 @@
 
 **spring data jdbc 扩展 mybatis 动态sql能力**
 ## What Is This?
+* 底层 jdbcTemplate 复杂SQL才需要mybatis动态模板能力 无QueryDSL 提供crudClient 和jdbcClient
+
 * 和spring data jdbc一样的追求简单,使用jdbcTemplate,调用jdbc。不提供缓存、延迟加载、QueryDSL等JPA或mybatis的许多特性。一个简单、有限、固执己见的ORM
 
-* 扩展mybatis动态sql能力(不依赖mybatis!提取了动态sql代码),可以应对复杂sql,如果换其他模板引擎或自己实现也是可以的,但有一定的学习成本,使用mybatis动态sql已比较成熟
+* 扩展mybatis动态sql能力(不依赖mybatis!提取了动态sql代码),可以应对复杂sql,如果换其他模板引擎也是可以的,但有学习成本
 
-* SQL统一写在Markdown里,不提供@Query或QueryDSL
+* 复杂的SQL写在Markdown的代码片段中,不提供@Query和QueryDSL写法,但按方法名查找和扩展的findByExample可以应付大部分单表查询需求
 
-* 扩展简易动态sql写法 [easy-dynamic-sql.md](easy-dynamic-sql.md)
+* 简化mybatis动态sql写法 [easy-dynamic-sql.md](easy-dynamic-sql.md)
 
 [UserInfoRepository.md](spring-data-jdbc-mybatis-demo%2Fsrc%2Fmain%2Fresources%2Fsql%2FUserInfoRepository.md)
 
@@ -29,18 +31,26 @@ SELECT  [@id column] FROM user_info
 <if test="null!=createTime">  and create_time < #{createTime}  </if>
 </where>
 ```
+* 扩展findByExample 按实体属性名查询扩展 入参是任意符合规范的实体 但请慎用 传入实体不可过多字段
+```
+userInfoMethodDao.findAll(UserExample.builder()
+.userCodeIn(Arrays.asList("u001","u002"))
+.userNameLike("ch%")
+.createTimeDesc(true).build());
+```
+
 ## 特性
-* 支持按方法名查询 但不推荐过度使用 [method-name-query.md](method-name-query.md)
-* @Id @Table @Column 极少的注解
-* crud 继成 CrudJdbcRepository 不是CrudRepository 因为需要新增和去掉部分方法
+* 支持按方法名查询  [method-name-query.md](method-name-query.md) 以及扩展版findByExample
+* @Id @Table @Column @Version @Transient极少的注解
+* 请使用CrudExtendRepository 新增insert update insertBatch updateBatch 扩展版findByExample
 * 不提供@Query或QueryDSL,sql统一写在markdown文件里面
 * 批量更新 [bach-update.md](bach-update.md)
 * [多数据源.md](multi-datasource.md)
 
 ## Getting Started with JDBC mybatis
 
 ```java
-public interface UserInfoRepository extends CrudJdbcRepository<UserInfoDO, Long> {
+public interface UserInfoRepository extends CrudExtendRepository<UserInfoDO, Long> {
     List<UserInfoDO> findByUserCodes(@Param("userCodes") List<String> userCodes);
     List<UserInfoDO> findUserBySearchParam(@Param("param") SearchParam searchParam); 
 }

common-util/pom.xml

@@ -10,7 +10,7 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>common-util</artifactId>
-    <version>2.5.0</version>
+    <version>2.5.0.1</version>
 
     <dependencies>
 

common-util/src/main/java/com/vonchange/common/util/ClazzUtils.java

@@ -2,6 +2,11 @@
 
 import com.vonchange.common.util.bean.convert.Converter;
 
+import java.net.URI;
+import java.net.URL;
+import java.util.Collection;
+import java.util.Locale;
+
 public class ClazzUtils {
 	private ClazzUtils() {
 		throw new IllegalStateException("Utility class");
@@ -12,7 +17,16 @@ private ClazzUtils() {
 	 */
 	public static boolean isBaseType(Class<?> clazz) {
 		// ||clazz== Time.class||clazz == Timestamp.class
-		return Converter.hasConvertKey(clazz) || clazz.isPrimitive() || clazz.isEnum();
+		return Converter.hasConvertKey(clazz) || clazz.isPrimitive() ||
+		Enum.class.isAssignableFrom(clazz) ||
+				URI.class == clazz || URL.class == clazz ||
+				Locale.class == clazz || Class.class == clazz;
+	}
+	public static boolean isBaseTypeWithArray(Class<?> clazz) {
+		return isBaseType(clazz)||(clazz.isArray()&& isBaseType(clazz.getComponentType()))|| Collection.class.isAssignableFrom(clazz) ;
+	}
+	public static boolean isVersionType(Class<?> clazz) {
+		return Integer.class==clazz||Long.class==clazz;
 	}
 
 	@SuppressWarnings("unchecked")
@@ -21,6 +35,15 @@ public static <T> T cast(Class<?> clazz, Object obj) {
 			throw new ClassCastException(cannotCastMsg(clazz, obj));
 		return (T) obj;
 	}
+	public static boolean isClassExists(String className) {
+		try {
+			Class.forName(className);
+			return true;
+		} catch (ClassNotFoundException e) {
+			return false;
+		}
+	}
+
 
 	@SuppressWarnings("unchecked")
 	public static <T> T cast(Object obj) {

common-util/src/main/java/com/vonchange/common/util/ConvertUtil.java

@@ -1,14 +1,26 @@
 package com.vonchange.common.util;
 
+import com.vonchange.common.util.bean.BeanUtil;
+import com.vonchange.common.util.bean.MethodAccessData;
 import com.vonchange.common.util.bean.convert.Converter;
+import com.vonchange.common.util.model.BaseField;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import java.lang.reflect.Field;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.charset.Charset;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * 简单方式(效率高)实现类型转换,细节部分会不如ConvertUtils :ConvertUtils一次类型转换需要69ms 有点代价过高
@@ -17,15 +29,78 @@
  * @author vonchange@163.com
  */
 public class ConvertUtil {
-	private static final String NULLSTR = "NULL";
+	private static Logger log = LoggerFactory.getLogger(ConvertUtil.class);
+	private static final String NULL_STR = "NULL";
+	private static final Map<String, List<BaseField>> fieldMap = new ConcurrentHashMap<>();
+
+	@SuppressWarnings("unchecked")
+	public static <T> Map<String, Object> toMap(T entity)  {
+		if (entity instanceof Map) {
+			return (Map<String, Object>) entity;
+		}
+		List<BaseField> baseFields =getBeanInfo(entity.getClass());
+		MethodAccessData methodAccessData = BeanUtil.methodAccessData(entity.getClass());
+		Map<String, Object> map = new HashMap<>();
+		for (BaseField baseField : baseFields) {
+			Integer index =BeanUtil.getPropertyIndex(methodAccessData,baseField.getFieldName());
+			if(null!=index){
+				Object value=methodAccessData.getMethodAccess().invoke(entity,index);
+				map.put(baseField.getFieldName(),value);
+			}
+		}
+		return map;
+	}
+	public static  List<BaseField> getBeanInfo(Class<?> clazz){
+		String entityName = clazz.getName();
+		if(!fieldMap.containsKey(entityName)){
+			initField(clazz);
+		}
+		return fieldMap.get(entityName);
+	}
+	private static void getFieldList(Class<?> clazz, List<Field> fieldList) {
+		fieldList.addAll(Arrays.asList(clazz.getDeclaredFields()));
+		if(null!=clazz.getSuperclass()){
+			getFieldList(clazz.getSuperclass(), fieldList);
+		}
+	}
+
+	private static synchronized   void initField(Class<?> clazz) {
+		if(ClazzUtils.isBaseType(clazz)){
+			return;
+		}
+		String entityName=clazz.getName();
+		log.debug("initField {}",entityName);
+		List<Field> fieldList = new ArrayList<>();
+		getFieldList(clazz,fieldList);
+		List<BaseField> entityFieldList = new ArrayList<>();
+		Map<String,Integer> fieldHasMap = new HashMap<>();
+		MethodAccessData methodAccessData = BeanUtil.methodAccessData(clazz);
+		int i=0;
+		for (Field field : fieldList) {
+			Class<?> type = field.getType();
+			boolean isNormalField =BeanUtil.containsProperty(methodAccessData,field.getName(),"set")
+					&&ClazzUtils.isBaseType(type);
+			String fieldName = field.getName();
+			if(!isNormalField||fieldHasMap.containsKey(fieldName)){
+				continue;
+			}
+			BaseField entityField = new BaseField();
+			entityField.setFieldName(fieldName);
+			entityField.setType(type);
+			entityFieldList.add(entityField);
+			fieldHasMap.put(fieldName, i);
+			i++;
+		}
+		fieldMap.put(clazz.getName(), entityFieldList);
+	}
 
 	private static Object toNull(Object value) {
 		if (null == value) {
 			return null;
 		}
 		if (value instanceof String) {
 			value = value.toString().trim();
-			if (NULLSTR.equals(value)) {
+			if (NULL_STR.equals(value)) {
 				return null;
 			}
 			if ("".equals(value)) {

common-util/src/main/java/com/vonchange/common/util/JsonUtil.java

@@ -4,23 +4,44 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.Module;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 public class JsonUtil {
-	private static Logger logger = LoggerFactory.getLogger(JsonUtil.class);
+	private static Logger log = LoggerFactory.getLogger(JsonUtil.class);
 	private JsonUtil() {
 		throw new IllegalStateException("Utility class");
 	}
+	static ObjectMapper objectMapper;
+	static List<String> moduleList=new ArrayList<>();
+	static {
+		objectMapper=new ObjectMapper();
+		moduleList.add("com.fasterxml.jackson.datatype.jsr310.JavaTimeModule");
+		moduleList.add("com.fasterxml.jackson.module.paramnames.ParameterNamesModule");
+		moduleList.add("com.fasterxml.jackson.datatype.jdk8.Jdk8Module");
+		for (String module : moduleList) {
+			if(ClazzUtils.isClassExists(module)){
+				try {
+					objectMapper.registerModule((Module) Class.forName(module).newInstance());
+				} catch (Exception e) {
+					log.info("registerModule {} {}",module,e.getMessage());
+				}
+			}
+		}
+		objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES,true);
+		objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
+	}
 	public static String toJson(Object object) {
-		ObjectMapper objectMapper = new ObjectMapper();  
 		try {
 			return objectMapper.writeValueAsString(object);
 		} catch (JsonProcessingException e) {
-			logger.error("序列化对象失败{}",e);
+			log.error("toJson",e);
 		}
 		return null;	
 	}
@@ -35,33 +56,22 @@ public static <T> T evalJson(String json, Class<T> clazz) throws IOException {
 		return evalJson(json,clazz,null);
 	}
 	public static <T> T evalJson(String json, Class<T> clazz,TypeReference<T> type) throws IOException {
-		ObjectMapper mapper = new ObjectMapper();
-		mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES,true);
-		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
 		T t =null;
 		if(null!=clazz){
-				t = mapper.readValue(json, clazz);
+				t = objectMapper.readValue(json, clazz);
 		}
 		if(null!=type){
-				t = mapper.readValue(json, type);
+				t = objectMapper.readValue(json, type);
 		}
 		return t;
 	}
 
 	private  static <T> T fromJson(String json, Class<T> clazz,TypeReference<T> type) {
-		ObjectMapper mapper = new ObjectMapper();
-		mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES,true);
-		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
 		T t =null;
 		try {
-			if(null!=clazz){
-				t = mapper.readValue(json, clazz);
-			}
-			if(null!=type){
-				t = mapper.readValue(json, type);
-			}
+			t=evalJson(json,clazz,type);
 		} catch (IOException e) {
-			logger.error("反序列化对象失败{}",e);
+			log.error("fromJson",e);
 		}
 		return t;
 	}

common-util/src/main/java/com/vonchange/common/util/MarkdownUtil.java

@@ -2,6 +2,7 @@
 
 
 import com.vonchange.common.util.exception.EnumUtilErrorCode;
+import com.vonchange.common.util.exception.ErrorMsg;
 import com.vonchange.common.util.exception.UtilException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,7 +33,8 @@ public     static synchronized   Map<String,String> readMarkdownFile(String id,b
              if(!notFoundError){
                  return null;
              }
-             throw new UtilException(path+" not Find");
+            throw new UtilException(EnumUtilErrorCode.MarkdownPathNotFound,
+                    ErrorMsg.builder().message(path+" not found"));
         }
         String content=null;
         try {
@@ -151,7 +153,8 @@ public static String  getContent(String id,boolean notFoundThrowError) {
             if(!notFoundThrowError){
                 return null;
             }
-            throw new UtilException(EnumUtilErrorCode.MarkdownIdNotFound,id+" not found");
+            throw new UtilException(EnumUtilErrorCode.MarkdownIdNotFound,
+                    ErrorMsg.builder().message(id+" not found"));
         }
         String filePath= UtilAll.UString.substringBeforeLast(id, StringPool.DOT);
         String codeId= id.substring(filePath.length()+1);
@@ -160,7 +163,8 @@ public static String  getContent(String id,boolean notFoundThrowError) {
             if(!notFoundThrowError){
                 return null;
             }
-            throw new UtilException(EnumUtilErrorCode.MarkdownIdNotFound,id+" not found");
+            throw new UtilException(EnumUtilErrorCode.MarkdownIdNotFound,
+                    ErrorMsg.builder().message(id+" not found"));
         }
         String content=  extendContent(contentMap,codeId);
         if(UtilAll.UString.isNotBlank(content)){

common-util/src/main/java/com/vonchange/common/util/Three.java

@@ -0,0 +1,31 @@
+package com.vonchange.common.util;
+
+public class Three<A,B,C>{
+    private final  A first;
+    private final  B second;
+
+    private final  C third;
+
+    private Three(A first, B second, C third) {
+        this.first = first;
+        this.second = second;
+        this.third=third;
+    }
+
+    public static <A, B,C> Three<A, B,C> of(A first, B second, C third) {
+        return new Three<>(first, second,third);
+    }
+
+
+    public A getFirst() {
+        return first;
+    }
+
+    public B getSecond() {
+        return second;
+    }
+    public C getThird() {
+        return third;
+    }
+
+}