Spring学习:静态代理

静态代理角色分析：

租房例子：

• 抽象角色：一般使用抽象类和接口来实现。
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
• 用户（客户）：使用代理角色来进行一些操作。

例子代码：
1.抽象角色

//抽象角色：租房
public interface Renting {
    void rent();
}

2.真实角色：房东

//真实角色: 房东，房东要出租房子
public class Landlord implements Renting{
    public void rent() {
        System.out.println("出租房子");
    }
}

3.代理角色

//代理角色：中介
public class Intermediary implements Renting {

    private Landlord landlord;

    public Intermediary() {
    }

    public Intermediary(Landlord landlord) {
        this.landlord = landlord;
    }

    public Landlord getLandlord() {
        return landlord;
    }

    public void setLandlord(Landlord landlord) {
        this.landlord = landlord;
    }

    public void seeRoom(){
        System.out.println("看房子");
    }

    public void sign(){
        System.out.println("签合同");
    }

    public void agencyFee(){
        System.out.println("中介费");
    }

    public void rent() {
        seeRoom();
        sign();
        landlord.rent();
        agencyFee();
    }

4.客户

public class Client {
    public static void main(String[] args) {
        //房东要租房
        Landlord landlord = new Landlord();
        //中介帮助房东
        Intermediary intermediary = new Intermediary(landlord);
        intermediary.rent();
    }
}

静态代理的好处：

• 可以使我们的真实角色更加纯粹，不去关注一些公共的事情
• 公共的业务由代理来完成，实现了业务的分工
• 方便拓展公共业务而且比较集中

缺点 :

• 类增多，新增了代理类，代码量增加，开发效率降低

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

拓展例子：

用户的增删改查，增加日志记录

1.抽象角色

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

2.真实角色

public class UserServiceImpl implements Uservice {
    public void add() {
        System.out.println("新增用户");
    }

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

    public void update() {
        System.out.println("修改用户");
    }

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

3.代理角色

public class UserProxy implements Uservice{

    private UserServiceImpl userService;

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

    public void Log(String msg){
        System.out.println("打印"+msg+"日志");
    }

    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();
    }
}

4.客户调用：

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserProxy proxy = new UserProxy();
        proxy.setUserService(userService);
        proxy.add();
        proxy.delete();
    }
}

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想