猿创征文 | Spring框架【管理对象(IOC详解)】

目录

1,管理对象(IOC详解)

1.1 :什么是IOC

1.2:Bean创建

1.2.1:Bean相关注解

1.3:依赖注入(DI)

1.3.1:什么是DI

1.3.2:按照名称注入

1.3.3:按照类型注入

1.3.4:注入简单数据:@Value

1.3.5:properies数据注入

1.4:@Bean注入第三方类

1.4.1:按照类型

1.4.2:按照名称

1.4.3:参数类型:引入数据

1.4.4:参数类型:简单数据

1.5:Bean作用域

1.5.1:概述

1.5.2:单例

1.5.3:多例

1.5.4:常量

1.6:生命周期

1.6.1:什么是生命周期

1.6.2:生命周期详解

1.6.3:方式一:详解-初始化&销毁

1.6.4:方式二:第三方@Bean

1.6.5:生命周期函数有什么用吗?


1,管理对象(IOC详解)

  • Spring框架是企业使用最多的框架,没有之一。

  • Spring是一站式框架,也就是Spring可以整合其他框架。

    • Spring IoC:对象工厂及依赖注入。

    • Spring AOP:面向切面编程技术,Spring事务管理的基础。

    • Spring Transaction management:Spring事务管理。

    • Spring Web MVC:后面单独学习。

猿创征文 | Spring框架【管理对象(IOC详解)】_第1张图片 

 

1.1 :什么是IOC

  • IoC 是 Inversion of Control 的缩写,即“控制反转”。

  • 控制反转:将创建对象的权利,由自己(new)反转给spring。

  • 图解1:未使用IoC

  • 猿创征文 | Spring框架【管理对象(IOC详解)】_第2张图片

    图解2:使用IoC  

  • 猿创征文 | Spring框架【管理对象(IOC详解)】_第3张图片

    IoC作用:

  • 统一管理对象

  • 解决对象之间的耦合

    • 之前使用,类之间存在耦合

  • 猿创征文 | Spring框架【管理对象(IOC详解)】_第4张图片

    解决程序耦合

  • servlet类中,只用了service接口,表示web层和service层解耦。

  • service实现类中,只用了dao的接口,表示service层和dao层解耦。

猿创征文 | Spring框架【管理对象(IOC详解)】_第5张图片

好处: 可以实现解耦, 让类和类之间的耦合度降低,  将对象的创建权交给Spring管理 

1.2:Bean创建

  • 在spring 容器中管理的对象,统称为bean。例如:UserDao、UserService 等

1.2.1:Bean相关注解

注解 描述
@Component 将修饰的资源交予spring管理。 value属性:为资源命名(唯一标识)
@Controller 衍生注解,与@Component作用和属性相同。特用于修饰==表示层==的资源。
@Service 衍生注解,与@Component作用和属性相同。特用于修饰==业务逻辑层==的资源。
@Repository 衍生注解,与@Component作用和属性相同。特用于修饰==数据访问层==的资源。

1.3:依赖注入(DI)

1.3.1:什么是DI

依赖注入(Dependency Injection,DI)Spring 容器在创建被调用者的实例时,会自动将调用者需要的对象实例注入给调用者。

猿创征文 | Spring框架【管理对象(IOC详解)】_第6张图片

注解 描述 修饰位置
@Resource(name=”…”) 按照指定名称注入对象 字段、setter方法
@ Resource 按照类型注入对象 字段、setter方法
@Value 注入简单值 字段、setter方法、参数
@PropertySource 加载properties配置文件

1.3.2:按照名称注入

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

字段注入

    @Resource(name = "studentService4")
    private StudentService studentService;

 setter方法注入

    private StudentService studentService;

    @Resource(name = "studentService4")
    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

1.3.3:按照类型注入

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

1.3.4:注入简单数据:@Value

  • 简单数据:基本数据类型、字符串等。

  • 需要:定义User对象,给User对象注入数据

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

    • 步骤1:目标类,User,进行普通数据注入

    • 步骤2:配置类

    • 步骤3:测试类

步骤1:目标类,User,进行普通数据注入

@Component
public class User {
    @Value("jack")
    private String username;
    @Value("18")
    private Integer age;
	//....
}

步骤2:配置类

@Configuration
@ComponentScan(basePackages = "com.czxy.demo05_di_value.domain")
public class Demo05Configuration {
}

 步骤3:测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo05Configuration.class)
public class TestDemo05 {
    @Resource
    private User user;

    @Test
    public void testDemo5() {
        System.out.println(user);
    }
}

1.3.5:properies数据注入

  • 需求:读取数据库配置信息

  • 步骤:

    • 步骤1:编写demo07.properties文件

    • 步骤2:编写配置类,读取properties内容。@Value修饰setter

    • 步骤3:测试类

编写properties文件,key=value

猿创征文 | Spring框架【管理对象(IOC详解)】_第7张图片

#key=value
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db2
jdbc.username=root
jdbc.password=1234 

使用@PropertySource("classpath:properties文件")加载properties文件,使用@Value("${key}")进行注入

猿创征文 | Spring框架【管理对象(IOC详解)】_第8张图片 

 测试类

猿创征文 | Spring框架【管理对象(IOC详解)】_第9张图片

 

1.4:@Bean注入第三方类

  • 在实际开发中,有很多第三方提供类(jar包里),需要在spring中使用。

  • Spring提供@Bean注解,整合第三方类。

注解 描述
@Bean 将第三方对象,添加到spring容器中,方法名为默认名。
@Bean(name = "") 按照指定名称,将第三方对象,添加到spring容器中。

 

1.4.1:按照类型

  • 需要:假设UserDao是第三方(不能添加注解),需要使用UserDao

  • 步骤:

    • 步骤1:模拟类

    • 步骤2:配置类

    • 步骤3:测试类

  • 模拟类

  • 猿创征文 | Spring框架【管理对象(IOC详解)】_第10张图片

  • 配置类

    猿创征文 | Spring框架【管理对象(IOC详解)】_第11张图片 

     配置类

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

1.4.2:按照名称

  • 需求:定义一个UserDao接口,编写2个实现类A、B,分别按照名称进行注入

  • 步骤:

    1. 模拟数据类

      • 接口

      • 实现类A

      • 实现类B

    2. 配置类,创建2个实现类,并进行不同的命名

    3. 测试类,依次注入不同命名的实现类

  • 实现

    • 配置类

    • @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();
          }
      }

1.4.3:参数类型:引入数据

  • 需求:service、dao 都是第三方

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

@Bean
public 返回值 方法名(参数类型 参数名) {		//主动注入参数对象
}
  • 步骤:

    • 模拟类

      • UserDao

      • UserService

    • 配置类

      • 编写方法,createUserDao

      • 编写方法,createUserService( UserDao userDao )

    • 测试类

  • 实现

    • 模拟类:dao实现类没有注解

public interface StudentDao {
    public void selectAll();
}

 

public class StudentDaoImpl implements StudentDao {
    @Override
    public void selectAll() {
        System.out.println("demo10 student dao ");
    }
}

模拟类:service,没有注解  

public interface StudentService {
    public void selectAll();
}
public class StudentServiceImpl implements StudentService {

    private StudentDao studentDao;

    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    @Override
    public void selectAll() {
        System.out.println("demo10 student service");
        studentDao.selectAll();
    }
}

 配置类 猿创征文 | Spring框架【管理对象(IOC详解)】_第12张图片

@Configuration
@ComponentScan(basePackages = {"com.czxy.demo10_bean_param"})
public class Demo10Configuration {

    @Bean
    public StudentDao studentDao() {
        return new StudentDaoImpl();
    }

    @Bean
    public StudentService studentService10(StudentDao studentDao) {
        StudentServiceImpl studentService = new StudentServiceImpl();
        studentService.setStudentDao(studentDao);
        return studentService;
    }
}

 测试类

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo10Configuration.class)
public class TestDemo10 {
    @Resource(name = "studentService10")
    private StudentService studentService;

    @Test
    public void testDemo() {
        studentService.selectAll();
    }
}

 

1.4.4:参数类型:简单数据

properties配置文件

猿创征文 | Spring框架【管理对象(IOC详解)】_第13张图片

配置类  

猿创征文 | Spring框架【管理对象(IOC详解)】_第14张图片 

测试类 猿创征文 | Spring框架【管理对象(IOC详解)】_第15张图片 

 

1.5:Bean作用域

1.5.1:概述

  • bean作用域:一个对象的使用范围。

  • 通过@Scope可以设置Bean的作用域

注解 取值
@Scope singleton 默认值,单例的。整个spring容器只有一个
prototype 多例的。每获得一次创建一份
  • 需求:编写UserDao,获得对象,注入2次。

1.5.2:单例

dao,确定作用域方式

@Repository
@Scope("singleton")
public class UserDao {
}

配置类 猿创征文 | Spring框架【管理对象(IOC详解)】_第16张图片 

 测试类,注入2次,打印结果一样的。 猿创征文 | Spring框架【管理对象(IOC详解)】_第17张图片

 

1.5.3:多例

修改单例代码

猿创征文 | Spring框架【管理对象(IOC详解)】_第18张图片

 

1.5.4:常量

猿创征文 | Spring框架【管理对象(IOC详解)】_第19张图片

 

1.6:生命周期

1.6.1:什么是生命周期

  • 生命周期:指Spring创建Bean到销毁Bean的整个过程。

  • spring bean 完整生命周期参数

  • 在实际开发中,最常用的是bean初始化销毁

1.6.2:生命周期详解

  • 完整示意图猿创征文 | Spring框架【管理对象(IOC详解)】_第20张图片

    实例:(⑧、⑬为XML配置内容)

  • 猿创征文 | Spring框架【管理对象(IOC详解)】_第21张图片 

    步骤1:创建后处理bean

  • @Component
    public class MyBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if("dog".equalsIgnoreCase(beanName)) {
                System.out.println("5. BeanPostProcessor#before --> " + beanName);
            }
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if("dog".equalsIgnoreCase(beanName)) {
                System.out.println("9. BeanPostProcessor#after --> " + beanName);
            }
            return bean;
        }
    }
    

     步骤2:编写目标类Dog

  • @Component
    //@Scope("prototype")
    public class Dog implements BeanNameAware, BeanFactoryAware, InitializingBean, DisposableBean {
    
        public Dog() {
            System.out.println("1. 初始化");
        }
    
        @Value("旺财")
        public void setName(String name) {
            System.out.println("2. properties --> " + name);
        }
    
        @Override
        public void setBeanName(String s) {
            System.out.println("3. BeanNameAware#setBeanName --> " + s);
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("4. BeanFactoryAware#beanFactory ");
        }
    
        @PostConstruct  //初始化
        public void init() {
            System.out.println("6. 小狗 出生了");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("7. InitializingBean#afterPropertiesSet");
        }
    
    
    
    
        public void eat() {
            System.out.println("10. 正在吃...");
        }
    
        @PreDestroy     //销毁
        public void DogDestroy() {
            System.out.println("11. 小狗 挂了");
        }
    
    
        @Override
        public void destroy() throws Exception {
            System.out.println("12. DisposableBean#destroy");
        }
    }

    步骤3:配置类

  • @Configuration
    @ComponentScan(basePackages = {"com.czxy.demo13_lifecycle.domain","com.czxy.demo13_lifecycle.processor"})
    public class Demo13Configuration {
    
    }

    步骤4:测试类

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

1.6.3:方式一:详解-初始化&销毁

  • 需求:

    • 编写目标类Dog,并执行eat方法打印正在吃...

    • 在eat()前后分别执行初始化小狗 出生了、销毁小狗 挂了

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

    • @PostConstruct 用于修饰==初始化==方法。

    • @PreDestroy 用于修饰==销毁==方法。

猿创征文 | Spring框架【管理对象(IOC详解)】_第22张图片 

配置类: 猿创征文 | Spring框架【管理对象(IOC详解)】_第23张图片 

 测试类:

猿创征文 | Spring框架【管理对象(IOC详解)】_第24张图片

 

1.6.4:方式二:第三方@Bean

  • 需求:

    • 使用@Bean配置目标类Dog的初始化和销毁

  • 目录类(假设Dog由第三方jar提供,没有源码,不允许使用注解@Component

猿创征文 | Spring框架【管理对象(IOC详解)】_第25张图片 

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

猿创征文 | Spring框架【管理对象(IOC详解)】_第26张图片

测试类

猿创征文 | Spring框架【管理对象(IOC详解)】_第27张图片 

 

1.6.5:生命周期函数有什么用吗?

释放资源:

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

你可能感兴趣的:(ssm框架,spring,java,后端)