java设计模式（代理模式）

代理模式

主要是有三个元素：

•       目标接口
•       代理对象
•       目标对象

实际上是由代理对象去执行目标对象的方法，对目标方法的扩展。

代理模式的种类：静态代理、动态代理（jdk动态代理、cglib动态代理、SpringAspectJ实现的动态代理）

                           所有的代理层只负责真实主题的调用，以及打开和关闭数据库。

Jdk的动态代理，是使用反射技术获得类的加载器并且创建实例，根据类执行的方法在执行方法的前后发送通知

Cglib实现代理的方式是和目标对象使用同一个父类，无论是继承还是实现接口，都是为了代理对象能直接调用目标对象的方法。

一.静态代理

/**
 * service 接口类（接口）
 */
public interface DeptService {
    public void add(); //增加操作
    public void delete(); //删除操作
    public void update();  //修改操作
    public void query();   //查询操作
}

/**
 * 实际对象实现的操作（实际对象）serviceimpl实现类
 */
public class DeptServiceImpl  implements DeptService {

    @Override
    public void add() {
        System.out.println("增加数据的操作");
    }

    @Override
    public void delete() {
        System.out.println("删除数据的操作");
    }

    @Override
    public void update() {
        System.out.println("更新数据的操作");
    }

    @Override
    public void query() {
        System.out.println("查询数据的操作");
    }
}

/**
 * 代理类实现的操作（代理对象）
 */
public class ProxyServiceImpl implements DeptService {
   private DeptServiceImpl deptService;
   public ProxyServiceImpl(DeptServiceImpl deptService){
        this.deptService=deptService;
   }
    @Override
    public void add() {
        System.out.println("执行增加操作方法之前");
        this.deptService.add();
        System.out.println("执行增加操作方法之后");
    }

    @Override
    public void delete() {
        System.out.println("执行删除操作方法之前");
        this.deptService.delete();
        System.out.println("执行删除操作方法之后");
    }

    @Override
    public void update() {
        System.out.println("执行更新操作方法之前");
        this.deptService.update();
        System.out.println("执行更新操作方法之后");
    }

    @Override
    public void query() {
        System.out.println("执行查询操作方法之前");
        this.deptService.query();
        System.out.println("执行查询操作方法之后");
    }
}

//工厂类（）
public class FactoryDept {
    /**
     * 静态代理
     * @return
     */
    public static DeptService getInstance(){
        return new ProxyServiceImpl(new DeptServiceImpl());
    }


}

//静态代理测试
public class ProxyTest {
    @Test
    public void StaticProxy(){
            DeptService deptService= FactoryDept.getInstance();
            deptService.add();
    }
}

二. jdk 动态代理

 

/**
 * 实现动态代理点(接口类使用静态代理的接口类和实现类)
 */
public class ServiceProxy implements InvocationHandler{
    private Object target=null;//真实的主题对象
    /**
     * 返回代理类对象，这样用户可以根据代理类操作真实的对象
     * @param object  真实业务的实际对象
     * @return  代理对象
     */
    public Object bind(Object object){
        this.target=object; //保存真实的主题对象
       return  Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("年后的的额  的额 的的");
        Object reVal=  method.invoke(target,args);//调用真实对象的操作方法
        System.out.println("adajdhakdjjjjjjjjjjjjjjjjjjj");
        return reVal;
    }
}

/**
 * 动态代理工厂类
 *
 */
public class FactoryProxyDt {
    public static DeptService getInstance(){
         return (DeptService) new ServiceProxy().bind(new DeptServiceImpl());
    }
}

/**
 * 动态代理测试类
 */
public class DtProxyTest {
    /**
     * jdk动态代理测试
     */
    @Test
    public void test() {
        DeptService deptService = FactoryProxyDt.getInstance();
        deptService.add();
    }
}

/**
 * 无封装的jdk动态代理
 */
@Test
public void test4(){
    DeptService target=new DeptServiceImpl();
    //为接口创建代理对象
    DeptService deptService= (DeptService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("jdk代理!!!!!!!!!!!!!!!!!!!!!");
            Object reVal=  method.invoke(target,args);
            return reVal;
        }
    });
    deptService.add();
}

 

/**
 * cglib 代理工厂类（没有接口的类）
 */
public class ProxyFactory implements MethodInterceptor {
    //维护目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;

    }
    //给目标对象创建代理对象
    public Object getInstance(){
        Enhancer enhancer=new Enhancer();
        //获得父类
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this); //设置回调函数
        return  enhancer.create(); //4.创建子类(代理对象)并且返回代理对象

    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib动态代理!!!!!!!!!!!!!!!!!");
        Object reVal=   method.invoke(target,objects);
        return reVal;
    }
}

 

 

/**
 * cjlib 动态代理测试
 */
@Test
public void Test1(){
     DeptService target= new DeptServiceImpl();
     Enhancer enhancer=new Enhancer();
     enhancer.setSuperclass(target.getClass());
     enhancer.setCallback(new MethodInterceptor() {
         @Override
         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
              System.out.println("cjlib 代理的！！！！！！！！！！！！！！！！");
              Object obj=  method.invoke(target,objects);
              return  obj;
         }
     });
    DeptService proxy=(DeptServiceImpl)enhancer.create();
    proxy.add();
}

/**
 * CGLIB 封装之后调用
 */
@Test
public void test3() {
    DeptServiceImpl object = (DeptServiceImpl) new ProxyFactory(new DeptServiceImpl()).getInstance();
    object.add();

}

 

转载于:https://my.oschina.net/u/3653755/blog/2209397