Java中的装饰者设计模式,你知道嘛?

痛定思痛。 2022-11-26 01:43 156阅读 0赞

# 一.**简述及实现原则** #

> 装饰模式：在**不改变 原有类** 和 不使用继承的情况下，** 动态地扩展**一个对象的功能。
> 
> 因会创建一个包装对象，来包裹真实对象而得名。

*  作用：增强对象的功能

> 例子1：
> 
> 墙： 功能---遮风挡雨
> 
> 包了墙纸的墙（本质还是墙）：
> 
> 功能---遮风挡雨
> 
> 新增功能---陶冶情操
> 
>  
> 
> 例子2：
> 
> 钢笔： 功能---写字
> 
> 包了礼盒的钢笔（本质还是钢笔）：
> 
> 功能---写字
> 
> 功能---礼品

> 1.  **没有改变原有类**
> 2.  **进行动态地增强**

> 装饰类：增强功能的类（包了墙纸的墙）
> 
> 被装饰类：待增强功能的类（墙）
> 
> 实现原则：
> 
> 1.  **装饰类 必须 实现 被装饰类的所有接口** 
> 2.  **装饰类 中 必须获取 被装饰类对象**

# 二.**入门案例** #

> 分析：
> 
> 1.  定义一个装饰类 实现 Phone接口
> 2.  装饰类中 获取到 被装饰类对象（成员变量）
> 
>

## 代码实现： ##

HWPhoneDecorator:

public class HWPhoneDecorator implements Phone {
        //被装饰类的对象
        private HWPhone old;
        public HWPhoneDecorator(HWPhone old) {
            this.old = old;
        }
        /*
        * 打电话方法不需要增强，不需要改变
        * */
        public void call(String number) {
            old.call(number);
        }
        /**
         * 发短信方法需要被增强
         */
        public void sendMsg() {
            //1、先运行原来的功能
            old.sendMsg();
            //2、再执行新的增强代码
            System.out.println("(o゜▽゜)o☆[BINGO!]");
        }
    }

测试类：

public static void main(String[] args) {
        Phone hw = new HWPhoneDecorator(new HWPhone());
        hw.call("12345");
        hw.sendMsg();
    }

## 小结： ##

> 装饰者设计模式，可以在不改变原有类的情况，动态增强类中某个方法。
> 
>  
> 
> 实现：
> 
> 1.  装饰类实现 被装饰类实现的所有接口
> 2.  装饰类中 获取  被装饰类对象

# 三.**装饰者设计模式向静态代理转变** #

HWPhoneDecorator

public class HWPhoneDecorator implements Phone {
        //被装饰类的对象
        private Phone old;  //接口下的实现类都能增强
        public HWPhoneDecorator(Phone old) {
            this.old = old;
        }
        /*
        * 打电话方法不需要增强，不需要改变
        * */
        public void call(String number) {
            old.call(number);
        }
        /**
         * 发短信方法需要被增强
         */
        public void sendMsg() {
            //1、先运行原来的功能
            old.sendMsg();
            //2、再执行新的增强代码
            System.out.println("(o゜▽゜)o☆[BINGO!]");
        }
    }

# 四..**使用装饰者设计模式修改连接池** #

*  增强Connection 对象close方法，不是关闭资源，而是归还连接池

> 分析：
> 
> 1.  编写一个装饰类MyConnection，增强Connection对象
> 2.  需要重写close方法
> 3.  把连接池创建的Connection对象，装饰为MyConnection对象

MyConnection

public class MyConnection implements Connection {
        //被装饰的Connection对象
        private Connection old;
        //因为close方法需要把连接归还连接池，所以这里也要获取连接池
        private LinkedList<Connection> pool;
        public MyConnection(Connection old, LinkedList<Connection> pool) {
            this.old = old;
            this.pool = pool;
        }
        /**
         * 要增强的close方法
         * @throws SQLException
         */
        public void close() throws SQLException {
            //old.close();//会关闭资源
            //把当前装饰类对象 归还到连接池
            pool.addLast(this);
        }
        /**
         * 其他方法 用原对象进行调用即可,底下代码无需手写
         */
        public Statement createStatement() throws SQLException {
            return old.createStatement();
        }
    
        public PreparedStatement prepareStatement(String sql) throws SQLException {
            return old.prepareStatement(sql);
        }
    
        public CallableStatement prepareCall(String sql) throws SQLException {
            return old.prepareCall(sql);
        }
    
        public String nativeSQL(String sql) throws SQLException {
            return old.nativeSQL(sql);
        }
    
        public void setAutoCommit(boolean autoCommit) throws SQLException {
            old.setAutoCommit(autoCommit);
        }
    
        public boolean getAutoCommit() throws SQLException {
            return old.getAutoCommit();
        }
    
        public void commit() throws SQLException {
            old.commit();
        }
    
        public void rollback() throws SQLException {
            old.rollback();
        }
    
    
        public boolean isClosed() throws SQLException {
            return old.isClosed();
        }
    
        public DatabaseMetaData getMetaData() throws SQLException {
            return old.getMetaData();
        }
    
        public void setReadOnly(boolean readOnly) throws SQLException {
            old.setReadOnly(readOnly);
        }
    
        public boolean isReadOnly() throws SQLException {
            return old.isReadOnly();
        }
    
        public void setCatalog(String catalog) throws SQLException {
            old.setCatalog(catalog);
        }
    
        public String getCatalog() throws SQLException {
            return old.getCatalog();
        }
    
        public void setTransactionIsolation(int level) throws SQLException {
            old.setTransactionIsolation(level);
        }
    
        public int getTransactionIsolation() throws SQLException {
            return old.getTransactionIsolation();
        }
    
        public SQLWarning getWarnings() throws SQLException {
            return old.getWarnings();
        }
    
        public void clearWarnings() throws SQLException {
            old.clearWarnings();
        }
    
        public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
            return old.createStatement(resultSetType,resultSetConcurrency);
        }
    
        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
            return old.prepareStatement(sql,resultSetType,resultSetConcurrency);
        }
    
        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
            return old.prepareCall(sql,resultSetType,resultSetConcurrency);
        }
    
        public Map<String, Class<?>> getTypeMap() throws SQLException {
            return old.getTypeMap();
        }
    
        public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
            old.setTypeMap(map);
        }
    
        public void setHoldability(int holdability) throws SQLException {
            old.setHoldability(holdability);
        }
    
        public int getHoldability() throws SQLException {
            return old.getHoldability();
        }
    
        public Savepoint setSavepoint() throws SQLException {
            return old.setSavepoint();
        }
    
        public Savepoint setSavepoint(String name) throws SQLException {
            return old.setSavepoint(name);
        }
    
        public void rollback(Savepoint savepoint) throws SQLException {
            old.rollback(savepoint);
        }
    
        public void releaseSavepoint(Savepoint savepoint) throws SQLException {
            old.releaseSavepoint(savepoint);
        }
    
        public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
            return old.createStatement(resultSetType,resultSetConcurrency,resultSetHoldability);
        }
    
        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
            return old.prepareStatement(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
        }
    
        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
            return old.prepareCall(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
        }
    
        public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
            return old.prepareStatement(sql,autoGeneratedKeys);
        }
    
        public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
            return old.prepareStatement(sql,columnIndexes);
        }
    
        public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
            return old.prepareStatement(sql,columnNames);
        }
    
        public Clob createClob() throws SQLException {
            return old.createClob();
        }
    
        public Blob createBlob() throws SQLException {
            return old.createBlob();
        }
    
        public NClob createNClob() throws SQLException {
            return old.createNClob();
        }
    
        public SQLXML createSQLXML() throws SQLException {
            return old.createSQLXML();
        }
    
        public boolean isValid(int timeout) throws SQLException {
            return old.isValid(timeout);
        }
    
        public void setClientInfo(String name, String value) throws SQLClientInfoException {
            old.setClientInfo(name,value);
        }
    
        public void setClientInfo(Properties properties) throws SQLClientInfoException {
            old.setClientInfo(properties);
        }
    
        public String getClientInfo(String name) throws SQLException {
            return old.getClientInfo(name);
        }
    
        public Properties getClientInfo() throws SQLException {
            return old.getClientInfo();
        }
    
        public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
            return old.createArrayOf(typeName,elements);
        }
    
        public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
            return old.createStruct(typeName,attributes);
        }
    
        public void setSchema(String schema) throws SQLException {
            old.setSchema(schema);
        }
    
        public String getSchema() throws SQLException {
            return old.getSchema();
        }
    
        public void abort(Executor executor) throws SQLException {
            old.abort(executor);
        }
    
        public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
            old.setNetworkTimeout(executor,milliseconds);
        }
    
        public int getNetworkTimeout() throws SQLException {
            return old.getNetworkTimeout();
        }
    
        public <T> T unwrap(Class<T> iface) throws SQLException {
            return old.unwrap(iface);
        }
    
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            return old.isWrapperFor(iface);
        }
    }

MyDataSource

public class MyDataSource implements DataSource {
        private static final String DRIVERCLASS="com.mysql.jdbc.Driver";
        private static final String URL="jdbc:mysql://127.0.0.1:3306/day01_db";
        private static final String USERNAME="root";
        private static final String PASSWORD="1234";
        //连接池
        private static final LinkedList<Connection> pool = new LinkedList<Connection>();
        static{
            //1、注册驱动
            try {
                Class.forName(DRIVERCLASS);
                //2、初始化连接池，默认连接池有5个连接
                initPool();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 初始化连接池
         */
        private static void initPool() throws SQLException {
            for (int i = 0; i <5 ; i++) {
                pool.addLast(getCon());
            }
        }
        /**
         * 类内部进行获取连接的方法
         * @return
         */
        private static Connection getCon() throws SQLException {
            return new MyConnection(DriverManager.getConnection(URL,USERNAME,PASSWORD),pool);
        }
    
        /**
         * 获取连接
         * @return
         * @throws SQLException
         */
        public Connection getConnection() throws SQLException {
            //判断：连接池是否有连接
            if(pool.size()==0){
                //连接池没有连接，再创建5个
                initPool();
            }
            //连接池有连接，从池中取出一个连接
            return pool.removeLast();
        }
    
        /**
         * 关闭所有资源 （con对象 归还到 连接池中）
         * @param con
         * @param ps
         * @param rs
         * @throws SQLException
         */
        public static void closeAll(Connection con, PreparedStatement ps,ResultSet rs) throws SQLException {
            if(rs!=null)
                rs.close();
            if(ps!=null)
                ps.close();
            if(con!=null)
                con.close();
        }
    
        public Connection getConnection(String username, String password) throws SQLException {
            return null;
        }
    
        public <T> T unwrap(Class<T> iface) throws SQLException {
            return null;
        }
    
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            return false;
        }
    
        public PrintWriter getLogWriter() throws SQLException {
            return null;
        }
    
        public void setLogWriter(PrintWriter out) throws SQLException {
    
        }
    
        public void setLoginTimeout(int seconds) throws SQLException {
    
        }
    
        public int getLoginTimeout() throws SQLException {
            return 0;
        }
    
        public Logger getParentLogger() throws SQLFeatureNotSupportedException {
            return null;
        }
    }

看完恭喜你,又知道了一点点!!!

**你知道的越多,不知道的越多! **

**~感谢志同道合的你阅读,  你的支持是我学习的最大动力 ! 加油 ,陌生人一起努力,共勉!!**

> **注: 如果本篇有需要改进的地方或错误,欢迎大神们指定一二~~**