java设计模式（部分转载）

最新推荐文章于 2024-04-16 17:40:41 发布

qq_44741982

最新推荐文章于 2024-04-16 17:40:41 发布

阅读量84

点赞数

分类专栏： java23种设计模式文章标签： java

本文链接：https://blog.csdn.net/qq_44741982/article/details/108861484

版权

java23种设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

23种设计模式（部分模式）

oop七大原则

开闭原则：对扩展开放，对修改关闭

里氏替换原则：继承必须确保超类所拥有的性质在子类种仍然成立

依赖倒置原则：要面向接口编程卖不要面对现实编程

单一职责原则：控制类的粒度大小，将对象解耦，提高它的内聚性

接口隔离原则：要为各个类建立他们需要的专用接口

迪米特原则：至于你的直接朋友交谈，不跟“陌生人”说话

合成复用原则：尽量先使用或者聚合等关联关系来实现，其次在考虑使用继承关系来实现

设计这模式主要分为三种大类：

创建型模式结构型模式行为型模式

创建型模式

单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式

单例模式

单例模式注意点

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

单例模式优点和缺点

优点：
1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2. 避免对资源的多重占用（比如写文件操作）。
缺点：
- 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
饿汉式单例模式
```
public class Hungry{
// 类初始化时,会立即加载该对象，线程天生安全,调用效率高
private static Hungry hungry = new Hungry();

    private Hungry() {
        System.out.println("SingletonDemo01初始化");
    }

    public static Hungry getInstance() {
        System.out.println("getInstance");
        return hungry;
    }

    public static void main(String[] args) {
        Hungry s1 = Hungry.getInstance();
        Hungry s2 = Hungry.getInstance();
        System.out.println(s1 == s2);
    }

}
```
懒汉式单例模式

懒汉式：类初始化时，不会初始化该对象，真正需要使用的时候才会去创建该对象，具备懒加载功能。

是否Lazy初始化：是

是否多线程安全：否

实现难度：易

描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class LazyMan{

	//类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
	   private static LazyMan lazyMan;

    private LazyMan() {

    }

    public synchronized static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    public static void main(String[] args) {
        LazyMan s1 = LazyMan.getInstance();
        LazyMan s2 = LazyMan.getInstance();
        System.out.println(s1 == s2);
    }
}

静态内部类

优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。

劣势：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久带的对象。

public class SingleStatic {
	private SingleStatic() {
           System.out.println("初始化..");
	}
 
	public static class SingletonClassInstance {
		private static final SingleStatic singletonDemo03 = new SingleStatic();
	}
 
	// 方法没有同步
	public static SingleStatic getInstance() {
		System.out.println("getInstance");
		return SingletonClassInstance.singletonDemo03;
	}
 
	public static void main(String[] args) {
		SingleStatic s1 = SingleStatic.getInstance();
		SingleStatic s2 = SingleStatic.getInstance();
		System.out.println(s1 == s2);
	}
}

枚举单例

枚举单例：使用枚举实现单例模式，实现简单、调用效率高，枚举本身就是单例，由JVM从根本上提供保障，避免通过反射和反序列化的漏洞，缺点是没有延迟加载。

public class User {
	public static User getInstance() {
		return SingletonDemo04.INSTANCE.getInstance();
	}
 
	private static enum SingletonDemo04 {
		INSTANCE;
		// 枚举元素为单例
		private User user;
 
		private SingletonDemo04() {
			System.out.println("SingletonDemo04");
			user = new User();
		}
 
		public User getInstance() {
			return user;
		}
	}
 
	public static void main(String[] args) {
		User u1 = User.getInstance();
		User u2 = User.getInstance();
		System.out.println(u1 == u2);
	}
}

双重检测锁

双重检测方式（因为JVM本身重排序的原因，可能会出现多次的初始化）

public class SingletonDemo04 {
	private volatile static SingletonDemo04 singletonDemo04;
 
	private SingletonDemo04() {
 
	}
 
	public SingletonDemo04 getInstance() {
		if (singletonDemo04 == null) {
			synchronized (this) {
				if (singletonDemo04 == null) {
					singletonDemo04 = new SingletonDemo04();
				}
			}
		}
		return singletonDemo04;
	}
 
}

工厂模式

工厂模式分三种：普通工厂模式，静态工厂模式

普通工厂模式

首先创建共同接口

public interface Sender {  
    public void Send();  
}

实现创建类

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}  
public class SmsSender implements Sender {  
  
    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}

建立工厂类

public class SendFactory {  
  
    public Sender produce(String type) {  
        if ("mail".equals(type)) {  
            return new MailSender();  
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }  
}

测试类如下：

public class FactoryTest {  
  
    public static void main(String[] args) {  
        SendFactory factory = new SendFactory();  
        Sender sender = factory.produceMail();  
        sender.Send();  
    }  
}

多个工厂方法模式

多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

将上面的代码做下修改，改动下SendFactory类就行，如下：

public class SendFactory {  
   public Sender produceMail(){  
        return new MailSender();  
    }  
      
    public Sender produceSms(){  
        return new SmsSender();  
    }  
}

静态工厂方法模式

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class SendFactory {  
      
    public static Sender produceMail(){  
        return new MailSender();  
    }  
      
    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}

测试类

public class FactoryTest {  
  
    public static void main(String[] args) {      
        Sender sender = SendFactory.produceMail();  
        sender.Send();  
    }  
}

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

抽象工厂模式

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。

公共接口

public interface Sender {  
    public void Send();  
}

实现类

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}  
public class SmsSender implements Sender {  
  
    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}

再提供一个公共接口

public interface Provider {  
    public Sender produce();  
}

两个工厂类

public class SendMailFactory implements Provider {  
      
    @Override  
    public Sender produce(){  
        return new MailSender();  
    }  
}  
public class SendSmsFactory implements Provider{  
  
    @Override  
    public Sender produce() {  
        return new SmsSender();  
    }  
}

测试类

public class Test {  
  
    public static void main(String[] args) {  
        Provider provider = new SendMailFactory();  
        Sender sender = provider.produce();  
        sender.Send();  
    }  
}

这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

但是这个代码复杂性高，代码多，实际运用少。

结构型模式

适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式

代理模式

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，***代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等*。**代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bGLYB3R6-1601340259015)(C:\Users\17765\AppData\Roaming\Typora\typora-user-images\1599553509463.png)]

代理模式分为静态代理和动态代理

静态代理

静态代理：由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口、被代理类、代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成。

静态代理实例：假如一个班的同学要向老师交班费，但是都是通过班长把自己的钱转交给老师。这里，班长代理学生上交班费，班长就是学生的代理。

1.确定创建接口的具体行为：

首先，我们创建一个Person接口。这个接口就是学生（被代理类），和班长（代理类）的公共接口，他们都有上交班费的行为。这样，学生上交班费就可以让班长来代理执行。

/**
 * 创建Person接口
 */
public interface Person {
    //上交班费
    void giveMoney();
}

2.被代理对象实现接口，完成具体的业务逻辑：

Student类实现Person接口。Student可以具体实施上交班费的动作：

public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
       System.out.println(name + "上交班费50元");
    }
}

3.代理类实现接口，完成委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

StudentsProxy类，这个类也实现了Person接口，但是还另外持有一个学生类对象。由于实现了Peson接口，同时持有一个学生对象，那么他可以代理学生类对象执行上交班费（执行giveMoney()方法）行为。

/**
 * 学生代理类，也实现了Person接口，保存一个学生实体，这样既可以代理学生产生行为
 * @author Gonjan
 *
 */
public class StudentsProxy implements Person{
    //被代理的学生
    Student stu;
    
    public StudentsProxy(Person stu) {
        // 只代理学生对象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班费，调用被代理学生的上交班费行为
    public void giveMoney() {
        stu.giveMoney();
    }
}

4.客户端使用操作与分析

public class StaticProxyTest {
    public static void main(String[] args) {
        //被代理的学生张三，他的班费上交有代理对象monitor（班长）完成
        Person zhangsan = new Student("张三");
        
        //生成代理对象，并将张三传给代理对象
        Person monitor = new StudentsProxy(zhangsan);
        
        //班长代理上交班费
        monitor.giveMoney();
    }
}

这里并没有直接通过张三（被代理对象）来执行上交班费的行为，而是通过班长（代理对象）来代理执行了，这就是代理模式。

代理模式最主要的就是有一个公共接口（Person），一个具体的类（Student），一个代理类（StudentsProxy），代理类持有具体类的实例，代为执行具体类实例方法。上面说到，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。这里的间接性就是指不直接调用实际对象的方法，那么我们在代理过程中就可以加上一些其他用途。就这个例子来说，加入班长在帮张三上交班费之前想要先反映一下张三最近学习有很大进步，通过代理模式很轻松就能办到：

public class StudentsProxy implements Person{
    //被代理的学生
    Student stu;
    
    public StudentsProxy(Person stu) {
        // 只代理学生对象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班费，调用被代理学生的上交班费行为
    public void giveMoney() {
        System.out.println("张三最近学习有进步！");
        stu.giveMoney();
    }
}

只需要在代理类中帮张三上交班费之前，执行其他操作就可以了。这种操作，也是使用代理模式的一个很大的优点。最直白的就是在Spring中的面向切面编程（AOP），我们能在一个切点之前执行一些操作，在一个切点之后执行一些操作，这个切点就是一个个方法。这些方法所在类肯定就是被代理了，在代理过程中切入了一些其他操作。其实也是切面思想的主要思路，这个后面会出一篇博客，并且举例怎么使用，想法是：对controller层出入参进行检验和必要的操作等，Spring源码里面也有许多这样的例子，后期有时间整理。

动态代理

代理类在程序运行时创建的代理方式被成为动态代理。

我们上面静态代理的例子中，代理类(studentProxy)是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。 比如说，想要在每个代理的方法前都加上一个处理方法：

public void giveMoney() {
        //调用被代理方法前加入处理方法
        beforeMethod();
        stu.giveMoney();
    }

这里只有一个giveMoney方法，就写一次beforeMethod方法，但是如果除了giveMonney还有很多其他的方法，那就需要写很多次beforeMethod方法，麻烦。所以建议使用动态代理实现。

动态代理的简单实现

在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

1.确定创建接口具体行为

/**
 * 创建Person接口
 */
public interface Person {
    //上交班费
    void giveMoney();
}

2.被代理对象实现接口，完成具体的业务逻辑（此处增加一些方法用于检测后面使用动态代理用于区分）

Student类实现Person接口。

public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
        try {
            //假设数钱花了一秒时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       System.out.println(name + "上交班费50元");
    }
}

再定义一个检测方法执行时间的工具类，在任何方法执行前先调用start方法，执行后调用finsh方法，就可以计算出该方法的运行时间，这也是一个最简单的方法执行时间检测工具。

public class MonitorUtil {
    
    private static ThreadLocal<Long> tl = new ThreadLocal<>();
    
    public static void start() {
        tl.set(System.currentTimeMillis());
    }
    
    //结束时打印耗时
    public static void finish(String methodName) {
        long finishTime = System.currentTimeMillis();
        System.out.println(methodName + "方法耗时" + (finishTime - tl.get()) + "ms");
    }
}

3.代理类实现接口，完成委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

创建StuInvocationHandler类，实现InvocationHandler接口，这个类中持有一个被代理对象的实例target。InvocationHandler中有一个invoke方法，所有执行代理对象的方法都会被替换成执行invoke方法。在invoke方法中执行被代理对象target的相应方法。在代理过程中，我们在真正执行被代理对象的方法前加入自己其他处理。这也是Spring中的AOP实现的主要原理，这里还涉及到一个很重要的关于java反射方面的基础知识。

public class StuInvocationHandler<T> implements InvocationHandler {
    //invocationHandler持有的被代理对象
    T target;
    
    public StuInvocationHandler(T target) {
       this.target = target;
    }
    
    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行" +method.getName() + "方法");  
        //代理过程中插入监测方法,计算该方法耗时
        MonitorUtil.start();
        Object result = method.invoke(target, args);
        MonitorUtil.finish(method.getName());
        return result;
    }
}

4.客户端使用操作与分析

public class ProxyTest {
    public static void main(String[] args) {
        
        //创建一个实例对象，这个对象是被代理的对象
        Person zhangsan = new Student("张三");
        
        //创建一个与代理对象相关联的InvocationHandler
        InvocationHandler stuHandler = new StuInvocationHandler<Person>(zhangsan);
        
        //创建一个代理对象stuProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);
 
       //代理执行上交班费的方法
        stuProxy.giveMoney();
    }
}

创建了一个需要被代理的学生张三，将zhangsan对象传给了stuHandler中，我们在创建代理对象stuProxy时，将stuHandler作为参数了的，上面也有说到所有执行代理对象的方法都会被替换成执行invoke方法，也就是说，最后执行的是StuInvocationHandler中的invoke方法。

动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。是因为所有被代理执行的方法，都是通过在InvocationHandler中的invoke方法调用的，所以我们只要在invoke方法中统一处理，就可以对所有被代理的方法进行相同的操作了。例如，这里的方法计时，所有的被代理对象执行的方法都会被计时，然而我只做了很少的代码量。

动态代理的过程，代理对象和被代理对象的关系不像静态代理那样一目了然，清晰明了。因为动态代理的过程中，我们并没有实际看到代理类，也没有很清晰地的看到代理类的具体样子，而且动态代理中被代理对象和代理对象是通过InvocationHandler来完成的代理过程的，其中具体是怎样操作的，为什么代理对象执行的方法都会通过InvocationHandler中的invoke方法来执行。带着这些问题，我们就需要对java动态代理的源码进行简要的分析，弄清楚其中缘由。

动态代理的好处：

可以使真实的校色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给代理角色，实现了业务分工
公共业务发生扩展的时候，方便集中管理
一个动态代理类代理的是一个接口，一般对应一类业务
一个动态代理类可以代理多个类，只是实现了一个接口即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1kYn1RTq-1601340259020)(C:\Users\17765\AppData\Roaming\Typora\typora-user-images\1599566366948.png)]

动态代理分为两大类：基于接口的动态代理，基于类的动态代理

* 基于接口--jdk动态代理 【我们在这里使用原生的】
* 基于类：cglib
* java字节码实现：javasist

要知道的两个类：Proxy InvocationHandler

InvocationHandler 是由代理实例的调用处理程序实现的接口

每个代理实例都有一个关联的调用处理程序，当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法

行为型模式

模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式,职责链模式，访问者模式

（博客是我之前学习设计者模式记的笔记，部分是来自其他人博客，忘了链接地址，侵权删）

qq_44741982

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java设计模式（部分转载）

23种设计模式部分oop七大原则开闭原则：对扩展开放，对修改关闭里氏替换原则：继承必须确保超类所拥有的性质在子类种仍然成立依赖倒置原则：要面向接口编程卖不要面对现实编程单一职责原则：控制类的粒度大小，将对象解耦，提高它的内聚性接口隔离原则：要为各个类建立他们需要的专用接口迪米特原则：至于你的直接朋友交谈，不跟“陌生人”说话合成复用原则：尽量先使用或者聚合等关联关系来实现，其次在考虑使用继承关系来实现创建型模式单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式单例模式单例模式注意点
复制链接

扫一扫