浅谈java中的装饰模式和动态代理模式

叁歲伎倆 2022-05-23 12:57 294阅读 0赞

什么是装饰模式

  1. 定义：装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。  
  4. 单单看上面的定义太抽象了，我们来举个栗子。

我们先定义一个Animal接口，里面有一个eat和call方法

  1. public interface Animal {
  2.     public void eat();
  3.     public void call();
  4.     }

再创建一个Dog类，实现Animal接口

  1. public class Dog implements Animal{
  3.     public void eat(){
  4.         System.out.println("狗在嘚嘚的吃");
  5.     }
  7.     public void call(){
  8.         System.out.println("狗在旺旺的叫");
  9.     }
  10. }

现在我们不喜欢狗的叫声，想让狗哈哈哈地叫，该怎么办呢。可以继承Dog类，然后重写call方法；也可以使用装饰模式。下面我们使用装饰模式来实现一下。

我们创建一个ZhuangshiDog类

  1. /**
  2.  * 装饰类 要实现和被装饰类一样的接口
  3.  * @author wangchaoyouziying
  4.  *
  5.  */
  6. public class ZhuangshiDog implements Animal {
  8.     private Animal ani;
  10.     public ZhuangshiDog(Animal ani) {
  11.         this.ani = ani;
  12.     }
  14.     @Override
  15.     public void eat() {
  16.         ani.eat();
  17.     }
  19.     @Override
  20.     public void call() {
  21.         System.out.println("狗在哈哈哈地叫");
  22.     }
  24. }

测试一下

  1. public class Test {
  3.     public static void main(String[] args) {
  4.         Animal dog = new Dog();//这里Dog是被装饰者
  6.         //实例化装饰类
  7.         Animal zsDog = new ZhuangshiDog(dog);
  8.         zsDog.call();
  9.         zsDog.eat();
  10.     }
  12. }

输出结果：

  1. 狗在哈哈哈地叫
  2. 狗在嘚嘚的吃

装饰模式的优点：可以不改变被装饰者和继承关系的情况下，拓展被装饰者的功能。

缺点：需要实现和被装饰者相同的接口，那么如果该接口有一百个方法，而我们只想装饰其中的一个方法。此时我们不得不另外实现其余的99个方法，很明显增加了代码冗余量。

总结：装饰模式适用于被装饰者实现的接口中方法数较少的情况。

那么对于方法数较多的情况下该怎么办呢。此时可以使用动态代理模式。

什么是动态代理模式？

  1. 定义：用来修改已经具有的对象的方法,控制方法是否执行,或在方法执行之前和执行之后做一些额外的操作。

我们同样来举个栗子。

我们先定义一个Animal接口，里面有一个eat和call方法

  1. package cn.chao.zhuangshiProxy;
  3. public interface Animal {
  4.     public void eat();
  5.     public void call();
  6. }

创建一个Dog类，实现Animal接口

  1. public class Dog implements Animal{
  3.     public void eat(){
  4.         System.out.println("狗在嘚嘚的吃");
  5.     }
  7.     public void call(){
  8.         System.out.println("狗在旺旺的叫");
  9.     }
  10. }

再创建一个代理类ProxyDog

  1. /**
  2.  * 动态代理类 给所有的Animal创建代理对象 代理对象，不需要实现接口
  3.  * 
  4.  * @author wangchaoyouziying
  5.  *
  6.  */
  7. public class ProxyDog {
  9.     private Object target;
  11.     public ProxyDog(Object target) {
  12.         this.target = target;
  13.     }
  15.     /**
  16.      * 给被代理对象生成代理对象
  17.      * 
  18.      * @return
  19.      */
  20.     public Object getProxyInstance() {
  21.         return Proxy.newProxyInstance(target.getClass().getClassLoader(), // 被代理对象的类加载器
  22.                 target.getClass().getInterfaces(), // 被代理对象所实现的所有接口组成的数组
  23.                 new InvocationHandler() {
  25.                     /**
  26.                      * proxy    代理对象
  27.                      * method    被代理对象的方法
  28.                      * args        被代理对象的方法中的参数
  29.                      * 返回值    被代理对象的方法的返回值
  30.                      */
  31.                     @Override
  32.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  33.                         if ("call".equals(method.getName())) {// 对被代理的Dog类的call方法进行改造
  34.                             System.out.println("狗在嘻嘻嘻地笑");
  35.                             return null;    //被代理对象的call方法没有返回值，所以这里返回null
  36.                         } else {//其他方法不改造，则调用method的invoke方法
  37.                             return method.invoke(target, args);//target-->被代理对象        args-->被代理对象的方法的参数
  38.                         }
  39.                     }
  40.                 });
  41.     }
  42. }

测试一下：

  1. public class Test {
  3.     public static void main(String[] args) {
  4.         Animal dog = new Dog();//这里的dog是被代理对象
  6.         //实例化装饰类
  7. //        Animal zsDog = new ZhuangshiDog(dog);
  8. //        zsDog.call();
  9. //        zsDog.eat();
  10.         Animal proxyDog = (Animal) new ProxyDog(dog).getProxyInstance();
  11.         proxyDog.call();
  12.         proxyDog.eat();
  13.     }
  15. }

输出结果：

狗在嘻嘻嘻地笑

狗在嘚嘚的吃

说了那么多，动态代理究竟有什么用呢？

比如我们有一个需求，手写一个数据库连接池，我们执行完sql语句查询出结果后要将当前数据库的连接还回到连接池吧，我们只需调用自定义的连接池MyPool类的returnConn方法就可以了。但是万一程序员忘了调用returnConn方法了，而是调用了Connection的close方法，那当前连接就回不到连接池了。这时我们就需要通过动态代理，改造一下close方法。

首先，新建一个自定义数据库连接池类MyPool，实现javax.sql.DataSource接口

  1. import java.io.PrintWriter;
  2. import java.lang.reflect.InvocationHandler;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Proxy;
  5. import java.sql.Connection;
  6. import java.sql.DriverManager;
  7. import java.sql.SQLException;
  8. import java.sql.SQLFeatureNotSupportedException;
  9. import java.util.LinkedList;
  10. import java.util.List;
  11. import java.util.logging.Logger;
  13. import javax.sql.DataSource;
  15. public class MyPool implements DataSource {
  17.     // LinkList底层是链表，方便增删，不方便查找
  18.     private static List<Connection> pool = new LinkedList<Connection>();
  20.     static {
  21.         try {
  22.             // 注册mysql驱动
  23.             Class.forName("com.mysql.jdbc.Driver");
  24.             for (int i = 0; i < 5; i++) {// 向数据库连接池中创建5个连接
  25.                 // 创建连接
  26.                 Connection conn = DriverManager.getConnection("jdbc:mysql:///ccm", "root", "123456");
  27.                 pool.add(conn);
  28.             }
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.             throw new RuntimeException();
  32.         }
  33.     }
  35.     @Override
  36.     public Connection getConnection() throws SQLException {
  37.         if (pool.size() == 0) {// 用户获取连接的时候，如果连接池中没有连接可用，则创建3条连接
  38.             for (int i = 0; i < 3; i++) {
  39.                 Connection conn = DriverManager.getConnection("jdbc:mysql:///ccm", "root", "123456");
  40.                 pool.add(conn);
  41.             }
  42.         }
  43.         Connection conn = pool.remove(0);// 从数据库连接池中取一个连接
  45.         // 利用动态代理改造Connection类的close方法，这样我们只要调用Connection的close方法就会将连接还回到连接池中
  46.         Connection proxyConn = (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(),
  47.                 conn.getClass().getInterfaces(), new InvocationHandler() {
  49.                     @Override
  50.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  51.                         if ("close".equals(method.getName())) {
  52.                             // 对于想要改造的close方法，我们自己写
  53.                             returnConn(conn);
  54.                             return null;
  55.                         } else {
  56.                             // 对于不想改造的方法，调用被代理对象原来的方法
  57.                             return method.invoke(conn, args);
  58.                         }
  59.                     }
  60.                 });
  61.         System.out.println("获取了一个连接，现在池里还有" + pool.size() + "个连接");
  62.         return proxyConn;
  63.     }
  65.     /**
  66.      * 将数据库连接还回到连接池中
  67.      */
  68.     protected void returnConn(Connection conn) {
  69.         try {
  70.             if (conn != null && !conn.isClosed()) {
  71.                 pool.add(conn);
  72.                 System.out.println("还回了一个连接，现在池里还有" + pool.size() + "个连接");
  73.             }
  74.         } catch (Exception e) {
  75.             e.printStackTrace();
  76.         }
  77.     }
  79.     @Override
  80.     public PrintWriter getLogWriter() throws SQLException {
  81.         // TODO Auto-generated method stub
  82.         return null;
  83.     }
  85.     @Override
  86.     public void setLogWriter(PrintWriter out) throws SQLException {
  87.         // TODO Auto-generated method stub
  89.     }
  91.     @Override
  92.     public void setLoginTimeout(int seconds) throws SQLException {
  93.         // TODO Auto-generated method stub
  95.     }
  97.     @Override
  98.     public int getLoginTimeout() throws SQLException {
  99.         // TODO Auto-generated method stub
  100.         return 0;
  101.     }
  103.     @Override
  104.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  105.         // TODO Auto-generated method stub
  106.         return null;
  107.     }
  109.     @Override
  110.     public <T> T unwrap(Class<T> iface) throws SQLException {
  111.         // TODO Auto-generated method stub
  112.         return null;
  113.     }
  115.     @Override
  116.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  117.         // TODO Auto-generated method stub
  118.         return false;
  119.     }
  121.     @Override
  122.     public Connection getConnection(String username, String password) throws SQLException {
  123.         // TODO Auto-generated method stub
  124.         return null;
  125.     }
  127. }

此时我们在jdbc中调用Connection改造过后的close方法就会帮我们将当前连接还回到连接池了。

jdbc的实现类：

  1. import java.sql.Connection;
  2. import java.sql.PreparedStatement;
  3. import java.sql.ResultSet;
  5. public class JdbcTest {
  7.     public static void main(String[] args) {
  8.         Connection conn = null;
  9.         PreparedStatement ps = null;
  10.         ResultSet rs = null;
  11.         MyPool pool = new MyPool();
  13.         try{
  14.             conn = pool.getConnection();
  15.             ps = conn.prepareStatement("select * from users");
  16.             rs = ps.executeQuery();
  17.             while(rs.next()){
  18.                 String username = rs.getString("username");
  19.                 System.out.println(username);
  20.             }
  21.         }catch (Exception e) {
  22.             e.printStackTrace();
  23.         }finally{
  24.             if(conn != null){
  25.                 try{
  26.                     conn.close();//调用close方法时，会将连接还回到连接池中，而不会将连接关闭
  27.                 }catch (Exception e) {
  28.                     e.printStackTrace();
  29.                 }finally{
  30.                     conn = null;
  31.                 }
  32.             }
  33.             if(ps != null){
  34.                 try{
  35.                     ps.close();
  36.                 }catch (Exception e) {
  37.                     e.printStackTrace();
  38.                 }finally{
  39.                     ps = null;
  40.                 }
  41.             }
  42.             if(rs != null){
  43.                 try{
  44.                     rs.close();
  45.                 }catch(Exception e){
  46.                     e.printStackTrace();
  47.                 }finally{
  48.                     rs = null;
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }

运行后的结果：

  1. 获取了一个连接，现在池里还有4个连接
  2. 川哥
  3. 晴姐
  4. 小红
  5. 还回了一个连接，现在池里还有5个连接

动态代理总结：动态代理不需要实现接口，但是被代理对象一定要实现至少一个接口，否则不能用动态代理。

源码：点击打开链接

发表评论

表情：
评论列表 （有 0 条评论，294人围观）

还没有评论，来说两句吧...

相关阅读

    相关 代理模式和java动态代理

    代理模式的作用及使用场景 使用代理模式的根本目的在于：如何在不直接操作对象的情况下,对此对象进行访问? 常用的场合包括：1）延迟加载；2）在调用实际对象的方法前后加入

    野性酷女野性酷女/ 0 赞/ 281 阅读

    相关 装饰者模式与动态代理

    类的方法的增强的方式有很多,最初使用的继承,但继承的缺点是后期项目会产生很多的类,增加了项目的复杂度,于是,人们提出了组合,这点在Go语言设计最突出,Go语言甚至去掉了类的继承

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 222 阅读