Spring学习五：代理

代理

为什么么要学习代理模式，因为aop的底层机制就是动态代理；

代理模式：

• 静态代理
• 动态代理

静态代理

代理模式的角色分析：

抽象角色：一般会使用抽象类或者接口实现

真实角色：被代理的角色

代理角色：代理真实角色，代理真实角色后，一般会做一些附属的操作；

客户：使用代理角色进行一些操作

代码实现例1—出租房子

创建一个租房的接口

package com.westos.staticproxy;

//出租的接口：抽象
public interface Rent {

    //出租
    void rent();
}

真实对象–真正的房东

package com.westos.staticproxy;

//这个房子要出租
//真实对象
public class Host implements Rent{
    //出租
    public void rent(){
        System.out.println("房东要出租房子");
    }
}

代理对象–代理

package com.westos.staticproxy;
//代理对象
//房屋中介--代理
public class Proxy  implements  Rent{
      //房东
    private Host host;

    public void setHost(Host host) {
        this.host = host;
    }

    public void rent() {
        lookHouse();
        host.rent();
        fare();
    }

    private void lookHouse(){
        System.out.println("中介带你去看房");
    }
    private void fare(){
        System.out.println("中介收取中介费用");
    }
}

测试

package com.westos.staticproxy;

public class You {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy();
        proxy.setHost(host);
        proxy.rent();
    }
}

测试结果：

代码实现例2

创建UserService接口，这个接口声明了与用户相关的增删改查。

package com.westos.user;

public interface UserService {

    void add();
    void delete();
    void update();
    void query();
}

创建真实对象UserServiceImpl实现UserService 接口中的方法。专注于处理核心业务。

package com.westos.user;

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加一个用户");
    }

    public void delete() {
        System.out.println("删除一个用户");
    }

    public void update() {
        System.out.println("更新一个用户");
    }

    public void query() {
        System.out.println("查询一个用户");
    }
}

创建静态代理类。代理真实对象，为真实对象增加一些控制策略，比方说，为真实对象增添一些日志功能。

package com.westos.user;

public class UserServiceImplProxy implements  UserService{
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void query() {
        log("query");
        userService.query();
    }

    public void log(String methodName){
        System.out.println("执行"+methodName+"方法");

    }

}

测试

package com.westos.user;

public class test {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceImplProxy proxy = new UserServiceImplProxy();
        proxy.setUserService(userService);
        proxy.add();

    }
}

测试结果

静态代理模式的好处

• 可以使真实角色更加纯粹，不用去关注一些公共的事情；
• 公共的业务由代理来完成，实现业务的分工；
• 公共业务的要扩展的话，可以更加集中和方便；

缺点：

• 假如我们的真实角色变得非常多，代理类也会随之增多，工作量变大，开发效率变低！

然后我们想需要一种能够有静态代理的全部好处，但是又不存在这种缺点的东西。

Aop就是横向编程，可以理解一下

动态代理

• 动态代理和静态代理的角色都是一样；

• 静态代理模式的代理类是我们提前写好的，动态代理的类是动态生成的；

• 动态代理大概分两类：

基于接口实现：JDK

基于类实现：cglib

当今用的比较多的是 JAVAssist来生成动态代理

了解动态代理之前，需要掌握两个类：

• InvocationHandler
• Proxy

InvocationHandler是由代理实例的调用处理程序实现的接口 。

invoke(Object proxy, 方法 method, Object[] args) 处理代理实例上的方法调用并返回结果。

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。**

newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

代码实现

抽象角色

package com.westos.staticproxy;
//出租的接口：抽象
public interface Rent {

    //出租
    void rent();
}

真实角色

package com.westos.staticproxy;


//这个房子要出租
//真实对象
public class Host implements Rent{
    //出租
    public void rent(){
        System.out.println("房东要出租房子");
    }
}

动态代理类生成的接口对象；

package com.westos.dynamicproxy;

import com.westos.staticproxy.Rent;

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

public class InvocationHandlerProxy implements InvocationHandler {


    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //动态生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),
                this);
    }


    //proxy:代理类
    //method ：代理类的调用处理程序的方法 的对象
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        lookHouse();
        Object result = method.invoke(rent, args);
        zhongJieFei();
        return null;
    }

    private void lookHouse(){
        System.out.println("中介带看房子");
    }

    private void zhongJieFei(){
        System.out.println("收中介费");
    }
}

测试

package com.westos.dynamicproxy;

import com.westos.staticproxy.Host;
import com.westos.staticproxy.Rent;

public class Test {
    public static void main(String[] args) {
        Host host = new Host();
        InvocationHandlerProxy ihp = new InvocationHandlerProxy();
        ihp.setRent(host);

        Rent proxy = (Rent) ihp.getProxy();

        proxy.rent();
    }
}

测试结果：

动态代理的好处：

• 可以使真实角色更加纯粹，不用去关注一些公共的事情；
• 公共的业务由代理来完成，实现业务的分工；
• 公共业务的要扩展的话，可以更加集中和方便；
• 一个动态代理，一般代理一类的业务，一个动态代理可以代理多个类，代理接口；