Spring框架当中的设计模式

1.单列模式

Bean默认为单列模式
也就是说，为了简化操作，我们不用每次要使用一个对象的时候要去重新创建它，而是只需要在spring.xml当中利用bean进行一定的配置就可以了
强调一下，在这里，单列模式分为懒汉模式和饿汉模式
懒汉模式就是每次在调用它的时候再创建，而饿汉模式是在调用它之前就进行的一个创建
下面首先来看懒汉模式

class LSingle{
 
private static Instance_instance = null;
 
private LSingle(){}
 
 
 
public static Instance getInstance(){
 
    if(_instance==null){
 
    _instance = new Instance();
 
    }
 
}

下面是饿汉式：

class ESingle{
 
private static Instance_instance = new Instance;//注意区别,直接作为成员对象创建
 
private ESingle(){}
 
 
 
    public static Instance getInstance(){
 
        return _instance;//直接返回之前已经创建好的实例
 
    }
 

首先我们来说明一下饿汉式的优点就是确保了即使在多线程的环境下也可以保证一个实例的目的。

2.工厂模式

首先我要说的就是，工厂模式分为三种，一种是简单工厂模式，第二种是工厂方法模式，第三种是抽象工厂模式。
简单工厂模式
是由一个工厂对象决定创建出哪一个产品类的实例

package simpleFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/14
 * Time: 23:26
 * Description: 课程接口类
 */
public interface ICourse {
    /**
     * 录制视频
     */
    void record();
}

JavaCourse.java

package simpleFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/14
 * Time: 23:27
 * Description: No Description
 */
public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制Java课程");
    }
}

PythonCourse.java

package simpleFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/14
 * Time: 23:29
 * Description: No Description
 */
public class PythonCourse implements ICourse{
    public void record() {
        System.out.println("录制Python课程");
    }
}

CourseFactory.java

package simpleFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/14
 * Time: 23:31
 * Description: No Description
 */
public class CourseFactory {
    public ICourse create(Class<? extends ICourse> clazz) {
        try {
            if (null != clazz) {
                return clazz.newInstance();
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }
}

SimpleFactoryMain.java

package simpleFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/14
 * Time: 23:30
 * Description: No Description
 */
public class SimpleFactoryMain {
    public static void main(String[] args) {
        CourseFactory factory = new CourseFactory();
        ICourse javaCourse = factory.create(JavaCourse.class);
        javaCourse.record();
        ICourse pythonCourse = factory.create(PythonCourse.class);
        pythonCourse.record();
    }
}

工厂方法模式
工厂方法模式是指定义一个创建对象的接口，但实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行

package task;

public interface IPay {
    void pay();
}

IIPayOut.java

package task;

public interface IIPayOut extends IPay {
}

IIPayIn.java

package task;

public interface IIPayIn extends IPay {
}

OtherIPay.java

package task;

public class OtherIPay implements IIPayOut {

    public void pay() {
        System.out.println("其他国外支付");
    }
}

AppleIPay.java

package task;

public class AppleIPay implements IIPayOut {
    public void pay() {
        System.out.println("苹果支付");
    }
}

WeIPay.java

package task;

public class WeIPay implements IIPayIn {
    public void pay() {
        System.out.println("微信支付");
    }
}

UniIPay.java

package task;

public class UniIPay implements IIPayIn {
    public void pay() {
        System.out.println("银联支付");
    }
}

AliIPay.java

package task;

public class AliIPay implements IIPayIn {
    public void pay() {
        System.out.println("支付宝支付！");
    }
}

IPayFactory.java

package task;

public interface IPayFactory {
    IPay create();
}

IPayOutFactory.java

package task;

public interface IPayOutFactory extends IPayFactory{
}

IPayInFactory.java

package task;

public interface IPayInFactory extends IPayFactory{
}

OtherPayFactory.java

package task;

public class OtherPayFactory implements IPayOutFactory{
    public IIPayOut create() {
        return new OtherIPay();
    }
}

ApplePayFactory.java

package task;

public class ApplePayFactory implements IPayOutFactory{
    public IIPayOut create() {
        return new AppleIPay();
    }
}

WePayFactory.java

package task;

public class WePayFactory implements IPayInFactory{
    public IIPayIn create() {
        return new WeIPay();
    }
}

AliPayFactory.java

package task;

public class AliPayFactory implements IPayInFactory{
    public IIPayIn create() {
        return new AliIPay();
    }
}

UniPayFactory.java

package task;

public class UniPayFactory implements IPayInFactory{
    public IIPayIn create() {
        return new UniIPay();
    }
}

TaskMain.java

package task;

public class TaskMain {
    public static void main(String[] args) {
        IPayInFactory factoryIn = new AliPayFactory();
        IPay payIn = factoryIn.create();
        payIn.pay();

        IPayOutFactory factoryOut = new ApplePayFactory();
        IPay payOut = factoryOut.create();
        payOut.pay();
    }
}

抽象工厂模式

抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类。
属于创建型设计模式

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:13
 * Description: No Description
 */
public interface IVideo {
    void record();
}

JavaVideo.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:27
 * Description: No Description
 */
public class JavaVideo implements IVideo{
    @Override
    public void record() {
        System.out.println("录制Java视频");
    }
}

PythonVideo.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:28
 * Description: No Description
 */
public class PythonVideo implements IVideo{
    @Override
    public void record() {
        System.out.println("录制python视频");
    }
}

INote.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:12
 * Description: No Description
 */
public interface INote {
    void edit();
}

JavaNote.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:14
 * Description: No Description
 */
public class JavaNote implements INote {

    @Override
    public void edit() {
        System.out.println("记录Java笔记");
    }
}

PythonNote.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:26
 * Description: No Description
 */
public class PythonNote implements INote {

    @Override
    public void edit() {
        System.out.println("记录python笔记");
    }
}

CourseFactory.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 14:29
 * Description: No Description
 */
public abstract class CourseFactory {

    public void init(){
        System.out.println("初始化");
    }

    protected abstract INote createNote();

    protected abstract IVideo createVideo();
}

JavaCourseFactory.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 15:21
 * Description: No Description
 */
public class JavaCourseFactory extends CourseFactory {

    public INote createNote() {
        super.init();
        return new JavaNote();
    }

    public IVideo createVideo() {
        super.init();
        return new JavaVideo();
    }
}

PythonCourseFactory.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 15:21
 * Description: No Description
 */
public class PythonCourseFactory extends CourseFactory {

    public INote createNote() {
        super.init();
        return new PythonNote();
    }


    public IVideo createVideo() {
        super.init();
        return new PythonVideo();
    }
}

AbstractFactoryMain.java

package abstractFactory;

/**
 * Created with IntelliJ IDEA.
 * User: 轩辕龙儿
 * Date: 2021/3/17
 * Time: 15:22
 * Description: No Description
 */
public class AbstractFactoryMain {
    public static void main(String[] args) {

        JavaCourseFactory factory = new JavaCourseFactory();
        factory.createNote().edit();
        factory.createVideo().record();

    }
}

3.模板方法模式

说到模板方法设计模式，就是说明，在这个过程当中，定义一个方法，然后在里面进行定义一些方法，然后进行编写之后，通过创建对应的实体类，然后就可以达到对应的解释

public abstract class Animal {
	//这个方法，子类不能去改变
	public final void takeShower(){
		//按照固定顺序执行
		showerStart();
		process();
	}
	abstract public void showerStart();
	abstract public void process();
}
 
class Cat extends Animal{
	@Override
	public void showerStart() {
		System.out.println("小猫——开始洗澡了");
	}
 
	@Override
	public void process() {
 
		System.out.println("小猫——洗澡中");
	}
}
 
class Dog extends Animal{
	@Override
	public void showerStart() {
		System.out.println("小狗——开始洗澡了");
	}
 
	@Override
	public void process() {
 
		System.out.println("小狗——洗澡中");
	}
}
class TestZoo{
	public static void main(String[] args) {
		Animal  c =new Cat();
		Animal  d =new Dog();
		c.takeShower();
		d.takeShower();
	}
}

4.代理模式

于Java中的动态代理，我们首先需要了解的是一种常用的设计模式–代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。

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

观察者模式

定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。