1
<dependencies>
2
    <!--引入依赖 beans、context、aop、expression、core、jcl 5+1-->
3
    <!--spring-context-->
4
    <dependency>
5
        <groupId>org.springframework</groupId>
6
        <artifactId>spring-context</artifactId>
7
        <version>5.2.5.RELEASE</version>
8
    </dependency>
9
    <dependency>
10
        <groupId>junit</groupId>
11
        <artifactId>junit</artifactId>
12
        <version>4.12</version>
13
        <scope>test</scope>
14
    </dependency>
15
</dependencies>

1
/**
2
     * 向容器中注册组件，从容器中取出组件
3
     */
4
@Test
5
public void testCase1() {
6
  // Spring容器
7
  // 初始化容器，并且注册组件
8
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
9
  // 从容器中取出组件
10
  // 按照组件的id(name)取出组件
11
  UserService userService1 = (UserService) applicationContext.getBean("userService");
12
  userService1.sayHello("spring");
13
  // 可以写接口的class，也可以写实现类的class，建议写接口
14
  // 如果容器中某个类型的组件只有一个，可以按照类型取出
15
  UserService userService2 = applicationContext.getBean(UserService.class);
16
  // id + 类型
17
  UserService userService3 = applicationContext.getBean("userService", UserService.class);
18
}

1
public class UserServiceImpl implements UserService{
2
    //主动 → 控制
3
    //UserDao userDao = new UserDaoImpl();
4
    UserDao userDao;
5

6
    public void setUserDao(UserDao userDao) {
7
        this.userDao = userDao;
8
    }
9

10
    @Override
11
    public void serviceSayHello() {
12
        System.out.println("service层的sayHello");
13
        userDao.sayHello();
14
    }
15
}

1
//@Component
2
//@Repository("userDao")  //组件id为userDao
3
@Repository               //组件id为userDaoImpl
4
public class UserDaoImpl implements UserDao{
5
}
6
/**
7
 * 增加其value属性，value属性值就是id
8
 * 如果没有增加value属性，id默认值是类名的首字母小写
9
 * @author stone
10
 * @date 2023/04/11 15:11
11
 */
12
//@Component // 组件id的默认值是goodsServiceImpl
13
@Component("goodsService") // 使用value属性值指定了组件id为goodsService
14
public class GoodServiceImpl implements GoodsService{
15
}

1
@Configuration
2
@ComponentScan("com.cskaoyan.demo2")
3
public class ApplicationConfiguration {
4

5
    // 在配置类中注册AdminServiceImpl组件
6
    // 在配置类中写的是方法 → 提供一个返回值为AdminServiceImpl类型的实例
7
    // 应用程序启动的时候 → 加载配置类 → 执行配置类中的方法(@Bean) → 方法的返回值注册为容器中的组件
8
    @Bean("wdAdminService")
9
    public AdminService adminService() {
10
        AdminService adminService = new AdminServiceImpl();
11
        System.out.println(adminService);
12
        return adminService;
13
    }
14

15
    // 容器中userService类型的组件有几个
16
    // 组件id默认值是方法名；可以使用@Bean的value属性指定
17
    // @Bean对应的方法的形参，默认是按照类型从容器中取出组件
18
    // 如果形参这个类型的组件在容器中不止一个，可以使用@Qualifier指定组件
19
    @Bean
20
    public UserService userService(@Qualifier("userDaoImpl") UserDao userDao) {
21
        UserServiceImpl userService = new UserServiceImpl();
22
        // 可否在组件注册过程中，从容器中取出UserDao的实例，给这个组件的成员变量赋值呢
23
        userService.setUserDao(userDao);
24
        return userService;
25
    }
26
}

1
/**
2
 * 要通过这个方法注册一个DruidDataSource组件
3
 * @return 应该返回的是一个DruidDataSource的实例，这个返回值会注册为容器中的组件
4
 * 返回值的定义：可以写实现类，也可以写接口；提供组件的类型信息给到容器中；建议写接口
5
 * SE的代码风格来提供属性值就可以
6
 * 通过这种方式注册的组件id：1、默认值是方法名；2、@Bean注解的value属性可以指定组件id
7
 */....................................................
8
@Bean
9
public DataSource dataSource(){
10
    DruidDataSource dataSource = new DruidDataSource();
11
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
12
    dataSource.setUrl("jdbc:mysql://localhost:3306/cskaoyan_db?useUnicode=true&characterEncoding=utf-8");
13
    dataSource.setUsername("root");
14
    dataSource.setPassword("123456");
15
    return dataSource;
16
}

1
@Bean
2
public DataSource dataSource2(){
3
    DruidDataSource dataSource = new DruidDataSource();
4
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
5
    dataSource.setUrl("jdbc:mysql://localhost:3306/cskaoyan_db2?useUnicode=true&characterEncoding=utf-8");
6
    dataSource.setUsername("root");
7
    dataSource.setPassword("123456");
8
    return dataSource;
9
}
10

11
/**
12
 * Component1这个类中有一个成员变量 叫dataSource需要的是一个DataSource类型的组件
13
 * 设置的这个DataSource想要从容器中来获得
14
 * 形参：默认是按照类型从容器中取出组件的  ac.getBean(Class)
15
 * 如果形参所需的组件在容器中不止一个，需要额外指定组件id的信息 → @Qualifier 的value属性指定组件id
16
 * 形参的名称也可以作为组件的id，但是我们更建议使用@Qualifier ，更直观一些
17
 * @return
18
 */
19
@Bean
20
public Component1 component1(@Qualifier("dataSource2") DataSource dataSource) {
21
    Component1 component1 = new Component1();
22
    component1.setDataSource(dataSource);
23
    return component1;
24
}

1
@Component
2
public class AdminServiceImpl implements AdminService{
3
    UserDao userDao;
4
    String username;
5
    // 如果你有无参构造方法，默认使用无参构造方法；
6
    // 如果你没有无参构造方法，实例化时会使用有参构造方法
7
    // 形参，默认是按照类型从容器中取出组件
8
    // 如果形参这个类型的组件在容器中不止一个，可以使用@Qualifier指定组件
9
    // 如果存在多个构造器，可以指定使用你标记构造器
10
    //@Autowired
11
    public AdminServiceImpl(UserDao userDao) {
12
        this.userDao = userDao;
13
    }
14
    @Autowired
15
    public AdminServiceImpl(UserDao userDao,@Value("zhangsan") String username) {
16
        this.userDao = userDao;
17
        this.username = username;
18
    }
19
}

1
/**
2
 * 组件可以使用之前要经过这样的一些生命周期
3
 *  组件可以使用之前：
4
 *      singleton：容器初始化的时候
5
 *      prototype：从容器中取出组件的时候，getBean
6
 */
7
@Component
8
public class LifeCycleBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware,
9
InitializingBean, DisposableBean {
10
  //实例化
11
  public LifeCycleBean(){
12
    System.out.println("1、bean的实例化");
13
  }
14
  //参数设置
15
  String parameter;
16
  @Autowired
17
  public void setParameter(String parameter) {
18
    System.out.println("2、设置参数");
19
    this.parameter = parameter;
20
  }
21
  //Aware：为组件中的成员变量提供参数 → BeanName、BeanFactory、ApplicationContext
22
  String beanName;
23
  BeanFactory beanFactory;
24
  ApplicationContext applicationContext;
25
  @Override
26
  public void setBeanName(String beanName) {
27
    System.out.println("3、BeanNameAware");
28
    this.beanName = beanName;
29
  }
30
  @Override
31
  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
32
    System.out.println("3、BeanFactoryAware");
33
    this.beanFactory = beanFactory;
34
  }
35
  @Override
36
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
37
    System.out.println("3、ApplicationContextAware");
38
    this.applicationContext = applicationContext;
39
  }
40

41
  @Override
42
  public void afterPropertiesSet() throws Exception {
43
    System.out.println("5、InitializingBean的afterPropertiesSet方法");
44
  }
45
  @PostConstruct
46
  public void init(){
47
    System.out.println("6、自定义的init方法");
48
  }
49

50
  @Override
51
  public void destroy() throws Exception {
52
    System.out.println("8、DisposableBean的destroy");
53
  }
54
  @PreDestroy
55
  public void customDestroy(){
56
    System.out.println("9、自定义的destroy");
57
  }
58

59

60
}

1
//该组件的before和after方法的作用范围：除了该组件本身之外，其他的所有组件
2
@Component
3
public class CustomBeanPostProcessor implements BeanPostProcessor {
4
    @Override
5
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
6
        System.out.println("4、BeanPostProcessor的before方法");
7
        return bean;
8
    }
9

10
    @Override
11
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
12
        System.out.println("7、BeanPostProcessor的after方法");
13
        return bean;
14
    }
15
}