【java框架】Spring(1) -- Spring入門

Spring入門

1.   Spring認識

Spring是一個輕量級的DI（IOC）和AOP的容器框架。

IOC（Inverse of control）：控制反轉，把業務層管理數據層生命周期的控制權交給Spring容器去管理，自己不再去管理數據層的生命周期（創建對象，銷毀對象）。

DI（Dependence inject）：依賴注入，對象的創建和實例化不再通過原本new的方式，而是使用Spring進行對象注入。

AOP（Aspect Oriented Programming）：面向切面編程。通過預編譯方式和運行期動態代理（在執行某件事情之前或者之后做一些其他事情）實現程序功能的統一維護的一種技術。AOP一般用於：日志記錄、性能統計、安全控制、權限管理、事務處理、異常處理等。

 

2.   完成一個Hello World的Spring

2.1．導入jar包

Spring Framework框架下載可以到Spring的官方社區進行下載：

https://spring.io/projects/spring-framework

這里學習Spring Framework以老版本spring-framework-4.1.2.RELEASE為例。

在\spring-framework-4.1.2.RELEASE\libs文件夾中導入核心包與beans包：

 

2.2. 創建配置文件applicationContext.xml

配置文件的命名可以是：application.xml、application-context.xml、applicationContext.xml、beans.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="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
</beans>

2.3. 完成Bean創建測試

import cn.yif.helloBean.MyBean;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class MyBeanTest {

    @org.junit.Test
    public void TestHello() {
        //讀取資源文件applicationContext.xml
        Resource resource = new ClassPathResource("applicationContext.xml");
        //拿到核心對象BeanFactory
        BeanFactory factory = new XmlBeanFactory(resource);
        MyBean myBean = (MyBean)factory.getBean("myBean");
        System.out.println(myBean);
    }
}

3.   BeanFactory與ApplicationContext

BeanFactory與ApplicationContext都是Spring用來實例化、配置和管理對象的接口，都有獲取getBean()的方法，它們兩個創建對應的對象去獲取Bean的方式都是一樣的。

ApplicationContext是繼承BeanFactory接口，相比於BeanFactory功能更強大，比如在國際化支持、資源訪問（URL與文件）、事件傳播等方面都有良好的支持。

3.1.   ApplicationContext的使用

導入jar包：

spring-context-4.1.2.RELEASE.jar

spring-expression-4.1.2.RELEASE.jar

獲取Bean對象：

//讀取資源文件applicationContext.xml
//拿到ApplicationContext核心對象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("-------------實例化分割線--------------------");
//獲取Bean同樣具有三種方式：這里不再一一列出
MyBean myBean = (MyBean)applicationContext.getBean("myBean");
System.out.println(myBean);

相對於BeanFactory，ApplicationContext在加載對象時是迫切加載，在啟動容器創建上下文環境的時候就創建Bean對象，而BeanFactory是懶加載，是在使用時才創建Bean對象。

3.2.  ApplicationContext配置懶加載

配置一：讓所有Bean都變成懶加載，配置default-lazy-init="true"

<?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"
default-lazy-init="true">
    <bean id="myBean" class="cn.yif.helloBean.MyBean">
    </bean>
</beans>

配置二：讓其中一個指定的Bean變成懶加載，配置lazy-init="true"

<bean id="myBean" class="cn.yif.helloBean.MyBean" lazy-init="true">
</bean>

 

4.   Spring的測試

傳統的測試是java中自帶的Junit4測試，如下圖：

而Spring自帶了一套自己的測試框架功能，如下圖：

Spring的測試可以在配置文件不能讀取的情況下（不啟動服務器），自動讀取相應的配置文件。

 

4.1. 完成Spring測試功能

導入對應的包：

spring-test-4.1.2.RELEASE.jar

spring-aop-4.1.2.RELEASE.jar

 

import cn.yif.testBean.TestBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @RunWith:代表你現在使用哪一個Junit環境來做Spring
 * SpringJUnit4ClassRunner:代表是Junit4的測試環境，使用的是Spring的測試
 */
@RunWith(SpringJUnit4ClassRunner.class)
/**
 * ContextConfiguration：找到我們的核心配置文件
 * 這里配置路徑有三種方式：
 * 方式一（web工程，正式開發時使用）：
 * /applicationContext.xml -> 從classpath的根目錄開始(不建議使用)
 * classpath:cn/yif/helloBean/applicationContext.xml ->從classpath的根目錄開始(正式開發)
 * 方式二(測試的時候使用)：
 * applicationContext.xml -> 當前目錄下面開始查找
 * 方式三：(測試的時候使用)
 * 在當前目錄下來創建xml的名稱為：測試類名-Context.xml
 * 例：SpringTest-Context.xml
 * (使用這種方式，@ContextConfiguration可以不加參數)
 */
@ContextConfiguration("/applicationContext.xml")
//@ContextConfiguration()
public class SpringTest {
    @Autowired
    private ApplicationContext context;

    @Autowired
    private TestBean testBean;

    @Test
    public void testGetBean() {
        System.out.println(testBean);
    }

}

5.   Spring中Bean對象作用域

Bean配置節點中有個屬性scope

這個可以讓注入的Bean生成單例或者是多例；

默認是singleton，單例；

prototype，多例，比如struts2的action必須配置多例

<bean id="myBean" class="cn.yif.helloBean.MyBean" lazy-init="true" scope="singleton">
 </bean>
 <bean id="testBean" class="cn.yif.testBean.TestBean" scope="prototype">
 </bean>

 

使用prototype與singleton在實際中的區別：

①singleton在創建bean對象時只會創建一個，而prototype會創建多個（調用getBean()就會創建）；

②singleton在加載applicationContext.xml配置文件時就會創建Bean的實例，而prototype則是在調用getBean時實例化Bean。

6.   Spring的注入功能

6.1.基於普通類的注入

Spring普通類的注入方式：

基於Dao→Service→Action三層模型來說明：

①    首先在Action層面需要注入Service層的實現Impl類，使用@Autowired標簽，並需要在類中提供Set方法，給注入的屬性賦值；

 

②    同樣的方式需要在Service中注入Dao實現類，並給予Set方法，賦值注入的屬性；

 

③   配置對應的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="userDao" class="cn.yif.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="cn.yif.service.Impl.UserServiceImpl">
        <!--name:注意這里的name值必須和UserServiceImpl類中的UserDaoImpl屬性名稱一致，而且必須提供set方法；
            否則無法注入
            ref：反向去找引用的哪個bean的id
            id:這里的bean中的id只是一個標識，id唯一就可以，命名沒有要求-->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userAction" class="cn.yif.action.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>
</beans>

6.2.獲取JDBC連接池屬性

Spring來管理JDBC連接池，可以使項目在運行時由Spring框架去管理連接數，何時斷開連接，合理分配資源。

利用Spring獲取applicationContext.xml配置時加載jdbc.properties配置文件獲取連接信息。

①    在操作前，需要預先導入相應的dbcp的連接jar包，而且操作數據庫，需要數據庫的驅動包，具體需要導入：

com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar

com.springsource.org.apache.commons.pool-1.5.3.jar

mysql-connector-java-5.1.26-bin.jar

或者Maven配置如下：

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.26</version>
</dependency>
<dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>com.springsource.org.apache.commons.pool</artifactId>
     <version>1.5.3</version>
 </dependency>
 <!--<dependency>  jar包依賴錯誤，會報：Caused by:
  java.lang.ClassNotFoundException: org.apache.commons.dbcp.BasicDataSource-->
  <!--<groupId>org.apache.commons</groupId>-->
  <!--<artifactId>com.springsource.org.apache.commons.dbcp</artifactId>-->
  <!--<version>1.2.2.osgi</version>-->
  <!--</dependency>-->
 <dependency>
       <groupId>commons-dbcp</groupId>
       <artifactId>commons-dbcp</artifactId>
       <version>1.2.2</version>
</dependency>

在Maven中可能需要使用com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar包版本問題，建議做如上配置。

 

②    首先需要配置applicationContext.xml文件；

注意需要引入context命名空間和約束路徑：

• 命名空間：xmlns:context="http://www.springframework.org/schema/context
• 約束路徑：http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!--導入外部的jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 配置一個DBCP的Bean destroy-method="close"：每次取用關閉連接池-->
    <bean id="dateSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <!-- 注意：這里我們不是使用的ref引用，而是直接寫的value，因此注入的數據是一個變通的值 -->
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

</beans>

③   配置好jdbc.properties文件；

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring01_0305
jdbc.username=root
jdbc.password=admin

④    創建SpringJunit4測試；

import org.apache.commons.dbcp.BasicDataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.sql.Connection;
import java.sql.SQLException;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/applicationContext.xml")
public class SpringJDBCPoolTest {
    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void insert() {
        //使用ApplicationContext對象來獲取bean對象
        BasicDataSource bean = applicationContext.getBean("dateSource", BasicDataSource.class);
        Connection connection = null;
        try {
            connection = bean.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println(connection);
    }
}

 

本節Spring相關示例代碼已上傳至GitHub地址：

https://github.com/devyf/JavaWorkSpace/tree/master/Spring01_0304