package proxy.imp;
public interface AnimalInterface {
  //设置名字
  void setName(String name);
  //获取名字
  String getName();
  //叫声
  void say();
  //获取栖性
  void getProperty();
}

package proxy;

import proxy.imp.AnimalInterface;
public class DogImp implements AnimalInterface {
  private String name = "小黑";
  public DogImp() {
  }
  @Override
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String getName() {
    return this.name;
  }
  @Override
  public void say() {
    System.out.println("小狗:汪汪汪汪.....");
  }
  @Override
  public void getProperty() {
    System.out.println("小狗是陆地动物,但是会游泳哦");
  }
}

package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class AOPHandle implements InvocationHandler{
  //保存对象
  private Object o;
  public AOPHandle(Object o) {
    this.o=o;
  }
  /**
   * 这个方法会自动调用,Java动态代理机制
   * 会传入下面是个参数
   * @param Object proxy 代理对象的接口,不同于对象
   * @param Method method 被调用方法
   * @param Object[] args 方法参数
   * 不能使用invoke时使用proxy作为反射参数时,因为代理对象的接口,不同于对象
   * 这种代理机制是面向接口，而不是面向类的
   **/
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //方法返回值
    Object ret=null;
    //打印方法名称
    System.err.println("执行方法:"+method.getName()+"n参数类型为:");
    //打印参数
    for(Class type:method.getParameterTypes())
      System.err.println(type.getName());
    //打印返回类型
    System.err.println("返回数据类型:"+method.getReturnType().getName());
    //反射调用方法
    ret=method.invoke(o, args);
    //声明结束
    System.err.println("方法执行结束");
    //返回反射调用方法的返回值
    return ret;
  }
}

package proxy;
import java.lang.reflect.Proxy;
public class AnimalFactory {
  /***
   * 获取对象方法
   * @param obj
   * @return
   */
  private static Object getAnimalBase(Object obj){
    //获取代理对象
    return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
        obj.getClass().getInterfaces(), new AOPHandle(obj));
  }
  /***
   * 获取对象方法
   * @param obj
   * @return
   */
  @SuppressWarnings("unchecked")
  public static T getAnimal(Object obj){
    return (T) getAnimalBase(obj);
  }
  /***
   * 获取对象方法
   * @param className
   * @return
   */
  @SuppressWarnings("unchecked")
  public static  T getAnimal(String className){
    Object obj=null;
    try {
      obj= getAnimalBase(Class.forName(className).newInstance());
    } catch (Exception e) {
      e.printStackTrace();
    }
    return (T)obj;
  }
  /***
   * 获取对象方法
   * @param clz
   * @return
   */
  @SuppressWarnings("unchecked")
  public static  T getAnimal(Class clz){
    Object obj=null;
    try {
      obj= getAnimalBase(clz.newInstance());
    } catch (Exception e) {
      e.printStackTrace();
    }
    return (T)obj;
  }
}

package proxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import proxy.AnimalFactory;
import proxy.imp.AnimalInterface;

@RunWith(BlockJUnit4ClassRunner.class)
public class AOPTest {

  @Test
  public void Test1() {
    AnimalInterface dog=AnimalFactory.getAnimal(DogImp.class);
    dog.say();
    System.out.println("我的名字是"+dog.getName());
    dog.setName("二狗子");
    System.out.println("我的名字是"+dog.getName());
  }
}

package proxy.imp;
import java.lang.reflect.Method;

public interface AOPMethod{
  //实例方法执行前执行的方法
  void after(Object proxy, Method method, Object[] args);
  //实例方法执行后执行的方法
  void before(Object proxy, Method method, Object[] args);
}

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

import proxy.imp.AOPMethod;

public class AOPHandle implements InvocationHandler{
  //保存对象
  private AOPMethod method;
  private Object o;
  public AOPHandle(Object o,AOPMethod method) {
    this.o=o;
    this.method=method;
  }
  /**
   * 这个方法会自动调用,Java动态代理机制
   * 会传入下面是个参数
   * @param Object proxy 代理对象的接口,不同于对象
   * @param Method method 被调用方法
   * @param Object[] args 方法参数
   * 不能使用invoke时使用proxy作为反射参数时,因为代理对象的接口,不同于对象
   * 这种代理机制是面向接口，而不是面向类的
   **/
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object ret=null;
    //修改的地方在这里哦
    this.method.before(proxy, method, args);
    ret=method.invoke(o, args);
    //修改的地方在这里哦
    this.method.after(proxy, method, args);
    return ret;
  }
}

package proxy;

import java.lang.reflect.Method;

import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import proxy.imp.AOPMethod;
import proxy.imp.AnimalInterface;

@RunWith(BlockJUnit4ClassRunner.class)
public class AOPTest {

  public static void main(String[] args) {

    AnimalInterface dog = AnimalFactory.getAnimal(DogImp.class, new AOPMethod() {
      // 这里写方法执行前的AOP切入方法
      public void before(Object proxy, Method method, Object[] args) {
        System.err.println("我在" + method.getName() + "方法执行前执行");
      }

      // 这里系方法执行后的AOP切入方法
      public void after(Object proxy, Method method, Object[] args) {
        System.err.println("我在 " + method.getName() + "方法执行后执行");

      }
    });
    dog.say();
    String name1="我的名字是" + dog.getName();
    System.out.println(name1);
    dog.setName("二狗子");
    String name2="我的名字是"+dog.getName();
    System.out.println(name2);
  }
}