Java常用设计模式

1 单例设计模式

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

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

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

1. 类中的构造方法私有

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

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

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

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

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

2 代理设计模式介绍

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

5.1.1 相同点

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

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

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

不同点

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

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

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

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

静态代理

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

应用：已经有一个日志记录器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();
    }
}

动态代理技术

常用的动态代理技术

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

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

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

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();

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; 
}}