package com.lxl.www.aop.interfaceAop;

/**
 * 使用接口方式实现AOP,默认通过JDK的动态代理来实现. 非接口方式,使用的是cglib实现动态代理
 *
 * 业务接口类-- 计算器接口类
 *
 * 定义三个业务逻辑方法
 */
public interface IBaseCalculate {

    int add(int numA,int numB);

    int sub(int div(int multi(int mod( numB);

}

package com.lxl.www.aop.interfaceAop;//业务类，也是目标对象

import com.lxl.www.aop.Calculate;

import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Service;

*
 * 业务实现类 -- 基础计算器
 */
@Service
class BaseCalculate implements IBaseCalculate {

    @Override
     numB) {
        System.out.println("执行目标方法: add");
        return numA + numB;
    }

    @Override
    执行目标方法: subreturn numA -执行目标方法: multireturn numA *执行目标方法: divreturn numA /执行目标方法: mod);

        int retVal = ((Calculate) AopContext.currentProxy()).add(numA,numB);
        return retVal % numA;
    }
}

package com.lxl.www.aop.interfaceAop;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

*
 * 定义前置通知
 
@Component
 BaseBeforeAdvice implements MethodBeforeAdvice {

    *
     *
     * @param method 切入的方法
     * @param args 切入方法的参数
     * @param target 目标对象
     * @throws Throwable
     
    @Override
    void before(Method method,Object[] args,Object target) throws Throwable {
        System.===========进入beforeAdvice()============);

        System.目标对象:" + target);
        System.方法名: "+method);

        System.即将进入切入点方法);
    }

}

package com.lxl.www.aop.interfaceAop;

import org.aspectj.lang.annotation.AfterReturning;
import org.springframework.aop.Afteradvice;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

 BaseAfterReturnAdvice implements AfterReturningAdvice {

    *
     *
     * @param returnValue 切入点执行完方法的返回值，但不能修改
     * @param method 切入点方法
     * @param args 切入点方法的参数数组
     * @param target 目标对象
     * @throws Throwable
      afterReturning(Object returnValue,Method method,1)">==========进入afterReturning()=========== \n);
        System.切入点方法执行完成后置通知--目标对象:后置通知--方法名: method);
        System.后置通知--方法入参:  args.toString());
        System.后置通知--方法返回值:  returnValue);
    }

}

package com.lxl.www.aop.interfaceAop;

import org.springframework.aop.ThrowsAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
@Component
 BaseAfterThrowsAdvice implements ThrowsAdvice {

    *
     * @param method    可选：切入的方法
     * @param args      可选：切入的方法的参数
     * @param target    可选：目标对象
     * @param throwable 必填 : 异常子类，出现这个异常类的子类，则会进入这个通知。
     */
     afterThrowing(Method method,Object target,Throwable throwable) {
        System.出错啦);
    }
}

package com.lxl.www.aop.interfaceAop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

*
 * 环绕通知
  BaseAroundAdvice implements MethodInterceptor {

    *
     * invocation ：连接点
     public Object invoke(MethodInvocation invocation) throws Throwable {
        System.===========around环绕通知方法 开始=========== 调用目标方法之前执行的动作
        System.环绕通知--调用方法之前: 执行 调用方法的参数
        Object[] args = invocation.getArguments();
         调用的方法
        Method method = invocation.getmethod();
         获取目标对象
        Object target = invocation.getThis();
        System.输入参数:" + args[0] + ;" + method +  target);

         执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object returnValue = invocation.proceed();

        System.环绕通知--调用方法之后: 执行);
      
        System.输出参数：" + target +  returnValue);

        System.===========around环绕通知方法  结束===========return returnValue;
    }

}

*
 * 切点
 *
 * 继承NameMatchMethodpointcut类，来用方法名匹配
 
import org.springframework.aop.support.NameMatchMethodpointcut;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
 pointcut extends NameMatchMethodpointcut {

    private static final long serialVersionUID = 3990456017285944475L;

    @SuppressWarnings(rawtypes)
    @Override
     boolean matches(Method method,Class targetClass) {
         设置单个方法匹配
        this.setMappedname(add 设置多个方法匹配
        String[] methods = { ",div };
      
        也可以用“ * ” 来做匹配符号
         this.setMappedname("get*");
      
        this.setMappednames(methods);

         super.matches(method,targetClass);
    }

}

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

    <!-- ==============================aop配置================================ -->
    <!-- 声明一个业务类 -->
    <bean id=baseCalculate" class=com.lxl.www.aop.interfaceAop.BaseCalculate"/>

    <!-- 声明通知类 -->
    <bean id=baseBeforecom.lxl.www.aop.interfaceAop.BaseBeforeAdvice"/>
    <bean id=baseAfterReturncom.lxl.www.aop.interfaceAop.BaseAfterReturnAdvicebaseAfterThrowscom.lxl.www.aop.interfaceAop.BaseAfterThrowsAdvicebaseAroundcom.lxl.www.aop.interfaceAop.BaseAroundAdvice"/>

    <!-- 指定切点匹配类 -->
    <bean id=pointcutcom.lxl.www.aop.interfaceAop.pointcut"/>

    <!-- 包装通知，指定切点 -->
    <bean id=matchBeforeAdvisororg.springframework.aop.support.DefaultpointcutAdvisor">
        <property name=">
            <ref bean="/>
        </property>
        <property name=advice"/>
        </property>
    </bean>

    <!-- 使用Proxyfactorybean 产生代理对象 -->
    <bean id=businessProxyorg.springframework.aop.framework.Proxyfactorybean">
        <!-- 代理对象所实现的接口 ，如果有接口可以这样设置 -->
        <property name=proxyInterfaces">
            <value>com.lxl.www.aop.interfaceAop.IBaseCalculate</value>
        </property>

        <!-- 设置目标对象 -->
        <property name=target"/>
        </property>
        <!-- 代理对象所使用的拦截器 -->
        <property name=interceptorNames">
            <list>
                <value>matchBeforeAdvisor</value>
                <value>baseAfterReturn</value>
                <value>baseAround</value>
            </list>
        </property>
    </bean>
</beans>

package com.lxl.www.aop.interfaceAop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClasspathXmlApplicationContext;

 InterfaceMainClass{

    static  main(String[] args) {
        ApplicationContext context = new ClasspathXmlApplicationContext(aop/aop.xml);
        BaseCalculate calculate = (BaseCalculate) context.getBean();
        calculate.add(1,1)">3);
    }

}

您可能感兴趣的文章:

• intellij idea tomcat热部署配置教程
• IntelliJ IDEA使用maven实现tomcat的热部署
• SpringBoot项目在IntelliJ IDEA中如何实现热部署
• IntelliJ IDEA配置Tomcat（完整版图文教程）
• IntelliJ IDEA Tomcat配置详解(图文)
• 使用IntelliJ IDEA搭建SSM框架的图文教程
• Intellij idea远程debug连接tomcat实现单步调试
• IntelliJ IDEA 最常用的配置图文详解

//数组实现String反转
  public String reverseByArray(){
    if(str == null || str.length() == 1){
      return null;
    }
    char[] ch = str.toCharArray();//字符串转换成字符数组
    for(int i = 0 ; i < ch.length/2 ; i++){
      char temp = ch[i];
      ch[i] = ch[ch.length-i-1];
      ch[ch.length-i-1] = temp;
    }
    return new String(ch);
  }

//用栈实现String反转
  public String reverseByStack(){
    if(str == null || str.length() == 1){
      return null;
    }
    Stack<Character> stack = new Stack<Character>();
    char[] ch = str.toCharArray();//字符串转换成字符数组
    for (char c : ch) {
      stack.push(c);//每个字符，推进栈
    }
    for (int i = 0; i < ch.length; i++) {
      ch[i] = stack.pop();//移除这个堆栈的顶部对象
    }
    return new String(ch);
  }

//用逆序遍历实现String反转
 
  public String reverseBySort(){
    if(str == null || str.length() == 1){
      return null;
    }
    StringBuffer sb = new StringBuffer();
    for (int i = str.length() -1 ; i >= 0; i--) {
      sb.append(str.charAt(i));//使用StringBuffer从右往左拼接字符
    }
    return sb.toString();
  }

//使用位运算实现String反转
  public String reverseByBit() {
    if(str == null || str.length() == 1){
      return null;
    }
    char[] ch = str.toCharArray();//字符串转换成字符数组
    int len = str.length();
    for(int i= 0; i< len/ 2; i++) {
      ch[i]^= ch[len- 1- i];
      ch[len- 1- i]^= ch[i];
      ch[i]^= ch[len- 1- i];
    }
    return new String(ch);
  }

//使用递归实现String反转
  public String reverseByRecursive(String str){
    if(str == null || str.length() == 0){
      return null;
    }
    if(str.length() == 1){
      return str;
    } else {
      //从下标为1开始截取字符串，在返回下标为0的字符
      return reverseByRecursive(str.substring(1)) + str.charAt(0);
    }
  }

public class Test {
  public static void main(String[] args) {
    String s = "123456";
    Reverse r = new Reverse(s);
    System.out.println(r.reverseByArray());
    System.out.println(r.reverseByStack());
    System.out.println(r.reverseBySort());
    System.out.println(r.reverseByBit());
    System.out.println(r.reverseByRecursive(s));
     
  }
}

public class Reverse {
  private String str = null;
   
  public Reverse(String str){
    this.str = str;
  }
   
  //数组实现String反转
  public String reverseByArray(){
    if(str == null || str.length() == 1){
      return null;
    }
    char[] ch = str.toCharArray();//字符串转换成字符数组
    for(int i = 0 ; i < ch.length/2 ; i++){
      char temp = ch[i];
      ch[i] = ch[ch.length-i-1];
      ch[ch.length-i-1] = temp;
    }
    return new String(ch);
  }
  //用栈实现String反转
  public String reverseByStack(){
    if(str == null || str.length() == 1){
      return null;
    }
    Stack<Character> stack = new Stack<Character>();
    char[] ch = str.toCharArray();//字符串转换成字符数组
    for (char c : ch) {
      stack.push(c);//每个字符，推进栈
    }
    for (int i = 0; i < ch.length; i++) {
      ch[i] = stack.pop();//移除这个堆栈的顶部对象
    }
    return new String(ch);
  }
  //用逆序遍历实现String反转
  public String reverseBySort(){
    if(str == null || str.length() == 1){
      return null;
    }
    StringBuffer sb = new StringBuffer();
    for (int i = str.length() -1 ; i >= 0; i--) {
      sb.append(str.charAt(i));//使用StringBuffer从右往左拼接字符
    }
    return sb.toString();
  }
  //使用位运算实现String反转
  public String reverseByBit() { 
    if(str == null || str.length() == 1){
      return null;
    }
    char[] ch = str.toCharArray();//字符串转换成字符数组
    int len = str.length(); 
    for(int i= 0; i< len/ 2; i++) { 
      ch[i]^= ch[len- 1- i]; 
      ch[len- 1- i]^= ch[i]; 
      ch[i]^= ch[len- 1- i]; 
    }
    return new String(ch);
  }
  //使用递归实现String反转
  public String reverseByRecursive(String str){
    if(str == null || str.length() == 0){
      return null;
    }
    if(str.length() == 1){
      return str;
    } else {
      //从下标为1开始截取字符串，在返回下标为0的字符
      return reverseByRecursive(str.substring(1)) + str.charAt(0);
    }
  }
}