Spring之IOC和相关注解

1.Spring的核心

IOC:控制反转,把创建对象的权利交给spring工厂,让别人(spring工厂)为你服务

AOP:控制反转,基于动态代理的功能增强模式

2.spring的核心配置文件

文件名applicationContext.xml,通常放到src目录下.

把类交给spring管理,xml配置方式如下:







通过spring工厂获取对象

//spring配置方式,创建spring工厂,加载spring配置文件
	 ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	 //从spring工厂中获取对象,通过bean的id/name
	 IUserDAO userDAO = (IUserDAO) ac.getBean("userDAO");
	 userDAO.findUserByUsernameAndPassword();

3.依赖注入DI

在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件(简单的说,可以将另外一个bean对象动态的注入到另外一个bean中)

步骤1:将要注入的对象也是交给spring管理的,此外通过配置property标签注入








	
	
	
	
	


步骤2:property是根据setter方法注入,在使用的时候定义属性并提供setter方法,然后就可以直接使用

public class UserServiceImpl implements IUserService{
	
	//定义属性
	private IUserDAO userDAO;

	public void setUserDAO(IUserDAO userDAO) {
		this.userDAO = userDAO;
	}

	public void login() {
		 System.out.println("UserServiceImpl-service层方法调用了");	 
		 //ioc:依赖注入
		 userDAO.findUserByUsernameAndPassword();
		
	}

测试运行,此时获取对象必须从spring工厂获取(在spring容器配置中才有依赖注入,自己创建的对象没有注入依赖关系)

 

注入除了通过setter方法注入,还可以通过构造方法注入:后续详解

4.spring的工厂

ApplicationContext直译为应用上下文,是用来加载Spring框架配置文件,来构建Spring的工厂对象,它也称之为Spring容器的上下文对象,也称之为Spring的容器。
ApplicationContext 只是BeanFactory(Bean工厂,Bean就是一个java对象) 一个子接口:

Spring之IOC和相关注解_第1张图片

开发的时候为什么不用beanFactory?

BeanFactory 采取延迟加载,第一次getBean时才会初始化Bean
        * Beanfactory的用法:
         BeanFactory ac = new XmlBeanFactory(new FileSystemResource("D:\\applicationContext.xml"));
* ApplicationContext是对BeanFactory扩展,提供了更多功能
        国际化处理
        事件传递
        Bean自动装配

        各种不同应用层的Context实现

拓展:FactortyBean是什么?

是一个接口,实例化bean的一种方式,spring在实例化Bean的时候会判断是否实现了FactoryBean接口,如果实现了就调用getObject方法返回实例

BeanFactory:是一个工厂(其实是构建了一个spring上下文的环境,容器),用来管理和获取很多Bean对象。
FactoryBean:是一个Bean生成工具,是用来获取一种类型对象的Bean,它是构造Bean实例的一种方式。

5.Bean获取的2种方式

	@Test
	public void getBean(){
		 
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//获取bean的两种方式
		//1.通过spring容器中bean的id/name获取
		//IUserService userService = (IUserService) ac.getBean("userService");
		
		//2.根据bean的类型或者bean接口的类型获取,一般使用接口类型,如果配置多个类型,则抛出异常
		IUserService userService = (IUserService) ac.getBean(IUserService.class);
		
		userService.login();
		
	}

6.实例化bean的四种方式

 1)默认使用无参构造器实例化bean,配置如下,


	
	

使用方式:
 public  void test(){
//创建spring工厂
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
Bean1 bean1 = (Bean1) ac.getBean("bean1");
System.out.println(bean1);
}

如果要使用带参数的构造器,需要传递参数,通过:

        

2)静态工厂的方式

提供一个工厂类和静态的返回对象的方法
public class Bean2Factory {
	//静态方法,用来返回对象的实例
	public static Bean2 getBean2(){
		//在做实例化的时候,可以做其他的事情,即可以在这里写初始化其他对象的代码
		//Connection conn....
		return new Bean2();
	}


	
	

3)实例工厂的方法

//实例工厂:必须new工厂--》bean
 public class bean3{}
 public class Bean3Factory {
	//普通的方法,非静态方法
	public Bean3 getBean3(){
		//初始化实例对象返回
		return new Bean3();
	}
}


	
	
	

4)factoryBean的方式

/4实现FactoryBean接口的方式
//泛型:你要返回什么类型的对象,泛型就是什么
public class Bean4FactoryBean implements FactoryBean{
	//用来获取bean的实例,对象
	public Bean4 getObject() throws Exception {
		//写一些初始化数据库连接等等其他代码
		return new Bean4();
	}
	public Class getObjectType() {
		return null;
	}
	public boolean isSingleton() {
		return false;
	}
}

	
	

7.bean的作用域

意思就是spring创建的bean在什么情况下有效

Spring之IOC和相关注解_第2张图片

singleton 单例、 prototype多例
        Singleton: 在一个spring容器中,对象只有一个实例。(默认值
        Prototype: 在一个spring容器中,存在多个实例,每次getBean 返回一个新的实例。

xml配置方式:scope,不写默认单例

   
	
	
	
	
	

8.spring中bean的生命周期

spring实例化bean的过程:

第一:如果你使用BeanFactory作为Spring Bean的工厂类,则所有的bean都是在第一次使用getBean的时候实例化
第二:如果你使用ApplicationContext作为Spring Bean的工厂类,则又分为以下几种情况:
    (1):如果bean的scope是singleton的,并且lazy-init为false(默认是false,所以可以不用设置),则 ApplicationContext启动的时候就实例化该Bean,并且将实例化的Bean放在一个map结构的缓存中,下次再使用该Bean的时候, 直接从这个缓存中取
       (2):如果bean的scope是singleton的,并且lazy-init为true,则该Bean的实例化是在第一次使用该Bean的时候进行实例化
        (3):如果bean的scope是prototype的,则该Bean的实例化是在第一次使用该Bean的时候进行实例化

 

bean的生命周期:

 

beanFactoryPostProcessor接口构造

   beanFactoryPostProcessor接口的postProcessBeanFactory方法

   beanPostProcessor 的构造方法

   InstantiationAwareBeanPostProcessor接口的构造方法

   InstantiationAwareBeanPostProcessor接口的前置方法

   bean构造方法

   InstantiationAwareBeanPostProcessor接口的postProcessPropertyValue方法

   setter方法属性注入

   BeanNameAware接口 setBeanName

   BeanFactoryAware接口 setBeanFactory

   beanPostProcessor 的前置方法

   @PostConstruct

   initialzing bean 的afterPropertitySet

   init-method方法

   beanPostProcessor 的后置方法

   InstantiationAwareBeanPostProcessor接口的后置方法

   -------------初始化成功,下面执行销毁

   @PreDestroy注解的方法

   disposableBean的destory方法

   destory-method的销毁方法

 

初始化和销毁方法的配置:指定方法名

销毁方法的执行必须满足两个条件:
        1)单例(singleton)的bean才会可以手动销毁。
        2)必须手动关闭容器(调用close的方法)时,才会执行手动销毁的方法。

9.后处理Bean(BeanPostProcessor接口)
   后处理Bean也称之为Bean的后处理器,作用是:在Bean初始化的前后,对Bean对象进行增强。它既可以增强一个指定的Bean,也可以增强所有的Bean,底层很多功能(如AOP等)的实现都是基于它的,Spring可以在容器中直接识别调用。
       

public class MyBeanPostProcessor implements BeanPostProcessor{

	//初始化时(之前)调用的
	//参数1:bean对象,参数2,bean的名字,id、name
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
//		System.out.println(beanName+"在初始化前开始增强了");
		//如何只增强一个bean
		if(beanName.equals("lifeCycleBean")){
			System.out.println(beanName+"在初始化前开始增强了");
		}
		return bean;//放行
	}

	//初始化时(之后)调用
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
//		System.out.println(beanName+"在初始化后开始增强了");
		if(beanName.equals("lifeCycleBean")){
			System.out.println(beanName+"在初始化后开始增强了");
		}
		return bean;
	}

}

10 bean属性的注入的3中方式

setter方法注入:bean提供setter方法

构造方法注入:bean提供构造方法

接口注入(x)


	
		
		
		
		
		
			宝马2代
		
		
	

	
		
		
		
		
		
			
		
	

11.注册bean的注解

注解的使用之前:需要开启spring注解功能

 

        

        

bean的注册:@component, @Controller, @Service, @Repository

 

@Component注解放置到类上
         * 相当于spring容器中定义:
         * 其中id属性默认bean的名字是类名的小写
     
 @Component(value="customerService")//自定义bean的名字

         * 相当于spring容器中定义:

 

 

12.注入bean的注解

bean的注入:@Autowired, @Value+SPEL表达式,@Resource,@inject

 

bean的注入

方式1:@value+SPEL表达式,spring3.0之后,其中customerDao表示节点id的属性值

    @Value("#{customerDao}")

        private CustomerDao customerDao;
方式2:

    @Autowired//默认按照类型注入(用的做多)

        private CustomerDao customerDao;

或者使用spring的@Autowired 结合 @Qualifier,则根据名字注入

        @Autowired//默认按照类型注入的

        @Qualifier("customerDao")//必须配合@Autowired注解使用,根据名字注入

        private CustomerDao customerDao;

方式3:JSR-250标准(jdk) 提供@Resource
        @Resource//默认先按照名称进行匹配,再按照类型进行匹配
        private CustomerDao customerDao;

    如果@Resource注解上添加name名称,则按照名称注入,会到spring容器中查找customerDao的名称,对应,id的属性值,如果找到,可以匹配。 如果没有找到,抛出异常。
        @Resource(name="customerDao")//只能按照customerDao名称进行匹配
        private CustomerDao customerDao;

方式4:需要导入javax.inject的jar包
        @Inject//默认按照类型注入

        private CustomerDao customerDao;

        使用@inject和@Named注解,则按照名称注入
        @Inject//默认按照类型注入

        @Named("customerDao")//按照名字注入,必须配合@Inject使用

          private CustomerDao customerDao;

 

 

小拓展:关于@Resource注解的使用

@Resource完成Map的注入

	@Resource(name="requestUrlMap"); //通过Resource注解可以自动注入Map中值
	private Map urlMap = new HashMap();
	
	@Resouce(name="myObjectMap")
	private Map myObject = new HashMap();
	
	public void show(){
		String str = urlMap.get("HF-SAS");
		System.out.println(str);//打印/rqeust/sas/queryInfo
		
	}

XML的配置


	
		
			
			
		
	

---------------------------------------------------------------------------------------


	
		
			
		
	



	
		HELLO_WORLD
	

 

 

 

 

 

13.bean的初始化和销毁的注解

初始化和销毁@PostContruct ,@PreDestory

        (1)当bean被载入到容器的时候调用setup ,
        注解方式如下:
        @PostConstruct
        初始化
        (2)当bean从容器中删除的时候调用teardown(scope= singleton有效)
        注解方式如下:
        @PreDestroy  

        销毁

@Component("lifeCycleBean")
		public class LifeCycleBean {
			
			public LifeCycleBean() {
				System.out.println("LifeCycleBean构造器调用了");
			}
			
			//初始化后自动调用方法:方法名随意,但也不能太随便,一会要配置
			@PostConstruct//初始化的方法
			public void init(){
				System.out.println("LifeCycleBean-init初始化时调用");
			}
			
			//bean销毁时调用的方法
			@PreDestroy
			public void destroy(){
				System.out.println("LifeCycleBean-destroy销毁时调用");
			}

		}

14.bean的作用域的注解

        @Component("lifeCycleBean")
        //@Scope(value=ConfigurableBeanFactory.SCOPE_PROTOTYPE)
        @Scope("prototype")//默认是单例(singleton),更改为多例(prototype)
        public class LifeCycleBean {

        }

 

15.spring与web集成

将Spring容器绑定到Web Servlet容器上,让Web容器来管理Spring容器的创建和销毁

 
          
              org.springframework.web.context.ContextLoaderListener
          
          
          
              contextConfigLocation
              
              classpath:applicationContext.xml
          

16.spring集成junit测试

使用spring和junit集成 
		第一步:项目导入junit 开发包 
		第二步:导入spring-test-3.2.0.RELEASE.jar 
		第三步: 通过@RunWith注解,使用junit整合spring
		         通过@ContextConfiguration注解,指定spring容器的位置
		//目标:测试一下spring的bean的某些功能
		@RunWith(SpringJUnit4ClassRunner.class)//junit整合spring的测试//立马开启了spring的注解
		@ContextConfiguration(locations="classpath:applicationContext.xml")//加载核心配置文件,自动构建spring容器
		public class SpringTest {
			//使用注解注入要测试的bean
			@Autowired
			private HelloService helloService;
			
			@Test
			public void testSayHello(){
				//测试业务功能
				helloService.sayHello();
				
			}

 

你可能感兴趣的:(spring)