Spring框架入門

Spring框架java

1、什麼是Spring 

      Spring框架是因爲軟件開發的複雜性而建立的。Spring使用的是基本的JavaBean來完成之前只可能由EJB完成的事情。然而,Spring的用途不只僅限於服務器端的開發。從簡單性、可測試性和鬆耦合性角度而言,絕大部分Java應用均可以從Spring中受益。Spring是一個輕量級控制反轉(IoC)和麪向切面(AOP)的容器框架。
 ◆目的:解決企業應用開發的複雜性
 ◆功能:使用基本的JavaBean代替EJB,並提供了更多的企業應用功能
 ◆範圍:任何Java應用
                                                                   ----------------百度百科
2、什麼是IOC
  控制反轉(Inversion of Control,英文縮寫爲IoC)把建立對象的權利交給框架,是框架的重要特徵,並不是面向對象編程的專用術語。它包括依賴注入和依賴查找。 傳統的業務層,當須要資源時就在該業務層new資源,這樣耦合性(程序之間相互依賴關聯)較高。如今將new的部分交給spring,作到高內聚低耦合。簡而言之:原先是每當調用dao層或service層方法時,由appnew,如今是將new的權利交給spring,要什麼資源從spring中獲取!
 
3、快速搭建框架環境
  1.下載框架所需的依賴jar包
   spring官網爲: http://spring.io/
    2.導入基本jar包
   

   其實基本核心jar有beans;context;core;expression包,其餘是依賴log4j日誌。固然spring的jar不止這些,後期慢慢加上。mysql

  3.配置log4j配置文件web

   日誌文件定義在src目錄下spring

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

  4.測試日誌文件是否部署成功sql

package com.clj.demo1;

import org.apache.log4j.Logger;
import org.junit.Test;

/**
 * 演示日誌用法
 * @author Administrator
 *
 */
public class Demo1 {
    //建立日誌類
    private Logger log=Logger.getLogger(Demo1.class);
    @Test
    public void run1(){
        //能夠將log4j.rootLogger屬性中的info改成off則不會再控制檯顯示
        log.info("執行了");
    }
}

  5.定義一個接口和實現類數據庫

   接口:express

package com.clj.demo2;

public interface UserService {
    public void sayHello();
}

   實現類apache

package com.clj.demo2;

public class UserServiceImpl implements UserService{
    private String name;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void init(){
        System.out.println("初始化。。");
    }
    public void sayHello() {
        System.out.println("Hello Spring"+"\t"+name);
    }
    public void destory(){
        System.out.println("銷燬。。");
    }

}

  6.定義spring專屬的配置文件編程

    定義名爲applicationContext.xml,位置爲src下,與日誌文件同目錄,導入相對應的約束,並將實現類注入到配置文件中,剛開始入門,使用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"
    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標籤  
         1.id值惟一(必寫)
        2.注意:class爲實現類路徑,不是接口(必寫)
        3.init-method核心方法執行以前初始化工做(選寫)
        4.destroy-method核心方法執行以後初始化工做(選寫)-->
     <bean id="userService" class="com.clj.demo2.UserServiceImpl" init-method="init" destroy-method="destory">
         <property name="name" value="佳先森"></property>
     </bean>
</beans>

   7.測試

public class Demo1 {
    /**
     * 原始方式
     */
    @Test
    public void run(){
        //建立實現類
        UserServiceImpl s=new UserServiceImpl();
        s.setName("佳先森");
        s.sayHello();
    }
    /**
     * 老的工廠版本BeanFactory
     * 舊的工廠不會建立配置文件對象
     */
    @Test
    public void run2(){
        BeanFactory factory=new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        UserService us=(UserService)factory.getBean("userService");
        us.sayHello();
    }
    /**
     * 使用spring框架IOC方式
     * 新版本factory建立啓動服務器會建立配置文件對象,再次調用時無需加載工廠
     */
    @Test
    public void run3(){
        //建立工廠,加載核心配置文件(ClassPathXmlApplicationContext從src下找)
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        //從工廠中獲取到對象(配置文件中的id值,這裏用了多態)
        UserService usi=(UserService) ac.getBean("userService");
        //調用對象的方法執行
        usi.sayHello();
    }
    /**
     * 演示destroy-method方法
     * bean摧毀方法不會自動執行
     * 除非scope= singleton或者web容器中會自動調用,可是main函數或測試用例須要手動調用(須要使用ClassPathXmlApplicationContext的close()方法)
     */
    @Test
    public void run4(){
        //建立工廠,加載核心配置文件(ClassPathXmlApplicationContext從src下找)
        ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        //從工廠中獲取到對象(配置文件中的id值,這裏用了多態)
        UserService usi=(UserService) ac.getBean("userService");
        //調用對象的方法執行
        usi.sayHello();
        //ApplicationContext實現類提供close方法,將工廠關閉就可執行destory-method方法
        ac.close();
    }
}

    其中舊工廠與新工廠的區別 

        * BeanFactory和ApplicationContext的區別

        * BeanFactory               -- BeanFactory採起延遲加載,第一次getBean時纔會初始化Bean

        * ApplicationContext      -- 在加載applicationContext.xml時候就會建立具體的Bean對象的實例,還提供了一些其餘的功能

            * 事件傳遞

            * Bean自動裝配

            * 各類不一樣應用層的Context實現

  總結:這是個最基本的demo,是將實現類配置到了spring配置文件中,每次啓動服務器時,就會加載配置文件,從而實例化了實現類

4、spring之依賴注入

  一、什麼是依賴注入?

  Spring 能有效地組織J2EE應用各層的對象。無論是控制層的Action對象,仍是業務層的Service對象,仍是持久層的DAO對象,均可在Spring的 管理下有機地協調、運行。Spring將各層的對象以鬆耦合的方式組織在一塊兒,Action對象無須關心Service對象的具體實現,Service對 象無須關心持久層對象的具體實現,各層對象的調用徹底面向接口。當系統須要重構時,代碼的改寫量將大大減小。依賴注入讓bean與bean之間以配置文件組織在一塊兒,而不是以硬編碼的方式耦合在一塊兒。理解依賴注入

    依賴注入(Dependency Injection)和控制反轉(Inversion of Control)是同一個概念。具體含義是:當某個角色(多是一個Java實例,調用者)須要另外一個角色(另外一個Java實例,被調用者)的協助時,在 傳統的程序設計過程當中,一般由調用者來建立被調用者的實例。但在Spring裏,建立被調用者的工做再也不由調用者來完成,所以稱爲控制反轉;建立被調用者 實例的工做一般由Spring容器來完成,而後注入調用者,所以也稱爲依賴注入。

無論是依賴注入,仍是控制反轉,都說明Spring採用動態、靈活的方式來管理各類對象。對象與對象之間的具體實現互相透明。  

  2. IOC和DI的概念

  * IOC -- Inverse of Control,控制反轉,將對象的建立權反轉給Spring!!

  * DI -- Dependency Injection,依賴注入,在Spring框架負責建立Bean對象時,動態的將依賴對象注入到Bean組件中!!

  3.演示

  對於類成員變量,經常使用的注入方式有兩種

       屬性set方法注入和構造方法注入

      先演示第一種:屬性set方法注入

   1)持久層

package com.clj.demo3;

public class CustomerDaoImpl {
    public void save(){
        System.out.println("我是持久層的Dao");
    }
}

   2)業務層

   注意:此時是想將持久層注入到業務層,將建立持久層實例權利交給框架,條件是業務層必須提供持久層的成員屬性和set方法

package com.clj.demo3;
/**
 * 依賴注入之將dao 層注入到service層
 * @author Administrator
 *
 */
public class CustomerServiceImpl{
    //提供成員屬相,提供set方法
    private CustomerDaoImpl customerDao;
    
    public void setCustomerDao(CustomerDaoImpl customerDao) {
        this.customerDao = customerDao;
    }

    public void save(){
        System.out.println("我是業務層的service...");
        //1.原始方式
        //new CustomerDaoImpl().save();
        
        //2.spring 之IOC方式
        customerDao.save();
    }
}

   3)配置文件配置

 <!-- 演示依賴注入 -->
     <bean id="customerDao" class="com.clj.demo3.CustomerDaoImpl"/>
     <bean id="customerService" class="com.clj.demo3.CustomerServiceImpl">
             <!-- 將Dao注入到service層 -->
            <property name="customerDao" ref="customerDao"></property>
     </bean>

   4)測試

/**
     * spring 依賴注入方式
     * 將dao層注入到service層
     */
    @Test
    public void run2(){
        //建立工廠,加載配置文件,customerService被建立,從而也建立了customerDao
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerServiceImpl csi=(CustomerServiceImpl) context.getBean("customerService");
        csi.save();
    }

   第二種:構造方法注入

  1)pojo類並提供構造方法

package com.clj.demo4;
/**
 * 演示的構造方法的注入方式
 * @author Administrator
 *
 */
public class Car1 {
    private String cname;
    private Double price;
    public Car1(String cname, Double price) {
        super();
        this.cname = cname;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car1 [cname=" + cname + ", price=" + price + "]";
    }
    
}

   2)配置文件配置

         <!-- 演示構造方法注入方式 -->
     <bean id="car1" class="com.clj.demo4.Car1">
         <!-- 寫法一<constructor-arg name="cname" value="寶馬"/>
         <constructor-arg name="price" value="400000"/> -->
         <!--寫法二 -->
         <constructor-arg index="0" value="寶馬"/>
         <constructor-arg index="1" value="400000"/>
       </bean>      

  3)測試

    @Test
    public void run1(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        Car1 car=(Car1) ac.getBean("car1");
        System.out.println(car);
    }

    拓展:構造方法之將一個對象注入到另外一個對象中

   1)pojo類:目的:將上列中的車注入到人類,使之成爲其中一個屬性,則必須在此類中提供車的成員屬性,並提供有參構造方法

package com.clj.demo4;

public class Person {
    private String name;
    private Car1 car1;
    public Person(String name, Car1 car1) {
        super();
        this.name = name;
        this.car1 = car1;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", car1=" + car1 + "]";
    }
    
    
}

   2)配置文件

         <!-- 構造方法之將一個對象注入到另外一個對象-->
     <bean id="person" class="com.clj.demo4.Person">
         <constructor-arg name="name" value="佳先森"/>
         <constructor-arg name="car1" ref="car1"/>
     </bean>         

  4.如何注入集合數組

   1)定義pojo類

package com.clj.demo4;

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

/**
 * 演示集合注入的方式
 * @author Administrator
 *
 */
public class User {
    private String[] arrs;
    private List<String> list;
    private Set<String> sets;
    private Map<String,String> map;
    private Properties pro;
    
    public void setPro(Properties pro) {
        this.pro = pro;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

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

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

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

    @Override
    public String toString() {
        return "User [arrs=" + Arrays.toString(arrs) + ", list=" + list
                + ", sets=" + sets + ", map=" + map + ", pro=" + pro + "]";
    }  
}

  2)配置文件

     <!-- 注入集合 -->
     <bean id="user" class="com.clj.demo4.User">
         <!-- 數組 -->
         <property name="arrs">
             <list>
                 <value>數字1</value>
                 <value>數字2</value>
                 <value>數字3</value>
             </list>
         </property>
         <!-- list集合 -->
         <property name="list">
             <list>
                 <value>金在中</value>
                 <value>王傑</value>
             </list>
         </property>
         <!-- set集合 -->
         <property name="sets">
             <set>
                 <value>哈哈</value>
                 <value>呵呵</value>
             </set>
         </property>
         <!-- map集合 -->
         <property name="map">
             <map>
                 <entry key="aa" value="rainbow"/>
                 <entry key="bb" value="hellowvenus"/>
             </map>
         </property>
         <!-- 屬性文件 -->
         <property name="pro">
             <props>
                 <prop key="username">root</prop>
                 <prop key="password">123</prop>
             </props>
         </property>
     </bean>

   3)測試

    /**
     * 測試注入集合
     */
    @Test
    public void run3(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        User user= (User) ac.getBean("user");
        System.out.println(user);
    }

   5.怎麼分模塊開發

   在主配置文件加入<import>標籤假如此時在com.clj.test包下定義了一個配置文件applicationContext2.xml

    <!-- 分模塊開發之引入其餘配置文件 -->
     <import resource="com/clj/test/applicationContext2.xml"/>

5、詳解Spring框架的IOC之註解方式

  一、入門

  1).導入jar包

   除了先前6個包,玩註解還需一個spring-aop

  

  2).持久層和實現層(這裏忽略接口)

   持久層

package com.clj.demo1;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * UserDaoImpl交給IOC的容器管理
 * @author Administrator
 *
 */
public class UserDaoImpl implements UserDao{

    @Override
    public void save() {
        System.out.println("保存客戶。。");
        
    }

}

   業務層

package com.clj.demo1;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

public class UserServiceImpl implements UserService{

@Override public void sayHello() { System.out.println("Hello spring"); } }

   3).定義配置文件

   此時約束條件需添加context約束,並添加組件掃描

<?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"> <!-- bean definitions here -->
    <!-- 開啓註解掃面 :base-package指定掃面對 包-->
    <context:component-scan base-package="com.clj.demo1"/>
</beans>

  4)在實現類中添加註解

/**
 * 組件註解,能夠用來標記當前的類
 * 相似<bean id="userService" class="com.clj.demo1.UserServiceImpl">
 * value表示給該類起個別名
 */
@Component(value="userService")
public class UserServiceImpl implements UserService{
            //省略
}

  5)編寫測試

    /**
     * 註解方式
     */
    @Test
    public void run2(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService us=(UserService) ac.getBean("userService");
        us.sayHello();
    }

  2.關於bean管理經常使用屬性

1. @Component:組件.(做用在類上)  最原始的註解,全部須要註解的類都寫這個沒問題,他是通用的
2. Spring中提供@Component的三個衍生註解:(功能目前來說是一致的)
    * @Controller       -- 做用在WEB層
    * @Service          -- 做用在業務層
    * @Repository       -- 做用在持久層
    * 說明:這三個註解是爲了讓標註類自己的用途清晰,Spring在後續版本會對其加強
 
3. 屬性注入的註解(說明:使用註解注入的方式,能夠不用提供set方法)
    * 若是是注入的普通類型,可使用value註解
    * @Value             -- 用於注入普通類型
    * 若是注入的是對象類型,使用以下註解
        * @Autowired        -- 默認按類型進行自動裝配   匹配的是類型,與注入類的類名無關
            * 若是想按名稱注入
            * @Qualifier    -- 強制使用名稱注入            必須與Autowired一塊兒用,指定類名,與注入的類名有關
        * @Resource         -- 至關於@Autowired和@Qualifier一塊兒使用
      它能夠對類成員變量、方法及構造函數進行標註,完成自動裝配的工做。 經過 @Resource 的使用來消除 set ,get方法。
* 強調:Java提供的註解 * 屬性使用name屬性

4. Bean的做用範圍註解

    * 註解爲@Scope(value="prototype"),做用在類上。值以下:

        * singleton     -- 單例,默認值

        * prototype     -- 多例

 

5. Bean的生命週期的配置(瞭解)

    * 註解以下:

        * @PostConstruct    -- 至關於init-method

        * @PreDestroy       -- 至關於destroy-method

  1.演示屬性對象註解

   條件:採用掃描的方式將屬性(name)和對象(userDaoImpl)注入到業務層中

  1)持久層開啓註解掃描Repository

//@Component(value="userDao")通用類註解
@Repository(value="ud")     //注意:此類配置了包掃描
public class UserDaoImpl implements UserDao{
    @Override
    public void save() {
        System.out.println("保存客戶。。");    
    }
}

   2)業務層針對屬性和對象提供註解

package com.clj.demo1;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
 * 組件註解,能夠用來標記當前的類
 * 相似<bean id="userService" class="com.clj.demo1.UserServiceImpl">
 * value表示給該類起個別名
 */
//@Scope(value="grototype")多列的(singletype爲單列)
@Component(value="userService")
public class UserServiceImpl implements UserService{
    //屬性註解:至關於給name屬性注入指定的字符串,setName方法能夠省略不寫
    @Value(value="佳先森")
    private String name;
    
    /**
     * 引用注入方式一:Autowired()
     * 引用注入方式二:Autowired()+Qualifier
     * 引用注入方式三:@Resource(name="userDao") java方式,按名稱識別注入
     */
    //Autowired()按類型自動裝配注入(缺點:由於是按類型匹配,因此不是很準確)
    @Autowired()
    @Qualifier(value="ud")  //按名稱注入,得與Autowired一塊兒用,二者一塊兒能指定類
    private UserDao userDao;
    //注意Qualifier中的value是指定UserDaoImpl類名頂上的註解名,也能夠指定配置文件中bean的id名
    
    
    /*public void setName(String name) {
        this.name = name;
    }*/

    @Override
    public void sayHello() {
        System.out.println("Hello spring"+name);
        userDao.save();
    }
    //@PostConstruct標籤用於action生命週期中初始化的註解
    @PostConstruct
    public void init(){
        System.out.println("初始化...");
    }
}

  3)配置文件只須要開啓所有掃描便可

<?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"> <!-- bean definitions here -->
    <!-- 開啓註解掃面 :base-package指定掃面對 包-->
    <context:component-scan base-package="com.clj.demo1"/>
     </beans>

 

  

注意:至於集合仍是推薦使用配置文件方式

  2.Spring框架整合JUnit單元測試

  1)添加單元測試所需依賴包spring-test.jar

  

  注意:基於myeclipes自帶Junit環境,可是有時由於版本問題,可能須要比較新的Junit環境,這裏我在網上下了一個教新的 Junit-4.9的jar包,若是myeclipes較新的話無須考慮

  2)編寫測試類,添加相對應的註解

   @RunWith與@ContextConfiguration(此是用於加載配置文件,由於默認從WebRoot路徑爲一級目錄,加上此是認定src爲一級目錄)

package com.clj.demo2;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.clj.demo1.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo2 {
    @Resource(name="userService")
    private UserService userService;
    @Test
    public void run1(){
        userService.sayHello();
    }
}

六.spring框架之AOP

  1.什麼是AOP

        * 在軟件業,AOP爲Aspect Oriented Programming的縮寫,意爲:面向切面編程,功能模塊化

        * AOP是一種編程範式,隸屬於軟工範疇,指導開發者如何組織程序結構

        * AOP最先由AOP聯盟的組織提出的,制定了一套規範.Spring將AOP思想引入到框架中,必須遵照AOP聯盟的規範

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

        * AOP是OOP的延續,是軟件開發中的一個熱點,也是Spring框架中的一個重要內容,是函數式編程的一種衍生範型

        * 利用AOP能夠對業務邏輯的各個部分進行隔離,從而使得業務邏輯各部分之間的耦合度下降,提升程序的可重用性,同時提升了開發的效率 

      AOP採起橫向抽取機制,取代了傳統縱向繼承體系重複性代碼(性能監視、事務管理、安全檢查、緩存)

  2. 爲何要學習AOP

        * 能夠在不修改源代碼的前提下,對程序進行加強!!(爲固定的方法生成一個代理,在訪問該方法以前,先進入代理,在代理中,能夠編寫更多的功能,使之方法的功能更強,使得程序進行增        強)

        Aop:面向切面編程,將一切事模塊化,每一個模塊比較獨立,模塊能夠共用(相同的),不一樣的格外自定義。用此替代傳統的面向縱向編程,提升程序的可重用性

  3.AOP的實現(實現原理)

   Aop的實現包含兩種代理方式<1>實現類接口:採用JDK動態代理<2>未實現類接口:採用CGLIB動態代理

   1.實現JDK動態代理

    1)定義持久層接口實現類

 

package com.clj.demo3;

public interface UserDao {
    public void save();
    public void update();
}
package com.clj.demo3;

public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("保存用戶");
    }
    @Override
    public void update() {
        System.out.println("修改用戶");
    }
}

 

   2)定義JDK動態代理工具類

       此工具類是在執行持久層save方法時增長一些功能,在開發中作到在不更改源碼狀況下加強某方法

package com.clj.demo3;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 使用JDK的方式生成代理對象(演示AOP原理)
 * @author Administrator
 *
 */
public class MyProxyUtils {
    public static UserDao getProxy(final UserDao dao){
        //使用Proxy類生成代理對象
        UserDao proxy=(UserDao)Proxy.newProxyInstance(dao.getClass().getClassLoader() , dao.getClass().getInterfaces(),new InvocationHandler() {
            //只要代理對象一執行,invoke方法就會執行一次
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                //proxy表明當前代理對象
                //method當前對象執行的方法
                //args封裝的參數
                //讓到類的save或者update方法正常執行下去
                if("save".equals(method.getName())){
                    System.out.println("執行了保存");
                    //開啓事務
                }
                return method.invoke(dao, args);
            }
        });
        return proxy;
    }
}

   3)測試

package com.clj.demo3;

import org.junit.Test;

public class Demo1 {
    @Test
    public void run1(){
        //獲取目標對象
        UserDao dao=new UserDaoImpl();
        dao.save();
        dao.update();
        System.out.println("===============");
        //使用工具類,獲取到代理對象
        UserDao proxy=MyProxyUtils.getProxy(dao);
        //調用代理對象的方法
        proxy.save();
        proxy.update();
        
    }
}

   2.實現CGLIB技術

    1)定義持久層,此時沒有接口

package com.clj.demo4;

public class BookDaoImpl {
    public void save(){
        System.out.println("保存圖書");
    }
    public void update(){
        System.out.println("修改圖書");
    }
}

   2)編寫工具類

package com.clj.demo4;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
/**
 * Cglib代理方式實現原理
 * @author Administrator
 *
 */
public class MyCglibUtils {
    /**
     * 使用CGLIB方式生成代理對象
     * @return
     */
    public static BookDaoImpl getProxy(){
        Enhancer enhancer=new Enhancer();
        //設置父類
        enhancer.setSuperclass(BookDaoImpl.class);
        //設置回調函數
        enhancer.setCallback(new MethodInterceptor() {
            
            @Override
            public Object intercept(Object obj, Method method, Object[] objs,
                    MethodProxy methodProxy) throws Throwable {
                if(method.getName().equals("save")){
                System.out.println("我保存了");
                System.out.println("代理對象執行了");
        }
                return methodProxy.invokeSuper(obj, objs);//是方法執行下去
            }
        });
        //生成代理對象
        BookDaoImpl proxy=(BookDaoImpl) enhancer.create();
        return proxy;
    }
}

   3)編寫測試類

package com.clj.demo4;

import org.junit.Test;

public class Demo1 {
    @Test
    public void run1(){
        //目標對象
        BookDaoImpl dao=new BookDaoImpl();
        dao.save();
        dao.update();
        System.out.println("==========");
        BookDaoImpl proxy=MyCglibUtils.getProxy();
        proxy.save();
        proxy.update();
    }
}

   三、Spring基於AspectJ的AOP的開發(配置文件方式)

   

 

   1)部署環境,導入相對應的jar包

   

  2)建立配置文件,並引入AOP約束

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

  3)建立接口和實現類

package com.clj.demo5;

public interface CustomerDao {
    public void save();
    public void update();
}
package com.clj.demo5;
/**
 * 採用配置文件的方式 詮釋AOP
 * @author Administrator
 *
 */
public class CustomerDaoImpl implements CustomerDao {

    @Override
    public void save() {
        //模擬異常
        //int a=10/0;
        System.out.println("保存客戶了啊");
    }

    @Override
    public void update() {
        // TODO Auto-generated method stub
        System.out.println("更新客戶了啊");
    }

}

   4)定義切面類

package com.clj.demo5;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 切面類:切入點+通知
 * @author Administrator
 *
 */
public class MyAspectXml {
    /**
     * 通知(具體的加強)
     */
    public void log(){
        System.out.println("記錄日誌");
    }
    /**
     * 方法執行成功或者異常都會執行
     */
    public void after(){
        System.out.println("最終通知");
    }
    /**
     * 方法執行以後,執行後置通知,若是程序出現異常,後置通知不會執行
     */
    public void afterReturn(){
        System.out.println("後置通知");
    }
    /**
     * 方法執行以後,若是程序有異常,纔會執行異常通知
     */
    public void afterThrowing(){
        System.out.println("異常通知");
    }
    /**
     * 環繞通知:方法執行以前和方法執行以後進行通知,
     * 默認狀況下,目標對象的方法不能執行的,須要手動讓目標對象執行
     */
    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("環繞通知1");
        //手動讓目標對象的方法執行
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("環繞通知2");
    }
}

  5)注入實現類和切面類

<?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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->
    <!-- 配置客戶的dao -->
    <bean id="customerDao" class="com.clj.demo5.CustomerDaoImpl"/>
    <!-- 編寫切面類配置好 -->
    <bean id="myAspectXml" class="com.clj.demo5.MyAspectXml"/>
    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面類:切入點+通知 (類型)-->
        <aop:aspect ref="myAspectXml">
            <!-- 配置前置通知,save方法執行以前,加強方法會執行 -->
            <!-- 切入點表達式:execution(public void com.clj.demo5.CustomerDaoImpl.save()) -->
            <!-- 切入點表達式:
                1.execution()固定的,必寫
                2.public能夠省略不寫
                3.返回值     必寫,嚴格根據切入點方法而定,不然加強方法不會執行,能夠用*代替,表示任意的返回值
                4.包名      必寫,能夠用*代替(如:*..*(默認全部包); com.clj.*)
                5.類名     必寫,能夠部分用*(如*DaoImpl表示以'DaoImpl'結尾的持久層實現類),但不建議用*代替整個類名
                6.方法     必寫,能夠部分用*(如save*表示以'save'開頭的方法),但不建議用*代替整個類名
                7.方法參數 根據實際方法而定,能夠用'..'表示有0或者多個參數
             -->
            <!-- <aop:before method="log" pointcut="execution(public void com.clj.*.CustomerDaoImpl.save(..))"/> -->
            <aop:before method="log" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>
    

  6)測試

  

package com.clj.demo5;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
    @Resource(name="customerDao")
    private CustomerDao customerDao;  //注意:這裏必定要要接口,不能直接用實現類,不然報錯
    @Test
    public void run(){
        customerDao.save();
        customerDao.update();
    }
}

 

  擴展:切面類升級

<?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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->
    <bean id="myAspectXml" class="com.clj.demo5.MyAspectXml"/>
    <aop:config>
        <aop:aspect ref="myAspectXml">
            <!-- 配置最終通知 
            <aop:after method="after" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>-->
            <!-- 配置後置通知 
            <aop:after-returning method="afterReturn" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>-->
            <!-- 配置異常通知 
            <aop:after-throwing method="afterThrowing" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>-->
            <aop:around method="around" pointcut="execution(* *..*.*DaoImpl.update*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>
    

  四、Spring框架AOP之註解方式

    1)建立接口和實現類

package com.clj.demo1;

public interface CustomerDao {
    public void save();
    public void update();
}
package com.clj.demo1;

public class CustomerDaoImpl implements CustomerDao{

    @Override
    public void save() {
        // TODO Auto-generated method stub
        System.out.println("保存客戶..");
    }

    @Override
    public void update() {
        // TODO Auto-generated method stub
        System.out.println("更新客戶");
    }

}

  2)定義切面類

package com.clj.demo1;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * 註解方式的切面類
 * @Aspect表示定義爲切面類
 */
@Aspect
public class MyAspectAnno {
    //通知類型:@Before前置通知(切入點的表達式)
    @Before(value="execution(public *     com.clj.demo1.CustomerDaoImpl.save())")
    public void log(){
        System.out.println("記錄日誌。。");
    }
    //引入切入點
    @After(value="MyAspectAnno.fun()")
    public void after(){
        System.out.println("執行以後");
    }
    @Around(value="MyAspectAnno.fun()")
    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("環繞通知1");
        try {
            //讓目標對象執行
            joinPoint.proceed();
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("環繞通知2");
    }
    //自定義切入點
    @Pointcut(value="execution(public *     com.clj.demo1.CustomerDaoImpl.save())")
    public void fun(){
        
    }
}

  3)配置切面類和實現類,並開啓自動代理

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 開啓自動註解代理-->
    <aop:aspectj-autoproxy/> 
    <!-- 配置目標對象 -->
    <bean id="customerDao" class="com.clj.demo1.CustomerDaoImpl"/>
    <!-- 配置切面類 -->
    <bean id="myAspectAnno" class="com.clj.demo1.MyAspectAnno"/>
</beans>

7、Spring之JDBC

  spring提供了JDBC模板:JdbcTemplate類

  1.快速搭建

   1)部署環境

   這裏在原有的jar包基礎上,還要添加關乎jdbc的jar包,這裏使用的是mysql驅動

  

   2)配置內置鏈接池,將鏈接數據庫程序交給框架管理,並配置Jdbc模板類

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 先配置鏈接池(內置) -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!-- 配置JDBC的模板類-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

  3)測試

package com.clj.demo2;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.dbcp.BasicDataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 測試JDBC的模板類,使用IOC的方式
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo2 {
    @Resource(name="jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    /**
     * 插入
     */
    @Test
    public void run1(){
        String sql="insert into t_account values(null,?,?)";
        jdbcTemplate.update(sql,"李釔林",10000);
    }
    /**
     * 更新
     */
    @Test
    public void run2(){
        String sql="update t_account set name=? where id=?";
        jdbcTemplate.update(sql,"李釔林",1);
    }
    /**
     * 刪除
     */
    @Test
    public void run3(){
        String sql="delete from t_account where id=?";
        jdbcTemplate.update(sql,4);
    }
    /**
     * 測試查詢,經過主鍵來查詢一條記錄
     */
    @Test
    public void run4(){
        String sql="select * from t_account where id=?";
        Account ac=jdbcTemplate.queryForObject(sql, new BeanMapper(),1);
        System.out.println(ac);
    }
    /**
     * 查詢全部
     */
    @Test
    public void run5(){
        String sql="select * from t_account";
        List<Account> ac=jdbcTemplate.query(sql,new BeanMapper());
        System.out.println(ac);
    }
}
/**
 * 定義內部類(手動封裝數據(一行一行封裝數據,用於查詢全部)
 * @author Administrator
 *
 */
class BeanMapper implements RowMapper<Account>{

    @Override
    public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
        Account ac=new Account();
        ac.setId(rs.getInt("id"));
        ac.setName(rs.getString("name"));
        ac.setMoney(rs.getDouble("money"));
        return ac;
    }
    
}

   二、配置開源鏈接池

    通常如今企業都是用一些主流的鏈接池,如c3p0和dbcp

   首先配置dbcp

  1)導入dbcp依賴jar包

  

  2)編寫配置文件

<!-- 配置DBCP開源鏈接池--> 
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

  將模板類中引入的內置類datasource改成開源鏈接池的

  3)編寫測試類

  配置c3p0

  1)導入c3p0依賴jar包

  

  2)配置c3p0

<!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

  將模板類中引入的內置類datasource改成開源鏈接池的

  3)編寫測試類

8、Spring之事務

  一、什麼是事務

  數據庫事務(Database Transaction) ,是指做爲單個邏輯工做單元執行的一系列操做,要麼徹底地執行,要麼徹底地不執行。 事務處理能夠確保除非事務性單元內的全部操做都成功完成,不然不會永久更新面向數據的資源。經過將一組相關操做組合爲一個要麼所有成功要麼所有失敗的單元,能夠簡化錯誤恢復並使應用程序更加可靠。一個邏輯工做單元要成爲事務,必須知足所謂的ACID(原子性、一致性、隔離性和持久性)屬性。事務是數據庫運行中的邏輯工做單位,由DBMS中的事務管理子系統負責事務的處理。

                                                                                    -----百度百科

  二、怎麼解決事務安全性問題

  讀問題解決,設置數據庫隔離級別;寫問題解決可使用 悲觀鎖和樂觀鎖的方式解決

  三、快速開發

   方式一:調用模板類,將模板注入持久層

  1)編寫相對應的持久層和也外層,這裏省略接口   

package com.clj.demo3;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl implements AccountDao{
   // 方式一:將jdbc模板類注入到配置文件中,直接在持久層寫模板類
      private JdbcTemplate jdbcTemplate;
      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
          this.jdbcTemplate = jdbcTemplate;
      }

   
    public void outMoney(String out, double money) {
        String sql="update t_account set money=money-? where name=?";
        jdbcTemplate().update(sql,money,out);
    }

    
    public void inMoney(String in, double money) {
        String sql="update t_account set money=money+? where name=?";
        jdbcTemplate().update(sql,money,in);
    }
    
}

 

package com.clj.demo4;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService{
    //採用的是配置文件注入方式,必須提供set方法
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void pay(String out, String in, double money) {
        // TODO Auto-generated method stub
        accountDao.outMoney(out, money);
        int a=10/0;
        accountDao.inMoney(in, money);
    }
}

 

  2)配置相對應的配置文件

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
<!-- 配置JDBC的模板類 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!-- 配置業務層和持久層 -->
    <bean id="accountService" class="com.clj.demo3.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
<bean id="accountDao" class="com.clj.demo3.AccountDaoImpl">
        <!-- 注入模板類-->
        <property name="jdbcTemplate" ref="jdbcTemplate"/>     
    </bean>
</beans>

  3)測試類

package com.clj.demo3;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
    @Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void Demo1(){
        //調用支付的方法
        accountService.pay("佳先森","李釔林",100);
    }
}

   方式二:持久層繼承JdbcDaoSupport接口,此接口封裝了模板類jdbcTemplate

 

   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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!-- 配置業務層和持久層 -->
    <bean id="accountService" class="com.clj.demo3.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <bean id="accountDao" class="com.clj.demo3.AccountDaoImpl">    
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

  2)更改持久層

package com.clj.demo3;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{
    //方式一:將jdbc模板類注入到配置文件中,直接在持久層寫模板類
//    private JdbcTemplate jdbcTemplate;
//    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
//        this.jdbcTemplate = jdbcTemplate;
//    }

    //方式二:持久層繼承JdbcDaoSupport,它裏面封轉了模板類,配置文件持久層無需注入模板類,也不須要配置模板類
    public void outMoney(String out, double money) {
        //jdbcTemplate.update(psc);
        String sql="update t_account set money=money-? where name=?";
        this.getJdbcTemplate().update(sql,money,out);
    }

    
    public void inMoney(String in, double money) {
        String sql="update t_account set money=money+? where name=?";
        this.getJdbcTemplate().update(sql,money,in);
    }
    
}

  3)更改業務層

package com.clj.demo4;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService{
    //採用的是配置文件注入方式,必須提供set方法
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void pay(String out, String in, double money) {
        // TODO Auto-generated method stub
        accountDao.outMoney(out, money);
        int a=10/0;
        accountDao.inMoney(in, money);
    }
    

}

  4)測試類和上述同樣

  四、spring事務管理

  Spring爲了簡化事務管理的代碼:提供了模板類 TransactionTemplate,手動編程的方式來管理事務,只須要使用該模板類便可!!

 

9、Spring框架的事務管理之編程式的事務管理

  一、手動編程方式事務(瞭解原理)

   1)快速部署,搭建配置文件,配置事務管理和事務管理模板,並在持久層注入事務管理模板

     配置事務管理器

  <!-- 配置平臺事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    配置事務管理模板

<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
</bean>

    將管理模板注入業務層

<bean id="accountService" class="com.clj.demo3.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="transactionTemplate" ref="transactionTemplate"/>
</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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
   
    <!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>  
    <!-- 配置業務層和持久層 -->
    <bean id="accountService" class="com.clj.demo3.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="transactionTemplate" ref="transactionTemplate"/>
    </bean>
    <bean id="accountDao" class="com.clj.demo3.AccountDaoImpl">   
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置平臺事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 手動編碼方式,提供了模板類,使用該類管理事務比較簡單-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>
</beans>

 

  2)在業務層使用模板事務管理

package com.clj.demo3;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService{
    //採用的是配置文件注入方式,必須提供set方法
    private AccountDao accountDao;
    //注入事務模板類
    private TransactionTemplate transactionTemplate;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }

    /**
     * 轉帳的方法
     */
    public void pay(final String out,final  String in, final double money) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            //事務的執行,若是沒有問題,提交,若是楚翔異常,回滾
            protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                // TODO Auto-generated method stub
                accountDao.outMoney(out, money);
                int a=10/0;
                accountDao.inMoney(in, money);
            }
        });
    }

}

  3)測試類和上一致

package com.clj.demo4;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class Demo2 {
    @Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void Demo1(){
        //調用支付的方法
        accountService.pay("佳先森","李釔林",100);
    }
}

 

10、Spring框架的事務管理之聲明式事務管理,即經過配置文件來完成事務管理(AOP思想)

  申明式事務有兩種方式:基於AspectJ的XML方式;基於AspectJ的註解方式

  一、XML方式

   1)配置配置文件

  須要配置平臺事務管理

<!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!-- 配置平臺事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

  配置事務加強

<tx:advice id="myAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 給方法設置數據庫屬性(隔離級別,傳播行爲) -->
            <!--propagation事務隔離級別:通常採用默認形式:tx:method能夠設置多個  -->
            <tx:method name="pay" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

  aop切面類

<aop:config>
        <!-- aop:advisor,是spring框架提供的通知-->
        <aop:advisor advice-ref="myAdvice" pointcut="execution(public * com.clj.demo4.AccountServiceImpl.pay(..))"/>
    </aop:config>

  所有代碼

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!-- 配置平臺事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 申明式事務(採用XML文件的方式) -->
    <!-- 先配置通知 -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 給方法設置數據庫屬性(隔離級別,傳播行爲) -->
            <!--propagation事務隔離級別:通常採用默認形式:tx:method能夠設置多個  -->
            <tx:method name="pay" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置AOP:若是是本身編寫的AOP,使用aop:aspect配置,使用的是Spring框架提供的通知 -->
    <aop:config>
        <!-- aop:advisor,是spring框架提供的通知-->
        <aop:advisor advice-ref="myAdvice" pointcut="execution(public * com.clj.demo4.AccountServiceImpl.pay(..))"/>
    </aop:config>
    
    <!-- 配置業務層和持久層 -->
    <bean id="accountService" class="com.clj.demo4.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <bean id="accountDao" class="com.clj.demo4.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

  2)編寫持久層和業務層(省略接口)

package com.clj.demo5;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{
    //方式一:將jdbc模板類注入到配置文件中,直接在持久層寫模板類
//    private JdbcTemplate jdbcTemplate;
//    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
//        this.jdbcTemplate = jdbcTemplate;
//    }

    //方式二:持久層繼承JdbcDaoSupport,它裏面封轉了模板類,配置文件持久層無需注入模板類,也不須要配置模板類
    public void outMoney(String out, double money) {
        //jdbcTemplate.update(psc);
        String sql="update t_account set money=money-? where name=?";
        this.getJdbcTemplate().update(sql,money,out);
    }

    
    public void inMoney(String in, double money) {
        String sql="update t_account set money=money+? where name=?";
        this.getJdbcTemplate().update(sql,money,in);
    }
    
}
package com.clj.demo5;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;public class AccountServiceImpl implements AccountService{
    //採用的是配置文件注入方式,必須提供set方法
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void pay(String out, String in, double money) {
        // TODO Auto-generated method stub
        accountDao.outMoney(out, money);
        int a=10/0;
        accountDao.inMoney(in, money);
    }
    

}

  3)測試類

package com.clj.demo4;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class Demo2 {
    @Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void Demo1(){
        //調用支付的方法
        accountService.pay("佳先森","李釔林",100);
    }
}

  二、註解方式

  1)配置配置文件

    配置事務管理

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

  開啓註釋事務

    <!-- 開啓事務的註解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

  所有代碼

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 配置C3P0開源鏈接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!-- 配置平臺事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 開啓事務的註解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <!-- 配置業務層和持久層 -->
    <bean id="accountService" class="com.clj.demo5.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <bean id="accountDao" class="com.clj.demo5.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

  2)業務層增長@Transactional

package com.clj.demo5;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;
//在當前類加此註解表示當前類全部的所有都有事務
@Transactional
public class AccountServiceImpl implements AccountService{
    //採用的是配置文件注入方式,必須提供set方法
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void pay(String out, String in, double money) {
        // TODO Auto-generated method stub
        accountDao.outMoney(out, money);
        int a=10/0;
        accountDao.inMoney(in, money);
    }
    

}

  3)持久層不變

package com.clj.demo5;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{
    //方式一:將jdbc模板類注入到配置文件中,直接在持久層寫模板類
//    private JdbcTemplate jdbcTemplate;
//    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
//        this.jdbcTemplate = jdbcTemplate;
//    }

    //方式二:持久層繼承JdbcDaoSupport,它裏面封轉了模板類,配置文件持久層無需注入模板類,也不須要配置模板類
    public void outMoney(String out, double money) {
        //jdbcTemplate.update(psc);
        String sql="update t_account set money=money-? where name=?";
        this.getJdbcTemplate().update(sql,money,out);
    }

    
    public void inMoney(String in, double money) {
        String sql="update t_account set money=money+? where name=?";
        this.getJdbcTemplate().update(sql,money,in);
    }
    
}

  4)測試類

package com.clj.demo5;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class Demo3 {
    @Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void Demo1(){
        //調用支付的方法
        accountService.pay("佳先森","李釔林",100);
    }
}

 另外:附上sprin4 的maven pom文件依賴

<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aopalliance/com.springsource.org.aopalliance -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/org.aspectj.weaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.7.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.0.8</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.17.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
相關文章
相關標籤/搜索