Spring葵花寶典

一 Spring簡介

Spring是一個輕量級的控制反轉(IoC)和麵向切面(AOP)的容器框架

為了解決企業應用開發的複雜性而建立

 

二 Spring功能

1. 方便解耦 簡化開發

Spring就是一個大工廠 專門負責生成Bean 可以將所有物件建立和依賴關係維護交給Spring管理

2. AOP程式設計的支援

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

3. 宣告式事務的支援

只需要通過配置就可以完成對事務的管理 而無需手動程式設計

4. 方便程式的測試

Spring對Junit4支援 可以通過註解方便的測試Spring程式

5. 方便整合各種優秀框架

Spring不排斥各種優秀的開源框架 其內部提供了對各種優秀框架的支援

6. 降低JavaEE API的使用難度

對JavaEE開發中一些難用的API(JDBC JavaMail WebService等) 都提供了封裝 使這些API應用難度大大降低

 

三 Spring體系結構

 

四 Spring初體驗

1. 新建一個Maven專案

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.hy.spring</groupId>
    <artifactId>spring-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 定義依賴版本號 -->
    <properties>
        <junit.version>4.12</junit.version>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>

    <!-- 管理jar版本號 -->
    <dependencyManagement>
        <dependencies>
            <!-- junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!-- spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 編譯 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 介面

public interface IUserService {

    void insertUser();
}

3. 實現類

public class UserService implements IUserService {

    @Override
    public void insertUser() {
        System.out.println("UserService insert ok");
    }
}

4. 裝配Bean resources/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-4.2.xsd">

    <bean id="userService" class="com.hy.spring.service.UserService" />
</beans>

5. Spring控制反轉建立例項

@Test
public void test01() {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    IUserService service = (UserService) context.getBean("userService");
    service.insertUser();
}

 

五 IoC

Inversion of Control 控制反轉

將原本在程式中手動建立物件的控制權 交由Spring框架管理

1. xml裝配

a. new實現類

<?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-4.2.xsd">

    <!-- 第一種裝配方式 new實現類 -->
    <bean id="userService1" class="com.hy.spring.service.UserService" />
</beans>

b. 靜態工廠方法

public class UserServiceFactory1 {

    public static UserService createUserService() {
        return new UserService();
    }
}

<?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-4.2.xsd">

    <!-- 第二種裝配方式 靜態工廠方法 -->
    <bean id="userService2" class="com.hy.spring.factory.UserServiceFactory1" factory-method="createUserService" />
</beans>

c. 例項工廠方法

public class UserServiceFactory2 {

    public UserService createUserService() {
        return new UserService();
    }
}

<?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-4.2.xsd">

    <!-- 第三種裝配方式 例項工廠方法 -->
    <bean id="factory2" class="com.hy.spring.factory.UserServiceFactory2" />
    <bean id="userService3" factory-bean="factory2" factory-method="createUserService" />
</beans>

2. 註解裝配

a. 開啟註解 配置掃描的位置

<?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-4.2.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 開啟註解 -->
    <context:annotation-config />

    <!-- 掃描的位置 -->
    <context:component-scan base-package="com.hy.spring" />
</beans>

b. @Component

1> @Component 取代 <bean class="" /> -> ApplicationContext#getBean(Class clazz)

2> @Component("id") 取代 <bean id="" class="" /> -> ApplicationContext#getBean(String id)

3> 在實際Web開發中 提供3個@Component衍生註解(功能一樣) 請使用衍生註解

　　@Repository -> dao層

　　@Service -> service層

　　@Controller -> web層

 

六 DI

Dependency Injection 依賴注入

在Spring框架負責建立Bean物件時 動態的將依賴物件注入到Bean

1. xml注入

普通資料<value> 引用資料<ref>

a. 屬性setter方法注入

<?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-4.2.xsd">

    <bean id="userService" class="com.hy.spring.service.UserService" />

    <bean id="userServiceX" class="com.hy.spring.service.UserServiceX">
        <!-- 依賴注入資料 呼叫屬性的set方法 -->
        <property name="name" value="nike" />
        <property name="service" ref="userService" />

        <!-- Array -->
        <property name="arg0">
            <array>
                <value>高考</value>
                <value>加油</value>
            </array>
        </property>

        <!-- List -->
        <property name="arg1">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </list>
        </property>

        <!-- Set -->
        <property name="arg2">
            <set>
                <value>1.23</value>
            </set>
        </property>

        <!-- Map -->
        <property name="arg3">
            <map>
                <entry key="age" value="10" />
            </map>
        </property>

        <!-- Properties -->
        <property name="arg4">
            <props>
                <prop key="name">hy</prop>
            </props>
        </property>
    </bean>
</beans>

b. 構造方法注入

<?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-4.2.xsd">

    <bean id="userService" class="com.hy.spring.service.UserService" />

    <bean id="userServiceX" class="com.hy.spring.service.UserServiceX">
        <!-- 依賴注入資料 通過構造方法 方式一 -->
        <constructor-arg name="name" value="nike" />
        <constructor-arg name="service" ref="userService" />
    </bean>
</beans>

<?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-4.2.xsd">

    <bean id="userService" class="com.hy.spring.service.UserService" />

    <bean id="userServiceX" class="com.hy.spring.service.UserServiceX">
        <!-- 依賴注入資料 通過構造方法 方式二 -->
        <constructor-arg index="0" value="nike" type="java.lang.String" />
        <constructor-arg index="1" ref="userService" type="com.hy.spring.service.UserService" />
    </bean>
</beans>

c. p名稱空間注入

<?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-4.2.xsd">

    <bean id="userService" class="com.hy.spring.service.UserService" />

    <!-- 依賴注入資料 通過p名稱空間 -->
    <bean id="userServiceX" class="com.hy.spring.service.UserServiceX" p:name="nike" p:service-ref="userService" />
</beans>

2. 註解注入

a. 開啟註解 配置掃描的位置

<?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-4.2.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 開啟註解 -->
    <context:annotation-config />

    <!-- 掃描的位置 -->
    <context:component-scan base-package="com.hy.spring" />
</beans>

b. @Autowired

1> @Autowired -> 自動根據型別注入

2> @Autowired + @Qualifier("id") = @Resource(name = "id") -> 自動根據id注入

 

七 載入Spring容器的三種方式

1. 類路徑獲得配置檔案

@Test
public void test01() {
    // 類路徑獲得配置檔案 classes路徑 target中檢視
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    IUserService service = (UserService) context.getBean("userService");
    System.out.println("IUserService = " + service);
}

2. 檔案系統路徑獲得配置檔案

@Test
public void test02() {
    // 檔案系統路徑獲得配置檔案 絕對路徑
    String path = "//Users/HUANGYI/Desktop/Java/spring-demo/src/main/resources/beans.xml";
    ApplicationContext context = new FileSystemXmlApplicationContext(path);
    IUserService service = (UserService) context.getBean("userService");
    System.out.print("IUserService = " + service);
}

3. BeanFactory 已過時

 

八 Bean的作用域

resources/beans.xml <bean scope="singleton" /> 或 註解 @Scope("singleton")

1. singleton 預設值 在Spring IoC容器中僅存在一個Bean例項 Bean以單例方式存在

2. prototype 每次從容器中呼叫Bean時 都返回一個新的例項 即每次呼叫getBean()時 相當於執行new Bean()

3. request 每次HTTP請求都會建立一個新的Bean 僅適用於WebApplicationContext環境

4. session 同一個Session共享一個Bean 不同Session使用不同Bean 僅適用於WebApplicationContext環境

 

九 AOP

Aspect Oriented Programming 面向切面

通過預編譯方式和執行期動態代理實現程式功能統一維護的一種技術

1. 功能

a. 對業務邏輯各部分進行隔離 從而使業務邏輯各部分之間的耦合度降低 提高程式的可重用性 同時提高了開發效率

b. 採取橫向抽取機制 取代了傳統縱向繼承體系重複性程式碼

c. 使用純Java實現 不需要專門的編譯過程和類載入器 在執行期通過代理方式向目標類織入增強程式碼

d. 常用於事務管理 效能監視 安全檢查 快取 日誌...

2. 實現原理

底層採用代理模式進行實現 有兩種實現方式

a. 動態代理(介面代理)

b. CGLIB代理(子類代理)

3. 術語

Target: 目標 需要被代理的類

JoinPoint: 連線點 可能被攔截到的方法

Pointcut: 切入點 已經被增強的連線點

Advice: 通知 增強程式碼

Weaving: 織入 把通知Advice應用到目標物件Target來建立代理物件Proxy的過程

Proxy: 代理

Aspect: 切面 切入點Pointcut和通知Advice的結合

4. 使用AspectJ進行AOP的開發

AspectJ是一個基於Java語言的AOP框架 Spring2.0開始 Spring引入對AspectJ的支援 AspectJ擴充套件了Java語言 提供了一個專門的編譯器 在編譯時提供橫向程式碼的織入 新版本Spring框架 建議使用AspectJ進行AOP的開發

a. xml方式

1> 介面

public interface IUserService {

    void insertUser();

    void deleteUser(int id);

    String selectUser(int id);
}

2> 業務類

public class UserService implements IUserService {

    @Override
    public void insertUser() {
        System.out.println("UserService insert ok");
    }

    @Override
    public void deleteUser(int id) {
        int i = id / 0; //模擬異常
    }

    @Override
    public String selectUser(int id) {
        return "HUANGYI";
    }
}

3> 切面類

public class Aspect {

    /**
     * 前置通知 在方法執行前執行 如果通知丟擲異常 阻止方法執行
     * @param joinPoint 連線點
     */
    public void before(JoinPoint joinPoint) {
        System.out.println("前置通知 JoinPoint = " + joinPoint.toString());
    }

    /**
     * 後置通知 方法正常返回後執行 可以獲得方法返回值 如果方法中丟擲異常 通知無法執行
     * @param joinPoint 連線點
     * @param ret 方法返回值
     */
    public void afterReturning(JoinPoint joinPoint, Object ret) {
        System.out.println("後置通知 ret = " + ret + " JoinPoint = " + joinPoint.toString());
    }

    /**
     * 環繞通知 方法執行前後分別執行 可以阻止方法的執行 必須手動執行目標方法
     * @param proceedingJoinPoint ProceedingJoinPoint
     * @return 方法返回值
     * @throws Throwable 異常
     */
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("環繞通知 - 前");
        Object object = proceedingJoinPoint.proceed();
        System.out.println("環繞通知 - 後 ");
        return object + "!!!";
    }

    /**
     * 異常通知 方法丟擲異常後執行 如果方法沒有丟擲異常 無法執行
     * @param joinPoint 連線點
     * @param throwable 異常
     */
    public void afterThrowing(JoinPoint joinPoint, Throwable throwable) {
        System.out.println("異常通知 Throwable = " + throwable.getMessage() + " JoinPoint = " + joinPoint.toString());
    }

    /**
     * 最終通知 方法執行完畢後執行 無論方法中是否出現異常
     * @param joinPoint 連線點
     */
    public void after(JoinPoint joinPoint) {
        System.out.println("最終通知 JoinPoint = " + joinPoint.toString());
    }
}

4> 裝配Bean resources/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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 業務類 -->
    <bean id="userService" class="com.hy.spring.service.UserService" />

    <!-- 切面類 -->
    <bean id="aspect" class="com.hy.spring.aspect.Aspect" />

    <!-- proxy-target-class true=CGLIB代理 -->
    <aop:config proxy-target-class="true">
        <aop:aspect ref="aspect">
            <!-- expression(表示式): 切點表示式 -->
            <!-- * com.hy.spring.service..*.*(..)
                    * = 任意返回值
                    com.hy.spring.service. = com.hy.spring.service包和所有子包
                    .*.* = .任意類.任意方法名
                    (..) = 任意引數 -->
            <aop:pointcut id="pointcut" expression="execution(* com.hy.spring.service..*.*(..))" />

            <!-- 前置通知 -->
            <aop:before pointcut-ref="pointcut" method="before" />

            <!-- 後置通知 returning ret=方法返回值的引數名 -->
            <aop:after-returning pointcut-ref="pointcut" method="afterReturning" returning="ret" />

            <!-- 環繞通知 -->
            <aop:around pointcut-ref="pointcut" method="around" />

            <!-- 異常通知 throwing throwable=異常的引數名 -->
            <aop:after-throwing pointcut-ref="pointcut" method="afterThrowing" throwing="throwable" />

            <!-- 最終通知 -->
            <aop:after pointcut-ref="pointcut" method="after" />
        </aop:aspect>
    </aop:config>
</beans>

5> 測試

public class XTest {

    @Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = (IUserService) context.getBean("userService");
        service.insertUser();
    }

    @Test
    public void test02() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = (IUserService) context.getBean("userService");
        service.selectUser(1);
    }

    @Test
    public void test03() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = (IUserService) context.getBean("userService");
        service.deleteUser(1);
    }
}

b. 註解方式

1> 開啟註解 配置掃描的位置

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 開啟AOP註解 -->
    <aop:aspectj-autoproxy />

    <!-- 掃描的位置 -->
    <context:component-scan base-package="com.hy.spring" />

    <!-- proxy-target-class true=CGLIB代理 -->
    <aop:config proxy-target-class="true" />
</beans> 

2> 介面

public interface IUserService {

    void insertUser();

    void deleteUser(int id);

    String selectUser(int id);
}

3> 業務類

@Service("userService")
public class UserService implements IUserService {

    @Override
    public void insertUser() {
        System.out.println("UserService insert ok");
    }

    @Override
    public void deleteUser(int id) {
        int i = id / 0; //模擬異常
    }

    @Override
    public String selectUser(int id) {
        return "HUANGYI";
    }
}

4> 切面類

@Component
@org.aspectj.lang.annotation.Aspect
public class Aspect {

    /**
     * 宣告公共切入點
     * expression(表示式): 切點表示式
     * * com.hy.spring.service..*.*(..)
     * * = 任意返回值
     * com.hy.spring.service. = com.hy.spring.service包和所有子包
     * .*.* = .任意類.任意方法名
     * (..) = 任意引數
     */
    @Pointcut("execution(* com.hy.spring.service..*.*(..))")
    public void pointcut() {}

    /**
     * 前置通知 在方法執行前執行 如果通知丟擲異常 阻止方法執行
     * @param joinPoint 連線點
     */
    @Before("execution(* com.hy.spring.service..*.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("前置通知 JoinPoint = " + joinPoint.toString());
    }

    /**
     * 後置通知 方法正常返回後執行 可以獲得方法返回值 如果方法中丟擲異常 通知無法執行
     * @param joinPoint 連線點
     * @param ret 方法返回值
     */
    @AfterReturning(value = "pointcut()", returning = "ret")
    public void afterReturning(JoinPoint joinPoint, Object ret) {
        System.out.println("後置通知 ret = " + ret + " JoinPoint = " + joinPoint.toString());
    }

    /**
     * 環繞通知 方法執行前後分別執行 可以阻止方法的執行 必須手動執行目標方法
     * @param proceedingJoinPoint ProceedingJoinPoint
     * @return 方法返回值
     * @throws Throwable 異常
     */
    @Around(value = "pointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("環繞通知 - 前");
        Object object = proceedingJoinPoint.proceed();
        System.out.println("環繞通知 - 後 ");
        return object + "!!!";
    }

    /**
     * 異常通知 方法丟擲異常後執行 如果方法沒有丟擲異常 無法執行
     * @param joinPoint 連線點
     * @param throwable 異常
     */
    @AfterThrowing(value = "pointcut()", throwing = "throwable")
    public void afterThrowing(JoinPoint joinPoint, Throwable throwable) {
        System.out.println("異常通知 Throwable = " + throwable.getMessage() + " JoinPoint = " + joinPoint.toString());
    }

    /**
     * 最終通知 方法執行完畢後執行 無論方法中是否出現異常
     * @param joinPoint 連線點
     */
    @After(value = "pointcut()")
    public void after(JoinPoint joinPoint) {
        System.out.println("最終通知 JoinPoint = " + joinPoint.toString());
    }
}

5> 測試

public class XTest {

    @Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = (IUserService) context.getBean("userService");
        service.insertUser();
    }

    @Test
    public void test02() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = (IUserService) context.getBean("userService");
        service.selectUser(1);
    }

    @Test
    public void test03() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = (IUserService) context.getBean("userService");
        service.deleteUser(1);
    }
}

5. 使用AOP進行事務配置 框架整合時講解