Go和Java实现代理模式

Go和Java实现代理模式

下面通过一个用户登录的例子来说明代理模式的使用。

1、代理模式

在代理模式中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

• 意图：为其他对象提供一种代理以控制对这个对象的访问。

• 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些

  对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访

  问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

• 何时使用：想在访问一个类时做一些控制。

• 如何解决：增加中间层。

• 关键代码：实现与被代理类组合。

• 应用实例：1、Windows 里面的快捷方式。 2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠

  兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟

  空，所以说孙悟空是高翠兰代理类。 3、买火车票不一定在火车站买，也可以去代售点。 4、一张支票或银行

  存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。 5、spring

  aop。

• 优点：1、职责清晰。 2、高扩展性。 3、智能化。

• 缺点：1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速

  度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

• 使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。

  4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化

  （Synchronization）代理。 8、智能引用（Smart Reference）代理。

• 注意事项：1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类

  的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

• 适用性：

  远程代理 (RemoteProxy) 为一个对象在不同的地址空间提供局部代表。

  虚代理 (VirtualProxy) 根据需要创建开销很大的对象。

  保护代理 (ProtectionProxy) 控制对原始对象的访问。

  智能指引 (SmartReference) 取代了简单的指针，它在访问对象时执行一些附加操作。

2、Go实现代理模式

package proxy

// ========== IUser ==========
type IUser interface {
	Login(username, password string)
}
1
2
3
4
5
6

package proxy

import "fmt"

// ========== User ==========
type User struct {
}

func (u *User) Login(username, password string) {
	fmt.Println("User Login...")
	fmt.Println("username is " + username + ",password is " + password)
}
1
2
3
4
5
6
7
8
9
10
11
12

package proxy

import "fmt"

// ========== UserProxy ==========
type UserProxy struct {
	user *User
}

func NewUserProxy() *UserProxy {
	fmt.Println("这是代理类!")
	return &UserProxy{
		user: &User{},
	}
}

// Login登录,和user实现相同的接口
func (p *UserProxy) Login(username, password string) {
	fmt.Println("执行代理类的login方法!")
	p.user.Login(username, password)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import (
	. "proj/proxy"
)

func main() {
	userProxy := NewUserProxy()
	userProxy.Login("root", "root")
}
1
2
3
4
5
6
7
8
9
10

# 输出
这是代理类!
执行代理类的login方法!
User Login...
username is root,password is root
1
2
3
4
5

3、Java实现代理模式

package com.proxy;

// ========== IUser ==========
public interface IUser {
    void login(String username, String password);
}
1
2
3
4
5
6

package com.proxy;

// ========== User ==========
public class User implements IUser{
    @Override
    public void login(String username, String password) {
        System.out.println("User Login...");
        System.out.println("username is " + username + ",password is "+password);
    }
}
1
2
3
4
5
6
7
8
9
10

package com.proxy;

// ========== UserProxy ==========
public class UserProxy implements IUser {

    private IUser iuser;

    public UserProxy() {
        System.out.println("这是代理类!");
        iuser = new User();
    }

    @Override
    public void login(String username, String password) {
        System.out.println("执行代理类的login方法!");
        iuser.login(username, password);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.proxy;

public class Test {
    public static void main(String[] args) {
        IUser iUser = new UserProxy();
        iUser.login("root","root");
    }
}
1
2
3
4
5
6
7
8

# 输出
这是代理类!
执行代理类的login方法!
User Login...
username is root,password is root
1
2
3
4
5