Spring

洛慕晨 發表於 2020-11-21

1、Spring

1.1、簡介

  • Spring:春天
  • [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-doXQasGm-1605962607198)(Spring.assets/image-20201111204457769.png)]
  • Spring理念:解決開發的複雜性。但也是一個大雜燴,整合現有的框架!
  • SSH:Struct2 + Spring + Hibernate
  • SSM:SpringMVC + Spring + Mybatis

官網:https://spring.io/projects/spring-boot

官方下載地址:https://repo.spring.io/libs-release-local/org/springframework/spring/

Github:https://github.com/spring-projects/spring-boot

Spring Maven倉庫:

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

1.2、優點

  • Spring是一個開源的免費框架(容器)!
  • Spring是一個輕量級的、非入侵式的框架!
  • 控制反轉(IOC),面向切面程式設計(AOP)!(重點)
  • 支援事務的處理,對框架整合的支援!

總結:Spring就是一個輕量級的控制反轉(IOC)和麵向切面程式設計(AOP)的框架!

1.3、組成

img

1.4、擴充

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-4TIaxznb-1605962607202)(Spring.assets/image-20201112143151090.png)]

  • SpringBoot
    • 快速開發的腳手架
    • 基於SpringBoot可以快速的開發單個微服務
    • 約定大於配置
  • SpringCloud
    • 基於SpringBoot實現

學習SpringBoot的前提,需要完全掌握Spring及SpringMVC,承上啟下

2、IOC理論推導

以前寫專案

  1. UserDao 介面

    package com.zheng.dao;
    
    public interface UserDao {
        void getUser();
    }
    
  2. UserDaoImpl 實現類

    package com.zheng.dao;
    
    public class UserDaoImpl implements UserDao{
        public void getUser() {
            System.out.println("default get user data");
        }
    }
    
  3. UserService 業務介面

    package com.zheng.service;
    
    public interface UserService {
        void getUser();
    }
    
  4. UserServiceImpl 業務實現類

    package com.zheng.service;
    
    import com.zheng.dao.UserDao;
    import com.zheng.dao.UserDaoImpl;
    import com.zheng.dao.UserDaoMysqlImpl;
    
    public class UserServiceImpl implements UserService{
    
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void getUser() {
            userDao.getUser();
        }
    }
    

Set介面實現

    private UserDao userDao;

	//利用set進行動態實現值的注入!
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

思想:將主動權從程式設計師手中交給使用者,減小程式的耦合性,讓程式設計師注重在業務層

IOC本質:解耦,實現方法是依賴注入(DI)

3、HelloSpring

  1. 建立Hello類

    package com.zheng.pojo;
    
    public class Hello {
        private String str;
    
        public String getStr() {
            return str;
        }
    
        public void setStr(String str) {
            this.str = str;
        }
    
        @Override
        public String toString() {
            return "Hello{" +
                    "str='" + str + '\'' +
                    '}';
        }
    }
    
  2. 配置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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--    使用Spring建立物件,在Spring這些都稱為Bean-->
        <bean id="hello" class="com.zheng.pojo.Hello">
            <property name="str" value="Spring"/>
        </bean>
    
    </beans>
    
  3. 建立測試類MyTest2

    import com.zheng.pojo.Hello;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest2 {
        public static void main(String[] args) {
            //獲取Spring的上下文物件!
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            Hello hello = (Hello) context.getBean("hello");
            System.out.println(hello.toString());
        }
    }
    
  4. 結果

    [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-pcSps0Y5-1605962607203)(Spring.assets/image-20201112205000194.png)]

3.1、改造以前的專案

  1. 增加配置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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="mysqlImpl" class="com.zheng.dao.UserDaoMysqlImpl"/>
        <bean id="UserServiceImpl" class="com.zheng.service.UserServiceImpl">
    
            <property name="userDao" ref="mysqlImpl"></property>
        </bean>
    
    </beans>
    
  2. 修改main函式

    import com.zheng.service.UserServiceImpl;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
        public static void main(String[] args) {
            //獲取ApplicationContext,拿到Spring的容器
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            //直接get
            UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
    
            userServiceImpl.getUser();
        }
    }
    

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-QziqveUY-1605962607205)(Spring.assets/image-20201114100824256.png)]

4、IOC建立物件的方式

  1. 使用無參構造物件,預設。

  2. 使用有參構造建立物件。

    1. 下標賦值

      <bean id="user" class="com.zheng.pojo.User">
          <constructor-arg index="0" value="ajax"/>
      </bean>
      
    2. 型別

      <bean id="user" class="com.zheng.pojo.User">
          <constructor-arg type="java.lang.String" value="ajax"/>
      </bean>
      
    3. 引數名

      <bean id="user" class="com.zheng.pojo.User">
          <constructor-arg name="name" value="ajax"/>
      </bean>
      

總結:在配置檔案載入的時候,容器中管理的物件就已經初始化了!

5、Spring配置

5.1、別名

<!--    別名,縮短名稱-->
<alias name="user" alias="user2"/>

5.2、Bean的配置

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-rM7wS8Ie-1605962607207)(Spring.assets/image-20201115143441716.png)]

5.3、import

一般用於團隊開發使用,將多個配置檔案匯入合併為一個

6、依賴注入

6.1、構造器注入

前面已經說過了

6.2、Set方式注入【重點】

  • 依賴注入:Set注入!
    • 依賴:bean物件的建立依賴於容器
    • 注入:bean物件中的所有屬性,由容器來注入

【環境搭建】

  1. 複雜型別

    package com.zheng.pojo;
    
    public class Address {
        private String address;
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }
    
  2. 真實測試物件

    package com.zheng.pojo;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Student {
        private String name;
        private Address address;
        private String[] books;
        private List<String> hobbies;
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", address=" + address +
                    ", books=" + Arrays.toString(books) +
                    ", hobbies=" + hobbies +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Address getAddress() {
            return address;
        }
    
        public void setAddress(Address address) {
            this.address = address;
        }
    
        public String[] getBooks() {
            return books;
        }
    
        public void setBooks(String[] books) {
            this.books = books;
        }
    
        public List<String> getHobbies() {
            return hobbies;
        }
    
        public void setHobbies(List<String> hobbies) {
            this.hobbies = hobbies;
        }
    }
    
  3. beans.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="student" class="com.zheng.pojo.Student">
            <property name="name" value="ajax"/>
        </bean>
    </beans>
    
  4. 測試類

    import com.zheng.pojo.Student;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            Student student = (Student) context.getBean("student");
            System.out.println(student.getName());
        }
    }
    

6.3、擴充方式注入

p名稱空間,c名稱空間

<?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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    p名稱空間,直接注入屬性-->
    <bean id="user" class="com.zheng.pojo.User" p:name="ajax" p:age="19"/>

    <!--c名稱空間,構造器注入:construct-args-->
    <bean id="user2" class="com.zheng.pojo.User" c:age="20" c:name="kk"/>
</beans>

測試:

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = context.getBean("user2", User.class);
    System.out.println(user);
}

注意點:p,c不能直接使用,要匯入約束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.4、bean的作用域

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-ItuXZBge-1605962607208)(Spring.assets/image-20201118103041289.png)]

  1. 單例模式(Spring預設機制)

    <bean id="accountService" class="com.something.DefaultAccountService"/>
    
    <!-- the following is equivalent, though redundant (singleton scope is the default) -->
    <!--以下是等效的,儘管是冗餘的(預設情況下是單例作用域)-->
    <bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>
    
  2. 原型模式:每次從容器get的時候,都會產生新物件

    <!--產生新的物件-->
    <bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>
    
  3. 其餘的request、session、application,這些只能在web開發中使用。

7、Bean的自動裝配

  • 自動裝配是Spring滿足bean依賴一種方式
  • Spring會在上下文中自動尋找,並自動給bean裝配屬性

在Spring中有三種裝配的方式

  1. 在xml中顯示的配置
  2. 在java中顯示配置
  3. 隱式的自動裝配bean【重點】

7.1、測試

環境搭建:一個人有兩隻寵物。

7.2、ByName自動裝配

<!--
byname:會自動在容器上下文中查詢,和自己物件set方法後面的值對應beanid! 
-->
<bean id="people" class="com.zheng.pojo.People" autowire="byName">
    <property name="name" value="aja"/>
</bean>

7.3、ByType自動裝配

<!--
byName:會自動在容器上下文中查詢,和自己物件set方法後面的值對應beanid!
byTame:會自動在容器上下文中查詢,和自己物件屬性型別相同的bean!
-->
<bean id="people" class="com.zheng.pojo.People" autowire="byType">
    <property name="name" value="aja"/>
</bean>

小結:

  • byname:需要保證所有bean的id唯一,並且這個bean需要和自動注入的屬性的set方法的值一致
  • bytype:需要保證所有bean的class唯一,並且這個bean需要和自動注入的屬性的型別一致

7.4、使用註解實現自動裝配

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

  1. 匯入約束
  2. 配置註解的支援:< context:annotation-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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    
    <context:annotation-config/>

</beans>

@Autowired:自動裝配

@Nullable:允許為空

測試程式碼

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

@Resource:java的自動裝配

只使用@Autowired

8、使用註解開發

在Spring4之後,要使用註解開發,必須要保證aop的包匯入

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-6ElvpGNw-1605962607209)(Spring.assets/image-20201118203215355.png)]

  1. bean

  2. 屬性如何注入

    //等價於<bean id="user" class="com.zheng.pojo.User"/>
    @Component
    public class User {
        @Value("asd")
        public String name;
    }
    
  3. 衍生的註解

    @Component有幾個衍生註解,功能一樣,註冊到Spring,裝配bean

    • dao【@Repository】
    • service【@Service】
    • controller【@Controller】
  4. 自動裝配

    @Autowired:自動裝配

    @Nullable:允許為空

    @Resource:java的自動裝配

  5. 作用域

    @Scope("prototype")
    @Component
    public class User {
        @Value("asd")
        public String name;
    }
    
  6. 小結

    xml與註解:

    • xml更加萬能,適用於任何場所,維護更簡單
    • 註解 不是自己類使用不了,維護相對複雜

    xml與註解最佳實踐:

    • xml用來管理bean
    • 註解只負責完成屬性的注入
    • 需要注意:必須讓註解生效,開啟註解的支援
    <!--    掃描包-->
    <context:component-scan base-package="com.zheng"/>
    <context:annotation-config/>
    

9、使用java的方式配置Spring

完全不需要xml配置檔案,在SpringBoot隨處可見,純註解

實體類:

package com.zheng.pojo;

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

@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("ajax")
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

配置類:

package com.zheng.config;

import com.zheng.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    //id
    @Bean
    public User user(){
        return new User();
    }
}

測試類:

import com.zheng.config.AppConfig;
import com.zheng.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        User getUser = (User) context.getBean("user");
        System.out.println(getUser.getName());
    }
}

10、代理模式

SpringAOP的底層:代理模式【SpringAOP和SpringMVC】

代理模式的分類:

  • 靜態代理
  • 動態代理

10.1、靜態代理

程式碼步驟:

  1. 介面

    package com.zheng.demo01;
    
    public interface Rent {
        public void rent();
    }
    
  2. 真實角色

    package com.zheng.demo01;
    
    public class Host implements Rent{
    
    
        public void rent() {
            System.out.println("房東要出租房子");
        }
    }
    
  3. 代理角色

    package com.zheng.demo01;
    
    public class Proxy {
        private Host host;
    
        public Proxy(){
    
        }
    
        public Proxy(Host host){
            this.host = host;
        }
    
        public void rent(){
            host.rent();
        }
    
        //...
    }
    
  4. 客戶端訪問代理角色

    package com.zheng.demo01;
    
    public class Client {
        public static void main(String[] args) {
            Host host = new Host();
    
            Proxy proxy = new Proxy(host);
            proxy.rent();
        }
    }
    

10.2、代理(切面程式設計)

10.3、動態代理

  • 動態代理和靜態代理角色一樣
  • 動態代理的代理類是動態生成的
  • 動態代理分為兩大類:基於介面的動態代理,基於類的動態代理
    • 基於介面—JDK動態代理
    • 基於類:cglib
    • java位元組碼實現:javassist

需要了解兩個類:Proxy代理,InvocationHandler呼叫處理程式

11、AOP

【重點】使用AOP織入,需要匯入一個依賴包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
    <scope>runtime</scope>
</dependency>

什麼是AOP

AOP(Aspect Oriented Programming)意為:面向切面程式設計,通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續,是軟體開發中的一個熱點,也是Spring框架中的一個重要內容,是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離,從而使得業務邏輯各部分之間的耦合度降低,提高程式的可重用性,同時提高了開發的效率。

Aop在Spring中的作用

提供宣告式事務;允許使用者自定義切面

以下名詞需要了解下:

  • 橫切關注點:跨越應用程式多個模組的方法或功能。即是,與我們業務邏輯無關的,但是我們需要關注的部分,就是橫切關注點。如日誌 , 安全 , 快取 , 事務等等 …
  • 切面(ASPECT):橫切關注點 被模組化 的特殊物件。即,它是一個類。
  • 通知(Advice):切面必須要完成的工作。即,它是類中的一個方法。
  • 目標(Target):被通知物件。
  • 代理(Proxy):向目標物件應用通知之後建立的物件。
  • 切入點(PointCut):切面通知 執行的 “地點”的定義。
  • 連線點(JointPoint):與切入點匹配的執行點。

SpringAOP中,通過Advice定義橫切邏輯,Spring中支援5種型別的Advice:

即 Aop 在 不改變原有程式碼的情況下 , 去增加新的功能 .

使用Spring實現Aop

【重點】使用AOP織入,需要匯入一個依賴包!

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

第一種方式

通過 Spring API 實現

首先編寫我們的業務介面和實現類

public interface UserService {
 
    public void add();
 
    public void delete();
 
    public void update();
 
    public void search();
 
}

public class UserServiceImpl implements UserService{

@Override
public void add() {
    System.out.println("增加使用者");
}
 
@Override
public void delete() {
    System.out.println("刪除使用者");
}
 
@Override
public void update() {
    System.out.println("更新使用者");
}
 
@Override
public void search() {
    System.out.println("查詢使用者");
}

}

然後去寫我們的增強類 , 我們編寫兩個 , 一個前置增強 一個後置增強

public class Log implements MethodBeforeAdvice {
 
    //method : 要執行的目標物件的方法
    //objects : 被呼叫的方法的引數
    //Object : 目標物件
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被執行了");
    }
}
public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被呼叫的方法
    //args 被呼叫的方法的物件的引數
    //target 被呼叫的目標物件
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("執行了" + target.getClass().getName()
        +"的"+method.getName()+"方法,"
        +"返回值:"+returnValue);
    }
}

最後去spring的檔案中註冊 , 並實現aop切入實現 , 注意匯入約束 .

<?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-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <!--aop的配置-->
    <aop:config>
        <!--切入點  expression:表示式匹配要執行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--執行環繞; advice-ref執行方法 . pointcut-ref切入點-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

測試

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.search();
    }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解這一塊 .

Spring的Aop就是將公共的業務 (日誌 , 安全等) 和領域業務結合起來 , 當執行領域業務時 , 將會把公共業務加進來 . 實現公共業務的重複利用 . 領域業務更純粹 , 程式猿專注領域業務 , 其本質還是動態代理 .

第二種方式

自定義類來實現Aop

目標業務類不變依舊是userServiceImpl

第一步 : 寫我們自己的一個切入類

public class DiyPointcut {
 
    public void before(){
        System.out.println("---------方法執行前---------");
    }
    public void after(){
        System.out.println("---------方法執行後---------");
    }
    
}

去spring中配置

<!--第二種方式自定義實現-->
<!--註冊bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
    <!--第二種方式:使用AOP的標籤實現-->
    <aop:aspect ref="diy">
        <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <aop:before pointcut-ref="diyPonitcut" method="before"/>
        <aop:after pointcut-ref="diyPonitcut" method="after"/>
    </aop:aspect>
</aop:config>

測試:

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

第三種方式

使用註解實現

第一步:編寫一個註解實現的增強類

package com.kuang.config;
 
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;
 
@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法執行前---------");
    }
 
    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法執行後---------");
    }
 
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("環繞前");
        System.out.println("簽名:"+jp.getSignature());
        //執行目標方法proceed
        Object proceed = jp.proceed();
        System.out.println("環繞後");
        System.out.println(proceed);
    }
}

第二步:在Spring配置檔案中,註冊bean,並增加支援註解的配置

<!--第三種方式:註解實現-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy:說明

通過aop名稱空間的<aop:aspectj-autoproxy />宣告自動為spring容器中那些配置@aspectJ切面的bean建立代理,織入切面。當然,spring 在內部依舊採用AnnotationAwareAspectJAutoProxyCreator進行自動代理的建立工作,但具體實現的細節已經被<aop:aspectj-autoproxy />隱藏起來了
 
<aop:aspectj-autoproxy />有一個proxy-target-class屬性,預設為false,表示使用jdk動態代理織入增強,當配為<aop:aspectj-autoproxy  poxy-target-class="true"/>時,表示使用CGLib動態代理技術織入增強。不過即使proxy-target-class設定為false,如果目標類沒有宣告介面,則spring將自動使用CGLib動態代理。