通用mapper使用指南

@tk.mybatis.spring.annotation.MapperScan(basePackages = "扫描包")
@SpringBootApplication
public class SampleMapperApplication implements CommandLineRunner {

}

public enum Style {
  normal,                     //原值
  camelhump,                  //驼峰转下划线，默认值
  uppercase,                  //转换为大写
  lowercase,                  //转换为小写
  camelhumpAndUppercase,      //驼峰转下划线大写形式
  camelhumpAndLowercase,      //驼峰转下划线小写形式
}

//Java8+可以使用默认方法判断自动抛出异常
public interface MyMapper<T> extends Mapper<T> {

  default int deleteWithVersion(T t){
    int result = delete(t);
    if(result == 0){
      throw new RuntimeException("删除失败!");
    }
    return result;
  }

  default int updateByPrimaryKeyWithVersion(Object t){
    int result = updateByPrimaryKey(t);
    if(result == 0){
      throw new RuntimeException("更新失败!");
    }
    return result;
  }
}

//用UUID实现主键生成策略
public class UUIDGenId implements GenId<String> {
  @Override
  public String genId(String table, String column) {
    return UUID.randomUUID().toString().replace("-","");
  }
}

public class User {
  @Id
  @KeySql(genId = UUIDGenId.class)
  private String id;
  private String name;
  private String code;

  public User() {
  }

  public User(String name, String code) {
    this.name = name;
    this.code = code;
  }

  //省略 setter 和 getter
}

public class MybatisGenerator{

  public static void main(String[] args) throws IOException, XMLParserException, InvalidConfigurationException, SQLException, InterruptedException {
    InputStream configFile = MybatisGenerator.class.getResourceAsStream("/generatorConfig.xml");
    System.out.println(configFile);
    List<String> warnings = new ArrayList<String>();
    boolean overwrite = true;
    ConfigurationParser cp = new ConfigurationParser(warnings);
    Configuration config = cp.parseConfiguration(configFile);
    DefaultShellCallback callback = new DefaultShellCallback(overwrite);
    MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
    ProgressCallback progress = new VerboseProgressCallback();
    myBatisGenerator.generate(progress);
  }
}

@RegisterMapper
public interface SelectAllMapper<T> {

  // 查询全部结果
  @SelectProvider(type = MySelectProvider.class, method = "dynamicSQL")
  List<T> selectAll();
}

public class MySelectProvider extends MapperTemplate {

  public BaseSelectProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
    super(mapperClass, mapperHelper);
  }

  // 查询全部结果
  public String selectAll(MappedStatement ms) {
    final Class<?> entityClass = getEntityClass(ms);
    //修改返回值类型为实体类型
    setResultType(ms, entityClass);
    StringBuilder sql = new StringBuilder();
    sql.append(SqlHelper.selectAllColumns(entityClass));
    sql.append(SqlHelper.fromTable(entityClass, tableName(entityClass)));
    sql.append(SqlHelper.orderByDefault(entityClass));
    return sql.toString();
  }
}

@RegisterMapper
public interface InsertIgnoreSelectiveMapper<T> {

  @InsertProvider(type = InsertIgnoreSelectiveProvider.class, method = "dynamicSQL")
  int insertIgnoreSelective(T record);
}

public class InsertIgnoreSelectiveProvider extends MapperTemplate {

  public InsertIgnoreSelectiveProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
    super(mapperClass, mapperHelper);
  }

  public String insertIgnoreSelective(MappedStatement ms) {
    Class<?> entityClass = getEntityClass(ms);
    StringBuilder sql = new StringBuilder();
    //获取全部列
    Set<EntityColumn> columnList = EntityHelper.getColumns(entityClass);
    EntityColumn logicDeleteColumn = SqlHelper.getLogicDeleteColumn(entityClass);
    processKey(sql, entityClass, ms, columnList);
    sql.append("INSERT IGNORE INTO ");
    sql.append(SqlHelper.getDynamicTableName(entityClass, tableName(entityClass)));
    sql.append(" ");
    sql.append("<trim prefix=\"(\" suffix=\")\" suffixOverrides=\",\">");
    for (EntityColumn column : columnList) {
      if (!column.isInsertable()) {
        continue;
      }
      if (column.isIdentity()) {
        sql.append(column.getColumn()).append(",");
      } else {
        if (logicDeleteColumn != null && logicDeleteColumn == column) {
          sql.append(column.getColumn()).append(",");
          continue;
        }
        sql.append(SqlHelper.getIfNotNull(column, column.getColumn() + ",", isNotEmpty()));
      }
    }
    sql.append("</trim>");

    sql.append("<trim prefix=\"VALUES(\" suffix=\")\" suffixOverrides=\",\">");
    for (EntityColumn column : columnList) {
      if (!column.isInsertable()) {
        continue;
      }
      if (logicDeleteColumn != null && logicDeleteColumn == column) {
        sql.append(SqlHelper.getLogicDeletedValue(column, false)).append(",");
        continue;
      }
      //优先使用传入的属性值,当原属性property!=null时，用原属性
      //自增的情况下,如果默认有值,就会备份到property_cache中,所以这里需要先判断备份的值是否存在
      if (column.isIdentity()) {
        sql.append(SqlHelper.getIfCacheNotNull(column, column.getColumnHolder(null, "_cache", ",")));
      } else {
        //其他情况值仍然存在原property中
        sql.append(SqlHelper.getIfNotNull(column, column.getColumnHolder(null, null, ","), isNotEmpty()));
      }
      //当属性为null时，如果存在主键策略，会自动获取值，如果不存在，则使用null
      //序列的情况
      if (column.isIdentity()) {
        sql.append(SqlHelper.getIfCacheIsNull(column, column.getColumnHolder() + ","));
      }
    }
    sql.append("</trim>");
    return sql.toString();
  }

  private void processKey(StringBuilder sql, Class<?> entityClass, MappedStatement ms, Set<EntityColumn> columnList){
    //Identity列只能有一个
    Boolean hasIdentityKey = false;
    //先处理cache或bind节点
    for (EntityColumn column : columnList) {
      if (column.isIdentity()) {
        //这种情况下,如果原先的字段有值,需要先缓存起来,否则就一定会使用自动增长
        //这是一个bind节点
        sql.append(SqlHelper.getBindCache(column));
        //如果是Identity列，就需要插入selectKey
        //如果已经存在Identity列，抛出异常
        if (hasIdentityKey) {
          //jdbc类型只需要添加一次
          if (column.getGenerator() != null && "JDBC".equals(column.getGenerator())) {
            continue;
          }
          throw new MapperException(ms.getId() + "对应的实体类" + entityClass.getCanonicalName() + "中包含多个MySql的自动增长列,最多只能有一个!");
        }
        //插入selectKey
        SelectKeyHelper.newSelectKeyMappedStatement(ms, column, entityClass, isBEFORE(), getIDENTITY(column));
        hasIdentityKey = true;
      } else if(column.getGenIdClass() != null){
        sql.append("<bind name=\"").append(column.getColumn()).append("GenIdBind\" value=\"@tk.mybatis.mapper.genid.GenIdUtil@genId(");
        sql.append("_parameter").append(", '").append(column.getProperty()).append("'");
        sql.append(", @").append(column.getGenIdClass().getCanonicalName()).append("@class");
        sql.append(", '").append(tableName(entityClass)).append("'");
        sql.append(", '").append(column.getColumn()).append("')");
        sql.append("\"/>");
      }

    }
  }
}

CountryExample example = new CountryExample();
example.createCriteria().andCountrynameLike("A%");
example.or().andIdGreaterThan(100);
example.setDistinct(true);
int count = mapper.deleteByExample(example);

Example example = new Example(Country.class);
example.setForUpdate(true);
example.createCriteria().andGreaterThan("id", 100).andLessThan("id",151);
example.or().andLessThan("id", 41);
List<Country> countries = mapper.selectByExample(example);

Example example = Example.builder(Country.class)
  .select("countryname")
  .where(Sqls.custom().andGreaterThan("id", 100))
  .orderByAsc("countrycode")
  .forUpdate()
  .build();
List<Country> countries = mapper.selectByExample(example);

List<Country> selectByWeekendSql = mapper.selectByExample(
  Example.Builder(Country.class)
  .where(WeekendSqls.<Country>custom()
         .andLike(Country::getCountryname, "%a%")
         .andGreaterThan(Country::getCountrycode, "123"))
  .build());

public class Address implements Serializable {
  private static final long serialVersionUID = 1L;
  private String province;
  private String city;

  // 省略Getter、Setter方法。。。

  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    if(province != null && province.length() > 0){
      builder.append(province);
    }
    if(city != null && city.length() > 0){
      builder.append("/").append(city);
    }
    return builder.toString();
  }
}

public class User implements Serializable {
  private static final long serialVersionUID = 1L;
  @Id
  private Integer   id;
  private String    name;
  @ColumnType(typeHandler = AddressTypeHandler.class)	//指定TypeHandler
  private Address   address;	//实体类对应的地址
}

public class AddressTypeHandler extends BaseTypeHandler<Address> {
  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, Address parameter,
                                  JdbcType jdbcType) throws SQLException {
    ps.setString(i, parameter.toString());
  }

  private Address convertToAddress(String addressStr){
    if(addressStr == null || addressStr.length() == 0){
      return null;
    }
    String[] strings = addressStr.split("/");
    Address address = new Address();
    if(strings.length > 0 && strings[0].length() > 0){
      address.setProvince(strings[0]);
    }
    if(strings.length > 1 && strings[1].length() > 0){
      address.setCity(strings[1]);
    }
    return address;
  }

  @Override
  public Address getNullableResult(ResultSet rs, String columnName) throws SQLException {
    return convertToAddress(rs.getString(columnName));
  }

  @Override
  public Address getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    return convertToAddress(rs.getString(columnIndex));
  }

  @Override
  public Address getNullableResult(CallableStatement cs, int columnIndex)
    throws SQLException {
    return convertToAddress(cs.getString(columnIndex));
  }
}

@Table(name = "user")
public class User implements Serializable {
  private static final long serialVersionUID = 1L;
  @Id
  private Integer   id;
  private String    name;
  @Column
  private Address   address;
  //省略 setter 和 getter
}