Spring簡介
Spring 是一個開放源代碼的框架。
Spring爲簡化企業級應用開發而生，使用spring可以使簡單的javaBean實現以前只有EJB才能實現的功能。
Spring是一個IOC(DI)、AOP容器框架。
Spring是一個一站式的開發框架。
Spring是輕量級的框架 輕量級：Spring是非侵入性的-基於Spring開發的應用中的對象可以不依賴於Spring的API。（不用繼承或實現接口）。 控制反轉（DI—dependency injection、IOC—Inversion of Control） 當應用了IOC，一個對象依賴的其它對象會通過被動的方式傳遞進來，而不是這個對象自己創建（不需要自己去new對象）。 AOP（Aspect Oriented Programming ：AOP編程的支持） 通過Spring提供的AOP功能，方便進行面向切面的編程，許多不容易用傳統OOP實現的功能可以通過AOP輕鬆應付。 聲明式事務的支持 在Spring中，我們可以從單調煩悶的事務管理代碼中解脫出來，通過聲明式方式靈活地進行事務的管理，提高開發效率和質量。 方便程序的測試 可以用非容器依賴的編程方式進行幾乎所有的測試工作，在Spring裏，測試不再是昂貴的操作，而是隨手可做的事情。例如：Spring對Junit4支持，可以通過註解方便的測試Spring程序 方便集成各種優秀框架 簡化各種框架的使用難度，Spring提供了對各種優秀框架（如Struts,Hibernate、Mybatis、Quartz）等的直接支持。 |
Spring的模塊架構圖：
每個模塊的功能如下：
- l 核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要組件是 BeanFactory，它是工廠模式的實現。BeanFactory 使用控制反轉（IOC） 模式將應用程序的配置和依賴性規範與實際的應用程序代碼分開
- l Spring 上下文：Spring 上下文是一個配置文件，向 Spring框架提供上下文信息。Spring 上下文包括企業服務，例如JNDI、EJB、電子郵件、國際化、校驗和調度功能。
- l Spring AOP：通過配置管理特性，Spring AOP 模塊直接將面向切面的編程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何對象支持AOP。Spring AOP 模塊爲基於 Spring 的應用程序中的對象提供了事務管理服務。通過使用 Spring AOP，不用依賴 EJB 組件，就可以將聲明性事務管理集成到應用程序中。
- l Spring DAO：JDBCDAO抽象層提供了有意義的異常層次結構，可用該結構來管理異常處理和不同數據庫供應商拋出的錯誤消息。異常層次結構簡化了錯誤處理，並且極大地降低了需要編寫的異常代碼數量（例如打開和關閉連接）。Spring DAO 的面向 JDBC 的異常遵從通用的 DAO 異常層次結構。
- l Spring ORM：Spring 框架插入了若干個ORM框架，從而提供了 ORM 的對象關係工具，其中包括JDO、Hibernate和Mybatis。所有這些都遵從 Spring 的通用事務和 DAO 異常層次結構。
- l Spring Web 模塊：Web 上下文模塊建立在應用程序上下文模塊之上，爲基於 Web 的應用程序提供了上下文。所以，Spring框架支持與 Jakarta Struts 的集成。Web 模塊還簡化了處理多部分請求以及將請求參數綁定到域對象的工作。
- l Spring MVC 框架：MVC框架是一個全功能的構建 Web應用程序的 MVC 實現。
Spring的入門小demo
1. 創建maven web工程
2. 解決web工程的兩個問題
- jdk版本過低問題
- 丟失web.xml的問題
3. 導入我們工程必須的jar包
<dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.2.4.RELEASE</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-core --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.2.4.RELEASE</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.2.4.RELEASE</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>4.2.4.RELEASE</version> </dependency>
</dependencies>
4. 創建接口及實現類
接口：
public interface IUserDao { public void sayHello(); }
實現類：
public class UserDaoImpl implements IUserDao { private String username; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } @Override public void sayHello() { System.out.println("hello " + username); } }
5. 創建spring容器的核心配置文件applicationContext.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="userDaoImpl" class="spring.spring01.demo1.UserDaoImpl"> <property name="username" value="spring"></property> </bean> </beans>
6. 編寫測試代碼
public class UserDaoTest { @Test public void test() throws Exception { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); IUserDao bean = (IUserDao) context.getBean("userDaoImpl"); bean.sayHello(); } }
spring容器的概念及三種創建方式
核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要組件是 BeanFactory，它是工廠模式的實現。BeanFactory 使用控制反轉（IOC） 模式將應用程序的配置和依賴性規範與實際的應用程序代碼分開。
Ⅰ. XmlBeanFactory來獲取容器類
使用XmlBeanFactory來獲取我們的beanFactory(已經過期，不建議使用)
/** * 第一種方式： 使用XmlBeanFactory的方式來獲取容器類(已過期，不建議使用) * XmlBeanFactory需要傳入一個配置文件的路徑，這個配置文件就是spring的配置文件 * spring默認的配置文件是applicationContext.xml */ @Test public void test01() throws Exception { BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); Class<? extends BeanFactory> class1 = factory.getClass(); System.out.println(class1); //結果：class org.springframework.beans.factory.xml.XmlBeanFactory }
Ⅱ. ClassPathXmlApplicationContext獲取容器類
從類路徑下加載配置文件：
/** * 第二種方式：ClassPathXmlApplicationContext */ @Test public void test02() throws Exception { BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml"); Class<? extends BeanFactory> class1 = factory.getClass(); System.out.println(class1); //結果：class org.springframework.context.support.ClassPathXmlApplicationContext }
Ⅲ. FileSystemXmlApplicationContext來獲取容器
從文件系統中加載配置文件：
/** * 第三種方式：FileSystemXmlApplicationContext * 注意：這種方式需要傳入配置文件的絕對路徑 * 可以使用外部的配置文件 */ @Test public void test03() throws Exception { BeanFactory factory = new FileSystemXmlApplicationContext("D:\\source\\Web\\maven\\springStart\\src\\main\\resources\\applicationContext.xml"); Class<? extends BeanFactory> class1 = factory.getClass(); System.out.println(class1); //結果：class org.springframework.context.support.FileSystemXmlApplicationContext }
IOC
IOC：inversion of control 控制反轉：說白了就是將創建對象的過程或者說創建對象的權限交給了spring框架來幫我們處理，我們再不用通過new的方式來創建Javabean對象，這個過程就叫做控制反轉。
DI：dependency injection 依賴注入: 就是組件以一些預先定義好的方式(例如: setter 方法)接受來自如容器的資源注入。說白了就是使用spring框架爲我們的JavaBean的屬性賦值的過程。
· 默認構造器創建對象
創建bean
public class UserBean { private String info; public String getInfo() { return info; } public void setInfo(String info) { this.info = info; } public void show(){ System.out.println("show method is invoked!"); } }
配置配置文件
<!-- id：唯一標識 class：創建對象的類路徑 通過反射創建userBean對象 --> <bean id="userBean" class="spring.ioc.UserBean"> <property name="info" value="this is userBean... ... "></property> </bean>
注意：Class:bean的全類名，通過反射的方式在IOC容器中創建Bean，所以要求Bean中必須有無參的構造器。
Id:標識容器中的bean，id唯一。
從容器中獲取我們的UserBean對象
/** * 默認構造器創建對象 */ @Test public void iocTest() throws Exception { /** * 1、創建spring容器 * 2、從容器中獲取userBean的對象 * 3、調用userBean的方法 */ ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-ioc.xml"); UserBean bean = (UserBean) applicationContext.getBean("userBean"); bean.show(); System.out.println(bean.getInfo()); }
· 靜態工廠創建對象
調用靜態工廠方法創建Bean是將對象創建的過程封裝到靜態方法中。當客戶端需要對象時，只需要簡單地調用靜態方法，而不用關心創建對象的細節(往往使用工廠方法就是爲了應對創建對象比較複雜的情況)。
創建bean
public class Car { private String brand; private Integer price; ... // get、set方法，有參、無參構造器 }
創建靜態工廠
/** * 靜態工廠：創建對象的方式，調用靜態方法的方式 */ public class StaticCarFactory { private static Map<String, Car> cars = new HashMap<>(); static{ cars.put("奧迪", new Car("audiA8",100000)); cars.put("寶馬", new Car("bmw",500000)); } public static Car getCar(String brand){ return cars.get(brand); } }
配置配置文件
<!-- id：唯一標識 class：靜態工廠的class路徑 factory-method：靜態工廠方法 --> <bean id="car" class="spring.ioc.StaticCarFactory" factory-method="getCar"> <!-- 如果工廠方法需要參數，通過constructor-arg傳遞參數 --> <constructor-arg value="奧迪"></constructor-arg> </bean>
編寫測試代碼
/** * 靜態工廠創建對象 */ @Test public void staticFactoryTest() throws Exception { ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-ioc.xml"); Car bean = (Car) applicationContext.getBean("car"); System.out.println(bean); }
· 實例工廠創建對象
實例工廠方法：將對象的創建過程封裝到另外一個對象實例的方法裏。當客戶端需要請求對象時，只需要簡單的調用該實例方法而不需要關心對象的創建細節(往往使用工廠方法就是爲了應對創建對象比較複雜的情況)。
創建bean
public class Car { private String brand; private Integer price; ... // get、set方法，有參、無參構造器 }
創建靜態工廠
public class InstanceCarFactory { private Map<String, Car> cars = null; public InstanceCarFactory() { cars = new HashMap<String,Car>(); cars.put("one", new Car("小天", 100)); cars.put("two", new Car("大波", 50)); } public Car getCar(String brand){ return cars.get(brand); } }
配置配置文件
<!-- 首先創建實例工廠，才能創建javaBean --> <bean id="instanceCarFactory" class="spring.ioc.InstanceCarFactory"></bean> <bean id="car" factory-bean="instanceCarFactory" factory-method="getCar"> <!-- 如果工廠方法需要參數，通過constructor-arg傳遞參數 --> <constructor-arg value="one"></constructor-arg> </bean>
編寫測試代碼
/** * 實例工廠創建對象 */ @Test public void instanceFactoryTest() throws Exception { ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-ioc.xml"); Car bean = (Car) applicationContext.getBean("car"); System.out.println(bean); }
Bean的作用域
默認情況下，Spring只爲每個在IOC容器裏聲明的Bean創建唯一一個實例（singleton），整個IOC容器範圍內都可共享該實例：所有後續的getBean（）調用和Bean引用都將返回這個唯一的Bean實例。該作用域被稱爲singleton，它是所有Bean的默認作用域。
在Spring中，可以在< bean>元素的scope屬性裏設置Bean的作用域。默認有四種取值：
Singleton、prototype、request、session
singleton:默認值，容器初始化是創建bean實例，在整個容器的生命週期內只創建這一個bean，單例的。
prototype：原型的，容器初始化時不創建bean的實例，而在每次請求時都創建一個新的Bean實例，並返回。
Bean的生命週期
SpringIOC容器可以管理Bean的生命週期，Spring允許在Bean生命週期的特定點執行定製的任務。
Spring IOC容器對Bean的生命週期進行管理的過程：
- 通過構造器或工廠方法創建Bean實例
- 爲Bean的屬性設置值和對其他Bean的引用set()
- 調用Bean的初始化方法init()
- 使用Bean的方法get()
- 當容器關閉時，調用Bean的銷燬方法destory()
DI
set方法注入
通過setter方法注入Bean的屬性值或依賴的對象。
對應的實體類中一定要有getter和setter方法，如果寫了帶參的構造器，
一定要有無參構造器，因爲容器用此方法創建對象時會調用空參的構造器
使用< property>元素, 使用 name 屬性指定 Bean 的屬性名稱，value 屬性或 子節點指定屬性值，如果是依賴對象類型，就使用ref屬性。
構造器注入
通過構造方法注入Bean 的屬性值或依賴的對象。
配置使用p和c命名空間配置javabean
配置帶集合屬性的Javabean
