常见的设计模型

最新推荐文章于 2024-07-11 14:44:52 发布

咸鱼的想法

最新推荐文章于 2024-07-11 14:44:52 发布

阅读量880

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/qq_45738291/article/details/121185455

版权

文章目录

设计模式背景
设计模式的分类
设计模式的六大原则
工厂模式
抽象工厂模式
- 介绍
- 实现
单例模式
- - 懒汉模式与饿汉模式
代理模式
- - 静态代理与动态代理的区别
MVC 模式

设计模式背景

前言：在 1994 年，由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 四人合著出版了一本名为 Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素） 的书。
四位作者合称 GOF（四人帮，全拼 Gang of Four）。他们所提出的设计模式主要是基于以下的面向对象设计原则。

对接口编程而不是对实现编程。
优先使用对象组合而不是继承。

使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式的分类

模型类型	模型
创建型模式：这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。	工厂模式（Factory Pattern）抽象工厂模式（Abstract Factory Pattern）单例模式（Singleton Pattern）建造者模式（Builder Pattern）原型模式（Prototype Pattern）
结构型模式：这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。	适配器模式（Adapter Pattern）桥接模式（Bridge Pattern）过滤器模式（Filter、Criteria Pattern）组合模式（Composite Pattern）装饰器模式（Decorator Pattern）外观模式（Facade Pattern）享元模式（Flyweight Pattern）代理模式（Proxy Pattern）
行为型模式：这些设计模式特别关注对象之间的通信。	责任链模式（Chain of Responsibility Pattern）命令模式（Command Pattern）解释器模式（Interpreter Pattern）迭代器模式（Iterator Pattern）中介者模式（Mediator Pattern）备忘录模式（Memento Pattern）观察者模式（Observer Pattern）状态模式（State Pattern）空对象模式（Null Object Pattern）策略模式（Strategy Pattern）模板模式（Template Pattern）访问者模式（Visitor Pattern）
J2EE 模式：这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。	MVC 模式（MVC Pattern）业务代表模式（Business Delegate Pattern）组合实体模式（Composite Entity Pattern）数据访问对象模式（Data Access Object Pattern）前端控制器模式（Front Controller Pattern）拦截过滤器模式（Intercepting Filter Pattern）服务定位器模式（Service Locator Pattern）传输对象模式（Transfer Object Pattern）

设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

意图：

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：

主要解决接口选择的问题。

何时使用：

明确地计划不同条件下创建不同实例时。

如何解决：

让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：

创建过程在其子类执行。

应用实例：

您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
Hibernate 换数据库只需换方言和驱动就可以。

优点：

一个调用者想创建一个对象，只要知道其名称就可以了。
扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景：

日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

注意事项：

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

代码实现：

public interface Pet {
    public void eat();
}

public class Cat implements Pet{
    @Override
    public void eat() {
        System.out.println("猫吃猫粮！！！");
    }
}

ublic class Dog implements Pet{
    @Override
    public void eat() {
        System.out.println("狗吃狗粮！！！");
    }
}

public class Fish implements Pet{
    @Override
    public void eat() {
        System.out.println("鱼吃鱼饲料！！！");
    }
}

public class PetFactory {
    public Pet getPet(String PetType){
        if(PetType == null){
            return null;
        }
        //equals() 会判断大小写区别，equalsIgnoreCase() 不会判断大小写区别
        if(PetType.equalsIgnoreCase("Cat")){
            return new Cat();
        } else if(PetType.equalsIgnoreCase("Dog")){
            return new Dog();
        } else if(PetType.equalsIgnoreCase("Fish")){
            return new Fish();
        }
        return null;
    }
}

public class Test {
    public static void main(String[] args) {
        //非工厂
        Pet dog = new Dog();
        System.out.println();
        dog.eat();
        Pet cat = new Cat();
        cat.eat();
        Pet fish = new Fish();
        fish.eat();
        //工厂
        PetFactory factory = new PetFactory();
        Pet pet1 = factory.getPet("Cat");
        pet1.eat();
        Pet pet2 = factory.getPet("Dog");
        pet2.eat();
        Pet pet3 = factory.getPet("Fish");
        pet3.eat();
    }
}

运行结果：

狗吃狗粮！！！
猫吃猫粮！！！
鱼吃鱼饲料！！！
猫吃猫粮！！！
狗吃狗粮！！！
鱼吃鱼饲料！！！

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

介绍

**意图：**提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

**主要解决：**主要解决接口选择的问题。

**何时使用：**系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

**如何解决：**在一个产品族里面，定义多个产品。

**关键代码：**在一个工厂里聚合多个同类产品。

**应用实例：**工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

**优点：**当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

**缺点：**产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。

**注意事项：**产品族难扩展，产品等级易扩展。

实现

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo 类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

步骤 1

为形状创建一个接口。

Shape.java

public interface Shape {   
    void draw(); 
}

步骤 2

创建实现接口的实体类。

Rectangle.java

Rectangle.java

public class Rectangle implements Shape {    
    @Override   
    public void draw() {      
        System.out.println("Inside Rectangle::draw() method.");   
    } 
}

Square.java

public class Square implements Shape {    
    @Override   
    public void draw() {      
        System.out.println("Inside Square::draw() method.");   
    } 
}

Circle.java

public class Circle implements Shape {    
    @Override   public void draw() {      
        System.out.println("Inside Circle::draw() method.");   
    } 
}

步骤 3

为颜色创建一个接口。

Color.java

public interface Color {   
    void fill(); 
}

步骤4

创建实现接口的实体类。

Red.java

public class Red implements Color {    
    @Override   public void fill() {      
        System.out.println("Inside Red::fill() method.");   
    } 
}

Green.java

public class Green implements Color {    
    @Override   
    public void fill() {      
        System.out.println("Inside Green::fill() method.");   
    } 
}

Blue.java

public class Blue implements Color {    
    @Override   public void fill() {      
        System.out.println("Inside Blue::fill() method.");   
    } 
}

步骤 5

为 Color 和 Shape 对象创建抽象类来获取工厂。

AbstractFactory.java

public abstract class AbstractFactory {   
    public abstract Color getColor(String color);  
    public abstract Shape getShape(String shape); 
}

步骤 6

创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

ShapeFactory.java

public class ShapeFactory extends AbstractFactory {       
    @Override   
    public Shape getShape(String shapeType){      
        if(shapeType == null){         
            return null;      
        }              
        if(shapeType.equalsIgnoreCase("CIRCLE")){         
            return new Circle();      
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){         
            return new Rectangle();      
        } else if(shapeType.equalsIgnoreCase("SQUARE")){        
            return new Square();      
        }      return null;   
    }      
    @Override   
    public Color getColor(String color) {      
        return null;   
    } 
}

ColorFactory.java

public class ColorFactory extends AbstractFactory {       
    @Override   
    public Shape getShape(String shapeType){      
        return null;   
    }      
    @Override   public Color getColor(String color) {      
        if(color == null){         
            return null;      
        }              
        if(color.equalsIgnoreCase("RED")){         
            return new Red();      
        } else if(color.equalsIgnoreCase("GREEN")){         
            return new Green();      
        } else if(color.equalsIgnoreCase("BLUE")){         
            return new Blue();      
        }      
        return null;   
    } 
}

步骤 7

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

FactoryProducer.java

public class FactoryProducer {   
    public static AbstractFactory getFactory(String choice){      
        if(choice.equalsIgnoreCase("SHAPE")){         
            return new ShapeFactory();      
        } else if(choice.equalsIgnoreCase("COLOR")){         
            return new ColorFactory();      
        }      
        return null;  
    } 
}

步骤 8

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

AbstractFactoryPatternDemo.java

public class AbstractFactoryPatternDemo {   
    public static void main(String[] args) {       
        //获取形状工厂      
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");       
        //获取形状为 Circle 的对象      
        Shape shape1 = shapeFactory.getShape("CIRCLE");       
        //调用 Circle 的 draw 方法      
        shape1.draw();       
        //获取形状为 Rectangle 的对象      
        Shape shape2 = shapeFactory.getShape("RECTANGLE");       
        //调用 Rectangle 的 draw 方法      
        shape2.draw();            
        //获取形状为 Square 的对象      
        Shape shape3 = shapeFactory.getShape("SQUARE");       
        //调用 Square 的 draw 方法      
        shape3.draw();       
        //获取颜色工厂      
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");       
        //获取颜色为 Red 的对象      
        Color color1 = colorFactory.getColor("RED");       
        //调用 Red 的 fill 方法      
        color1.fill();       
        //获取颜色为 Green 的对象      
        Color color2 = colorFactory.getColor("Green");       
        //调用 Green 的 fill 方法      
        color2.fill();       
        //获取颜色为 Blue 的对象      
        Color color3 = colorFactory.getColor("BLUE");       
        //调用 Blue 的 fill 方法      
        color3.fill();   
    } 
}

步骤 9

执行程序，输出结果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

**意图：**保证一个类仅有一个实例，并提供一个访问它的全局访问点。

**主要解决：**一个全局使用的类频繁地创建与销毁。

**何时使用：**当您想控制实例数目，节省系统资源的时候。

**如何解决：**判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

**关键代码：**构造函数是私有的。

应用实例：

1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

**缺点：**没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

**注意事项：**getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

代码实现：

public class SingleObject {
    //创建 SingleObject 的一个对象
    private static SingleObject instance = new SingleObject();
    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}
    //获取唯一可用的对象
    public static SingleObject getInstance(){
        return instance;
    }
    public void showMessage(){
        System.out.println("Hello World!");
    }
}

public class Test {
    public static void main(String[] args) {
        //SingleObject singleObject = new SingleObject();
        //报错：java: SingleObject()可以在stu.Patern.demo2.SingleObject中访问private
        //原因为该类的构造器是私有的，无法访问
        SingleObject singleObject = SingleObject.getInstance();
        singleObject.showMessage();

    }

懒汉模式与饿汉模式

**1.懒汉模式：**顾名思义，他是一个懒汉，他不愿意动弹。什么时候需要吃饭了，他就什么时候开始想办法搞点食物。

即懒汉式一开始不会实例化，什么时候用就什么时候new，才进行实例化。

**2.饿汉模式：**顾名思义，他是一个饿汉，他很勤快就怕自己饿着。他总是先把食物准备好，什么时候需要吃了，他随时拿来吃，不需要临时去搞食物。

即饿汉式在一开始类加载的时候就已经实例化，并且创建单例对象，以后只管用即可。

3.懒汉式代码实现：

public class Singleton {
　//默认不会实例化，什么时候用就什么时候new
    private static Singleton instance = null;
    private Singleton(){

    }
    public static synchronized Singleton getInstance(){
        if(instance == null){
　　　//什么时候用就什么时候new
            instance = new Singleton();
        }·
        return instance;
    }
}

4.饿汉式代码实现:

public class Singleton {
　//一开始类加载的时候就实例化，创建单实例对象
    private static Singleton instance = new Singleton();
    private Singleton(){

    }
    public static Singleton getInstance(){
        return instance;
    }
}

5.懒汉式和饿汉式的安全和性能区别：

（1）线程安全：饿汉式在线程还没出现之前就已经实例化了，所以饿汉式一定是线程安全的。懒汉式加载是在使用时才会去new 实例的，那么你去new的时候是一个动态的过程，是放到方法中实现的，比如：

public static synchronized Singleton getInstance(){
　 if(instance == null){
　　　　　//什么时候用就什么时候new
　　instance = new Singleton();
　 }

如果这个时候有多个线程访问这个实例，这个时候实例还不存在，还在new，就会进入到方法中，有多少线程就会new出多少个实例。一个方法只能return一个实例，那最终return出哪个呢？是不是会覆盖很多new的实例？这种情况当然也可以解决，那就是加同步锁，避免这种情况发生。

（2）执行效率：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。
（3）内存使用：饿汉式在一开始类加载的时候就实例化，无论使用与否，都会实例化，所以会占据空间，浪费内存。懒汉式什么时候用就什么时候实例化，不浪费内存。

代理模式

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

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

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

主要解决：

在直接访问对象时带来的问题

比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
就是在不修改原来代码的基础上，对原有的功能进行增强

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

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

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

应用实例：

Windows 里面的快捷方式。
买火车票不一定在火车站买，也可以去代售点。
一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。
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、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

代码实现：

1、增加业务

2、避免直接访问(直接访问会带来的一系列问题，如操作需要安全控制、、、)

public interface Image {
    void display();
}

public class RealImage implements Image{
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        System.out.println("display "+fileName);
    }

    private  void loadFromDisk(String fileName){
        System.out.println("Loading "+fileName);
    }

}

public class RealImage implements Image{
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        System.out.println("display "+fileName);
    }

    private  void loadFromDisk(String fileName){
        System.out.println("Loading "+fileName);
    }

}

public class ProxyPatternDemo {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");
        //图像将从磁盘加载
        image.display();
        System.out.println("");
        //图像不需要从磁盘中加载
        image.display();
    }
}

静态代理与动态代理的区别

原因：

1，通过DRP这个项目，了解到了动态代理，认识到我们之前一直使用的都是静态代理，那么动态代理又有什么好处呢？它们二者的区别是什么呢？

2，通过学习动态代理了解到动态代理是一种符合AOP设计思想的技术，那么什么又是AOP?

理解

代理Proxy：

Proxy代理模式是一种结构型设计模式，主要解决的问题是：在直接访问对象时带来的问题

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

更通俗的说，代理解决的问题当两个类需要通信时，引入第三方代理类，将两个类的关系解耦，让我们只了解代理类即可，而且代理的出现还可以让我们完成与另一个类之间的关系的统一管理，但是切记，代理类和委托类要实现相同的接口，因为代理真正调用的还是委托类的方法。

使用场合举例：

如果需要委托类处理某一业务，那么我们就可以先在代理类中统一处理然后在调用具体实现类

按照代理的创建时期，代理类可以分为两种：

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

动态：在程序运行时运用反射机制动态创建而成。

下面分别用静态代理与动态代理演示一个示例：

添加打印日志的功能，即每个方法调用之前和调用之后写入日志

静态代理：

具体用户管理实现类

public class UserManagerImpl implements UserManager {

@Override
public void addUser(String userId, String userName) {
	System.out.println("UserManagerImpl.addUser");
}
 
@Override
public void delUser(String userId) {
	System.out.println("UserManagerImpl.delUser");
}
 
@Override
public String findUser(String userId) {
	System.out.println("UserManagerImpl.findUser");
	return "张三";
}
 
@Override
public void modifyUser(String userId, String userName) {
	System.out.println("UserManagerImpl.modifyUser");
 
}

}
代理类–代理用户管理实现类

public class UserManagerImplProxy implements UserManager {

// 目标对象
private UserManager userManager;
// 通过构造方法传入目标对象
public UserManagerImplProxy(UserManager userManager){
	this.userManager=userManager;
}
@Override
public void addUser(String userId, String userName) {
	try{
			//添加打印日志的功能
			//开始添加用户
			System.out.println("start-->addUser()");
			userManager.addUser(userId, userName);
			//添加用户成功
			System.out.println("success-->addUser()");
		}catch(Exception e){
			//添加用户失败
			System.out.println("error-->addUser()");
		}
}
 
@Override
public void delUser(String userId) {
	userManager.delUser(userId);
}
 
@Override
public String findUser(String userId) {
	userManager.findUser(userId);
	return "张三";
}
 
@Override
public void modifyUser(String userId, String userName) {
	userManager.modifyUser(userId,userName);
}

}

客户端调用

public class Client {

public static void main(String[] args){
	//UserManager userManager=new UserManagerImpl();
	UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());
	userManager.addUser("1111", "张三");
}

}
静态代理类优缺点

优点：

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。

缺点：

1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）

即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

引入动态代理：

根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类

所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理

在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

java.lang.reflect.InvocationHandler接口的定义如下：

//Object proxy:被代理的对象
//Method method:要调用的方法
//Object[] args:方法调用时所需要参数
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

java.lang.reflect.Proxy类的定义如下：
//CLassLoader loader:类的加载器
//Class<?> interfaces:得到全部的接口
//InvocationHandler h:得到InvocationHandler接口的子类的实例
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

动态代理：

具体实现类

public class UserManagerImpl implements UserManager {

@Override
public void addUser(String userId, String userName) {
	System.out.println("UserManagerImpl.addUser");
}
 
@Override
public void delUser(String userId) {
	System.out.println("UserManagerImpl.delUser");
}
 
@Override
public String findUser(String userId) {
	System.out.println("UserManagerImpl.findUser");
	return "张三";
}
 
@Override
public void modifyUser(String userId, String userName) {
	System.out.println("UserManagerImpl.modifyUser");
 
}

}

动态创建代理对象的类

//动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类

public class LogHandler implements InvocationHandler {

// 目标对象
private Object targetObject;
//绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。            
public Object newProxyInstance(Object targetObject){
	this.targetObject=targetObject;
	//该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
	//第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
	//第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
	//第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
	//根据传入的目标返回一个代理对象
	return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
			targetObject.getClass().getInterfaces(),this);
}
@Override
//关联的这个实现类的方法被调用时将被执行
/*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/
public Object invoke(Object proxy, Method method, Object[] args)
		throws Throwable {
	System.out.println("start-->>");
	for(int i=0;i<args.length;i++){
		System.out.println(args[i]);
	}
	Object ret=null;
	try{
		/*原对象方法调用前处理日志信息*/
		System.out.println("satrt-->>");
		
		//调用目标方法
		ret=method.invoke(targetObject, args);
		/*原对象方法调用后处理日志信息*/
		System.out.println("success-->>");
	}catch(Exception e){
		e.printStackTrace();
		System.out.println("error-->>");
		throw e;
	}
	return ret;
}

}
被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。

客户端代码

public class Client {

public static void main(String[] args){
	LogHandler logHandler=new LogHandler();
	UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());
	//UserManager userManager=new UserManagerImpl();
	userManager.addUser("1111", "张三");
}

}

可以看到，我们可以通过LogHandler代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是AOP(面向切面编程)的基本原理。

插曲：

AOP（AspectOrientedProgramming）：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码—解耦。

针对如上的示例解释：

我们来看上面的UserManagerImplProxy类，它的两个方法System.out.println(“start–>addUser()”)和System.out.println(“success–>addUser()”)，这是做核心动作之前和之后的两个截取段，正是这两个截取段，却是我们AOP的基础，在OOP里，System.out.println(“start–>addUser()”)、核心动作、System.out.println(“success–>addUser()”)这个三个动作在多个类里始终在一起，但他们所要完成的逻辑却是不同的，如System.out.println(“start–>addUser()”)里做的可能是权限的判断，在所有类中它都是做权限判断，而在每个类里核心动作却各不相同，System.out.println(“success–>addUser()”)可能做的是日志，在所有类里它都做日志。正是因为在所有的类里，核心代码之前的操作和核心代码之后的操作都做的是同样的逻辑，因此我们需要将它们提取出来，单独分析，设计和编码，这就是我们的AOP思想。一句话说，AOP只是在对OOP的基础上进行进一步抽象，使我们的类的职责更加单一。

动态代理优点：

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强

总结：

其实所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。

代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先翻墙，然后再访问facebook。这就是代理的作用了。

纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！

MVC 模式

MVC 模式代表 Model-View-Controller（模型-视图-控制器）模式。这种模式用于应用程序的分层开发。为了更好的分层，重用，降低依赖性，就有了MVC，由M层接受和绑定用户的数据，V层进行展现，C层进行控制。

Model（模型） - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。
View（视图） - 视图代表模型包含的数据的可视化。
Controller（控制器） - 控制器作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。

代码实现：

public class M_Student {
    String name;
    String no ;

    public String getName() {
        return name;
    }

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

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }
}

public class View_Student {
    public void printStudentDetails(String studentName, String studentRollNo){
        System.out.println("Student: ");
        System.out.println("Name: " + studentName);
        System.out.println("No: " + studentRollNo);
    }
}

public class Controller_Student {
    private M_Student model;
    private View_Student view;
    public Controller_Student(M_Student model, View_Student view){
        this.model = model;
        this.view = view;
    }
    public void setStudentName(String name){
        model.setName(name);
    }

    public String getStudentName(){
        return model.getName();
    }
    public void setStudentRollNo(String no){
        model.setNo(no);
    }
    public String getStudentRollNo(){
        return model.getNo();
    }
    public void updateView(){
        view.printStudentDetails(model.getName(), model.getNo());
    }
}

public class MVCDemo {
    public static void main(String[] args) {
        //从数据库获取学生记录
        M_Student model  = retrieveStudentFromDatabase();
        //创建一个视图：把学生详细信息输出到控制台
        View_Student view = new View_Student();
        Controller_Student controller = new Controller_Student(model, view);
        controller.updateView();
        //更新模型数据
        controller.setStudentName("John");
        controller.updateView();
    }
    private static M_Student retrieveStudentFromDatabase(){
        M_Student student = new M_Student();
        student.setName("Robert");
        student.setNo("10");
        return student;
    }
}

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

public String getStudentName(){
    return model.getName();
}
public void setStudentRollNo(String no){
    model.setNo(no);
}
public String getStudentRollNo(){
    return model.getNo();
}
public void updateView(){
    view.printStudentDetails(model.getName(), model.getNo());
}

}


```java
public class MVCDemo {
    public static void main(String[] args) {
        //从数据库获取学生记录
        M_Student model  = retrieveStudentFromDatabase();
        //创建一个视图：把学生详细信息输出到控制台
        View_Student view = new View_Student();
        Controller_Student controller = new Controller_Student(model, view);
        controller.updateView();
        //更新模型数据
        controller.setStudentName("John");
        controller.updateView();
    }
    private static M_Student retrieveStudentFromDatabase(){
        M_Student student = new M_Student();
        student.setName("Robert");
        student.setNo("10");
        return student;
    }
}