Java常用设计模式_java中的设计模式

目录

1 单例设计模式

1.1 单利模式优势和场景

2 代理设计模式介绍

2.1 静态代理和装饰者设计模式的区别

2.2 不同点

3 静态代理

4 动态代理技术

4.1 JDK 的动态代理

4.2 cglib 的动态代理

5 工厂模式

6 适配器设计模式

1 单例设计模式

什么是单例：永远只能够创建一个对象

单例设计模式书写方式总共是有两种：饿汉式、懒汉式

书写单例设计模式的语法规则：

1. 类中的构造方法私有

     2.需要提供一个公共的获取对象的方法

饿汉式单例设计模式：(好比人很饿,需要提前备好饭,这里的饭就是对象)

final修饰的话不可变,永远都是内个对象.

懒汉式单例设计模式： (懒汉就是饿了才会想起来做饭,饭就相当于创建对象)

线程的抢占会跑入这个判断,会创建多个对象,成为多例

解决方案双重校验锁：
这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

1.1 单利模式优势和场景

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

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

单利模式优点：

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

单利模式真实应用场景：

1、网站的计数器
2、应用程序的日志应用
3、数据库连接池设计
4、多线程的线程池设计

2 代理设计模式介绍

2.1 静态代理和装饰者设计模式的区别

2.1.1 相同点

1）都要实现与目标类相同的业务接口

2）在俩个类中都要声明目标对象

3）都可以在不修改目标类的前提下增强目标方法

2.2 不同点

1）目的不同，装饰者，简单说，就是为了增强目标对象

静态代理的使用目的是为了保护和隐藏目标对象

2）对于目标对象的获取方式不同

装饰者中目标对象的获取，通过代参构造器传入，静态代理类中，是在无参构造器中直接创建。

3 静态代理

静态代理的思想：将被代理类作为代理类的成员，通过代理类调用被代理类的函数，并添加新的控制。包装类与被包装类实现同一接口，使得使用时的代码一致。

应用：已经有一个日志记录器LoggerSubject，需要对writeLog()函数的前后进行某些操作（如初始化、异常处理等），使用Proxy类间接调用LoggerSubject.writeLog()实现新控制操作的添加。

interface Logger {
    void writeLog();
}
 
// 被代理类
class LoggerSubject implements Logger{
    @Override
    public void writeLog(){
        System.out.println("writeLog by LoggerSubject");
    }
}
 
// 代理类
class Proxy implements Logger{
    Logger logger;
    // 与装饰者模式的主要区别位置
    // 代理模式一般要求和原来的类行为一致，因此构造函数不传入对象
    Proxy(){
        this.logger = new LoggerSubject();
    }
    @Override
    public void writeLog(){
        System.out.println("logger write before");
        logger.writeLog();
        System.out.println("logger write after");
    }
}
 
public class StaticProxy {
    public static void main(String []argvs){
        Logger logger = new Proxy();
        logger.writeLog();
    }
}

4 动态代理技术

常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术

cglib 代理：基于父类的动态代理技术

4.1 JDK 的动态代理

①目标类接口

public interface TargetInterface {
    public void method();
}

②目标类

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

③动态代理代码

Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass()
.getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
                System.out.println("前置增强代码...");
                Object invoke = method.invoke(target, args);
                System.out.println("后置增强代码...");
                return invoke;
            }
        }
);

④ 调用代理对象的方法测试

// 测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

• 1
• 2

​

4.2 cglib 的动态代理

①目标类

public class Target {
    public void method() {
        System.out.println("Target running....");
    }
}

②动态代理代码

Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象

③调用代理对象的方法测试

//测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

​

5 工厂模式

public class SimpleFactory {
    public static Product createProduct(String pname){
        Product product=null; if("p1".equals(pname)){
            product = new Product(); }
        else if("p2".equals(pname)){
            product = new Product(); }
        else if("pn".equals(pname)){
            product = new Product(); }
        return product;
    }