JavaWeb - Sping & Sping IOC

• JavaWeb - Sping & Sping IOC
  • 1 Sping
    • 1.1 Sping 概念
      • 1.1.1 Sping 兩大核心：
      • 1.1.2 耦合和解耦的概念
      • 1.1.3 Sping 的優點
  • 2 Spring IOC
    • 2.1 IOC的概念
    • 2.2 自定義IOC容器
    • 2.3 Sping 快速使用
    • 2.4 Spring API
      • 2.4.1 Spring 體系
      • 2.4.2 BeanFactory 介面
      • 2.4.3 ApplicationContext 介面
      • 2.4.4 BeanFactory 和 ApplicationContext 的區別
      • 2.4.5 常用方法 - getBean()
      • 2.4.6 Bean 標籤配置
        • 2.4.6.1 Bean 標籤的基本配置
        • 2.4.6.2 Bean 標籤的範圍配置
        • 2.4.6.3 Bean 生命週期的配置
        • 2.4.6.4 Bean 例項化的三種方式
      • 2.4.7 Bean 依賴注入
        • 2.4.7.1 Bean 依賴注入方式 - 構造方法
        • 2.4.7.3 Bean 依賴注入的的資料型別
      • 2.4.8 配置檔案模組化
      • 2.4.9 Bean 標籤配置，依賴注入和配置檔案模組化小結
    • 2.5 DbUtils （IOC 實戰）
    • 2.6 Spring 註解開發
      • 2.6.1 Spring 註解開發常用註解
        • 2.6.1.1 自定義類相關注解
        • 2.6.1.2 非自定義類和核心配置檔案相關注解
      • 2.6.2 Spring 整合Junit

1 Sping

1.1 Sping 概念

Spring是分層的 Java SE/EE應用 full-stack(全棧式) 輕量級開源框架

• 全棧式：

  • 對各種主流技術和框架都進進行了整合，同時對三層架構都提供瞭解決方案

• 輕量級：

  • 輕量級和重量級的劃分主要依據服務使用的多少，啟動時資源載入的多少及耦合度等等

提供了表現層 SpringMVC

持久層 Spring JDBC Template

業務層事務管理，物件控制等眾多的企業級應用技術

還能整合開源世界眾多著名的第三方框架和類庫

1.1.1 Sping 兩大核心：

• IOC（Inverse Of Control：控制反轉），把物件的建立權交給sping

• AOP（Aspect Oriented Programming：面向切面程式設計），在不修改原始碼的情況下對方法進行增強

1.1.2 耦合和解耦的概念

耦合：程式間的依賴關係

解耦：降低程式間的依賴關係，並不是完全消除

例項：

//1. 註冊驅動 存在編譯期依賴，這就是耦合重的體現
//new 關鍵字就會存在編譯期依賴，解耦思路為去掉new改用反射
DriverManager.registerDriver(new com.mysql.jdbc.Driver());

解耦：使用反射機制讓其編譯期不依賴，執行期才依賴，但還存在硬編碼問題
Class.forName("com.mysql.jdbc.Driver");

//最終解耦思路為：配置檔案+反射，自定義IOC用到此思路

1.1.3 Sping 的優點

• 方便解耦，簡化開發

  • Spring就是一個容器，可以將所有物件建立和關係維護交給Spring管理

• AOP程式設計的支援

  • Spring提供面向切面程式設計，方便實現程式進行許可權攔截，執行監控等功能

• 宣告式事務的支援

  • 通過配置完成事務的管理，無需手動程式設計

• 方便測試，降低JavaEE API的使用

  • Spring對Junit4支援，可以使用註解測試

• 方便整合各種優秀框架

  • 不排除各種優秀的開源框架，內部提供了對各種優秀框架的直接支援

2 Spring IOC

2.1 IOC的概念

控制反轉（Inverse Of Control）不是什麼技術，而是一種設計思想。它的目的是指導我們設計出更加鬆耦合的程式

• 控制：在java中指的是物件的控制權限（建立、銷燬）
• 反轉：指的是物件控制權由原來 由開發者在類中手動控制 反轉到 由Spring容器控制

2.2 自定義IOC容器

核心思想為將物件的建立通過反射機制來實現進而實現解耦，再通過配置檔案的方式來實現反射建立物件時產生的硬編碼問題

步驟：

• 建立maven專案，匯入需要使用包的座標

<dependencies>
//dom4j 用來解析xml檔案
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

• 編寫userDao介面及實現類，編寫userService介面及實現類並在實現類中建立userDao例項物件並呼叫方法，最後編寫測試類建立userService例項物件並呼叫方法
• 編寫bean.xml 檔案，將需要容器管理類編寫到該檔案中

<beans>
    <bean id = "userDao" class = "com.lagou.dao.userDaoImpl"></bean>
    <bean id="userService" class="com.lagou.service.userServiceImpl"></bean>
</beans>

• 編寫BeanFactory工廠類，用來完成ioc容器的初始化載入和分配容器中的物件
  • 靜態程式碼塊用來載入配置檔案並解析，獲取到配置檔案中類的路徑和名稱，再通過該路徑來建立該類的物件
  • 宣告一個Map型別的成員變數用來儲存解類與其對應的物件
  • 宣告一個方法用來通過類名獲取物件

public class BeanFactory {
    private static Map<String, Object> ioc = new HashMap<>();

    static {
        try {
        //1.將xml檔案讀取，通過呼叫類載入器中的方法
            InputStream stream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
		//2.解析xml檔案
            SAXReader saxReader = new SAXReader();

            Document document = saxReader.read(stream);
		//3.編寫xpath來指定需要獲取的標籤
            String xpath = "//bean";
		//4.獲取所有的bean 標籤
            List<Element> list = document.selectNodes(xpath);
		//將標籤中的元素取出並新建物件再放入集合中
            for (Element element : list) {
                ioc.put(element.attributeValue("id"),Class.forName(element.attributeValue("class")).newInstance());
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
//宣告方法用來獲取物件
    public static Object getBean(String id){
        return ioc.get(id);
    }
}

• 編寫測試類

userService service = (userService) BeanFactory.getBean("userService");
        service.save();

2.3 Sping 快速使用

• 建立專案並匯入相關座標

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

• 建立Sping 的核心配置檔案，一般使用applicationContext.xml

// 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">

</beans>

• 在核心配置檔案中為Bean物件進行配置

<bean id="" class=""></bean>

• 建立ApplicationContext物件，執行getBean

ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
XXX xxx = (XXX) applicationContext.getBean("xxx");

2.4 Spring API

2.4.1 Spring 體系

2.4.2 BeanFactory 介面

BeanFactory是 IOC 容器的核心介面，它定義了IOC的基本功能

• 通過XmlBeanFactory 實現類來載入核心配置檔案

BeanFactory beanFactory =
new XmlBeanFactory(new
ClassPathResource("applicationContext.xml"));

2.4.3 ApplicationContext 介面

代表應用上下文物件，可以獲得spring中IOC容器的Bean物件

常用實現類：

• ClassPathXmlApplicationContext

  • 是從類的根路徑下載入配置檔案 推薦使用這種

• FileSystemXmlApplicationContext

  • 從磁碟路徑上載入配置檔案，配置檔案可以在磁碟的任意位置

• AnnotationConfigApplicationContext

  • 使用註解配置容器物件時，需要使用此類來建立 spring 容器。它用來讀取註解

ApplicationContext app =
new ClassPathXmlApplicationContext("applicationContext.xml");

2.4.4 BeanFactory 和 ApplicationContext 的區別

• BeanFactory 在第一次呼叫 getBean() 方法的時候建立指定物件的例項

//該語句執行並沒有建立例項
new XmlBeanFactory(new ClassPathResource("xxx.xml"));

• ApplicationContext在啟動容器時就載入和建立了所有物件的例項

2.4.5 常用方法 - getBean()

• Object getBean(String name);

  • 根據Bean的id從容器中獲得Bean例項，返回是Object，需要強轉

• T getBean(Class requiredType);

  • 根據型別從容器中匹配Bean例項，當容器中相同型別的Bean有多個時，則此方法會報錯
  • 一個介面的每個實現類都需要在核心配置檔案中配置
  • 對於有多個實現類的介面該方法不適用

• T getBean(String name,Class requiredType);

  • 根據Bean的id和型別獲得Bean例項，解決容器中相同型別Bean有多個情況

2.4.6 Bean 標籤配置

2.4.6.1 Bean 標籤的基本配置

<bean id = "xxxService" class = "service 層裡的實現類">
	<constructor-arg index="引數下標從0開始" type="構造方法引數介面型別" ref="構造方法引數bean id"/>
	或
	<constructor-arg name="構造方法引數的形參名" ref="構造方法引數bean id"/>
<bean/>

<bean id = "xxxService" class = "service層介面的實現類">
<property name = "set方法set後首字母小寫" ref="屬性對應介面Bean id"/>
<bean/>

xmlns:p="http://www.springframework.org/schema/p"

<bean id = "xxxService" class = "service層介面的實現類" p:xxxDao-ref="xxxDao/>

<property name="">
<list>
<value>基本資料型別的值<value/>
<ref bean = "引用資料類 Bean id"/>
<list/>
<property/>

<property name="">
<set>
<value>基本資料型別的值<value/>
<ref bean = "引用資料類 Bean id"/>
<set/>
<property/>

<property name="">
<array>
<value>基本資料型別的值<value/>
<ref bean = "引用資料類 Bean id"/>
<array/>
<property/>

<property name="">
<map>
<entry key="基本資料型別" value="基本資料型別">
<entry key-ref="引用資料型別Bean id" value-ref="引用資料型別Bean id">
<map/>
<property/>

<property name="">
<props>
<prop key="">值</prop>
<props/>
<property/>

ApplicationContext act =
new
ClassPathXmlApplicationContext("ApplicationContext.xml","xxx.xml","...");

<import resource="applicationContext-xxx.xml"/>

<bean>標籤：建立物件並放到spring的IOC容器
id屬性:在容器中Bean例項的唯一標識，不允許重複
class屬性:要例項化的Bean的全限定名
scope屬性:Bean的作用範圍，常用是Singleton(預設)和prototype

<constructor-arg>標籤：屬性注入
name屬性：屬性名稱
value屬性：注入的普通屬性值
ref屬性：注入的物件引用值

<property>標籤：屬性注入
name屬性：屬性名稱
value屬性：注入的普通屬性值
ref屬性：注入的物件引用值
<list>
<set>
<array>
<map>
<props>

<import>標籤:匯入其他的Spring的分檔案

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property> //特別注意該地方的set方法
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

在核心配置檔案檔案頭中新增：
名稱空間
xmlns:context="http://www.springframework.org/schema/context"

約束路徑
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

標籤內配置：
<context:property-placeholder location="classpath:jdbc.properties" />

<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

<!--註解的元件掃描-->
<context:component-scan base-package="com.lagou"></context:component-scan>

<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.2</version>
</dependency>

載入properties檔案的配置：<context:property-placeholder location="classpath:jdbc.properties">

元件掃描的配置：<context:component-scan>

引入其他檔案：<import>

new AnnotationConfigApplicationContext(核心配置檔案.class);

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = {SpringConfig.class}) // 載入spring核心配置類

或

@ContextConfiguration(value = {"classpath:applicationContext.xml"}) //載入spring
核心配置檔案

javax.net.ssl.SSLException: closing inbound before receiving peer's close_notify