目錄

1.spring框架概念

1 spring是輕量級開源框架:

Spring是一個開源框架，Spring是於2003 年興起的一個輕量級的Java 開發框架，由 Rod Johnson 在其著作 Expert One-On-One J2EE Development and Design 中闡述的部分理念和原型衍生而來。它是 為了解決企業應用開發的複雜性而建立的。框架的主要優勢之一就是其分層架構，分層架構允許使 用者選擇使用哪一個元件，同時為 J2EE 應用程式開發提供整合的框架。Spring 使用基本的 JavaBean 來完成以前只可能由 EJB

完成的事情。然而，Spring 的用途不僅限於伺服器端的開發。從簡單性、 可測試性和鬆耦合的角度而言，任何 Java 應用都可以從 Spring 中受益。Spring 的核心是控制反轉 （IoC）和麵向切面（AOP）。簡單來說，Spring 是一個分層的 JavaSE/EEfull-stack(一站式) 輕量級 開源框架。

EE 開發分成三層結構:

* WEB 層:Spring MVC.

* 業務層:Bean 管理:(IOC)

* 持久層:Spring 的 JDBC 模板.ORM

2 spring核心有兩部分：

（1）控制反轉 ioc：

* 比如現在有普通類，在這個類裡面有普通的方法，呼叫這個類裡面的普通的方法，需要建立類物件，使用物件呼叫方法。

* 建立類的物件，使用原始方式new物件。使用ioc實現物件建立，不需要手動new物件，通過配置檔案方式建立物件

* 把物件建立交給spring配置

（2）面向切面 aop：

* 不通過修改原始碼方式增強類裡面的方法

*  aop底層動態代理

3 spring是一站式框架:

（1）spring針對javaee三層，在每一層提供解決技術

* web層：springMVC

* service層:  spring ioc

* dao層：spring jdbcTemplate

2.spring的ioc操作

1 ioc稱為控制反轉，把物件建立不是new出來，而是在spring使用配置方式建立

（1）把物件建立交給spring進行管理

3.ioc底層原理

1 ioc底層原理使用技術

（1）xml配置檔案

（2）dom4j解析xml檔案

（3）工廠模式

（4）反射

4.spring入門案例

1.匯入jar包,包括四個spring框架的jar包以及倆個日誌jar包

2.建立XML配置檔案,引入schema約束

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


</beans>

3.建立一個類,裡面建立一個方法

public class User {
	public void add() {
		System.out.println("我是add()方法");
	}
}	public void add() {
		System.out.println("我是add()方法");
	}
}

4.在配置檔案中配置物件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        
	<!-- 配置user物件 
		id: 根據id值獲取物件
		class: 要建立物件所在類全路徑
	-->
	<bean id="user" class="com.ioc.User"></bean>
        
</beans><bean id="user" class="com.ioc.User"></bean>
        
</beans>

5.進行測試

	/**
	 * 第一種方法測試，直接建立User物件
	 */
	@Test
	public void testUser() {
		// 1 載入spring配置檔案
		//載入spring配置檔案，把配置物件建立
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 2 根據id值獲取物件
		User user = (User) context.getBean("user");
		System.out.println(user);
		user.add();
	}

5.配置檔案沒有提示問題

引入配置檔案

6.spring的bean管理

6.1 : 什麼是bean管理

  兩個操作：

（1）建立物件（bean例項化）

（2）設定類裡面屬性值（注入屬性）

6.2 : spring的bean管理有兩種方式

（1）基於xml配置檔案方式

（2）基於註解方式

6.3 : Bean例項化的方式

1 在spring裡面通過配置檔案建立物件

（1）建立物件操作

2 bean例項化（建立物件）三種方式實現

第一種 使用類的無引數構造建立

public class User {
	public void add() {
		System.out.println("我是add()方法");
	}
}

<!-- 使用User物件直接建立，重點 -->
	<bean id="user" class="com.deu.xiaoniu.ioc.User"></bean>

	@Test
	public void testUser() {
		// 1 載入spring配置檔案
		//載入spring配置檔案，把配置物件建立
		ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
		// 2 根據id值獲取物件
		User user = (User) context.getBean("user");
		System.out.println(user);
		user.add();
	}

第二種 使用靜態工廠建立

（1）建立靜態的方法，返回類物件

public class Bean2 {
	public void bean2() {
		System.out.println("我是Bean2類的bean2()方法");
	}
}

public class Bean2Factory {
	public static Bean2 getBean2() {
		return new Bean2();		
	}
}

<!-- 使用靜態工廠建立 -->  
    <bean id="bean2" class="com.deu.xiaoniu.factory.Bean2Factory" factory-method="getBean2"></bean>

/**
* 第二種方式建立，使用靜態工廠
*/
@Test
public void testGetBean2() {
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
	Bean2 bean2 = context.getBean("bean2",Bean2.class);
	bean2.bean2();
}

第三種 使用例項工廠建立

（1）建立不是靜態的方法，返回類物件

public class Bean3 {
	public void bean3() {
		System.out.println("我是Bean3類的bean3()方法");
	}	
}

public class Bean3Factory {
	public Bean3 getBean3() {
		return new Bean3();
	}
}

    <!-- 使用例項工廠建立 -->
    <bean id="Bean3Factory" class="com.deu.xiaoniu.factory.Bean3Factory"></bean>
    <bean id="bean3" factory-bean="Bean3Factory"  factory-method="getBean3"></bean>

	/**
	 * 第三種方式，建立工廠物件
	 */
	@Test
	public void testGetBean3() {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
		Bean3 bean = context.getBean("bean3" ,Bean3.class);
		bean.bean3();
	}

6.4 : bean標籤常用屬性

1 id屬性
（1）根據id屬性值獲取物件
（2）在一個spring配置檔案中，可以有多個bean標籤，但是bean標籤id屬性值不同
2 class屬性
（1）類的全路徑
3 name屬性
（1）name屬性作用和id屬性一樣的
（2）id屬性值裡面不能包含特殊符號的
（3）name屬性值可以包含特殊符號
4 scope屬性
（1）主要作用：配置建立物件是單例項還是多例項物件
（2）屬性值：
* 預設值，singleton，表示單例項物件
* prototype，表示多例項物件
* action是多例項物件
request：把建立物件放到request裡面
session：把建立物件放到session裡面
globalSession：把建立物件放到globalSession裡面
** 單點登入

6.5 : Bean生命週期配置

6.5.1  :  XML配置檔案測試Bean生命週期

package com.edu.xiaoniu.bean;
/**
 * XML配置檔案的方式測試生命週期
 * @author Administrator
 *
 */

public class BeanLive2 {
	public void show() {
		System.out.println("我是BeanLive類的show()方法.....");
	}
	public void init() {
		System.out.println("我是BeanLive類的init()方法.....");
	}
	public void destory() {
		System.out.println("我是BeanLive類的destory()方法....");
	}
}

<!-- 使用配置檔案的方式測試生命週期 -->
	<bean id="beanLive2" class="com.edu.xiaoniu.bean.BeanLive2" init-method="init" destroy-method="destory"></bean>

	/**
	 * XML配置檔案方式測試生命週期
	 */
	@Test
	public void testBeanLive2() {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		BeanLive2 beanLive = context.getBean("beanLive2",BeanLive2.class);
		beanLive.show();
		context.close();
	}

6.5.2 : 註解方式測試Bean生命週期

/**
 * 註解方式測試生命週期
 * @author Administrator
 *
 */

@Service("beanLive")public class BeanLive {public void show() {System.out.println("我是BeanLive類的show()方法.....");}@PostConstructpublic void init() {System.out.println("我是BeanLive類的init()方法.....");}@PreDestroypublic void destory() {System.out.println("我是BeanLive類的destory()方法....");}}

    <!-- 開啟註解掃描.到配置包裡面找到所有類上面,方法上面,和屬性上面的註解,根據不同的註解.實現不同的功能 -->
    <context:component-scan base-package="com.edu.xiaoniu.bean"></context:component-scan>	

/**
 * 註解方式測試生命週期
 */

     @Test    public void testBeanLive() {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");BeanLive beanLive = context.getBean("beanLive",BeanLive.class);beanLive.show();context.close();    }

7 . 屬性注入

1 .  一個類裡面有屬性,向類裡面的屬性設定值,這個過程叫做屬性注入
2 .  向類裡面屬性設定值,java程式碼中有三種實現方式:分別為無參構造（set）方法，有參構造，介面注入

2.1 無參構造，即set方法設定值

public class User1 {
	private String name;
	private String age;
	
	public void setName(String name) {
		this.name = name;
	}

	public void setAge(String age) {
		this.age = age;
	}
}

2.2 有參構造

public class User2 {
	private String name ;
	private String age ;
	
	public String getName() {
		return name;
	}

	public String getAge() {
		return age;
	}

	public void user(String name,String age) {
		this.name = name;
		this.age = age ;
	}
}

2.3介面注入

public interface User3 {
	public void add(String name,String age);
}

public class TestUser3 implements User3{
	
	private String name;
	private String age;
	
	@Override
	public void add(String name, String age) {
		this.name = name;
		this.age = age;
		System.out.println();
	}
	
}

3 . spring框架裡面支援是set方法注入和有引數構造注入

3.1 spring 框架使用有參構造注入

第一步 : 建立一個類.定義屬性,生成有參構造

public class Book {
	
	private String bname;
	private String author;
	
	//生成有參構造
	public Book(String bname, String author) {
		super();
		this.bname = bname;
		this.author = author;
	}
	
	public void add() {
		System.out.println("書名:" + bname + "\n作者:" + author);
	}
	
}

第二步 : 在配置檔案中注入屬性

<Bean>標籤裡面 id 屬性自定義一個值 , 用於載入類的時候使用 , class 為類名全路徑

<constructor-arg>標籤裡面 name 值為要賦值的屬性名 , value 為要賦的值

     <!-- spring框架有參構造屬性注入 -->
     <bean id="book" class="com.edu.xiaoniu.attr.Book">
     	<constructor-arg name="bname" value="如何像我一樣優秀"></constructor-arg>
     	<constructor-arg name="author" value="劉備"></constructor-arg>
     </bean>

第三步 : 測試

	/**
	 * 測試spring框架有參屬性注入
	 */
	@Test
	public void testBook() {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
		Book bean = context.getBean("book",Book.class);
		bean.add();
		
	}

3.2 spring 框架使用set()方法注入

第一步 : 建立物件 ,設定屬性 ,生成set方法

    建立一個add()方法用於測試是否賦值成功

public class Orders {
	private String oname;
	private String oaddress;
	
	public void setOname(String oname) {
		this.oname = oname;
	}
	public void setOaddress(String oaddress) {
		this.oaddress = oaddress;
	}
	
	public void add() {
		System.out.println("物品:" + oname + "地址:" + oaddress);
	}
}

第二步 : 配置檔案賦值

<Bean>標籤中的 id 屬性作為一個標識 , 自己設定 , 用於建立類的時候用,class為類的全路徑

<property>標籤裡面name為要賦值的屬性的名稱,value為要賦的值

<constructor-arg>標籤用於有引數構造用,<property>標籤用於set()方法用

<!-- spring框架set()方法注入 -->
<bean id="order" class="com.edu.xiaoniu.attr.Orders">
    <property name="oname" value="奢侈品"></property>
    <property name="oaddress" value="中北大學"></property>
 </bean>

第三步 : 測試

/**
 * 測試spring框架set()方法注入
 */
@Test
public void testOrder() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Orders bean = context.getBean("order",Orders.class);
    bean.add();	
}

3.3 spring 框架物件型別屬性注入

第一步 : 建立UserDao類和UserService倆個類,其中UserDao類作為屬性添加註入到UserService類中

public class UserDao {

}

public class UserService {

	private UserDao userDao;
	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	
	public void add() {
		System.out.println(userDao);
	}
}

第二步 : 在配置檔案中將UserDao類作為屬性注入到UserService類中

     <!-- spring框架的注入物件型別屬性 -->
     <bean id="userDaoImpl" class="com.edu.xiaoniu.attr.UserDao"></bean>
     <bean id="userService" class="com.edu.xiaoniu.attr.UserService">
	 <property name="userDao" ref="userDaoImpl"></property>
     </bean>

第一個<bean>標籤為要注入的物件,id 為標識 , class 為要作為屬性注入的物件的全路徑

第二個<bean>標籤為要注入到哪裡, class 為要注入的類的全路徑 , name 為物件屬性的名稱, ref 為物件所在標籤的id值

如果注入普通型別屬性 使用value屬性 ，如果注入物件型別屬性，使用ref屬性

第三步 : 測試

	/**
	 * 測試spring框架物件注入
	 */
	@Test
	public void testUserService() {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
		UserService bean = context.getBean("userService",UserService.class);
		bean.add();
	}

8 . p名稱空間注入

1 . 引入p名稱空間約束

2 .  配置檔案中，使用名稱空間注入屬性

9 . SpEl注入