Spring IOC - 控制反转与依赖注入

classlist=com.cskaoyan.demo1.service.UserServiceImpl,com.cskaoyan.demo1.service.GoodServiceImpl,com.cskaoyan.demo1.service.AdminServiceImpl

 Class clazz = Class.forName("com.cskaoyan.demo1.service.UserServiceImpl")

Object instance = clazz.newInstance();

// Map map = new ConcurrentHashMap<>();
map.put("userServiceImpl",instance);

<dependencies>
  <!--引入依赖 beans、context、aop、expression、core、jcl、micrometer-observation 5+2-->
  <!--io.micrometer:micrometer-observation:1.14.14内置的可观测性埋点-->
  <!--spring-context-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.2.15</version>
  </dependency>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
  </dependency>
</dependencies>

public class UserServiceImpl implements UserService{
    @Override
    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

<?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 https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- bean definitions here -->

</beans>

<!--spring配置文件的名称通常叫application(-xxx).xml-->
<!-- bean definitions here -->
<!--控制反转-->
<!--id属性 👉 组件在容器中的唯一标识-->
<!--name属性 👉 名称 👉 通常省略不写-->
<!--class 全类名 👉 实现类的全类名-->
<!--组件 注册 👉 将实例交给spring管理的过程我们称之为注册-->
<bean id="userService" class="com.cskaoyan.demo1.service.UserServiceImpl"/>

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

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

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void serviceSayHello() {
        System.out.println("service层的sayHello");
        userDao.sayHello();
    }
}

public class UserDaoImpl implements UserDao{
    @Override
    public void sayHello() {
        System.out.println("hello xiaowu");
    }
}

<bean id="userService" class="com.cskaoyan.demo1.service.UserServiceImpl">
  <!--注册UserServiceImpl这个类型的组件的时候，实例化的过程会执行set方法(setUserDao)
            这个set方法的形参是UserDao类型的实例，通过id从容器中取出作为形参
            this.userDao = userDao; 给userServiceImpl这个组件的userDao成员变量做了赋值
            → 依赖注入
        -->
  <property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.cskaoyan.demo1.dao.UserDaoImpl"/>

@Test
public void testCase2() {
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
  UserDao userDao = applicationContext.getBean(UserDao.class);
  UserService userService = applicationContext.getBean(UserService.class);
  // 直接从容器中取出的userDao实例和从容器中取出的userService实例中的userDao成员变量是否是同一个
  /*UserServiceImpl userService = applicationContext.getBean(UserServiceImpl.class);

        userService.setUserDao(userDao);*/
}

// 这里增加功能性的注解
@Configuration
public class SpringConfiguration {
    // 类中的方法做组件的注册
}

// 这里增加功能性的注解
@Configuration
@ComponentScan("com.cskaoyan.demo1")
public class SpringConfiguration {
    // 类中的方法做组件的注册
}

@Target(ElementType.TYPE)// 该注解写在类上
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {

   /**
    * The value may indicate a suggestion for a logical component name,
    * to be turned into a Spring bean in case of an autodetected component.
    * @return the suggested component name, if any (or empty String otherwise)
    */
   String value() default "";

}

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

@SneakyThrows
@Test
public void testIsAnnotationPresent() {
    Map<String,Object> map = new ConcurrentHashMap<>();
    List<Class<?>> classList = Arrays.asList(UserServiceImpl.class, GoodServiceImpl.class, UserServiceImpl.class);
    for (Class<?> singleClass : classList) {
        if (singleClass.isAnnotationPresent(Component.class)) {
            Object instance = singleClass.newInstance();
            String key = singleClass.getName();
            map.put(key, instance);
        }
    }
    System.out.println(map);
}

@Configuration
@ComponentScan("com.cskaoyan.demo2")
public class ApplicationConfiguration {

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

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

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {}

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

public class Component1 {
    
    DataSource dataSource;

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

/**
 * Component1这个类中有一个成员变量 叫dataSource需要的是一个DataSource类型的组件
 * 设置的这个DataSource想要从容器中来获得
 * 形参：默认是按照类型从容器中取出组件的  ac.getBean(Class)
 * @return
 */
@Bean
public Component1 component1(DataSource dataSource) {
    Component1 component1 = new Component1();
    component1.setDataSource(dataSource);
    return component1;
}

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

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

@Component
public class Component2 {
    DataSource dataSource;

    public Component2(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

@Component
public class Component2 {
    DataSource dataSource;

    public Component2(@Qualifier("dataSource1") DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

public UserServiceImpl(UserDao userDao, @Value("zhangsan") String name) {
    this.userDao = userDao;
    this.name = name;
}

@Service
public class UserServiceImpl implements UserService {
    UserDao userDao;
    String name;

    public UserServiceImpl(UserDao userDao, @Value("zhangsan") String name) {
        this.userDao = userDao;
        this.name = name;
    }

    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
}

@Component
public class Component3 {
    DataSource dataSource;

    // 默认这个方法并不会自动执行
    // 如果我们在上面增加了@Autowired 注解的话，在生命周期设置属性值的过程中会自动执行
    // 形参默认按照类型从容器中取出;如果要指定组件id，还是@Qualifier
    @Autowired
    public void setDataSource(@Qualifier("dataSource2") DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

@Repository
public class OrderDaoImpl implements OrderDao{
}
@Repository
public class UserDaoImpl1 implements UserDao{
}
@Repository
public class UserDaoImpl2 implements UserDao{
}

/**
 * 要使用注入功能注解，一定要保证当前类是容器中的组件
 */
@Service
public class UserServiceImpl implements UserService{
    @Autowired //容器中该类型的组件只有一个
    OrderDao orderDao;
    @Autowired //使用@Qualifier注解指定组件id
    @Qualifier("userDaoImpl1")
    UserDao userDao1;
    @Resource(name = "userDaoImpl2") //默认是按照组件的类型去注入，使用name属性指定组件id
    UserDao userDao2;
}

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>6.2.15</version>
  <scope>test</scope>
</dependency>

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:application.xml")
public class MyTest2 {

    @Autowired
    UserService userService;
    @Autowired
    OrderDao orderDao;
    @Autowired
    @Qualifier("userDaoImpl1")
    UserDao userDao1;
    /**
     * 从容器中取出UserService组件
     * 查看userService组件中的成员变量是否取出容器中的组件
     */
    @Test
    public void mytest1(){

    }
}

@Service
public class CategoryServiceImpl implements CategoryService{
    @Autowired
    UserDao userDao;

    public CategoryServiceImpl() {
        System.out.println("CategoryServiceImpl的无参构造方法");
    }
}

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

@Configuration
@ComponentScan("com.cskaoyan")
public class AppConfiguration {

  //这就是一种工厂
  @Bean
  public UserService serviceProxy(UserService userService) {
    return ProxyUtil.getServiceProxy(userService);
  }
}

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

/**
 * 直接注册为容器中的组件
 * FactoryBean 👉 XXXFactoryBean
 *      👉 组件类型和FactoryBean接口中的getObject方法相关
 * BeanFactory和factoryBean：
 *      BeanFactory：生产的是容器中的所有的组件
 *      FactoryBean：生产的是特定的组件
 */
@Component
public class UserFactoryBean implements FactoryBean<User> {

    /**
     * 完成组件的实例化
     * @return 组件类型和返回值相关
     * @throws Exception
     */
    @Override
    public User getObject() throws Exception {
        User user = new User();
        return user;
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

@Component
public class UserServiceFactoryBean implements FactoryBean<UserService> {
  @Autowired
  UserService instance;
  @Override
  public UserService getObject() throws Exception {
    UserService proxy = (UserService) Proxy.newProxyInstance(UserServiceFactoryBean.class.getClassLoader(), UserServiceImpl.class.getInterfaces(), new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开启事务");
        Object invoke = method.invoke(instance, args);
        System.out.println("提交并关闭事务");
        return invoke;
      }
    });
    return proxy;
  }

  @Override
  public Class<?> getObjectType() {
    return UserService.class;
  }
}

@Component
@Scope("singleton")
public class SingletonBean {
}
@Component
@Scope("prototype")
public class PrototypeBean {
}
@Component
public class DefaultBean {
}

@Test
public void mytest1(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    SingletonBean bean1 = applicationContext.getBean(SingletonBean.class);
    SingletonBean bean2 = applicationContext.getBean(SingletonBean.class);
    SingletonBean bean3 = applicationContext.getBean(SingletonBean.class);
}
@Test
public void mytest2(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    PrototypeBean bean1 = applicationContext.getBean(PrototypeBean.class);
    PrototypeBean bean2 = applicationContext.getBean(PrototypeBean.class);
    PrototypeBean bean3 = applicationContext.getBean(PrototypeBean.class);
}
@Test
public void mytest3(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    DefaultBean bean1 = applicationContext.getBean(DefaultBean.class);
    DefaultBean bean2 = applicationContext.getBean(DefaultBean.class);
    DefaultBean bean3 = applicationContext.getBean(DefaultBean.class);
}

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {AppConfiguration.class})
public class ScopeTest {
    @Autowired
    SingletonBean singletonBean1;
    @Autowired
    SingletonBean singletonBean2;
    @Autowired
    SingletonBean singletonBean3;

    @Autowired
    PrototypeBean prototypeBean1;
    @Autowired
    PrototypeBean prototypeBean2;
    @Autowired
    PrototypeBean prototypeBean3;

    @Autowired
    DefaultBean defaultBean1;
    @Autowired
    DefaultBean defaultBean2;
    @Autowired
    DefaultBean defaultBean3;
    @Test
    public void testScope() {
        System.out.println(1);
    }
}

<dependency>
    <groupId>jakarta.annotation</groupId>
    <artifactId>jakarta.annotation-api</artifactId>
    <version>3.0.0</version>
</dependency>

@Component
public class LifeCycleBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware,
        InitializingBean,
        DisposableBean
{

    // 1. 构造器实例化(有参无参都行)
    public LifeCycleBean() {
        System.out.println("1. 构造器实例化(一定是最开始执行的)");
    }

    // 2.设置属性值(主要就是set方法、也可以直接增加在成员变量上)
    private String name;
    private UserDao userDao;
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("2. 设置属性值(主要就是set方法、也可以直接增加在成员变量上)");
    }
    // 设置属性值如果不为实例，可以使用@Value注解设置
    @Autowired
    public void setName(@Value("张三") String name) {
        this.name = name;
    }


    // 3. Aware接口实现的方法，会在生命周期过程中自动执行
    //    这些方法会有参数，beanName、beanFactory、applicationContext
    //    主要就是给组件中的成员变量做赋值,容器中的这个组件的其他方法就可以使用这些成员变量了
    //    这几个接口我们一般不太用，一般是看源码的时候大家要能看懂
    private String beanName;
    private BeanFactory beanFactory;
    // 自己写的代码，直接取就完了；但是我们会看一些源码，源码里使用的就是实现接口的方法的方式
    //    第三方或一些源码里，并不会在类上直接增加注解(比如@Component)，加注解要有扫描包配置
    //@Autowired
    private ApplicationContext applicationContext;

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("3. BeanNameAware.setBeanName");
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("3. BeanFactoryAware.setBeanFactory");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("3. ApplicationContextAware.setApplicationContext");
        //System.out.println(applicationContext);
    }

    // 初始化方法通常只使用其中的一种
    // 5. 自定义的init方法
    @PostConstruct // 构造器之后(但是这是一个初始化方法)
    public void customInitMethod() {
        System.out.println("5. 自定义的init方法(自己开发的类，直接使用即可)");
    }

    // 5. 实现接口的init方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5. InitializingBean.afterPropertiesSet(一般是第三方的类)");
    }


    // 销毁方法通常只使用其中的一种
    @PreDestroy // 容器销毁之前(但是这是一个销毁方法)
    public void customDestroyMethod() {
        System.out.println("7. 自定义的销毁方法(自己开发的类，直接使用即可)");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("7. DisposableBean.destroy(一般是第三方的类)");
    }
}

/**
 * 它就是提供方法的组件(方法的载体)
 *
 *    这两个方法：容器中的每一个组件 生命周期的初始化阶段都会去执行
 *      参数1：正在生命周期的组件实例(还没有放入到容器中)
 *      参数2：组件的名称(组件的id)
 *    返回值：实例
 *      交给下一个流程（容器中的组件其实是返回的这个实例）
 *      也就是说容器中管理的实例取决于return返回的值
 *   这两个方法按需提供
 *
 *
 *   全部组件初始化的时候的时候会执行
 *
 *   我是否可以针对特定的组件做处理呢？？？
 *
 */
@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

  @Nullable
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    System.out.println(beanName + " ：4. CustomBeanPostProcessor postProcessBeforeInitialization");
    return bean;
  }

  // 两个方法之间：初始化方法(自定义的init方法或实现InitializingBean接口)

  @Nullable
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println(beanName + " ：6. CustomBeanPostProcessor postProcessAfterInitialization");
    return bean;
  }
}

Class clazz = bean.getClass();
if(clazz.isAnnotationPresent(WdFlag.class)){
  System.err.println(beanName + " ：hello world");
}