public class User {
    private Long id;
    private String username;
    private List<Order> orders;

    // Getters and setters...
}

public interface UserMapper {
    User selectUserWithOrders(@Param("userId") Long userId);
}

public class YourService {
    @Autowired
    private UserMapper userMapper;

    public User getUserWithOrders(Long userId) {
        return userMapper.selectUserWithOrders(userId);
    }
}

public interface UserMapper {
    User selectUserWithOrdersAndAddress(@Param("userId") Long userId);
}

public class YourService {
    @Autowired
    private UserMapper userMapper;

    public User getUserWithOrdersAndAddress(Long userId) {
        return userMapper.selectUserWithOrdersAndAddress(userId);
    }
}

import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;

import java.sql.Connection;
import java.util.Properties;

@Intercepts({
        @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
public class SqlInterceptor implements Interceptor {

    private static final ThreadLocal<String> dynamicSqlSuffix = new ThreadLocal<>();

    public static String getDynamicSqlSuffix() {
        return dynamicSqlSuffix.get();
    }

    public static void setDynamicSqlSuffix(String suffix) {
        dynamicSqlSuffix.set(suffix);
    }

    public static void clear() {
        dynamicSqlSuffix.remove();
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        ParameterHandler parameterHandler = statementHandler.getParameterHandler();

        // 获取原始SQL语句
        String originalSql = statementHandler.getBoundSql().getSql();

        // 获取动态SQL后缀
        String dynamicSuffix = getDynamicSqlSuffix();
        if (dynamicSuffix != null && !dynamicSuffix.isEmpty()) {
            // 在原始SQL语句后面添加动态后缀
            // 加上判断是否包含WHERE的逻辑，以免直接AND报错
            originalSql += dynamicSuffix;
        }

        // 将修改后的SQL语句设置回去
        statementHandler.getBoundSql().setSql(originalSql);

        // 继续执行原来的操作
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 可以在这里配置一些属性
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class SqlAspect {

    @Before("execution(* com.example.controllers.AController.*(..))")
    public void beforeAController(JoinPoint joinPoint) {
        // 设置动态SQL后缀为 " AND status != 1"
        SqlInterceptor.setDynamicSqlSuffix(" AND status != 1");
    }

    @Before("execution(* com.example.controllers.BController.*(..))")
    public void beforeBController(JoinPoint joinPoint) {
        // 设置动态SQL后缀为 " AND status = 0"
        SqlInterceptor.setDynamicSqlSuffix(" AND status = 0");
    }
    
    // 加上对应@After清空动态sql：SqlInterceptor.clear()
}

public interface SysUserMapper extends BaseMapper<SysUser> {}

public interface ISysUserService extends IService<SysUser> {}

public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements ISysUserService {}

Page<CustomerStoreType> page = new Page<>(current, size);
LambdaQueryWrapper<实体类> lqw = new LambdaQueryWrapper<>();
lqw
  .like(StrUtil.isNotBlank(param.getTypeCode()),CustomerStoreType::getTypeCode, param.getTypeCode())
  .orderByAsc(CustomerStoreType::getSortOrder);

Page<CustomerStoreType> result = customerStoreTypeServiceImpl.page(page, lqw);
return Result.success(result);

package com.enlin.session;

import com.enlin.commons.cache.RedisCacheUtil;
import com.enlin.entity.SysUser;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.concurrent.TimeUnit;

/**
 * @author 
 * @projectName SpringBoot_MongoDB
 * @description 用户缓存
 * @date 2023/11/3 11:53
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class UserSession {

    private static final String BEARER_PREFIX = "Bearer ";
    private static final int BEARER_PREFIX_LENGTH = 7;
    
    @Autowired
    protected HttpServletRequest request;
    private SysUser user;
    private final RedisCacheUtil redisCacheUtil;


    public SysUser getUser() {
        // 从request中获取token

        String authorization = request.getHeader("Authorization");

        // 判断token是否为空
        if (authorization == null) {
            return null;
        }
        String token = authorization.replace(BEARER_PREFIX, "");
        if (user==null){
            user = getUser(token);
        }
        return user;
    }

    /**
     * 根据token获取用户信息
     * @param token 用户token
     * @return 用户信息，如果未找到则返回null
     */
    public SysUser getUser(String token) {
        if (!StringUtils.hasText(token)) {
            return null;
        }
        
        return redisCacheUtil.get(token, SysUser.class);
    }

    /**
     * 设置用户会话信息
     * @param token 用户token
     * @param user 用户信息
     * @return 是否设置成功
     */
    public boolean setUser(String token, SysUser user) {
        if (!StringUtils.hasText(token) || user == null) {
            log.warn("设置用户会话失败：token或用户信息为空");
            return false;
        }
        
        boolean success = redisCacheUtil.set(token, user, BEARER_PREFIX_LENGTH, TimeUnit.DAYS);
        if (success) {
            log.debug("用户会话设置成功，token: {}, userId: {}", token, user.getId());
        }
        return success;
    }
    /**
     * 根据token移除用户会话
     * @param token 用户token
     * @return 是否移除成功
     */
    public boolean removeUser(String token) {
        if (!StringUtils.hasText(token)) {
            return false;
        }
        return redisCacheUtil.delete(token);
    }
    /**
     * 检查用户会话是否存在
     * @param token 用户token
     * @return 是否存在
     */
    public boolean exists(String token) {
        if (!StringUtils.hasText(token)) {
            return false;
        }
        return redisCacheUtil.exists(token);
    }
    /**
     * 刷新用户会话过期时间
     * @param token 用户token
     * @return 是否刷新成功
     */
    public boolean refresh(String token) {
        if (!StringUtils.hasText(token)) {
            return false;
        }
        return redisCacheUtil.expire(token, BEARER_PREFIX_LENGTH, TimeUnit.DAYS);
    }
    /**
     * 获取用户会话过期时间
     * @param token 用户token
     * @return 过期时间，单位：毫秒
     */
    public long getExpire(String token) {
        if (!StringUtils.hasText(token)) {
            return -1;
        }
        return redisCacheUtil.getExpire(token);
    }

}

package com.enlin.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;

import com.enlin.entity.SysUser;
import com.enlin.session.UserSession;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 自定义元数据对象处理器
 */
@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Autowired
    private UserSession userSession;
    /**
     * 插入操作，自动填充
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        SysUser user;
        String userId = "1";
        try {
            user = userSession.getUser();
            if (user != null) {
                userId = user.getId();
            }
        } catch (Exception e) {
            log.warn("获取当前用户信息失败，使用默认用户ID: {}", userId, e);
        }
        metaObject.setValue("createTime", System.currentTimeMillis());
        metaObject.setValue("updateTime", System.currentTimeMillis());
        metaObject.setValue("createBy",userId);
        metaObject.setValue("updateBy",userId);
        metaObject.setValue("deleted", false);
    }

    /**
     * 更新操作，自动填充
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        SysUser user;
        String userId = "1";
        try {
            user = userSession.getUser();
            if (user != null) {
                userId = user.getId();
            }
        } catch (Exception e) {
            log.warn("获取当前用户信息失败，使用默认用户ID: {}", userId, e);
        }
        metaObject.setValue("updateTime", System.currentTimeMillis());
        metaObject.setValue("updateBy", userId);
    }
}

package com.enlin.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;

/**
 * <p>
 * 登录账号表
 * </p>
 *
 * @author Jay.Bao
 * @since 2025-08-13
 */
@Getter
@Setter
@ToString
@TableName("t_sys_user")
public class SysUser extends BaseEntity implements Serializable  {

    private static final long serialVersionUID = 1L;
    
    /**
     * 账号编码（唯一）
     */
    @TableField("c_code")
    private String code;


}

package com.enlin.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

@Data
public class BaseEntity {
    
    /**
     * 雪花算法生成的唯一ID
     */
    @TableId(value = "c_id", type = IdType.ASSIGN_ID)
    private String id;
    
    @TableField(value = "c_create_by", fill = FieldFill.INSERT)
    private String createBy;

    @TableField(value = "c_create_time", fill = FieldFill.INSERT)
    private Long createTime;

    @TableField(value = "c_update_by", fill = FieldFill.INSERT_UPDATE)
    private String updateBy;

    @TableField(value = "c_update_time", fill = FieldFill.INSERT_UPDATE)
    private Long updateTime;

    /**
     * 是否逻辑删除
     */
    @TableField(value = "c_deleted", fill = FieldFill.INSERT)
    private Boolean deleted;
}