代理设计模式

1. Java常用的几种设计模式

下面给你介绍5种设计模式：

1.单例设计模式

所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：

(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

(3) 定义一个静态方法返回该类的实例。

2.工厂设计模式

程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

3.代理设计模式

指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

4.观察者设计模式

所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

5.适配器模式

如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。

2. 如何理解iOS开发中的代理设计模式

Delegate ，又称为 委托或代理， 它是一种设计模式。 学习iOS开发，需要深入理解 Delegate的用法。 Apple 对Delegate 有明确的说明。但理解起来还是有些抽象。 Delegate的用途： 用于改变或控制其他对象 。 Delegate 的定义： （1）Delegate 是一个对象， 其类型为 id (anonymous type: 匿名类型)； （2） Delegate 的引用通常是一个实例变量 （instance variable）， 命名为 delegate； （3）Delegate 内所用的方法是 访问模式 （Accessors pattern） Delegate Message 的命名： 发给Delegate的消息 通常带有(should, will, did) 之一。 should：期待delegate返回一个值； will：表示变化发生之前 要做的事情； did ： 表示变化发生之后 要做的事情。 Cocoa Touh 的很多类都不同程度地用到Delgete。 比如： NSTextField， NSTableView。 其中 NSTableView 还用到了 Data Source。 其实，Data Source 也是一种委托。 Data Source 减少了 View 与 Model 之间的耦合性。 其中 ， NSAppplication 实现了几十个委托方法。 Delegate 使用的注意事项： Delegate 是一个 ID 类型的对象， 同样存在创建和释放问题。 对于Data Source ， 只有Data Source的使用者 （比如Table View）释放后， Data Souce 才能被释放。 否则， 就会出现crash。 因为在table view 获取数据时， 数据已经不见了。 Delegate 可用在多个场景下，比如对象间的数据交互， 不同视图之间的行为交互。 若仅仅是数据交互， 可实现的方法还有很多。Delegate 尤其适用于视图之间的行为交互。

3. 设计模式：适配器模式和代理模式的区别

这是之前我的博客总结的：

Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问。
例如：经典的体现在Spring AOP切面中，Spring中利用了俩种代理类型。
其实，代理也分为静态和动态，但是我们一般常用动态，因为静态代理秀不起来

Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
其中对象的适配器模式是各种结构型模式的起源，分为三种：类，对象，接口的适配器模式。

结一下三种适配器模式的应用场景：
类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。
接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

区别：很明显，适配器模式是因为新旧接口不一致导致出现了客户端无法得到满足的问题，但是，由于旧的接口是不能被完全重构掉的，因为我们还想使用实现了这个接口的一些服务。那么为了使用以前实现旧接口的服务，我们就应该把新的接口转换成旧接口。相比于适配器的应用场景，代理就不一样了，虽然代理也同样是增加了一层，但是，代理提供的接口和原本的接口是一样的，代理模式的作用是不把实现直接暴露给client，而是通过代理这个层，代理能够做一些处理。

4. java设计模式之代理模式：

很简单：对外部提供统一的接口方法，而代理类在接口中实现对真实类的附加操作行为，从而可以在不影响外部调用情况下，进行系统扩展。也就是说，我要修改真实角色的操作的时候，尽量不要修改他，而是在外部在“包”一层进行附加行为，即代理类。

例如：接口A有一个接口方法operator()，真是角色：RealA实现接口A，则必须实现接口方法operator()。客户端Client调用接口A的接口方法operator()。
现在新需求来了，需要修改RealA中的operator()的操作行为。怎么办呢？如果修改RealA就会影响原有系统的稳定性，还要重新测试。这是就需要代理类实现附加行为操作。创建代理ProxyA实现接口A，并将真实对象RealA注入进来。ProxyA实现接口方法operator()，可以增加附加行为，然后调用真实对象的operator()。从而达到了“对修改关闭，对扩展开放”，保证了系统的稳定性。我们看客户端Client调用仍是接口A的接口方法operator()，只不过实例变为了ProxyA类了而已。
建议看看《软件秘笈：设计模式那点事》，当中讲解的很详细，例子也很生动，读了收获很大！希望以上内容对你有帮助！

5. 继续设计模式，代理模式有什么好理解的实用的例子

代理模式就是抽象出一个调用方与被调方的中间层

达到一定程度的解耦与封装内

设计模容式只是一种思想

打个比方说, 使用代理模式， 被调方的对象在调用方就不能直接操作， 可以在代理类中调用被调方的方法前后再加上一些操作， 又或者再隐藏一些被调方的操作

当然， 我举的例子可能有一些是其他设计模式的思想， 但是我觉得没有必要死扣概念， 设计出符合当前需求、易于维护、扩展的框架才是设计模式的最终体现

6. 这个是设计模式中代理模式的结构图，我没看懂构建流程，哪位大神帮助再描述下构建顺序

abstract public class Subject
{
abstract public void request();

}

public class RealSubject extends Subject
{
public RealSubject() { }

public void request()
{
System.out.println( " From real subject. " );
}
}

public class ProxySubject extends Subject
{
private RealSubject realSubject; // 以真实角色作为代理角色的属性

public ProxySubject() { }

public void request()
{ // 该方法封装了真实对象的request方法
preRequest();

if ( realSubject == null )
{

realSubject = new RealSubject();
}

realSubject.request(); // 此处执行真实对象的request方法

postRequest();
}
}

//调用
Subject sub = new ProxySubject();
Sub.request();

7. java-接口的代理设计模式

代理设计模式是有解决特定的问题的先决条件的，即：假定代码中Network 的实现类 Real 中的代码作为第三方库或者其他形式的代码功能实现【不能被修改或者改变】，此时如果我们想在实际应用Real类中的 browser 方法时，在此方法调用前后添加其他业务逻辑代码，同时做到不破坏 Real 类的目的，我们需要引入【代理 Proxy】的设计模式来解决此问题（此设计模式被 Spring 中的 AOP 切面编程应用）

//定义业务接口
interfaceNetwork{
	voidbrowse();
}

//----------------------------------------//
//Real实现类，此时我们不想修改人家代码哦！咋整？
//----------------------------------------//
classRealimplementsNetwork{
	publicvoidbrowse(){
		System.out.println("Realisworkingforbrowsing");
	}
}

//----------------------------------------//
//代理设计模式类
//----------------------------------------//
classProxyimplementsNetwork{
//按照接口编程，把Real的父类的类型当做成员变量放进来，只要有人实现了
//Network类，都能在本类实例化的时候传进来，对不？
	privateNetworknetwork;

//此时实现了Network的类型就被扔进来了
	publicProxy(Networknetwork){
		this.network=network;
	}

	publicvoidbrowse(){
	//其他的业务逻辑Blahblah~~~
		this.network.browse();
//其他的业务逻辑Blahblah~~~
	}
}
//此时这个类也属于了Network的实现类，但是我们的browse()方法中，业务代码更
//丰富了，更厉害了，对不？^_^

publicstaticvoidmain(String[]args){
		Networknet=newProxy(newReal())
		//此时我们的browse方法，既没有改Real人家的代码，又比人家
		//代码更厉害了，Real现在只是Proxy类的一个内部小变量了.
		net.browse();
}

8. 我觉得大话设计模式中对于代理模式，用GG追MM的例子的解释是完全错误的！

仔细抄看了一下，是有问题的

A 要访问 C， 无法直接访问，必须通过B，则

B（参数）
{
C(参数）
}

A 提供的参数就是 flower，通过B，则
B（flower)
{
C （flower）
}

这里实际作用的是C，B和C应该是同一个接口，A是客户端，大话设计模式里将A与B作为实现一个接口，是不对的

9. 设计模式都有哪些

总体来说设计模式分为三大类：

一、创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

二、结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

三、行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1、工厂方法模式：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，这就用到工厂方法模式。

创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

2、抽象工厂模式：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承。

3、单例模式：

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

（1）某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

（2）省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

（3）有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

4、建造者模式：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

5、原型模式：

原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类。

6、适配器模式：

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

7、装饰器模式：

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

8、代理模式：

代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。

9、外观模式：

外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口。

10、桥接模式：

桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样。

JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。

11、组合模式：

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

12、享元模式：

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

13、策略模式：

策略模式定义了一系列算法，并将每个算法封装起来，使其可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。

14、模板方法模式：

一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。

15、观察者模式：

观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。

其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

16、迭代子模式：

顾名思义，迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。

17、责任链模式：

责任链模式，有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。

18、命令模式：

命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开。

19、备忘录模式：

主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。

20、状态模式：

状态模式在日常开发中用的挺多的，尤其是做网站的时候，我们有时希望根据对象的某一属性，区别开他们的一些功能，比如说简单的权限控制等。

21、访问者模式：

访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。

若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。

22、中介者模式：

中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。

如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用。

23、解释器模式：

解释器模式一般主要应用在OOP开发中的编译器的开发中，所以适用面比较窄。

(9)代理设计模式扩展阅读：

介绍三本关于设计模式的书：

1、《设计模式：可复用面向对象软件的基础》

作者：[美] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

出版社： 机械工业出版社

2、《软件秘笈：设计模式那点事》

作者：郑阿奇

出版社：电子工业出版社

3、《设计模式：基于C#的工程化实现及扩展》

作者：王翔

出版社：电子工业出版社

10. 求教java高手：什么是DAO设计模式，听老师说DAO设计模式通常会和工厂设计模式、代理设计模式一起使用，

class User {
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
interface UserDAO {
public boolean doCreate(User user)throws Exception;
}
class UserDAOImpl implements UserDAO {
private String str=null;
public UserDAOImpl(String str){
this.str=str;
}
public boolean doCreate(User user)throws Exception{
boolean flag=false;
try{
System.out.println("真实主题类的数据库增加操作");
}catch(Exception e){
e.printStackTrace();
}finally{

}
return flag;
}
}
class UserDAOProxy implements UserDAO {
private UserDAOImpl =null;
private String str=null; //此处其实应该传入一个数据库的连接到真实主题类的，不过这里只是个演示，所有以字符串的形式传了进去
public UserDAOProxy(){
this.str=new String();
this.=new UserDAOImpl(this.str);
}
public boolean doCreate(User user)throws Exception{
boolean flag=true;
System.out.println("代理类的操作，打开数据库，同时取得真实主题类的实例去调用真实的数据层操作");
try{
this..doCreate(user);
}catch(Exception e){
e.printStackTrace();
}finally{
System.out.println("代理类的操作，调用完真实主题类的操作，同时关闭数据库");
}
return flag;
}
}
class UserDAOFactory {
public static UserDAO getUserDAONewInstance(){
System.out.println("通过工厂类取得代理类的实例去调用代理类的操作。");
return new UserDAOProxy();
}
}
public class FactoryDemo {
public static void main(String args[])throws Exception{
User user=new User();
user.setName("jhjjs");
user.setAge(20);
UserDAOFactory.getUserDAONewInstance().doCreate(user);
}
}
lz看下吧，刚做的