說明：本文主要內(nèi)容來自慕課網(wǎng)。配合視頻食用口味更佳虾攻。
主要是順著已經(jīng)學(xué)習(xí)的視頻順序總結(jié)一遍帽借，以深化理解和方便日后復(fù)習(xí)憔维。
本部分只包含IOC和AOP。

第一章 概述

Spring 入門課程簡介

本門課程包含的內(nèi)容：
Spring簡介
IOC（配置谋减、注解）
Bean（配置、注解）
AOP（配置、注解难裆、AspetJ、API）

Spring概況

Spring是什么

• Spring是一個開源框架镊掖，最初為了解決企業(yè)應(yīng)用開發(fā)的復(fù)雜性而創(chuàng)建的乃戈，但現(xiàn)在已經(jīng)不止應(yīng)用于企業(yè)應(yīng)用
• 是一個輕量級的控制反轉(zhuǎn)（IOC）和面向切面（AOP）的容器框架
  • 從大小與開銷兩方面而言Spring都是輕量的
  • 通過控制反轉(zhuǎn)（IOC）的技術(shù)達(dá)到松耦合的目的
  • 提供了面向切面編程(AOP)的豐富支持，允許通過分離應(yīng)用的業(yè)務(wù)邏輯與系統(tǒng)級服務(wù)進(jìn)行內(nèi)聚性的開發(fā)
  • 包含并管理應(yīng)用對象的配置和生命周期堰乔，這個意義上是一種容器偏化。
  • 將簡單的組件配置、組合成為復(fù)雜的應(yīng)用镐侯，這個意義上是框架

為什么是Spring

• 在Spring上開發(fā)應(yīng)用簡單
• 在Spring上開發(fā)應(yīng)用方便
• 在Spring上開發(fā)應(yīng)用快捷

Spring作用

• 容器
• 提供了多種技術(shù)的支持
  --JMS
  --MQ支持
  --UnitTest
• AOP（事務(wù)管理侦讨、日志等）
• 提供了眾多方便應(yīng)用的輔助類（JDBC Template等）
• 對主流應(yīng)用框架（Hibernate等）提供了良好的支持

適用范圍

• 構(gòu)建企業(yè)應(yīng)用（SpringMVC+Spring+Hibernate/MyBatis）
• 單獨(dú)使用Bean容器（Bean管理）
• 單獨(dú)使用AOP進(jìn)行切面處理
• 其他的Spring功能：如：對消息的支持等
• 在互聯(lián)網(wǎng)中的應(yīng)用

Spring框架

Spring框架總覽

框架

什么是框架

維基百科：軟件框架，通常是指為了實(shí)現(xiàn)某個業(yè)界標(biāo)準(zhǔn)或者完成特定基本任務(wù)的軟件組件規(guī)范苟翻，也指為了實(shí)現(xiàn)某個軟件組織規(guī)范時韵卤，提供規(guī)范所要求之基礎(chǔ)功能的軟件產(chǎn)品。

通俗的說崇猫，框架就是制定一套規(guī)范或者規(guī)則（思想）沈条，大家（程序員）在該規(guī)范或者規(guī)程（思想）下工作。用現(xiàn)實(shí)生活中的比喻就是：使用別人搭好的舞臺诅炉，你來做表演蜡歹。

框架的特點(diǎn)

• 半成品
• 封裝了特定的處理流程和控制邏輯
• 成熟的屋厘、不斷升級的軟件

框架與類庫的區(qū)別

• 框架一般是封裝了邏輯、高內(nèi)聚的月而，類庫則是松散的工具組合汗洒。
• 框架專注于某一領(lǐng)域，類庫則是更通用的父款。

框架于類庫區(qū)別

• 類庫通過不同的方式組裝成不同的框架

為什么使用框架

• 軟件系統(tǒng)日趨復(fù)雜
• 重用度高溢谤，開發(fā)效率和質(zhì)量提高
• 軟件設(shè)計(jì)人員要專注于對領(lǐng)域的了解，使需求分析更充分
• 易于上手憨攒、快速解決問題

第二章 Spring IOC 容器

接口與面向接口編程

接口

• 用于溝通的中介物的抽象化
• 實(shí)體把自己提供給外界的一種抽象化說明世杀，用以由內(nèi)部操作分離出外部溝通方式，使其能被修改內(nèi)部而不影響外界其他實(shí)體與其交互的方式肝集。
• 對應(yīng)Java接口即聲明瞻坝，聲明了哪些方法對外提供的。
• 在Java8中包晰，接口可以擁有方法體

面向接口編程

• 結(jié)構(gòu)設(shè)計(jì)中湿镀，分清層次及調(diào)用關(guān)系，每層只向外（上層）提供一組功能接口伐憾，各層間僅依賴接口而非實(shí)現(xiàn)類
• 接口實(shí)現(xiàn)的變動不影響各層間的調(diào)用勉痴，這一點(diǎn)在公共服務(wù)中尤為重要
• “面向接口編程”中的“接口”是用于隱藏具體實(shí)現(xiàn)和實(shí)現(xiàn)多態(tài)性的組件

什么是IOC

站在過程的角度看

IOC：控制反轉(zhuǎn)，控制權(quán)的轉(zhuǎn)移树肃，不再是應(yīng)用程序本身-->依賴對象的創(chuàng)建和維護(hù)蒸矛，而是由外部容器-->依賴對象的創(chuàng)建和維護(hù)

站在主體的角度看

DI（依賴注入）是其中一種實(shí)現(xiàn)方式
2004年，Martin Fowler探討了同一個問題胸嘴，既然IoC是控制反轉(zhuǎn)雏掠，那么 到底是“哪些方面被控制反轉(zhuǎn)了呢？”劣像，經(jīng)過詳細(xì)的分析和論證后乡话，他得出了答案：“獲得依賴對象的過程被反轉(zhuǎn)了”《龋控制被反轉(zhuǎn)之后绑青，獲得依賴對象的過程由自身管理變成了由IOC容器的主動注入。于是屋群，他給“控制反轉(zhuǎn)” 取了一個更合適的名字“依賴注入（Dependency Injection）”闸婴。他的這個答案，實(shí)際上給出了實(shí)現(xiàn)IoC的方法：注入芍躏。
所謂依賴注入邪乍，就是由IoC容器 在運(yùn)行期間，動態(tài)地將某種依賴關(guān)系注入到對象之中。

目的

創(chuàng)建對象并且組裝對象之間的關(guān)系

IOC簡單類比

Spring的Bean配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd" >
     
    //這是我們要配置的內(nèi)容
    <bean id="oneInterface" class="com.imooc.ioc.interfaces.OneInterfaceImpl"></bean>

 </beans>

Java bean是什么

Bean容器初始化

基礎(chǔ)

兩個包：

• org.springframework.beans
• org.springframework.context

容器：

• BeanFactory提供配置結(jié)構(gòu)和基本功能榜配，加載并初始化Bean
• ApplicationContext保存了Bean對象，并在Spring中廣泛使用

BeanFactory和ApplicationContext是Spring兩種很重要的容器,前者提供了最基本的依賴注入的支持姐刁，而后者在繼承前者的基礎(chǔ)進(jìn)行了功能的拓展芥牌，例如增加了事件傳播，資源訪問和國際化的消息訪問等功能聂使。

方式---ApplicationContext

1. 本地文件

FileSystemXmlApplicationContext

FileSystemXmlApplicationContext context = new 
FileSystemXmlApplicationContext("F:/workspace/appcontext.xml");

2. 類路徑

ClassPathXmlApplicationContext

ClassPathXmlApplicationContext context = new
ClassPathXmlApplicationContext("classpath:spring-context.xml");

3. Web應(yīng)用

依賴servlet或Listener

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderServlet</listener-class>
</listener>
<servlet>
    <servlet-name>context</servlet-name>
    <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
    <load-on-startup>on</load-on-startup>
</servlet>

Spring注入方式

Spring注入是指在啟動Spring容器加載bean配置的時候，完成對變量的賦值行為谬俄。常用的兩種注入方式設(shè)值注入與構(gòu)造注入柏靶。

設(shè)值注入---property

通過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.xsd" >

      <bean id="injectionService" class="com.imooc.ioc.injection.service.InjectionServiceImpl">
            <property name="injectionDAO" ref="injectionDAO"></property>
      </bean>


      <bean id="injectionDAO" class="com.imooc.ioc.injection.dao.InjectionDAOImpl"></bean>

 </beans>

構(gòu)造注入---constructor-arg

通過構(gòu)造器注入溃论。

<?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="injectionService" class="com.imooc.ioc.injection.service.InjectionServiceImpl">
            <constructor-arg name="injectionDAO" ref="injectionDAO"></constructor-arg>
        </bean>

        <bean id="injectionDAO" class="com.imooc.ioc.injection.dao.InjectionDAOImpl"></bean>

 </beans>

第三章：Spring Bean裝配（上）

Bean的配置項(xiàng)及作用域

Bean配置項(xiàng)

Bean的作用域

添加方式

<bean id=" " class=" " scope="singleton"></bean>

Bean的生命周期

Bean的生命周期

1. 首先容器啟動后先煎，會對scope為singleton且非懶加載的bean進(jìn)行實(shí)例化
2. 按照Bean定義信息配置信息，注入所有的屬性
3. 如果Bean實(shí)現(xiàn)了BeanNameAware接口巧涧，會回調(diào)該接口的setBeanName()方法薯蝎，傳入該Bean的id，此時該Bean就獲得了自己在配置文件中的id
4. 如果Bean實(shí)現(xiàn)了BeanFactoryAware接口,會回調(diào)該接口的setBeanFactory()方法谤绳，傳入該Bean的BeanFactory占锯，這樣該Bean就獲得了自己所在的BeanFactory
5. 如果Bean實(shí)現(xiàn)了ApplicationContextAware接口,會回調(diào)該接口的setApplicationContext()方法，傳入該Bean的ApplicationContext闷供，這樣該Bean就獲得了自己所在的ApplicationContext烟央，
6. 如果有Bean實(shí)現(xiàn)了BeanPostProcessor接口，則會回調(diào)該接口的postProcessBeforeInitialzation()方法
7. 如果Bean實(shí)現(xiàn)了InitializingBean接口歪脏，則會回調(diào)該接口的afterPropertiesSet()方法
8. 如果Bean配置了init-method方法疑俭，則會執(zhí)行init-method配置的方法
9. 如果有Bean實(shí)現(xiàn)了BeanPostProcessor接口，則會回調(diào)該接口的postProcessAfterInitialization()方法
   10.經(jīng)過流程9之后婿失，就可以正式使用該Bean了,對于scope為singleton的Bean,Spring的ioc容器中會緩存一份該bean的實(shí)例钞艇，而對于scope為prototype的Bean,每次被調(diào)用都會new一個新的對象啄寡，期生命周期就交給調(diào)用方管理了，不再是Spring容器進(jìn)行管理了
   11.容器關(guān)閉后哩照，如果Bean實(shí)現(xiàn)了DisposableBean接口挺物，則會回調(diào)該接口的destroy()方法
   12.如果Bean配置了destroy-method方法，則會執(zhí)行destroy-method配置的方法

至此飘弧，整個Bean的生命周期結(jié)束

創(chuàng)建與銷毀

方法1：實(shí)現(xiàn)InitializingBean和DisposableBean接口

這兩個接口都只包含一個方法识藤。

• 實(shí)現(xiàn)InitializingBean接口的afterPropertiesSet()方法可以在Bean屬性值設(shè)置好之后做一些操作
• 實(shí)現(xiàn)DisposableBean接口的destroy()方法可以在銷毀Bean之前做一些操作。

如下：

public class GiraffeService implements InitializingBean,DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("執(zhí)行InitializingBean接口的afterPropertiesSet方法");
    }
 
    @Override
    public void destroy() throws Exception {
        System.out.println("執(zhí)行DisposableBean接口的destroy方法");
    }
}

這種方法比較簡單次伶，但是不建議使用痴昧。因?yàn)檫@樣會將Bean的實(shí)現(xiàn)和Spring框架耦合在一起。

方法2：在bean的配置文件中指定init-method和destroy-method方法

Spring允許我們創(chuàng)建自己的init方法和destroy方法冠王，只要在Bean的配置文件中指定init-method和destroy-method的值就可以在Bean初始化時和銷毀之前執(zhí)行一些操作赶撰。

配置文件中的配置：

<bean name="giraffeService" class="com.giraffe.spring.service.GiraffeService" 
                            init-method="initMethod" destroy-method="destroyMethod">
</bean>

代碼：

public class GiraffeService {
    //通過<bean>的destroy-method屬性指定的銷毀方法
    public void destroyMethod() throws Exception {
        System.out.println("執(zhí)行配置的destroy-method");
    }
 
    //通過<bean>的init-method屬性指定的初始化方法
    public void initMethod() throws Exception {
        System.out.println("執(zhí)行配置的init-method");
    }
}

需要注意的是自定義的init-method和post-method方法可以拋異常但是不能有參數(shù)。
這種方式比較推薦柱彻，因?yàn)榭梢宰约簞?chuàng)建方法豪娜，無需將Bean的實(shí)現(xiàn)直接依賴于spring的框架。

方法3：使用@PostConstruct和@PreDestroy注解

• 除了xml配置的方式哟楷，Spring也支持用@PostConstruct和 @PreDestroy注解來指定init和destroy方法瘤载。
• 這兩個注解均在javax.annotation包中。
• 為了注解可以生效吓蘑，需要在配置文件中定義org.springframework.context.annotation.CommonAnnotationBeanPostProcessor或context:annotation-config

配置文件:

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />

代碼：

public class GiraffeService {
    @PostConstruct
    public void initPostConstruct(){
        System.out.println("執(zhí)行PostConstruct注解標(biāo)注的方法");
    }
 
    @PreDestroy
    public void preDestroy(){
        System.out.println("執(zhí)行preDestroy注解標(biāo)注的方法");
    }
 
}

方法4：配置全局默認(rèn)初始化惕虑、銷毀方法

default-init-method=" "
default-destroy-method=" "

<?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-init-method="defautInit" default-destroy-method="defaultDestroy">

 </beans>

Bean的生命周期示例

• 定義一個Person類
• 實(shí)現(xiàn)了BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean,DisposableBean五個接口
• 在applicationContext.xml文件中配置了該Bean的id為person1,并且配置了init-method和destroy-method,為該Bean配置了屬性name為jack的值
• 然后定義了一個MyBeanPostProcessor方法,該方法實(shí)現(xiàn)了BeanPostProcessor接口，且在applicationContext.xml文件中配置了該方法的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"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-3.2.xsd">
                    
     <bean id="person1" destroy-method="myDestroy" 
            init-method="myInit" class="com.test.spring.life.Person">
        <property name="name">
            <value>jack</value>
        </property>
    </bean>
    
    <!-- 配置自定義的后置處理器 -->
     <bean id="postProcessor" class="com.pingan.spring.life.MyBeanPostProcessor" />
</beans>

public class Person implements BeanNameAware, BeanFactoryAware,
        ApplicationContextAware, InitializingBean, DisposableBean {

    private String name;   
    public Person() {
        System.out.println("PersonService類構(gòu)造方法");
    }
    
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
        System.out.println("set方法被調(diào)用");
    }

    //自定義的初始化函數(shù)
    public void myInit() {
        System.out.println("myInit被調(diào)用");
    }
    
    //自定義的銷毀方法
    public void myDestroy() {
        System.out.println("myDestroy被調(diào)用");
    }

    public void destroy() throws Exception {
        // TODO Auto-generated method stub
     System.out.println("destory被調(diào)用");
    }

    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("afterPropertiesSet被調(diào)用");
    }

    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        // TODO Auto-generated method stub
       System.out.println("setApplicationContext被調(diào)用");
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        // TODO Auto-generated method stub
         System.out.println("setBeanFactory被調(diào)用,beanFactory");
    }

    public void setBeanName(String beanName) {
        // TODO Auto-generated method stub
        System.out.println("setBeanName被調(diào)用,beanName:" + beanName);
    }
    
    public String toString() {
        return "name is :" + name;
    }

public class MyBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean,
            String beanName) throws BeansException {
        // TODO Auto-generated method stub
        
        System.out.println("postProcessBeforeInitialization被調(diào)用");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean,
            String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessAfterInitialization被調(diào)用");
        return bean;
    }

}

public class AcPersonServiceTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.out.println("開始初始化容器");
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/test/spring/life/applicationContext.xml");
        
        System.out.println("xml加載完畢");
        Person person1 = (Person) ac.getBean("person1");
        System.out.println(person1);        
        System.out.println("關(guān)閉容器");
        ((ClassPathXmlApplicationContext)ac).close();
        
    }
}

我們啟動容器磨镶，可以看到整個調(diào)用過程：

開始初始化容器
九月 25, 2016 10:44:50 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@b4aa453: startup date [Sun Sep 25 22:44:50 CST 2016]; root of context hierarchy
九月 25, 2016 10:44:50 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [com/test/spring/life/applicationContext.xml]
Person類構(gòu)造方法
set方法被調(diào)用
setBeanName被調(diào)用,beanName:person1
setBeanFactory被調(diào)用,beanFactory
setApplicationContext被調(diào)用
postProcessBeforeInitialization被調(diào)用
afterPropertiesSet被調(diào)用
myInit被調(diào)用
postProcessAfterInitialization被調(diào)用
xml加載完畢
name is :jack
關(guān)閉容器
九月 25, 2016 10:44:51 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@b4aa453: startup date [Sun Sep 25 22:44:50 CST 2016]; root of context hierarchy
destory被調(diào)用
myDestroy被調(diào)用

Aware接口

有些時候我們需要在Bean的初始化中使用Spring框架自身的一些對象來執(zhí)行一些操作溃蔫，比如獲取ServletContext的一些參數(shù)，獲取ApplicaitionContext中的BeanDefinition的名字琳猫，獲取Bean在容器中的名字等等伟叛。為了讓Bean可以獲取到框架自身的一些對象，Spring提供了一組名為___Aware的接口脐嫂。

這些接口均繼承于org.springframework.beans.factory.Aware標(biāo)記接口统刮，并提供一個將由Bean實(shí)現(xiàn)的set___()方法,Spring通過基于setter的依賴注入方式使相應(yīng)的對象可以被Bean使用。

一些重要的Aware接口：

自動裝配（Autowiring）

具體參考
博客
為什么Spring要支持Autowire（自動裝配）

什么是裝配

在spring中鞭衩，對象無需自己查找或創(chuàng)建與其關(guān)聯(lián)的其他對象，容器負(fù)責(zé)把需要相互協(xié)作的對象引用賦予各個對象。
而創(chuàng)建對象之間協(xié)作關(guān)系的行為通常稱為裝配论衍。

Spring 裝配的方式

1. 隱式Bean的發(fā)現(xiàn)機(jī)制和自動裝配
   所謂自動裝配瑞佩，就是將一個Bean注入到其他Bean的Property中，類似于以下：

<bean id="customer" class="com.lei.common.Customer" autowire="byName" />

2. 顯式裝配：
   • 在Java中顯式裝配
   • 在XML中顯式裝配

為什么自動裝配

Spring引入Autowire（自動裝配）機(jī)制就是為了解決<bean>標(biāo)簽下<property>標(biāo)簽過多的問題

5種自動裝配模式

Resource

簡介

在Spring內(nèi)部實(shí)現(xiàn)機(jī)制外厂，針對于資源文件(配置的xml文件)有一個統(tǒng)一的接口Resource

常用方法

常用實(shí)現(xiàn)類

第四章 注解

Spring的一個核心功能是IOC佣耐，就是將Bean初始化加載到容器中，Bean是如何加載到容器的唧龄，可以使用Spring注解方式或者Spring XML配置方式兼砖。
Spring注解方式減少了配置文件內(nèi)容，更加便于管理既棺，并且使用注解可以大大提高了開發(fā)效率讽挟。
下面安裝分類講解Spring中常用的一些注解。

將普通類加入容器形成Bean

spring使用配置文件或者注解的方式進(jìn)行標(biāo)識需要處理的java類丸冕，從而知道哪些Java類當(dāng)bean類處理耽梅。

其中@Component、@Repository胖烛、@Service眼姐、@Controller實(shí)質(zhì)上屬于同一類注解，用法相同佩番，功能相同众旗，區(qū)別在于標(biāo)識組件的類型。

從容器中取Bean（裝配bean）

Spring MVC模塊注解

@Controller---與前端交互

表明該類會作為與前端作交互的控制層組件

• 通過服務(wù)接口定義的提供訪問應(yīng)用程序的一種行為，解釋用戶的輸入沃琅，將其轉(zhuǎn)換成一個模型然后將試圖呈獻(xiàn)給用戶

@Controller
public class HappyController {
    //do something
}

@RequestMapping---url --> 類或方法

• 這個注解用于將url映射到整個處理類或者特定的處理請求的方法
• 可以只用通配符哗咆！
• @RequestMapping中可以使用 method =屬性標(biāo)記其所接受的方法類型，如果不指定方法類型的話益眉，可以使用 HTTP GET/POST 方法請求數(shù)據(jù)晌柬，但是一旦指定方法類型姥份，就只能使用該類型獲取數(shù)據(jù)

@Controller
@RequestMapping("/happy")
public class HappyController  {

  @Autowired
  private HappyService happyService;

  @RequestMapping(/hello/ *)
  public void sayHello(){
        //請求為 /happy/hello/ * 都會進(jìn)入這個方法！
        //例如：/happy/hello/123   /happy/hello/adb
        //可以通過get/post 請求
  }

  @RequestMapping(value="/haha",method=RequestMethod.GET)
  public void sayHaHa(){
  //只能通過get請求
  }

}

第五章：Spring AOP

具體參考博客

AOP基本概念及特點(diǎn)

什么是AOP

AOP(Aspect Oriented Programming)意為：面向切面編程年碘，通過預(yù)編譯方式和運(yùn)行期動態(tài)代理實(shí)現(xiàn)程序功能的統(tǒng)一維護(hù)的一種技術(shù)澈歉。

主要功能是：日志記錄，性能統(tǒng)計(jì)屿衅，安全控制埃难，事務(wù)處理，異常處理等

AOP實(shí)現(xiàn)方式

• 預(yù)編譯
  AspectJ
• 運(yùn)行期間動態(tài)代理（JDK動態(tài)代理涤久、CGLib動態(tài)代理）
  SpringAOP涡尘、JbossAOP

AOP幾個關(guān)鍵概念

各關(guān)鍵概念具體介紹

Advice

說明：

使用方式：

通知執(zhí)行順序：

前置通知→環(huán)繞通知連接點(diǎn)之前→連接點(diǎn)執(zhí)行  1→  環(huán)繞通知連接點(diǎn)之后→返回通知→后通知
                                     2→  (如果發(fā)生異常)異常通知→后通知

pointcut

定義

• 一個切入點(diǎn)通過一個普通的方法定義來提供，使用@Pointcut注解

• 方法返回類型必須為void

• eg.
  定義一個名為‘a(chǎn)nyOldTransfer’县习，這個切點(diǎn)將匹配任何名為”transfer“的方法執(zhí)行@Pointcut("execution(* transfer(..))")//the pointcut expression

@Pointcut("execution(* transfer(..))")//the pointcut expression
private void anyOldTransfer(){}//the pointcut signature

組合pointcut

• 切入點(diǎn)表達(dá)式可以通過&&涮母、||、!進(jìn)行組合躁愿，也可以通過名字引入切入點(diǎn)表達(dá)式
• 通過組合叛本，可以建立更加復(fù)雜的切入點(diǎn)表達(dá)式

@Pointcut("execution(public * (..))")
private void anyPublicOperation(){}

@Pointcut("within(com.xyz.someapp.trading...)")
private void inTrading(){}

@Pointcut("anyPublicOperation() && inTrading()")
private void tradingOperation(){}

匹配語法

實(shí)現(xiàn)手法

環(huán)境

Spring中AOP代理由Spring的IOC容器負(fù)責(zé)生成帖世、管理休蟹，其依賴關(guān)系也由IOC容器負(fù)責(zé)管理，要在Spring 中使用AOP日矫，還需要加入這兩個jar包
1赂弓、aopalliance.jar
2、aspectjweaver.jar

Spring中 AOP中的兩種代理

1. Java動態(tài)代理
   默認(rèn)使用 哪轿〖鹫梗可以為任何接口實(shí)例創(chuàng)建代理了
2. CGLIB
   當(dāng)需要代理的類不是代理接口的時候，Spring會切換為使用CGLIB代理缔逛，也可強(qiáng)制使用CGLIB

Spring AOP的使用步驟

1. 定義具體業(yè)務(wù)邏輯模塊（目標(biāo)對象）
2. 定義切面（即實(shí)現(xiàn)通知邏輯）
3. 實(shí)現(xiàn)切面邏輯

兩種方式的例子

兩種方式备埃，基于Schema或@AspectJ姓惑。

一. 基于Schema的Spring AOP

第一步、定義具體業(yè)務(wù)模塊（目標(biāo)對象）

兩個業(yè)務(wù)模塊都是基于接口

TestAOPDaoImpl .java

public class TestAOPDaoImpl implements TestAOPDao{

    @Override
    public void addUser() {
        System.out.println("添加成功");
    }
}

TestAOPServiceImpl.java

public class TestAOPServiceImpl implements TestAOPService{

    @Autowired
    private TestAOPDao testAOPDao;

    @Override
    public void addUser() {
        testAOPDao.addUser();
    }
}

第二步和第三步按脚、 定義切面（即實(shí)現(xiàn)通知邏輯）

aop創(chuàng)建代理后會返回一個 連接點(diǎn)JointPoint于毙，然后在通知中可以通過該連接點(diǎn)實(shí)現(xiàn)我們的切面邏輯

日志切面

public class LogAdivice{

    public void myBeforeAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——前置通知——" + methodname);
    }

    public void myAfterAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——后置通知——" + methodname);
    }

   //環(huán)繞通知將決定要不要執(zhí)行連接點(diǎn)
    public void myAroundAdivice(ProceedingJoinPoint point) throws Throwable{
        System.out.println("環(huán)繞通知，執(zhí)行代碼前");
        //選擇執(zhí)行
        point.proceed();
        System.out.println("環(huán)繞通知辅搬，執(zhí)行代碼后");
    }
}

時間切面：

public class TimeAdvice {

    public void timeBefore(){
        System.out.println("beforeTime = " + System.currentTimeMillis());
    }

    public void timeAfter(){
        System.out.println("afterTime = " + System.currentTimeMillis());
    }
}

在applicationContext中配置切面：

<context:annotation-config/>
    <bean id="testAOPDao" class="com.ssh.dao.impl.TestAOPDaoImpl"/>
    <bean id="testAOPService" class="com.ssh.service.impl.TestAOPServiceImpl"/>
    <bean id="logAdivice" class="com.ssh.adivice.LogAdivice"/>
    <bean id="timeAdvice" class="com.ssh.adivice.TimeAdvice"/>

    <aop:config>
       <!-- 配置一個切面 -->
       <aop:aspect id="logaop" ref="logAdivice" order="2">
           <!-- 定義切入點(diǎn)唯沮，表示對service的所有方法都進(jìn)行攔截 -->
           <aop:pointcut expression="execution(* com.ssh.service.TestAOPService.*(..))" id="testpointcut"/>
           <!-- 定義前置通知 -->
           <aop:before method="myBeforeAdivice" pointcut-ref="testpointcut"/>
           <!-- 定義后置通知 -->
           <aop:after-returning method="myAfterAdivice" pointcut-ref="testpointcut"/>
           <!-- 定義環(huán)繞通知 -->
           <aop:around method="myAroundAdivice" pointcut-ref="testpointcut"/>
       </aop:aspect>

       <!-- 定義另一個切面 -->
       <aop:aspect id="timeaop" ref="timeAdvice" order="1">
           <!-- 定義切入點(diǎn)，表示對service的所有方法都進(jìn)行攔截 -->
           <aop:pointcut expression="execution(* com.ssh.service.TestAOPService.*(..))" id="testpointcut"/>
           <!-- 定義前置通知 -->
           <aop:before method="timeBefore" pointcut-ref="testpointcut"/>
           <!-- 定義后置通知 -->
           <aop:after-returning method="timeAfter" pointcut-ref="testpointcut"/>
       </aop:aspect>
    </aop:config>

當(dāng)有多個切面時堪遂，Spring默認(rèn)是按照切面定義的順序來執(zhí)行介蛉，也可以通過order屬性來配置切面的執(zhí)行屬性，order=1 早于 order=2執(zhí)行

測試

public class AOPTest {
    public static void main(String[] args) {
        ApplicationContext context = new 
                            ClassPathXmlApplicationContext("applicationContext.xml");
        TestAOPService service = (TestAOPService) context.getBean("testAOPService");
        service.addUser();
    }
}

二. 基于@AspectJ注解的AOP實(shí)現(xiàn)

啟用@AsjectJ支持

在applicationContext.xml中配置下面一句:

<aop:aspectj-autoproxy />

第一步溶褪、定義具體業(yè)務(wù)邏輯模塊（目標(biāo)對象）

第一步和基于Schema的一樣

TestAOPDaoImpl .java

public class TestAOPDaoImpl implements TestAOPDao{

    @Override
    public void addUser() {
        System.out.println("添加成功");
    }
}

TestAOPServiceImpl.java

public class TestAOPServiceImpl implements TestAOPService{

    @Autowired
    private TestAOPDao testAOPDao;

    @Override
    public void addUser() {
        testAOPDao.addUser();
    }
}

第二步和第三步 定義切面（即實(shí)現(xiàn)通知邏輯）

重點(diǎn)是定義切入點(diǎn)

@Aspect
public class LogAdivice{

    //定義一個方法作為切入點(diǎn)id
    @Pointcut("execution(* com.ssh.service.TestAOPService.*(..))")
    private void allMethod(){}

    @Before("allMethod()")
    public void myBeforeAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——前置通知——" + methodname);
    }

    @AfterReturning("allMethod()")
    public void myAfterAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——后置通知——" + methodname);
    }

  //環(huán)繞通知將決定要不要執(zhí)行連接點(diǎn)
    @Around("allMethod()")
    public void myAroundAdivice(ProceedingJoinPoint point) throws Throwable{
        System.out.println("環(huán)繞通知币旧，執(zhí)行代碼前");
        //執(zhí)行
        point.proceed();
        System.out.println("環(huán)繞通知，執(zhí)行代碼后");
    }
}

在applicationContext的配置：

<!-- 打開自動掃描(隱式打開注解管理器） -->
    <!-- <context:component-scan base-package="com.ssh"/> -->
    <context:annotation-config/>
    <bean id="testAOPDao" class="com.ssh.dao.impl.TestAOPDaoImpl"/>
    <bean id="testAOPService" class="com.ssh.service.impl.TestAOPServiceImpl"/>
    <bean id="logAdivice" class="com.ssh.adivice.LogAdivice"/>
    <bean id="timeAdvice" class="com.ssh.adivice.TimeAdvice"/>

    <!-- 打開aop注解管理器 -->
    <aop:aspectj-autoproxy/>

參考文章在各個小結(jié)中有鏈接