package com.ys.aop.one;
public class User {
    private int uid;
    private String uname;
    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
}

package com.ys.aop.one;
public interface UserService {
    //添加 user
    public void addUser(User user);
    //刪除 user
    public void deleteUser(int uid);
}

package com.ys.aop.one;
public class UserServiceImpl implements UserService{
    @Override
    public void addUser(User user) {
        System.out.println("增加 User");
    }
    @Override
    public void deleteUser(int uid) {
        System.out.println("刪除 User");
    }
}

package com.ys.aop.one;
public class MyTransaction {
    //開啟事務(wù)
    public void before(){
        System.out.println("開啟事務(wù)");
    }
    //提交事務(wù)
    public void after(){
        System.out.println("提交事務(wù)");
    }
}

package com.ys.aop.one;
public class ProxyUser implements UserService{
    //真實(shí)類
    private UserService userService;
    //事務(wù)類
    private MyTransaction transaction;
    //使用構(gòu)造函數(shù)實(shí)例化
    public ProxyUser(UserService userService,MyTransaction transaction){
        this.userService = userService;
        this.transaction = transaction;
    }
    @Override
    public void addUser(User user) {
        transaction.before();
        userService.addUser(user);
        transaction.after();
    }
    @Override
    public void deleteUser(int uid) {
        transaction.before();
        userService.deleteUser(uid);
        transaction.after();       
    }
}

@Test
    public void testOne(){
        MyTransaction transaction = new MyTransaction();
        UserService userService = new UserServiceImpl();
        //產(chǎn)生靜態(tài)代理對(duì)象
        ProxyUser proxy = new ProxyUser(userService, transaction);
        proxy.addUser(null);
        proxy.deleteUser(0);
    }

package com.ys.aop.two;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.ys.aop.one.MyTransaction;
public class ObjectInterceptor implements InvocationHandler{
    //目標(biāo)類
    private Object target;
    //切面類（這里指事務(wù)類）
    private MyTransaction transaction;
    //通過構(gòu)造器賦值
    public ObjectInterceptor(Object target,MyTransaction transaction){
        this.target = target;
        this.transaction = transaction;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //開啟事務(wù)
        this.transaction.before();
        //調(diào)用目標(biāo)類方法
        method.invoke(this.target, args);
        //提交事務(wù)
        this.transaction.after();
        return null;
    }
}

@Test
    public void testOne(){
        //目標(biāo)類
        Object target = new UserServiceImpl();
        //事務(wù)類
        MyTransaction transaction = new MyTransaction();
        ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);
        /**
         * 三個(gè)參數(shù)的含義：
         * 1、目標(biāo)類的類加載器
         * 2、目標(biāo)類所有實(shí)現(xiàn)的接口
         * 3、攔截器
         */
        UserService userService = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), proxyObject);
        userService.addUser(null);
    }

<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">
    <!--1、 創(chuàng)建目標(biāo)類 -->
    <bean id="userService" class="com.ys.aop.UserServiceImpl"></bean>  
    <!--2、創(chuàng)建切面類（通知）  -->
    <bean id="transaction" class="com.ys.aop.one.MyTransaction"></bean>
    <!--3、aop編程 
        3.1 導(dǎo)入命名空間
        3.2 使用 <aop:config>進(jìn)行配置
                proxy-target-class="true" 聲明時(shí)使用cglib代理
                如果不聲明，Spring 會(huì)自動(dòng)選擇cglib代理還是JDK動(dòng)態(tài)代理
            <aop:pointcut> 切入點(diǎn) ，從目標(biāo)對(duì)象獲得具體方法
            <aop:advisor> 特殊的切面，只有一個(gè)通知 和 一個(gè)切入點(diǎn)
                advice-ref 通知引用
                pointcut-ref 切入點(diǎn)引用
        3.3 切入點(diǎn)表達(dá)式
            execution(* com.ys.aop.*.*(..))
            選擇方法         返回值任意   包             類名任意   方法名任意   參數(shù)任意
    -->
    <aop:config>
        <!-- 切入點(diǎn)表達(dá)式 -->
        <aop:pointcut expression="execution(* com.ys.aop.*.*(..))" id="myPointCut"/>
        <aop:aspect ref="transaction">
            <!-- 配置前置通知，注意 method 的值要和 對(duì)應(yīng)切面的類方法名稱相同 -->
            <aop:before method="before" pointcut-ref="myPointCut"></aop:before>
            <aop:after-returning method="after" pointcut-ref="myPointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

@Test
    public void testAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser(null);
    }

execution（modifiers-pattern? ref-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?）
　　　　　　　　　　   類修飾符           返回值           方法所在的包                  方法名                     方法拋出的異常

execution(* com.ys.aop.*.*(..))
選擇方法         返回值任意   包             類名任意   方法名任意   參數(shù)任意