Spring框架基础知识总结（一）

#spring

1.什么是Spring框架？

他是一个企业级、一站式非入侵性的框架，提供了从表现层-springMVC到业务层-spring再到持久层-springData的一套完整的解决方案。他的两大核心是：IOC（控制反转）或DI（注入依赖）和AOP（面向切面编程）。

2.spring框架的优势

1. ​方便解耦，简化开发
2. ​AOP编程的支持
3. ​声明式事务的支持
4. ​方便程序的测试

3.spring框架的核心包

 1.spring-core.jar        spring的核心jar包（工具类）
 2. spring-beans.jar        配置文件、创建和管理bean及IOC所需要的类
 3. spring-context.jar       上下文的jar（spring核心扩展包）
 4. spring-aop.jar               使用Spring的AOP特性时所需的类
 5. spring-expression.jar      spring表达式语言
 6. commons-login.jar     日志jar包
 7. spring-webmvc.jar 		Spring MVC框架相关的所有类

4.IOC

控制反转，把创建对象的权利交给框架，是框架的重要特征。是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。最常见的方式是依赖注入（Dependency Injection ,简称DI）。还有一种方式叫依赖查找（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它，也可以说依赖被注入到对象中。

作用：减少代码间的耦合

5.spring中实例化对象的几种方式

1. 通过无参构造来实例化对象(重点)

例如获取时间类的对象

<!-- 使用无参构造器创建对象 -->
<bean id="date" class="java.util.Date"></bean>

测试方法中获取该类的对象
 AbstractApplicationContext ac= new ClassPathXmlApplicationContext("applicationContext.xml");
 Date bean = ac.getBean("date",Date.class);

2. 通过静态工厂来实例化对象（了解）

注意：

• 使用静态工厂方法创建Bean实例时，class属性也必须指定，但此时class属性并不是指定Bean实例的实现类，而是静态工厂类，Spring通过该属性知道由哪个工厂类来创建Bean实例。

• 除此之外，还需要使用factory-method属性来指定静态工厂方法，Spring将调用静态工厂方法返回一个Bean实例，一旦获得了指定Bean实例，Spring后面的处理步骤与采用普通方法创建Bean实例完全一样。如果静态工厂方法需要参数，则使用<constructor-arg…/>元素指定静态工厂方法的参数。

	<!-- 使用静态工厂方法创建对象 -->
	<bean id="cal1" class="java.util.Calendar" factory-method="getInstance"></bean> <!--必须是静态的方法-->

3. 通过实例化工厂的方式来进行（了解）

• 实例工厂方法与静态工厂方法只有一个不同：调用静态工厂方法只需使用工厂类即可，而调用实例工厂方法则需要工厂实例。使用实例工厂方法时，配置Bean实例的<bean…/>元素无须class属性，配置实例工厂方法使用factory-bean指定工厂实例。
• 采用实例工厂方法创建Bean的<bean…/>元素时需要指定如下两个属性： 1). factory-bean: 该属性的值为工厂Bean的id;
  2). factory-method: 该属性指定实例工厂的工厂方法。
  若调用实例工厂方法时需要传入参数，则使用<constructor-arg…/>元素确定参数值。

 <!-- 使用实例工厂方法创建对象 -->
 <bean id="date" class="java.util.Date"></bean>
	<bean id="time" factory-bean="date1" factory-method="getTime" > </bean>

6.作用域

• 默认情况下，容器对一个bean，只会创建一个是实例（单利模式），即bean中scope的属性为“scope=singleton”(缺省值)
• prototype（原型）：scope=“prototype”，一个bean会创建多个实例，调用一次创建一次
• request：该属性仅对HTTP请求产生作用，使用该属性定义Bean时，每次HTTP请求都会创建一个新的Bean，适用于WebApplicationContext环境。
• session：该属性仅用于HTTP Session，同一个Session共享一个Bean实例。不同Session使用不同的实例。
• global-session：该属性仅用于HTTP Session，同session作用域不同的是，所有的Session共享一个Bean实例。

7.生命周期

• 初始化：分配资源

init-method="init"    //init是初始化的方法的名称

• 销毁：释放资源

destory-method="destory"     //destory是销毁方法的名称

• 延迟加载

 lazy-init="ture"   //如果为false则不会发生

注意：spring容器在启动的时候会先检查一遍，将所有为单例作用域的对象创建好，但是多对象的不会管
但是使用延迟加载后，在容器启动时就不会创建对象，而是在调用的时候进行创建对象（即调用getBean的时候创建）

9.依赖注入的几种方式

（依赖注入的底层是通过反射调用无参构造的方式实现的，即IOC中定义bean的前提是：必须提供无参构造 ）

• set方式注入
  1.提供相应的set属性
  2.配置property属性

注意：普通的8中基本类型，直接使用value="“就好了，ref=”"主要是针对于引用类型

• 构造器注入：通过构造方法赋值

package cn.tedu.wjh;
public class Student {//一个学生类
	private String name;
	private int age;
	private  String gender;
	public Student(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}

配置文件

<bean id="stu" class="cn.tedu.wjh.Student">
		<constructor-arg value="小明" index="0"></constructor-arg>
		<constructor-arg value="34" index="1"></constructor-arg>
		<constructor-arg value="男" index="2"></constructor-arg>
	</bean>

构造器注入时，添加的元素的默认顺序和构造方法中的顺序是一致的，但是为了防止后续出错和，通常会加上标志元素，如：index，name，type来进行区别，但是为了提高代码的可读性和更高的可靠性，通常推荐 使用name

• p命名空间注入：

  1.首先要配置文件中加一个东西
  
         2.使用方式

<bean id="stup" class="cn.tedu.wjh.Student"  p:name="王涛"  p:age="23"  p:gender="男"></bean>
<!--注意，标签p之间要用空格隔开，如果是引用类型（例如：Student类中有一个属性 private Teacher teacher），那么使用p标签赋值的时候可以使用p:teacher-ref=""的这种形式-->

• 自动装配(只适用于ref类型<引用类型>)
  约定优于配置
  1.byName

Teacher类中有一个ref属性student（属性名），并且该IOC容器中恰好有一个bean的id也叫student，机bean的id的值=该属性值（autowire=“byName”）

	<!-- 自动装配 -->
	<bean id="student" class="cn.tedu.wjh.Student">
		<property value="zp小明" name="name"></property>
		<property value="73" name="age"></property>
		<property value="zp男" name="gender"></property>
	</bean>
	<bean id="teacher" class="cn.tedu.wjh.Teacher" autowire="byName"></bean>
	<!--自动寻找：其他bean的id=该Teacher类的属性名-->
	<!--byName的本质是byId-->

2.byType

其他bean的类型（class） 是否与该 Teacher类的ref属性一致（注意：此种方式 必须满足：当前IOC容器中只能有一个bean满足条件）

3.Constructor

其他bean的类型（class） 是否与该 Teacher类的构造方法的参数 的类型一致（本质就是byType）

4.全局自动装配

• 使用注解
  （具体请看下一篇分析）
  例题：

例题一：注入各种集合的数据类型：List、set、map、properties、数组
set、list、数组 各自都有自己的标签： ,但是也可以混着用
map的标签比较特殊：

	<!-- set方式注入（内涵集合等的测试 ） -->
	<bean id="Source" class="cn.tedu.wjh.Source">
		<property name="listEement">
			<list>
				<value>足球1</value>
				<value>篮球1</value>
				<value>棒球1</value>
			</list>
		</property>
		<property name="setElement">
			<set>
				<value>足球2</value>
				<value>篮球2</value>
				<value>棒球2</value>
			</set>
		</property>
		<property name="arrayElement">
			<array>
				<value>足球3</value>
				<value>篮球3</value>
				<value>棒球3</value>
			</array>
		</property>
		<property name="mapElement">
			<map>
				<entry>
					<key>
						<value>foot</value>
					</key>
					<value>足球4</value>
				</entry>
				<entry>
					<key>
						<value>lanqiu</value>
					</key>
					<value>篮球4</value>
				</entry>
				<entry>
					<key>
						<value>bangqiu</value>
					</key>
					<value>棒球4</value>
				</entry>
			</map>
		</property>
	</bean>

• *但是推荐使用下面这种方式：引用方式注入集合类型的值 （和上面de一个道理，就不再一一叙述了）

<--配置文件中新引入两个东西-->
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">

注意：在给对象类型赋值时：null—>(没有value) 赋空值“”-------->

package cn.tedu.wjh;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Source {
	private List<String> listEement;
	private Set<String> setElement;
	private String[] arrayElement;
	private Map<String, String> mapElement;

	public Source() {
		// TODO Auto-generated constructor stub
	}

	public Source(List<String> listEement, Set<String> setElement, String[] arrayElement,
			Map<String, String> mapElement) {
		super();
		this.listEement = listEement;
		this.setElement = setElement;
		this.arrayElement = arrayElement;
		this.mapElement = mapElement;
	}

	public List<String> getListEement() {
		return listEement;
	}

	public void setListEement(List<String> listEement) {
		this.listEement = listEement;
	}

	public Set<String> getSetElement() {
		return setElement;
	}

	public void setSetElement(Set<String> setElement) {
		this.setElement = setElement;
	}

	public String[] getArrayElement() {
		return arrayElement;
	}

	public void setArrayElement(String[] arrayElement) {
		this.arrayElement = arrayElement;
	}

	public Map<String, String> getMapElement() {
		return mapElement;
	}

	public void setMapElement(Map<String, String> mapElement) {
		this.mapElement = mapElement;
	}

	@Override
	public String toString() {
		String strContent = "";
		for (String string : arrayElement) {
			strContent += string;
		}

		return "list=" + listEement + ", \nset=" + setElement + ", \narray=" + strContent + ", \nmap=" + mapElement;
	}

}

Source sou = ac.getBean("Source",Source.class);
		System.out.println(sou);

运行结果如下：