Spring学习-3-代理模式

概述

代理是一种设计模式，它提供了对目标对象另外的访问方式;即通过代理访问目标对象。好处，可以在目标对象实现的基础之上，增强额外的功能操作。（扩展目标对象的功能）

代理对象

目标对象

静态代理

1）代理对象，要实现和目标对象一样的接口

2）保存用户

Dao直接保存

DaoProxy 给保存方法添加事务处理

实例：

staticProxy.UserDao

package staticProxy;

/**
 * Created by cxspace on 16-8-9.
 */
public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("---保存数据---");
    }
}

staticProxy.IUserDao

package staticProxy;

/**
 * Created by cxspace on 16-8-9.
 */
public interface IUserDao {
    public void save();
}

staticProxy.UserDaoProxy

package staticProxy;

/**
 * Created by cxspace on 16-8-9.
 */
public class UserDaoProxy implements IUserDao {

    private IUserDao target;

    public UserDaoProxy(IUserDao target){
        this.target = target;
    }

    @Override
    public void save() {
        System.out.println("--------------------------");
        System.out.println("------保存对象-------------");
        System.out.println("--------------------------");
    }
}

测试

package staticProxy;

import org.junit.Test;

/**
 * Created by cxspace on 16-8-9.
 */
public class App {
    @Test

    public void test(){

        IUserDao target = new UserDao();

        IUserDao proxy = new UserDaoProxy(target);

        proxy.save();

    }
}

总结静态代理

1)  可以做到在不修改目标对象的功能前提下，对目标对象功能扩展

2)  缺点：

因为代理对象需要有目标对象实现一样的接口，所以会出现很多代理类

一旦接口增加方法，目标对象与代理对象都要维护

动态代理

1) 代理对象，不需要实现接口

2) 代理对象的生成，是利用JDKAPI，动态的在内存中构建代理对象（需要我们指定创建代理对象实现的接口的类型）

3) 动态代理，也叫JDK代理或者接口代理

JDK中生成代理对象的api

实例

通用代理类工厂

dynamic.ProxyFactory

package dynamic;

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

/**
 * Created by cxspace on 16-8-9.
 *
 * 给所有的dao创建代理对象[动态代理]
 *
 * 代理对象,不需要实现接口
 *
 */
public class ProxyFactory {

    //维护一个
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 给目标对象,生成代理对象
    public Object getProxyInstance(){
        return 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("开启事务");

                        Object returnValue = method.invoke(target,args);

                        System.out.println("提交事务");
                        return returnValue;
                    }
                }
        );
    }
}

测试

package dynamic;

import org.junit.Test;

/**
 * Created by cxspace on 16-8-9.
 */
public class App {

    @Test
    public void testDynamic(){

        IUserDao target = new UserDao();

        //原始类型
        System.out.println(target.getClass());
        //创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        //内存中动态生成的代理对象 class com.sun.proxy.$Proxy2

        System.out.println(proxy.getClass());

        proxy.save();
    }
}