基于AspectJ实现AOP

package com.sw.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
    String value() default "";
}

package com.sw.spring.dao;

import com.sw.spring.annotation.Log;


public interface IUserDao {
    @Log("添加了用户")  //因为代理对象访问的是接口，注解要加在接口上而不是实现类
    public  void add();
     void update();
      void del();
      void list();

}

package com.sw.spring.dao;

import org.springframework.stereotype.Repository;

import com.sw.spring.annotation.Log;
import com.sw.spring.log.Logger;


@Repository("userDao")
public class UserDao implements IUserDao{

    public void add() {
        System.out.println("使用普通方式进行保存用户");

    }

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

    public void del() {
        System.out.println("删除用户");
    }

    public void list() {
        System.out.println("显示用户列表");
    }


}

package com.sw.spring.log;

import java.util.Date;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Logger {
    public static void log(String info){
        System.out.println(new Date()+"---"+info);
    }

}

package com.sw.spring.proxy;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import com.sw.spring.log.Logger;

@Component
@Aspect
public class LoggerProxy{
    /**
     * 前置通知
     * 第一个*代表 方法的修饰符 和返回值类型
     * 第二个*service包下的任意类
     * 第三个*service包下的任意类的方法
     * (..)方法的参数
     */
    /*@Before("execution(* com.sw.spring.service.*.*(..))")
    public void beforeMethod(){
        Logger.log("---在调用方法前执行");
    }*/

    /*
     * 如果只想一个方法或者两个方法加日志  可以直接写方法的名字
     */
    /*@Before("execution(* com.sw.spring.service.*.save(..)) ||"
            + "execution(* com.sw.spring.service.*.del(..))")
    public void beforeMethod(){
        Logger.log("---在调用方法前执行");
    }*/

    /**
     * 后置通知
     */
    /*@After("execution(* com.sw.spring.service.*.*(..))")
    public void afterMethod(){

        Logger.log("在方法调用后执行-----");
    }*/

    /**
     * 环绕通知   需要一个参数
     * @throws Throwable 
     */
    /*@Around("execution(* com.sw.spring.service.*.*(..))")
    public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable{

        Logger.log("环绕执行前");
        pjp.proceed();
        Logger.log("环绕执行后");

    }*/

    /**
     * 后置通知  测试异常
     */
    @After("execution(* com.sw.spring.service.*.*(..))")
    public void afterMethod(JoinPoint jp){
        //获取执行的方法名   需要导aopalliance-1.0.jar包
      System.out.println("正在执行的方法是"+jp.getSignature().getName());
        Logger.log("在方法调用后执行-----");
    }


    /**
     * 方法正常运行通过之后才会调用
     */
    /*@AfterReturning("execution(* com.sw.spring.service.*.*(..))")
    public void afterReturningMethod(){
        Logger.log("方法正常执行后调用");
    }*/

    /**
     * 方法运行异常才会调用
     */
    /*@AfterThrowing("execution(* com.sw.spring.service.*.*(..))")
    public void afterThrowingMethod(){
        Logger.log("方法运行异常才能看到我");
    }*/

}

package com.sw.spring.service;

public interface IUserService {
        void save();
         void update();
         void del();
         void list();
}

package com.sw.spring.service;

import javax.annotation.Resource;

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

import com.sw.spring.dao.IUserDao;



@Service
public class UserService implements IUserService{
    //默认根据类型装配  但有两个实现类会报错，所以要指定bean的类型  通过@Qualifier

    //@Qualifier("userProxyDao")
    /*@Autowired()
    @Qualifier("loggerProxy")
    private IUserDao userDao;
    public void save(){
        userDao.add();
    }
    */


    /**
     * 第二种方法  需要加@resource 
     */
    private IUserDao userDao;

    //@Resource(name="userjdbcDao")
    //@Resource(name="userProxyDao")
    @Resource(name="userDao")
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    public void save() {
        userDao.add();
    }

    public void update() {
        userDao.update();
    }

    public void del() {
        userDao.del();
    }

    public void list() {
        userDao.list();
    }

}

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
     <!-- 扫描加入注解的包 --> 
    <context:component-scan base-package="com.sw.spring"></context:component-scan>
    <!-- 开启spring aop支持 -->
    <aop:aspectj-autoproxy />


</beans>

package com.sw.spring;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.sw.spring.service.IBookService;
import com.sw.spring.service.IUserService;

public class SpringTest {
    static ApplicationContext ac=null;
    static{
        ac=new ClassPathXmlApplicationContext("spring.xml");
    }
    @Test
    public void test(){
            IUserService us = ac.getBean("userService", IUserService.class);
            us.save();
            us.update();
            us.del();
            us.list();
    }


}