lambda表达式的使用（二）

@Service
public class AccessTokenServiceImpl implements IAccessTokenService {

    @Autowired
    private IAccessTokenMapper accessTokenMapper;

    @Override
    @Cacheable(cacheNames = ACCESS_TOKEN_SELECT_BY_TOKEN)
    public Optional<AccessTokenEntity> getToken(String token, String refreshToken) {
        return accessTokenMapper.select(c -> c.where()
                .and(accesstokenEntity.token, isEqualToWhenPresent(token))
                .and(accesstokenEntity.refreshToken, isEqualToWhenPresent(refreshToken))
        ).stream()
        .findFirst();
    }

    @Override
    public Integer delFailureToken() {
        Date date = Jdk8DateUtil.minusDays(new Date(), 30);
        return accessTokenMapper.delete(c -> c.where(accesstokenEntity.expires, isLessThan(date.getTime())));
    }
}

package com.hst.ces.mybatis.mybatis3.dao;

import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.accesstokenEntity;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.clientId;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.creationDate;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.encodedPrincipal;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.expires;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.id;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.modificationDate;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.refreshToken;
import static com.hst.ces.mybatis.mybatis3.dao.support.AccessTokenEntityDynamicSqlSupport.token;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;

import com.hst.ces.mybatis.mybatis3.entity.AccessTokenEntity;
import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.ResultMap;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.BasicColumn;
import org.mybatis.dynamic.sql.delete.DeleteDSLCompleter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
import org.mybatis.dynamic.sql.select.CountDSLCompleter;
import org.mybatis.dynamic.sql.select.SelectDSLCompleter;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.UpdateDSLCompleter;
import org.mybatis.dynamic.sql.update.UpdateModel;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;

import java.util.Collection;
import java.util.List;
import java.util.Optional;

/**
 * @author dengxl
 */
@Mapper
public interface IAccessTokenMapper extends IBaseDao {
    BasicColumn[] selectList = BasicColumn.columnList(id, creationDate, modificationDate, expires, refreshToken, token,
            clientId, encodedPrincipal);

    /**
     * count
     */
    @SelectProvider(type = SqlProviderAdapter.class, method = "select")
    long count(SelectStatementProvider selectStatement);

    /**
     * count
     */
    default long count(CountDSLCompleter completer) {
        return MyBatis3Utils.countFrom(this::count, accesstokenEntity, completer);
    }

    /**
     * delete
     */
    @DeleteProvider(type = SqlProviderAdapter.class, method = "delete")
    int delete(DeleteStatementProvider deleteStatement);

    /**
     * delete
     */
    default int delete(DeleteDSLCompleter completer) {
        return MyBatis3Utils.deleteFrom(this::delete, accesstokenEntity, completer);
    }

    /**
     * deleteByPrimaryKey
     */
    default int deleteByPrimaryKey(Long idParam) {
        return delete(c ->
                c.where(id, isEqualTo(idParam))
        );
    }

    /**
     * insertMultiple
     */
    @Insert({"${insertStatement}"})
    @Options(useGeneratedKeys = true, keyProperty = "records.id")
    int insertMultiple(@Param("insertStatement") String insertStatement,
                       @Param("records") List<AccessTokenEntity> records);

    /**
     * insertMultiple
     */
    default int insertMultiple(MultiRowInsertStatementProvider<AccessTokenEntity> multipleInsertStatement) {
        return insertMultiple(multipleInsertStatement.getInsertStatement(), multipleInsertStatement.getRecords());
    }

    /**
     * insertMultiple
     */
    default int insertMultiple(Collection<AccessTokenEntity> records) {
        return MyBatis3Utils.insertMultiple(this::insertMultiple, records, accesstokenEntity, c ->
                c.map(creationDate).toProperty("creationDate")
                        .map(modificationDate).toProperty("modificationDate")
                        .map(expires).toProperty("expires")
                        .map(refreshToken).toProperty("refreshToken")
                        .map(token).toProperty("token")
                        .map(clientId).toProperty("clientId")
                        .map(encodedPrincipal).toProperty("encodedPrincipal")
        );
    }

    /**
     * insert
     */
    @InsertProvider(type = SqlProviderAdapter.class, method = "insert")
    @Options(useGeneratedKeys = true, keyProperty = "record.id")
    int insert(InsertStatementProvider<AccessTokenEntity> insertStatement);

    /**
     * insert
     */
    default int insert(AccessTokenEntity record) {
        return MyBatis3Utils.insert(this::insert, record, accesstokenEntity, c ->
                c.map(creationDate).toProperty("creationDate")
                        .map(modificationDate).toProperty("modificationDate")
                        .map(expires).toProperty("expires")
                        .map(refreshToken).toProperty("refreshToken")
                        .map(token).toProperty("token")
                        .map(clientId).toProperty("clientId")
                        .map(encodedPrincipal).toProperty("encodedPrincipal")
        );
    }

    /**
     * insertSelective
     */
    default int insertSelective(AccessTokenEntity record) {
        return MyBatis3Utils.insert(this::insert, record, accesstokenEntity, c ->
                c.map(creationDate).toPropertyWhenPresent("creationDate", record::getCreationDate)
                        .map(modificationDate).toPropertyWhenPresent("modificationDate", record::getModificationDate)
                        .map(expires).toPropertyWhenPresent("expires", record::getExpires)
                        .map(refreshToken).toPropertyWhenPresent("refreshToken", record::getRefreshToken)
                        .map(token).toPropertyWhenPresent("token", record::getToken)
                        .map(clientId).toPropertyWhenPresent("clientId", record::getClientId)
                        .map(encodedPrincipal).toPropertyWhenPresent("encodedPrincipal", record::getEncodedPrincipal)
        );
    }

    /**
     * selectOne
     */
    @SelectProvider(type = SqlProviderAdapter.class, method = "select")
    @ResultMap("AccesstokenEntityResult")
    Optional<AccessTokenEntity> selectOne(SelectStatementProvider selectStatement);

    /**
     * selectOne
     */
    default Optional<AccessTokenEntity> selectOne(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectOne(this::selectOne, selectList, accesstokenEntity, completer);
    }

    /**
     * select
     */
    default List<AccessTokenEntity> select(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectList(this::selectMany, selectList, accesstokenEntity, completer);
    }

    /**
     * selectMany
     */
    @SelectProvider(type = SqlProviderAdapter.class, method = "select")
    @Results(id = "AccesstokenEntityResult", value = {
            @Result(column = "id", property = "id", jdbcType = JdbcType.BIGINT, id = true),
            @Result(column = "creationDate", property = "creationDate", jdbcType = JdbcType.TIMESTAMP),
            @Result(column = "modificationDate", property = "modificationDate", jdbcType = JdbcType.TIMESTAMP),
            @Result(column = "expires", property = "expires", jdbcType = JdbcType.BIGINT),
            @Result(column = "refreshToken", property = "refreshToken", jdbcType = JdbcType.VARCHAR),
            @Result(column = "token", property = "token", jdbcType = JdbcType.VARCHAR),
            @Result(column = "client_id", property = "clientId", jdbcType = JdbcType.BIGINT),
            @Result(column = "encodedPrincipal", property = "encodedPrincipal", jdbcType = JdbcType.LONGVARCHAR)
        })
    List<AccessTokenEntity> selectMany(SelectStatementProvider selectStatement);

    /**
     * selectDistinct
     */
    default List<AccessTokenEntity> selectDistinct(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectDistinct(this::selectMany, selectList, accesstokenEntity, completer);
    }

    /**
     * selectByPrimaryKey
     */
    default Optional<AccessTokenEntity> selectByPrimaryKey(Long idParam) {
        return selectOne(c ->
                c.where(id, isEqualTo(idParam))
        );
    }

    /**
     * update
     */
    @UpdateProvider(type = SqlProviderAdapter.class, method = "update")
    int update(UpdateStatementProvider updateStatement);

    /**
     * update
     */
    default int update(UpdateDSLCompleter completer) {
        return MyBatis3Utils.update(this::update, accesstokenEntity, completer);
    }

    /**
     * updateAllColumns
     */
    static UpdateDSL<UpdateModel> updateAllColumns(AccessTokenEntity record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(creationDate).equalTo(record::getCreationDate)
                .set(modificationDate).equalTo(record::getModificationDate)
                .set(expires).equalTo(record::getExpires)
                .set(refreshToken).equalTo(record::getRefreshToken)
                .set(token).equalTo(record::getToken)
                .set(clientId).equalTo(record::getClientId)
                .set(encodedPrincipal).equalTo(record::getEncodedPrincipal);
    }

    /**
     * updateSelectiveColumns
     */
    static UpdateDSL<UpdateModel> updateSelectiveColumns(AccessTokenEntity record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(creationDate).equalToWhenPresent(record::getCreationDate)
                .set(modificationDate).equalToWhenPresent(record::getModificationDate)
                .set(expires).equalToWhenPresent(record::getExpires)
                .set(refreshToken).equalToWhenPresent(record::getRefreshToken)
                .set(token).equalToWhenPresent(record::getToken)
                .set(clientId).equalToWhenPresent(record::getClientId)
                .set(encodedPrincipal).equalToWhenPresent(record::getEncodedPrincipal);
    }

    /**
     * updateByPrimaryKey
     */
    default int updateByPrimaryKey(AccessTokenEntity record) {
        return update(c ->
                c.set(creationDate).equalTo(record::getCreationDate)
                        .set(modificationDate).equalTo(record::getModificationDate)
                        .set(expires).equalTo(record::getExpires)
                        .set(refreshToken).equalTo(record::getRefreshToken)
                        .set(token).equalTo(record::getToken)
                        .set(clientId).equalTo(record::getClientId)
                        .set(encodedPrincipal).equalTo(record::getEncodedPrincipal)
                        .where(id, isEqualTo(record::getId))
        );
    }

    /**
     * updateByPrimaryKeySelective
     */
    default int updateByPrimaryKeySelective(AccessTokenEntity record) {
        return update(c ->
                c.set(creationDate).equalToWhenPresent(record::getCreationDate)
                        .set(modificationDate).equalToWhenPresent(record::getModificationDate)
                        .set(expires).equalToWhenPresent(record::getExpires)
                        .set(refreshToken).equalToWhenPresent(record::getRefreshToken)
                        .set(token).equalToWhenPresent(record::getToken)
                        .set(clientId).equalToWhenPresent(record::getClientId)
                        .set(encodedPrincipal).equalToWhenPresent(record::getEncodedPrincipal)
                        .where(id, isEqualTo(record::getId))
        );
    }
}

lambda的骚操作（集合collection（如list）才有steam（）流方法，且返回流对象，findFirst（）方法返回的是optional对象。