spring (三) 应用：springIOC

约定不等于承诺〃 2022-12-10 08:47 118阅读 0赞

> springIOC （Inversion of Control ，IoC），是面向对象编程的一种设计原则，可以用来降低计算机代码之间的耦合度常见的方式： [依赖注入 （Dependency Injection , DI）                      依赖查找  (Dependency Lookup)][_Dependency Injection _ DI_ _ _ _ _ _ _ _ _ _ _ _ _Dependency Lookup]

**目录**

Spring实现ioc的思路

spring编程风格

依赖注入的两种方式

1、通过getter和setter方法进行注入

2、通过getter和setter方法进行注入

具体实例

1、xml + spring getter/setter   xml结合spring的getter和setter方法使用

2、xml + constructor  xml文件结合类的构造方法的使用

3、直接通过注解进行依赖注入：

4、演示通过p标签，c标签，context + 注解实现注入

自动装配 -- spring核心的核心

spring的作用域

（1）实现ApplicationContextAware，拿到spring上下文

(2)使用@Lookup注解

--------------------

## **Spring实现ioc的思路** ##

> spring实现IOC的思路是提供一些配置信息用来描述类之间的依赖关系，然后由容器去解析这些配置信息，继而维护好对象之间的依赖关系，前提是对象之间的依赖关系必须在类中定义好，比如A.class中有一个B.class的属性，那么我们可以理解为A依赖了B。既然我们在类中已经定义了他们之间的依赖关系那么为什么还需要在配置文件中去描述和定义呢？
> 
> spring实现IOC的思路大致可以拆分成3点 ：
> 
> （1）应用程序中提供类，提供依赖关系（属性或者构造方法）
> 
> （2）把需要交给容器管理的对象通过配置信息告诉容器（xml、annotation，javaconfig）
> 
> （3）把各个类之间的依赖关系通过配置信息告诉容器

--------------------

## spring编程风格 ##

> schemal-based-------xml
> 
> annotation-based-----annotation
> 
> java-based----java Configuration

## 依赖注入的两种方式 ##

> **[1、通过getter和setter方法进行注入][1_getter_setter]**
> 
> **[2、通过构造器进行注入][2]**

### 1、通过getter和setter方法进行注入 ###

![27d2bf88e6cb5694850ace236fb7837e.png][]

### 2、通过getter和setter方法进行注入 ###

![be97db3c1ae6127525fb2e0dd7629505.png][]

--------------------

## 具体实例 ##

以下为spring注入的几种风格代码，项目的整体目录结构如下图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70][]

### **1、xml + spring getter/setter   **xml结合spring的getter和setter方法使用 ###

spring.xml： 使用property申明属性

<?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
                             ">
    
        
        <bean id="indexDaoImpl" class="com.smiletimli.dao.IndexDaoImpl"></bean>
    
        <bean id="indexService" class="com.smiletimli.dao.IndexService">
            <property name="indexDaoImpl" ref="indexDaoImpl"></property>
        </bean>
    </beans>

类文件： 使用setter方法，实现service和dao的绑定

public interface IndexDao {
    
        public void test();
    }
    
    public class IndexDaoImpl implements IndexDao {
    
        public void test() {
            System.out.println("impl");
        }
    }
    
    public class IndexService {
    
        private IndexDao indexDao;
    
        public void service() {
            indexDao.test();
        }
    
        public void setIndexDaoImpl(IndexDaoImpl indexDaoImpl) {
            this.indexDao = indexDaoImpl;
        }
    
    }

### 2、xml + constructor  xml文件结合类的构造方法的使用 ###

spring.xml： 使用construct-arg 生成构造关系，同时演示字符串的注入方式，此处***可以联想到数据库的环境配置信息***

<?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
                             ">
        
        <bean id="constructDaoImpl" class="com.smiletimli.dao.ConstructDaoImpl">
            
            <property name="str" value="str"></property>
        </bean>
        <bean id="constructService" class="com.smiletimli.dao.ConstructService">
            <constructor-arg ref="constructDaoImpl"></constructor-arg>
        </bean>
    </beans>

类文件，通过构造方法进行注入

public interface ConstructDao {
    
        public void test();
    }
    public class ConstructDaoImpl implements ConstructDao {
    
        private String str = "";
    
        public String getStr() {
            return str;
        }
    
        public void setStr(String str) {
            this.str = str;
        }
    
        public void test() {
            System.out.println(str);
            System.out.println("construct");
        }
    }
    public class ConstructService {
    
        private ConstructDao dao;
    
        public ConstructService(ConstructDao constructDao) {
            this.dao = constructDao;
        }
    
        public void service() {
            dao.test();
        }
    
    }

以上两种，测试方法如下，

public static void main(String[] args) {
            // 通过resource目录下的xml维护spring环境的初始化的话，就是用ClassPathXmlApplicationContext进行加载
            ClassPathXmlApplicationContext classPathXmlApplicationContext =
                    new ClassPathXmlApplicationContext("classpath:spring.xml");
    
            // 通过set、get方法进行注入
            IndexService service = (IndexService) classPathXmlApplicationContext.getBean("indexService");
            service.service();
    
            // 通过构造方法进行注入
            ConstructService constructService = (ConstructService) classPathXmlApplicationContext.getBean("constructService");
            constructService.service();
        }

### 3、直接通过注解进行依赖注入： ###

项目结构如下图所示

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 1][]

首先通过添加configuration注解，声明为配置类，添加包路径扫描

@Configuration
    @ComponentScan("com.smiletimli.dao")
    //@ImportResource("classpath: spring.xml") // 如果三者同时存在，需要使用importResource进行引入
    public class Spring {
    }

public interface IndexDao {
    
        public void test();
    }
    @Component
    public class IndexDaoImpl implements IndexDao {
    
        public void test() {
            System.out.println("impl");
        }
    }
    @Service("indexService")
    public class IndexService {
    
        // 通过get、set方法进行注入
        @Autowired
        private IndexDao indexDao;
    
        public void service() {
            indexDao.test();
        }
    
        public void setIndexDaoImpl(IndexDaoImpl indexDaoImpl) {
            this.indexDao = indexDaoImpl;
        }
    
    }

此处使用AnnotationConfigApplicationContext 加载Spring.class类

public static void main(String[] args) {
            AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Spring.class);
            // 通过set、get方法进行注入
            IndexService service = (IndexService) annotationConfigApplicationContext.getBean("indexService");
            service.service();
        }

### 4、演示通过p标签，c标签，context + 注解实现注入 ###

（1）p标签

xml文件

p-property   c-contructor context - spring上下文，通过context实现开启注解，实现扫描

>     <?xml version="1.0" encoding="UTF-8"?>
>     <beans xmlns="http://www.springframework.org/schema/beans"
>            xmlns:p="http://www.springframework.org/schema/p"  
>            xmlns:c="http://www.springframework.org/schema/c"
>            xmlns:context="http://www.springframework.org/schema/context"
>            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
>                                http://www.springframework.org/schema/context
>                                http://www.springframework.org/schema/context/spring-context.xsd">
>     
>         
>         <context:component-scan base-package="com"></context:component-scan>
>         
>     
>         
>         <bean id="constructDaoImpl" class="com.smiletimli.dao.ConstructDaoImpl" p:str="str123">
>             
>         </bean>
>         <bean id="constructService" class="com.smiletimli.dao.ConstructService" c:constructDao-ref="constructDaoImpl">
>         </bean>
>     </beans>

类文件

public interface ConstructDao {
        public void test();
    }
    @Component
    public class ConstructDaoImpl implements ConstructDao {
        private String str = "";
        public String getStr() {
            return str;
        }
        public void setStr(String str) {
            this.str = str;
        }
        public void test() {
            System.out.println(str);
            System.out.println("construct");
        }
    }
    @Service("constructService")
    public class ConstructService {
        @Autowired
        private ConstructDao dao;
        public ConstructService(ConstructDao constructDao) {
            this.dao = constructDao;
        }
        public void service() {
            dao.test();
        }
    }

test类

public static void main(String[] args) {
            // 通过resource目录下的xml维护spring环境的初始化的话，就是用ClassPathXmlApplicationContext进行加载
            ClassPathXmlApplicationContext classPathXmlApplicationContext =
                    new ClassPathXmlApplicationContext("classpath:spring.xml");
    
            // 通过构造方法进行注入
            ConstructService constructService = (ConstructService) classPathXmlApplicationContext.getBean("constructService");
            constructService.service();
        }

--------------------

## 自动装配 -- spring核心的核心 ##

> 上面说过，IOC的注入有两个地方需要提供依赖关系，一是类的定义中，二是在spring的配置中需要去描述。
> 
> 自动装配则把第二个取消了，即我们仅仅需要在类中提供依赖，继而把对象交给容器管理即可完成注入。
> 
> 在实际开发中，描述类之间的依赖关系通常是大篇幅的，如果使用自动装配则省去了很多配置，并且如果对象的依赖发生更新我们可以不需要去更新配置，但是也带来了一定的缺点
> 
> 自动装配的优点参考文档：
> 
> [https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html\#beans-factory-autowire][https_docs.spring.io_spring-framework_docs_current_spring-framework-reference_core.html_beans-factory-autowire]
> 
> 缺点参考文档：
> 
> [https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html\#beans-autowired-exceptions][https_docs.spring.io_spring-framework_docs_current_spring-framework-reference_core.html_beans-autowired-exceptions]

自动装配的方法

> no
> 
> byName
> 
> byType
> 
> constructor
> 
> 自动装配的方式参考文档：
> 
> https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html\#beans-factory-autowire

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 2][]

区别：

@Autowire默认根据类型进行装配，如果类型找不到，就根据name进行查找

@Resource默认根据名称进行装配

根据名称查找的话，默认首字母小写，然后进行get和set属性名称进行查找

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 3][]

如果不想通过spring默认的名称进行查找，则重写BeanNameGenerator进行名称的重命名

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 4][]

--------------------

## [spring的作用域][spring] ##

![9fe77bc1d91eb62c66457a4822434216.png][]

spring相关的属性，默认是单例的，@Scope("singleton")

项目中如果想要每次拿到不同的对象实例可以采用以下方法

### （1）实现ApplicationContextAware，拿到spring上下文 ###

public interface IndexDao {
    
        public void test();
    }
    
    @Repository("dao")
    @Scope("prototype")
    public class IndexDaoImpl implements IndexDao {
    
        public void test() {
            System.out.println("impl");
        }
    }
    
    @Service("indexService")
    public class IndexService implements ApplicationContextAware {
    
        private ApplicationContext applicationContext;
    
        private IndexDao indexDao;
    
        public void service() {
            System.out.println(this.hashCode());
            System.out.println(applicationContext.getBean("dao").hashCode());
        }
    
        public void setIndexDaoImpl(IndexDaoImpl indexDaoImpl) {
            this.indexDao = indexDaoImpl;
        }
    
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
        }
    }

测试类

AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Spring.class);
            // 通过set、get方法进行注入
            IndexService service = (IndexService) annotationConfigApplicationContext.getBean("indexService");
            service.service();
            IndexService service1 = (IndexService) annotationConfigApplicationContext.getBean("indexService");
            service1.service();

1027007693  
1783047508  
1027007693  
2146608740

### (2)使用@Lookup注解 ###

\--- 单例(singleton)中引入多例（prototype）

@Service("indexService2")
    public abstract class IndexService2 {
    
        @Lookup("dao")
        public abstract IndexDao getDao();
    
        public void service() {
            System.out.println(this.hashCode());
            System.out.println("dao: " + getDao().hashCode());
        }
    }

> 726281927  
> dao: 1447499999  
> 726281927  
> dao: 1371006431

[_Dependency Injection _ DI_ _ _ _ _ _ _ _ _ _ _ _ _Dependency Lookup]: http://1
[1_getter_setter]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-setter-injection
[2]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-constructor-injection
[27d2bf88e6cb5694850ace236fb7837e.png]: /images/20221123/1438a0f88a60498fa816a7e64cc12598.png
[be97db3c1ae6127525fb2e0dd7629505.png]: /images/20221123/3f554545f39541fcbcd79e378b6d2d1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70]: /images/20221123/e567bd46404c4ffd9ea7af156b50718d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 1]: /images/20221123/e52c481f6435476b9852abf6617e7599.png
[https_docs.spring.io_spring-framework_docs_current_spring-framework-reference_core.html_beans-factory-autowire]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-autowire
[https_docs.spring.io_spring-framework_docs_current_spring-framework-reference_core.html_beans-autowired-exceptions]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-autowired-exceptions
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 2]: /images/20221123/0f6c8d7990b54873a51ffc8a8e11f21f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 3]: /images/20221123/cf5ac2f79c21492e80ad5828702c02d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 4]: /images/20221123/812bdd2b20e94e68bcaa6d360608ce76.png
[spring]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-scopes
[9fe77bc1d91eb62c66457a4822434216.png]: /images/20221123/8a517bebb8ca4835b75b96fa1946bea1.png