【Spring】Spring常用注解(上)

Java
43
0
0
2024-06-11
标签   Spring

Spring注解

AnnotationConfigApplicationContext
组件添加
@Configuration+@Bean
XML文件方式
Person


public class Person { 
   
   private String name;
    
   private Integer age;
   
   private String nickName;
   
   public String getNickName() {
      return nickName;
   }
   public void setNickName(String nickName) {
      this.nickName = nickName;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public Integer getAge() {
      return age;
   }
   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Person(String name, Integer age) {
      super();
      this.name = name;
      this.age = age;
   }
   public Person() {
      super();
      // TODO Auto-generated constructor stub
   }
   @Override
   public String toString() {
      return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]";
   }
}
beans.xml-配置文件
<?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"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

   <context:component-scan base-package="com.atguigu" use-default-filters="false"></context:component-scan>
   <bean id="person" class="com.atguigu.bean.Person">
      <property name="age" value="18"></property>
      <property name="name" value="zhangsan"></property>
   </bean>
</beans>
MainTest
public class MainTest {
   
   @SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		Person bean = (Person) applicationContext.getBean("person");
		System.out.println(bean);
	}
}

输出

Person [name=zhangsan, age=18, nickName=null]
注解方式
//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
   
   //给容器中注册一个Bean;类型为返回值的类型,id默认是用方法名作为id(就是bean的名字),在这里就是person01
   @Bean
   public Person person01(){
      return new Person("lisi", 20);
   }

}
或者以下面的这种方式

//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
   
   //这里bean的name就是person
    @Bean("person")
	public Person person01(){
		return new Person("lisi", 20);
	}

}
@ComponentScans
//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类

@ComponentScans(
      value = {
            @ComponentScan(value="com.atguigu",includeFilters = {
/*                @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
                  @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
                  @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
            },useDefaultFilters = false)   
      }
      )
//@ComponentScan  value:指定要扫描的包
//excludeFilters = Filter[] :指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] :指定扫描的时候只需要包含哪些组件
//FilterType.ANNOTATION:按照注解
//FilterType.ASSIGNABLE_TYPE:按照给定的类型;
//FilterType.ASPECTJ:使用ASPECTJ表达式
//FilterType.REGEX:使用正则指定
//FilterType.CUSTOM:使用自定义规则
public class MainConfig {
   
   //给容器中注册一个Bean;类型为返回值的类型,id默认是用方法名作为id
   @Bean("person")
   public Person person01(){
      return new Person("lisi", 20);
   }

}
自定义TypeFilter指定包扫描规则
public class MyTypeFilter implements TypeFilter {

   /**
    * metadataReader:读取到的当前正在扫描的类的信息
    * metadataReaderFactory:可以获取到其他任何类信息的
    */
   @Override
   public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
         throws IOException {
      // TODO Auto-generated method stub
      //获取当前类注解的信息
      AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
      //获取当前正在扫描的类的类信息
      ClassMetadata classMetadata = metadataReader.getClassMetadata();
      //获取当前类资源(类的路径)
      Resource resource = metadataReader.getResource();
      
      String className = classMetadata.getClassName();
      System.out.println("--->"+className);
      if(className.contains("er")){
         return true;
      }
      return false;
   }

}
@Scope
@Configuration
public class MainConfig2 {
   
	/**
	 * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE   任何环境都可以使用
	 * @see ConfigurableBeanFactory#SCOPE_SINGLETON   任何环境都可以使用
	 * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST  request    只能在web容器里用
	 * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION	 sesssion   只能在web容器里用
	 * 
	 * @Scope:调整作用域
	 * prototype:多实例的:ioc容器启动并不会去调用方法创建对象放在容器中。
	 * 					每次获取的时候才会调用方法创建对象;
	 * singleton:单实例的(默认值):ioc容器启动会调用方法创建对象放到ioc容器中。
	 * 			以后每次获取就是直接从容器(map.get())中拿,
	 * request:同一次请求创建一个实例
	 * session:同一个session创建一个实例
	 *
	 * 默认是单实例的
	 * 
	 */
	@Scope("prototype")
	@Lazy
	@Bean("person")
	public Person person(){
		System.out.println("给容器中添加Person....");
		return new Person("张三", 25);
	}

}
@Lazy
@Configuration
public class MainConfig2 {
   
   /**
    * 
    * 懒加载:
    *        单实例bean:默认在容器启动的时候创建对象;
    *        懒加载:容器启动不创建对象。第一次使用(获取)Bean创建对象,并初始化;
    * 
    */
   @Lazy
   @Bean("person")
   public Person person(){
      System.out.println("给容器中添加Person....");
      return new Person("张三", 25);
   }
@Conditional
MainConfig2


//类中组件统一设置。满足当前条件,这个类中配置的所有bean注册才能生效;
@Conditional({WindowsCondition.class})
@Configuration
public class MainConfig2 {
   
   
   /**
    * @Conditional({Condition}) : 按照一定的条件进行判断,满足条件给容器中注册bean
    * 
    * 如果系统是windows,给容器中注册("bill")
    * 如果是linux系统,给容器中注册("linus")
    */
   
   @Bean("bill")
   public Person person01(){
      return new Person("Bill Gates",62);
   }
   
   @Conditional(LinuxCondition.class)
   @Bean("linus")
   public Person person02(){
      return new Person("linus", 48);
   }
}
LinuxCondition


//判断是否linux系统
public class LinuxCondition implements Condition {

   /**
    * ConditionContext:判断条件能使用的上下文(环境)
    * AnnotatedTypeMetadata:注释信息
    */
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
      // TODO是否linux系统
      //1、能获取到ioc使用的beanfactory
      ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
      //2、获取类加载器
      ClassLoader classLoader = context.getClassLoader();
      //3、获取当前环境信息
      Environment environment = context.getEnvironment();
      //4、获取到bean定义的注册类
      BeanDefinitionRegistry registry = context.getRegistry();
      
      String property = environment.getProperty("os.name");
      
      //可以判断容器中的bean注册情况,也可以给容器中注册bean
      boolean definition = registry.containsBeanDefinition("person");
      if(property.contains("linux")){
         return true;
      }
      
      return false;
   }
WindowsCondition
//判断是否windows系统
public class WindowsCondition implements Condition {

   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
      Environment environment = context.getEnvironment();
      String property = environment.getProperty("os.name");
      if(property.contains("Windows")){
         return true;
      }
      return false;
   }

}
@Import
MainConfig2
@Configuration
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
//@Import导入组件,id默认是组件的全类名
public class MainConfig2 {
   
   /**
    * 给容器中注册组件;
    * 1)、包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)[只能注册自己写的类]
    * 2)、@Bean[导入的第三方包里面的组件]
    * 3)、@Import[快速给容器中导入一个组件]
    *        1)、@Import(要导入到容器中的组件);容器中就会自动注册这个组件,id默认是全类名
    *        2)、ImportSelector:返回需要导入的组件的全类名数组;
    *        3)、ImportBeanDefinitionRegistrar:手动注册bean到容器中
    */
   @Bean
   public ColorFactoryBean colorFactoryBean(){
      return new ColorFactoryBean();
   }
}
MyImportSelector


//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {

   //返回值,就是到导入到容器中的组件全类名
   //AnnotationMetadata:@Import引入MyImportSelector的类的所有注解信息
   @Override
   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
      //importingClassMetadata.get
      //方法不要返回null值,不然会报错
      return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
   }

}
MyImportBeanDefinitionRegistrar


public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

   /**
    * AnnotationMetadata:当前类的注解信息
    * BeanDefinitionRegistry:BeanDefinition注册类;
    *        把所有需要添加到容器中的bean;调用
    *        BeanDefinitionRegistry.registerBeanDefinition手工注册进来
    */
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      
      boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
      boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
      if(definition && definition2){
         //指定Bean定义信息;(Bean的类型,Bean。。。)
         RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
         //注册一个Bean,指定bean名
         registry.registerBeanDefinition("rainBow", beanDefinition);
      }
   }

}
public class Color {
   
   private Car car;

   public Car getCar() {
      return car;
   }

   public void setCar(Car car) {
      this.car = car;
   }

   @Override
   public String toString() {
      return "Color [car=" + car + "]";
   }
   
}
public class Blue {
   
   public Blue(){
      System.out.println("blue...constructor");
   }
   
   public void init(){
      System.out.println("blue...init...");
   }
   
   public void detory(){
      System.out.println("blue...detory...");
   }
   
}
FactoryBean
MainConfig2
@Configuration
public class MainConfig2 {
  
   
   /**
    * 给容器中注册组件;
    * 1)、包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)[自己写的类]
    * 2)、@Bean[导入的第三方包里面的组件]
    * 3)、@Import[快速给容器中导入一个组件]
    *        1)、@Import(要导入到容器中的组件);容器中就会自动注册这个组件,id默认是全类名
    *        2)、ImportSelector:返回需要导入的组件的全类名数组;
    *        3)、ImportBeanDefinitionRegistrar:手动注册bean到容器中
    * 4)、使用Spring提供的 FactoryBean(工厂Bean);
    *        1)、默认获取到的是工厂bean调用getObject创建的对象
    *        2)、要获取工厂Bean本身,我们需要给id前面加一个&
    *           &colorFactoryBean
    *
    * 虽然这里装配的是ColorFactoryBean,但实际上beand的类型是Color
    */
   @Bean
   public ColorFactoryBean colorFactoryBean(){
      return new ColorFactoryBean();
   }

}
ColorFactoryBean
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

   //返回一个Color对象,这个对象会添加到容器中
   @Override
   public Color getObject() throws Exception {
      // TODO Auto-generated method stub
      System.out.println("ColorFactoryBean...getObject...");
      return new Color();
   }

   @Override
   public Class<?> getObjectType() {
      // TODO Auto-generated method stub
      return Color.class;
   }

   //是单例?
   //true:这个bean是单实例,在容器中保存一份
   //false:多实例,每次获取都会创建一个新的bean;
   @Override
   public boolean isSingleton() {
      // TODO Auto-generated method stub
      return false;
   }

}