Spring（一）

原教程： https://www.w3cschool.cn/wkspring/

springMVC:

模型(Model)封装了应用程序数据，通常它们将由POJO类组成。
视图(View)负责渲染模型数据，一般来说它生成客户端浏览器可以解释HTML输出。
控制器(Controller)负责处理用户请求并构建适当的模型，并将其传递给视图进行渲染.

java project中也可以用spring：

创建Javabean.java
创建MainApp.java

1 // 创建应用程序的上下文
2 ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
3 // 获取bean对象，注意参数是bean的id
4 HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
5 // 调用bean对象的方法
6 obj.getMessage();

View Code

创建beans.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 
 3 <beans xmlns="http://www.springframework.org/schema/beans"
 4      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5      xsi:schemaLocation="http://www.springframework.org/schema/beans
 6     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 7  
 8     <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
 9        <property name="message" value="Hello World!"/>
10    </bean>
11  
12 </beans>

View Code

Spring IoC容器

被称作 bean 的对象是构成应用程序的支柱，也是由 Spring IoC 容器管理的。
bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。
这些 bean 是由用容器提供的配置元数据创建的

两种不同类型的容器：

BeanFactory容器

// 加载beans.xml文件，创建并初始化所有对象
XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("Beans.xml"));

ApplicationContext容器(优先使用)

包含BeanFactory所有功能
ApplicationContext接口实现

FileSystemXmlApplicationContext
ClassPathXmlApplicationContext
WebXmlApplicationContext

Spring xml文件配置元数据

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 
 3 <beans 
 4     默认命名空间，没有空间名，用于spring bean的定义
 5     xmlns="http://www.springframework.org/schema/beans"
 6     xsi标准命名空间，用于为每个文档中的命名空间指定相应的Schema样式文件
 7     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 8     xsi:schemaLocation="http://www.springframework.org/schema/beans
 9     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
10 
11    <bean id="..." class="...">
12        <!-- collaborators and configuration for this bean go here -->
13    </bean>
14 
15    <bean id="..." class="..." lazy-init="true">
16        <!-- collaborators and configuration for this bean go here -->
17    </bean>
18 
19    <bean id="..." class="..." init-method="...">
20        <!-- collaborators and configuration for this bean go here -->
21    </bean>
22 
23    <bean id="..." class="..." destroy-method="...">
24        <!-- collaborators and configuration for this bean go here -->
25    </bean>
26 
27 </beans>

View Code

spring bean的作用域

singleton
prototype
request
session
global-session

spring bean的生命周期

Bean的定义——Bean的初始化——Bean的使用——Bean的销毁

bean的初始化和销毁回调

方法1

Spring Bean类实现InitializingBean，DisposableBean接口
分别实现接口中的afterPropertiesSet(), destroy()
beans.xml文件中为bean标签指定init-method及destroy-method(方法名任意)

方法2
- 配置beans.xml文件为bean标签指定init-method及destroy-method
- 在spring bean中实现bean标签中指定的init及destroy方法
方法3（默认的初始化和销毁方法）
- 在beans大标签中指定default-init-method及default-destroy-method属性
- 所有的bean都将有相同的初始化和销毁方法

spring bean后置处理器

作用：调用初始化方法前后对 Bean 进行额外的处理

在beans.xml中指定init方法并在spring bean中实现init方法
在beans.xml文件中注册额外处理的类的bean
编写额外处理的类InitHelloWorld ，实现BeanPostProcessor接口，及接口中的方法

 1 // HelloWorld.java (Spring Bean)
 2 package com.tutorialspoint;
 3 public class HelloWorld {
 4    private String message;
 5    public void setMessage(String message){
 6       this.message  = message;
 7    }
 8    public void getMessage(){
 9       System.out.println("Your Message : " + message);
10    }
11    public void init(){
12       System.out.println("Bean is going through init.");
13    }
14    public void destroy(){
15       System.out.println("Bean will destroy now.");
16    }
17 }
18 
19 // InitHelloWorld.java 初始化方法前后执行的逻辑
20 package com.tutorialspoint;
21 import org.springframework.beans.factory.config.BeanPostProcessor;
22 import org.springframework.beans.BeansException;
23 public class InitHelloWorld implements BeanPostProcessor {
24    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
25       System.out.println("BeforeInitialization : " + beanName);
26       return bean;  // you can return any other object as well
27    }
28    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
29       System.out.println("AfterInitialization : " + beanName);
30       return bean;  // you can return any other object as well
31    }
32 }
33 
34 // beans.xml
35 <?xml version="1.0" encoding="UTF-8"?>
36 
37 <beans xmlns="http://www.springframework.org/schema/beans"
38     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
39     xsi:schemaLocation="http://www.springframework.org/schema/beans
40     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
41 
42    <bean id="helloWorld" class="com.tutorialspoint.HelloWorld"
43        init-method="init" destroy-method="destroy">
44        <property name="message" value="Hello World!"/>
45    </bean>
46 
47    <bean class="com.tutorialspoint.InitHelloWorld" />
48 
49 </beans>

View Code

spring bean中的继承

子bean将继承所有父bean的属性
子bean也可重新赋值父bean属性
子bean未赋值的继承自父bean的属性值将和父bean值一样
实现方式
- 在beans.xml中为子bean指定parent属性，其值为父bean的id
应用：（bean模板）
- 模板bean不指定class属性，而将abstract属性设置为true
- 子bean在继承模板bean后，将会有模板中的所有属性
- 模板bean不能被实例化

spring依赖注入

注入前的代码：

1 public class TextEditor {
2    private SpellChecker spellChecker;  
3    public TextEditor() {
4       spellChecker = new SpellChecker();
5    }
6 }

控制反转后（依赖注入后）：

1 public class TextEditor {
2    private SpellChecker spellChecker;
3    public TextEditor(SpellChecker spellChecker) {
4       this.spellChecker = spellChecker;
5    }
6 }

实质是将被注入对象（SpellChecker）在注入之前实现，在实例化TextEditor时，将SpellChecker作为一个工具提供给TextEditor。

这个过程spring框架来控制。bean对象间的依赖关系委托到spring框架中。直白说new对象不放在TextEditor中了，而是交给spring框架了。

两种注入方式：

Constructor-based DI
Setter-based DI

spring基于构造函数的依赖注入

（SpellChecker-->TextEditor表示“前者”作为参数传给“后者”，“前者”是“后者”的一个属性）
编写spring bean类（TextEditor，SpellChecker）
在beans.xml中注册bean（其中“后者”中要配置<constructor-arg>）

多参构造函数的beans.xml文件配置
- 参数为对象，则<constructor-arg>使用ref属性
- 参数为int，string等，则
  - 法1：<constructor-arg>使用type及value属性（type指定类型，int或string，value指定参数值）
  - 法2：<constructor-arg>使用index及value属性（index指定参数的顺序，value指定参数值）

spring基于set函数的依赖注入

对象属性用set函数来赋值
在“后者”的bean中（TextEditor）使用<property name="" ref=""/>其中ref引用的是对象属性在beans.xml中定义的bean的id。int或string类型参数将ref换为value属性。

 1 // TextEditor.java
 2 package com.tutorialspoint;
 3 public class TextEditor {
 4    private SpellChecker spellChecker;
 5    
 6    public void setSpellChecker(SpellChecker spellChecker) {
 7       System.out.println("Inside setSpellChecker." );
 8       this.spellChecker = spellChecker;
 9    }
10   
11    public SpellChecker getSpellChecker() {
12       return spellChecker;
13    }
14    public void spellCheck() {
15       spellChecker.checkSpelling();
16    }
17 }
18 
19 // SpellChecker.java
20 package com.tutorialspoint;
21 public class SpellChecker {
22    public SpellChecker(){
23       System.out.println("Inside SpellChecker constructor." );
24    }
25    public void checkSpelling() {
26       System.out.println("Inside checkSpelling." );
27    }  
28 }
29 
30 // MainApp.java
31 package com.tutorialspoint;
32 import org.springframework.context.ApplicationContext;
33 import org.springframework.context.support.ClassPathXmlApplicationContext;
34 public class MainApp {
35    public static void main(String[] args) {
36       ApplicationContext context = 
37              new ClassPathXmlApplicationContext("Beans.xml");
38       TextEditor te = (TextEditor) context.getBean("textEditor");
39       te.spellCheck();
40    }
41 }
42 
43 // beans.xml
44 <?xml version="1.0" encoding="UTF-8"?>
45 
46 <beans xmlns="http://www.springframework.org/schema/beans"
47     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
48     xsi:schemaLocation="http://www.springframework.org/schema/beans
49     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
50 
51    <bean id="textEditor" class="com.tutorialspoint.TextEditor">
52       <property name="spellChecker" ref="spellChecker"/>
53    </bean>
54 
55    <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
56    </bean>
57 
58 </beans>

使用p-namespace实现xml设置

用于set函数

 1 // 使用p-namespace前的beans.xml
 2 <?xml version="1.0" encoding="UTF-8"?>
 3 
 4 <beans xmlns="http://www.springframework.org/schema/beans"
 5     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6     xsi:schemaLocation="http://www.springframework.org/schema/beans
 7     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 8 
 9    <bean id="john-classic" class="com.example.Person">
10       <property name="name" value="John Doe"/>
11       <property name="spouse" ref="jane"/>
12    </bean>
13 
14    <bean name="jane" class="com.example.Person">
15       <property name="name" value="John Doe"/>
16    </bean>
17 
18 </beans>
19 
20 // 使用p-namespace后的beans.xml
21 <?xml version="1.0" encoding="UTF-8"?>
22 
23 <beans xmlns="http://www.springframework.org/schema/beans"
24     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
25     xmlns:p="http://www.springframework.org/schema/p"
26     xsi:schemaLocation="http://www.springframework.org/schema/beans
27     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
28 
29    <bean id="john-classic" class="com.example.Person"
30       p:name="John Doe"
31       p:spouse-ref="jane"/>
32    </bean>
33 
34    <bean name="jane" class="com.example.Person"
35       p:name="John Doe"/>
36    </bean>
37 
38 </beans>

spring注入内部beans

1 // set方法注入
2 <bean id="outerBean" class="...">
3       <property name="target">
4          <bean id="innerBean" class="..."/>
5       </property>
6 </bean>

spring注入集合

“后者”的属性是集合形式。唯一不同是beans.xml中<property>的设置

<lsit>	值可重复
<set>	值不可重复
<map>	key-value对，key与value类型任意
<props>	key-value对，key与value类型必须为字符串

 1 // JavaCollection.java (spring bean)
 2 package com.tutorialspoint;
 3 import java.util.*;
 4 public class JavaCollection {
 5    List addressList;
 6    Set  addressSet;
 7    Map  addressMap;
 8    Properties addressProp;
 9    
10    // 属性的get和set方法
11   ······    
12 }
13 
14 // beans.xml
15 <bean id="javaCollection" class="com.tutorialspoint.JavaCollection">
16 
17       <property name="addressList">
18          <list>
19             <value>INDIA</value>
20             <value>Pakistan</value>
21             <value>USA</value>
22             <value>USA</value>
23          </list>
24       </property>
25 
26       <property name="addressSet">
27          <set>
28             <value>INDIA</value>
29             <value>Pakistan</value>
30             <value>USA</value>
31             <value>USA</value>
32         </set>
33       </property>
34 
35       <property name="addressMap">
36          <map>
37             <entry key="1" value="INDIA"/>
38             <entry key="2" value="Pakistan"/>
39             <entry key="3" value="USA"/>
40             <entry key="4" value="USA"/>
41          </map>
42       </property>
43 
44       <property name="addressProp">
45          <props>
46             <prop key="one">INDIA</prop>
47             <prop key="two">Pakistan</prop>
48             <prop key="three">USA</prop>
49             <prop key="four">USA</prop>
50          </props>
51       </property>
52 
53 </bean>

注入bean引用

 1 <bean id="..." class="...">
 2 
 3       <!-- Passing bean reference  for java.util.List -->
 4       <property name="addressList">
 5          <list>
 6             <ref bean="address1"/>
 7             <ref bean="address2"/>
 8             <value>Pakistan</value>
 9          </list>
10       </property>
11 
12       <!-- Passing bean reference  for java.util.Set -->
13       <property name="addressSet">
14          <set>
15             <ref bean="address1"/>
16             <ref bean="address2"/>
17             <value>Pakistan</value>
18          </set>
19       </property>
20 
21       <!-- Passing bean reference  for java.util.Map -->
22       <property name="addressMap">
23          <map>
24             <entry key="one" value="INDIA"/>
25             <entry key ="two" value-ref="address1"/>
26             <entry key ="three" value-ref="address2"/>
27          </map>
28       </property>
29 
30    </bean>

注入null和空字符串的值

1 // 注入空字符串 等价于exampleBean.setEmail("")
2 <bean id="..." class="exampleBean">
3    <property name="email" value=""/>
4 </bean>
5 
6 // 注入null 等价于exampleBean.setEmail(null)
7 <bean id="..." class="exampleBean">
8    <property name="email"><null/></property>
9 </bean>

spring beans的自动装配

依赖注入有两种方式1. 构造函数 2. set函数。这两种方式都需要在beans.xml中配置<constructor-arg><property>标签。

自动装配的意思是不需要这两个标签，由spring框架完成bean之间关系的协作。

自动装配模式由<bean>的autowire指定

byName	必须有对象属性的set方法，若发现对象属性则自动装配，否则报错。其他属性由<property>指定
byType	必须有对象属性的set方法，有就自动装配，否则报错其他属性由<property>指定
constructor	对象属性不用在<bean>中配置，构造函数中其他的参数需要用<constructor-arg>来配置
autodetect	首先尝试constructor，若不执行则使用byType

byName与byType中正因为有除了对象属性的其他属性，才会用<property>标签，正因为有此标签，才一定要有set方法。

没有除了对象属性的其他属性，可以没有set方法，因此也没有<property>。

因此byName与byType是用于set方法的自动装配，constructor是构造方法的自动装配

另外：在beans.xml中配置bean时若没有为任何属性赋值，则容器会调用该bean的无参构造函数，虽然指定了byName或者byType

也就是说在<bean>中指定的<constructor-arg>的个数，决定了容器会调用哪个构造函数。

spring基于注解的配置

1. @Required

被此注解修饰的set方法的属性，必须在<bean>中被指定，否则 BeanInitializationException 异常

 1 package com.tutorialspoint;
 2 import org.springframework.beans.factory.annotation.Required;
 3 public class Student {
 4    private Integer age;
 5    private String name;
 6    @Required
 7    public void setAge(Integer age) {
 8       this.age = age;
 9    }
10    public Integer getAge() {
11       return age;
12    }
13    @Required
14    public void setName(String name) {
15       this.name = name;
16    }
17    public String getName() {
18       return name;
19    }
20 }
// 属性age与name必须在<bean>中被指定

2. @Autowired

　　autowired就是自动装配的意思

1 // 不用使用<constructor-arg><property>来为参数赋值 2.1 2.2 2.3配置都是如此
2 <bean id="textEditor" class="com.tutorialspoint.TextEditor">
3 </bean>
4 
5 <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
6 </bean>

　　2.1 修饰set方法

　　　　自动装配set方法中的对象属性（采用byType自动连接）

　　　　消除<property>元素

 1 package com.tutorialspoint;
 2 import org.springframework.beans.factory.annotation.Autowired;
 3 public class TextEditor {
 4    private SpellChecker spellChecker;
 5    @Autowired
 6    public void setSpellChecker( SpellChecker spellChecker ){
 7       this.spellChecker = spellChecker;
 8    }
 9    public SpellChecker getSpellChecker( ) {
10       return spellChecker;
11    }
12    public void spellCheck() {
13       spellChecker.checkSpelling();
14    }
15 }

　　2.2 修饰属性

　　　　消除set方法

 1 package com.tutorialspoint;
 2 import org.springframework.beans.factory.annotation.Autowired;
 3 public class TextEditor {
 4    @Autowired
 5    private SpellChecker spellChecker;
 6    public TextEditor() {
 7       System.out.println("Inside TextEditor constructor." );
 8    }  
 9    public SpellChecker getSpellChecker( ){
10       return spellChecker;
11    }  
12    public void spellCheck(){
13       spellChecker.checkSpelling();
14    }
15 }

　　2.3修饰构造函数

　　消除<constructor-arg>元素

 1 package com.tutorialspoint;
 2 import org.springframework.beans.factory.annotation.Autowired;
 3 public class TextEditor {
 4    private SpellChecker spellChecker;
 5    @Autowired
 6    public TextEditor(SpellChecker spellChecker){
 7       System.out.println("Inside TextEditor constructor." );
 8       this.spellChecker = spellChecker;
 9    }
10    public void spellCheck(){
11       spellChecker.checkSpelling();
12    }
13 }

　　2.4@Autowired的(required=false)选项

　　　　修饰set方法　　

　　　　和@Required有相同效果，被@Autowired修饰的set方法中的对象属性，必须在<bean>元素中赋值。

　　　　默认是@Autowired(required=true)

 1 package com.tutorialspoint;
 2 import org.springframework.beans.factory.annotation.Autowired;
 3 public class Student {
 4    private Integer age;
 5    private String name;
 6    @Autowired(required=false)
 7    public void setAge(Integer age) {
 8       this.age = age;
 9    }  
10    public Integer getAge() {
11       return age;
12    }
13    @Autowired
14    public void setName(String name) {
15       this.name = name;
16    }   
17    public String getName() {
18       return name;
19    }
20 }

3. @Qualifier

　　通常@Qualifier与@Autowired一起使用。

　　主要用于beans.xml中有多个相同类型的bean，而只需要其中一个bean来装配。

 1 package com.tutorialspoint;
 2 import org.springframework.beans.factory.annotation.Autowired;
 3 import org.springframework.beans.factory.annotation.Qualifier;
 4 public class Profile {
 5    @Autowired
 6    @Qualifier("student1")
 7    private Student student;
 8    public Profile(){
 9       System.out.println("Inside Profile constructor." );
10    }
11    public void printAge() {
12       System.out.println("Age : " + student.getAge() );
13    }
14    public void printName() {
15       System.out.println("Name : " + student.getName() );
16    }
17 }

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for profile bean -->
   <bean id="profile" class="com.tutorialspoint.Profile">
   </bean>

   <!-- Definition for student1 bean -->
   <bean id="student1" class="com.tutorialspoint.Student">
      <property name="name"  value="Zara" />
      <property name="age"  value="11"/>
   </bean>

   <!-- Definition for student2 bean -->
   <bean id="student2" class="com.tutorialspoint.Student">
      <property name="name"  value="Nuha" />
      <property name="age"  value="2"/>
   </bean>

</beans>

spring JSR-250注释

1. @Postconstruct和@PreDestroy

 1 package com.tutorialspoint;
 2 
 3 import javax.annotation.PostConstruct;
 4 import javax.annotation.PreDestroy;
 5 
 6 public class TextEditor {
 7     
 8     SpellChecker s;
 9 
10     public TextEditor(SpellChecker spellChecker) {
11         System.out.println("TextEditor的1参构造函数");
12         this.s = spellChecker;
13     }
14 
15     public void spellCheck() {
16         s.checkSpelling();
17     }
18     
19     @PostConstruct
20     public void init() {
21         System.out.println("textEditor bean init()");
22     }
23     
24     @PreDestroy
25     public void destroy() {
26         System.out.println("textEditor bean destroy()");
27     }
28     
29 }

1 // beans.xml
2 // 没有指定<bean>的init-method和destroy-method属性
3 <context:annotation-config/>
4 <bean id="textEditor" class="com.tutorialspoint.TextEditor" autowire="byName">
5     <constructor-arg ref="spellChecker"></constructor-arg>
6 </bean>
7 <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean>

2. @Resource

　　可修饰属性和set方法

　　修饰属性：

// TextEditor.java
package com.tutorialspoint;

import javax.annotation.Resource;

public class TextEditor {
    
    @Resource(name="spellChecker")
    SpellChecker s;

    public TextEditor(SpellChecker spellChecker) {
        System.out.println("TextEditor的1参构造函数");
        this.s = spellChecker;
    }

    public void spellCheck() {
        s.checkSpelling();
    }

}


// beans.xml
<context:annotation-config></context:annotation-config>
    
<bean id="textEditor" class="com.tutorialspoint.TextEditor"></bean>
<bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean>

　　修饰set方法

 1 // TextEditor.java
 2 package com.tutorialspoint;
 3 import javax.annotation.Resource;
 4 public class TextEditor {
 5     
 6     SpellChecker s;
 7 
 8     public TextEditor(SpellChecker spellChecker) {
 9         System.out.println("TextEditor的1参构造函数");
10         this.s = spellChecker;
11     }
12     
13     public SpellChecker getS() {
14         return s;
15     }
16     
17     @Resource(name="spellChecker")
18     public void setS(SpellChecker s) {
19         this.s = s;
20     }
21 
22     public void spellCheck() {
23         s.checkSpelling();
24     }
25     
26 }
27 
28 // beans.xml
29 <context:annotation-config></context:annotation-config>
30     
31 <bean id="textEditor" class="com.tutorialspoint.TextEditor"></bean>
32 <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean>

　　注意：@Resource不可修饰构造函数

spring基于Java的配置

1. @Configuration和@Bean

　　@Configuration注解类表示定义bean的来源

　　@bean注解的方法将返回一个对象，不管是利用构造方法还是其他方法，一定要返回一个对象。类似于beans.xml中的<bean>元素

　　不需要beans.xml文件

 1 // HelloWorldConfig.java
 2 package com.tutorialspoint;
 3 
 4 import org.springframework.context.annotation.Bean;
 5 import org.springframework.context.annotation.Configuration;
 6 
 7 @Configuration
 8 public class HelloWorldConfig {
 9     @Bean
10     public HelloWorld helloWorld() {
11         return new HelloWorld();
12     }
13 }
14 
15 // HelloWorld.java
16 package com.tutorialspoint;
17 
18 public class HelloWorld {
19     String message;
20 
21     public String getMessage() {
22         System.out.println("Your Message:"+message);
23         return message;
24     }
25 
26     public void setMessage(String message) {
27         this.message = message;
28     }
29     
30 }
31 
32 // MainApp.java
33 public class MainApp {
34     public static void main(String[] args) {
35         ApplicationContext context = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
36         HelloWorld helloWorld = context.getBean(HelloWorld.class);
37         helloWorld.setMessage("Hello World!");
38         helloWorld.getMessage();
39     }
40 }

注入bean的依赖性

1. 第一种方法：利用构造函数

 1 // Foo.java
 2 package com.tutorialspoint;
 3 
 4 public class Foo {
 5     Bar bar;
 6     
 7     public Foo(Bar bar) {
 8         System.out.println("Foo 1参构造函数");
 9         this.bar = bar;
10     }
11 }
12 
13 // Bar.java
14 package com.tutorialspoint;
15 
16 public class Bar {
17     public Bar() {
18         System.out.println("Bar无参构造函数");
19     }
20 }
21 
22 // AppConfig.java
23 package com.tutorialspoint;
24 
25 import org.springframework.context.annotation.Bean;
26 import org.springframework.context.annotation.Configuration;
27 
28 @Configuration
29 public class AppConfig {
30     @Bean
31     public Foo foo() {
32         return new Foo(new Bar());
33     }
34     
35     @Bean
36     public Bar bar() {
37         return new Bar();
38     }
39 }
40 
41 // MainApp.java
42 package com.tutorialspoint;
43 
44 import org.springframework.context.ApplicationContext;
45 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
46 
47 public class MainApp {
48     public static void main(String[] args) {
49         ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
50         Foo foo = ctx.getBean(Foo.class);
51     }
52 }

2. 其他方法

 1 // Foo.java
 2 package com.tutorialspoint;
 3 
 4 public class Foo {
 5     Bar bar;
 6     
 7     public Foo() {
 8         System.out.println("Foo无参构造函数");
 9     }
10 
11     public Bar getBar() {
12         return bar;
13     }
14 
15     public void setBar(Bar bar) {
16         this.bar = bar;
17     }
18     
19 }
20 
21 // Bar.java
22 package com.tutorialspoint;
23 
24 public class Bar {
25     public Bar() {
26         System.out.println("Bar无参构造函数");
27     }
28 }
29 
30 // AppConfig.java
31 package com.tutorialspoint;
32 
33 import org.springframework.context.annotation.Bean;
34 import org.springframework.context.annotation.Configuration;
35 
36 @Configuration
37 public class AppConfig {
38     @Bean
39     public Foo method() {
40         Foo foo = new Foo();
41         foo.setBar(bar());// method注入
42         return foo;
43     }
44     
45     @Bean
46     public Bar bar() {
47         return new Bar();
48     }
49 }
50 
51 // MainApp.java
52 package com.tutorialspoint;
53 
54 import org.springframework.context.ApplicationContext;
55 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
56 
57 public class MainApp {
58     public static void main(String[] args) {
59         ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
60         Foo foo = ctx.getBean(Foo.class);
61     }
62 }

2. @Import

从另一个配置类中加载@Bean定义

// A.javapublic class A {
    public A() {
        System.out.println("A无参constructor");
    }
    
    public void methodOfA() {
        System.out.println("A中的方法");
    }
}

// B.javapublic class B {
    A a;
    
    public B(A a) {
        System.out.println("B 1参构造函数");
        this.a = a;
    }
    
    public void method() {
        a.methodOfA();
    }
}

// ConfigA.java
@Configuration
public class ConfigA {
    @Bean
    public A a() {
        return new A();
    }
}

// ConfigB.java
@Configuration
@Import(ConfigA.class)
public class ConfigB {
    @Bean
    B b() {
        return new B(new A());
    }
}

// MainApp.javapublic class MainApp {
    public static void main(String[] args) {
        // 当实例化上下文时，不需要同时指定 ConfigA.class 和 ConfigB.class，只有 ConfigB 类需要提供
        ApplicationContext context = new AnnotationConfigApplicationContext(ConfigB.class);
        A a = context.getBean(A.class);
        B b = context.getBean(B.class);
　　　　 a.methodOfA();
        b.method();
    }
}

3. bean的生命周期

@Bean(initMethod = "init", destroyMethod = "cleanup" )

 1 // A.java
 2 public class A {
 3     public A() {
 4         System.out.println("A无参constructor");
 5     }
 6     
 7     public void init() {
 8         System.out.println("A init()");
 9     }
10     
11     public void cleanup() {
12         System.out.println("A cleanup()");
13     }
14     
15     public void methodOfA() {
16         System.out.println("A中的方法");
17     }
18 }
19 
20 // ConfigA.java
21 @Configuration
22 public class ConfigA {
23     @Bean(initMethod="init", destroyMethod="cleanup")
24     public A a() {
25         return new A();
26     }
27 }
28 
29 // MainApp.java
30 public class MainApp {
31     public static void main(String[] args) {
32         AbstractApplicationContext context = new AnnotationConfigApplicationContext(ConfigA.class);
33         A a = context.getBean(A.class);
34         a.methodOfA();
35         context.registerShutdownHook();
36     }
37 }

相关阅读:
'Neither SQLALCHEMY_DATABASE_URI nor SQLALCHEMY_BINDS is set.
flask os.environ 的作用
 flask 中xx.init_app(app)方法
 win10安装ubuntu双系统遇到的问题
 福大软工 · 最终作业
 福大软工 · 第十二次作业
 Beta 冲刺（7/7）
Beta 冲刺（6/7）
常用正则
 使用elementUI动态增减表单项且使用自定义校验
原文地址：https://www.cnblogs.com/yfs123456/p/10666804.html