Spring项目IOC/DI注解开发

素颜马尾好姑娘i 2024-04-01 09:35 122阅读 0赞

Spring的IOC/DI对应的配置开发使用起来相对来说还是比较复杂的，复杂的地方在配置文件。  
前面Spring的时候说过，Spring可以简化代码的开发，到现在并没有体会到。  
所以Spring到底是如何简化代码开发的呢?  
要想真正简化开发，就需要用到Spring的注解开发，Spring对注解支持的版本历程:

*  2.0版开始支持注解
 *  2.5版注解功能趋于完善
 *  3.0版支持纯注解开发

关于注解开发，我们会讲解两块内容`注解开发定义bean`和`纯注解开发`。  
注解开发定义bean用的是2.5版提供的注解，纯注解开发用的是3.0版提供的注解。

## 1. 环境准备 ##

注解开发之前，先来准备下案例环境:

*  创建一个Maven项目
 *  pom.xml添加Spring的依赖
    
        <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>5.2.15.RELEASE</version>
                </dependency>
            </dependencies>
 *  resources下添加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">
        
            <bean id="userDao" class="com.dcxuexi.dao.impl.UserDaoImpl" />
        
        </beans>
 *  添加UserDao、UserDaoImpl、UserService、UserServiceImpl类
    
        public interface UserDao {
              
            public void select();
        }
        public class UserDaoImpl implements UserDao {
              
            public void select() {
              
                System.out.println("UserDao select , running ......");
            }
        }
        public interface UserService {
              
            public void select();
        }
        public class UserServiceImpl implements UserService {
              
            public void select() {
              
                System.out.println("UserService select, running ......");
        
            }
        }
 *  创建运行类SpringAnnotation
    
        public class SpringAnnotation {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
                UserDao userDao = context.getBean("userDao", UserDao.class);
                userDao.select();
            }
        }

最终创建好的项目结构如下:  
![在这里插入图片描述][d9f1884749c447a69dc0f5f3d233c552.png_pic_center]

## 2. 注解开发定义bean ##

在上述环境的基础上，我们来学一学Spring是如何通过注解实现bean的定义开发?

### 步骤1:删除原XML配置 ###

将配置文件中的`<bean>`标签删除掉

### 步骤2:Dao上添加注解 ###

在UserDaoImpl类上添加`@Component`注解

@Component("userDao")
    public class UserDaoImpl implements UserDao {
        
        public void select() {
        
            System.out.println("UserDao select , running ......");
        }
    }

注意:@Component注解不可以添加在接口上，因为接口是无法创建对象的。  
XML与注解配置的对应关系:  
![在这里插入图片描述][cbc12494a76c4a2792c99a17d5ddd759.png_pic_center]

### 步骤3:配置Spring的注解包扫描 ###

为了让Spring框架能够扫描到写在类上的注解，需要在配置文件上进行包扫描

<?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.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    
        <context:component-scan base-package="com.dcxuexi" />
    
    </beans>

**说明:**  
component-scan

*  component:组件,Spring将管理的bean视作自己的一个组件
 *  scan:扫描

base-package指定Spring框架扫描的包路径，它会扫描指定包及其子包中的所有类上的注解。

*  包路径越多\[如:com.dcxuexi.dao.impl\]，扫描的范围越小速度越快
 *  包路径越少\[如:com.dcxuexi\],扫描的范围越大速度越慢
 *  一般扫描到项目的组织名称即Maven的groupId下\[如:com.dcxuexi\]即可。

### 步骤4：运行程序 ###

运行`SpringAnnotation`类查看打印结果  
![在这里插入图片描述][b333c61779dc45b99f656a8a32a98073.png_pic_center]

### 步骤5:Service上添加注解 ###

在UserServiceImpl类上也添加`@Component`交给Spring框架管理

@Component("userService")
    public class UserServiceImpl implements UserService {
        
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        public void select() {
        
            System.out.println("UserService select, running ......");
            userDao.select();
        }
    }

### 步骤6:运行程序 ###

在SpringAnnotation类中，从IOC容器中获取UserServiceImpl对应的bean对象，打印

public class SpringAnnotation {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDao = context.getBean("userDao", UserDao.class);
            //userDao.select();
            System.out.println(userDao);
    
            //按类型获取bean
            UserService userService = context.getBean(UserService.class);
            //userService.select();
            System.out.println(userService);
    
        }
    }

打印观察结果，两个bean对象都已经打印到控制台  
![在这里插入图片描述][6f51eb13ff4642ef899f8d8d0b674332.png_pic_center]  
**说明:**

*  UserServiceImpl类没有起名称，所以在App中是按照类型来获取bean对象
 *  @Component注解如果不起名称，会有一个默认值就是`当前类名首字母小写`，所以也可以按照名称获取，如
    
        UserService userService = (UserService) context.getBean("userServiceImpl");
        System.out.println(userService);

对于@Component注解，还衍生出了其他三个注解`@Controller`、`@Service`、`@Repository`  
通过查看源码会发现:  
![在这里插入图片描述][aa4addad418c4254b0fc4a19c244ad85.png_pic_center]  
这三个注解和@Component注解的作用是一样的，为什么要衍生出这三个呢?  
方便我们后期在编写类的时候能很好的区分出这个类是属于`表现层`、`业务层`还是`数据层`的类。

### 知识点1:@Component等 ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Component/@Controller/@Service/@Repository</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该类为spring管理的bean</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean的id</td> 
  </tr> 
 </tbody> 
</table>

## 3. 纯注解开发模式 ##

上面已经可以使用注解来配置bean,但是依然有用到配置文件，在配置文件中对包进行了扫描，Spring在3.0版已经支持纯注解开发

*  Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

具体如何实现?

### 3.1 思路分析 ###

实现思路为:

*  将配置文件applicationContext.xml删除掉，使用类来替换。

### 3.2 实现步骤 ###

#### 步骤1:创建配置类 ####

创建一个配置类`SpringConfig`

public class SpringConfig {
        
    }

#### 步骤2:标识该类为配置类 ####

在配置类上添加`@Configuration`注解，将其标识为一个配置类,替换`applicationContext.xml`

@Configuration
    public class SpringConfig {
        
    }

#### 步骤3:用注解替换包扫描配置 ####

在配置类上添加包扫描注解`@ComponentScan`替换`<context:component-scan base-package=""/>`

@Configuration
    @ComponentScan("com.dcxuexi")
    public class SpringConfig {
        
    }

#### 步骤4:创建运行类并执行 ####

创建一个新的运行类`SpringConfigAnnotation`

public class SpringConfigAnnotation {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
            UserDao userDao = context.getBean(UserDao.class);
            System.out.println(userDao);
            UserService userService = context.getBean(UserService.class);
            System.out.println(userService);
        }
    }

运行SpringConfigAnnotation,可以看到两个对象依然被获取成功  
![在这里插入图片描述][574346014ed0401fb90b5163992f0fea.png_pic_center]  
至此，纯注解开发的方式就已经完成了，主要内容包括:

*  Java类替换Spring核心配置文件  
    ![在这里插入图片描述][550792f46c4741d3b29387afbc2c4223.png_pic_center]
 *  @Configuration注解用于设定当前类为配置类
 *  @ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式
    
        @ComponentScan({
              "com.dcxuexi.dao","com.dcxuexi.service"})
 *  读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
    
        //加载配置文件初始化容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //加载配置类初始化容器
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

#### 知识点1：@Configuration ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Configuration</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该类为spring配置类</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean的id</td> 
  </tr> 
 </tbody> 
</table>

#### 知识点2：@ComponentScan ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@ComponentScan</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置spring配置类扫描路径，用于加载使用注解格式定义的bean</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：扫描路径，此路径可以逐层向下扫描</td> 
  </tr> 
 </tbody> 
</table>

**小结:**  
这一节重点掌握的是使用注解完成Spring的bean管理，需要掌握的内容为:

*  记住@Component、@Controller、@Service、@Repository这四个注解
 *  applicationContext.xml中`<context:component-san/>`的作用是指定扫描包路径，注解为@ComponentScan
 *  @Configuration标识该类为配置类，使用类替换applicationContext.xml文件
 *  ClassPathXmlApplicationContext是加载XML配置文件
 *  AnnotationConfigApplicationContext是加载配置类

## 4. 注解开发bean作用范围与生命周期管理 ##

使用注解已经完成了bean的管理，接下来按照前面所学习的内容，将通过配置实现的内容都换成对应的注解实现，包含两部分内容:`bean作用范围`和`bean生命周期`。

### 4.1 环境准备 ###

先来准备环境:

*  创建一个Maven项目
 *  pom.xml添加Spring的依赖
    
        <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>5.2.15.RELEASE</version>
                </dependency>
            </dependencies>
 *  添加一个配置类`SpringConfig`
    
        @Configuration
        @ComponentScan("com.dcxuexi")
        public class SpringConfig {
              
        }
 *  添加UserDao、UserDaoImpl类
    
        public interface UserDao {
              
            public void select();
        }
        @Repository
        public class UserDaoImpl implements UserDao {
              
            public void select() {
              
                System.out.println("UserDao select, running ......");
            }
        }
 *  创建运行类SpringAnnotationBean
    
        public class SpringAnnotationBean {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
                UserDao userDao = context.getBean(UserDao.class);
                UserDao userDao2 = context.getBean(UserDao.class);
                System.out.println(userDao);
                System.out.println(userDao2);
            }
        }

最终创建好的项目结构如下:  
![在这里插入图片描述][7f0ba1b2990f4a46b206d02b1649ca43.png_pic_center]

### 4.2 Bean的作用范围 ###

(1)先运行SpringAnnotationBean类,在控制台打印两个一摸一样的地址，说明默认情况下bean是单例  
![在这里插入图片描述][642bc368cc5149938c352cbeaa4891ff.png_pic_center]  
(2)要想将UserDaoImpl变成非单例，只需要在其类上添加`@scope`注解

@Repository
    //@Scope设置bean的作用范围
    @Scope("prototype")
    public class UserDaoImpl implements UserDao {
        
        public void select() {
        
            System.out.println("UserDao select, running ......");
        }
    }

再次执行SpringAnnotationBean类，打印结果:  
![在这里插入图片描述][d973ad8761eb49ef8916681a5ba78a2b.png_pic_center]

#### 知识点1：@Scope ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Scope</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该类创建对象的作用范围<br>可用于设置创建出的bean是否为单例对象</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean作用范围，<br>默认值singleton（单例），可选值prototype（非单例）</td> 
  </tr> 
 </tbody> 
</table>

### 4.3 Bean的生命周期 ###

(1)在UserDaoImpl中添加两个方法，`init`和`destroy`,方法名可以任意

@Repository
    //@Scope设置bean的作用范围
    //@Scope("prototype")
    public class UserDaoImpl implements UserDao {
        
        public void select() {
        
            System.out.println("UserDao select, running ......");
        }
    
        public void init() {
        
            System.out.println("UserDao init ...");
        }
        public void destroy() {
        
            System.out.println("UserDao destroy ...");
        }
    }

(2)如何对方法进行标识，哪个是初始化方法，哪个是销毁方法?  
只需要在对应的方法上添加`@PostConstruct`和`@PreDestroy`注解即可。

@Repository
    //@Scope设置bean的作用范围
    //@Scope("prototype")
    public class UserDaoImpl implements UserDao {
        
        public void select() {
        
            System.out.println("UserDao select, running ......");
        }
    
        @PostConstruct //在构造方法之后执行，替换 init-method
        public void init() {
        
            System.out.println("UserDao init ...");
        }
    
        @PreDestroy //在销毁方法之前执行,替换 destroy-method
        public void destroy() {
        
            System.out.println("UserDao destroy ...");
        }
    }

(3)要想看到两个方法执行，需要注意的是`destroy`只有在容器关闭的时候，才会执行，所以需要修改SpringAnnotationBean的类

public class SpringAnnotationBean {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
            UserDao userDao = context.getBean(UserDao.class);
            UserDao userDao2 = context.getBean(UserDao.class);
            System.out.println(userDao);
            System.out.println(userDao2);
            context.close(); //关闭容器
        }
    }

(4)运行SpringAnnotationBean类查看打印结果，证明init和destroy方法都被执行了。  
![在这里插入图片描述][7c74174dedf049808621dcb9fdd8d874.png_pic_center]  
**注意:**@PostConstruct和@PreDestroy注解如果找不到，需要导入下面的jar包

<dependency>
      <groupId>javax.annotation</groupId>
      <artifactId>javax.annotation-api</artifactId>
      <version>1.3.2</version>
    </dependency>

找不到的原因是，从JDK9以后jdk中的javax.annotation包被移除了，这两个注解刚好就在这个包中。

#### 知识点1：@PostConstruct ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@PostConstruct</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>方法注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>方法上</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该方法为初始化方法</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

#### 知识点2：@PreDestroy ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@PreDestroy</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>方法注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>方法上</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该方法为销毁方法</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

**小结**  
![在这里插入图片描述][36f38e65f6384b64be509a6ddf6b1354.png_pic_center]

## 项目代码 ##

*  [gitee 代码下载][gitee]
 *  [github 代码代码][github]

[d9f1884749c447a69dc0f5f3d233c552.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ac3625b98ba34a79a2a141b813cde3b4.png
[cbc12494a76c4a2792c99a17d5ddd759.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7cf34c8d461b46d18b449771bd7266de.png
[b333c61779dc45b99f656a8a32a98073.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d6a5126423bf404294ea50c9d030c6b0.png
[6f51eb13ff4642ef899f8d8d0b674332.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bb5b4e81c48843f5af59c3dd9ce41793.png
[aa4addad418c4254b0fc4a19c244ad85.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b334d1c5bc5442f899583b536f1c1326.png
[574346014ed0401fb90b5163992f0fea.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/81df22d8d5ed478aac82bdbfefd9ef13.png
[550792f46c4741d3b29387afbc2c4223.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/829a374069214fa7ad09804e04c35069.png
[7f0ba1b2990f4a46b206d02b1649ca43.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3ce3e6226b14434aa1b74950b462d2a3.png
[642bc368cc5149938c352cbeaa4891ff.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bc0ed4bdf9874be38fdc6b70738db9f8.png
[d973ad8761eb49ef8916681a5ba78a2b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5e98587c7a5e436f9b04fe08398fdfee.png
[7c74174dedf049808621dcb9fdd8d874.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/386a934c230c4c269e7dfbdee4286499.png
[36f38e65f6384b64be509a6ddf6b1354.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/a1272c4ac99443c49a3ce40b769524a1.png
[gitee]: https://gitee.com/DchuangDB/sping-projeck
[github]: https://github.com/dcbut/spring