轻量级框架SSH应用与开发——Spring之学习总结（初阶）

Spring概述

Spring是一个轻量级的IoC（控制反转）和AOP（面向切面）的容器框架。具有如下几个特点：

1.轻量：从大小与开销两方面而言都死轻量的。

2.控制反转：Spring通过一种称作IoC（控制反转）的技术促进了松耦合。

3.面向切面：Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑和系统级服务（例如事务）进行内聚性的开发。

4.容器：Spring包含并管理应用对象的配置和生命周期，在这个意义上Spring只是一种容器。

Spring为企业级来发提供一个轻量级的解决方案，主要包括以下功能：

1.基于依赖注入的核心功能；

2.声明式的面向切面鞭策和国内（AOP）支持；

3.与多种持久层技术的整合；

4.独立的Web MVC框架。

Spring体系结构

maven依赖如下：

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.10.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.5.4</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.3.10.RELEASE</version>
		</dependency> 
		<dependency>
    		<groupId>c3p0</groupId>
    		<artifactId>c3p0</artifactId>
   			<version>0.9.1.2</version>
		</dependency>

IoC容器

Spring框架的核心功能就是IoC，AOP和声明式事务等功能都依赖于IoC实现的基础上。控制反转的含义所在，即控制权由应用代码中转到了外部容器，控制权的转移就是反转。控制权的转移的意义是降低了业务对象之间的依赖程度。

配置依赖注入

Order.java

package com.lxj.www;

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

public class Order {
	private int id;			//构造方法注入
	private String orderNum;//构造方法注入
	private double amount;
	private OrderItem orderItem;
	private Date orderDate;//自动装配
	
	private Object[] myArray;
	private List<?> myList;
	private Set<?> mySet;
	private Map<?, ?> myMap;
	private Properties myProp;

	public Order(int id, String orderNum) {
		super();
		this.id = id;
		this.orderNum = orderNum;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getOrderNum() {
		return orderNum;
	}
	public void setOrderNum(String orderNum) {
		this.orderNum = orderNum;
	}
	public double getAmount() {
		return amount;
	}
	public void setAmount(double amount) {
		this.amount = amount;
	}
	public OrderItem getOrderItem() {
		return orderItem;
	}
	public void setOrderItem(OrderItem orderItem) {
		this.orderItem = orderItem;
	}
	public Object[] getMyArray() {
		return myArray;
	}
	public void setMyArray(Object[] myArray) {
		this.myArray = myArray;
	}
	public List<?> getMyList() {
		return myList;
	}
	public void setMyList(List<?> myList) {
		this.myList = myList;
	}
	public Set<?> getMySet() {
		return mySet;
	}
	public void setMySet(Set<?> mySet) {
		this.mySet = mySet;
	}
	public Map<?, ?> getMyMap() {
		return myMap;
	}
	public void setMyMap(Map<?, ?> myMap) {
		this.myMap = myMap;
	}
	public Properties getMyProp() {
		return myProp;
	}
	public void setMyProp(Properties myProp) {
		this.myProp = myProp;
	}
	public Date getOrderDate() {
		return orderDate;
	}
	public void setOrderDate(Date orderDate) {
		this.orderDate = orderDate;
	}	
	
}

bean.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd">
						
 	<bean id="order" class="com.lxj.www.Order" autowire="byName">
 		<!-- 构造方法注入，注入值类型：字面值 -->
		<constructor-arg name="id" value="100"></constructor-arg>
		<constructor-arg name="orderNum" value="sp1234"></constructor-arg>
		<!-- setter方法注入，注入值类型：字面值 -->
		<property name="amount" value="1234.56"></property>
		<!-- setter方法注入，注入值类型：其他bean -->
		<property name="orderItem" ref="orderItem1"></property>

		<property name="myArray">
			<array>
				<value>1234</value>
				<ref bean="orderItem1"/>
			</array>
		</property>
		<property name="myList">
			<list>
				<value>1234</value>
				<ref bean="orderItem1"/>
			</list>
		</property>
		<property name="mySet">
			<set>
				<value>1234</value>
				<ref bean="orderItem1"/>
			</set>
		</property>
		<property name="myMap">
			<map>
				<entry key="1" value="1234"></entry>
				<entry key="2" value-ref="orderItem1"></entry>
			</map>
		</property>
		<property name="myProp">
			<props>
				<prop key="aaa">AAA</prop>
				<prop key="bbb">BBBB</prop>
			</props>
		</property>
	</bean>
 
 	<bean id="orderItem1" class="com.lxj.www.OrderItem">
 		<property name="id" value="10"></property>
 		<property name="product" value="电视机"></property>
 		<property name="price" value="6000"></property>
 		<property name="count" value="4"></property>
 	</bean>
 	
 	<bean id="orderDate" class="com.lxj.www.Date">	
 	</bean>
 
</beans>

Bean之间的关系

继承

<bean id="orderItem1" class="com.lxj.www.OrderItem">
 		<property name="id" value="10"></property>
 		<property name="product" value="电视机"></property>
 		<property name="price" value="6000"></property>
 		<property name="count" value="4"></property>
 	</bean>
 	<bean id="orderItem2" parent="orderItem1">
 		<property name="price" value="5000"></property>//覆盖
 		<property name="count" value="2"></property>
 	</bean>

依赖

有时可能要求Bean A的初始化必须在Bean B的初始化之后，而B并不是A的属性，因此无法通过向A注入B来保证首先完成B的创建，为此，Spring为<Bean>元素提供的depends-on属性来指定前置依赖的Bean

 	<!-- 依赖 -->
 	<bean id="userDao" class="com.abc.dao.UserDao"></bean>
 	<bean id="userService" class="com.abc.service.UserService" depends-on="userDao"></bean>

Bean作用域

<bean id="orderDate" class="com.lxj.www.Date" scope="singleton"></bean>

singleton：一个Bean定义对应唯一一个对象实例，Bean以单实例的方式存在。

prototype：一个Bean定义对应多个对象实例，每次调用getBean()时，就创建一个新实例。

request：在一次HTTP请求中，一个Bean定义对应一个实例，即每次HTTP请求都将会有各自的实例。该作用域仅在基于Web的Spring ApplicationContext情形下有效。

session：在一次HTTP Session中，一个Bean定义对应一个实例，该作用域仅在基于Web的Spring ApplicationContext情形下有效。

自动装配

Spring IoC容器可以自动装配相互协作Bean之间的关联关系。自动让Spring通过检查BeanFactory中的内容，来指定Bean的协作者（其他被依赖的Bean），在xml配置中，autowire一共有5种类型可以指定。

no：不使用自动装配。必须通过ref元素指定依赖，这是默认设置。

byName：根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的Bean，并将其与属性自动装配。

byType：如果容器中存在一个与指定属性类型相同的Bean，那么将与该属性自动装配。如果存在多个该类型的Bean，那么将会抛除异常。若没有找到，则什么事也不会发生。

constructor：与byType类似：不同之处在于它应用与构造器参数。如果没有找到与构造器参数类型一致的Bean，那么将会抛出异常。

autodetect：通过Bean类的自省机制来决定是使用constructor还是byType。如果发现默认的构造器，那么将使用byType。