最早概念是在建筑领域产生的，后来被引入到软件开发领域。
模式是解决一类问题的固定写法，一个模式用来解决一种问题，经过反复优化，最终得出来的。之前的程序员们，在工作中对某一类问题解决方式进行总结归纳，一种问题对应着一个模式。设计模式就是在面向对象的基础上，更加合理的组织类与类之间的关系。
为什么学习设计模式?
学习别人的经验，拿来为我们所用，提高编程设计能力，让程序设计更加标准合理，提高开发效率。提高程序的维护性，能够看懂复杂的源码。
1、单例模式
解决的问题：在一个程序中，一个类只能创建一个对象。 举例：windows任务管理器，只能打开一个。
实现：把构造方法私有化，在其他类中不能访问了，不能创建对象。可以在单例类中，向外界提供一个方法，访问到唯一的单例对象。
1.饿汉式单例(急切式)
在类加载时就创建唯一的对象，不存在线程安全问题
public class Window {
//饿汉式单例, 静态的成员在类被加载时,就将唯一的window对象创建
//没有任何的线程安全问题
private static Window window = new Window();
private Window(){}
//调用getWindow，返回对象即可
public static Window getWindow(){
return window;
}
}public class Test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
System.out.println(Window.getWindow());
}).start();
}
}
}Runtime类属于典型的单例设计，从源码中可以看出是饿汉式单例。利用Runtime类可以启动新的进程或进行相关运行时环境的操作。比如，取得内存空间以及释放垃圾空间。
Runtime.getRuntime();
2.懒汉式
在类加载的时候不创建对象，在使用时创建，生成对象的数量就需要我们自己来进行控制。
但是会出现线程安全问题：在多线程访问时，可能会有多个线程同时进行到if，就会创建出多个对象。
线程安全问题的解决：
1、给方法加锁，虽然可以解决，但是效率低，一次只能有一个线程进入获取。
public class Window {
//在类加载的时候不创建改类的对象，在第一次获取单例对象时创建
private static Window window=null;
private Window(){}
public static synchronized Window getWindow(){
if(window==null){
window = new Window();
}
return window;
}
}public class Test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
System.out.println(Window.getWindow());
}).start();
}
}
}2、给代码块加锁，双重检索+volatile
window = new Window();这一句代码可以分为3条指令执行，万一指令重排序，会导致出现一个半成品对象返回。
为什么双重检索？先确保有一个线程把对象new出来，后面的线程来了之后，只要走第一个判断就好了。一旦对象创建之后，之后效率就变高了，不用进入同步代码块里面了。
public class Window {
//禁止整个过程中指令重排
private static volatile Window window=null;
private Window(){}
public static Window getWindow(){
if(window==null){//如果没有的话，相当于给方法加锁
synchronized(Window.class){
if(window == null){//如果没有的话，相当于没有加锁
window = new Window();
}//一旦对象创建之后，之后效率就变高了，不用进入同步代码块里面了
}
}
return window;
}
}2、工厂模式
工厂--->生产对象--->spring（把创建对象的权利反转给spring框架，把创建对象和使用对象分离）
有一个工厂专门负责创建对象，使用对象时只需要找对应的工厂。根据我们产生对象的场景，需求的不同，又分为：简单工厂模式、工厂方法模式、抽象工厂模式。
1.简单工厂模式
工厂只有一个。一个工厂类负责同一类所有产品的创建；但是扩展不方便，如果增加或减少产品时，需要修改工厂类，违背了开闭原则。
该模式中包含的角色：
工厂：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类提供静态方法，可以被外界直接调用，创建所需的产品对象。
抽象产品：所有对象的父类，描述所有实例共有的接口。可以是抽象类或接口。
具体产品：是简单工厂模式的创建目标
优点：客户端不负责对象的创建，而是由专门的工厂类完成。客户端只负责对象的调用，实现了创建和调用的分离
缺点：扩展不方便，如果增加和减少子类，要修改简单工厂类，违反了开闭原则。
public interface Car {
void run();
}public class Aodi implements Car{
@Override
public void run() {
System.out.println("奥迪汽车行驶");
}
}public class Bmw implements Car{
@Override
public void run() {
System.out.println("宝马汽车行驶");
}
}public class CarFactory {
public static Car createCar(String name){
if(name.equals("aodi")){
Aodi aodi = new Aodi();
return aodi;
}
if(name.equals("bmw")){
return new Bmw();
}
return null;
}
}public class Test {
public static void main(String[] args) {
Car bmw = CarFactory.createCar("bmw");
Car aodi = CarFactory.createCar("aodi");
bmw.run();
aodi.run();
}
}2.工厂方法模式
添加一个抽象工厂，具体工厂实现抽象工厂。一个具体工厂负责创建一个具体的产品，即使这些产品是有联系的，也必须由不同的工厂分别创建。如果产品增加或减少，只增加产品子类和工厂子类，符合开闭原则。
- 抽象工厂：工厂方法模式的核心，任何在模式中创建的对象的工厂类必须实现这个接口。
- 具体工厂：实现抽象工厂接口的具体工厂类。
- 抽象产品：产品对象的共同父类或接口。
- 具体产品：实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往——对应。
好处：符合开闭原则。若增加和减少产品子类，只增加产品子类和工厂子类，不需要修改其他产品。
缺点：需要额外的编写代码，增加了工作量。
适用场景：所有的产品子类是同一类的、比较多的。
public interface Car {
void run();
}public class Aodi implements Car {
@Override
public void run() {
System.out.println("奥迪汽车行驶");
}
}public class Bmw implements Car {
@Override
public void run() {
System.out.println("宝马汽车行驶");
}
}public interface CarFactory {
Car createCar();
}public class AodiFactory implements CarFactory{
@Override
public Car createCar() {
return new Aodi();
}
}public class BmwFactory implements CarFactory{
@Override
public Car createCar() {
return new Bmw();
}
}3.抽象工厂模式
一个工厂创建一个系列的产品，可以造出这个厂家所有的产品。例如华为工厂可以创建汽车产品、手机产品
- 抽象工厂：同一品牌中所有系列的产品
- 具体工厂：负责创建同一个品牌的产品。
- 抽象产品
- 具体产品
public interface AbstractFactory {
Car getCar();
Phone getPhone();
}public class AodiFactory implements AbstractFactory{
@Override
public Car getCar() {
return new AodiCar();
}
@Override
public Phone getPhone() {
return new AodiPhone();
}
}public class BmwFactory implements AbstractFactory{
@Override
public Car getCar() {
return new BmwCar();
}
@Override
public Phone getPhone() {
return new BmwPhone();
}
}public interface Car {
void run();
}
public interface Phone {
void call();
}public class AodiCar implements Car{
@Override
public void run() {
System.out.println("奥迪汽车行驶");
}
}public class AodiPhone implements Phone{
@Override
public void call() {
System.out.println("奥迪手机打电话");
}
}public class Test {
public static void main(String[] args) {
AbstractFactory aodiFactory = new AodiFactory();
Car aodiCar = aodiFactory.getCar();
Phone aodiphone = aodiFactory.getPhone();
aodiCar.run();
aodiphone.call();
AbstractFactory bmwFactory = new BmwFactory();
Car bmwCar = bmwFactory.getCar();
Phone bmwPhone = bmwFactory.getPhone();
bmwCar.run();
bmwPhone.call();
}
}3、原型模式
spring创建bean作用域:
- singleton：单例bean，一个类创建一个对象，spring启动时就创建单例对象。
- prototype: 原型的（多例），每次获取时，都会创建一个新的对象。
创建一些内容相同的对象，如果每次去new就比较耗时间。可以造出来一个，然后对对象进行克隆，提高创建的效率。（注意深克隆和浅克隆）
4、代理模式
最早在spring框架中的aop提到。面向切面编程：可以对业务逻辑和非业务逻辑进行隔离，将程序中的一些非业务代码进行提取，然后让代理对象去调用公共的方法，就可以做到在不需要修改原来代码的情况下，为程序添加额外的功能。
底层实现：使用的是动态代理模式。是通过一个代理对象来实现对非业务代码进行调用的。告诉代理对象，调用哪个方法时，让代理对象去帮助我们调用哪个方法。
代理模式：分为静态代理和动态代理。
1.静态代理
目标对象（汽车厂卖汽车，最终要具体干这件事的主体）不能/不方便操作某些事情，这时可以为目标对象提供一个代理对象，代理对象代表目标对象。在调用目标对象方法时，可以为目标对象添加一些额外功能。
角色：
- 抽象主体(接口)
- 真实主体(目标对象)：实际做事情
- 代理对象：代表目标对象
静态代理实现：目标对象和代理对象必须实现相同的接口。如果需要代理新的目标，需要对代理对象进行修改，必须添加实现新的接口，这样违背开闭原则，扩展起来不方便。一般框架中不使用，自己在一些简单的功能中可以使用。
public class StaticProxy implements SellCar,SellPhone{}
//抽象操作定义 卖东西
public interface Sell {
void sell();
}//汽车厂
public class CarFactoryImpl implements Sell {
@Override
public void sell() {
System.out.println("汽车厂卖汽车");
}
}//静态代理,实际中很少使用静态代理,因为其代理类实现的接口必须与目标类实现接口一致,扩展起来就比较麻烦
public class StaticProxy implements Sell {
Sell sell;
public StaticProxy(Sell sell) {
this.sell = sell;
}
//代理对象中的方法
@Override
public void sell() {
System.out.println("汽车介绍");
sell.sell();//最终执行者还是目标对象
System.out.println("办理手续");
}
}public class Test {
public static void main(String[] args) {
Sell carFactory = new CarFactoryImpl();
//创建汽车厂代理对象
StaticProxy staticProxy = new StaticProxy(carFactory);
staticProxy.sell();//看似访问的是代理类，其实是目标对象来做的
}
}
/*
汽车介绍
汽车厂卖汽车
办理手续
*/2.动态代理
为目标类动态的生成代理对象，这样就可以代理任意的目标类。动态代理分为：jdk代理和cglib代理。
在spring框架中两种代理方式都支持，如果一个类实现了接口，就采用jdk代理；如果一个类没有实现接口，就采用的cglib代理。
（1）jdk代理
底层使用的反射机制，动态获取目标类对象所实现的接口，然后为目标类动态生成一个代理对象，并动态获取到要调用的方法，最终调用目标对象中的方法。
动态代理可以代理任意的目标类，但是目标类必须要实现一个接口。
动态代理器中，可以传进来任意的目标类。在getProxy方法中，获取到目标对象的接口、拿到目标对象的信息，最终为目标对象生成代理对象。代理对象实现了目标对象的接口，最后代理对象调用目标类的接口中的sell方法，其实会调用代理器类中的invoke方法。然后通过反射机制，调用目标对象中的方法。
//抽象操作定义 卖东西
public interface Sell {
void sell();
}//汽车厂
public class CarFactoryImpl implements Sell {
@Override
public void sell() {
System.out.println("汽车厂卖汽车");
}
}/*
动态代理类
代理类不需要实现与目标类相同的接口,这样就可以代理任意的目标类
但是是有要求的,目标类必需实现接口,此种方式是动态代理的实现方式之一: jdk代理 是一种纯反射机制实现(动态获取目标类接口方法)
*/
public class DynamicProxy implements InvocationHandler {
Object object;//真实对象,接收任何的目标类对象
public DynamicProxy(Object object) {
this.object = object;
}
/*
在代理类中调用目标类中的具体方法,
动态的将代理动态对象,目标类中要调用的方法,及方法中的参数传递过来
Method method 动态获取的真正要执行的方法
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("之前开启事务");
method.invoke(object);//调用目标对象中的sell方法
System.out.println("之后提交事务");
return proxy;
}
//根据目标对象生成代理对象
public Object getProxy(){
return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
}
}public class Test {
public static void main(String[] args) {
CarFactoryImpl carFactory = new CarFactoryImpl();
DynamicProxy dtproxy = new DynamicProxy(carFactory);//创建动态代理器
//这才是真正的创建动态代理对象 获取目标类所实现的接口
Sell sell =(Sell)dtproxy.getProxy();//代理对象实现了目标对象的接口
sell.sell();//使用代理对象调用接口中的方法,获取当前调用的方法,最终调用invoke方法
}
}（2）cglib代理
针对jdk代理必须要让目标类实现接口这一问题，spring后来引入chlib技术。
cglib代理：目标类不需要实现接口，在底层以生成字节码的方式，为目标类动态生成子类对象。在调用目标类方法时，对方法进行拦截，动态获取所调用的方法，最终动态调用方法。
注意：cglib代理中，目标类不能用final修饰，目标类中的方法不能用final和static修饰。
public class CarFactoryImpl {
public void sell() {
System.out.println("汽车厂卖汽车");
}
}//动态代理类
public class CGLibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class<?> clazz){
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();//为目标类生成子类对象
}
/*
* 拦截所有目标类方法的调用
* 参数：
* obj 目标实例对象
* method 目标方法的反射对象
* args 方法的参数
* proxy 代理类的实例
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
//代理类调用父类的方法
System.out.println("开始事务");
Object obj1 = proxy.invokeSuper(obj, args);
System.out.println("关闭事务");
return obj1;
}
}public class Test {
public static void main(String[] args) {
CGLibProxy proxy = new CGLibProxy();
CarFactoryImpl carFactory = (CarFactoryImpl) proxy.getProxy(CarFactoryImpl.class);//为目标对象生成代理对象
carFactory.sell();
}
}
