Spring個人筆記_ZenDei技術網路在線

xml配置 1.xml基本結構：其中id是bean字元串，bean的唯一標識符，相當於對象名，class是bean類名的完全限定路徑 2.別名起別名有兩種方式， 1.通過alias 2.通過bean中的name屬性用bean中name更高級，可以起多個別名 IoC創建對象方式 1.通過無參構造 ...

xml配置

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="..." class="...">  
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->

</beans>

其中id是bean字元串，bean的唯一標識符，相當於對象名，class是bean類名的完全限定路徑

2.別名

起別名有兩種方式，

1.通過alias

<bean id="helloWorld" class="com.hyq.pojo.HelloWorld">
        <property name="hello" value="abc"/>
    </bean>
    <alias name="helloWorld" alias="dsd"/>
name=hello是創建對象的變數名，相當於Helloworld hello= new Helloworld（）；
value 為參數賦值，

ApplicationContext context = new                       ClassPathXmlApplicationContext("ApplicationContext.xml");解析xml文件的固定格式（不止一種）
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");獲取類對象，
        HelloWorld helloWorld = (HelloWorld) context.getBean("dsd");也可以用別名獲取對象

2.通過bean中的name屬性

<bean id="helloWorld" class="com.hyq.pojo.HelloWorld" name="dsdd,h1">
        <property name="hello" value="abc"/>
    </bean>

ApplicationContext context = new                       ClassPathXmlApplicationContext("ApplicationContext.xml");解析xml文件的固定格式（不止一種）
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");獲取類對象，
        HelloWorld helloWorld = (HelloWorld) context.getBean("h1");也可以用別名獲取對象

用bean中name更高級，可以起多個別名

IoC創建對象方式

1.通過無參構造來創建對象，系統預設

2.通過有參構造函數來創建。(構造器construction )

1.下標賦值

<bean id="helloWorld" class="com.hyq.pojo.HelloWorld">
        <constructor-arg index="0" value="abc"/>
    </bean>
index：下標是從有參構造函數中括弧的參數開始算起

2.類型賦值（不建議使用）

<bean id="helloWorld" class="com.hyq.pojo.HelloWorld">
        <constructor-arg type="java.lang.String" value="ds"/>
    </bean>
當有參構造函數括弧中有兩個string類型的變數時，無法使用

總結：在xml註冊的bean對象，只要註冊，無論使不使用，對象都被創建

DI依賴註入

分為以下幾種

Student實體類：

package com.hyq.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] array;
    private List<String> hobby;
    private Map<String,String> books;
    private Set<String> movie;
    private Properties properties;
    private String wife;

    public Student() {
    }

    public Student(String name,String wife) {
        this.name = name;
        this.wife = wife;
    }

    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[] getArray() {
        return array;
    }

    public void setArray(String[] array) {
        this.array = array;
    }

    public List<String> getHobby() {
        return hobby;
    }

    public void setHobby(List<String> hobby) {
        this.hobby = hobby;
    }

    public Map<String, String> getBooks() {
        return books;
    }

    public void setBooks(Map<String, String> books) {
        this.books = books;
    }

    public Set<String> getMovie() {
        return movie;
    }

    public void setMovie(Set<String> movie) {
        this.movie = movie;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", array=" + Arrays.toString(array) +
                ", hobby=" + hobby +
                ", books=" + books +
                ", movie=" + movie +
                ", properties=" + properties +
                ", wife='" + wife + '\'' +
                '}';
    }
}

Address實體類

package com.hyq.pojo;

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

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

    <bean id="address" class="com.hyq.pojo.Address">
        <property name="address" value="河南"/>
    </bean>

    <bean id="student" class="com.hyq.pojo.Student">
        <!-- 普通註冊 -->
        <property name="name" value="小明"/>
        <!-- bean註冊 -->
        <property name="address" ref="address"/>
        <!-- 數組註冊 -->
        <property name="array" >
            <array>
                <value>00</value>
                <value>11</value>
                <value>22</value>
            </array>
        </property>
        <!-- map註冊 -->
        <property name="books">
            <map>
                <entry key="a" value="語文"/>
                <entry key="b" value="數學"/>
                <entry key="c" value="英語"/>
            </map>
        </property>
        <!-- list註冊 -->
        <property name="hobby">
            <list>
                <value>音樂</value>
                <value>美術</value>
                <value>電影</value>
            </list>
        </property>
        <!-- set註冊 -->
        <property name="movie">
            <set>
                <value>中國電影</value>
                <value>美國電影</value>
                <value>印度電影</value>
            </set>
        </property>
        <!-- property註冊 -->
        <property name="properties">
            <props>
                <prop key="driver">com.mysql</prop>
                <prop key="user">root</prop>
                <prop key="password">123</prop>
            </props>
        </property>
        <!-- null註冊 -->
        <property name="wife">
            <null />
        </property>
    </bean>

</beans>

P命名空間註冊需要導入約束信息：xmlns:p="http://www.springframework.org/schema/p"

c命名空間註冊需要導入約束信息：xmlns:c="http://www.springframework.org/schema/c"

引入後的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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.hyq.pojo.Student"
          p:name="xiaoHu"/>
    <bean id="student1" class="com.hyq.pojo.Student"
          c:name="a"
          c:wife="0"/>

</beans>

測試類

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext1.xml");
        Student student =  context.getBean("student",Student.class);student--->student1
        System.out.println(student);
    }

總結：C命名空間是基於有參構造器，P命名空間是基於property

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="cat" class="com.hyq.pojo.Cat"/>
    <bean id="dog" class="com.hyq.pojo.Dog"/>

    <bean id="people" class="com.hyq.pojo.People">
        <property name="name" value="低調"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>
</beans>

dog類如下：

public class Dog {
    public void eat(){
        System.out.println("吃狗糧");
    }
}

cat類如下：

public class Cat {
    public void eat(){
        System.out.println("吃貓糧");
    }
}

people類如下：

package com.hyq.pojo;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

}

1.使用byName的配置文件如下：

<?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="cat" class="com.hyq.pojo.Cat"/>
    <bean id="dog" class="com.hyq.pojo.Dog"/>

    <bean id="people" class="com.hyq.pojo.People" autowire="byName">
        <property name="name" value="低調"/>
    </bean>
</beans>
在bean中有autowire的屬性，byName的原理是<bean id="dog" class="com.hyq.pojo.Dog"/>中的id必須唯一，且這個id必須和com.hyq.pojo.Dog類中setDog對應，不能寫成setDog1.需要一 一對應。

2.使用byType的配置文件如下：

<?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="cat" class="com.hyq.pojo.Cat"/>
    <bean id="dog" class="com.hyq.pojo.Dog"/>

    <bean id="people" class="com.hyq.pojo.People" autowire="byType">
        <property name="name" value="低調"/>
    </bean>
</beans>
原理：在<bean id="dog" class="com.hyq.pojo.Dog"/>中，class必須唯一，不能重覆，也就說該類只能用一次，和 id沒有關係，可以省略不寫。

3.註解實現自動裝配

使用註解必須：

1.導入約束，

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

此時people中的欄位cat和dog可以使用註解配置，就不用在xml中使用byName或者byType了。

    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
使用了註解配置，只需要在欄位的上方加上@autowired即可。
裡面的set方法也可以不寫。

4.補充：

欄位中如果有@Nullable，說明這個欄位可以為空

<context:component-scan base-package="com.hyq.pojo"/>
component:成分；scan：掃描
可以掃描指定包下的註解

使用註解開發

== 在spring4之後，要使用註解開發，必須要有aop的包 ==

1.component-scan,屬性註入

在xml中使用時，可以簡化配置，只需要在其他類名上標註@Component即可，如下：

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"
       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:component-scan base-package="com.hyq.pojo"/>
    <context:annotation-config/>

</beans>

User類如下：

package com.hyq.pojo;

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

//此處使用了註解配置,相當於 <bean id="user" class="com.hyq.pojo.User"/>
@Component
public class User {
    //此處使用了註解配置，可以簡化name的賦值,相當於<property name="name" value="張三"/>
    @Value("張三")
    private String name;

    public String getName() {
        return name;
    }
}

2.動態代理

想實現某個介面，你需要寫一個類，然後在類名字的後面給出“implements”XXX介面。這才是實現某個介面：

public interface MyInterface {
　　void fun1();
　　void fun2();
}

public class MyInterfaceImpl implements MyInterface {
　　public void fun1() {
　　　　System.out.println("fun1()");
　　}
　　public void fun2() {
　　　　System.out.println("fun2()");
　　}
}

動態代理技術可以通過一個方法調用就可以生成一個對指定介面的實現類對象。

Class[] cs = {MyInterface.class};
MyInterface mi = (MyInterface)Proxy.newProxyInstance(loader, cs, h);

上面代碼中，Proxy類的靜態方法newProxyInstance()方法生成了一個對象，這個對象實現了cs數組中指定的介面。沒錯，返回值mi是MyInterface介面的實現類。你不要問這個類是哪個類，你只需要知道mi是MyInterface介面的實現類就可以了。你現在也不用去管loader和h這兩個參數是什麼東東，你只需要知道，Proxy類的靜態方法newProxyInstance()方法返回的方法是==實現了指定介面的實現類對象==，甚至你都沒有看見實現類的代碼。　

動態代理就是在運行時生成一個類，這個類會實現你指定的一組介面，而這個類沒有.java文件，是在運行時生成的，你也不用去關心它是什麼類型的，你只需要知道它實現了哪些介面即可。

newProxyInstance()方法的參數
　　Proxy類的newInstance()方法有三個參數：
　　　　ClassLoader loader：它是類載入器類型，你不用去理睬它，你只需要知道怎麼可以獲得它就可以了：MyInterface.class.getClassLoader()就可以獲取到ClassLoader對象，沒錯，只要你有一個Class對象就可以獲取到ClassLoader對象；
　　　　Class[] interfaces：==指定newProxyInstance()方法返回的對象要實現哪些介面==，沒錯，可以指定多個介面，例如上面例子只我們只指定了一個介面：Class[] cs = {MyInterface.class};
　　　　InvocationHandler h：它是最重要的一個參數！它是一個介面！它的名字叫調用處理器！你想一想，上面例子中mi對象是MyInterface介面的實現類對象，那麼它一定是可以調用fun1()和fun2()方法了，難道你不想調用一下fun1()和fun2()方法麽，它會執行些什麼東東呢？其實無論你調用代理對象的什麼方法，它都是在調用InvocationHandler的invoke()方法！

InvocationHandler的invoke()方法 　　

InvocationHandler的invoke()方法的參數有三個：

Object proxy：代理對象，也就是Proxy.newProxyInstance()方法返回的對象，通常我們用不上它；　　　Method method：表示當前被調用方法的反射對象，例如mi.fun1()，那麼method就是fun1()方法的反射對象；Object[] args：表示當前被調用方法的參數，當然mi.fun1()這個調用是沒有參數的，所以args是一個零長數組。

Object o = method.invoke(obj, args);

method是方法對象

obj是該方法對象所在的類對象實例

args是方法參數

返回是Object類型，因為編譯時無法獲得方法輕易獲得所要調用方法的返回類型，因此使用了“萬能型” 　

最後要說的是invoke()方法的返回值為Object類型，它表示當前被調用的方法的返回值，當然mi.fun1()方法是沒有返回值的，所以invoke()返回的就必須是null了。

實例1：

public interface Waiter {
　　public void serve();
}

public class MyWaiter implements Waiter {
　　public void serve() {
　　　　System.out.println("服務...");
　　}
}

　　現在我們要對MyWaiter對象進行增強，要讓它在服務之前以及服務之後添加禮貌用語，即在服務之前說“您好！”，在服務之後說：“很高興為您服務！”。

public class MainApp1 {
　　public static void main(String[] args) {
　　　　ClassLoader loader = MainApp1.class.getClassLoader();
　　　　Class[] cs = {Waiter.class};
　　　　Waiter target = new MyWaiter();
　　　　MyInvocationHandler h = new MyInvocationHandler(target);
　　　　Waiter waiter = (Waiter)Proxy.newProxyInstance(loader, cs, h);
　　　　waiter.serve();
　　}
}
class MyInvocationHandler implements InvocationHandler {
　　public Waiter target;
　　public MyInvocationHandler(Waiter target) {
　　　　this.target = target;
　　}
　　public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
　　　　System.out.println("您好！");
　　　　Object result = method.invoke(target, args);
　　　　System.out.println("很高興為您服務！");
　　　　return result;
　　}
}

實例2

public interface Rent {
    public void rent();
}

public class Host implements Rent {
    public void rent() {
        System.out.println("房東出租房子");
    }
}

public class ProxyDeal implements InvocationHandler {
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("前");
        Object invoke = method.invoke(rent, args);
        System.out.println("後");
        return invoke;
    }
}

public void test(){
        Rent rent = new Host();
        ProxyDeal proxyDeal = new ProxyDeal();
        proxyDeal.setRent(rent);
        Object proxy = proxyDeal.getProxy();
        Rent rent1 = (Rent)proxy;
        rent1.rent();

    }

AOP面向切麵編程

AOP的相關術語及應用

Aspect：表示切麵。切入業務流程的一個獨立模塊。實際上是若幹個==類==
join point：表示連接點。是業務流程在運行過程中需要插入切麵的具體位置。
Advice：表示通知。是切麵的具體實現方法。==它是類中的一個方法== 可分為
- 前置通知（Before）
- 後置通知（AfterRunning）
- 異常通知（AfterThrowing）
- 最終通知（After）
- 環繞通知（Around）
  
  實現方法具體屬於哪類通知，是在配置文件和註解中指定的。
Pointcut ：表示切入點。定義通知應該切入到哪些連接點上，不同的通知通常需要切入到不同的連接點上
Target：表示目標對象。被一個或者多個切麵所通知的對象。
Proxy ：表示代理對象。將通知應用到目標對象之後被動態創建的對象。可以簡單地理解為，代理對象為目標對象的業務邏輯功能加上被切入的切麵所形成的對象。
Weaving ：表示切入，也稱為織入。將切麵應用到目標對象從而創建一個新的代理對象的過程。這個過程可以發生在編譯期、類裝載期及運行期。

原生方式實現

User介面和UserImpl類位於Dao包下

public interface User {
    public void add();
    public void delete();
    public void update();
    public void query();
}

public class UserImpl implements User {
    public void add() {
        System.out.println("增加了一個用戶");
    }

    public void delete() {
        System.out.println("刪除了一個用戶");
    }

    public void update() {
        System.out.println("修改了一個用戶");
    }

    public void query() {
        System.out.println("查詢了一個用戶");
    }
}

AfterLog和BeforeLog位於log包下

public class AfterLog implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("執行了"+method.getName()+"的方法");
    }
}

public class BeforeLog implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("執行了"+method.getName()+"的方法，");
    }
}

註冊類

<?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="userImpl" class="com.hyq.dao.UserImpl"/>
    <bean id="afterLog" class="com.hyq.log.AfterLog"/>
    <bean id="beforeLog" class="com.hyq.log.BeforeLog"/>

<!--    切入點   -->
    <aop:config>
        execution(切入的指定位置)
        <aop:pointcut id="pointcut" expression="execution(* com.hyq.dao.UserImpl.*(..))"/>
        
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>

    </aop:config>
</beans>

pointcut：切入點，要插入到指定的位置。

execution語法：

其中訪問修飾符可以省略

advice：通知

引用advice-ref：的類切入到pointcut-ref：這個切入點。

測試類：

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        User user = (User)context.getBean("userImpl");
        user.add();
    }
}

輸出結果：

執行了add的方法，
增加了一個用戶
執行了add的方法

自定義類來實現AOP

diyPointCut類：

public class DiyPointCut {
    public void before(){
        System.out.println("執行前");
    }
    public void after(){
        System.out.println("執行後");
    }
}

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: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="userImpl" class="com.hyq.dao.UserImpl"/>
    <bean id="afterLog" class="com.hyq.log.AfterLog"/>
    <bean id="beforeLog" class="com.hyq.log.BeforeLog"/>

<!--    方式二：自定義類實現-->
<!--    註冊Bean-->
    <bean id="diyPointCut" class="com.hyq.diy.DiyPointCut"/>

    <aop:config>
<!--        切麵-->
        <aop:aspect ref="diyPointCut">
<!--            切入點-->
            <aop:pointcut id="pointcut" expression="execution(* com.hyq.dao.UserImpl.*(..))"/>
<!--            通知          -->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>

        </aop:aspect>
    </aop:config>
</beans>

ref：指向指定類

註解實現AOP

Annotation類

@Aspect//這是一個切麵
public class Annotation {
    //切入點
    @Before("execution(* com.hyq.dao.UserImpl.*(..))")
    public void before(){
        System.out.println("----前----");
    }
}

<?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="userImpl" class="com.hyq.dao.UserImpl"/>
    <bean id="afterLog" class="com.hyq.log.AfterLog"/>
    <bean id="beforeLog" class="com.hyq.log.BeforeLog"/>

<!--    方式三-->
    <bean id="annotation" class="com.hyq.annotationAop.Annotation"/>

<!--    開啟註解-->
    <aop:aspectj-autoproxy/>
</beans>

==註意：==使用註解需要開啟註解。

<!--    開啟註解-->
    <aop:aspectj-autoproxy/>