静态代理模式

¶静态代理模式

¶定义

静态地为其他对象提供代理，用以对某个对象的访问。静态代理模式共分为三个部分，代理类，被代理类，共同接口。

共同接口
通用接口，代理类和被代理类共同实现，这让代理类能够替代被代理的对象。共同接口使得代理类能够代理这个接口下的一系列的被代理类。
被代理类
可以称作委托者，是业务逻辑的执行者。实现了共同接口，可以被代理类代理。
代理类
获取被代理类引用(获取业务逻辑)，为最终的执行者。实现了共同接口，可以代理被代理类。

我们可以用代购举例，用户需要购买商品，可以通过代理帮助购买，代理能够帮助购买很多种类的商品，而购买商品操作是用户与代理共同具有的。
可以有代理能够购买和用户需要购买的商品操作为共同接口
用户实现这个接口表示用户需要购买这些商品
代理实现这个接口表示代理能够购买这些商品
代理需要访问用户得知需要购买什么商品(业务逻辑)
用户需要告知代理需要购买什么商品(业务逻辑)
并且用户需要给代理钱来购买商品
最终代理购买了商品给用户

¶使用静态代理模式

¶第一步，创建实体

/**
 * 创建用户实体（需要给代理的钱）
 */

package com.spring.bean;

public class User {
    private int id ;
    private String name ;
    private int age ;

    public User() {
    }

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

¶第二步，创建共同接口

package com.spring.service;

import com.spring.bean.User;

/**
 * 创建共同接口(买东西这个操作)
 */
public interface UserService {
    void addUser(User u);
    void deleteUser(int id);
}

¶第三步，创建被代理类

package com.spring.serviceImpl;

import com.spring.bean.User;
import com.spring.service.UserService;

/**
 * 创建用户的业务逻辑实现(具体买什么东西)
 * 我们需要知道用户要干什么
 */
public class UserServiceImpl implements UserService {
    public void addUser(User u) {
        System.out.println("增加User");
    }

    public void deleteUser(int id) {
        System.out.println("删除User");
    }
}

¶第四步，创建事务类

package com.spring.transaction;

/**
 * 事务(代理买东西时需要用到的额外工具)
 * 相当于一个代理需要的一个工具
 */
public class Transaction {
    public void before(){
        System.out.println("开始事务");
    }

    public void after(){
        System.out.println("提交事务");
    }

}

¶第五步，创建代理类

package com.spring.serviceImpl;

import com.spring.bean.User;
import com.spring.service.UserService;
import com.spring.transaction.Transaction;

/**
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"></span><br></pre></td></tr></table></figure>
<ul>
<li>代理类</li>
<li>代理类需要实现共同的接口，使得代理知道用户要干什么</li>
<li>代理之后需要使用工具事务类，帮助代理执行这个操作<br>
*/</li>
</ul>
<p>public class ProxyUser implements UserService {</p>
<!--0-->
<p>}</p>

¶第六步，代理开始工作

import com.spring.bean.User;
import com.spring.service.UserService;
import com.spring.serviceImpl.ProxyUser;
import com.spring.serviceImpl.UserServiceImpl;
import com.spring.transaction.Transaction;

public class Test {

    /**
     * 创建实体对象(相当于买东西的钱)
     * 创建用户业务逻辑对象(需要买什么东西)
     * 创建事务对象(代购需要的工具)
     * 创建代理对象(代购人)
     * 代理对象确定需要代理的对象(userService),使用transaction对象作为工具，实现代理工作
     */

    @org.junit.Test
    public void test01(){
        User user = new User(1, "张三", 18);
        UserService userService = new UserServiceImpl();
        Transaction transaction = new Transaction();
        ProxyUser proxyUser = new ProxyUser(userService, transaction);
        proxyUser.addUser(user);
    }
}

¶第七步，测试结果

1
2
3

开始事务
增加User
提交事务

¶优缺点

¶优点

可以将两个类需要通信的类解耦，实现低耦合，高内聚。使我们只需要了解代理类。
两个类之间的关系能被统一管理。

¶缺点

代理对象的一个接口服务于一种类型的对象(一种代表了代理类和被代理类必须实现同一个接口，这个接口下的所有类都可被代理类访问到)，如果代理的方法很多，需要为每一种方法都进行代理，这样会出现非常多的冗余代码。
如果共同接口增加一个方法，则代理类和被代理类都需要实现这个方法。这增加了代码维护难度。

¶自言自语

静态代理模式使我们只需要改代理类的实现，而不需要更改其他的类。但是静态代理合适应用在小的项目中，如果在大项目中，则需要使用动态代理模式。
剩余:22种。