Spring框架基础

1.JavaBean:

符合一定规范的（结构雷同）的简单Java对象，有时候也称为POJO对象。必须有包（package），必须有无参数构造器(方便子类的继承和创建，方便利用无参数构造器创建对象)，实现序列化接口(方便底层自动调用对象的序列化功能)，属性有get和set访问方法(get set 方法声明的属性称为“Bean属性”, 类中声明的实例变量称为“对象属性”)。

2.Spring核心功能：

Spring 内部提供了一个JavaBean对象容器（集合）由于创建和管理对象。需要提供配置文件（xml文件），Spring根据配置文件创建和管理对象。

3.使用Spring:

1)导入Spring框架API

                <dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.10.RELEASE</version>
		</dependency>

2)创建一个符合要求JavaBean

3)创建一个XML文件，告诉Spring创建哪些对象

    <bean id="obj1" class="day01.HelloWorld"/></beans>

4)启动Spring容器，Spring会根据XML文件创建对象

                ClassPathXmlApplicationContext ctx;
		@Before //在测试案例之前执行
		public void initCtx() {
			//初始化Spring容器, 需要提供配置文件,默认位置为 resources
			ctx =new ClassPathXmlApplicationContext("applicationContext.xml");
		}
		@After //在测试案例之后执行
		public void destroy() {
			ctx.close(); //关闭Spring容器，会销毁Bean对象
		}

5. 从Spring获得创建对象

        @Test
		public void testHelloWorld() {
			//Spring中就已经创建了 HelloWorld对象，利用ID获取Spring中创建的对象
			HelloWorld obj=(HelloWorld)ctx.getBean("obj1");
			//检查是否成功创建了对象
			System.out.println(obj); 
		}

4.Spring 容器

Spring 核心功能是管理JavaBean对象，由于其内部缓存了JavaBean对象，所以称为为 JavaBean 容器。

Spring可以创建JavaBean对象，也称为BeanFactory（JavaBean的工厂），后来Spring在BeanFactory基础上扩展了接口 ApplicationContext，常用实现类是 ClassPathXmlApplicationContext。
           ClassPathXmlApplicationContext 是Spring容器、Bean容器也是Bean工厂。

5.Spring 容器功能使用

1)Spring 配置文件用于声明JavaBean对象

<bean id="obj1" class="day01.HelloWorld"/>

2)Spring配置文件中 id 属性和name属性功能一样常用的属性是id

<!-- id 属性和 name属性作用一样 -->
		<bean name="obj2" class="day01.HelloWorld"/>

3)Spring容器提供了多个获取Bean对象的方法：

    //返回是Object类型需要进行类型转换
    Object bean = ctx.getBean("BeanID")
    //返回具体类型的Bean对象		
    类型 obj = ctx.getBean("BeanID", 类型)

案例:

 
	<!-- 利用配置文件，告诉Spring管理哪些JavaBean对象 -->
	<bean id="obj1" class="day01.HelloWorld"/>
	<!-- id 属性和 name属性作用一样 -->
	<bean name="obj2" class="day01.HelloWorld"/>
	@Test
	public void testName() {
		//利用name属性获取Spring容器中的对象
		HelloWorld obj=(HelloWorld)ctx.getBean("obj2");
		//检查是否成功创建了对象
		System.out.println(obj); 
	}
	@Test
	public void testGetBean() {
		//Spring容器提供了多个获取Bean对象的方法：
		HelloWorld bean1 = (HelloWorld)ctx.getBean("obj1");
		System.out.println(bean1);
		//返回具体类型的方法，无需类型转换（常用）
		HelloWorld bean2 = ctx.getBean("obj1", HelloWorld.class);
		System.out.println(bean2); 
	}

6.Spring 创建对象的方式

1)利用无参数构造器创建对象
        默认情况下，Spring会自动调用（反射调用）无参数构造器创建对象。
2)利用静态工厂方法创建对象, Spring可以利用工厂方法来创建对象
        “工厂方法” 创建对象方法称为工厂方法。

//配置文件：
<!-- Spring利用静态工厂方法创建对象 -->
<bean id="cal1" class="java.util.Calendar" factory-method="getInstance"/> 
//测试案例：
@Test 
public void testCalendar() {
	//静态方法getInstance()，来创建Calendar对象，创建对象的静态方法称为，静态工厂方法。
	//Calendar cal = Calendar.getInstance();
	//Spring支持静态工厂方法，调用静态工厂方法将创建的对象放到Spring容器管理，提供给外部使用。
	Calendar cal1 = ctx.getBean("cal1", Calendar.class);
	System.out.println(cal1); 
}

3. 利用对象工厂方法创建对象
        利用对象提供的工厂方法创建另外一个对象。

    <!-- 利用Bean对象cal1提的工厂方法创建对象 -->
		<bean id="date1" factory-bean="cal1"factory-method="getTime"/>
		@Test
		public void testFactoryBean() {
			//测试利用Spring调用Bean对象的工厂方法创建对象
			Date date = ctx.getBean("date1", Date.class);
			System.out.println(date); 
		}

7.单例与多例

单例的特点：

1. 资源占用少， 一个对象可以被复用。
2. 并发访问时候，单例对象的属性可能出现并发访问问题。

多个实例：
1. 每个实例都有一组数据，资源占用高，可以保持多个状态
2. 如果每个线程访问一个实例，就没有线程并发安全问题

> Spring默认情况下按照单例管理对象！

<!-- scope="prototype" 属性设置后，obj3是多例的，每次getBean都会创建一个新对象-->
	<bean id="obj3" class="day01.HelloWorld" scope="prototype"/>

8.对象的生命周期管理

Spring支持对象的生命周期管理方法。生命周期管理方法用于初始化，或者回收资源。

1.默认情况下是单例对象，Spring利用属性调用初始化和销毁方法

<!-- 测试对象生命周期管理方法 -->
		<bean id="demo"	class="day01.DemoBean" init-method="init" destroy-method="destroy"/>

> 关闭容器时候调用 销毁方法。
    > 容器启动时候创建对象调用其初始化方法

2.多例对象时候，Spring只在创建对象时候调用init方法。 不会调用销毁方法

<!-- 测试对象生命周期管理方法 -->
		<bean id="demo"	class="day01.DemoBean"  scopt="prototype"
			init-method="init"  destroy-method="destroy"/>

getBean时候，创建对象并且调用init方法。如果需要执行销毁方法，只能手动执行。

9.懒惰实例化JavaBean

在第一次请求getBean时候实例化对象。按需实例化 lazy-init="true"。

1. 默认情况下Spring对于单例对象，容器启动时候立即实例化。优点是在使用对象时候，对象已经实例化，可以减少延迟，提高性能。 会占用系统资源。
2. lazy-init="true" 属性，以后按需实例化，资源占用低，获取对象慢。
3. 对于一定使用的对象，建议采用立即实例化规则
4. 对于使用少的对象建议采用懒惰实例化
5. Spring默认规则是 立即实例化

案例：

<!-- 测试对象生命周期管理方法 -->
	<bean id="demo"	class="day01.DemoBean" lazy-init="true" 
        init-method="init" destroy-method="destroy"/>

 

10.IOC/DI

控制反转 IOC：由Spring创建对象称为控制反转。

依赖注入DI：由Spring帮助建立对象的依赖关系。

DI 的优势：解耦，将软件组件从紧耦合转换为松耦合关系。

在Spring配置文件中利用 IOC/DI 解决依赖关系:

		<bean id="axe" class="day02.Axe"/>	
		<bean id="saw" class="day02.Saw"/>
		<bean id="qiang" class="day02.Worker">
			<!-- 依赖注入DI：由Spring帮助建立对象的依赖关系 -->
			<!-- spring会自动调用 setTool 方法注入 axe 引用 -->
			<property name="tool" ref="saw"/> 
		</bean>

 

11.构造器参数注入

Spring支持 利用 构造器创建对象：constructor-arg 子元素，其中index="0"用于指定参数在构造器参数的位置。

配置:

                <bean id="xiong" class="day02.Worker" lazy-init="true">
			<!-- 构造器参数注入，也就是调用有参数构造器创建对象 -->
			<constructor-arg index="0" value="熊大"/>
			<property name="tool" ref="saw"/> 
		</bean>

12.按照名字自动注入

Spring支持自动按照名字注入功能，Spring会自动检查Bean属性和Bean ID的匹配，如果匹配上就自动完成注入。

优点：自动注入可以减少XML文件的编写量。

编写配置文件:

                <bean id="tool" class="day02.Axe" lazy-init="true"/>
		<!-- autowired="byName" 自动按Bean属性名字和id的名字进行自动注入：
                bean属性叫tool匹配ID tool称为按照名字自动装配  autowire="byName"-->
		<bean id="tom" class="day02.Worker"  autowired="byName"/>

13.按照类型自动注入

为了实现按照类型注入，需要利于新的配置文件完成测试：

1. 编写 applicationContext1.xml

                <!-- 测试  autowire="byType" 按照类型自动装配，解决对象的依赖关系 -->
		<bean class="day02.Axe"/>	
		<bean id="tom" class="day02.Worker"  autowired="byType"/>

14.Spring基本值注入

Spring支持为Bean注入基本类型参数， 这里的基本类型包括：8个基本类，8个包装类型，String类型。Spring注入基本值时候也是调用的“Bean属性”方法实现的。

1. 配置 :

<!-- 测试基本值的注入 基本值包含：8个基本类，8个包装类型，String类型 -->
		<bean id="andy" class="day02.Worker" lazy-init="true">
			<!-- 注入 JavaBean 对象，使用ref属性 -->
			<property name="tool" ref="axe"></property>
			<!-- 注解基本值，使用value属性 -->
			<property name="name" value="熊二"></property>
			<property name="age" value="10"></property>
		</bean>

15.Spring 表达式

Spring表达式的语法与EL表达式类似：

1. EL表达式： ${}  Spring表达式： #{}
2. Spring表达式也可以读取
    - Bean属性: #{qiang.name}  #{qiang['name']}
    - 数组元素: #{arr[0]}
    - List元素: #{list[1]}
    - Map(Properties)元素: #{jdbc.username} #{jdbc['username']} 
3. 在Spring文件中，可以利用Spring表达式，将一个Bean对象的属性，赋值给另外一个Bean。