文章目录
前言
spring Ioc以及DI配置
一、Spring Ioc容器
1、概念
Spring IoC 容器,负责实例化、配置和组装 bean(组件)。容器通过读取配置元数据来获取有关要实例化、配置和组装组件的指令。
IoC(控制反转) 主要是针对对象的创建和调用控制而言的。不再是应用程序直接创建该对象,而是由 IoC 容器来创建和管理,即控制权由应用程序转移到 IoC 容器中。
DI(依赖注入)在组件之间传递依赖关系的过程中,将依赖关系在容器内部进行处理,实现了对象之间的解耦合。通过 XML 配置文件或注解的方式实现的。它提供了三种形式的依赖注入:构造函数注入、Setter 方法注入和接口注入。
2、具体接口和实现类
二、实现步骤
1、配置元数据,编写交给SpringIoC容器管理组件的信息。(三种配置方式)
2、实例化Ioc容器
3、获取Bean(组件)
配置方式
XML配置方式:
通过在XML文件中定义Bean及其依赖关系、Bean的作用域等信息
注解方式:
通过在Bean类上使用注解来代替XML配置文件中的配置信息。通过在Bean类上加上相应的注解(如@Component, @Service, @Autowired等)
Java配置类方式:
通过Java类来定义Bean、Bean之间的依赖关系和配置信息,从而代替XML配置文件的方式。通过@Configuration、@Bean等注解来实现Bean和依赖关系的配置
1、基于xml配置
(1)准备spring项目和组件
导入依赖pom.xml
<dependencies>
<!--spring context依赖-->
<!--当你引入Spring Context依赖之后,表示将Spring的基础依赖引入了-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.6</version>
</dependency>
</dependencies>
实例化对象
基于无参数构造函数
a.准备组件类
package com.atguigu.ioc;
public class HappyComponent {
//默认包含无参数构造函数
public void doWork() {
System.out.println("HappyComponent.doWork");
}
}
b.xml配置文件编写
<!-- [重要]创建bean -->
<bean id="happyComponent" class="com.atguigu.ioc.HappyComponent"/>
- bean标签:通过配置bean标签告诉IOC容器需要创建对象的组件信息
- id属性:bean的唯一标识,方便后期获取Bean!
- class属性:组件类的全限定符!
基于静态工厂方法实例化
a.准备组件类
public class ClientService {
private static ClientService clientService = new ClientService();
private ClientService() {}
public static ClientService createInstance() {
return clientService;
}
}
b.xml配置文件编写
<bean id="clientService" class="examples.ClientService"
factory-method="createInstance"/>
-class属性:指定工厂类的全限定符!
-factory-method: 指定静态工厂方法,注意,该方法必须是static方法。
基于实例工厂方法实例化
a.准备组件类
public class DefaultServiceLocator {
private static ClientServiceImplclientService = new ClientServiceImpl();
public ClientService createClientServiceInstance() {
return clientService;
}
}
b.xml配置文件编写
<!-- 将工厂类进行ioc配置 -->
<bean id="serviceLocator" class="examples.DefaultServiceLocator"></bean>
<!-- 根据工厂对象的实例工厂方法进行实例化组件对象 -->
<bean id="clientService"
factory-bean="serviceLocator"
factory-method="createClientServiceInstance"/>
- factory-bean属性:指定当前容器中工厂Bean 的名称。
- factory-method: 指定实例工厂方法名。注意,实例方法必须是非static的!
(2)组件Bean注入依赖(DI)
基于构造函数的依赖注入
a.组件类
public class UserDao {}
public class UserService {
private UserDao userDao;
//单个构造参数
public UserService(UserDao userDao) {
this.userDao = userDao;
}
//多构造参数解析
public UserService(int age , String name ,UserDao userDao) {
this.userDao = userDao;
this.age = age;
this.name = name;
}
}
b.编写配置文件
<beans>
<!-- 引用类bean声明 -->
<bean id="userService" class="x.y.UserService">
<!--多构造函数加入值-->
<!-- value直接注入基本类型值 -->
<constructor-arg value="18"/>
<constructor-arg value="赵伟风"/>
<!-- 构造函数引用 -->
<constructor-arg ref="userDao"/>
</bean>
<!-- 被引用类bean声明 -->
<bean id="userDao" class="x.y.UserDao"/>
</beans>
constructor-arg标签:可以引用构造参数 ref引用其他bean的标识。
基于setter方法依赖注入
a.组件类
public Class MovieFinder{}
public class SimpleMovieLister {
private MovieFinder movieFinder;
private String movieName;
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
public void setMovieName(String movieName){
this.movieName = movieName;}
}
b.编写配置文件
<bean id="simpleMovieLister" class="examples.SimpleMovieLister">
<!-- setter方法,注入movieFinder对象的标识id
name = 属性名 ref = 引用bean的id值-->
<property name="movieFinder" ref="movieFinder" />
<!-- setter方法,注入基本数据类型movieName
name = 属性名 value= 基本类型值-->
<property name="movieName" value="消失的她"/>
</bean>
<bean id="movieFinder"class="examples.MovieFinder"/>
(3)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"
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">
<!-- 配置自动扫描的包 -->
<!-- 1.包要精准,提高性能!
2.会扫描指定的包和子包内容
3.多个包可以使用,分割 例如: com.atguigu.controller,com.atguigu.service等-->
<context:component-scan base-package="com.atguigu.components"/>
</beans>
指定排除组件
<context:component-scan base-package="com.atguigu.components">
<!-- context:exclude-filter标签:指定排除规则 -->
<!-- type属性:指定根据什么来进行排除,annotation取值表示根据注解来排除 -->
<!-- expression属性:指定排除规则的表达式,对于注解来说指定全类名即可 -->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
指定扫描组件
<!-- 仅扫描 = 关闭默认规则 + 追加规则 -->
<!-- use-default-filters属性:取值false表示关闭默认扫描规则 -->
<context:component-scan base-package="com.atguigu.ioc.components" use-default-filters="false">
<!-- context:include-filter标签:指定在原有扫描规则的基础上追加的规则 -->
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
(4)Ioc容器创建和使用
a.容器实例化
//方式1:实例化并且指定配置文件
//参数:String...locations 传入一个或者多个配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("services.xml", "daos.xml");
//方式2:先实例化,再指定配置文件,最后刷新容器触发Bean实例化动作 [springmvc源码和contextLoadListener源码方式]
ApplicationContext context =
new ClassPathXmlApplicationContext();
//设置配置配置文件,方法参数为可变参数,可以设置一个或者多个配置
iocContainer1.setConfigLocations("services.xml", "daos.xml");
//后配置的文件,需要调用refresh方法,触发刷新配置
iocContainer1.refresh();
b.Bean对象读取
//方式1: 根据id获取
//没有指定类型,返回为Object,需要类型转化!
HappyComponent happyComponent =
(HappyComponent) iocContainer.getBean("bean的id标识");
//使用组件对象
happyComponent.doWork();
//方式2: 根据类型获取
//根据类型获取,但是要求,同类型(当前类,或者之类,或者接口的实现类)只能有一个对象交给IoC容器管理
//配置两个或者以上出现: org.springframework.beans.factory.NoUniqueBeanDefinitionException 问题
HappyComponent happyComponent = iocContainer.getBean(HappyComponent.class);
happyComponent.doWork();
//方式3: 根据id和类型获取
HappyComponent happyComponent = iocContainer.getBean("bean的id标识", HappyComponent.class);
happyComponent.doWork();
/*根据类型来获取bean时,在满足bean唯一性的前提下,其实只是看:『对象 instanceof 指定的类型』的返回结果,
只要返回的是true就可以认定为和类型匹配,能够获取到。*/
FactoryBean
2、基于注解方式
和XML 配置文件一样,注解本身并不能执行,注解本身仅仅只是做一个标记。(步骤同上)
配置总结
a. 注解方式IoC只是标记哪些类要被Spring管理
b. 最终,我们还需要XML方式或者后面讲解Java配置类方式指定注解生效的包
(1)组件添加标记注解
注解直接添加在java类上 (代码如上)
准备组件类
/* description: 普通的组件*/
@Component
public class CommonComponent {}
/*description: controller类型组件*/
@Controller
public class XxxController {}
/* description: service类型组件*/
@Service
public class XxxService {}
/* description: dao类型组件*/
@Repository
public class XxxDao {}
组件BeanName问题
类名首字母小写就是 bean 的 id。例如:SoldierController 类对应的 bean 的 id 就是 soldierController。
使用value属性指定:
@Controller(value = "tianDog")
public class SoldierController {
}
//当注解中只设置一个属性时,value属性的属性名可以省略:
@Controller("tianDog")
### (1)组件周期方法注解
我们可以在组件类中定义方法,然后当IoC容器实例化和销毁组件对象的时候进行调用!这两个方法我们成为生命周期方法!类似于Servlet的init/destroy方法,我们可以在周期方法完成初始化和释放资源等工作。
**a、周期方法声明**
```java
public class BeanOne {
//周期方法要求: 方法命名随意,但是要求方法必须是 public void 无形参列表
@PostConstruct //注解制指定初始化方法
public void init() {// 初始化逻辑}
}
public class BeanTwo {
@PreDestroy //注解指定销毁方法
public void cleanup() {// 释放资源逻辑}
}
(2)组件作用域配置
Bean作用域概念
<bean 标签声明Bean,只是将Bean的信息配置给SpringIoC容器!标签对应的信息转成Spring内部 BeanDefinition 对象(包含id,class,属性等等)
作用域可选值
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON) //单例,默认值
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE) //多例 二选一
public class BeanOne {
@PostConstruct //注解制指定初始化方法
public void init() {// 初始化逻辑 }
}
(3)引用类型自动装配(DI)
场景
- SoldierController 需要 SoldierService
- SoldierService 需要 SoldierDao
- 同时在各个组件中声明要调用的方法。
自动装配实现
前提:参与自动装配的组件(需要装配、被装配)全部都必须在IoC容器中。
@Autowired注解
不需要提供setXxx()方法
标记位置:成员变量、构造方法、setXXX()方法
例子:
@Controller(value = "tianDog")
public class SoldierController {
@Autowired
private SoldierService soldierService;
public void getMessage() {
soldierService.getMessage();
}
}
(4)基本类型属性赋值
@Value 通常用于注入外部化属性
步骤
1、声明外部配置 application.properties
catalog.name=MovieCatalog
2、xml引入外部配置
<!-- 引入外部配置文件-->
<context:property-placeholder location="application.properties" />
3、@Value注解读取配置
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class CommonComponent {
/**
* 情况1: ${key} 取外部配置key对应的值!
* 情况2: ${key:defaultValue} 没有key,可以给与默认值
*/
@Value("${catalog:hahaha}")
private String name;
}
注解+XML IoC方式问题
a、 自定义类可以使用注解方式,但是第三方依赖的类依然使用XML方式!
b、XML格式解析效率低!
3、基于配置类方式
完全注解配置(通过 Java配置类代码来配置 Spring 应用程序,使用注解来替代原本在 XML 配置文件中的配置)
(1)配置类和扫描注解
xml+注解方式
//1、配置文件application.xml
//2、创建IoC容器
// xml方式配置文件使用ClassPathXmlApplicationContext容器读取
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("application.xml");
配置类+注解方式(完全注解方式)
(a) 配置类
使用 @Configuration 注解将一个普通的类标记为 Spring 的配置类。
//标注当前类是配置类,替代application.xml
@Configuration
//使用注解读取外部配置,替代 <context:property-placeholder标签
@PropertySource("classpath:application.properties")
//使用@ComponentScan注解,可以配置扫描包,替代<context:component-scan标签
@ComponentScan(basePackages = {"com.atguigu.components"})
public class MyConfiguration {}
(b)测试创建IoC容器
// AnnotationConfigApplicationContext 根据配置类创建 IOC 容器对象
ApplicationContext iocContainerAnnotation =
new AnnotationConfigApplicationContext(MyConfiguration.class);
(2)@Bean组件
场景需求:将Druid连接池对象存储到IoC容器
需求分析:第三方jar包的类,添加到ioc容器,无法使用@Component等相关注解!因为源码jar包内容为只读模式!
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"
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:property-placeholder location="classpath:jdbc.properties"/>
<!-- 实验六 [重要]给bean的属性赋值:引入外部属性文件 -->
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="${jdbc.url}"/>
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
</beans>
配置类方式实现
@Bean(<bean) 注释用于指示方法实例化、配置和初始化要由 Spring IoC 容器管理的新对象。
//标注当前类是配置类,替代application.xml
@Configuration
//引入jdbc.properties文件
@PropertySource({"classpath:application.properties","classpath:jdbc.properties"})
@ComponentScan(basePackages = {"com.atguigu.components"})
public class MyConfiguration {
//如果第三方类进行IoC管理,无法直接使用@Component相关注解
//解决方案: xml方式可以使用<bean标签
//解决方案: 配置类方式,可以使用方法返回值+@Bean注解
@Bean
public DataSource createDataSource(@Value("${jdbc.user}") String username,
@Value("${jdbc.password}")String password,
@Value("${jdbc.url}")String url,
@Value("${jdbc.driver}")String driverClassName){
//使用Java代码实例化
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUsername(username);
dataSource.setPassword(password);
dataSource.setUrl(url);
dataSource.setDriverClassName(driverClassName);
//返回结果即可
return dataSource;
}
}
注解+配置类 IoC方式总结
- 完全摒弃了XML配置文件
- 自定义类使用IoC和DI注解标记
- 第三方类使用配置类声明方法+@Bean方式处理
- 完全注解方式(配置类+注解)是现在主流配置方式