Java设计模式：代理模式

最新推荐文章于 2024-04-02 12:55:59 发布

smilezmh

最新推荐文章于 2024-04-02 12:55:59 发布

阅读量130

点赞数

分类专栏： java基础知识文章标签：设计模式

本文链接：https://blog.csdn.net/weixin_37549458/article/details/107932989

版权

java基础知识专栏收录该内容

45 篇文章 0 订阅

订阅专栏

使用代理模式来实现数据库连接池，代码部分转自廖雪峰的官方网站

代理模式我的理解是：首先代理类继承了被代理类。存储了真正的被代理类对象的访问钥匙或途径，代理类可以有自己的功能，如鉴权等一些操作，等到真正需要用时才用钥匙获取被代理对象。
定义抽象类（可以不实现接口中方法）

被代理类 Connecton AbstractConnectionProxy
Connecton connection=DriverManager.getConnection(url, username, password);
代理类 LazyConnectionProxy
LazyConnectionProxy，存储了获取真正被代理类的钥匙； getRealConnection()中使用 Supplier接口的 supplier.get()方法获取到真正的被代理类对象

Supplier supplier=
() -> {
            try {
                Connection conn = DriverManager.getConnection(url, username, password);
                System.out.println("Open connection: " + conn);
                return conn;
            } catch (SQLException e) {
                return null;
            }
        }

LazyDataSource 获取连接getConnection()获取的是一个代理类LazyConnectionProxy对象。

package com.example.designModel.proxy;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

public class LazyDataSource implements DataSource {
    private String url;
    private String username;
    private String password;

    public LazyDataSource(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public Connection getConnection() throws SQLException {
        return new LazyConnectionProxy(() -> {
            try {
                Connection conn = DriverManager.getConnection(url, username, password);
                System.out.println("Open connection: " + conn);
                return conn;
            } catch (SQLException e) {
                return null;
            }
        });
    }

   ...
}

代理类中定义了获取真正连接Connection的方法getRealConnection()

package com.example.designModel.proxy;


import java.sql.Connection;
import java.sql.SQLException;
import java.util.function.Supplier;

public class LazyConnectionProxy extends AbstractConnectionProxy {
    private Supplier<Connection> supplier=null;
    private Connection connection=null;

    public LazyConnectionProxy(Supplier<Connection> supplier){
        this.supplier=supplier;
    }

    public void close() throws SQLException {
        if(connection!=null){
            System.out.println(Thread.currentThread().getName());
            System.out.println("关闭连接");
            super.close();
        }
    }

    protected Connection getRealConnection(){
        if(connection==null){
            connection= supplier.get();
        }

        return connection;
    }
}

AbstractConnectionProxy实现了Connection方法(可以认为是被代理类，因为如果不实现Connection,代理类要重写很多方法，为了省去在代理类中重写被代理类的方法，定义一个类AbstractConnectionProxy)

package com.example.designModel.proxy;

import java.sql.*;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

public abstract class AbstractConnectionProxy implements Connection {

    protected abstract Connection getRealConnection();

    public Statement createStatement() throws SQLException{
        return getRealConnection().createStatement();
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException{
        return getRealConnection().prepareStatement(sql);
    }

   ...
}

如果不想每次都获取new实例，重复利用已有连接对象，那么久放入一个代理队列池中ConcurrentLinkedQueue connectionsQuene

被代理类 Connecton AbstractConnectionProxy
Connecton connection=DriverManager.getConnection(url, username, password);
代理类 PooledConnectionProxy
PooledConnectionProxy，存储了获取真正被代理类的钥匙 getRealConnection()，返回PooledConnectionProxy中定义的实例变量Connection对象

连接池中维护了ConcurrentLinkedQueue connectionsQuene代理连接池，getConnection() 方法获取的是代理连接。

package com.example.designModel.proxy;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Logger;

public class PooledDataSource implements DataSource {
    private String url;
    private String username;
    private String password;
    private ConcurrentLinkedQueue<PooledConnectionProxy> connectionsQuene=new ConcurrentLinkedQueue<>();

    public PooledDataSource(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }

    private PooledConnectionProxy openNewConnection() throws  SQLException {
        Connection conn= DriverManager.getConnection(url, username, password);
        System.out.println("打开代理连接: " + conn);
        return new PooledConnectionProxy(connectionsQuene, conn);
    }

    @Override
    public Connection getConnection() throws SQLException {
        PooledConnectionProxy conn=connectionsQuene.poll();

        if(conn==null){
            return openNewConnection();
        }else {
            System.out.println(Thread.currentThread().getName());
            System.out.println("从队列里取出代理连接");
        }

        return conn;
    }
...
}

代理对象PooledConnectionProxy

package com.example.designModel.proxy;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.ConcurrentLinkedQueue;

public class PooledConnectionProxy extends AbstractConnectionProxy {
    private Connection connection;

    private ConcurrentLinkedQueue<PooledConnectionProxy> poolQuene;

    public PooledConnectionProxy(ConcurrentLinkedQueue<PooledConnectionProxy> poolQuene, Connection connection){
        this.poolQuene=poolQuene;
        this.connection=connection;
    }

    public void close() throws SQLException{
        System.out.println("假关闭，将连接放进队列"+connection);
        this.poolQuene.offer(this);
    }


    @Override
    protected Connection getRealConnection() {
        return connection;
    }
}

main方法

package com.example.designModel.proxy;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MainApp {
    public static void main(String[] args) throws SQLException {
        DataSource lazyDataSource =
                new LazyDataSource("jdbc:mysql://10.136.11.199:3306/adminsys",
                        "root", "Dp5VqJtAQr");
        System.out.println("get lazy connection...");
        try (Connection conn1 = lazyDataSource.getConnection()) {
            // 并没有实际打开真正的Connection
        }
        System.out.println("get lazy connection...");
        try (Connection conn2 = lazyDataSource.getConnection()) {
            try (PreparedStatement ps = conn2.prepareStatement("SELECT * FROM sys_role")) { // 打开了真正的Connection
                try (ResultSet rs = ps.executeQuery()) {
                    while (rs.next()) {
                        System.out.println(rs.getString("id"));
                    }
                }
            }
    }

    DataSource pooledDataSource =
            new PooledDataSource("jdbc:mysql://10.136.11.199:3306/adminsys",
                    "root", "Dp5VqJtAQr");
        System.out.println("get pooled connection...");
        try (Connection conn1 = pooledDataSource.getConnection()) {
            // 并没有实际打开真正的Connection
        }
        System.out.println("get pooled connection...");
        try (Connection conn2 = pooledDataSource.getConnection()) {
            try (PreparedStatement ps = conn2.prepareStatement("SELECT * FROM sys_role")) { // 打开了真正的Connection
                try (ResultSet rs = ps.executeQuery()) {
                    while (rs.next()) {
                        System.out.println(rs.getString("id"));
                    }
                }
            }
        }
    }
}

LazyConnectionProxy代理Connection的过程：

main执行lazyDataSource方法getConnection获得的是代理类LazyConnectionProxy对象，这个时候被代理类对象Connecton，还没有生成实例即DriverManager.getConnection(url, username, password);没执行，当代理类执行prepareStatement函数时，因为被代理类没有这个方法，所以去父类Connection找，又出现了getRealConnection这个类的实现，这时因为多态，栈中this指针指向的是代理对象，又会到代理对象中执行对应的getRealConnection，通过supplier.get()获得真知的被代理代理类，这时被代理类才生成实例对象。调用方法时先到父类，又回到子类，是典型的继承和多态两个特性使用。

LazyConnectionProxy代理Connection的过程：

main执行PooledDataSource方法getConnection()获得的是代理类PooledConnectionProxy对象（每个代代理对象都会有一个Connection维护在代理对象中）。调用getConnection()方法，这个时候被代理类对象判断队列是空对象，所以生成了一个被代理Connecton实例，getConnection()方法返回的是一个代理对象PooledConnectionProxy 实例，这个实例放在PooledConnectionProxy维护的队列池中，关闭时PooledConnectionProxy被加入同一个队列池中。当代理类执行prepareStatement函数时，因为被代理类没有这个方法，所以去父类Connection找，又出现了getRealConnection这个类的实现，这时因为多态，栈中this指针指向的是代理对象，又会到代理对象中执行对应的getRealConnection，通过PooledConnectionProxy中的connection获得真知的被代理代理类。

Connection接口继承了AutoCloseable接口所以可以使用try{}语句来自动关闭连接。

结果

get lazy connection…
get lazy connection…
Open connection: com.mysql.cj.jdbc.ConnectionImpl@57f23557
1
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
关闭连接
get pooled connection…
打开代理连接: com.mysql.cj.jdbc.ConnectionImpl@4148db48
假关闭，将连接放进队列com.mysql.cj.jdbc.ConnectionImpl@4148db48
get pooled connection…
从队列里取出代理连接
1
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
假关闭，将连接放进队列com.mysql.cj.jdbc.ConnectionImpl@4148db48

smilezmh

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java设计模式：代理模式

使用代理模式来实现数据库连接池，代码部分转自廖雪峰的官方网站代理模式我的理解是：代理类继承了被代理类。存储了真正的被代理类对象的访问钥匙或途径，封装在代理类的变量中，代理类可以有自己的功能，如鉴权等一些操作，等到真正需要用时才用钥匙获取被代理对象。定义抽象类（可以不实现接口中方法）执行被代理类中对应方法可以作为访问的钥匙，此方法在代理类中没有，于是去找父类被代理类中的此方法，这个方法引用又需要到代理类中获取，先到父类，又到子类，用了继承和多态两个特性...
复制链接

扫一扫

专栏目录