代理---观光代码

• 动态代理

  这也是spring容器中aop概念的原理，aop意为面向切面编程，同时也是oop的衍生和扩展，主要是增强一个类中的方法。接下来直接上代码，观光即可。。。。。。。。。。

  被代理对象必须使用接口
  

  package com.userservice;
  
  
  public interface UserService {
    public void insert();
    public void delete();
    public void update();
    public void select();
  }
  
  
  

  被代理对象的实现类
  

  package com.userserviceimpl;
  
  
  import com.userservice.UserService;
  
  
  public class UserServiceImpl implements UserService {
  
  
    @Override
    public void insert() {
      System.out.println("这是添加方法");
      
    }
  
  
    @Override
    public void delete() {
      System.out.println("这是删除方法");
      
    }
  
  
    @Override
    public void update() {
      System.out.println("这是修改方法");
      
    }
  
  
    @Override
    public void select() {
      System.out.println("这是查询方法");
      
    }
  
  
  }
  
  
  
  
  

  实现一个代理类

  通过Proxy.newProxyInstance实现一个代理对象，最终返回出去，腹泻该类中的invoke方法作为一个增强方法，然后调用.invoke调用该方法即可。
  

  package com.userserviceproxyfacory;
  
  
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  
  
  import com.userservice.UserService;
  import com.userserviceimpl.UserServiceImpl;
  
  
  public class UserServiceProxyFacory implements InvocationHandler{
  
  
    private UserService us;
    //将代理对象传进来
    public UserServiceProxyFacory(UserService us) {
      super();
      this.us = us;
    }
  
  
    public UserService getUserService(){
      //生成动态代理
      UserService usProxy = (UserService)Proxy.newProxyInstance(UserServiceProxyFacory.class.getClassLoader(), 
          UserServiceImpl.class.getInterfaces(), 
          this);
      //返回对象
      return usProxy;
    }
  
  
    /**
     * Object proxy:当前代理对象
     * Method method：当前执行的方法
     * Object[] args：当前方法执行的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("打开事务");
      //业务方法的执行
      Object invoke = method.invoke(us, args);
      System.out.println("提交事务");
      return invoke ;
    }
  }
  
  
  
  
  
  
  

  写一个DemoTest进行测试
  

  package com.test;
  
  
  import org.junit.Test;
  
  
  import com.userservice.UserService;
  import com.userserviceimpl.UserServiceImpl;
  import com.userserviceproxyfacory.UserServiceProxyFacory;
  
  
  public class Demo {
  
  
    @Test
    public void fun(){
      //被代理对象
      UserService us = new UserServiceImpl();
      //将被代理对象传入代理类中
      UserServiceProxyFacory facory=new UserServiceProxyFacory(us);
      //调用方法返回代理对象
      UserService usProxy = facory.getUserService();
      usProxy.delete();
    }
  }
  
  
  

  最终结果如下

• CGLIB代理

  此代理是一个第三方代理，同时也是一个继承代理，即代理对象继承了被代理对象。

  被代理对象和动态代理一致，这里不再写出。
  

  package com.userserviceproxyfacory;
  
  
  import java.lang.reflect.Method;
  
  
  import org.springframework.cglib.proxy.Enhancer;
  import org.springframework.cglib.proxy.MethodInterceptor;
  import org.springframework.cglib.proxy.MethodProxy;
  
  
  import com.userservice.UserService;
  import com.userserviceimpl.UserServiceImpl;
  
  
  public class UserServiceProxyFacory2 implements MethodInterceptor{
  
  
  
  
    public UserService getUserService(){
      //生成动态代理
      Enhancer enhancer = new Enhancer();//创建CJLIB核心类
      enhancer.setSuperclass(UserServiceImpl.class);//设置父类，也就是被代理对象
      enhancer.setCallback(this);//设置要做的事情
      UserService us = (UserService)enhancer.create();//生成代理
      //返回代理对象
      return us;
    }
  
  
    /*
     * 使用此方法增强
     */
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
      System.out.println("开启事务");
      Object invokeSuper = arg3.invokeSuper(arg0, arg2);
      System.out.println("提交事务");
      return invokeSuper;
    }
  }
  
  
  

  @Test
    public void fun1(){
      UserServiceProxyFacory2 facory=new UserServiceProxyFacory2();
      UserService userService = facory.getUserService();
      userService.insert();
    }
    
  

  结果如下