spring_ioc

1.spring介绍

​ spring首先它是一个开放的源代码框架，主要解决的就是业务逻辑层和其他层松耦合问题，所以它的编程思想是面向接口。简单来说，Spring是一个分层的JavaSE/EE
full-stack(一站式)轻量级开源框架

1.1spring特点

1. 方便解耦，简化开发

   ​ Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2. AOP编程的支持

   ​ 通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

3. 声明式事务的支持

   ​ 在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

4. 方便程序的测试

   ​ 可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如:Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5. 方便集成各种优秀框架

   ​ Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持。

6. 降低Java EEAPI的使用难度

1.2spring组织架构]

1. Data Access/Intergration

   ​ ORM:即Object-Relationl Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了 。

   ​ OXM:Object xml mappin。将Java对象转换为xml文档。您需要将一个 XML 文档转换为一个简单 Java bean，Spring 的 O/X Mapper 也能胜任。

   ​ JDBC:连接数据库。

   ​ JMS: - Java消息服务（Java Message Service ，JMS）

   ​ Transactions:在实际开发中，对于一组数据库操作特别是增删改操作，为了保证原子性，通过需要用事务来控制，要么全部成功，要么全部失败。Spring中可以通过注解@Transaction

2. Web

   ​ WebSocket :protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。Socket是传输控制层协议，WebSocket是应用层协议。

   servlet:

   web:

   portlet

3. Coro Container

   ​ beans:模块是所有应用都要用到的，它包含访问配置文件，创建和管理bean以及进行控制反转、依赖注入操作相关的所有类。

   ​ Core:模块主要包含Spring框架基本的核心工具类，Spring的其他组件都需要使用这个包里的类。

   ​ Context:模块构建于Core和Beans基础之上，提供了一种类似JNDI注册器的框架式的对象访问方法，Context继承了Beans的特性，为Spring核心提供了大量扩展，追加了对国际化、事件传播、资源加载和对Context的透明创建支持。模块提供了一个强大的表达式语言用于在运行时查询和操作对象。

4. test

   1.3spring下载

   ​ Spring官网:http://spring.io

   ​ Spring资源地址:http://repo.spring.io/release/org/springframework/spring

   1.4spring的核心模块

​ spring-core：依赖注入IOC与DI的最基本实现

• spring-beans：Bean工厂与bean的装配

• spring-context：spring的context上下文即IoC容器

  spring-context-support- spring-expression：spring表达式语言

2.spring中的IOC

​ IOC是 Inverse of Control 的简写，意思是控制反转。是降低对象之间的耦合关系 的设计思想。

​ DI是Dependency Injection的缩写，意思是依赖注入,说的是创建对象实例时，同时为这个对象注入它所依赖的属性。

2.1. 实现过程

1. 步骤1:添加jar包

<!-- Spring的核心工具包-->      
  <dependency>       
     <groupId>org.springframework</groupId>      
           <artifactId>spring-core</artifactId>        
               <version>5.0.8.RELEASE</version>     
             </dependency><!--在基础IOC功能上提供扩展服务，还提供许多企业级服务的支持，有邮件服务、任务调度、远程访问、缓存以及多种视图层框架的支持-->        
             <dependency>          
                    <groupId>org.springframework</groupId> 
                    <artifactId>spring-context</artifactId> 
                    <version>5.0.8.RELEASE</version>   
               </dependency> 
                         <!-- Spring IOC的基础实现，包含访问配置文件、创建和管理bean等 -->        
              <dependency>   
                      <groupId>org.springframework</groupId>              
                       <artifactId>spring-beans</artifactId>       
                       <version>5.0.8.RELEASE</version>
              </dependency> 
                     <!-- Spring context的扩展支持，用于MVC方面 --> 
                <dependency>
                            <groupId>org.springframework</groupId>
                            <artifactId>spring-context-support</artifactId>  
                             <version>5.0.8.RELEASE</version>  
                </dependency>
                               <!-- Spring表达式语言 --> 
                  <dependency>  
                             <groupId>org.springframework</groupId>            
                             <artifactId>spring-expression</artifactId>            
                             <version>5.0.8.RELEASE</version>
                </dependency>
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
28
29

​ 2.步骤2:创建配置文件applicationContext.xml

<?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.xsd"></beans>
1
2
3
4

​ 3.步骤3:在配置文件中创建对象

<bean id="对象名" class="类的完整路径">  
    <property name="属性名" ref="对象的id值">
    </property>
 </bean>
1
2
3
4

​ 4.步骤4:加载配置文件，获得对象

ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml"); Users users=
(Users)app.getBean("u1");
1
2

2.2 bean标签的属性介绍

2.3 对象创建的方式

(1)无参构造

(2)有参构造

public  Person(String  name , Car car){     
    this.name = name;     
    this.car = car;      
    System.out.println("Person的有参构造方法:"+name+car);
}
1
2
3
4
5

<bean name="person" class="com.xzk.spring.bean.Person">  
         <constructor-arg name="name" value="rose"/> 
                   <constructor-arg name="car"  ref="car"/> 
         </bean>
1
2
3
4

(3)静态方法创建对象

//静态工厂模式

public class PersonFactory { 
    public static Person  createPerson(){  
         System.out.println("静态工厂创建Person");    
           return  new Person(); 
        }
}
1
2
3
4
5
6

<bean name="pf" class="com.xzk.PersonFactory" factory-method="createPerson" />
1

(4)非静态工厂方法

public class Users{ 
	public  Person createPerson1(){  
    	System.out.println("非静态工厂创建Person"); 
        return new Person();  
        }
    }
1
2
3
4
5
6

<bean id="u2"  class="com.bean.Users"></bean>
<bean id="u3" factory-method="createPerson1" factory-bean="u2"></bean>
1
2

2.4 springBean的生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PkDHOnya-1600961645434)(C:\Users\hu\AppData\Roaming\Typora\typora-user-images\1600916008854.png)]

​ Bean 生命周期的整个执行过程描述如下

1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。

2）利用依赖注入完成 Bean 中所有属性值的配置注入。

3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 			setBeanName() 方法传入当前Bean 的 id 值。

4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 			   setBeanFactory() 方法传入当前工厂实例的引用。

5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。

6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP  就是利用它实现的。

7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。初始化bean的时候执行，可以针对某个具体的bean进行配置。afterPropertiesSet 必须实现 InitializingBean接口。实现 InitializingBean接口必须实现afterPropertiesSet方法。

8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。 

9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。

10）如果在中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入  Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在中指定了该 Bean  的作用范围为scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该Bean。 

11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方 法将 Spring 中的  Bean销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.DI注入值

一种是调取属性的set方法赋值，第二种使用构造方法赋值

3.1 set注入值

3.1.1 基本属性类型值注入

 <property name="name" value="jeck" />
1

3.1.2 引用属性类型值注入(引入对象)

 <property name="car" ref="car"></property>
1

3.2 构造注入:

3.2.1 可以通过name属性，按照参数名赋值

​

public  Person(String  name , Car car){     
    this.name = name;    
    this.car = car;       
    System.out.println("Person的有参构造方法:"+name+car); 
}   


<bean name="person" class="com.xzk.spring.bean.Person">
          	<constructor-arg name="name" value="rose"/>  
          		     <constructor-arg name="car"  ref="car"/> 
</bean>
1
2
3
4
5
6
7
8
9
10
11

3.2.2 可以通过index属性，按照参数索引注入

   <bean name="person2" class="com.xzk.spring.bean.Person"> 
          <constructor-arg name="name" value="helen" index="0"></constructor-arg>     
       <constructor-arg name="car" ref="car" index="1">
       </constructor-arg>
</bean>
1
2
3
4
5

3.2.3 使用type注入

 public Person(Car car, String name) {  
     super();    
     System.out.println("Person(Car car, String name)");  
      this.name = name;      
     this.car = car; 
 }    
public Person(Car car, Integer name) {   
    super();    
    System.out.println("Person(Car car, Integer name)");  
          this.name = name + "";    
    this.car = car;  
}
1
2
3
4
5
6
7
8
9
10
11
12

<bean name="person2" class="com.xzk.spring.bean.Person">  
   <constructor-arg name="name" value="988" type="java.lang.Integer"></constructor-arg>     <constructor-arg name="car" ref="car" ></constructor-arg>
     </bean>
1
2
3

3.3 spel spring表达式

bean name="car"  class="com.xzk.spring.bean.Car" >  
   <property name="name" value="mime" />      
   <property name="color" value="白色"/>  
</bean>   
<!--利用spel引入car的属性 -->  
<bean  name="person1"  class="com.xzk.spring.bean.Person"  p:car-ref="car">            
    <property name="name" value="#{car.name}"/>  
                <property name="age" value="#{person.age}"/> 
</bean
1
2
3
4
5
6
7
8
9

使用p:属性名完成注入,走set方法

-基本类型值: p:属性名=“值”

-引用类型值: P:属性名-ref=“bean名称”

实现步骤:配置文件中添加命名空间p

xmlns:p="http://www.springframework.org/schema/p"
1

实例：

<bean id="u6" class="com.entity.Users" p:age="30" p:name="李四" p:student-ref="stu1"></bean>
1

3.5 复杂类型注入

 Object[],list,set,map,java.util.Properties

<!-- 数组变量注入 -->         
<property name="arrs">           
    <list>                   
        <value>数组1</value>               
        <!--引入其他类型-->             
        <ref bean="car"/>           
    </list>       
</property>       
<!-- 集合变量赋值-->      
<property name="list">   
    <list>              
        <value>集合1</value>       
        <!--集合变量内部包含集合-->      
        <list>                  
            <value>集合中的集合1</value>   
            <value>集合中的集合2</value>   
            <value>集合中的集合3</value>      
        </list>                
        <ref bean="car" />     
    </list>       
</property>     
<!--map赋值 -->     
<property name="map">      
    <map>               
        <entry key="car" value-ref="car" /> 
        <entry key="name" value="保时捷" />    
        <entry key="age"  value="11"/>  
    </map>     
</property>       
<!-- properties赋值 -->    
<property name="properties">   
    <props>                
        <prop key="name">pro1</prop> 
        <prop key="age">111</prop> 
    </props>        
</property>
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
28
29
30
31
32
33
34
35
36
37
38

3.6 自动注入(由程序自动给属性赋值)

​ autowire：

​ no 不自动装配(默认值)

​ byName 属性名=id名，调取set方法赋值

	 byType  属性的类型和id对象的类型相同，当找到多个同类型的对象时报错，调	取set方法赋值        
1

​ constructor 构造方法的参数类型和id对象的类型相同,当没有找到时，报错。调取构造方法赋值

示例:

<bean id="service" class="service.impl.UserServiceImpl" autowire="constructor"></bean>
1

配置全局自动装配

<beans   default-autowire="constructor/byName/byType/no">
1

4.注解实现IOC

​ （1）配置文件中添加约束

​ 参考文件位置:

​ spring-framework-5.0.8.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
1
2
3

​ (2)配置注解扫描:指定扫描包下所有类中的注解,扫描包时,会扫描包所有的子孙包

<!--扫描包设置--><context:component-scan base-package="com.xzk.spring.bean"></context:component-scan>
1

3)注解

3.1 添加在类名上

@Component(“对象名”)

@Service(“person”) // service层

@Controller(“person”) // controller层

@Repository(“person”)// dao层

@Scope(scopeName=“singleton”) //单例对象

@Scope(scopeName=“prototype”) //多例对象

3.2 添加在属性上

@Value(“属性值”)

private String name;

@Autowired //如果一个接口类型，同时有两个实现类，则报错，此时可以借助@Qualifier(“beanname”)

@Qualifier(“bean name”)

private Car car;

//说明:@Resource 是java的注释,但是Spring框架支持,@Resource指定注入哪个名称的对象//@Resource(name=“对象名”) == @Autowired + @Qualifier(“name”)@Resource(name=“baoma”)

private Car car;

3.3 添加在方法上

@PostConstruct    //等价于init-method属性 
public  void init(){  
	 System.out.println("初始化方法");
} 
@PreDestroy  //等价于destroy-method属性
 public void destroy(){  
	  System.out.println("销毁方法");
 }
1
2
3
4
5
6
7
8