Spring 静态代理

静态代理（为了学习AOP）

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

• 静态代理
• 动态代理

学习aop之前 , 我们要先了解一下代理模式！

静态代理角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现
• 真实角色 : 被代理的角色
• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
• 客户 : 使用代理角色来进行一些操作 .

代码实现

1. 抽象角色–共同的抽象业务

//出租房子
public interface Rent {
    public void rent();
}

2. 真实角色–房东

public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("我是房东，我要出租房子！！！");
    }
}

3. 代理角色–中介

package com.kuang.demo1;

public class Proxy {
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent() {
        seeHose();
        host.rent();
        hetong();
        fare();
    }

    //看房
    public void seeHose() {
        System.out.println("中介带着看房");
    }
    //签租赁合同
    public void hetong() {
        System.out.println("签租赁合同");
    }
    //收中介费
    public void fare() {
        System.out.println("收中介费");
    }
}

4. 客户–租房的人

package com.kuang.demo1;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

静态代理的优点：

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工 ,
• 公共业务发生扩展时变得更加集中和方便 .

缺点 :

• 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 。

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

静态代理再理解

练习步骤:

1. 创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查!

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

2. 我们需要一个真实对象来完成这些增删改查操作

package com.kuang.demo2;

public class UserServiceImpl implements UserService{
    @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("查询了一个用户");
    }
}

3. 需求来了，现在我们需要增加一个日志功能，怎么实现!

• 思路1 :在实现类上增加代码 【麻烦!】
• 思路2:使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了!

---

4. 设置一个代理类来处理日志! 代理角色

package com.kuang.demo2;

public class UserServiceProxy implements UserService{

    private UserServiceImpl userService;

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

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

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

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

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

    public void log(String msg) {
        System.out.println("【debug】使用了" + msg + "方法");
    }
}

5. 测试访问类:

package com.kuang.demo2;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.add();
    }
}

OK，到了现在代理模式大家应该都没有什么问题了，重点大家需要理解其中的思想; 我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想 【聊聊AOP:纵向开发，横向开发】

问题思考：测试类中为什么要使用：
proxy.setUserService(userService);