设计模式

最新推荐文章于 2024-10-06 08:57:52 发布

codeccb

最新推荐文章于 2024-10-06 08:57:52 发布

阅读量159

点赞数

文章标签：设计模式 java proxy jvm spring

本文链接：https://blog.csdn.net/weixin_45519907/article/details/122599145

版权

设计模式：为了让程序更加灵活、更有拓展性，而设计的一套程序设计方式

开闭原则

可以拓展程序，但不能修改原有的代码，多使用抽象类和接口

工厂方法模式

定义一个用于创建产品的工厂接口，由具体的子类决定生产什么产品javax.xml.bind.JAXBContext.createMarshaller

单例模式

整个程序只存在一个对象，通过将构造方法私有化，在本类中提供一个实例化对象的方法，通过判空来保证只有一个对象被实例化了。

懒汉式实现

需要实例化对象时才调用 getInstance()方法创建对象，不过得到的是全局唯一的一个对象

```java public class LazySingleTon {

private static LazySingleTon instance;

// 构造方法私有化，其他类就不能再实例化对象
private LazySingleTon() {
}

// 提供创建对象的方法，但只能创建一个对象
public static LazySingleTon getInstance(){

    if (instance==null){

        synchronized (LazySingleTon.class){
            if (instance==null){
                instance= new LazySingleTon();
            }
        }
    }
    return instance;
}

}

class Test{ public static void main(String[] args) { SingleTon instance = SingleTon.getInstance(); } } ```

饿汉式实现

```java /** * 类初始化时就实例化唯一的一个对象，有 jvm保证线程安全 */ public class HungrySingleTon {

private static HungrySingleTon instance=new HungrySingleTon();

// 构造方法私有化
private HungrySingleTon(){}

public HungrySingleTon getInstance(){
    return instance;
}

} ```

代理模式

对目标对象提供代理以控制对这个对象的访问。按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。

静态代理

在编译期(写代码的时候)实现对目标对象的代理，被代理对象和代理对象需要实现共同的接口

java // 卖票接口 public interface SellTickets { void sell(); } // 被代理对象(火车站) public class TrainStation implements SellTickets { public void sell() { System.out.println("火车站卖票"); } } // 代理对象(中介) public class ProxyPoint implements SellTickets { private TrainStation station = new TrainStation(); public void sell() { System.out.println("代理点收取一些服务费用"); station.sell(); } } // 测试类 public class Client { public static void main(String[] args) { ProxyPoint pp = new ProxyPoint(); pp.sell(); } }

jdk动态代理

jdk 提供了Proxy类，该类用于生成代理类和代理对象，代理对象和目标对象都实现了相同的接口，以下是jdk 动态代理模拟代码

版本1：

```java //卖票接口 public interface SellTickets { void sell(); } }

// 火车站实现SellTickets接口 public class TrainStation implements SellTickets { public void sell() { System.out.println("火车站卖票"); } }

// 代理工厂，用来创建代理对象 public class ProxyFactory { private TrainStation station = new TrainStation(); public SellTickets getProxyObject() { //使用Proxy获取代理对象 SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance( station.getClass().getClassLoader(), // 通过被代理对象加载代理类 station.getClass().getInterfaces(), // 通过被代理对象获取代理对象要实现的接口 new InvocationHandler() { /* InvocationHandler中invoke方法参数说明： proxy ：代理对象 method ：对应于在代理对象上调用的接口方法的 Method 实例 args ：代理对象调用接口方法时传递的实际参数 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("jdk代理方式，用来增强的逻辑");
                    Object result = method.invoke(station, args);//执行真实对象的方法
                    return result;
                }
            });
            return sellTickets;
        }

}

//测试类 public class Client { public static void main(String[] args) { //获取代理对象 ProxyFactory factory = new ProxyFactory(); SellTickets proxyObject = factory.getProxyObject(); proxyObject.sell(); } } ```

java // 程序运行过程中动态生成的代理类 // 代理类($Proxy0)同样实现了SellTickets接口 public final class $Proxy0 extends Proxy implements SellTickets { private static Method m3; public $Proxy0(InvocationHandler invocationHandler) { super(invocationHandler); } static { m3 =Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]); } public final void sell() { this.h.invoke(this, m3, null); } }

版本2：

~~~java public class JDKProxy {

public Object createBookServiceProxy(Class clazz){

    ClassLoader cl = clazz.getClassLoader();

    Class[] classes = clazz.getInterfaces();

    InvocationHandler ih = new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object ret=method.invoke(clazz.getDeclaredConstructor().newInstance(),args);
            System.out.println("事务处理");
            System.out.println("日志记录");
            return ret;
        }
    };

    Object o = Proxy.newProxyInstance(cl,classes,ih);
    return o;
}

} ~~~

~~~java public interface BookService {

void createBook();

}

public class BookServiceImpl implements BookService { @Override public void createBook() { System.out.println("create book..."); } } ~~~

~~~java public class App {

public static void main(String[] args) {

//jdk动态代理 BookService bookService = new BookServiceImpl(); BookService jdkProxy = (BookService) new JDKProxy().createBookServiceProxy(bookService.getClass()); jdkProxy.createBook(); } ~~~