3.项目启动spring加载bean时卡住 log4j: Finished configuring. 项目启动耗时过长问题

最新推荐文章于 2023-09-06 15:05:52 发布
最新推荐文章于 2023-09-06 15:05:52 发布
阅读量902 收藏 2
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x948130516/article/details/96475308
版权

现象：没有提示，也不报错，项目正常启动，但耗时长，有时一分钟两分钟甚至两分钟，控制台无输出，一分钟后突然开始加载实例化bean，然后启动完毕。

原因：其实是spring扫描时间过长，因为配置中指定的bean扫描目录过来，大多是因为指定了 **.*导致，修改成具体的扫描目录即可。我的项目即是这样改完后从原来的一分五十秒变成二十几秒。

原来配置如下：

<!-- 装载自定义bean -->

<context:component-scan base-package="**.*" use-default-filters="false">

<context:include-filter type="assignable" expression="com.fun.common.base.BaseInterface"></context:include-filter>

<context:include-filter type="assignable" expression="com.fun.common.base.BaseThread"></context:include-filter>

</context:component-scan>

 

修改后：

<!-- 装载自定义bean -->

<context:component-scan base-package="com.consumer.web.thread" use-default-filters="false">

<!-- <context:include-filter type="assignable" expression="com.consumer.common.base.BaseInterface"></context:include-filter>-->

<context:include-filter type="assignable" expression="com.consumer.common.base.BaseThread"></context:include-filter>

</context:component-scan>

沫离痕
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
项目启动很慢，一致加载不出来，感觉是进入死循环
David的博客
04-06 5618
解决：将日志级别设置为debug，查看启动细节log4j.propertites放在resources# Global logging configuration log4j.rootLogger=DEBUG,ERROR, stdout, files # MyBatis logging configuration... log4j.logger.mapper=ERROR # Conso...
Syngress - Dr. Tom Shinder's Configuring ISA Server 2004 (2005).pdf
08-20
Syngress - Dr. Tom Shinder's Configuring ISA Server 2004 (2005).pdf
Manning.Spring.in.Action.4th.Edition.2014.11.epub
06-25
Table of Contents Copyright Brief Table of Contents Table of Contents Praise for the Third Edition of Spring in Action Preface Acknowledgments About this Book 1. Core Spring Chapter 1. Springing into action 1.1. Simplifying Java development 1.1.1. Unleashing the power of POJOs 1.1.2. Injecting dependencies 1.1.3. Applying aspects 1.1.4. Eliminating boilerplate code with templates 1.2. Containing your beans 1.2.1. Working with an application context 1.2.2. A bean’s life 1.3. Surveying the Spring landscape 1.3.1. Spring modules 1.3.2. The Spring portfolio 1.4. What’s new in Spring 1.4.1. What was new in Spring 3.1? 1.4.2. What was new in Spring 3.2? 1.4.3. What’s new in Spring 4.0? 1.5. Summary Chapter 2. Wiring beans 2.1. Exploring Spring’s configuration options 2.2. Automatically wiring beans 2.2.1. Creating discoverable beans 2.2.2. Naming a component-scanned bean 2.2.3. Setting a base package for component scanning 2.2.4. Annotating beans to be automatically wired 2.2.5. Verifying automatic configuration 2.3. Wiring beans with Java 2.3.1. Creating a configuration class 2.3.2. Declaring a simple bean 2.3.3. Injecting with JavaConfig 2.4. Wiring beans with XML 2.4.1. Creating an XML configuration specification 2.4.2. Declaring a simple <bean> 2.4.3. Initializing a bean with constructor injection 2.4.4. Setting properties 2.5. Importing and mixing configurations 2.5.1. Referencing XML configuration in JavaConfig 2.5.2. Referencing JavaConfig in XML configuration 2.6. Summary Chapter 3. Advanced wiring 3.1. Environments and profiles 3.1.1. Configuring profile beans 3.1.2. Activating profiles 3.2. Conditional beans 3.3. Addressing ambiguity in autowiring 3.3.1. Designating a primary bean 3.3.2. Qualifying autowired beans 3.4. Scoping beans 3.4.1. Working with request and session scope 3.4.2. Declaring scoped proxies in XML 3.5. Runtime value injection 3.5.1. Injecting external values 3.5.2. Wiring with the Spring Expression Language 3.6. Summary Chapter 4. Aspect-oriented Spring 4.1. What is aspect-oriented programming? 4.1.1. Defining AOP terminology 4.1.2. Spring’s AOP support 4.2. Selecting join points with pointcuts 4.2.1. Writing pointcuts 4.2.2. Selecting beans in pointcuts 4.3. Creating annotated aspects 4.3.1. Defining an aspect 4.3.2. Creating around advice 4.3.3. Handling parameters in advice 4.3.4. Annotating introductions 4.4. Declaring aspects in XML 4.4.1. Declaring before and after advice 4.4.2. Declaring around advice 4.4.3. Passing parameters to advice 4.4.4. Introducing new functionality with aspects 4.5. Injecting AspectJ aspects 4.6. Summary 2. Spring on the web Chapter 5. Building Spring web applications 5.1. Getting started with Spring MVC 5.1.1. Following the life of a request 5.1.2. Setting up Spring MVC 5.1.3. Introducing the Spittr application 5.2. Writing a simple controller 5.2.1. Testing the controller 5.2.2. Defining class-level request handling 5.2.3. Passing model data to the view 5.3. Accepting request input 5.3.1. Taking query parameters 5.3.2. Taking input via path parameters 5.4. Processing forms 5.4.1. Writing a form-handling controller 5.4.2. Validating forms 5.5. Summary Chapter 6. Rendering web views 6.1. Understanding view resolution 6.2. Creating JSP views 6.2.1. Configuring a JSP-ready view resolver 6.2.2. Using Spring’s JSP libraries 6.3. Defining a layout with Apache Tiles views 6.3.1. Configuring a Tiles view resolver 6.4. Working with Thymeleaf 6.4.1. Configuring a Thymeleaf view resolver 6.4.2. Defining Thymeleaf templates 6.5. Summary Chapter 7. Advanced Spring MVC 7.1. Alternate Spring MVC configuration 7.1.1. Customizing DispatcherServlet configuration 7.1.2. Adding additional servlets and filters 7.1.3. Declaring DispatcherServlet in web.xml 7.2. Processing multipart form data 7.2.1. Configuring a multipart resolver 7.2.2. Handling multipart requests 7.3. Handling exceptions 7.3.1. Mapping exceptions to HTTP status codes 7.3.2. Writing exception-handling methods 7.4. Advising controllers 7.5. Carrying data across redirect requests 7.5.1. Redirecting with URL templates 7.5.2. Working with flash attributes 7.6. Summary Chapter 8. Working with Spring Web Flow 8.1. Configuring Web Flow in Spring 8.1.1. Wiring a flow executor 8.1.2. Configuring a flow registry 8.1.3. Handling flow requests 8.2. The components of a flow 8.2.1. States 8.2.2. Transitions 8.2.3. Flow data 8.3. Putting it all together: the pizza flow 8.3.1. Defining the base flow 8.3.2. Collecting customer information 8.3.3. Building an order 8.3.4. Taking payment 8.4. Securing web flows 8.5. Summary Chapter 9. Securing web applications 9.1. Getting started with Spring Security 9.1.1. Understanding Spring Security modules 9.1.2. Filtering web requests 9.1.3. Writing a simple security configuration 9.2. Selecting user details services 9.2.1. Working with an in-memory user store 9.2.2. Authenticating against database tables 9.2.3. Applying LDAP-backed authentication 9.2.4. Configuring a custom user service 9.3. Intercepting requests 9.3.1. Securing with Spring Expressions 9.3.2. Enforcing channel security 9.3.3. Preventing cross-site request forgery 9.4. Authenticating users 9.4.1. Adding a custom login page 9.4.2. Enabling HTTP Basic authentication 9.4.3. Enabling remember-me functionality 9.4.4. Logging out 9.5. Securing the view 9.5.1. Using Spring Security’s JSP tag library 9.5.2. Working with Thymeleaf’s Spring Security dialect 9.6. Summary 3. Spring in the back end Chapter 10. Hitting the database with Spring and JDBC 10.1. Learning Spring’s data-access philosophy 10.1.1. Getting to know Spring’s data-access exception hierarchy 10.1.2. Templating data access 10.2. Configuring a data source 10.2.1. Using JNDI data sources 10.2.2. Using a pooled data source 10.2.3. Using JDBC driver-based data sources 10.2.4. Using an embedded data source 10.2.5. Using profiles to select a data source 10.3. Using JDBC with Spring 10.3.1. Tackling runaway JDBC code 10.3.2. Working with JDBC templates 10.4. Summary Chapter 11. Persisting data with object-relational mapping 11.1. Integrating Hibernate with Spring 11.1.1. Declaring a Hibernate session factory 11.1.2. Building Spring-free Hibernate 11.2. Spring and the Java Persistence API 11.2.1. Configuring an entity manager factory 11.2.2. Writing a JPA-based repository 11.3. Automatic JPA repositories with Spring Data 11.3.1. Defining query methods 11.3.2. Declaring custom queries 11.3.3. Mixing in custom functionality 11.4. Summary Chapter 12. Working with NoSQL databases 12.1. Persisting documents with MongoDB 12.1.1. Enabling MongoDB 12.1.2. Annotating model types for MongoDB persistence 12.1.3. Accessing MongoDB with MongoTemplate 12.1.4. Writing a MongoDB repository 12.2. Working with graph data in Neo4j 12.2.1. Configuring Spring Data Neo4j 12.2.2. Annotating graph entities 12.2.3. Working with Neo4jTemplate 12.2.4. Creating automatic Neo4j repositories 12.3. Working with key-value data in Redis 12.3.1. Connecting to Redis 12.3.2. Working with RedisTemplate 12.3.3. Setting key and value serializers 12.4. Summary Chapter 13. Caching data 13.1. Enabling cache support 13.1.1. Configuring a cache manager 13.2. Annotating methods for caching 13.2.1. Populating the cache 13.2.2. Removing cache entries 13.3. Declaring caching in XML 13.4. Summary Chapter 14. Securing methods 14.1. Securing methods with annotations 14.1.1. Restricting method access with @Secured 14.1.2. Using JSR-250’s @RolesAllowed with Spring Security 14.2. Using expressions for method-level security 14.2.1. Expressing method access rules 14.2.2. Filtering method inputs and outputs 14.3. Summary 4. Integrating Spring Chapter 15. Working with remote services 15.1. An overview of Spring remoting 15.2. Working with RMI 15.2.1. Exporting an RMI service 15.2.2. Wiring an RMI service 15.3. Exposing remote services with Hessian and Burlap 15.3.1. Exposing bean functionality with Hessian/Burlap 15.3.2. Accessing Hessian/Burlap services 15.4. Using Spring’s HttpInvoker 15.4.1. Exposing beans as HTTP services 15.4.2. Accessing services via HTTP 15.5. Publishing and consuming web services 15.5.1. Creating Spring-enabled JAX-WS endpoints 15.5.2. Proxying JAX-WS services on the client side 15.6. Summary Chapter 16. Creating REST APIs with Spring MVC 16.1. Getting REST 16.1.1. The fundamentals of REST 16.1.2. How Spring supports REST 16.2. Creating your first REST endpoint 16.2.1. Negotiating resource representation 16.2.2. Working with HTTP message converters 16.3. Serving more than resources 16.3.1. Communicating errors to the client 16.3.2. Setting headers in the response 16.4. Consuming REST resources 16.4.1. Exploring RestTemplate’s operations 16.4.2. GETting resources 16.4.3. Retrieving resources 16.4.4. Extracting response metadata 16.4.5. PUTting resources 16.4.6. DELETEing resources 16.4.7. POSTing resource data 16.4.8. Receiving object responses from POST requests 16.4.9. Receiving a resource location after a POST request 16.4.10. Exchanging resources 16.5. Summary Chapter 17. Messaging in Spring 17.1. A brief introduction to asynchronous messaging 17.1.1. Sending messages 17.1.2. Assessing the benefits of asynchronous messaging 17.2. Sending messages with JMS 17.2.1. Setting up a message broker in Spring 17.2.2. Using Spring’s JMS template 17.2.3. Creating message-driven POJOs 17.2.4. Using message-based RPC 17.3. Messaging with AMQP 17.3.1. A brief introduction to AMQP 17.3.2. Configuring Spring for AMQP messaging 17.3.3. Sending messages with RabbitTemplate 17.3.4. Receiving AMQP messages
一次服务启动慢问题排查
qq_64170174的博客
08-03 194
这不本人就遇到一个服务启动慢的问题，印象中服务启动是比较快的，一般也就20几秒，但这次开发一个需求发现服务启动要接近1分钟，这对本地开发调试，测试同学测试都是非常不方便的，影响工作效率。我们看如下的详细过程，发现确实如此。随着时间推移，参与开发的人员越来越多，项目代码也会越来越复杂，需要我们有意识的定期对代码进行优化，有问题及时解决，避免技术债务越积越多。3.在启动时做一些框架初始化，如使用数据库orm框架，通常需要加载数据库元信息，如果数据库表过多，加载时间长，可能导致服务启动慢。
分析Spring Boot项目启动慢原因之 《一》打印bean耗时
weixin_43934626的博客
07-03 943
【代码】分析Spring Boot项目启动慢原因之 《一》打印bean耗时。
SpringBoot 启动慢？那是因为你不知道它
m0_63437643的博客
08-10 667
工厂 Bean 顾名思义就是这个玩意也是一个 Bean 只是他的主要职责是作为工厂，通常用于生成特定类型的 Bean ，那么我们就有一个骚操作了，让这个工厂生产的 Bean 就是它自己，而且中间还能定义很多额外的逻辑，不多 BB 上代码。其实我们都比较清楚大部分的启动时间是由于 Spring 需要加载各种 Bean 导致启动速度下降的，那么对于那些不是特别重要的 Bean 我们是不是可以让他再起一个线程做 Bean 初始化，不阻塞主线程启动，这样启动速度不就起来了么，说干就干！
SpringBoot如何优化启动速度
最新发布
qq_46130027的博客
09-06 1639
spring-graalvm-native是springboot3非常重大的一个特性，支持使用GraalVM将SpringBoot的应用程序编译成本地可执行的镜像文件，可以显著提升启动速度、峰值性能以及减少内存使用。由于Java语言的特性及Spring Boot的一些实现方式，决定了即便是开启了G1/ZGC的去使用内存及时归还操作系统，Spring Boot的内存占用仍然远大于Golang这种编译型语言。到这启动速度应该算是优化的比较极致了，但是内存占用依然是问题。
Spring容器启动耗时分析 (Bean启动耗时)
刘献强的专栏
11-17 3502
1. 引入 Spring容器启动耗时过长, 主要原因是有些Bean做了复杂初始化的工作. 找到这些Bean, 再做针对性的优化, 才能把Spring容器启动耗时降下来. 如果开发对应用代码还不太熟悉, 本文提供了一种方式, 快速找出这些启动非常耗时的Bean. 2. 源码 LaunchTimeBeanPostProcessor.java (Bean启动时间抓取) import org.springframework.beans.BeansException; import org.springframe
Configuring_SMPP.rar_site:www.pudn.com
09-22
its the basic configuration file for smpp with description
8.3.3.5 Configuring Basic OSPFv3 in a Single Area
05-27
8.3.3.5 Packet Tracer - Configuring Basic OSPFv3 in a Single Area Cisco Packet Tracer 思科模拟器 正确答案文件 可直接上交正确答案文件 本答案版权归mewhaku所有，严禁再次转载！！！ Copyright @mewhaku ...
Packt.Learning.Spring5
09-14
Beginning with an introduction to Spring and setting up the environment, the book will teach you in detail about the Bean life cycle and help you discover the power of wiring for dependency injection....
Spring框架Ioc容器加载流程及Bean的生命周期源码分析
helloWorld
12-30 684
Spring源码分析-IoC容器
Spring IOC原理 Bean实例化、依赖注入和循环依赖解决
AllenChan_的博客
07-27 638
IOC Inverse Object Control 对象控制反转。Spring框架的最大特性，分离对象的维护控制工作，帮助工程师专注业务逻辑的实现。整个Spring体系甚至其它整合的框架都是基于IOC容器实现，因为都需要Spring管托Bean。 本章要叙述Bean加载过程，IOC的实现原理就是Bean的加载过程。会涉及到： 1.Bean的实例化 2.循环依赖的解决 3.依赖属性的注入 4.对Bean应用前置、后置处理器，Aware接口 5.衔接AOP的入口，对Bean应用动态代理......
spring getBean导致死锁问题
axe的专栏
07-03 3061
如果发生死锁，一般是这个方法导致，里面有个synchronized (this.singletonObjects) org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(String, boolean) /** * Return the (raw) singleton o...
SpringBoot项目启动卡死问题调查
dongdong199033的博客
03-11 3277
发现key1会走第12行和第21行，在21行会调用Lambda表达式等待结果，这时候key2会进来，发现key1已经占住了位置，会走36行的else里，而key2不满足39行和61行的if条件，循环中没有可以跳出的地方，就陷入了死循环。后来我就好奇，为什么就会卡死了呢，为什么不报错，看栈信息，最后应该是卡死在了ConcurrentHashMap的computeIfAbsent方法上，于是就去跟了下源码，找到了调用computeIfAbsent方法的地方，是ConcurrentMapCache的get方法。
Java中已投入系统变得异常缓慢_Java异常有多慢？
weixin_30737027的博客
02-28 166
这取决于异常是如何实现的。最简单的方法是使用setjmp和long jmp。这意味着CPU的所有寄存器都被写入堆栈(这已经花费了一段时间)，并且可能需要创建一些其他数据.所有这些都已经发生在try语句中。抛出语句需要展开堆栈并恢复所有寄存器(以及VM中可能的其他值)的值。所以，尝试和抛出是同样慢的，这是相当慢的，但是如果没有抛出异常，退出try块在大多数情况下都不需要任何时间(因为所有东西都放在堆...
Spring Boot 启动卡住了
热门推荐
09-18 1万+
Spring Boot 疑难问题，启动卡住，没有日志，很难排查
Spring中getBean失败解决办法
weixin_45230274的博客
03-18 3176
记录一个贼弱智的情境。 这几天刚学spring，在使用这段代码时，老报错。，获取不到这个bean。一开始以为是注解默认值的问题。后来发现是在测试类里面导入了userServiceImpl这个包，所以getBean不起作用了。所以删掉import com.yjy.spring5.service.UserServiceImpl;这段代码就可以了 当我解决完这个问题，终于看到了这玩意 舒服了… ...
tomcat启动报错：Error configuring application listener of class org.springframework.web.context.ContextLo...
05-16
这个错误通常是因为你的项目缺少 Spring Web 库导致的。请确保你的项目中包含了 Spring Web 库的依赖，例如在 Maven 项目中，需要在 pom.xml 文件中添加以下依赖： ``` <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>5.3.9</version> </dependency> ``` 如果你已经添加了 Spring Web 的依赖，但仍然出现该错误，请检查 Spring Web 库的版本是否与你的项目中其他 Spring 相关库的版本匹配。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值