efs/eladmin-system/src/main/java/me/zhengjie/archives/plus/AbstractService.java

package me.zhengjie.archives.plus;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.reflection.property.PropertyNamer;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.LambdaUtils;
import com.baomidou.mybatisplus.core.toolkit.support.LambdaMeta;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.service.IService;

public interface AbstractService<T> extends IService<T> {
	static final Log logger = LogFactory.getLog(AbstractService.class);

	/**
	 * 博客地址：https://blog.csdn.net/qq_19266669/article/details/114369195
	 * 查看AbstractLambdaWrapper通过方法得到字段名称
	 * 
	 * @param column
	 * @return
	 */
	default String columnToString(SFunction<T, ?> column) {
		return column.toString();
	};

	/**
	 * 根据 entity 条件，删除记录
	 *
	 * @param queryWrapper 实体包装类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default boolean remove(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return remove(queryWrapper);
	}

	/**
	 * 根据 whereEntity 条件，更新记录
	 *
	 * @param entity        实体对象
	 * @param updateWrapper 实体对象封装操作类
	 *                      {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 */
	default boolean update(T entity, SFunction<T, ?> column, Object value) {
		try {
			UpdateWrapper<T> updateWrapper = new UpdateWrapper<>();
			// 这里使用反射得到字段，
			String conditions = columnToString(column);
			updateWrapper.eq(conditions, value);
			return update(entity, updateWrapper);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 根据 whereEntity 条件，更新记录
	 *
	 * @param entity        实体对象
	 * @param updateWrapper 实体对象封装操作类
	 *                      {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 */
	default boolean update(T entity, String column, Object value) {
		try {
			UpdateWrapper<T> updateWrapper = new UpdateWrapper<>();
			updateWrapper.eq(column, value);
			return update(entity, updateWrapper);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

	default boolean update(T entity, SFunction<T, ?> column) {
		// 这里是反射，通过反射来得到

//		Field startRange = clazz.getDeclaredField(attribute[0]);
//		startRange.setAccessible(true);
//		Object val = startRange.get(obj);
		try {
			String columnName = columnToString(column);
			String fieldName = getFieldName(column);
			Class<?> clazz = entity.getClass();
			Field field = clazz.getDeclaredField(fieldName);
			// 抑制Java对修饰符的检查
			field.setAccessible(true);
			Object value = field.get(entity);
			field.set(entity, null);
			return update(entity, columnName, value);
		} catch (Exception e) {
			logger.error("update class" + entity.getClass() + " exception :" + e.getMessage());
			return false;
		}

	}

	default String getFieldName(SFunction<T, ?> column) {
		LambdaMeta meta = LambdaUtils.extract(column);
		String fieldName = PropertyNamer.methodToProperty(meta.getImplMethodName());
		return fieldName;

	}

	default boolean update(T entity, SFunction<T, ?> column, Collection<?> coll) {
		UpdateWrapper<T> updateWrapper = new UpdateWrapper<>();
		// 这里使用反射得到字段，
		try {
			String conditions = columnToString(column);
			updateWrapper.in(conditions, coll);
			return update(entity, updateWrapper);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

	default boolean update(T entity, String conditions, Object... values) {
		UpdateWrapper<T> updateWrapper = new UpdateWrapper<>();

		updateWrapper.in(conditions, values);

		return update(entity, updateWrapper);
	}

	/**
	 * 根据 Wrapper，查询一条记录 <br/>
	 * <p>
	 * 结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
	 * </p>
	 *
	 * @param queryWrapper 实体对象封装操作类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default T getOne(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return getOne(queryWrapper, true);
	}

	default Map<String, Object> getMap(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return getMap(queryWrapper);
	}

	/**
	 * 根据 Wrapper 条件，查询总记录数
	 *
	 * @param queryWrapper 实体对象封装操作类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default long count(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return count(queryWrapper);
	}

	/**
	 * 查询列表
	 *
	 * @param queryWrapper 实体对象封装操作类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default List<T> list(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return list(queryWrapper);
	}

	/**
	 * 查询列表
	 *
	 * @param queryWrapper 实体对象封装操作类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default List<Map<String, Object>> listMaps(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return listMaps(queryWrapper);
	}

	/**
	 * 根据 Wrapper 条件，查询全部记录
	 *
	 * @param queryWrapper 实体对象封装操作类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default List<Object> listObjs(T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		return listObjs(queryWrapper);
	}

	/**
	 * 翻页查询
	 *
	 * @param page         翻页对象
	 * @param queryWrapper 实体对象封装操作类
	 *                     {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
	 */
	default <E extends IPage<T>> E page(E page, T t) {
		Wrapper<T> queryWrapper = QueryWrapperUtil.convertQuery(t);
		try {
			return page(page, queryWrapper);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

}