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

時間 2019-11-26

原文原文鏈接

介紹

　　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層）]中，每一層均提供了不一樣的解決技術。以下：java

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

Spring中的IoC操做

　　將對象的建立交由Spring框架進行管理。
　　IoC操做分爲：IoC配置文件方式和IoC的註解方式。spring

IoC入門案例

（1）導入Spring框架中的相關jar包，這裏只導入Spring的Core模塊下的jar包（Core模塊是框架的核心類庫），以及支持日誌輸出的 commons-logging 和 log4j 的jar包；
（2）建立一個普通的Java類，並在該類中建立方法，以下：
　　User.javaexpress

package com.wm103.ioc;

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

（3）建立Spring的配置文件，進行Bean的配置
　　Spring的核心配置文件名稱和位置不是固定的。但官方件建議將該核心配置文件放在src目錄下，且命名爲 applicationContext.xml。
　　這裏爲了方便，將核心配置文件放在src目錄下，並命名爲 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" 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 2017/5/31. */ public class TestIoC { @Test public void testUser() { // 1. 加載Spring配置文件，根據建立對象 ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); // 2. 獲得配置建立的對象 User user = (User) context.getBean("user"); System.out.println(user); user.add(); } }

Spring的bean管理（配置文件）

Bean實例化的方式

　　在Spring中經過配置文件建立對象。
　　Bean實例化三種方式實現：
（1）使用類的無參數構造建立，如：session

<!-- 等同於 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屬性配置爲產生實例的方法。如：app

<!-- 等同於 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方法設置屬性或採用有參構造函數建立對象並初始化屬性。ide

使用有參構造函數注入屬性

　　案例：
　　Demo1.java 提供有參的構造方法

package com.wm103.ioc;
public class Demo1 { private String demoName; public Demo1(String demoName) { this.demoName = demoName; } public void out() { System.out.println("This is Demo1."); } }

　　bean的配置：

<bean id="demo1" class="com.wm103.ioc.Demo1"> <constructor-arg name="demoName" value="Demo1"></constructor-arg> </bean>

　　建立Demo1對象進行測試：

@Test
public void testDemo1() { // 1. 加載Spring配置文件，根據建立對象 ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); // 2. 獲得配置建立的對象 Demo1 demo1 = (Demo1) context.getBean("demo1"); System.out.println(demo1); demo1.out(); }

使用set方法注入屬性

　　案例：
　　Demo2.java 提供屬性的set方法

package com.wm103.ioc;
public class Demo2 { private String demoName; public void setDemoName(String demoName) { this.demoName = demoName; } public void out() { System.out.println("This is Demo2."); } }

　　bean的配置：

<bean id="demo2" class="com.wm103.ioc.Demo2"> <property name="demoName" value="Demo2"></property> </bean>

　　建立Demo2對象進行測試：

@Test
public void testDemo2() { // 1. 加載Spring配置文件，根據建立對象 ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); // 2. 獲得配置建立的對象 Demo2 demo2 = (Demo2) context.getBean("demo2"); System.out.println(demo2); demo2.out(); }

注入對象類型屬性

　　以三層架構中的service層和dao層爲例，爲了讓service層使用dao層的類建立的對象，須要將dao對象注入到service層類中。具體實現過程當中以下：
（1）建立service類、dao層接口、dao類，以下：
UserService.java

package com.wm103.ioc;
public class UserService { private UserDao userDao; // 聲明爲接口類型，下降service層與dao層的耦合度，不依賴於dao層的具體實現 public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void add() { System.out.println("service add..."); this.userDao.add(); } }

UserDao.java

package com.wm103.ioc; /** * 暴露給service層的接口 * Created by DreamBoy on 2017/5/31. */ public interface UserDao { void add(); }

UserDaoImpl.java

package com.wm103.ioc; /** * 接口的具體實現 * Created by DreamBoy on 2017/5/31. */ public class UserDaoImpl implements UserDao { @Override public void add() { System.out.println("dao add..."); } }

（2）在配置文件中注入關係，以下：

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

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

@Test
    public void testUserService() { ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); UserService userService = (UserService) context.getBean("userService"); System.out.println(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="demo2" class="com.wm103.ioc.Demo2" p:demoName="DEMO2"></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 void setArrs(String[] arrs) { this.arrs = arrs; } public void setList(List<String> list) { this.list = list; } public void setMap(Map<String, String> map) { this.map = map; } public void setProperties(Properties properties) { this.properties = properties; } public String[] getArrs() { return arrs; } public List<String> getList() { return list; } public Map<String, String> getMap() { return map; } public Properties getProperties() { return 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="pdemo" 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> <property name="properties"> <props> <prop key="username">root</prop> <prop key="password">123</prop> </props> </property> </bean> </beans>

IoC和DI的區別

　　IoC，控制反轉，把對象的建立交給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..."); } }

（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 testUser() { ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); User user = (User) context.getBean("user"); System.out.println(user); user.add(); } }

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

@Controller ：WEB層
@Servlet ：業務層
@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..."); } }

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

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

@Autowired private UserDao userDao;

或者 @Resource

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

　　其中該註解的name屬性值爲註解建立Dao對象的value屬性的值。
　　這兩種註解方式都不要爲須要注入的屬性定義set方法。
（3）建立測試方法

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

注：配置文件和註解混合使用 1）建立對象的操做通常使用配置文件方式實現； 2）注入屬性的操做通常使用註解方式實現。