2. 程式人生 > >Spring 的 IOC 和 AOP的簡單實現

Spring 的 IOC 和 AOP的簡單實現

阿新 • • 發佈：2018-12-18

一、IOC

1、配置檔案實現IOC

IOC ：控制反轉，將建立物件的控制權又之前的new轉移給Spring框架，目的是為了解耦。

  1. 匯入相應的Jar包。
  2. 匯入配置檔案applicationContext.xml  並進行配置如下： 
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
	xmlns:jee="http://www.springframework.org/schema/jee" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	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
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
   

    <!-- 菜系類 -->
    <bean id="cuisine" class="com.bb.hrb.pojo.Cuisine">
    	<!-- <property name="name" value="魯菜"></property>-->
    	<constructor-arg index="0" value="東北菜"></constructor-arg>
    </bean>
    <!-- 菜品類 -->
    <bean id="food" class="com.bb.hrb.pojo.Food">
    	<!-- 通過setter方法進行依賴注入，直接引用上面的id為cuisine屬性賦值 -->
    	<!-- <property name="cuisine" ref="cuisine"></property>-->
    	<!-- 通過構造器進行依賴注入 -->
    	<constructor-arg index="0" value="豬肉燉粉條"></constructor-arg>
    	<constructor-arg index="1" value="36.8"></constructor-arg>
    	<constructor-arg index="2" ref="cuisine"></constructor-arg>
    </bean>


</beans>

    屬性介紹：

      <bean id="" class=""></bean>
  class屬性是用來指明類的包名加類名，id屬性用來獲取這個bean物件

  <bean id="" class="">
    <property name="" ref=""></property>
   </bean>
  property標籤用來通過setter方法進行依賴注入，name屬性是bean物件中屬性名，ref指向一個
    bean的id，還可以有value屬性，用於直接設定基本資料型別

   <bean id="" class="">
    <constructor-arg index="" value="" ref=""></constructor-arg>
   </bean>
   constructor-arg標籤是通過構造器進行依賴注入，index屬性指定第幾個構造器引數0為第一個，
    value用於直接設定基本資料型別。ref指向一個bean的id

     

  3. 現在就可以直接使用了！實現如下：

// 讀取配置檔案，如果配置檔案中bean中已經賦值，則返回一個賦好值得物件，反之則返回空物件
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//food為配置檔案裡的id
Food food = (Food) ac.getBean("food");
System.out.println(food);

 

2、註解實現IOC

 使用註解只需要在Spring配置檔案中新增標籤：自動掃描註解
    <context:component-scan base-package="com.bb.hrb"></context:component-scan>

1、bean註解
  @Control 用於控制層元件
  @Service 用於業務層元件
  @Respository 用於DAO層元件
  @Component 用於其它元件
  以上註解使用後都可以建立bean物件，沒有區別，不同的使用只是便於分層理解
  添加註解之後預設將類名(首字母小寫)定義為bean的id名，id也可以自己定義(註解後
新增小括號雙引號，在其中新增自定義的id名)

  2、依賴注入註解
  @Resource JDK提供的
  @AutoWired Spring提供的   預設按照型別匹配，也可指定id
  @Qualifier 配合@AutoWired使用，用於指定注入的bean的id

二、AOP

1、配置檔案實現AOP

AOP： "面向切面程式設計"或者叫做"面向方面程式設計"
        可以動態的在一個類的方法執行前後自動之前其它類的方法，在不改變這兩個類程式碼的前提下就可以實現，這種程式設計思想就是"面向切面程式設計"，當不再需要使用時可以自由分開。

1、首先還是匯入相應的jar包

2、模擬建立 兩個類

UserService類

public class UserService{

	public void addUser() {
		System.out.println("使用者註冊");
	}

	public String deleteUser() {
		System.out.println("刪除使用者");
        String name = null;
		try{
			name.length();
		} catch(Exception ex) {}
		return "success";
	}

}

UserLogging通知類

import org.aspectj.lang.ProceedingJoinPoint;

public class UserLogging {
	public void logger() {
		System.out.println("前置通知...");
	}
	public void afterLogger() {
		System.out.println("最終通知...");
	}
	public void afterLoggerReturning(Object ret) {
		System.out.println("後置通知..." + ", 返回值是：" + ret);
	}
	public void afterLoggerThrowing(Exception ex) {
		System.out.println("異常通知...");
		//ex.printStackTrace();
	}
	/*
	 * 環繞通知需要ProceedingJoinPoint執行proceed()目標方法
	 * 並且需要return執行proceed()後的返回值
	 */
	public Object aroundLogger(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("環繞通知前部...");
		Object r = pjp.proceed();// 執行目標方法
		System.out.println("環繞通知後部...");
		return r;
	}
}

3、然後在Spring配置檔案中加入

  	<bean id="userService" class="com.oracle.service.UserServiceImpl"></bean>
	
	<bean id="logg" class="com.oracle.aop.UserLogging"></bean>
	
	<aop:config>
		<!-- 定義切入點 -->
        <!-- 第一個*代表返回值，第二個*代表類，第三個*代表方法，（..）所有的過載方法，..表示任意的引數列表 -->
		<aop:pointcut expression="execution(* com.oracle.service.*.*(..))" id="servicePointcut"/>
		<!-- 配置切面 -->
		<aop:aspect id="loggeraspect" ref="logg">
			<!-- 前置通知 -->
			<aop:before method="logger" pointcut-ref="servicePointcut"/>
			<!-- 最終通知 -->
			<aop:after method="afterLogger" pointcut-ref="servicePointcut"/>
			<!-- 後置通知 returning="ret"的值要和異常通知的方法的引數一致 -->
			<aop:after-returning method="afterLoggerReturning" pointcut-ref="servicePointcut" returning="ret"/>
			<!-- 異常通知 throwing="ex"的值要和異常通知的方法的引數一致 -->
			<aop:after-throwing method="afterLoggerThrowing"  pointcut-ref="servicePointcut" throwing="ex"/>
			<!-- 環繞通知 -->
			<aop:around method="aroundLogger" pointcut-ref="servicePointcut"/>
		</aop:aspect>
	</aop:config>

4、大功告成，寫一個測試類測試一下吧！

public class TestUserService {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService service = (UserService) ac.getBean("userService");
		service.addUser();
		String r = service.deleteUser();
		System.out.println(r);
	}
}

2、註解實現AOP

使用註解只需要在Spring配置檔案中寫兩行

    <!-- 註解IOC -->
    <context:component-scan base-package="com.oracle"></context:component-scan>
    <!-- 註解AOP -->
    <aop:aspectj-autoproxy />

舉個栗子：

我們把上面用配置檔案實現的改一下

UserService類：

import org.springframework.stereotype.Service;

@Service("userService")
public class UserService {

	public void addUser() {
		System.out.println("使用者註冊");
	}

	public String deleteUser() {
		System.out.println("刪除使用者");
		String name = null;
		try{
			name.length();
		} catch(Exception ex) {}
		return "success";
	}

}

UserLogging通知類：這裡只拿前置通知為例

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class UserLogging {
	// 定義切入點，這個方法就相當於切入點id
	@Pointcut("execution(* com.oracle.service.*.*(..))")
	public void servicePointcut(){}
	
	@Before("servicePointcut()")
	public void logger() {
		System.out.println("前置通知...");
	}
	public void afterLogger() {
		System.out.println("最終通知...");
	}
	public void afterLoggerReturning(Object ret) {
		System.out.println("後置通知..." + ", 返回值是：" + ret);
	}
	public void afterLoggerThrowing(Exception ex) {
		System.out.println("異常通知...");
		//ex.printStackTrace();
	}
	/*
	 * 環繞通知需要ProceedingJoinPoint執行proceed()目標方法
	 * 並且需要return執行proceed()後的返回值
	 */
	public Object aroundLogger(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("環繞通知前部...");
		Object r = pjp.proceed();// 執行目標方法
		System.out.println("環繞通知後部...");
		return r;
	}
}

好了可以測試一下了，測試類用上面的就可以。

相關推薦

自己動手實現的 Spring IOC 和 AOP - 上篇

1. 背景 我在大四實習的時候開始接觸 J2EE 方面的開發工作，也是在同時期接觸並學習 Spring 框架，到現在也有快有兩年的時間了。不過之前沒有仿寫過 Spring IOC 和 AOP，只是巨集觀上對 Spring IOC 和 AOP 原理有一定的認識。所以為了更進一步理解 Spring

Spring IoC和AOP使用擴展

處理類型 can 初始 ext @aspectj 環繞增強 組件 ont qualifier 　　Spring提供了設值註入，構造註入等依賴註入方式。 　　使用p命令空間可以簡化屬性註入的配置。 　　Spring提供的增強處理類型包括前置增強，異常拋出增強，環繞增強，最終增

Spring IoC和AOP使用擴展（二）

cor ima 容器 常用 size ops ali class sta 一、IOC的實現方式： 　　Set註入：熟悉必須有公共set方法； 　　構造器註入：可以根據構造器參數名稱、下標註入； 　　p命名空間註入：要求有set方法； 　　 　　 　　 　　內部bean的實現

Spring IOC 和 AOP

文件 編程思想 dep nbsp 織入 擴展 con 集中管理 重復 一.　　IOC 　　1.　概念及原理 　　IOC: Inversion of Control(控制反轉)是一種設計思想,就是容器控制應用程序所需要的外部資源的創建和管理,然後將其反轉給應用程序.對象及其依

對Spring Ioc和AOP的理解

轉載自：https://blog.csdn.net/u013148153/article/details/80293587  Ioc和AOP是Spring的兩大核心，面試的時候也經常被問及對這兩個概念的理解，因此也記下我對此的理解，方便以後查漏補缺。  一、控制反轉(Ioc,

Spring IOC和AOP

Spring提供了很多輕量級應用開發實踐的工具集合，這些工具集以介面、抽象類、或工具類的形式存在於Spring中。通過使用這些工具集，可以實現應用程式與各種開源技術及框架間的友好整合。比如有關jdbc封裝的資料訪問工具Spring JDBC，有關編寫單元測試的spring t

Spring——IoC和Aop使用拓展

一、多種方式實現依賴注入 構造注入 設值注入 p名稱空間注入 1、構造注入：通過建構函式注入資料。 構造注入的優劣勢：構造注入的時效性好，在物件例項化時就得到所依賴的物件，便於在物件的初始化時就得到所依賴的物件，便於在物件的初始化方法中使用依賴物件；但受限於方法

關於spring IOC和AOP的解析原理和舉例

1.關於spring ioc  　這段時間也著實好好的看了下spring的相關書籍，對其也有了大概和初步的認識和理解，雖然之前也一直聽說spring是一個非常優秀的開源框架，可一直沒有機會學習和使用（是不是有點落伍了？呵呵），所以呢，這段時間就重點學習了spring（一個星期的時間

Spring IOC和AOP 原理徹底搞懂

Spring提供了很多輕量級應用開發實踐的工具集合，這些工具集以介面、抽象類、或工具類的形式存在於Spring中。通過使用這些工具集，可以實現應用程式與各種開源技術及框架間的友好整合。比如有關jdbc封裝的資料訪問工具Spring JDBC，有關編寫單元測試的

spring ioc和aop原理理解

ioc的意思是控制反轉，表示建立物件並不是new出來的，而是通過spring配置建立的，實現原理是xml配置檔案+SAX解析+工廠模式。aop的意思是面向切面程式設計，表示將封裝好的物件剖開，找出對多個物件產生影響的公共行為，並封裝成可重用的模組，這種被成為“切面”，切面將那

關於spring,IOC和AOP的解析原理和舉例

先從IOC說起，這個概念其實是從我們平常new一個物件的對立面來說的，我們平常使用物件的時候，一般都是直接使用關鍵字類new一個物件，那這樣有什麼壞處呢？其實很顯然的，使用new那麼就表示當前模組已經不知不覺的和new的物件耦合了，而我們通常都是更高層次的抽象模組

【Java】 Spring 框架初步學習總結（一）簡單實現 IoC 和 AOP

1.0 其中 表示 只需要 第一篇 否則 info fin pojo 　　Spring 是一個開源的設計層面的輕量級框架，Spring 的好處網上有太多，這裏就不在贅述。 　　IoC 控制反轉和 AOP 面向切面編程是 Spring 的兩個重要特性。 　　IoC（Inver

對於spring中IOC和AOP的理解及程式碼簡單實現

IoC（Inversion of Control）: 在傳統的java程式編寫中如果呼叫方法或類者，必須要對被呼叫者進行例項化，即必須要通過new 被呼叫者類，才能對被呼叫者類中的方法、成員進行操作。在開發某一個專案時必然會出現很多類來完善專案的需求，並且類與類

Spring 的 IOC 和 AOP的簡單實現

一、IOC 1、配置檔案實現IOC IOC ：控制反轉，將建立物件的控制權又之前的new轉移給Spring框架，目的是為了解耦。 匯入相應的Jar包。 匯入配置檔案applicationContext.xml  並進行配置如下： <?xml version="

「框架」菜鳥簡單模仿一下spring的ioc和aop思想，歡迎大家進來閱讀指教

col buffere all 防止 換行 root getc rop proxy *博客搬家：初版發布於 2015/12/04 16:41 原博客地址：https://my.oschina.net/sunqinwen/blog/539397 spring最核心的部

Spring IOC和Spring AOP的實現原理(原始碼主線流程)

寫在前面      正本文參考了《spring技術內幕》和spring 4.0.5原始碼。本文只描述原理流程的主線部分，其他比如驗證，快取什麼可以具體參考原始碼理解。Spring IOC一、容器初始化      容器的初始化首先是在對應的構造器中進行，在application

理解Spring中的IOC和AOP

nfa 重復 高度 只需要 spring框架 aop 編程 靈活 攔截 我們是在使用Spring框架的過程中，其實就是為了使用IOC，依賴註入和AOP，面向切面編程，這兩個是Spring的靈魂。 主要用到的設計模式有工廠模式和代理模式 IOC就是典型的工廠模式，通過se

Spring 容器IOC解析及簡單實現

interface utf-8 cat container 就是 pat 註入 () class 最近一段時間，“容器”兩個字一直縈繞在我的耳邊，甚至是吃飯、睡覺的時候都在我腦子裏蹦來蹦去的。隨著這些天一次次的交流、討論，對於容器的理解也逐漸加深。理論上的東西終歸要落實到實

用通俗的語言解釋 Spring 中的 DI 、IOC 和AOP概念

private rgs 完成 編程 而是 無需 解決 情況 分離關註點 DI 所謂依賴，從程序的角度看，就是比如A要調用B的方法，那麽A就依賴於B，反正A要用到B，則A依賴於B。所謂倒置，你必須理解如果不倒置，會怎麽著，因為A必須要有B，才可以調用B，如果不倒置，意思就是A

深入理解Spring的兩大特征（IOC和AOP）<轉>

編譯器 如果 定義 包括 其他 enc row 這就是 生命 在某博主的博客上看到一篇解釋Spring的兩大核心IOC與AOP的文章，借此轉發一下，希望能夠幫助到更多的人。 原文地址：https://blog.csdn.net/gloomy_114/article/deta