❤️‍Spring从入门到大神-----IOC详解

---

IoC详解

1、Bean创建

• @Component，组件注解，用于将任意对象添加到spring容器中
• @Controller，将web层的对象，添加到spring容器。
• @Service，将service层的对象，添加到spring容器。
• @Repository，将dao层的对象，添加到spring容器。

2、依赖注入

按照名称注入

public class 类名{
@Resource(name=“名称”)
private 类型 变量;
}

按照类型注入

public class 类名{
@Resource
private 类型 变量;
}

注册普通数据

@Value 可以给成员变量注入、也可以给属性注入(getter/setter)

properties数据注入

• 编写properties文件，key=value
• 加载 @PropertySource(“classpath:properties文件”)
• 注入数据 @Value("${key}")

@Configuration
@PropertySource(“classpath:demo07.properties”)
public class Demo07Configuration {
@Value("$jdbc.driver")privateStringdriver;//给成员变量赋值@Value("${jdbc.url}")
public void setUrl(String url) { //给写属性赋值
System.out.println(“url:” + url);
System.out.println(“driver:” + driver);

3、@Bean 注入第三方类

3.1、 按照类型

模拟类

public class UserDao {
public void selectAll() {
System.out.println("user dao ");
}
}

配置类

@Configuration
public class Demo08Configuration {
@Bean
public UserDao createUserDao() {
return new UserDao();
}
}

测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo08Configuration.class)
public class TestDemo08 {
@Resource
private UserDao userDao;
@Test
public void testDemo07() {
// UserDao userDao = new UserDao();
userDao.selectAll();
}
}

3.2、按照名称

• 模拟数据类
  • 接口
  • 实现类A
  • 实现类B
• 配置类，创建2个实现类，并进行不同的命名
• 测试类，依次注入不同命名的实现类

实现

• 配置类

@Configuration
public class Demo09Configuration {
@Bean(name=“userDaoA”)
public UserDao createUserDaoA() {
return new UserDaoImplA();
}
@Bean(name=“userDaoB”)
public UserDao createUserDaoB() {
return new UserDaoImplB();
}
}

测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo09Configuration.class)
public class TestDemo09 {
@Resource(name=“userDaoA”)
private UserDao userDaoA;
@Resource(name=“userDaoB”)
private UserDao userDaoB;
@Test
public void testDemo07() {
userDaoA.selectAll();
userDaoB.selectAll();
}
}

3.3、参数类型：引用数据

• @Bean 修饰的方法，如果有参数，将自动注入。

• 步骤：

  • 模拟类
    • UserDao
    • UserService
  • 配置类
    • 编写方法，createUserDao
    • 编写方法，createUserService( UserDao userDao )
  • 测试类

• 实现

  • 配置类

  @Configuration
  public class Demo10Configuration {
  @Bean
  public UserDao userDao() {
  return new UserDao();
  }
  @Bean
  public UserService userService(UserDao userDao) {
  userDao.selectAll();
  return new UserService();
  }
  }

测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo10Configuration.class)
public class TestDemo10 {
@Resource(name=“userService”)
private UserService userService;
@Test
public void testDemo07() {
userService.selectAll();
}
}

3.4、 参数类型：简单数据

properties配置文件

#key=value
jdbc.driver=com.mysql.jdbc.cj.Driver
jdbc.url=jdbc:mysql://localhost:3306/db2
user.username=jack
user.password=6666

配置类

@Configuration
@PropertySource(“classpath:demo07.properties”)
public class Demo11Configuration {
@Bean
public User createUser(@Value("$user.username")Stringusername,@Value("${user.password}") String password) {
return new User(username,password);
}
}

测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo11Configuration.class)
public class TestDemo11 {
@Resource
private User user;
@Test
public void testDemo07() {
System.out.println(user);
}
}

4、 Bean 作用域

• 默认2个作用域：
  • 单例 singleton ：整个spring容器只有一个。
  • 多例 prototype：每获得一次创建一份。

4.1、 单例

dao，确定作用域方式

@Repository
@Scope(“singleton”)
public class UserDao {
}

配置类

@Configuration
@ComponentScan(basePackages = {“com.czxy.demo12_scope.dao”})
public class Demo12Configuration {
}

测试类，注入2次，打印结果一样的。

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo12Configuration.class)
public class TestDemo12 {
@Resource
private UserDao userDao1;
@Resource
private UserDao userDao2;
@Test
public void testDemo4() {
System.out.println(userDao1);
System.out.println(userDao2);
}
}

4.2、 多例

修改单例代码

@Repository
//@Scope(“singleton”)
@Scope(“prototype”)
public class UserDao {
}

4.3、 常量

@Repository
//@Scope(“singleton”)
//@Scope(“prototype”)
//@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON) //单例常量 singleton
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) //多例常量 prototype
public class UserDao {
}

5、生命周期

5.1、 自定义Bean

目标类：需要完成初始化、销毁功能的类

• @PostConstruct 用于修饰初始化方法。
• @PreDestroy 用于修饰销毁方法。

@Component
public class Dog {
@PostConstruct //初始化
public void init() {
System.out.println(“小狗 出生了”);
}
public void eat() {
System.out.println(“正在吃…”);
}
@PreDestroy //销毁
public void destroy() {
System.out.println(“小狗 挂了”);
}
}

配置类：

@Configuration
@ComponentScan(basePackages = “com.czxy.demo13_lifecycle.domain”)
public class Demo13Configuration {
}

测试类：

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo13Configuration.class)
public class TestDemo13 {
@Resource
private Dog dog;
@Test
public void testDemo13() {
dog.eat();
}
}

5.2、 工厂bean （第三方类型）

目录类（有第三方jar提供，模拟的数据不允许有注解）

public class Dog {
public void init() {
System.out.println(“小狗14 出生了”);
}
public void eat() {
System.out.println(“14正在吃…”);
}
public void destroy() {
System.out.println(“小狗14 挂了”);
}
}

配置类，使用@Bean注册第三方对象，通过 initMethod 和 destroyMethod 两个属性设置初始化和销毁

@Configuration
public class Demo14Configuration {
@Bean(initMethod = “init”, destroyMethod = “destroy”)
public Dog dog() {
return new Dog();
}
}

测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo14Configuration.class)
public class TestDemo14 {
@Resource
private Dog dog;
@Test
public void testDemo14() {
dog.eat();
}
}

5.3、 生命周期函数有什么用？

释放资源：

public class 类名 {
@Bean(destroyMethod=“close”)
public DataSource datasource() {
return new DruidDataSource();
}
}