IoC详解
共有两类注解类型可以实现：
1. 类注解：@Controller、@Service、@Repository、@Component、@Configuration.
2. 方法注解：@Bean.
类注解
@Controller（控制器存储）
使⽤@Controller存储bean的代码如下所⽰：
@Controller // 将对象存储到 Spring 中 public class UserController {public void sayHi(){System.out.println("hi,UserController...");}}如何观察这个对象已经存在Spring容器当中了呢?
接下来我们学习如何从Spring容器中获取对象
@SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 UserController userController = context.getBean(UserController.class);//使⽤对象 userController.sayHi();}}观察运⾏结果,发现成功从Spring中获取到Controller对象,并执⾏Controller的sayHi⽅法
如果把@Controller删掉,再观察运⾏结果
没有类型为“com.kdust.exercise”的合格bean。UserController”可用
获取bean对象的其他⽅式
上述代码是根据类型来查找对象,如果Spring容器中,同⼀个类型存在多个bean的话,怎么来获取呢?
ApplicationContext也提供了其他获取bean的⽅式,ApplicationContext获取bean对象的功能,是⽗类BeanFactory提供的功能.
public interface BeanFactory {//以上省略... // 1. 根据bean名称获取bean Object getBean(String var1) throws BeansException;// 2. 根据bean名称和类型获取bean <T> T getBean(String var1, Class<T> var2) throws BeansException;// 3. 按bean名称和构造函数参数动态创建bean,只适⽤于具有原型(prototype)作⽤域的bean Object getBean(String var1, Object... var2) throws BeansException;// 4. 根据类型获取bean <T> T getBean(Class<T> var1) throws BeansException;// 5. 按bean类型和构造函数参数动态创建bean, 只适⽤于具有原型(prototype)作⽤域的bean<T> T getBean(Class<T> var1, Object... var2) throws BeansException;//以下省略...
}
常⽤的是上述1,2,4种,这三种⽅式,获取到的bean是⼀样的
其中1,2种都涉及到根据名称来获取对象.
代码演示:
@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象//根据bean类型, 从Spring上下⽂中获取对象UserController userController1 = context.getBean(UserController.class);//根据bean名称, 从Spring上下⽂中获取对象UserController userController2 = (UserController)context.getBean("userController");//根据bean类型+名称, 从Spring上下⽂中获取对象UserController userController3 =context.getBean("userController", UserController.class);System.out.println(userController1);System.out.println(userController2);System.out.println(userController3);}
}
地址⼀样,说明对象是⼀个
获取bean对象,是⽗类BeanFactory提供的功能
• 继承关系和功能⽅⾯来说：Spring容器有两个顶级的接：BeanFactory和ApplicationContext。其中BeanFactory提供了基础的访问容器的能⼒，⽽ApplicationContext属于BeanFactory的⼦类，它除了继承了BeanFactory的所有功能之外， 它还拥有独特的特性，还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持.
• 从性能⽅⾯来说：ApplicationContext是⼀次性加载并初始化所有的Bean对象，⽽BeanFactory是需要那个才去加载那个，因此更加轻量.(空间换时间)
@Service（服务存储）
使⽤@Service存储bean的代码如下所⽰：
@Service
public class UserService {public void sayHi(String name) {System.out.println("Hi," + name);}
}public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring中获取UserService对象UserService userService = context.getBean(UserService.class);//使⽤对象userService.sayHi("UserService");}观察运⾏结果,发现成功从Spring中获取到UserService对象,并执⾏UserService的sayHi⽅法
同样的,把注解@Service删掉,再观察运⾏结果
没有类型为“com.kdust.exercise”的合格bean。UserService”可用
@Repository（仓库存储）
使⽤@Repository 存储bean的代码如下所⽰：
@Repository
public class UserRepository {public void sayHi() {System.out.println("Hi, UserRepository~");}
} public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象UserRepository userRepository = context.getBean(UserRepository.class);//使⽤对象userRepository.sayHi();}观察运⾏结果,发现成功从Spring中获取到UserRepository对象,并执⾏UserRepository的sayHi⽅法
同样的,把注解@Repository删掉,再观察运⾏结果
没有类型为“com.kdust.exercise”的合格bean。UserRepository”可用
@Component（组件存储）
使⽤@Component存储bean的代码如下所⽰：
@Component
public class UserComponent {public void sayHi() {System.out.println("Hi, UserComponent~");}
}public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象UserComponent userComponent = context.getBean(UserComponent.class);//使⽤对象userComponent.sayHi();}观察运⾏结果,发现成功从Spring中获取到UserRepository对象,并执⾏UserRepository的sayHi⽅法
同样的,把注解@Component删掉,再观察运⾏结果
没有类型为“com.kdust.exercise”的合格bean。UserComponent”可用
@Configuration（配置存储）
使⽤@Configuration存储bean的代码如下所⽰：
@Configuration
public class UserConfiguration {public void sayHi() {System.out.println("Hi,UserConfiguration~");}
} public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象UserConfiguration userConfiguration = context.getBean(UserConfiguration.class);//使⽤对象userConfiguration.sayHi();}观察运⾏结果,发现成功从Spring中获取到UserConfiguration对象,并执⾏UserConfiguration的 sayHi⽅法
同样的,把注解@Configuration删掉,再观察运⾏结果
没有类型为“com.kdust.exercise”的合格bean。UserConfiguration”可用
为什么要这么多类注解？
这个也是和咱们前⾯讲的应⽤分层是呼应的.让程序员看到类注解之后，就能直接了解当前类的⽤途.
• @Controller：控制层,接收请求,对请求进⾏处理,并进⾏响应.
• @Servie：业务逻辑层,处理具体的业务逻辑.
• @Repository：数据访问层，也称为持久层.负责数据访问操作
• @Configuration：配置层.处理项⽬中的⼀些配置信息.
这和每个省/市都有⾃⼰的⻋牌号是⼀样的.
⻋牌号都是唯⼀的,标识⼀个⻋辆的.但是为什么还需要设置不同的⻋牌开头呢.
⽐如陕西的⻋牌号就是：陕X：XXXXXX，北京的⻋牌号：京X：XXXXXX，甚⾄⼀个省不同的县区也 是不同的，⽐如西安就是，陕A：XXXXX，咸阳：陕B：XXXXXX，宝鸡，陕C：XXXXXX，⼀样.
这样做的好处除了可以节约号码之外，更重要的作⽤是可以直观的标识⼀辆⻋的归属地.
程序的应⽤分层，调⽤流程如下：
类注解之间的关系
查看@Controller /@Service /@Repository /@Configuration 等注解的源码发现：
其实这些注解⾥⾯都有⼀个注解@Component ，说明它们本⾝就是属于@Component 的"⼦类".
@Component 是⼀个元注解，也就是说可以注解其他类注解，如 @Controller ,@Service , @Repository 等.这些注解被称为
@Component 的衍⽣注解. @Controller ,@Service 和@Repository ⽤于更具体的⽤例(分别在控制层,业务逻辑层,持久化层),在开发过程中,如果你要在业务逻辑层使⽤ @Component 或@Service，显然@Service是更 好的选择
⽐如杯⼦有喝⽔杯,刷⽛杯等,但是我们更倾向于在⽇常喝⽔时使⽤⽔杯,洗漱时使⽤刷⽛杯.
方法注解@Bean
类注解是添加到某个类上的，但是存在两个问题:
1. 使⽤外部包⾥的类,没办法添加类注解
2. ⼀个类,需要多个对象,⽐如多个数据源
这种场景,我们就需要使⽤⽅法注解@Bean
我们先来看看⽅法注解如何使⽤:
public class BeanConfig {@Beanpublic User user(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}
}然⽽，当我们写完以上代码，尝试获取bean对象中的user时却发现，根本获取不到：
@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User user = context.getBean(User.class);//使⽤对象 System.out.println(user);}
}以上程序的执⾏结果如下：
这是为什么呢?
方法注解要配合类注解使用
在Spring框架的设计中，⽅法注解 @Bean 要配合类注解才能将对象正常的存储到Spring容器中， 如下代码所⽰：
@Component
public class BeanConfig {@Beanpublic User user(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}
}再次执⾏以上代码，运⾏结果如下：
定义多个对象
对于同⼀个类,如何定义多个对象呢?
⽐如多数据源的场景,类是同⼀个,但是配置不同,指向不同的数据源.
我们看下@Bean的使⽤
@Component
public class BeanConfig {@Beanpublic User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}@Beanpublic User user2(){User user = new User();user.setName("lisi");user.setAge(19);return user;}
} public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象SecurityProperties.User user = context.getBean(SecurityProperties.User.class);//使⽤对象System.out.println(user);}定义了多个对象的话,我们根据类型获取对象,获取的是哪个对象呢?
运⾏结果:
报错信息显⽰:期望只有⼀个匹配,结果发现了两个,user1,user2
从报错信息中,可以看出来,@Bean注解的bean,bean的名称就是它的⽅法名
接下来我们根据名称来获取bean对象
@SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//根据bean名称, 从Spring上下⽂中获取对象 User user1 = (User) context.getBean("user1");User user2 = (User) context.getBean("user2");System.out.println(user1);System.out.println(user2);}}运⾏结果:
可以看到,@Bean可以针对同⼀个类,定义多个对象.
重命名Bean
@Bean(name = {"u1","user1"})public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}此时我们使⽤u1就可以获取到User对象了，如下代码所⽰：
@SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User u1 = (User) context.getBean("u1");//使⽤对象 System.out.println(u1);}}name={}可以省略，如下代码所⽰：
@Bean({"u1","user1"})public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}只有⼀个名称时,{}也可以省略,如:
@Bean("u1")public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}扫描路径
Q:使⽤前⾯学习的四个注解声明的bean，⼀定会⽣效吗？
A:不⼀定（原因：bean想要⽣效，还需要被Spring扫描）
下⾯我们通过修改项⽬⼯程的⽬录结构，来测试bean对象是否⽣效：
再运⾏代码:
@SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User u1 = (User) context.getBean("u1");//使⽤对象 System.out.println(u1);}}运⾏结果:
解释:没有bean的名称为u1
为什么没有找到bean对象呢?
使⽤五⼤注解声明的bean，要想⽣效,还需要配置扫描路径,让Spring扫描到这些注解
也就是通过 @ComponentScan 来配置扫描路径.
@ComponentScan({"com.example.demo"})@SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context =SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User u1 = (User) context.getBean("u1");//使⽤对象 System.out.println(u1);}}{}⾥可以配置多个包路径
这种做法仅做了解,不做推荐使⽤
那为什么前⾯没有配置@ComponentScan注解也可以呢?
@ComponentScan 注解虽然没有显式配置，但是实际上已经包含在了启动类声明注解
@SpringBootApplication中了
默认扫描的范围是SpringBoot启动类所在包及其⼦包
在配置类上添加@ComponentScan注解,该注解默认会扫描该类所在的包下所有的配置类
推荐做法:
把启动类放在我们希望扫描的包的路径下,这样我们定义的bean就都可以被扫描到
