spring IOC 详解

最新推荐文章于 2025-09-12 18:08:49 发布
最新推荐文章于 2025-09-12 18:08:49 发布
阅读量95 收藏
点赞数
文章标签： java 数据库
本文深入探讨Spring框架中Bean的配置与管理，包括构造器注入、属性注入、构造方法注入、内部bean、null值赋值、集合属性赋值、自动装配、bean配置的继承、抽象bean以及bean之间的依赖关系等内容。

Hello World

wKioL1QDH7Ozya2jAAEfLCtXWVM593.jpg

HelloWorld.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package  com.test.spring01;
 
public  class  HelloWorld {
     private  String name;
 
     public  HelloWorld() {
         System.out.println( "调用构造函数..." );
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName2(String name) { //对应name="name2" 
         this .name = name;
     }
 
     public  void  sayHello() {
         System.out.println( "Hello,"  + name);
     }
 
}

 

Main.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package  com.test.spring01;
 
import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;
 
public  class  Main {
     public  static  void  main(String[] args) {
     //ClassPathXmlApplicationContext是ApplicationContext接口的实现类，实现从类路径下加载配置文件
         ApplicationContext applicationContext =  new  ClassPathXmlApplicationContext( "ApplicationContext.xml" );
         System.out.println( "创建对象" );
         HelloWorld helloWorld = (HelloWorld)applicationContext.getBean( "a1" );
         //HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
         //这种方式要求在配置文件中只配置了一个HelloWorld的bean
         helloWorld.sayHello();
     }
}

 

applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< beans  xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
                                  
     < bean  id = "a1"  class = "com.test.spring01.HelloWorld" >
         < property  name = "name2"  value = "spring" />
         <!--set方法注入-->
     </ bean >
</ beans >

 

运行结果

调用构造函数...

创建对象

Hello,spring

 

也可以通过构造方法注入

1
2
3
4
5
6
<!--通过构造方法来配置bean属性-->
< bean  id = "car"  class = "com.atguigu.spring.beans.Car" > <!--参数和构造函数的参数对应-->
     < constructor-arg  value = "Audi"  index = "0" ></ constructor-arg >
     < constructor-arg  value = "Shanghai"  index = "1" ></ constructor-arg >
     < constructor-arg  value = "300000"  type = "double" ></ constructor-arg >
</ bean >
1
2
3
4
5
6
<!--使用构造器注入属性值可以指定参数的位置和参数的类型，以区分重载的构造器-->
< bean  id = "car2"  class = "com.atguigu.spring.beans.Car" >
     < constructor-arg  value = "Baoma"  type = "java.lang.String" ></ constructor-arg >
     < constructor-arg  value = "Shanghai"  type = "java.lang.String" ></ constructor-arg >
     < constructor-arg  value = "400000"  type = "int" ></ constructor-arg >
</ bean >

 

 

有特殊标记时也可以下面这么写

1
2
3
4
5
6
7
8
9
< bean  id = "car2"  class = "com.atguigu.spring.beans.Car" >
     < constructor-arg  value = "Baoma"  type = "java.lang.String" ></ constructor-arg >
     < constructor-arg  type = "java.lang.String" >
         < value > <![CDATA[<Shanghai^>]]> </ value >
     </ constructor-arg >
     < constructor-arg  type = "int" >
         < value >400000</ value >
     </ constructor-arg >
</ bean >

 

 

引用类型

1
2
3
4
5
< bean  id = "person"  class = "com.atguigu.spring.beans.Person" >
     < property  name = "name"  value = "Tom" ></ property >
     < property  name = "age"  value = "34" ></ property >
     < property  name = "car"  ref = "car2" ></ property > <!--引用car2-->
</ bean >

 

 

内部bean，不能被外部引用，只能在内部使用

1
2
3
4
5
6
7
8
<!--内部bean-->
< property  name = "car" > <!--上面的car可以这么写-->
     < bean  class = "com.atguigu.spring.beans.Car" >
         < constructor-arg  value = "Ford" ></ constructor-arg >
         < constructor-arg  value = "Changan" ></ constructor-arg >
         < constructor-arg  value = "200000"  type = "double" ></ constructor-arg >
     </ bean >
</ property >

 

 

赋null值

1
2
<!--测试值赋null-->
< constructor-arg >< null /></ constructor-arg >

 

 

为级联属性赋值（必须有set方法） 要先创建car才能赋值

1
2
3
< constructor-arg  ref = "car" ></ constructor-arg >
<!--为级联属性赋值-->
< property  name = "car.macSpeed"  value = "240" ></ property >

 

 

为集合属性赋值（list set map）

1
2
3
4
5
6
7
8
9
10
< bean  id = "person3"  class = "com.atguigu.spring.collections.Person" >
     < property  name = "name"  value = "Tom" ></ property >
     < property  name = "age"  value = "34" ></ property >
     < property  name = "cars" > <!--cars是Person类的一个list类型的属性-->
         < list >
             < ref  bean = "car" >
             < ref  bean = "car2" >
         </ list >
     </ property >
</ bean >
1
2
3
4
5
6
7
8
9
10
11
<!--配置Map属性值-->
< bean  id = "person4"  class = "com.atguigu.spring.collections.Person" >
     < property  name = "name"  value = "Tom" ></ property >
     < property  name = "age"  value = "34" ></ property >
     < property  name = "cars" > <!--cars是Person类的一个map类型的属性-->
         < map >
             < entry  key = "AA"  value-ref = "car" ></ entry >
             < entry  key = "BB"  value-ref = "car2" ></ entry >
         </ map >
     </ property >
</ bean >
1
2
3
4
5
6
7
8
9
10
11
<!--配置Peoperties属性值-->
< bean  id = "dataSource"  class = "com.atguigu.spring.collections.dataSource" >
     < property  name = "peoperties" >
         < props >
             < prop  key = "user" >root</ prop >
             < prop  key = "password" >123456</ prop >
             < prop  key = "jdbcUrl" >jdbc:mysql:///test</ prop >
             < prop  key = "driverClass" >com.mysql.jdbc.Driver</ prop >
         </ props >
     </ property >
</ bean >
1
2
3
4
5
6
7
8
9
10
<!--配置单例的集合bean，以供多个bean进行引用，需要导入util命名空间-->
< util:list  id = "cars" >
     < ref  bean = "car" >
     < ref  bean = "car2" >
</ util:list >
< bean  id = "person4"  class = "com.atguigu.spring.collections.Person" >
     < property  name = "name"  value = "Jack" ></ property >
     < property  name = "age"  value = "29" ></ property >
     < property  name = "cars"  ref = "cars" ></ property > <!--引用上面配置的cars-->
</ bean >
1
2
3
<!--通过P命名空间为bean的属性赋值，需要先导入P命名空间-->
< bean  id = "person5"  class = "com.atguigu.spring.collections.Person"  p:age = "35"  p:name = "Shang"  p:cars-ref = "cars" >
</ bean >

 

 

自动装配（Person类中有address属性和car属性）

byName根据bean的名字和当前bean的setter风格的属性名进行自动装配。

byType根据bean的类型和当前bean的数学的类型进行自动装配。（如果有两个类型一样的bean就会出错）

缺点：在bean配置文件里设置autowire属性进行自动装配将会装配bean的所有属性。若只希望装配个别属性时，autowire属性就不够灵活了。autowire属性要么根据类型自动装配，要么根据名称自动装配，不能两者兼而有之。

一般情况下，在是寄到 项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力一些。

1
2
3
4
5
< bean  id = "address"  class = "com.atguigu.spring.beans.autowire.Address"  p:city = "Beijing"  p:street = "Huilongguan" ></ bean >
 
< bean  id = "car"  class = "com.atguigu.spring.beans.autowire.Car"  p:brand = "Audi"  p:price = "30000" ></ bean >
 
< bean  id = "person"  class = "com.atguigu.spring.beans.autowire.Person"  p:name = "Tom"  p:autowire = "byName" ></ bean >

 

bean配置的继承

1
2
3
4
< bean  id = "address"  class = "com.atguigu.spring.beans.autowire.Address"  p:city = "Beijing"  p:street = "Wudaokou" >
</ bean >
<!--bean配置的继承：使用bean的parent属性指定继承哪个bean的配置-->
< bean  id = "address2"  p:street = "Dazhongsi"  parent = "address" ></ bean >

 

 

抽象bean，只能被继承

1
2
3
4
<!--抽象bean：bean的abstract属性为true的bean，不能被IOC容器实例化
若一个bean的class属性没有指定，则该bean必须是一个抽象的bean。类似抽象类
-->
< bean  id = "address"  p:city = "Beijing"  p:street = "Wudaokou"  abstract = "true" ></ bean >

 

bean之间的依赖关系

Spring允许用户通过depends-on属性设定Bean前置依赖的Bean，前置依赖的Bean会在本Bean实例化之前创建好。如果前置依赖于多个Bean，则可以通过逗号、空格的方式配置多个Bean。

1
2
3
< bean  id = "car"  class = "com.atguigu.spring.autowire.Car"  p:brand = "Audi"  p:price = "30000" ></ bean >
<!--要求在配置person时，必须有一个关联的car。person这个bean依赖于car这个bean-->
< bean  id = "person"  class = "som.atguigu.spring.beans.autowire.Person"  p:name = "Tom"  p:address-ref = "address2"  depends-on = "car" ></ bean >

 

 

bean配置的作用域

默认为单例singleton，容器初始化时创建bean实例，在整个容器的生命周期里只创建一个bean。

prototype原型，容器初始化时不创建bean实例，在每次请求时创建一个新的bean实例并返回。

1
2
3
4
< bean  id = "car"  class = "com.atguigu.spring.autowire.Car"  scope = "prototype" >
     < property  name = "brand"  value = "Audi" ></ property >
     < property  name = "price"  value = "300000" ></ property >
</ bean >

 

 

引入外部配置文件

不引入配置文件时这么写.  beans-properties.xml

1
2
3
4
5
6
< bean  id = "dataSource"  class = "com.mchange.v2.c3p0.ComboPooledDataSource" >
     < property  name = "user"  value = "root" ></ property >
     < property  name = "password"  value = "123456" ></ property >
     < property  name = "driverClass"  value = "com.mysql.jdbc.Driver" ></ property >
     < property  name = "jdbcUrl"  value = "jdbc:mysql:///test" ></ property >
</ bean >
1
2
3
ApplicationContext ctx =  new  ClassPathXmlApplicationContext( "beans-properties.xml" );
DataSource dataSource = (DataSource)ctx.getBean( "dataSource" );
System.out.println(dataSource.getConnection()); //建立连接

引入外部配置文件

db.properties

1
2
3
4
user=root
password= 123456
driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql: ///test

beans-properties.xml写法

1
2
3
4
5
6
7
8
<!--导入属性文件--> <!--要导入context命名空间-->
< context:property-placeholder  location = "classpath:db.properties" />
< bean  id = "dataSource"  class = "com.mchange.v2.c3p0.ComboPooledDataSource" >
     < property  name = "user"  value = "${user}" ></ property >
     < property  name = "password"  value = "${password}" ></ property >
     < property  name = "driverClass"  value = "${driverClass}" ></ property >
     < property  name = "jdbcUrl"  value = "${jdbcUrl}" ></ property >
</ bean >

 

Spring表达式语言：SpEL。支持运行时查询和操作对象。

字面量的表示

整数 

1
< property  name = "count"  value = "#{5}" />

小数 

1
< property  name = "frequency"  value = "#{89.7}" />

科学计数法 

1
< property  name = "capacity"  value = "1e4" />

String可以使用单引号或者双引号作为字符串的定界符号

1
2
< property  name = "name"  value = "#{'chuck'}" />
< property  name = "name"  value = '#{"chuck"}' />

Boolean 

1
< property  name = "enabled"  value = "#{false}" />

引用其他对象，等同ref

1
2
<!--通过value属性和SpEL配置bean之间的引用关系-->
< property  name = "prefix"  value = "#{prefixGernerator}" />

引用其他对象的属性

1
< property  name = "suffix"  value = "#{prefixGernerator.suffix}" />

调用其他方法，还可以链式操作

1
< property  name = "suffix"  value = "#{prefixGernerator.toString()}" />
1
2
<!---方法的连缀-->
< property  name = "suffix"  value = "#{prefixGernerator.toString().toUpperCase()}" />
1
< property  name = "price"  value = "#{T(java.jang.Math).PI*80}" ></ property >
1
2
3
4
5
6
<!--使用SpEL表达式来引用其他的bean-->
< property  name = "car"  value = "#{car}" ></ property >
<!--使用SpEL表达式来引用其他的bean的属性-->
< property  name = "city"  value = "#{address.city}" ></ property >
<!--在SpEL中使用运算符-->
< property  name = "info"  value="#{car.price>300000?'金玲':'白领'}"></ property >

为bean指定init方法和destroy方法

1
2
3
4
5
< bean  id = "car"  class = "com.atguigu.spring.bean.Car"
init-method = "init"  destroy-method = "destroy" > <!--init和destroy对应Car类中的init destroy方法-->
     < property  name = "brand"  value = "Audi" ></ property >
</ bean >
<!--setBrand之后调用init方法，ctx.close();时调用destroy方法-->

Bean后置处理器允许在调用初始化方法前后对bean进行额外的处理。Bean后置处理器对IOC容器里的所有的Bean实例逐一处理，而非单一实例。其典型应用是：检查Bean属性的正确性或根据特定的标准更改Bean属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  class  MyBeanPostProcessor  implements  BeanPostProcessor{
     //处理所有bean
     @override
     public  Object postProcessBeforeInitialization(Object bean, Stirng beanName) throws  BeansException{
     //可以在这里进行一些操作
     if ( "car" .equals(beanName)){
     //...
     }
         System.out.println( "postProcessBeforeInitialization..." );
         return  bean;
     }
     
     
     @override
     public  Object postProcessAfterInitialization(Object bean, Stirng beanName) throws  BeansException{
         System.out.println( "postProcessAfterInitialization..." );
         //可以在这里对bean的属性进行更改...安全隐患
         return  bean;
     }
}
1
2
3
4
5
6
7
8
9
10
<!--配置文件中配置bean的后置处理器。不需要配置id，IOC容器自动识别是一个BeanPostProcessor-->
<!--
实现BeanPostProcessor接口，并且提供实现
Object postProcessBeforeInitialization(Object bean, Stirng beanName)  init-method之前调用
Object postProcessAfterInitialization(Object bean, Stirng beanName)  init-method之后调用
bean: bean实例本身
beanName：IOC容器配置的bwan的名字
返回值：实际上返回给用户的bean。可以在以上两个方法中修改返回的bean，甚至返回一个新的bean
-->
< bean  class = "com.atguigu.spring.MyBeanPostProcessor" ></ bean >

Spring IOC容器对Bean的生命周期进行管理的过程

-通过构造器或工厂方法创建Bean实例

-为bean的属性设置值和对其他bean的引用

-将bean实例传递给bean后置处理器的postProcessBeforeInitialization方法

-调用bean的初始化方法

-将bean实例传递给bean后置处理器的postProcessAfterInitialization方法

-bean可以使用了

-容器关闭时，调用bean的销毁方法

 

 

静态工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
*静态工厂方法：直接调用某一个类的静态方法就可以返回bean的实例
*/
public  class  StaticCarFactory{
     private  static  Map<String, car> cars =  new  HashMap<String, Car>();
     static {
         cars.put( "audi" ,  new  Car( "audi" ,  300000 ));
         cars.put( "ford" ,  new  Car( "ford" ,  400000 ));
     }
     //静态工厂方法
     public  static  Car getCar(String name){
         return  cars.get(name);
     }
}
1
2
3
4
5
6
7
8
9
10
11
<!--通过静态工厂方法来配置bean-->
<!--
     class属性：指向静态工程方法的全类名
     factory-method:静态工厂方法的名字
     constructor-arg:如果工厂方法需要传入参数，使用constructor-arg来配置参数
-->
< bean  id = "car1"
     class = "com.atguigu.spring.StaticCarFactory"
     factory-method = "getCar" >
     < constructor-arg  value = "audi" ></ constructor-arg >
</ bean >
1
Car car = (Car)ctx.getBean( "car1" ); //取对象

 

实例工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
*实例工厂方法，即先需要创建工厂，然后调用工厂的实例方法来返回bean的实例
*/
public  class  InstanceCarFactory{
     private  Map<String, car> cars =  null ;
     public  InstanceCarFactory(){
     cars =  new  HashMap<String, Car>();
         cars.put( "audi" ,  new  Car( "audi" ,  300000 ));
         cars.put( "ford" ,  new  Car( "ford" ,  400000 ));
     }
     
     public  Car getCar(String name){
         return  cars.get(name);
     }
}
1
2
3
4
5
6
7
8
9
10
< bean  id = "carFactory"  class = "com.atguigu.spring.InstanceCarFactory" ></ bean >
<!--通过实例工厂方法来配置bean-->
<!--
     factory-bean属性：指向实例工程方法的全类名
     factory-method:方法的名字
     constructor-arg:如果工厂方法需要传入参数，使用constructor-arg来配置参数
-->
< bean  id = "car2"  factory-bean = "carFactory"  factory-method = "getCar" >
     < constructor-arg  value = "audi" ></ constructor-arg >
</ bean >
1
Car car = (Car)ctx.getBean( "car2" ); //取对象

 

通过FactoryBean配置Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public  class  CarFactoryBean  implements  FactoryBean{
     private  String name;
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
         
         @Override
     public  Object getObject()  throws  Exception {
         return  new  Car(name,  "beijing" ); //调用构造函数
     }
         
         @Override
     public  Class getObjectType() {
         return  Car. class ;
     }
 
     @Override
     public  boolean  isSingleton() {
         return  true ;
     }
 
}
1
2
3
< bean  id = "car"  class = "com.test.spring04.CarFactoryBean" >
     < property  name = "name"  value = "BMW" ></ property >
</ bean >
1
2
Car car = (Car) applicationContext.getBean( "car" );
System.out.println(car);

 

在IOC容器中通过注解配置Bean

组件扫描（component scanning）：Spring可以从classpath下自动扫描、侦测和实例化具有特定注解的组件。

特定组件包括：

-@Component 基本注解，标识了一个受Spring管理的组件

-@Repository 标识持久层组件

-@Service 标识服务层（业务层）组件

-@Controller 标识表现层组件

对于扫描到的组件，Spring有默认的莫名策略：使用非限定类名，第一个字母小写，也可以在注解中通过value属性值标识组件的名称。

Spring IOC详解
JAVA_KX的博客
05-12 633
Spring 是目前主流的 Java 开发框架，是 Java 世界最为成功的框架。其目的是用于简化企业级应用程序开发的难度和周期，任何 Java 应用都可以从 Spring 中受益。Spring 框架还是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力。什么是框架？框架是一个半成品，提供了基本的运行功能，但具体业务实现需要我们去编写。
Spring IoC 详解：原理、实现与实战
ljw714的专栏
06-05 1268
本文系统介绍了Spring IoC的核心概念与实现机制。首先解释了IoC（控制反转）和DI（依赖注入）的关系，梳理了Bean、容器、作用域等核心概念。详细分析了XML、注解和Java Config三种配置方式，深入解读了IoC容器的工作原理和Bean生命周期。文章还提供了常见应用场景、源码机制简析、最佳实践和常见问题解答，强调IoC在系统解耦、配置管理等方面的优势。通过掌握这些内容，开发者能更有效地构建灵活、健壮的Spring应用。
Spring学习（4）
sinat_33582628的博客
05-02 156
关于Spring中Bean的装配方式中基于xml的装配方式部分的内容我们就已经讲述完了，现在我们将要讲述的是在Bean装配中的另外一种装配方式:基于注解的装配方式，以下同样是给予例子进行阐述 使用@Service注解将UserServiceImpl标识为Spring中的Bean类，相当于<bean id="userService" class="com.itheima.annoat...
spring4学习日记——第五天
克己的博客
01-12 303
今天主要学习了JDBC的配置，连接，还有传说中神圣的CRUD，也就是增删改查。在不断的实例中，慢慢的对AOP有点理解了，最主要的是了解每个注解是干嘛的，怎么应用，了解之后上手比较快。 其次是在bean中配置AOP，代码如下 "result"/>
自己写的Spring4教程，给Java学习者参考！
Java客学习室
11-15 1658
Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。
Spring4.x学习笔记 ——Spring概念、IOC概念及基本使用方法
Sirm23333
04-21 9249
一、Spring框架相关概念 开源的轻量级框架 Spring框架主要涉及两部分 AOP：面向切面编程（对代码扩展的优化） IOC：控制反转（对象创建方式的改变） Spring为一站式框架，提供javaee三层中的技术支持 web层（展现层）：springMVC servive层（业务逻辑层）：spring的IOC dao层（数据访问层）：spring的jdbcTemplate 二、...
Spring4学习笔记----Spring的依赖注入详解
沙漏
07-27 2407
Spring是一个IOC和AOP容器，Spring是非侵入型的，基于Spring开发的web应用中的对象可以不依赖Spring的API. IOC:依赖注入 （让Spring Bean以配置文件的形式组织在一起） 所谓依赖注入：在程序运行过程中，如需要另外一个对象协作（调用他的属性、方法），无需在代码中创建该被调对象，而是依赖外部容器的注入。 一、Spring容器 （1） Spring容器
Spring IoC详解
这河里吗l的博客
06-14 1097
Spring 是一款开源的轻量级 Java 开发框架，旨在提高开发人员的开发效率以及系统的可维护性。我们一般说 Spring 框架指的都是，它是很多模块的集合，使用这些模块可以很方便地协助我们进行开发，比如说 Spring 支持IoC（Inversion of Control:控制反转） 和AOP。
Spring IOC详解：从原理到实战
BUG糕手的博客
06-20 1390
Spring框架的核心IOC（控制反转）机制通过容器管理对象生命周期和依赖关系，实现组件解耦。
Spring IOC 详解
SunStaday的博客
01-09 401
Spring IOCIOC什么是IOCIOC容器介绍BeanFactory和ApplicationContext的区别Spring容器管理对象Spring依赖（pom.xml）Spring的配置文件Bean类的实例化方式（demo）创建实例类基于xml配置文件实现Bean基于无参构造函数实例化静态工厂方式实例化基于普通工厂方法实例化基于注解的方式装配Beanspring配置文件引入context约束实例类上添加注解 IOC 什么是IOC Ioc—Inversion of Control，即“控制反转”，不是
Spring Ioc详解
qq_33697759的博客
09-14 1366
属性上：@Qualifier 和 @Autowired结合使用可以通过唯一Bean的id实现自动装配，因为单独的@Autowired注解实现自动装配是按照类型优先原则的，一旦IOC容器中出现了两个类型一样的Bean，@Autowired注解就会无法辨别用那个，即而报错，但是当我们加上 @Qualifier(value = "Bean的id") 的时候就可以直接通过Bean的唯一标识（id）进行装配了。在参数上时通@Qualifier注解指定Bean的唯一标识，让参数的指定的Bean绑定起来；
Spring IOC 详解：基于 XML 配置与注解的依赖注入
03-22
Spring IOC 详解：基于 XML 配置与注解的依赖注入
SpringIOC 详解
09-17
SpringIOC Spring 框架是一个流行J2EE的开源产品，它提供了统一的应用架构方式、大量的中间层功能模块，大大简化了传统J2EE的开发模式。它的核心代码均来自于真实的项目，是由Spring 之父Rod Johnson 从商业项目开发...
性能测试工具JvisualVM/jconsole使用
最新发布
平时的经验总结，学习历程
09-12 235
port是jmx的另一个通信端口。可以不设置，启动后系统会自动随机指定端口。如果关闭了防火墙，没有网络访问策略，可以不设置。如果服务器需要开通端口访问策略此处需要配置开通策略的端口。然后在windows客户机，安装jdk目录下的bin目录下找到jvisualvm.exe或jconsole，通过远程连接方式监控jvm的cpu 内存 线程 类加载的情况。com.sun.management.jmxremote.port 是客户端连接的端口。主要介绍远程使用方式，在启动参数添加如下参数。
还在重启应用改 Topic？Spring Boot 动态 Kafka 消费的“终极形态”
郑龙飞
09-10 744
/ 用于存储 @KafkaListener 的“蓝图”// ... 可按需添加 concurrency, autoStartup 等其他属性(元数据采集与注册)@Component@OverrideClass<?= null &&!通过巧妙地结合和动态配置中心，我们实现了一个功能极其强大的动态 Kafka 消费管理方案。
【lucene】bitsetiterator
risc123456的博客
09-09 543
某些自定义 `FieldCache` 或 `DocValues` 去重逻辑，会先把出现过的 docID 记到 `BitSet`，再用 `BitSetIterator` 一次性吐出。`BitSet` 本身只有 `get()/set()/nextSetBit(int)`，没有标准的迭代器语义，于是就有了 `BitSetIterator` 做适配。- `cost()` 直接返回 `cardinality()`，方便上层 `ConjunctionDISI/DisjunctionDISI` 做排序、选 lead。
计算机毕设 java 高校饭堂点餐系统 基于微信小程序 + SSM 的高校餐饮服务平台 Java+MySQL 的点餐与运营系统
毕设源码伍学长
09-10 1035
在高校饭堂就餐需求增长的背景下，传统点餐依赖窗口排队、效率低，存在高峰期拥堵、菜品信息不透明等问题，难以满足师生便捷就餐需求。采用 Java 技术、SSM 框架、Uni-weixin 技术及 MySQL 数据库，开发高校饭堂点餐系统（微信小程序端 + 服务端），整合菜品展示、在线点餐、订单跟踪等功能，支持管理员、商家、用户三类角色协同，打造专业化餐饮服务平台。该系统既能帮助管理员监管平台内容，商家高效管理菜品与订单，又能让用户便捷查询菜品、完成点餐，提升高校饭堂服务效率与用户体验。
Spring Cloud Gateway：构建智能API网关的终极指南
xinzhiyishi的博客
09-12 570
摘要： Spring Cloud Gateway是微服务架构中的核心API网关，基于Spring 5、WebFlux和Reactor构建，提供异步非阻塞高性能路由。其核心通过路由（Route）、**断言（Predicate）和过滤器（Filter）**实现灵活请求匹配与处理，支持动态路由、负载均衡（如lb://service集成Eureka）、路径重写（RewritePath）、限流（RequestRateLimiter）等功能。相较于Zuul 1.x，它利用Netty实现高并发，内置丰富断言（Path、M
Spring Ioc详解：李兴华教你依赖注入
"MLDN 李兴华 Spring IOC 教程，PDF 格式，涵盖了 Spring 框架中的核心概念——IOC（控制反转），通过具体的代码示例解释了如何使用配置文件来管理 Bean。" 在 Spring 框架中，IOC（Inversion of Control，控制反转...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值