【注解使用】SpringBoot 注解的使用笔记，持续更新（一）

补缺漏的注解笔记，重点不是基本的注解（例如RequestMapping），当然之后如果有时间会把这一部分的笔记补上去，主要涉及的是使用过程当中遇到的突然的没有见过的注解。

 

1、@Conditional

场景：在编写Redis的配置类的时候遇见的

@Conditional(TestCondition.class)

这句代码可以标注在类上面，表示该类下面的所有@Bean都会启用配置，也可以标注在方法上面，只是对该方法启用配置。

@ConditionalOnBean（仅仅在当前上下文中存在某个对象时，才会实例化一个Bean）
@ConditionalOnClass（某个class位于类路径上，才会实例化一个Bean）
@ConditionalOnExpression（当表达式为true的时候，才会实例化一个Bean）
@ConditionalOnMissingBean（仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean）
@ConditionalOnMissingClass（某个class类路径上不存在的时候，才会实例化一个Bean）
@ConditionalOnNotWebApplication（不是web应用）

@ConditionalOnClass：该注解的参数对应的类必须存在，否则不解析该注解修饰的配置类；
@ConditionalOnMissingBean：该注解表示，如果存在它修饰的类的bean，则不需要再创建这个bean；可以给该注解传入参数例如@ConditionOnMissingBean(name = "example")，这个表示如果name为“example”的bean存在，这该注解修饰的代码块不执行。

 

2、@Compoment

@Component （把普通pojo实例化到spring容器中，相当于配置文件中的 <bean id="" class=""/>）
泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。

说明： 
<context:component-scan base-package=”com.*”> 
上面的这个例子是引入Component组件的例子，其中base-package表示为需要扫描的所有子包。 
共同点：被@controller 、@service、@repository 、@component 注解的类，都会把这些类纳入进spring容器中进行管理

 

一个类加了@bean，就会被Spring扫描到

所以项目在启动的时候，会创建一个这个类的对象，而此时如果有@Bean，就可以将这个对象注入进来。

Spring默认的是单例模式，如果需要用到其他的实例，就需要注入它

@Component
public String beanNews(){
    @Bean
    public NewPaperImpl newPaper(){
        NewPaperImpl newPaperImpl = new NewPaperImpl();
        return newPaperImpl ;
    }

    @Bean
    public InkImpl ink(){
        InkImpl inkImpl = new InkImpl();
        return inkImpl ;
    }
 
}

总而言之，bean是spring容器在管理实例和运行实例的方式，创建为bean是殊途同归的一件事。

创建bean的三种方式

原文链接：https://blog.csdn.net/weixin_40929150/article/details/81262891

1、默认的无参构建方法：

<!-- 默认的无参构建 -->
    <bean id="user" class="ioc.pojo.User"></bean>

@Test
public void testUser(){
	ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
	// 默认的无参构造创建
	User user = (User) context.getBean("user");
	System.out.println("默认的无参构造创建:" + user);
}

2、采用静态工厂创建实例

工厂类：

/**
 * User对象的工厂类
 * @author:LiChong
 * @date:2018/7/28
 */
public class UserFactory {
	
	// 静态方法
	public static User getUser1() {
		return new User();
	}
 
}

xml配置：

  <!-- 使用静态工厂创建user -->
  <bean id="user1" class="ioc.service.UserFactory" factory-method="getUser1"></bean>

测试：

@Test
public void testUser1(){
	ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		// 静态工厂创建
	User user1 = (User) context.getBean("user1");
	System.out.println("静态工厂创建:" + user1);
}

3、采用实例工厂

工厂类同上：

/**
 * User对象的工厂类
 * @author:LiChong
 * @date:2018/7/28
 */
public class UserFactory {
	
	//普通方法
	public User getUser2() {
		return new User();
	}
}

配置文件：

<!-- 使用实例工厂创建 user -->
    <bean id="userFactory" class="ioc.service.UserFactory"></bean>
    <bean id="user2" factory-bean="userFactory" factory-method="getUser2"></bean>

测试类：

@Test
	public void testUser2(){
		ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		// 实例工厂创建
		User user2 = (User) context.getBean("user2");
		System.out.println("实例工厂创建:" + user2);


}

第一种，通过默认的无参构造方式创建，其本质就是把类交给Spring自带的工厂（BeanFactory）管理、由Spring自带的工厂模式帮我们维护和创建这个类。如果是有参的构造方法，也可以通过XML配置传入相应的初始化参数，这种也是开发中用的最多的。

第二种，通过静态工厂创建，其本质就是把类交给我们自己的静态工厂管理，Spring只是帮我们调用了静态工厂创建实例的方法，而创建实例的这个过程是由我们自己的静态工厂实现的，在实际开发的过程中，很多时候我们需要使用到第三方jar包提供给我们的类,而这个类没有构造方法，而是通过第三方包提供的静态工厂创建的，这是时候，如果我们想把第三方jar里面的这个类交由spring来管理的话，就可以使用Spring提供的静态工厂创建实例的配置。

第三种，通过实例工厂创建，其本质就是把创建实例的工厂类交由Spring管理，同时把调用工厂类的方法创建实例的这个过程也交由Spring管理，看创建实例的这个过程也是有我们自己配置的实例工厂内部实现的。在实际开发的过程中，如Spring整合Hibernate就是通过这种方式实现的。但对于没有与Spring整合过的工厂类，我们一般都是自己用代码来管理的。
 

 

3、@SuppressWarnings

抑制代码左侧出现的警告，@SuppressWarnings("all") 表示抑制所有警告，这样做的目的是

为了防止左侧出现的警告挡住了打断点的位置。

excuse me？

 

 

4、@Bean

Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中。

SpringIOC 容器管理一个或者多个bean，这些bean都需要在@Configuration注解下进行创建，在一个方法上使用@Bean注解就表明这个方法需要交给Spring进行管理。

@Bean常见于在@Configuration注解的类里，也可以用在@Component注解的类里。添加的bean的id为方法名

 

例如说：

@Configuration
public class AppConfig {

    @Bean
    public TransferService transferService() {
        return new TransferServiceImpl();
    }

}

其他 用法例如说：

public class MyBean {

    public MyBean(){
        System.out.println("MyBean Initializing");
    }

    public void init(){
        System.out.println("Bean 初始化方法被调用");
    }

    public void destroy(){
        System.out.println("Bean 销毁方法被调用");
    }
}

@Configuration
public class AppConfig {

//    @Bean
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public MyBean myBean(){
        return new MyBean();
    }

}

这就是指定了生命周期的方法，生命周期方法是在什么时候都会被调用的

此外@Bean还可以同其他注解组合使用产生特殊反应。

例如

@Bean + @Scope

@Configuration
public class configofbean {

    public configofbean(){
        System.out.println("MyBean Initializing");
    }

    public void init(){
        System.out.println("Bean 初始化方法被调用");
    }

    public void destroy(){
        System.out.println("Bean 销毁方法被调用");
    }

    /**
     * 为myBean起两个名字，b1 和 b2
     * @Scope 默认为 singleton，但是可以指定其作用域
     * prototype 是多例的，即每一次调用都会生成一个新的实例。
     */
    @Bean({"b1","b2"})
    @Scope("prototype")
    public  configofbean myBean(){
        return new configofbean();
    }
}

然后再使用测试函数调用他们两个：

    @Test
    public static void main(String[] args) {

        ApplicationContext context = new AnnotationConfigApplicationContext(configofbean.class);
        configofbean myBean = (configofbean) context.getBean("b1");
        configofbean myBean2 = (configofbean) context.getBean("b2");
        System.out.println(myBean);
        System.out.println(myBean2);
    }

这是不加prototype的结果

 

因此我们得到结论：

SpringIOC通过将方法转化为bean，从而达到容器（方法）管理，当你使用

ApplicationContext context = new AnnotationConfigApplicationContext(****.class);

来获取Spring上下文的时候，成功获取到了某 class底下的所有bean，然后因为第一个 public  configofbean是构造函数，所以里面的一定会输出，那加入了prototype为什么会打印三次呢？

说明啊，该class被实例化了三次，这就是bean跟其他注解组合使用的时候会有的一些东西。