• Spring设计模式，事务管理和代理模式的应用

    扩充：贝叶斯定理答案见底。

    设计模式对关于面向对象问题的具体解决方案．

    1，单例多例

    在设计单例模式时，要注意两个点

    1.构造方法要私有

    2.成员变量要私有

    3.创建对象所用的方法要被synchronized修饰.(因为方法体中会涉及到判断当前成员对象是否为空，在饿汉模式下，会有多个线程来访问该方法，为了防止判断访问结果同时为空，从而创建多个对象，就要被synchronized修饰)

    2，模版

    所谓模板板式，就是在父类中定义算法的主要流程，而把一些个性化的步骤延迟到子类中去实现，父类始终控制着整个流程的主动权，子类只是辅助父类实现某些可定制的步骤

    父类

    1. public abstract class FatherClass {
    2.  
    3.     //人生
    4.     public final void 人生(){
    5.         学习();
    6.         工作();
    7.         爱情();
    8.     }
    9.  
    10.     //学习
    11.     public void 学习(){
    12.         System.out.println("=========放学回家学到晚上12点不许睡觉===========");
    13.     }
    14.  
    15.     //工作
    16.     public void 工作(){
    17.         System.out.println("============稳定就好===============");
    18.     }
    19.  
    20.     //爱情(放飞自我)
    21.     public abstract void 爱情();
    22.  
    23.  
    24.  
    25. }

    继承父类的类

    1. package com.apesource.test;
    2. //儿子
    3. public class SonClass extends FatherClass{
    4.  
    5.  
    6.  
    7.     @Override
    8.     public void 学习() {
    9.         System.out.println("=========开心就好，及格万岁============");
    10.     }
    11.  
    12.  
    13.     @Override
    14.     public void 爱情() {
    15.         System.out.println("======肤白貌美大长腿.....=======");
    16.     }
    17. }

    如果该方法被重写，那么结果是子类的内容。反之，则是父类的内容 

    •  Spring中jdbcTemplate、hibernateTemplate等以Template结尾的
    •  对数据库操作的类，它们就使用到模板模式。一般情况下，我们都是使用继承的方式来实现模板模式，但是Spring并没有使用这种方式，而是使用Callback模式与模板方法配合，既达到了代码复用的效果，同时增加了灵活性。

    3，工厂

    一个工厂可以根据传入参数的不同，而创建出来不同的对象。

    4，代理（静态代理，动态代理）

     功能：
            1.中介隔离作用
            2.方法增强

    一.静态代理，静态代理中，代理在代码执行前已经被创建出来了。

    动态代理，是代码执行的时候被创建出来的， 1.基于接口（jdk自带）2.基于子类（第三方）

    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.InvocationHandler;子类

    1. public class Test03 {
    2.     public static void main(String[] args) {
    3.         //1.创建被代理对象
    4.         ISinger teng = new TengEr();
    5.         //2.创建代理对象
    6.         ISinger jinJiRen = (ISinger)Enhancer.create(teng.getClass(), new InvocationHandler() {
    7.             @Override
    8.             public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
    9.  
    10.                 Object obj = method.invoke(teng,objects);
    11.  
    12.                 return obj;
    13.             }
    14.         });
    15.  
    16.         //3.使用
    17.         jinJiRen.sing();
    18.  
    19.  
    20.     }
    21. }

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy; 

    1. public class Test02 {
    2.     public static void main(String[] args) {
    3.         //1.被代理对象
    4.         ISinger zhouJieLun = new ZhouJieLun();
    5.         /**
    6.          * 2.创建代理对象
    7.          * ClassLoader loader被代理对象的类的加载器
    8.          * Class<?>[] interfaces,被代理对象的类的字节数组
    9.          * InvocationHandler h处理器对象
    10.          * */
    11.         ISinger jinJiRen = (ISinger) Proxy.newProxyInstance(zhouJieLun.getClass().getClassLoader(), zhouJieLun.getClass().getInterfaces(), new InvocationHandler() {
    12.             /**
    13.              * Object proxy, 被代理对象的引用
    14.              * Method method,被代理对象类中的所有方法
    15.              * Object[] args 被代理对象类中的所有方法的参数
    16.              * Object 被代理对象类中的所有方法的返回值
    17.              *
    18.              * */
    19.             @Override
    20.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    21.                 //方法增强
    22.                 System.out.println("挑一个舞，打个球~~~");
    23.  
    24.                 Object obj = method.invoke(zhouJieLun,args);//执行周杰伦唱歌方法,(执行被代理对象中的所有方法)
    25.  
    26.                 return obj;
    27.             }
    28.         });
    29.  
    30.         //3.消费使用
    31.         jinJiRen.sing();
    32.  
    33.  
    34.     }
    35. }

     

    事务管理

    1，在转账服务时，更新数据库时，可能会发生异常，就会导致金额不对

    解决方法，1.被调用到的dao层语句，都拿着同一个对象，这个对象可以实现锁的功能。那么就要在dao层query和update语句中，增加一个Connection对象。threadLocal可以充当sql语句的锁对象

    因为threadlocal有一个线程们的公共区域，完全可以实现当公共区有一个connection的时候，线程们完全不需要再考虑在去造很多connection。

    ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

    2.service层中，调用事务管理，当异常发生时，实现事务的回滚

    ①在dao层用到的连接工具类

    1. package com.apesource.util;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.SQLException;
    6.  
    7. /**
    8.  * @author  * @version 1.0
    9.  * @since 2023/9/15
    10.  */
    11. public class ConnectionUtil {
    12.  
    13.     //1.线程区域对象
    14.     ThreadLocal<Connection> threadLocal =  new ThreadLocal<Connection>();
    15.     //2.数据源
    16.     private DataSource dataSource;
    17.     public void setDataSource(DataSource dataSource) {
    18.         this.dataSource = dataSource;
    19.     }
    20.     Connection connection = null;
    21.  
    22.     //获取连接
    23.     public Connection createConn(){
    24.         try {
    25.             //1.线程区域
    26.             connection = threadLocal.get();
    27.             //2.判断
    28.             if (connection ==null){
    29.                 //创建连接
    30.                 connection = dataSource.getConnection();
    31.                 //保存
    32.                 threadLocal.set(connection);
    33.             }
    34.             return connection;
    35.         } catch (SQLException throwables) {
    36.             throwables.printStackTrace();
    37.         }
    38.         return null;
    39.     }
    40.  
    41.     //关闭连接
    42.     public void closeConn(){
    43.         threadLocal.remove();//解除绑定
    44.     }
    45. }

    在dao层的每一个语句都装配工具类 

     //装配连接工具类
        ConnectionUtil connectionUtil;

        public void setConnectionUtil(ConnectionUtil connectionUtil) {
            this.connectionUtil = connectionUtil;
        }

        @Override
        public void save(Student student) {
            try {
                queryRunner.update(connectionUtil.createConn(),"insert into student(sname,shobby,smoney) value(?,?,?)",student.getSname(),student.getShobby(),student.getSmoney());
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    ②在service层用到的事务管理工具类

    1. package com.apesource.util;
    2.  
    3. import java.sql.SQLException;
    4.  
    5. /**
    6.  * @author 
    7.  * @version 1.0
    8.  * @since 2023/9/15
    9.  */
    10. public class TransactionUtil {
    11.     //装配连接工具类
    12.     ConnectionUtil connectionUtil;
    13.  
    14.     public void setConnectionUtil(ConnectionUtil connectionUtil) {
    15.         this.connectionUtil = connectionUtil;
    16.     }
    17.  
    18.     //开启事务
    19.     public void beginTransaction(){
    20.         try {
    21.             connectionUtil.createConn().setAutoCommit(false);
    22.         } catch (SQLException throwables) {
    23.             throwables.printStackTrace();
    24.         }
    25.     }
    26.     //提交事务
    27.     public void commitTransaction(){
    28.         try {
    29.             connectionUtil.createConn().commit();
    30.         } catch (SQLException throwables) {
    31.             throwables.printStackTrace();
    32.         }
    33.     }
    34.     //回滚事务
    35.     public void rollbackTransaction(){
    36.         try {
    37.             connectionUtil.createConn().rollback();
    38.         } catch (SQLException throwables) {
    39.             throwables.printStackTrace();
    40.         }
    41.     }
    42.     //关闭事务
    43.     public void closeTransaction(){
    44.         try {
    45.             connectionUtil.createConn().close();//关闭连接
    46.             connectionUtil.closeConn();//解除绑定
    47.         } catch (SQLException throwables) {
    48.             throwables.printStackTrace();
    49.         }
    50.     }
    51. }

    service里的用到的事务管理

    1.    @Override
    2.     public void transfer(String sourceName, String targetName, int money) {
    3.         try {
    4.             //开启事务
    5.             transactionUtil.beginTransaction();
    6.             //1.查询用户信息
    7.             Student sourceStudent =  dao.findByName(sourceName);
    8.             Student targetStudent =  dao.findByName(targetName);
    9.             //2.java代码中实现转账
    10.             sourceStudent.setSmoney(sourceStudent.getSmoney()-money);
    11.             targetStudent.setSmoney(targetStudent.getSmoney()+money);
    12.             //3.修改数据库
    13.             dao.update(sourceStudent);
    14.             int a = 10/0;//模拟异常
    15.             dao.update(targetStudent);
    16.             //提交事务
    17.             transactionUtil.commitTransaction();
    18.         } catch (Exception e) {
    19.             e.printStackTrace();
    20.             //回滚事务
    21.             transactionUtil.rollbackTransaction();
    22.         }finally {
    23.             //关闭事务
    24.             transactionUtil.closeTransaction();
    25.         }
    26.     }

                                                                          优化方法

    优化方法

    采用Beanfactory创建代理对象，代理对象可以用来方法增强，可以将被代理对象的方法不经过污染，就可以实现事务管理。

    在这个案例中,controller是消费者

     
       
           
       

       
        proxySerivce" class="com.apesource.service.StudentServiceImp" factory-bean="factory" factory-method="createProxy">
       
           
           
       

       
       
            studentService" ref="proxySerivce">
       

    抽取方法用到了代理对象 ，BeansFactory代码如下：

    1. package com.apesource.factory;
    2.  
    3. import com.apesource.service.IStudentService;
    4. import com.apesource.util.TransactionUtil;
    5.  
    6. import java.lang.reflect.InvocationHandler;
    7. import java.lang.reflect.InvocationTargetException;
    8. import java.lang.reflect.Method;
    9. import java.lang.reflect.Proxy;
    10.  
    11. /**
    12.  * @author 
    13.  * @version 1.0
    14.  * @since 2023/9/15
    15.  */
    16. public class BeansFactory {
    17.  
    18.     //装配被代理业务对象
    19.     IStudentService toProxyService;
    20.  
    21.     public void setToProxyService(IStudentService toProxyService) {
    22.         this.toProxyService = toProxyService;
    23.     }
    24.  
    25.     //装配事务工具类
    26.     TransactionUtil transactionUtil;
    27.  
    28.     public void setTransactionUtil(TransactionUtil transactionUtil) {
    29.         this.transactionUtil = transactionUtil;
    30.     }
    31.  
    32.     //创建代理对象
    33.     public IStudentService createProxy(){
    34.       return (IStudentService)Proxy.newProxyInstance(toProxyService.getClass().getClassLoader(), toProxyService.getClass().getInterfaces(), new InvocationHandler() {
    35.             @Override
    36.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    37.  
    38.                 Object obj = null;//主业务方法
    39.                 try {
    40.                     transactionUtil.beginTransaction();
    41.                     obj = method.invoke(toProxyService,args);
    42.                     transactionUtil.commitTransaction();
    43.                 } catch (Exception e) {
    44.                     e.printStackTrace();
    45.                     transactionUtil.rollbackTransaction();
    46.                 } finally {
    47.                     transactionUtil.closeTransaction();
    48.                 }
    49.                 return obj;
    50.             }
    51.         });
    52.     }
    53. }

    八年后的重逢：贝叶斯定理是一则随机事件的条件概率(或边缘概率)的定理，其中P(A|B)是在B发生的情况下A发生的可能性。也就是说，如果你喜欢他，那么他就会喜欢你。如果你对他好，他也会对你好的。因此，如果你表白，你需要相信他，将全部的情感完全吐露给对方，将真诚当成一生的信念，投入到爱情中，去充实彼此的关系，全心全意地去经营彼此的关系，将相互接纳、宽容、体谅和支持当作最可贵的宝贵财富。 

  • 相关阅读:
    Redis数据库持久化---RDB（Redis DataBase）概念与实操
    【无标题】
    无人机的工作原理
    技术分享 | 如何编写同时兼容 Vue2 和 Vue3 的代码？
    OrangePiLinux连接小米手机使用adb显示“List of devices attached”的问题解决
    Flink Operator 使用指南 之 Flink Operator安装
    集训杂记 7/17
    0401hive入门-hadoop-大数据学习.md
    【python】raise Exception使用方式示例
    pyside6安装
  • 原文地址：https://blog.csdn.net/weixin_51704612/article/details/132943247