SpringAOP-01-概述

public interface MethodBeforeAdvice extends BeforeAdvice {
   void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}

public interface AfterReturningAdvice extends AfterAdvice {
   void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}

public interface Pointcut {
   ClassFilter getClassFilter();
   MethodMatcher getMethodMatcher();
   Pointcut TRUE = TruePointcut.INSTANCE;
}

@Override
protected boolean matches(String pattern, int patternIndex) {
   Matcher matcher = this.compiledPatterns[patternIndex].matcher(pattern);
   return matcher.matches();
}

public boolean matches(Method method, Class<?> targetClass) {
   for (String mappedName : this.mappedNames) {
      if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) {
         return true;
      }
   }
   return false;
}

public class DefaultPointcutAdvisor extends AbstractGenericPointcutAdvisor implements Serializable {
   private Pointcut pointcut = Pointcut.TRUE;
   public DefaultPointcutAdvisor() {
   }
   public DefaultPointcutAdvisor(Advice advice) {
      this(Pointcut.TRUE, advice);
   }
   public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) {
      this.pointcut = pointcut;
      setAdvice(advice);
   }
   public void setPointcut(@Nullable Pointcut pointcut) {
      this.pointcut = (pointcut != null ? pointcut : Pointcut.TRUE);
   }
   @Override
   public Pointcut getPointcut() {
      return this.pointcut;
   }
   @Override
   public String toString() {
      return getClass().getName() + ": pointcut [" + getPointcut() + "]; advice [" + getAdvice() + "]";
   }
}

final class TruePointcut implements Pointcut, Serializable {
   public static final TruePointcut INSTANCE = new TruePointcut();
   private TruePointcut() {
   }
 
   @Override
   public ClassFilter getClassFilter() {
      return ClassFilter.TRUE;
   }
 
   @Override
   public MethodMatcher getMethodMatcher() {
      return MethodMatcher.TRUE;
   }
   private Object readResolve() {
      return INSTANCE;
   }
 
   @Override
   public String toString() {
      return "Pointcut.TRUE";
   }
 
}
final class TrueMethodMatcher implements MethodMatcher, Serializable {
 
   public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();
   private TrueMethodMatcher() {
   }
   @Override
   public boolean isRuntime() {
      return false;
   }
   @Override
   public boolean matches(Method method, Class<?> targetClass) {
      return true;
   }
   @Override
   public boolean matches(Method method, Class<?> targetClass, Object... args) {
      // Should never be invoked as isRuntime returns false.
      throw new UnsupportedOperationException();
   }
   @Override
   public String toString() {
      return "MethodMatcher.TRUE";
   }
   private Object readResolve() {
      return INSTANCE;
   }
 
}

public class MyInvocationHandler implements InvocationHandler {
 
    private Object origin;
 
    public MyInvocationHandler(Object origin) {
        this.origin = origin;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke start");
        Object result = method.invoke(origin, args);
        System.out.println("invoke end");
        return result;
    }
}
 
 
public class JdkProxyTest {
    public static void main(String[] args) {
        UserService proxy = (UserService) Proxy.newProxyInstance(JdkProxyTest.class.getClassLoader(),
                new Class[]{UserService.class}, new MyInvocationHandler(new UserServiceImpl()));
        proxy.doSomething();
    }
}

public class CglibInterceptor implements MethodInterceptor {
 
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("intercept start");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("intercept end");
        return result;
    }
}
 
public class CglibProxyTest {
 
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(CglibObject.class);
        enhancer.setCallback(new CglibInterceptor());
        CglibObject proxy = (CglibObject) enhancer.create();
        proxy.doSomething();
    }
}

public interface Person {
	void say();
}
public class Student implements Person{
 
	public void say(){
		System.out.println("这是一个苦逼的程序员");
	}
}

@Aspect
public class AspectJTest {
 
    //切点表达式
	@Pointcut("execution(* com.test.spring..say*(..))")
	public void test(){}
	
    //前置通知
	@Before("test()")
	public void before(){
		System.out.println("before test..");
	}
	
    //后置通知
	@After("test()")
	public void after(){
		System.out.println("after test..");
	}
	
    //环绕通知
	@Around("test()")
	public Object around(ProceedingJoinPoint p){
		System.out.println("before1");
		Object o = null;
		try {
			o = p.proceed();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("after1");
		return o;
	}
}

@Component
@EnableAspectJAutoProxy
public class EnabledAOP {
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringApplicationContextInitializer.class)
public class SpringTest {

    @Autowired
    private Person person;

    @Test
    public void test(){
        person.say();
    }
}