spring注解开发实例

创建对象

需要jar：spring-context，junit

创建一个实体类

public class Student {

public Student() {
}

public Student(Integer id, String name, String pass) {
this.id = id;
this.name = name;
this.pass = pass;
}

private Integer id;
private String name;
private String pass;
}

添加一个配置类

@Configuration  //告诉Spring这是一个配置类
public class BeanConfig {

//@Bean类似xml配置文件中的<bean>标签。
//返回类型类似bean的class属性。
//方法名称类似bean的id属性。
@Bean
public Student student() {
    return new Student(1, "zhangsan", "123123");
   }
}

添加一个测试类

@Test
public void test1() {
ApplicationContext ac = new AnnotationConfigApplicationContext(BeanConfig.class);
//通过类型获取对象
// Student student = ac.getBean(Student.class); 
//通过id获取对象
Student student = ac.getBean("student", Student.class); System.out.println(student);
}

自动扫描

扫描所有的包

@Configuration
@ComponentScan(basePackages = “com.znsd.annotation”)  //包扫描
public class BeanConfig {

}

排除某个包

@Configuration
@ComponentScan(basePackages = "com.znsd.annotation",
excludeFilters = {
 //排除@Controllor注解修饰的类
 @Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
})
public class BeanConfig {

}

只扫描某个包

@Configuration
@ComponentScan(basePackages = "com.znsd.annotation",
 includeFilters = {//只包含@Controllor注解修饰的类
 @Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
},useDefaultFilters = false)public class BeanConfig {

}

自定义排除规则

实现TypeFileter接口,重写typefileter的match方法

public class MyTypeFilter implements TypeFilter {
//metadataReader:读取到的当前正在扫描类的信息。
//metadataReaderFactory:可以获取到其他任何类的信息。
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
	//获取当前类的注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		//获取当前类的类的信息。
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		//获取当前类的资源(类的路径)
		Resource resource = metadataReader.getResource();
		//获取当前类的名称
		String className = classMetadata.getClassName();
		if(className.contains("Service")) {
		    return true;
		}
	return false;
	}
}

将过滤条件加入到扫描

@Configuration
@ComponentScan(basePackages = "com.znsd.annotation",includeFilters = {
//自定义过滤规则，只扫描文件名中包含了Service的类
@Filter(type = FilterType.CUSTOM,classes = {MyTypeFilter.class})
},useDefaultFilters = false)
public class BeanConfig {
}

修改对象的声明周期

需要jar:spring-webmvc

@Bean
/*
 * prototype：每次创建不同的对象。
 * singleton：单例模式（默认）。
 * request：同一个请求中一个对象，Web项目有效。
 * session：同一个会话中一个独享，Web项目有效。
 **/
@Scope("prototype")
public Student student() {
    return new Student(1, "zhangsan", "123123");
}

懒加载

默认情况（单实例情况下）下我们Spring容器中的对象都是在Spring启动时创建对象

@Bean
@Lazy  //懒加载，只对单实例方式有效。
public Student student() {
    return new Student(1, "zhangsan", "123123");
}

@Conditional

Spring中提供了一种按照一定条件进行判断，满足条件给容器注册bean，否则就不进行注册。

如果是Windows就返回true

public class ConditionWindows implements Condition{
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		Environment em = context.getEnvironment();
		if(em.getProperty("os.name").contains("Windows")) {
		    return true;
		}
	  return false;
	}
}

如果是Linux就返回true

public class ConditionLinux implements Condition{
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		Environment em = context.getEnvironment();
		if(em.getProperty("os.name").contains("Linux")) {
		    return true;
		}
	  return false;
	}
}

@Configuration
public class BeanConfig {
	@Bean
	@Conditional(ConditionWindows.class)
	public Student bill() {
	    return new Student(2,"windows","123123");
	}
	
	@Bean
	@Conditional(ConditionLinux.class)
	public Student linux() {
	    return new Student(2,"linux","123123");
	}
}

判断容器中是否存在student，如果存在则创建bill。

public class ConditionStudent implements Condition{
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {BeanDefinitionRegistry registry = context.getRegistry();
		//判断容器中是否包含student
		if(registry.containsBeanDefinition("student")) {
		    return true;
		}
	  return false;
	}
}

@Configuration
public class BeanConfig {
	@Bean
	@Conditional({ConditionWindows.class, ConditionStudent.class})
	public Student bill() {
	    return new Student(2,"bill","123123");
	}
}

@Import

@Configuration 
@Import({Color.class})  //Import方式导入组件。
public class BeanConfig2 {
}

定义一些导入规则

ImportSelector

public class MyImportSelector implements ImportSelector {
    //返回值：就是要导入到容器中的组件全类名，注意不能返回null。
    //参数：当前标注@Import注解类的所有类和注解信息。
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.znsd.spring.entile.Student","com.znsd.spring.entile.Gread"};
    }
}

@Configuration
//根据ImportSelector规则导入组件。
@Import({ Student.class, Gread.class })
public class BeanConfig2 {
   
}

ImportBeanDefinitionRegistrar

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
 	/**
	 * AnnotationMetadata：获取当前注册类的信息。
	 * BeanDefinitionRegistry：BeanDefinition注册类
	 * 把所有要添加到容器的bean；
	 * 调用BeanDefinitionRegistry手工注册进来。
	 */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        if(registry.containsBeanDefinition("com.znsd.spring.dao.Student")){
            //bean的定义信息。
            RootBeanDefinition rbd=new RootBeanDefinition(Student.class);
            //注册一个bean，并制定bean的名字。
            registry.registerBeanDefinition("student",rbd);
        }
    }
}

@Configuration
//根据ImportSelector规则导入组件。
@Import({ MyImportBeanDefinitionRegistrar.class})
public class BeanConfig2 {
   
}

FactoryBean

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

	//返回需要添加的组件
	public Color getObject() throws Exception {
	    return new Color();
	}
	
	//返回需要添加的组件类型
	public Class<Color> getObjectType() {
	    return Color.class;
	}
	
	//是否是单例模式
	public boolean isSingleton() {
	    return true;
	}
}

@Configuration
public class BeanConfig2 {
    @Bean
	public ColorFactoryBean colorFactoryBean() {
	   return new ColorFactoryBean();
	}
}

    @Test
    public void demo6(){
        ApplicationContext ac1=new AnnotationConfigApplicationContext(BeanConfig.class);
        ColorFactoryBean  colorFactoryBean= ac1.getBean(ColorFactoryBean.class);
        //如果是.class返回的是studentFactoryBean对象
        System.out.println(colorFactoryBean);
    }

  @Test
    public void demo6(){
        ApplicationContext ac1=new AnnotationConfigApplicationContext(BeanConfig.class);
        Color color=(Color)ac1.getBean("ColorFactoryBean ");
        //如果是id的值返回的是student对象
        System.out.println(color);
    }