2. 程式人生 > >Spring基礎配置----依賴注入&AOP

Spring基礎配置----依賴注入&AOP

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

引言

spring框架本身有四大原則：

  1. 使用POJO進行輕量級和最小侵入式開發
  2. 通過依賴注入和基於介面變成實現鬆耦合
  3. 通過AOP和預設習慣進行宣告式程式設計
  4. 使用AOP和模板（template）減少模式化程式碼

Spring所有功能的設計和實現都是基於此四大原則。

一、依賴注入

 我們將常說的控制反轉（Inversion of Control-IOC）和依賴注入（dependency injection-DI）在Spring環境下是等同的概念，控制反轉是通過依賴注入實現的。所謂的依賴注入是指容器負責建立物件和維護物件間的依賴關係，而不是通過物件本身負責自己的建立和解決自己的依賴。

依賴注入起到的作用就是將物件之間的依賴關係從原先的程式碼中解耦出來，通過配置檔案或註解等方式加上Spring框架的處理讓我們對依賴關係靈活集中的進行管理。依賴注入的主要目的是為了解耦，體現的一種“組合”的概念。如果你希望你的類具備某項功能的時候，是繼承自一個具有此功能的父類好呢？還是組合另外一個具有這個功能的類好？答案是肯定的，如果說你繼承一個父類，子類將於父類耦合，組合另外一個類則是耦合度大大降低。

Spring Ioc 容器（ApplicationContext）負責建立 Bean ，並通過容器將功能類的 bean 注入到你需要的bean 中。Spring 提供使用 xml 、註解、java配置實現 Bean 的建立和注入。

無論是xml配置、註解配置、java配置，都稱之為配置元資料，所謂元資料即描述資料的資料。元資料本身不具備任何執行的能力，只能通過外界的程式碼來對這些元資料解析後進行相應的操作。Spring 容器解析這些配置元資料進行 Bean 初始化、配置和管理依賴。

宣告 Bean 的註解：

  • @Component元件，沒有明確的角色
  • @Service 在業務邏輯層（service層）使用
  • @Repository 在資料訪問層（dao層）使用
  • @Controller 在展現層（MVC--->Spring MVC）使用

注入Bean的註解，一般情況下通用

  • @Autowired：Spring提供的註解
  • @Inject：JSR-330提供的註釋
  • @Resource：JSR-250提供的註解

示例

1）編寫功能類的bean。

package com.wsf.spring;

import org.springframework.stereotype.Service;

/**
 * @author feng
 * @create 2018-09-20 14:00
 */
@Service
public class TestService {
    public String sayHello (String world) {
        return "Hello " + world ;
    }
}

程式碼解釋：

使用@Service 註解聲明當前TestService類是Spring管理的一個類。

2）使用功能類的 Bean。

package com.wsf.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author feng
 * @create 2018-09-20 14:04
 */
@Service
public class UseTestService {

    @Autowired
    TestService testService;

    public String sayHello (String word) {
        return testService.sayHello(word);
    }
}

程式碼解釋：

使用@Service 註解聲明當前UseTestService 類是Spring 管理的一個Bean。

使用@Autowired 將TestService 的實體 Bean注入到 UseTestService 中，讓UseTestService 具備 TestService 的功能。

3）配置類

package com.wsf.spring;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author feng
 * @create 2018-09-20 14:10
 */
@Configuration
@ComponentScan("com.wsf.spring")
public class MyConfig {
}

程式碼解釋：

@Configuration 聲明當前類是一個配置類。

@ComponentScan 自動掃描包名下所有使用@Service、@Component、@Repository和@Controller 的類，並註冊為Bean。

4）執行

import com.wsf.spring.MyConfig;
import com.wsf.spring.UseTestService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author feng
 * @create 2018-09-20 14:12
 */
public class MyTest {

    AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(MyConfig.class);

    UseTestService useTestService = context.getBean(UseTestService.class);

    @Test
    public void testSpringIOC(){
        System.out.println(useTestService.sayHello("Spring"));
        context.close();
    }
}

程式碼解釋：

使用AnnotationConfigApplicationContext 作為 Spring 容器 ，接受輸入一個配置類作為引數；

獲得宣告配置的 UseTestService 的Bean。

5）執行結果

Hello Spring

 二、AOP

AOP：面向切面程式設計。Spring的AOP的存在是為了解耦。AOP可以讓一組類共享相同的行為。

Spring支援AspectJ的註解式切面程式設計。

1）使用@Aspect宣告是一個切面

2)  使用@After、@Before、@Around 定義建言（advice），可直接將攔截規則（切點）作為引數。

3）其中@After、@Before、@Around引數的攔截規則為切點（PointCut），為了使切點服用，可使用@PointCut專門定義攔截規則，然後再@After、@Before、@Around 的引數中呼叫。

4）其中符合條件的每一個被攔截處為連線點（JoinPoint）。

示例

1）新增Spring aop支援和AspectJ依賴

2）編寫攔截規則的註解。

package com.wsf.spring.aop;

import java.lang.annotation.*;

/**
 * @author feng
 * @Description:TODO
 * @create 2018-09-20 16:36
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Action {
    String name();
}

程式碼解釋：

註解本身是沒有功能的，和xml一樣。註解和xml都是一種元資料，元資料即解釋資料的資料，這就是所謂配置。

註解的功能來自用這個註解的地方。

3）編寫使用註解的被攔截類

package com.wsf.spring.aop;

import org.springframework.stereotype.Service;

/**
 * @author feng
 * @Description:TODO
 * @create 2018-09-20 16:38
 */
@Service
public class DemoAnnotationService {
    @Action(name="註解式攔截的add操作")
    public void add(){}
}

4）編寫使用方法的被攔截類

package com.wsf.spring.aop;

import org.springframework.stereotype.Service;

/**
 * @author feng
 * @Description:編寫使用方法規則被攔截類
 * @create 2018-09-20 16:38
 */
@Service
public class DemoMethodService {
    public void add(){}
}

5）編寫切面

package com.wsf.spring.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author feng
 * @Description:TODO
 * @create 2018-09-20 16:41
 */
@Aspect
@Component
public class LogAscept {

    @Pointcut("@annotation(com.wsf.spring.aop.Action)")
    public void annotationPointCut(){};

    @After("annotationPointCut()")
    public void after (JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Action action = method.getAnnotation(Action.class);
        System.out.println("註解式攔截 " + action.name());
    }

    @Before("execution(* com.wsf.spring.aop.DemoMethodService.*(..))")
    public void before (JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("方法規則式攔截 " + method.getName());
    }

}

程式碼解釋：

通過@Aspect註解宣告一個切面。

通過@Component讓此切面成為Spring容器管理的Bean。

通過@PointCut註解宣告切點。

通過@After註解宣告一個建言，並使用@PointCut定義的切點。

通過反射可獲得註解上的屬性，然後做日誌記錄相關的操作。

通過@Before 直接宣告一個建言，此建言直接使用攔截規則作為引數。

6）配置類

package com.wsf.spring.aop;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author feng
 * @Description:TODO
 * @create 2018-09-20 16:54
 */
@Configuration
@ComponentScan("com.wsf.spring.aop")
@EnableAspectJAutoProxy
public class AopConfig {
}

程式碼解釋：使用@EnableAspectJAutoProxy註解開啟Spring對AspectJ代理的支援。

7）執行

import com.wsf.spring.aop.AopConfig;
import com.wsf.spring.aop.DemoAnnotationService;
import com.wsf.spring.aop.DemoMethodService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author feng
 * @create 2018-09-20 14:12
 */
public class AOPTest {

    AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AopConfig.class);
    DemoAnnotationService demoAnnotationService = context.getBean(DemoAnnotationService.class);
    DemoMethodService demoMethodService = context.getBean(DemoMethodService.class);

    /**
     * 測試AOP
     */
    @Test
    public void testSpringAOP(){
        demoAnnotationService.add();
        demoMethodService.add();
        context.close();
    }
    
}

執行結果：

註解式攔截 註解式攔截的add操作 方法規則式攔截 add

相關推薦

Spring基礎配置----依賴注入&AOP

引言 spring框架本身有四大原則： 使用POJO進行輕量級和最小侵入式開發 通過依賴注入和基於介面變成實現鬆耦合 通過AOP和預設習慣進行宣告式程式設計 使用AOP和模板（template）減少模式化程式碼 Spring所有功能的設計和實現都是基於此四大原則。

Spring基礎：依賴注入（DI）

一. Spring的概述 Spring是Java生態中最為成功的框架，他的核心思想是控制反轉（Inverse of Control）和麵向切面程式設計（Aspect Oriented Programming）。Spring的優勢： Spring可以通過配置（X

Spring Boot自動配置（Auto-Configuration），@EnableAutoConfiguration，Spring Beans和依賴注入

自動配置（Auto-Configuration） 自動配置（auto-configuration）是Spring Boot最重要的特性之一，因為該特性會根據應用的classpath（這個主要是根據maven pom.xml決定），annotations和其他的

關於spring中依賴注入(AOP)的理解

Spring中的依賴注入可以分為介面注入、構造器注入、set方法注入    介面注入的話都是實現一個介面然後實現對應的方法。（比較常用)    如果使用構造器注入可以在建立物件的同時完成依賴關係的建立。如果使用set方法注入的話更容易識別它的名稱。但是如果使用構造器注入的方式

對spring IOC(控制翻轉) DI(依賴注入)AOP(面向切面)理解

　(1) 控制反轉（Inversion of Confrol）：  物件的建立交給外部容器完成，這個就叫做控制反轉,　　Ioc—Inversion of Control，即“控制反轉”，不是什麼技術，而是一種設計思想。在Java開發中，Ioc意味著將你設計好的物件交給容器控

Spring 基礎知識 - 依賴註入

ans factory control 自己 int pac java str actor 所謂的依賴註入是指容器負責創建對象和維護對象間的依賴關系，而不是通過對象本身負責自己的創建和解決自己的依賴。 依賴註入主要目的是為了解耦，體現了一種“組合”的理念。 無論是xml配置

Spring基礎配置

cor 進行 TE 依賴 pojo log 代碼 基於接口 設計 Spring框架的四大原則： 1、使用POJO進行輕量級和最小侵入式開發； 2、通過依賴註入和基於接口編程實現松耦合； 3、通過AOP和默認習慣進行聲明式編程； 4、使用AOP和模板（template）減少模

Spring基礎（3）--- Spring基礎配置

string app 都是 autowired emp ice 條件 tex npoi Spring 基礎配置 Sprin框架本身有四大原則: 使用POJO進行輕量級和最小侵入式開發。 通過依賴註入和基於接口編程實現松耦合。 通過AOP實現默認習慣進行聲明式編程。 使用A

spring xml 配置 工廠注入

請注意，是通過工廠注入bean，而不是注入工廠。 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/sch

Spring學習--DI依賴注入

**依賴與依賴注入：** 傳統應用程式設計中所說的依賴一般指“類之間的關係”，那先讓我們複習一下類之間的關係： **泛化：**表示類與類之間的繼承關係、介面與介面之間的繼承關係； **實現：**表示類對介面的實現； **依賴：**

單元測試(Junit)使用及Junit支援Spring IOC的依賴注入

單元測試在我們日常寫程式碼的過程中特別重要，可以儘快發現區域性的程式碼問題 Junit是我經常使用的一種單元測試工具 下面先寫一個單元測試的示例 先寫一個提供呼叫方法的類 package test; /** * @author coder * @version v

深入理解Spring核心技術---Spring中的依賴注入

         在前面的幾篇部落格中給大家介紹了Spring中的IOC容器，現在大家應該都知道IOC容器的概念和實現的原理了吧，IOC容器是Spring的核心，他的功能就是幫助開發者去儲存物件以及管理物件之間的關係。不用讓開發者自己去管理物件之間的關係，使開發者只需要專注於

在IoC容器中裝配Bean之-----------基於XML的配置(依賴注入)

一.Spring裝配Bean的簡要概述 1.要使應用程式中的Spring容器成功啟動, 需要同時具備以下三個方面的條件: (1)Spring框架的類包都已經被Maven專案依賴成功. (2)應用程式為Spring提供了完整的Bean配置資訊. (3)Bean的類都已經

Spring基礎學習（四 AOP 註解實現）

配置XML  applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"

【筆記】Spring基礎配置及物件的基本獲取

一、首先安裝Spring Tool Suite 二、匯入需要用到基本jar包  commons-logging-1.1.3.jar spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELEASE.jar spr

Spring 入門-01-依賴注入

1.新增jar包 需要到下載好的spring裡的libs尋找基礎的四個包，beans,context,core,expression（或許有別的更方便的方法），還有第三方依賴包commons-logging 2.建立applicationContext.xml檔案，寫好框架， &l

Spring學習--IOC依賴注入

最近在玩SpringBoot，因為要做分享，所以拿出Spring去做個對比，才能感受到使用SpringBoot的簡單和快速性。 一.Spring定義 Spring是一個開源框架，為了解決企業應用開發的複雜性而建立的，但現在已經不止應用與企業應用。 Spring是一個輕量級的控制反轉（IO

Spring不支援依賴注入static靜態變數

在springframework裡,我們不能@Autowired一個靜態變數,使之成為一個spring bean,例如下面這樣:@Autowired private static YourClass yourClass; 可以試一下,yourClass在這種狀態下不能夠被

控制反轉 依賴注入 AOP 和 IOC

一.IOC概念 IOC也成為控制反轉和依賴注入 依賴注入和控制反轉是一個概念，具體講當某個角色需要另外一個角色協助時，在傳統程式設定過程中，需要由呼叫者建立被呼叫者的例項，但在string中建立呼叫者的工作不在由呼叫者完成，因此成為控制反轉。建立者的工作由spring來完成，然後注入到呼叫者

Spring Boot學習一之Spring Beans和依賴注入

　　你可以自由地使用任何標準的Spring框架技術去定義beans和它們注入的依賴。簡單起見，我們經常使用 @ComponentScan 註解搜尋beans，並結合 @Autowired 構造器注入。 　　如果遵循以上的建議組織程式碼結構（將應用的main類放到包的最上層，即rootpackage），那麼你