RuoYi框架：Spring Boot企业级开发实践与优化-代码聚汇网

RuoYi框架：Spring Boot企业级开发实践与优化

REECHO大鱼总舵

1. RuoYi框架概述与核心定位

RuoYi是一款基于Spring Boot的快速开发框架，在Java企业级应用开发领域具有广泛的应用基础。这个框架最早由国内开发者社区贡献，经过多年迭代已经形成了完整的生态体系。我初次接触RuoYi是在2018年参与一个政府信息化项目时，当时团队需要快速搭建具备RBAC权限管理、代码生成器和基础CRUD功能的后台系统，经过技术选型对比后最终采用了RuoYi作为基础框架。

从架构设计角度看，RuoYi采用了经典的分层架构模式：

表现层：Thymeleaf模板引擎 + Bootstrap前端组件
控制层：Spring MVC实现RESTful接口
业务层：Spring事务管理 + 自定义注解
持久层：MyBatis + PageHelper分页插件
安全层：Apache Shiro权限控制

这种架构组合使得RuoYi在保持技术先进性的同时，也兼顾了开发效率。特别是在中小型管理系统的开发场景中，开发者可以基于RuoYi快速搭建出具备完善权限体系和基础功能的后台应用。根据我的项目经验，使用RuoYi相比从零开发可以节省约40%的前期开发时间。

2. 核心模块实现原理深度解析

2.1 权限控制系统的设计哲学

RuoYi的权限系统采用RBAC（基于角色的访问控制）模型，这是其最具特色的设计之一。在底层实现上，框架通过Shiro的Subject、SecurityManager和Realm三大核心组件构建了完整的认证授权体系。

具体到代码层面，ShiroConfig类中配置了以下几个关键bean：

java复制@Bean
public SecurityManager securityManager(UserRealm userRealm) {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setRealm(userRealm);
    securityManager.setRememberMeManager(rememberMeManager());
    return securityManager;
}

@Bean
public UserRealm userRealm() {
    UserRealm userRealm = new UserRealm();
    userRealm.setCredentialsMatcher(hashedCredentialsMatcher());
    return userRealm;
}

权限数据在数据库中的存储结构设计也很有特点：

sys_user：用户基础信息表
sys_role：角色定义表
sys_menu：菜单/权限项表
sys_user_role：用户-角色关联表
sys_role_menu：角色-权限关联表

这种设计使得权限分配非常灵活，我在实际项目中曾遇到需要实现"数据权限"的需求（不同角色看到不同的数据范围），通过扩展UserRealm和自定义注解就顺利实现了这个功能。

2.2 代码生成器的实现机制

RuoYi的代码生成器模块(GenController)是其提高开发效率的关键。这个模块的核心原理是通过解析数据库表结构，基于Velocity模板引擎动态生成Entity、Mapper、Service、Controller等标准CRUD代码。

生成器的核心处理流程如下：

通过JDBC获取表元数据（字段名、类型、注释等）
将元数据转换为模板变量
根据选择的模板类型（单表、树表）渲染代码
输出ZIP压缩包供下载

一个典型的模板文件（如vm/java/entity.java.vm）内容如下：

velocity复制package ${packageName}.domain;

import java.io.Serializable;
import java.util.Date;
import com.ruoyi.common.annotation.Excel;

public class ${ClassName} implements Serializable {
    private static final long serialVersionUID = 1L;

    #foreach ($column in $columns)
    /** $column.columnComment */
    @Excel(name = "${column.columnComment}")
    private $column.javaType $column.javaField;
    #end
}

在实际使用中，我发现通过调整模板文件可以快速适配不同团队的编码规范。例如，我们团队习惯使用Lombok注解，只需修改entity模板添加@Data注解即可统一风格。

3. 框架扩展与定制实践

3.1 多数据源支持的实现方案

在大型项目中，经常需要同时访问多个数据库。RuoYi通过继承AbstractRoutingDataSource实现了动态数据源切换功能。核心实现类DynamicDataSource的关键代码如下：

java复制public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

配置多个数据源时需要在application.yml中声明：

yaml复制datasource:
    master:
        url: jdbc:mysql://localhost:3306/ry?useSSL=false
        username: root
        password: 123456
    slave:
        url: jdbc:mysql://192.168.1.100:3306/ry_slave?useSSL=false
        username: readuser
        password: 123456

在实际使用中，通过@DataSource注解即可切换数据源：

java复制@Service
public class UserServiceImpl implements UserService {
    
    @DataSource(value = DataSourceType.MASTER)
    public void addUser(User user) {
        // 使用主库写入
    }
    
    @DataSource(value = DataSourceType.SLAVE) 
    public List<User> selectUserList() {
        // 使用从库查询
    }
}

注意事项：在多数据源环境下，事务管理需要特别处理。建议在Service层方法上明确指定事务管理器，避免跨数据源事务问题。

3.2 定时任务模块的优化实践

RuoYi内置了基于Spring Task的定时任务功能，但原生实现存在任务持久化和集群部署方面的问题。在我的项目中，我们对其进行了以下改进：

持久化改造：将任务配置从内存迁移到数据库

sql复制CREATE TABLE sys_job (
    job_id BIGINT NOT NULL AUTO_INCREMENT,
    job_name VARCHAR(64) NOT NULL,
    job_group VARCHAR(64) NOT NULL,
    invoke_target VARCHAR(500) NOT NULL,
    cron_expression VARCHAR(255),
    misfire_policy VARCHAR(20),
    concurrent CHAR(1),
    status CHAR(1),
    create_time DATETIME,
    PRIMARY KEY (job_id)
);

集群支持：通过Redis分布式锁防止任务重复执行

java复制public void executeJob(SysJob job) {
    String lockKey = "job_lock:" + job.getJobId();
    try {
        boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 30, TimeUnit.SECONDS);
        if (locked) {
            // 执行任务逻辑
        }
    } finally {
        redisTemplate.delete(lockKey);
    }
}

失败重试机制：对异常任务进行有限次重试

java复制@Retryable(value = Exception.class, maxAttempts = 3, backoff = @Backoff(delay = 5000))
public void invokeMethod(SysJob job) throws Exception {
    // 反射调用目标方法
}

这些改进使得定时任务模块更加健壮，能够适应生产环境的需求。特别是在分布式部署场景下，避免了任务被多个节点重复执行的问题。

4. 性能优化与生产实践

4.1 缓存策略的深度应用

RuoYi默认集成了Redis缓存，但在实际使用中需要根据业务特点进行定制化配置。以下是我们项目中总结的缓存最佳实践：

多级缓存架构：
- 一级缓存：本地Caffeine缓存（超时时间短，5-10分钟）
- 二级缓存：Redis集群（超时时间长，30分钟-2小时）
- 三级缓存：数据库
缓存注解的增强使用：

java复制@Cacheable(value = "userCache", key = "#userId", 
           unless = "#result == null || #result.status == 'disabled'")
public User getUserById(Long userId) {
    return userMapper.selectUserById(userId);
}

@CacheEvict(value = "userCache", key = "#user.userId")
public void updateUser(User user) {
    userMapper.updateUser(user);
}

缓存雪崩防护：

java复制@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(30))
        .disableCachingNullValues()
        .serializeValuesWith(SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(Object.class)));
    
    // 随机过期时间分散雪崩风险
    return RedisCacheManager.builder(factory)
        .cacheDefaults(config)
        .withInitialCacheConfigurations(getRandomTtlConfigs())
        .transactionAware()
        .build();
}

4.2 接口性能监控方案

在生产环境中，我们对RuoYi的接口性能进行了系统化监控，主要实现方案如下：

Spring AOP切面记录接口耗时：

java复制@Aspect
@Component
public class PerformanceAspect {
    
    private static final Logger logger = LoggerFactory.getLogger(PerformanceAspect.class);
    private static final long WARN_THRESHOLD = 1000; // 1秒阈值
    
    @Around("execution(* com.ruoyi..*Controller.*(..))")
    public Object monitorPerformance(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return pjp.proceed();
        } finally {
            long cost = System.currentTimeMillis() - start;
            if (cost > WARN_THRESHOLD) {
                logger.warn("Slow API: {}.{}, cost {}ms", 
                    pjp.getTarget().getClass().getSimpleName(),
                    pjp.getSignature().getName(),
                    cost);
            }
        }
    }
}

Prometheus + Grafana监控看板：

java复制@Bean
public MeterRegistryCustomizer<PrometheusMeterRegistry> metricsCommonTags() {
    return registry -> registry.config().commonTags("application", "ruoyi-system");
}

// 在Controller中添加指标统计
@GetMapping("/api/users")
@Timed(value = "user.api.time", description = "Time taken to return users")
public List<User> getUsers() {
    // 业务逻辑
}

慢SQL监控配置：

yaml复制mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    mapUnderscoreToCamelCase: true

通过这些监控手段，我们成功将平均接口响应时间从最初的800ms优化到了300ms以内，其中最关键的几个慢接口通过SQL优化和缓存策略调整获得了5-10倍的性能提升。

5. 安全加固实践

5.1 认证安全增强

虽然RuoYi已经内置了Shiro进行安全控制，但在实际生产环境中我们还需要进行以下加固：

密码加密策略升级：

java复制@Bean
public HashedCredentialsMatcher hashedCredentialsMatcher() {
    HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
    matcher.setHashAlgorithmName("SHA-256");
    matcher.setHashIterations(1024);
    matcher.setStoredCredentialsHexEncoded(false);
    return matcher;
}

登录失败防御：

java复制public class LoginRetryLimitFilter extends FormAuthenticationFilter {
    
    private RedisTemplate<String, Integer> redisTemplate;
    private int maxRetryCount = 5;
    private long lockTime = 1800; // 30分钟
    
    @Override
    protected boolean onLoginFailure(..., AuthenticationToken token, 
                                   AuthenticationException e) {
        String username = (String) token.getPrincipal();
        String key = "login:retry:" + username;
        
        Integer retryCount = redisTemplate.opsForValue().get(key);
        if (retryCount == null) {
            retryCount = 0;
        }
        
        if (++retryCount >= maxRetryCount) {
            redisTemplate.opsForValue().set(key, retryCount, lockTime, TimeUnit.SECONDS);
            throw new ExcessiveAttemptsException("账号已锁定，请30分钟后重试");
        } else {
            redisTemplate.opsForValue().set(key, retryCount, lockTime, TimeUnit.SECONDS);
        }
        
        return super.onLoginFailure(token, e);
    }
}

Session安全配置：

java复制@Bean
public ServletContextInitializer servletContextInitializer() {
    return servletContext -> {
        servletContext.getSessionCookieConfig().setHttpOnly(true);
        servletContext.getSessionCookieConfig().setSecure(true);
        servletContext.getSessionCookieConfig().setMaxAge(1800); // 30分钟
    };
}

5.2 接口防重放攻击

对于重要接口（如支付、数据修改等），我们实现了防重放攻击机制：

请求签名算法：

java复制public class ApiSignUtil {
    public static String generateSign(Map<String, String> params, String secret) {
        // 1. 过滤空值参数
        // 2. 按参数名排序
        // 3. 拼接成key1=value1&key2=value2格式
        // 4. 拼接secret
        // 5. MD5加密
    }
}

时间戳校验：

java复制@Aspect
@Component
public class ApiSecurityAspect {
    
    private static final long TIME_DIFF_LIMIT = 5 * 60 * 1000; // 5分钟
    
    @Before("@annotation(com.ruoyi.common.annotation.RequireSign)")
    public void checkSign(JoinPoint joinPoint) {
        HttpServletRequest request = ((ServletRequestAttributes) 
            RequestContextHolder.getRequestAttributes()).getRequest();
        
        long clientTime = Long.parseLong(request.getHeader("X-Timestamp"));
        if (Math.abs(System.currentTimeMillis() - clientTime) > TIME_DIFF_LIMIT) {
            throw new ApiException("请求已过期");
        }
        
        // 验证签名...
    }
}

随机数防重放：

java复制@Cacheable(value = "nonceCache", key = "#nonce")
public void checkNonce(String nonce) {
    if (StringUtils.isEmpty(nonce) || nonce.length() != 32) {
        throw new ApiException("非法请求");
    }
    // 如果nonce已存在缓存中，说明是重放请求
}

通过这些安全措施，我们成功防御了多次针对系统的恶意攻击尝试，特别是在开放API接口方面，未再出现安全事件。

6. 微服务化改造经验

随着业务规模扩大，我们将单体架构的RuoYi系统改造成了微服务架构，主要改造点包括：

6.1 服务拆分策略

按照业务功能垂直拆分：

用户中心服务 (user-service)
权限管理服务 (auth-service)
内容管理服务 (cms-service)
文件存储服务 (file-service)
消息通知服务 (notify-service)

每个服务都有自己独立的数据库，通过API网关统一对外暴露接口。

6.2 Spring Cloud集成

服务注册与发现：

yaml复制spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev

OpenFeign客户端声明：

java复制@FeignClient(name = "user-service", path = "/api/user")
public interface UserServiceClient {
    
    @GetMapping("/{userId}")
    Result<UserDTO> getUserById(@PathVariable Long userId);
    
    @PostMapping
    Result<Long> createUser(@RequestBody UserCreateVO vo);
}

分布式事务处理：

java复制@GlobalTransactional
public void crossServiceOperation() {
    // 调用服务A
    // 调用服务B
    // 本地数据库操作
}

6.3 配置中心实践

使用Nacos作为配置中心，实现配置的动态更新：

bootstrap.yml配置：

yaml复制spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        shared-configs:
          - data-id: common.yaml
            refresh: true

动态刷新配置类：

java复制@RefreshScope
@Configuration
public class DynamicConfig {
    
    @Value("${custom.config.timeout:5000}")
    private int timeout;
    
    // Getter/Setter
}

配置版本管理：

bash复制# 回滚到历史版本
curl -X POST "http://127.0.0.1:8848/nacos/v1/cs/configs?dataId=user-service.yaml&group=DEFAULT_GROUP&type=yaml&version=123"

在微服务改造过程中，最大的挑战是分布式事务和跨服务数据一致性问题。我们最终采用了"最终一致性+补偿机制"的方案，通过消息队列和定时任务来保证数据最终一致。

7. 前端架构优化

虽然RuoYi默认采用Thymeleaf服务端渲染，但在我们的项目中改造成了前后端分离架构：

7.1 Vue.js集成方案

前端项目结构：

code复制src/
├── api/           # 接口定义
├── assets/        # 静态资源
├── components/    # 公共组件
├── router/        # 路由配置
├── store/         # Vuex状态管理
├── utils/         # 工具函数
└── views/         # 页面组件

接口请求封装：

javascript复制const service = axios.create({
  baseURL: process.env.VUE_APP_BASE_API,
  timeout: 5000
})

// 请求拦截器
service.interceptors.request.use(config => {
  if (store.getters.token) {
    config.headers['Authorization'] = 'Bearer ' + getToken()
  }
  return config
})

// 响应拦截器
service.interceptors.response.use(
  response => {
    const res = response.data
    if (res.code !== 200) {
      Message.error(res.msg || 'Error')
      return Promise.reject(new Error(res.msg || 'Error'))
    }
    return res
  }
)

权限控制实现：

javascript复制router.beforeEach(async (to, from, next) => {
  const hasToken = getToken()
  
  if (hasToken) {
    if (to.path === '/login') {
      next({ path: '/' })
    } else {
      const hasRoles = store.getters.roles && store.getters.roles.length > 0
      if (hasRoles) {
        next()
      } else {
        try {
          const { roles } = await store.dispatch('user/getInfo')
          const accessRoutes = await store.dispatch('permission/generateRoutes', roles)
          router.addRoutes(accessRoutes)
          next({ ...to, replace: true })
        } catch (error) {
          await store.dispatch('user/resetToken')
          Message.error(error || 'Has Error')
          next(`/login?redirect=${to.path}`)
        }
      }
    }
  }
})

7.2 性能优化措施

路由懒加载：

javascript复制const UserManage = () => import('@/views/system/user/index')

组件按需引入：

javascript复制import { Button, Table, Pagination } from 'element-ui'

Vue.use(Button)
Vue.use(Table)
Vue.use(Pagination)

Webpack打包优化：

javascript复制configureWebpack: {
  plugins: [
    new BundleAnalyzerPlugin(),
    new CompressionPlugin({
      test: /\.js$|\.css$/,
      threshold: 10240
    })
  ],
  externals: {
    'vue': 'Vue',
    'element-ui': 'ELEMENT'
  }
}

CDN加速配置：

html复制<!DOCTYPE html>
<html>
<head>
  <link href="https://cdn.jsdelivr.net/npm/element-ui@2.15.3/lib/theme-chalk/index.css" rel="stylesheet">
</head>
<body>
  <script src="https://cdn.jsdelivr.net/npm/vue@2.6.14/dist/vue.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/element-ui@2.15.3/lib/index.js"></script>
</body>
</html>

通过这些优化措施，前端应用的首次加载时间从原来的4秒降低到了1.5秒左右，大大提升了用户体验。特别是在移动端场景下，性能提升更为明显。

8. 容器化部署实践

8.1 Docker化改造

后端Dockerfile示例：

dockerfile复制FROM openjdk:8-jdk-alpine
VOLUME /tmp
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

前端Dockerfile示例：

dockerfile复制FROM nginx:alpine
COPY dist/ /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Nginx配置优化：

nginx复制server {
    listen 80;
    gzip on;
    gzip_types text/plain text/css application/json application/javascript text/xml;
    
    location / {
        root /usr/share/nginx/html;
        index index.html;
        try_files $uri $uri/ /index.html;
    }
    
    location /api/ {
        proxy_pass http://gateway-service:8080;
        proxy_set_header Host $host;
    }
}

8.2 Kubernetes部署方案

Deployment示例：

yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: registry.example.com/user-service:1.0.0
        ports:
        - containerPort: 8080
        resources:
          limits:
            cpu: "1"
            memory: 1Gi
          requests:
            cpu: "0.5"
            memory: 512Mi

Service暴露：

yaml复制apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

Ingress路由配置：

yaml复制apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ruoyi-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  rules:
  - http:
      paths:
      - path: /api/user(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80

在容器化部署过程中，我们遇到了服务发现、配置管理和日志收集等挑战。通过引入Service Mesh（Istio）和EFK（Elasticsearch+Fluentd+Kibana）日志系统，最终构建了完整的云原生架构。

9. 持续集成与交付

9.1 Jenkins流水线配置

完整的CI/CD流程：

groovy复制pipeline {
    agent any
    
    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', url: 'https://github.com/your-repo.git'
            }
        }
        
        stage('Build Backend') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        
        stage('Build Frontend') {
            steps {
                sh 'cd frontend && npm install && npm run build'
            }
        }
        
        stage('Docker Build') {
            steps {
                script {
                    docker.build("user-service:${env.BUILD_ID}", "-f Dockerfile.backend .")
                    docker.build("user-web:${env.BUILD_ID}", "-f Dockerfile.frontend .")
                }
            }
        }
        
        stage('Deploy to K8s') {
            steps {
                sh "kubectl set image deployment/user-service user-service=user-service:${env.BUILD_ID}"
                sh "kubectl set image deployment/user-web user-web=user-web:${env.BUILD_ID}"
            }
        }
    }
}

质量门禁设置：

groovy复制stage('Code Quality') {
    steps {
        sh 'mvn sonar:sonar -Dsonar.projectKey=user-service'
        timeout(time: 10, unit: 'MINUTES') {
            waitForQualityGate abortPipeline: true
        }
    }
}

9.2 自动化测试策略

单元测试覆盖率要求：

xml复制<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.7</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <rules>
            <rule>
                <limit>
                    <counter>LINE</counter>
                    <value>COVEREDRATIO</value>
                    <minimum>0.8</minimum>
                </limit>
            </rule>
        </rules>
    </configuration>
</plugin>

API契约测试：

java复制@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureStubRunner(ids = {"com.example:auth-service:+:stubs:8080"},
        stubsMode = StubsMode.LOCAL)
public class UserApiContractTest {

    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    public void getUserById_shouldReturnUser() {
        ResponseEntity<User> response = restTemplate.getForEntity(
            "/api/user/1", User.class);
        
        assertThat(response.getStatusCodeValue()).isEqualTo(200);
        assertThat(response.getBody().getUsername()).isEqualTo("admin");
    }
}

端到端测试方案：

javascript复制describe('User Management', () => {
  before(() => {
    cy.login('admin', 'admin123');
  });

  it('should create new user', () => {
    cy.visit('/system/user');
    cy.get('.el-button--primary').contains('新增').click();
    cy.get('input[placeholder="用户名"]').type('testuser');
    // 填写其他表单字段...
    cy.get('.el-dialog__footer .el-button--primary').click();
    cy.contains('.el-notification', '创建成功').should('be.visible');
  });
});

通过完善的CI/CD流水线，我们将代码从提交到部署的时间从原来的人工2小时缩短到了全自动化的15分钟，且质量稳定性显著提升。特别是在多团队协作的大型项目中，这种自动化流程极大地减少了人为错误和沟通成本。

10. 项目演进与架构反思

经过三年多的RuoYi框架应用和改造实践，我对这个框架的演进方向有了一些新的思考：

模块化设计改进：

将核心功能拆分为独立模块（如rbac-core、codegen-core）
通过SPI机制提供扩展点
示例模块结构：

code复制ruoyi-core/
ruoyi-framework/
ruoyi-system/
ruoyi-quartz/
ruoyi-generator/

响应式编程支持：

java复制@RestController
@RequestMapping("/reactive/users")
public class ReactiveUserController {
    
    private final ReactiveUserService userService;
    
    @GetMapping
    public Flux<User> listUsers() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public Mono<User> getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

GraphQL集成方案：

java复制@Controller
public class UserGraphQLController {
    
    @QueryMapping
    public Flux<User> users() {
        return userService.findAll();
    }
    
    @MutationMapping
    public Mono<User> createUser(@Argument UserInput input) {
        return userService.create(input);
    }
}

领域驱动设计实践：

java复制public class User {
    private UserId id;
    private Username username;
    private Password password;
    private Email email;
    
    public void changePassword(String oldPass, String newPass) {
        if (!password.matches(oldPass)) {
            throw new BusinessException("原密码错误");
        }
        this.password = new Password(newPass);
    }
}

在技术选型方面，我认为RuoYi框架未来可以考虑：

逐步迁移到Spring Boot 3.x和Java 17
引入GraalVM原生镜像支持
增加对Kotlin协程的支持
完善云原生相关功能（如Serverless适配）

从架构角度看，RuoYi作为一个快速开发框架，在保持简单易用的同时，也需要与时俱进地吸收现代架构思想。特别是在微服务、云原生和领域驱动设计等方面，还有很大的演进空间。