Spring入門（二）— IOC註解、Spring測試、AOP入門

本文主要介紹Spring整合Servlet背後的細節、IOC註解、Spring測試、AOP入門使用等。 ...

一、Spring整合Servlet背後的細節

1. 為什麼要在web.xml中配置listener

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

配置listener主要是為了捕獲項目發佈 | 伺服器啟動的契機，為瞭解析xml , 創建工廠。這個listener是spring官方提供的，裡面已經具備瞭解析xml 和創建工廠的代碼。

2. 為什麼要在web.xml中配置context-param

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

正如上面所說的，listener捕獲到了項目發佈的契機，進而去創建工廠。但是創建工廠需要解析xml 。 spring的這個監聽器裡面，預設會到WEB-INF/applicationContext.xml. 如果不想放置到這個位置，可以通過一個context-param來告訴spring，我們的配置文件在哪裡。 classpath 表示這個文件是位於類路徑底下。 classes目錄

3. 為什麼使用工具類也能拿到工廠，到底工廠放在了哪裡?　　

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    
    //項目一發佈，就執行
    public void contextInitialized(ServletContextEvent event) {
        //創建工廠
        initWebApplicationContext(event.getServletContext());
    }
}

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
        ...
        if (this.context == null) {
             //創建工廠
             this.context = createWebApplicationContext(servletContext);
        }
                             
 //把創建好的工廠，存儲到作用域     
 //servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, 
        this.context);
        ...
    }

//spring為了簡化程式員獲取工廠的工作， 就提供了一個工具類，其實這個工具類就是對取值的代碼進行封裝
ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        
//ApplicationContext context = (ApplicationContext) getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

二、IOC註解

1. 註解入門

導入jar包

spring-aop-xxx.jar
導入約束

<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">

在xml裡面打開註解掃描開關

<!-- 告訴spring要去解析類，因為類上有註解 -->
<context:component-scan base-package="com.pri.service.impl"/>

在托管的類上打註解

@Component("us") 
public class UserServiceImpl implements UserService {
    ...
}

問工廠要實例對象

//創建工廠 創建工廠，需要解析xml ，所以要傳遞進去xml文件
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
//問工廠要實例對象
UserService userService = (UserService) context.getBean("us");
        
//調用方法
userService.save();
        
//關閉工廠 : 以後我們幾乎不會關閉工廠。
((AbstractApplicationContext) context).close();

2. 註解創建對象

/*
 1. @Component組件，表示要托管這個類，讓spring創建這個類的實例。 括弧裡面的us 其實就是id標識符
 2. @Component 是通用的註解， 對任何托管的類都可以使用，但是spring為了迎合三層架構，所以對每一層
 也給出了具體的註解。
        Action  --- @Controller
        Service --- @Service
        Dao --- @Repository :倉庫，
    建議： 如果以後托管三層中的類，請使用具體對應的註解，如果托管的是普通的其他類。@Component
 3. 預設生成的實例還是單例，如果想做成多例，那麼還得添加一個註解
        @Scope("prototype")
 4.  @PostConstruct  //初始化實例的時候調用
     @PreDestroy  //銷毀實例之前，調用
 5. 如果使用註解托管某一個類，不寫屬性值，那麼預設的id標識符就是類的名字（首字母是小寫） userServiceImpl
 6.<!-- 如果想要掃描多個包，就寫一個通用的首碼即可 -->
<context:component-scan base-package="com.pri"/>
*/

3. DI註解開發（註入對象）

使用註解來完成依賴註入。一般註解註入，它針對的點是對象的註入。 spring針對對象的註入，提供了兩個註解 @Resource 和 @Autowired

常用的註解就兩個 @Resource & @Autowired

@Resource（name="ud"）根據給定的標記找到對應的類，創建對象，註入進來。

@Autowired 自動裝配，會找到對應的實現類創建對象，註入進來。但是如果存在多個實現，那麼會拋出異常

@Repository("ud")
public class UserDaoImpl implements UserDao {
}

public class UserServiceImpl implements UserService {   
    @Resource(name="ud") //spring拿著ud找到具體的類，然後創建實例，註入進來。
    private UserDao userDao;
    ...
}
----------------------------------------------------------
public class UserServiceImpl implements UserService {
     @Autowired  //自動裝配 根據註入的介面類型找到對應的實現類，註入進來。
     private UserDao userDao;
        ...
}

4. xml和註解混合使用

在項目裡面，使用xml和註解來完成Spring 的配置。

xml : 負責完成IOC (對象的創建)

註解 : 負責完成DI （屬性的註入）

xml托管類

<context:component-scan base-package="com.pri"/>
<bean id="ud" class="com.pri.dao.impl.UserDaoImpl"></bean>
<bean id="us" class="com.pri.service.impl.UserServiceImpl"></bean>

註解完成註入：

 public class UserServiceImpl implements UserService {
     @Resource(name="ud")
     private UserDao userDao;
 }

三、Spring測試

導入jar包

spring-test-xxx.jar
托管業務邏輯類，不管是用xml還是註解都可以

<bean id="us" class="com.pri.service.impl.UserServiceImpl"></bean>

在測試類上打上註解，給測試類的成員變數註入值

//spring擴展了junit的運行環境，除了有測試功能之外，還在裡面定義了創建工廠的代碼
@RunWith(SpringJUnit4ClassRunner.class)

//告訴spring的測試環境，配置文件在哪裡
@ContextConfiguration("classpath:applicationContext.xml")
public class TestUserService {
    
    //測試類裡面出現的註解，不用打開掃描開關。因為這個測試環境裡面，它會解析這個測試類的註解。 
    @Autowired
    private UserService userService;
    @Test
    public void testSave(){
        userService.save();
    }
}

四、AOP

1. 什麼是AOP ，它有什麼用?

AOP（Aspect Oriented Programming，面向切麵編程），可以說是OOP（Object Oriented Programing，面向對象編程）的補充和完善。OOP更多的是側重於上下間的關係（繼承關係、實現關係）， OOP很難體現左右間的關係。核心：在不改動源碼的前提下，對原有功能能完成擴展 | 升級

2. AOP的底層原理

aop不改源碼，但是能夠擴展和升級代碼。能夠做成這個事情，只有三種解決手法： 裝飾者模式 ， 靜態代理 、 動態代理 。 AOP 選擇的是動態代理，裝飾者模式和靜態代理，要求我們必須寫出來裝飾類和代理類。動態代理的實現機制，有兩種： 基於JDK的動態搭理、基於Cglib的動態代理

1. 動態代理的實現機制

基於JDK的動態代理

如果哪一個真實類有實現介面，那麼就採用這種方式，創建出來介面的另一個實現類作為代理類

//jdk動態代理
@Test
public void testJDKPorxy(){
    
    //UserService userService = new UserServiceImpl();
    //userService.save();
    
    //1. 先創建真實對象
    final UserService userService = new UserServiceImpl();
    
    //2. 創建代理對象
    UserService proxyObj = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),  //類載入器，真實類用什麼，代理類就用什麼
            userService.getClass().getInterfaces(),  //真實類實現什麼介面，代理類也實現什麼介面
            new InvocationHandler() {//回調函數
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("invoke~");
                    //userService.save();
                    
                    if(method.getName().equals("save")){
                        Logger.log();
                    }
                    
                    //以不變應萬變。 反射調用
                    return method.invoke(userService, args);
                }
            }); 
    
    //3. 讓代理對象幹活
    proxyObj.save();  //代理對象。save()  ----> 真實對象.save();
}

基於Cglib動態代理

如果真實類是一個普通類，沒有實現介面，那麼就採用這種方式，創建出來真實類的子類作為代理類。

//cglib動態代理
@Test
public void testCglibPorxy(){
    //1. 一定要有真實對象
    final ProductService productService = new ProductService();
    //2. 創建代理
    Enhancer  enhancer = new Enhancer();
    //設置父類是誰
    enhancer.setSuperclass(ProductService.class);
    //設置回調
    enhancer.setCallback(new MethodInterceptor() {
        /*
         * arg0 :代理對象
         * arg3 : 方法的代理 
         * 
         * 一般這兩不用。
         * 
         * arg1 ： 方法引用
         * arg2 :參數
         */
        @Override
        public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
            Logger.log();
            return arg1.invoke(productService, arg2);
        }
    });
    
    //創建代理對象
    ProductService proxyObj = (ProductService) enhancer.create();
    proxyObj.save(); 
}

3. AOP術語

4.AOP的入門

Spring的AOP其實已經準備好了創建代理的代碼。只是不知道的是要創建誰的代碼。哪些方法需要被增強。我們需要通過配置的形式告訴spring。

定義業務邏輯類

public class UserServiceImpl implements UserService {

    @Override
    public void save() {
        System.out.println("調用了UserServiceImpl 的 save方法");
    }
}

定義增強類

public class Logger {
    public static void log(){
        System.out.println("輸出日誌了~~");
    }
}

導入jar包

    a. 導入 spring必須的jar

    b. 額外導入： 

        spring-aop-xx.jar,spring-aspect-xx.jar

        面向切麵過程中，Spring AOP是遵循了AOP聯盟的規範實現的，所以需要有AOP聯盟的介面包
        aopalliance-x.x.jar，介面包依賴aspectjweaver-x.x.x.jar

xml中配置

要導入aop的約束

讓spring托管 業務邏輯類 和 增強類

<bean id="us" class="com.pri.service.impl.UserServiceImpl" ></bean>
<bean id="logger" class="com.pri.util.Logger" ></bean>

配置AOP

<!-- 2. 開始配置aop -->
    <aop:config>
        <!-- 配置切入點  expression 表達式 '
            execution(* com.xyz.myapp.service.*.*(..))
            execution 固定寫法
            第一個* 代表任意返回值
            com.xyz.myapp.service ： 包名
            第二個* 包下的任意類
            第三個* 類中的任意方法
            (..) : 任意參數
        saveUser
        saveOrder
        -->
        <aop:pointcut expression="execution(* com.pri.service.impl.*.*(..))" id="aa"/>
        <!-- 配置增強 
            根據aa的表達式找到的方法，都給他們做前置增強，增強的功能是log方法
        -->
        <aop:aspect ref="logger"> 
            <aop:before method="log" pointcut-ref="aa"/>
        </aop:aspect>
    </aop:config>

5. AOP 增強

<aop:config>
　　<aop:pointcut expression="execution(* com.pri.service.impl.*.*(..))" id="pointcut01"/>
    <!-- 真正用aop來擴展一個功能，比較少。 除非是我們想擴展第三方jar包。 
        aop的思想無處不在：struts 攔截器 （就是AOP） -->
        
        <!-- 配置切麵aspect -->
        <aop:aspect ref="logger">
            <!-- 前置增強 -->
            <!-- <aop:before method="log" pointcut-ref="pointcut01"/> -->
            
            <!-- 最終增強 -->
            <!-- <aop:after method="log" pointcut-ref="pointcut01"/> -->
            
            <!-- 後置增強 -->
            <!-- <aop:after-returning method="log" pointcut-ref="pointcut01"/> -->
            
            <!-- 異常增強 -->
            <!-- <aop:after-throwing method="log" pointcut-ref="pointcut01"/> -->
            
            <!-- 環繞增強 -->
            <!-- <aop:around method="around" pointcut-ref="pointcut01"/>  -->
            <aop:before method="log" pointcut-ref="pointcut01"/>
            <aop:after-returning method="log" pointcut-ref="pointcut01"/>
        </aop:aspect>
   </aop:config>

Spring入門（二）— IOC註解、Spring測試、AOP入門

一、Spring整合Servlet背後的細節

1. 為什麼要在web.xml中配置listener

2. 為什麼要在web.xml中配置context-param

3. 為什麼使用工具類也能拿到工廠，到底工廠放在了哪裡?

二、IOC註解

1. 註解入門

2. 註解創建對象

3. DI註解開發（註入對象）

4. xml和註解混合使用

三、Spring測試

四、AOP

1. 什麼是AOP ， 它有什麼用?

2. AOP的底層原理

1. 動態代理的實現機制

3. AOP術語

4.AOP的入門

5. AOP 增強

3. 為什麼使用工具類也能拿到工廠，到底工廠放在了哪裡?　　

1. 什麼是AOP ，它有什麼用?