Java静态代理和动态代理

　　Spring框架用了很久了，对于Spring AOP也只是应用在数据库事务管理上面。对于Spring AOP的原理也只是知道使用动态代理实现，再深入的就知之甚少了，惭愧啊。

最近有时间深入学习了一下，现在对动态代理的原理和应用进行一下总结。对于Spring AOP的基础概念和实现原理后续会进行总结。

　　代理模式又分为静态代理和动态代理。

　　在现实生活中代理模式比比皆是，就拿租房来说， 房东要出租房子，就通过中介将房源挂出，当有租客想要租房子时，需要先跟中介进行沟通，看房子最后才跟房东签合同交钱等等，

但是真正的房子出租价格都是房东定的（计算的），所以中介就是房东的代理。

　　接下来分别通过静态代理和动态代理来实现房东通过中介出租房租给租客这个业务场景。

　　静态代理模拟实现房屋出租业务场景：

/**
 * @author Jack2013
 * 出租房屋接口
 */
public interface Rentable {

    public void rentOutHouse() ;
}
/**
 * @author Jack2013
 * 房东,被代理的对象
 */
public class Landlord implements Rentable {
        
    public void rentOutHouse() {
        System.out.println("我是房东，我与租客签合同并收取租金...");
    }
    
}
/**
 * @author Jack2013
 * 房产中介，代理房东出租房子
 */
public class HouseAgent implements Rentable {
    
    private Rentable rentable;

    public void rentOutHouse() {
        showHouse() ;
        rentable.rentOutHouse();
        getFee() ;
    }
    
    public boolean hasRentable() {
        return rentable == null ? Boolean.FALSE : Boolean.TRUE ;
    }
    
    private void showHouse() {
        System.out.println("我是中介，我带租客看房子...");
    }
    
    private void getFee() {
        System.out.println("我是中介，我拿到了报酬...");
    }

    public Rentable getRentable() {
        return rentable;
    }

    public void setRentable(Rentable rentable) {
        this.rentable = rentable;
    }
}
/**
 * @author Jack2013
 *    租客，通过中介租房子
 */
public class Renter {
    
    /**
     * 找到有房源的中介
     */
    public HouseAgent findHouseAgent(List<HouseAgent> agents) {
        for(HouseAgent agent : agents) {
            if(agent.hasRentable()) {
                System.out.println("我找到一个有房源的中介...");
                return agent ;
            }
        }
        return null ;
    }
    
    public void moveIn() {
        System.out.println("我是房客，我搬进了新租的房子...");
    }
    
    public Renter() {
        System.out.println("我是打工族，我准备租房子...");
    }
    
}
import java.util.List;
import com.google.common.collect.Lists;
/**
 * @author Jack2013
 * 测试类
 */
public class Test {

    public static void main(String[] args) {
        List<HouseAgent> houseAgents = Lists.newArrayList() ;
        HouseAgent agent1 = new HouseAgent() ;
        HouseAgent agent2 = new HouseAgent() ;
        houseAgents.add(agent1) ;
        houseAgents.add(agent2) ;
        
        //房东找中介2出租自己的房子
        Landlord landlord = new Landlord() ;
        agent2.setRentable(landlord) ; 
    
        //租客通过中介租房子
        Renter renter = new Renter() ;
        HouseAgent agent = renter.findHouseAgent(houseAgents) ;
        agent.rentOutHouse() ;
        renter.moveIn(); 
    }
}
运行结果如下：　

　　　　我是打工族，我准备租房子...
　　　　我找到一个有房源的中介...
　　　　我是中介，我带租客看房子...
　　　　我是房东，我与租客签合同并收取租金...
　　　　我是中介，我拿到了报酬...
       我是房客，我搬进了新租的房子...

　  上面模拟场景中的中介目前只提供房屋出租的业务，如果想要提供房屋出售业务，则需要在添加一个Salable接口类，这是必须的，另外还必须添加一个Salable接口实现类的代理类。

     应为静态代理只能代理一个接口，但是动态代理则不需要增加新的代理类。

　　动态代理模拟实现房屋出租和出售业务场景：

/**
 * @author Jack2013
 * 出售房屋接口
 */
public interface Salable {

    public void saleOutHouse() ;
}

/**
 * @author Jack2013
 * 出租房屋接口
 */
public interface Rentable {

    public void rentOutHouse() ;
}

/**
 * @author Jack2013
 * 房东,被代理的对象
 */
public class Landlord implements Rentable, Salable {
        
    public void rentOutHouse() {
        System.out.println("我是房东，我与租客签合同并收取租金...");
    }

    public void saleOutHouse() {
        System.out.println("我是房东，我与买家签合同并收取全款...");
    }
    
}

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

public class HouseAgentCompany implements InvocationHandler{

    private String companyName ;
    
    private Object target;
    
    public HouseAgentCompany(){}
    
    public HouseAgentCompany(String companyName){
        this.companyName = companyName ;
        System.out.println("["+this.companyName + "] 成立");
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        showHouse() ;
        method.invoke(target, args) ;
        getFee() ;
        return null;
    }
    
    @SuppressWarnings("unchecked")
    public <T> T assign() {
        System.out.println("这里是" + this.companyName + ",为您分配一个专职员工服务");
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    private void showHouse() {
        System.out.println("我是中介，我带租客看房子...");
    }
    
    private void getFee() {
        System.out.println("我是中介，我拿到了报酬...");
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
}

public class People {

    private String name ;
    
    public People(){}
    
    public People(String name){
        this.name = name ;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Buyer extends People{

    public Buyer(String name) {
        super(name) ;
        System.out.println("我是白领: "+name+"，我准备租房子...");
    }
    
    public void moveIn() {
        System.out.println("我是房客，我搬进了新买的房子...");
    }
    
    public Buyer() {
        System.out.println("我是白领，我准备买房子...");
    }
}

/**
 * @author Jack2013
 *    租客，通过中介租房子
 */
public class Renter extends People{
    
    public Renter(String name) {
        super(name) ;
        System.out.println("我是打工族:"+name+"，我准备租房子...");
    }
    
    /**
     * 找到有房源的中介
     */
    public HouseAgent findHouseAgent(List<HouseAgent> agents) {
        for(HouseAgent agent : agents) {
            if(agent.hasRentable()) {
                System.out.println("我找到一个有房源的中介...");
                return agent ;
            }
        }
        return null ;
    }
    
    public void moveIn() {
        System.out.println("我是房客，我搬进了新租的房子...");
    }
    
    public Renter() {
        System.out.println("我是打工族，我准备租房子...");
    }
    
}

import com.gxg.demo.jdk.proxy.Buyer;
import com.gxg.demo.jdk.proxy.Landlord;
import com.gxg.demo.jdk.proxy.Rentable;
import com.gxg.demo.jdk.proxy.Renter;
import com.gxg.demo.jdk.proxy.Salable;

public class DynamicTest {

    public static void main(String[] args) {
        //中介公司
        HouseAgentCompany agentCompany = new HouseAgentCompany("NB房屋中介公司") ;
        System.out.println("-------------------------场景模拟开始-----------------------------");
        /**
         * 租房场景
         * */
        //房东找中介公司出租自己的房子
        Landlord landlordToRent = new Landlord() ;
        agentCompany.setTarget(landlordToRent); 
        //租客通过中介公司租房子
        Renter renter = new Renter() ;
        //中介公司随即分配一个中介服务租客
        Rentable randomAgentToRent = agentCompany.assign() ;
        randomAgentToRent.rentOutHouse(); 
        renter.moveIn(); 
        System.out.println("======================场景分界线====================");
        
        /**
         * 买房场景
         * */
        //房东找中介公司出售自己的房子
        Landlord landlordToSale = new Landlord() ;
        agentCompany.setTarget(landlordToSale); 
        
        //买家通过中介公司买房子
        Buyer buyer = new Buyer() ;
        //中介公司随即分配一个中介服务买家
        Salable randomAgentToSale = agentCompany.assign() ;
        randomAgentToSale.saleOutHouse(); 
        buyer.moveIn(); 
    }
}

运行结果：

[NB房屋中介公司] 成立
-------------------------场景模拟开始-----------------------------
我是打工族，我准备租房子...
这里是NB房屋中介公司,为您分配一个专职员工服务
我是中介，我带租客看房子...
我是房东，我与租客签合同并收取租金...
我是中介，我拿到了报酬...
我是房客，我搬进了新租的房子...
======================场景分界线====================
我是白领，我准备买房子...
这里是NB房屋中介公司,为您分配一个专职员工服务
我是中介，我带租客看房子...
我是房东，我与买家签合同并收取全款...
我是中介，我拿到了报酬...
我是房客，我搬进了新买的房子...

 　  动态代理与静态代理的区别在于事先对需要代理的类，需要代理的方法是未知的。

　　需要调用者传入被代理的对象Target，根据通过反射机制获取到的Target实现的接口，动态生成一个代理对象ProxyObject,

　　当程序调用ProxyObject代理对象实现的接口种某个方法，此时完成了对Target的某个方法的代理操作。

　　由于事先未知所以动态代理可以代理多个接口。