Spring初始化Hibernate Repository单次实例化异常问题求助

嘿，我来帮你捋清楚这个问题！首先先纠正一个你的小误解：Spring MVC里的@Controller默认是单例作用域的，也就是说整个应用生命周期里只会创建一个实例，不会每次请求都新建。你可以在控制器的构造函数里加一行日志验证，启动后多次调用接口，只会看到一次构造函数的打印，就能确认这点了。

那为什么每次调用接口都会触发MySQL查询呢？核心问题应该是每次请求时你的代码都主动触发了Repository的查询操作，而且没有做任何缓存处理，结合你说的Property是初始配置（也就是不会频繁变更的数据），给你几个针对性的解决方案：

可能的原因&对应解决办法 #

1. 每次请求都重复执行了查询逻辑 #

如果你的控制器/PropertyDao里，每次请求都调用了repository.findAll()这类查询方法，那自然每次都会走数据库。比如你的代码可能是这样的：

@Controller
public class PropertyController {
    private final PropertyDao propertyDao;

    public PropertyController(PropertyDao propertyDao) {
        this.propertyDao = propertyDao;
    }

    @GetMapping("/props")
    public Map<String, Object> getProps() {
        // 每次请求都调用Dao的转换方法，而Dao里每次都查库
        return propertyDao.convertToMap();
    }
}

@Service
public class PropertyDao {
    private final PropertyRepository repo;

    public PropertyDao(PropertyRepository repo) {
        this.repo = repo;
    }

    public Map<String, Object> convertToMap() {
        List<Property> props = repo.findAll();
        // 转HashMap的逻辑
        return map;
    }
}

解决办法：在PropertyDao初始化时缓存结果
因为是初始配置，数据不会经常变，直接在Bean创建时查一次库，把转换后的HashMap缓存起来，后续请求直接用缓存：

@Service
public class PropertyDao {
    private final PropertyRepository repo;
    private Map<String, Object> cachedProps;

    // 构造函数初始化时就查询并缓存
    public PropertyDao(PropertyRepository repo) {
        this.repo = repo;
        this.cachedProps = convertToMap(repo.findAll());
    }

    public Map<String, Object> getCachedProps() {
        // 返回副本，避免外部修改缓存的原始数据
        return new HashMap<>(cachedProps);
    }

    private Map<String, Object> convertToMap(List<Property> props) {
        Map<String, Object> map = new HashMap<>();
        for (Property p : props) {
            map.put(p.getKey(), p.getValue());
        }
        return map;
    }

    // 可选：如果需要手动刷新缓存，加这个方法
    @Transactional
    public void refreshCache() {
        this.cachedProps = convertToMap(repo.findAll());
    }
}

之后控制器里调用getCachedProps()就行，只有启动时会查一次库，后续请求都用缓存。

2. 启用Spring的注解式缓存（更灵活） #

如果以后配置数据可能会更新，或者想更灵活地控制缓存，可以用Spring的缓存机制：

• 第一步：在启动类上加@EnableCaching开启缓存功能

@SpringBootApplication
@EnableCaching
public class YourApp {
    public static void main(String[] args) {
        SpringApplication.run(YourApp.class, args);
    }
}

• 第二步：在PropertyDao的转换方法上加@Cacheable注解，让Spring自动缓存结果

@Service
public class PropertyDao {
    private final PropertyRepository repo;

    public PropertyDao(PropertyRepository repo) {
        this.repo = repo;
    }

    @Cacheable(value = "propertiesCache") // 指定缓存名称
    public Map<String, Object> convertToMap() {
        List<Property> props = repo.findAll();
        // 转换逻辑
        return map;
    }

    // 可选：更新数据后刷新缓存
    @CacheEvict(value = "propertiesCache", allEntries = true)
    @CachePut(value = "propertiesCache")
    @Transactional
    public Map<String, Object> refreshProps() {
        return convertToMap(repo.findAll());
    }
}

第一次调用convertToMap()会查库并缓存，后续调用直接用缓存，不用再碰数据库。

3. 启用Hibernate二级缓存（针对JPA层面的查询缓存） #

如果想让Hibernate本身缓存查询结果，可以配置二级缓存：

• 先在application.properties里加配置：

# 启用二级缓存
spring.jpa.properties.hibernate.cache.use_second_level_cache=true
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.jcache.JCacheRegionFactory
# 启用查询缓存
spring.jpa.properties.hibernate.cache.use_query_cache=true

• 然后在Property实体类上标记只读缓存（因为是配置数据，不需要写操作）：

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
public class Property {
    // 你的实体字段、getter/setter
}

• 最后在Repository的查询方法上启用查询缓存：

public interface PropertyRepository extends JpaRepository<Property, Long> {
    @QueryHints(@QueryHint(name = "org.hibernate.cacheable", value = "true"))
    List<Property> findAll();
}

这样Hibernate会缓存findAll()的结果，避免重复执行SQL。

快速验证建议 #

1. 先确认控制器是否是单例：在控制器构造函数里加一行System.out.println("PropertyController created!")，启动后多次调用接口，只会看到一次打印，就能排除“每次请求创建控制器”的怀疑。
2. 检查查询触发点：在Repository的findAll()方法上加日志，或者看Hibernate的SQL日志，确认是不是每次请求都执行了查询。

内容的提问来源于stack exchange，提问作者Ozeta