小言_互联网的博客

Spring——IOC + DI功能实现(完全注解开发)

319人阅读  评论(0)

1.前言

IOC也是Spring的核心之一了,之前学的时候是采用xml配置文件的方式去实现的,后来其中也多少穿插了几个注解,但是没有说完全采用注解实现。

那么这篇文章就和大家分享一下,全部采用注解来实现IOC + DI。


2.项目源码

2.1 方式一:@Component + @ComponentScan + @Value + @Autowired

首先还是pom文件,maven项目依赖必不可少。


  
  1. <dependencies>
  2. <dependency>
  3. <groupId>org.springframework </groupId>
  4. <artifactId>spring-context </artifactId>
  5. <version>5.2.5.RELEASE </version>
  6. </dependency>
  7. <dependency>
  8. <groupId>org.projectlombok </groupId>
  9. <artifactId>lombok </artifactId>
  10. <version>1.18.20 </version>
  11. </dependency>
  12. <dependency>
  13. <groupId>javax.annotation </groupId>
  14. <artifactId>javax.annotation-api </artifactId>
  15. <version>1.3.2 </version>
  16. </dependency>
  17. <dependency>
  18. <groupId>junit </groupId>
  19. <artifactId>junit </artifactId>
  20. <version>4.11 </version>
  21. <scope>test </scope>
  22. </dependency>
  23. </dependencies>

然后,写两个Java Bean,一个是Student学生类、另一个是School学校类。

由于不写xml配置,所以在两个类上方都要加上 @Component 注解,通过注解的方式将其交给Spring IOC容器管理,@Value注解则用于给8种基本数据类型以及String类型做依赖注入,@Autowired是针对引用类型的,这里不再多说了。


  
  1. package com.szh.bean;
  2. import lombok.Data;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.stereotype.Component;
  6. /**
  7. *
  8. */
  9. @Data
  10. @Component
  11. public class Student {
  12. @Value("张起灵")
  13. private String name;
  14. @Value("20")
  15. private Integer age;
  16. @Autowired
  17. private School school;
  18. }

  
  1. package com.szh.bean;
  2. import lombok.Data;
  3. import org.springframework.beans.factory.annotation.Value;
  4. import org.springframework.stereotype.Component;
  5. /**
  6. *
  7. */
  8. @Data
  9. @Component
  10. public class School {
  11. @Value("北京大学")
  12. private String name;
  13. @Value("北京市海淀区")
  14. private String address;
  15. }

下面要写一个配置类,功能就是添加包扫描机制,确保上面那两个 @Component 注解修饰的Java Bean可以被Spring扫描并添加至容器中。


  
  1. package com.szh.config;
  2. import org.springframework.context.annotation.ComponentScan;
  3. import org.springframework.context.annotation.Configuration;
  4. /**
  5. *
  6. */
  7. @Configuration
  8. @ComponentScan(basePackages = "com.szh.bean")
  9. public class SpringConfig {
  10. }

最后是我们的测试类了。


  
  1. package com.szh;
  2. import com.szh.bean.Student;
  3. import com.szh.config.SpringConfig;
  4. import org.junit.Test;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  7. /**
  8. *
  9. */
  10. public class MyTest {
  11. @Test
  12. public void testIocAnnotation () {
  13. ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig.class);
  14. Student student = (Student) ioc.getBean( "student");
  15. System.out.println(student);
  16. }
  17. }

2.2 方式二:@Configuration + @Bean

pom文件和方式一是一样的。

下面是不一样的Java Bean。


  
  1. package com.szh.entity;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  5. /**
  6. *
  7. */
  8. @Data
  9. @NoArgsConstructor
  10. @AllArgsConstructor
  11. public class Goods {
  12. private String name;
  13. private String info;
  14. }

  
  1. package com.szh.entity;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  5. import java.math.BigDecimal;
  6. /**
  7. *
  8. */
  9. @Data
  10. @NoArgsConstructor
  11. @AllArgsConstructor
  12. public class Order {
  13. private Integer id;
  14. private BigDecimal totalFee;
  15. private Goods goods;
  16. }

然后是该方式对应的配置类,采用@Bean实现。


  
  1. package com.szh.config;
  2. import com.szh.entity.Goods;
  3. import com.szh.entity.Order;
  4. import org.springframework.beans.factory.annotation.Autowire;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import java.math.BigDecimal;
  8. /**
  9. *
  10. */
  11. @Configuration
  12. public class SpringConfig2 {
  13. @Bean
  14. public Goods goods () {
  15. return new Goods( "联想-拯救者", "一款不错的游戏笔记本");
  16. }
  17. @Bean
  18. public Order order (Goods goods) {
  19. return new Order( 1, new BigDecimal( 9999), goods);
  20. }
  21. }

最后是这种方式的测试类代码。


  
  1. @Test
  2. public void testIocAnnotation2 () {
  3. ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig2.class);
  4. Order order = (Order) ioc.getBean( "order");
  5. System.out.println(order);
  6. System.out.println( "IOC容器中存在的bean如下:");
  7. String[] beanDefinitionNames = ioc.getBeanDefinitionNames();
  8. for (String bean : beanDefinitionNames) {
  9. System.out.println(bean);
  10. }
  11. }


转载:https://blog.csdn.net/weixin_43823808/article/details/125467874
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场