Spring框架自學之路

加瓦一枚發表於2018-10-23

介紹

　　Spring框架是個輕量級的Java EE框架。所謂輕量級，是指不依賴於容器就能執行的。Struts、Hibernate也是輕量級的。
　　輕量級框架是相對於重量級框架而言的，重量級框架必須依賴特定的容器，例如EJB框架就必須執行在Glassfish、JBoss等支援EJB的容器中，而不能執行在Tomcat中。——《Java Web整合開發王者歸來》
　　Spring以IoC、AOP為主要思想，其中IoC，Inversion of Control 指控制反轉或反向控制。在Spring框架中我們通過配置建立類物件，由Spring在執行階段例項化、組裝物件。AOP，Aspect Oriented Programming，面向切面程式設計，其思想是在執行某些程式碼前執行另外的程式碼，使程式更靈活、擴充套件性更好，可以隨便地新增、刪除某些功能。Servlet中的Filter便是一種AOP思想的實現。
　　Spring同時也是一個“一站式”框架，即Spring在JavaEE的三層架構[表現層（Web層）、業務邏輯層（Service層）、資料訪問層（DAO層）]中，每一層均提供了不同的解決技術。如下：

表現層（Web層）：Spring MVC
業務邏輯層（Service層）：Spring的IoC
資料訪問層（DAO層）：Spring的jdbcTemplate

Spring中的IoC操作

　　將物件的建立交由Spring框架進行管理。
　　IoC操作分為：IoC配置檔案方式和IoC的註解方式。

IoC入門案例

（1）匯入Spring框架中的相關jar包，這裡只匯入Spring的Core模組（Core模組是框架的核心類庫）下的jar包（使用IoC的基本操作，並不需要匯入Spring的所有jar包，只匯入spring-beans、spring-core、spring-context、spring-expression這4個jar包），以及支援日誌輸出的 commons-logging 和 log4j 的jar包；
（2）建立一個普通的Java類，並在該類中建立方法，如下：
　　User.java

package com.wm103.ioc;

/**
 * Created by DreamBoy on 2018/3/17.
 */
public class User {
    public void add() {
        System.out.println("User Add Method.");
    }

    @Override
    public String toString() {
        return "This is a user object.";
    }
}

（3）建立Spring的配置檔案，進行Bean的配置
　　Spring的核心配置檔名稱和位置不是固定的。但官方件建議將該核心配置檔案放在src目錄下，且命名為 applicationContext.xml。
　　這裡為了方便，將核心配置檔案放在src目錄下，並命名為 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="user" class="com.wm103.ioc.User"></bean>
</beans>

（４）編寫測試類進行測試，通過配置檔案建立類物件
　　TestIoC.java

package com.wm103.ioc;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by DreamBoy on 2018/3/17.
 */
public class TestIoc {
    @Test
    public void runUser() {
        // 1. 載入Spring配置檔案，根據建立物件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2. 得到配置建立的物件
        User user = (User) context.getBean("user");
        System.out.println(user);
        user.add();
    }
}

Spring的bean管理（配置檔案）

Bean例項化的方式

　　在Spring中通過配置檔案建立物件。
　　Bean例項化三種方式實現：
（1）使用類的無引數構造建立，如：

<!-- 等同於 user = new com.wm103.ioc.User(); -->
<bean id="user" class="com.wm103.ioc.User"></bean>

（2）使用靜態工廠建立
　　如果一個Bean不能通過new直接例項化，而是通過工廠類的某個靜態方法建立的，需要把<bean>的class屬性配置為工廠類。如：

<!-- 等同於 user = com.wm103.ioc.UserFactory.createInstance(); -->
<bean id="user" class="com.wm103.ioc.UserFactory" factory-method="createInstance"></bean>

（3）使用例項工廠建立
　　如果一個Bean不能通過new直接例項化，而是通過工廠類的某個例項方法建立的，需要先配置工廠的<bean>標籤，然後在需要建立的物件的bean標籤的factory-bean屬性配置為工廠類物件，factory-method屬性配置為產生例項的方法。如：

<!-- 等同於 userFactory = new com.wm103.ioc.UserFactory(); -->
<bean id="userFactory" class="com.wm103.ioc.UserFactory"></bean>
<!-- 等同於 user = userFactory.createInstance(); -->
<bean id="user" factory-bean="userFactory" factory-method="createInstance"></bean>

Bean標籤的常用屬性

（1）id屬性：用於指定配置物件的名稱，不能包含特殊符號。
（2）class屬性：建立物件所在類的全路徑。
（3）name屬性：功能同id屬性一致。但是在name屬性值中可以包含特殊符號。
（4）scope屬性

singleton：預設值，單例
單例模式下，在程式下只有一個例項。非單態模式下，每次請求該Bean，都會生成一個新的物件。
prototype：多例
request：建立物件後將物件存放到request域
session：建立物件後將物件存放到session域
globalSession：建立物件後將物件存放到globalSession域

屬性注入

　　屬性注入指建立物件時，向類物件的屬性設定屬性值。
　　在Spring框架中支援set方法注入和有參建構函式注入，即建立物件後通過set方法設定屬性或採用有參建構函式建立物件並初始化屬性。

使用有參建構函式注入屬性
　　案例：
　　Student.java 提供有參的構造方法

package com.wm103.ioc;
public class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

　　bean的配置：

<bean id="student" class="com.wm103.ioc.Student">
    <constructor-arg name="name" value="DreamBoy"></constructor-arg>
</bean>

　　建立Student物件進行測試：

@Test
public void runStudent() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    Student student = (Student) context.getBean("student");
    System.out.println(student);
}

使用set方法注入屬性
　　案例：
　　Teacher.java 提供屬性的set方法

package com.wm103.ioc;
public class Teacher {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

　　bean的配置：

<bean id="teacher" class="com.wm103.ioc.Teacher">
    <property name="name" value="Teacher Wu"></property>
</bean>

　　建立Teacher物件進行測試：

@Test
public void runTeacher() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    Teacher teacher = (Teacher) context.getBean("teacher");
    System.out.println(teacher);
}

注入物件型別屬性

　　以三層架構中的service層和dao層為例，為了讓service層使用dao層的類建立的物件，需要將dao物件注入到service層類中。具體實現過程中如下：
（1）建立service類、dao層介面、dao類，如下：

UserService.java

package com.wm103.exp;
public class UserService {
    private UserDao userDao; // 宣告為介面型別，降低service層與dao層的耦合度，不依賴於dao層的具體實現

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("UserService Add...");
        this.userDao.add();
    }
}

UserDao.java

package com.wm103.exp;

/**
 * 暴露給service層的介面
 * Created by DreamBoy on 2018/3/17.
 */
public interface UserDao {
    void add();
}

UserDaoImpl.java

package com.wm103.exp;

/**
 * 介面UserDao的具體實現
 * Created by DreamBoy on 2018/3/17.
 */
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("UserDaoImpl Add...");
    }
}

（2）在配置檔案中注入關係，如下：

<!-- 配置service和dao物件 -->
<!-- 因為service依賴於dao，所以先進行dao物件的bean配置 -->
<bean id="userDaoImpl" class="com.wm103.exp.UserDaoImpl"></bean>
<bean id="userService" class="com.wm103.exp.UserService">
    <!--
        注入dao物件
        name屬性值為：service中的某一屬性名稱
        ref屬性值為：被引用的物件對應的bean標籤的id屬性值
     -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>

（3）建立測試方法進行測試，如下：

@Test
public void runUserService() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
}

p名稱空間注入屬性

　　之前提到了一種set方法的屬性注入方式，這裡將介紹另一種屬性注入的方式，名為 p名稱空間注入。對比set方法的屬性注入方式，核心配置檔案配置修改如下：

<?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">
    <bean id="teacher" class="com.wm103.ioc.Teacher" p:name="Teacher Wu"></bean>
</beans>

注入複雜型別屬性
　　物件注入複雜型別屬性，如陣列、List、Map、Properties。
　　案例：
　　PropertyDemo.java

package com.wm103.ioc;

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

public class PropertyDemo {
    private String[] arrs;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;

    public String[] getArrs() {
        return arrs;
    }

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

　　bean配置檔案，內容如下：

<?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="prop" class="com.wm103.ioc.PropertyDemo">
        <!-- 注入陣列 -->
        <property name="arrs">
            <list>
                <value>Value 1 of Array</value>
                <value>Value 2 of Array</value>
                <value>Value 3 of Array</value>
            </list>
        </property>
        <!-- 注入List集合 -->
        <property name="list">
            <list>
                <value>Value 1 of List</value>
                <value>Value 2 of List</value>
                <value>Value 3 of List</value>
            </list>
        </property>
        <!-- 注入Map集合 -->
        <property name="map">
            <map>
                <entry key="key1" value="Value 1 of Map"></entry>
                <entry key="key2" value="Value 2 of Map"></entry>
                <entry key="key3" value="Value 3 of Map"></entry>
            </map>
        </property>
        <!-- 注入Properties -->
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>
</beans>

　　建立PropertyDemo物件進行測試：

@Test
public void runPropertyDemo() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    PropertyDemo pd = (PropertyDemo) context.getBean("prop");
    System.out.println(pd);
    System.out.println(Arrays.toString(pd.getArrs()));
    System.out.println(pd.getList());
    System.out.println(pd.getMap());
    System.out.println(pd.getProperties());
}

IoC和DI的區別

　　IoC，控制反轉，將傳統的物件建立流程轉變為交由框架進行建立和管理。在Spring中，物件的建立交給Spring進行配置。它包括依賴注入。
　　DI，依賴注入，向類的屬性設定值。
　　IoC與DI的關係：依賴注入不能單獨存在，需要在IoC基礎之上完成操作。

Spring的bean管理（註解）

　　註解是程式碼中特殊的標記，使用註解可以完成特定的功能。註解可以使用在類、方法或屬性上，寫法如：@註解名稱(屬性名稱=屬性值)。
　　Spring的bean管理註解方式，案例如下。

Spring註解開發準備
（1）匯入jar包：

匯入基本的jar包：commons-logging、log4j、spring-beans、spring-context、spring-core、spring-expression相關jar包。
匯入AOP的jar包：spring-aopjar包。
（2）建立類、方法
　　User.java

package com.wm103.anno;

import org.springframework.stereotype.Component;

public class User {
    public void add() {
        System.out.println("User Add Method.");
    }
}

（3）建立Spring配置檔案，引入約束；並開啟註解掃描
　　bean1.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        開啟註解掃描
            （1）到包中掃描類、方法、屬性上是否有註解
     -->
    <context:component-scan base-package="com.wm103"></context:component-scan>

    <!--
            （2）只掃描屬性上的註解
    -->
    <!--<context:annotation-config></context:annotation-config>-->
</beans>

註解建立物件
　　在建立物件的類上面使用註解實現，如：

@Component(value="user")
public class User {

　　建立測試類 TestAnno.java和測試方法，如：

package com.wm103.anno;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAnno {

    @Test
    public void runUser() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = (User) context.getBean("user");
        user.add();
    }
}

　　除了上述提到的 @Component註解外，Spring中還提供了@Component的3個衍生註解，其功能就目前來說是一致的，均是為了建立物件。

@Controller ：WEB層
@Service ：業務層
@Repository ：持久層

　　以單例或多例項方式建立物件，預設為單例，多例物件設定註解如下：

@Component(value="user")
@Scope(value="prototype")
public class User {

註解注入屬性
　　案例：建立Service類和Dao類，並在Service中注入Dao物件。如下：
（1）建立Dao和Service物件
　　UserDao.java

package com.wm103.anno;

import org.springframework.stereotype.Repository;

@Repository(value="userDao")
public class UserDao {
    public void add() {
        System.out.println("UserDao Add Method.");
    }
}

　　UserService.java

package com.wm103.anno;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value="userService")
public class UserService {
    public void add() {
        System.out.println("UserService Add Method.");
        userDao.add();
    }
}

（2）在Service類中定義UserDao型別的屬性，並使用註解完成物件的注入
@Autowired：自動注入或自動裝配，是根據類名去找到類對應的物件來完成注入的。

@Autowired
private UserDao userDao;

或者 @Resource

@Resource(name="userDao")
private UserDao userDao;

　　其中該註解的name屬性值為註解建立Dao物件的value屬性的值。
　　這兩種註解方式都不一定要為需要注入的屬性定義set方法。
（3）建立測試方法

@Test
public void runUserService() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
}

注：配置檔案和註解混合使用
1）建立物件的操作一般使用配置檔案方式實現；
2）注入屬性的操作一般使用註解方式實現。

---------------------
原文：https://blog.csdn.net/qq_15096707/article/details/72819930

Spring自學之路---AOP
2018-10-23
Spring
spring框架半自動註解
2020-12-09
Spring框架
C/C++自學之路
2018-07-31
C++
記錄自學 PHP 之路
2020-03-07
PHP
聊聊我的 Java 自學之路
2018-12-25
Java
0基礎Java自學之路
2018-03-25
Java
[Android]後端之路--整合SSM（Spring+SpringMVC+MyBatis）框架（2）
2018-07-28
Android後端SSMSpringMVCMyBatis框架
laravel框架學習之路（二）pjax的使用
2019-02-16
Laravel框架
學習Spring Cloud與微服務之路三
2020-09-25
SpringCloud微服務
Spring原始碼學習之路---IOC初探（二）
2018-04-03
Spring原始碼
Spring框架學習筆記（1）
2020-09-10
Spring框架筆記
spring框架學習依賴注入
2020-12-12
Spring框架依賴注入
Linux應用開發自學之路
2019-03-02
Linux
Spring框架 - Spring和Spring框架組成
2022-06-20
Spring框架
擷取Spring框架自動丟擲異常
2024-05-15
Spring框架
一個「學渣」從零Web前端自學之路
2019-02-17
Web前端
零基礎的自學前端之路
2019-01-12
前端
深入學習Spring框架（一）- 入門
2019-07-12
Spring框架
Spring boot學習（八）Spring boot配置ehcache快取框架
2019-03-20
Spring Boot快取框架
暑期自學 Day 16 | Spring （二）
2020-06-20
Spring
暑期自學 Day 15 | Spring （一）
2020-05-30
Spring
暑期自學 Day 17 | Spring （三）
2020-06-23
Spring
暑期自學 Day 18 | Spring （四）
2020-06-25
Spring
暑期自學 Day 20 | Spring （六）
2020-07-17
Spring
暑期自學 Day 19 | Spring （五）
2020-07-12
Spring
深入理解Spring框架的自動裝配原理
2023-12-29
Spring框架
深入學習Spring框架（三）- AOP面向切面
2019-07-15
Spring框架
Spring Boot--日誌框架的學習
2019-07-02
Spring Boot框架
深入學習Spring框架（二）- 註解配置
2019-07-12
Spring框架
SAP UI5框架自學教程
2020-09-18
UI框架
暑期自學 Day 21 | Spring Boot（一）
2020-07-21
Spring Boot
Node.js學習之路24——Express框架的app物件
2019-02-16
Node.jsExpress框架APP物件
Beego 框架巔峰之路
2019-05-12
Go框架
web前端從入門到精通的自學之路
2018-08-09
Web前端
01-Spring Security框架學習--入門（二）
2021-09-09
Spring框架
Java | Spring框架學習筆記--(1)工廠
2020-12-18
JavaSpring框架筆記
一個「學渣」從零開始的Web前端自學之路
2019-02-17
Web前端
Spring JDBC框架
2018-10-31
SpringJDBC框架