當前位置：
首頁 > 知識 > Spring框架自學之路——簡易入門

Spring框架自學之路——簡易入門

知識 07-18

目錄

  • 目錄
  • 介紹
  • Spring中的IoC操作
  • IoC入門案例
  • Spring的bean管理（配置文件）
  • Bean實例化的方式
  • Bean標籤的常用屬性
  • 屬性注入
  • 使用有參構造函數注入屬性
  • 使用set方法注入屬性
  • 注入對象類型屬性
  • p名稱空間注入屬性
  • 注入複雜類型屬性
  • IoC和DI的區別
  • Spring的bean管理（註解）
  • Spring註解開發準備
  • 註解創建對象
  • 註解注入屬性

介紹

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.";

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

（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>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

（４）編寫測試類進行測試，通過配置文件創建類對象

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();

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

Spring的bean管理（配置文件）

Bean實例化的方式

在Spring中通過配置文件創建對象。

Bean實例化三種方式實現：

（1）使用類的無參數構造創建，如：

<!-- 等同於 user = new com.wm103.ioc.User(); -->

<bean id="user" class="com.wm103.ioc.User"></bean>

  • 1
  • 2

（2）使用靜態工廠創建

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

<!-- 等同於 user = com.wm103.ioc.UserFactory.createInstance(); -->

<bean id="user" class="com.wm103.ioc.UserFactory" factory-method="createInstance"></bean>

  • 1
  • 2

（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>

  • 1
  • 2
  • 3
  • 4

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

"}";

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

bean的配置：

<bean id="student" class="com.wm103.ioc.Student">

<constructor-arg name="name" value="DreamBoy"></constructor-arg>

</bean>

  • 1
  • 2
  • 3

創建Student對象進行測試：

@Test

public void runStudent() {

// 1. 載入Spring配置文件，根據創建對象

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

// 2. 得到配置創建的對象

Student student = (Student) context.getBean("student");

System.out.println(student);

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

使用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 + """ +

"}";

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

bean的配置：

<bean id="teacher" class="com.wm103.ioc.Teacher">

<property name="name" value="Teacher Wu"></property>

</bean>

  • 1
  • 2
  • 3

創建Teacher對象進行測試：

@Test

public void runTeacher() {

// 1. 載入Spring配置文件，根據創建對象

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

// 2. 得到配置創建的對象

Teacher teacher = (Teacher) context.getBean("teacher");

System.out.println(teacher);

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

注入對象類型屬性

以三層架構中的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();

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

UserDao.java

package com.wm103.exp;

/**

* 暴露給service層的介面

* Created by DreamBoy on 2018/3/17.

*/

public interface UserDao {

void add();

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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...");

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

（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>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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

@Test

public void runUserService() {

// 1. 載入Spring配置文件，根據創建對象

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

// 2. 得到配置創建的對象

UserService userService = (UserService) context.getBean("userService");

userService.add();

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

注入複雜類型屬性

對象注入複雜類型屬性，如數組、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;

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

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>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

創建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());

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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.");

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

（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>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

註解創建對象

在創建對象的類上面使用註解實現，如：

@Component(value="user")

public class User {

  • 1
  • 2

創建測試類 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();

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

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

  • @Controller ：WEB層
  • @Service ：業務層
  • @Repository ：持久層
  • 以單例或多實例方式創建對象，默認為單例，多例對象設置註解如下：

@Component(value="user")

@Scope(value="prototype")

public class User {

  • 1
  • 2
  • 3

註解注入屬性

案例：創建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.");

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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();

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

（2）在Service類中定義UserDao類型的屬性，並使用註解完成對象的注入

@Autowired：自動注入或自動裝配，是根據類名去找到類對應的對象來完成注入的。

@Autowired

private UserDao userDao;

  • 1
  • 2

或者 @Resource

@Resource(name="userDao")

private UserDao userDao;

  • 1
  • 2

其中該註解的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
  • 3
  • 4
  • 5
  • 6

註：配置文件和註解混合使用

1）創建對象的操作一般使用配置文件方式實現；

2）注入屬性的操作一般使用註解方式實現。

Spring框架自學之路——簡易入門

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！

本站內容充實豐富，博大精深，小編精選每日熱門資訊，隨時更新，點擊「搶先收到最新資訊」瀏覽吧！


請您繼續閱讀更多來自 程序員小新人學習 的精彩文章:

※Linux下Nginx+多Tomcat負載均衡實現詳解

TAG:程序員小新人學習 |