public interface IPerson {public void doSomething();
}复制代码
public class Person implements IPerson {public void doSomething(){System.out.println("I want wo sell this house");}
}复制代码
public class PersonProxy {private IPerson iPerson;private final static Logger logger = LoggerFactory.getLogger(PersonProxy.class);public PersonProxy(IPerson iPerson) {<span class="hljs-keyword">this</span>.iPerson = iPerson;
}
public <span class="hljs-keyword">void</span> doSomething() {logger.info(<span class="hljs-string">"Before Proxy"</span>);iPerson.doSomething();logger.info(<span class="hljs-string">"After Proxy"</span>);
}public <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> main(<span class="hljs-built_in">String</span>[] args) {PersonProxy personProxy = <span class="hljs-keyword">new</span> PersonProxy(<span class="hljs-keyword">new</span> Person());personProxy.doSomething();
}
}复制代码

public class PersonProxy implements InvocationHandler{private Object delegate;private final Logger logger = LoggerFactory.getLogger(this.getClass();public <span class="hljs-built_in">Object</span> bind(<span class="hljs-built_in">Object</span> delegate) {<span class="hljs-keyword">this</span>.delegate = delegate;<span class="hljs-keyword">return</span> <span class="hljs-built_in">Proxy</span>.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), <span class="hljs-keyword">this</span>);
}
public <span class="hljs-built_in">Object</span> invoke(<span class="hljs-built_in">Object</span> proxy, Method method, <span class="hljs-built_in">Object</span>[] args) throws Throwable {<span class="hljs-built_in">Object</span> result = <span class="hljs-literal">null</span>;<span class="hljs-keyword">try</span> {logger.info(<span class="hljs-string">"Before Proxy"</span>);result = method.invoke(delegate, args);logger.info(<span class="hljs-string">"After Proxy"</span>);} <span class="hljs-keyword">catch</span> (Exception e) {<span class="hljs-keyword">throw</span> e;}<span class="hljs-keyword">return</span> result;
}public <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> main(<span class="hljs-built_in">String</span>[] args) {PersonProxy personProxy = <span class="hljs-keyword">new</span> PersonProxy();IPerson iperson = (IPerson) personProxy.bind(<span class="hljs-keyword">new</span> Person());iperson.doSomething();
}
}复制代码

public class PersonProxy implements MethodInterceptor {private Object delegate;private final Logger logger = LoggerFactory.getLogger(this.getClass());public <span class="hljs-built_in">Object</span> intercept(<span class="hljs-built_in">Object</span> proxy, Method method, <span class="hljs-built_in">Object</span>[] args,  MethodProxy methodProxy) throws Throwable {logger.info(<span class="hljs-string">"Before Proxy"</span>);<span class="hljs-built_in">Object</span> result = methodProxy.invokeSuper(proxy, args);logger.info(<span class="hljs-string">"After Proxy"</span>);<span class="hljs-keyword">return</span> result;
}public <span class="hljs-keyword">static</span> Person getProxyInstance() {Enhancer enhancer = <span class="hljs-keyword">new</span> Enhancer();enhancer.setSuperclass(Person.class);enhancer.setCallback(<span class="hljs-keyword">new</span> PersonProxy());<span class="hljs-keyword">return</span> (Person) enhancer.create();
}
}复制代码

public class Person {public int tradePrice () {return 1000;}
}复制代码

public class LogsInterceptor implements MethodInterceptor {Logger logger = LoggerFactory.getLogger(this.getClass().getName());public Object invoke(MethodInvocation invocation) throws Throwable {try {logger.info("Start bargaining....");Object returnValue = invocation.proceed();} catch (Exception e) {throw e;} finally {logger.info("Bargaining Over");}return null;}
}复制代码

<bean id="pointCut" class="org.springframework.aop.support.NameMatchMethodPointcut"><property name="mappedName" value="tradePrice"/>
</bean>
<bean id="myInterceptor" class="com.sankuai.meituan.meishi.poi.tag.LogsInterceptor"></bean>
<bean id="myAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"><property name="pointcut" ref="pointCut"/><property name="advice" ref="myInterceptor"/>
</bean>
<bean id="myProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="interceptorNames"><list><value>myAdvisor</value></list></property>
</bean>复制代码

<bean id="pointCut1" class="org.springframework.aop.support.NameMatchMethodPointcut"><property name="mappedName" value="tradePrice"/>
</bean>
<bean id="pointCut2" class="org.springframework.aop.support.NameMatchMethodPointcut"><property name="mappedName" value="tradePrice"/>
</bean>
<bean id="myInterceptor" class="com.sankuai.meituan.meishi.poi.tag.LogsInterceptor"></bean><bean id="myProxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"><property name="beanNames"><list><value>pointCut1</value><value>pointCut2</value></list></property><property name="interceptorNames"><list><value>myInterceptor</value></list></property>
</bean>复制代码

public class MyAspect {private final Logger logger = LoggerFactory.getLogger(this.getClass());@Pointcut(<span class="hljs-string">"execution(public void *.method1)"</span>)
public <span class="hljs-keyword">void</span> pointcutName(){}@Around(<span class="hljs-string">"pointcutName()"</span>)
public <span class="hljs-built_in">Object</span> performanceTrace(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {<span class="hljs-keyword">try</span> {logger.info(<span class="hljs-string">"log....."</span>);<span class="hljs-keyword">return</span> proceedingJoinPoint.proceed();} <span class="hljs-keyword">finally</span> {logger.info(<span class="hljs-string">"log end"</span>);}
}
}复制代码

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>复制代码

public abstract class StaticMethodMatcher implements MethodMatcher {@Overridepublic final boolean isRuntime() {return false;}@Overridepublic final boolean matches(Method method, Class<?> targetClass, Object[] args) {// should never be invoked because isRuntime() returns falsethrow new UnsupportedOperationException("Illegal MethodMatcher usage");}
}复制代码
public abstract class DynamicMethodMatcher implements MethodMatcher {@Overridepublic final boolean isRuntime() {return true;}/*** Can override to add preconditions for dynamic matching. This implementation* always returns true.*/@Overridepublic boolean matches(Method method, Class<?> targetClass) {return true;}}复制代码

private boolean proxyTargetClass = false;private boolean optimize = false;boolean opaque = false;boolean exposeProxy = false;private boolean frozen = false;复制代码

/*** Set whether to proxy the target class directly, instead of just proxying* specific interfaces. Default is "false".* <p>Set this to "true" to force proxying for the TargetSource's exposed* target class. If that target class is an interface, a JDK proxy will be* created for the given interface. If that target class is any other class,* a CGLIB proxy will be created for the given class.* <p>Note: Depending on the configuration of the concrete proxy factory,* the proxy-target-class behavior will also be applied if no interfaces* have been specified (and no interface autodetection is activated).* @see org.springframework.aop.TargetSource#getTargetClass()*/复制代码

/*** Set whether proxies should perform aggressive optimizations.* The exact meaning of "aggressive optimizations" will differ* between proxies, but there is usually some tradeoff.* Default is "false".* <p>For example, optimization will usually mean that advice changes won't* take effect after a proxy has been created. For this reason, optimization* is disabled by default. An optimize value of "true" may be ignored* if other settings preclude optimization: for example, if "exposeProxy"* is set to "true" and that's not compatible with the optimization.*/复制代码

/*** Set whether proxies created by this configuration should be prevented* from being cast to {@link Advised} to query proxy status.* <p>Default is "false", meaning that any AOP proxy can be cast to* {@link Advised}.*/复制代码

/*** Set whether the proxy should be exposed by the AOP framework as a* ThreadLocal for retrieval via the AopContext class. This is useful* if an advised object needs to call another advised method on itself.* (If it uses {@code this}, the invocation will not be advised).* <p>Default is "false", in order to avoid unnecessary extra interception.* This means that no guarantees are provided that AopContext access will* work consistently within any method of the advised object.*/复制代码

/*** Set whether this config should be frozen.* <p>When a config is frozen, no advice changes can be made. This is* useful for optimization, and useful when we don't want callers to* be able to manipulate configuration after casting to Advised.*/复制代码