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

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

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

1，单例多例

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

1.构造方法要私有

2.成员变量要私有

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

2，模版

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

父类

public abstract class FatherClass {//人生public final void 人生(){学习();工作();爱情();}//学习public void 学习(){System.out.println("=========放学回家学到晚上12点不许睡觉===========");}//工作public void 工作(){System.out.println("============稳定就好===============");}//爱情(放飞自我)public abstract void 爱情();}

继承父类的类

package com.apesource.test;
//儿子
public class SonClass extends FatherClass{@Overridepublic void 学习() {System.out.println("=========开心就好，及格万岁============");}@Overridepublic void 爱情() {System.out.println("======肤白貌美大长腿.....=======");}
}

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

•  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;子类

public class Test03 {public static void main(String[] args) {//1.创建被代理对象ISinger teng = new TengEr();//2.创建代理对象ISinger jinJiRen = (ISinger)Enhancer.create(teng.getClass(), new InvocationHandler() {@Overridepublic Object invoke(Object o, Method method, Object[] objects) throws Throwable {Object obj = method.invoke(teng,objects);return obj;}});//3.使用jinJiRen.sing();}
}

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

public class Test02 {public static void main(String[] args) {//1.被代理对象ISinger zhouJieLun = new ZhouJieLun();/*** 2.创建代理对象* ClassLoader loader被代理对象的类的加载器* Class<?>[] interfaces,被代理对象的类的字节数组* InvocationHandler h处理器对象* */ISinger jinJiRen = (ISinger) Proxy.newProxyInstance(zhouJieLun.getClass().getClassLoader(), zhouJieLun.getClass().getInterfaces(), new InvocationHandler() {/*** Object proxy, 被代理对象的引用* Method method,被代理对象类中的所有方法* Object[] args 被代理对象类中的所有方法的参数* Object 被代理对象类中的所有方法的返回值** */@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//方法增强System.out.println("挑一个舞，打个球~~~");Object obj = method.invoke(zhouJieLun,args);//执行周杰伦唱歌方法,(执行被代理对象中的所有方法)return obj;}});//3.消费使用jinJiRen.sing();}
}

---

 

事务管理

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

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

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

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

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

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

package com.apesource.util;import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;/*** @author  * @version 1.0* @since 2023/9/15*/
public class ConnectionUtil {//1.线程区域对象ThreadLocal<Connection> threadLocal =  new ThreadLocal<Connection>();//2.数据源private DataSource dataSource;public void setDataSource(DataSource dataSource) {this.dataSource = dataSource;}Connection connection = null;//获取连接public Connection createConn(){try {//1.线程区域connection = threadLocal.get();//2.判断if (connection ==null){//创建连接connection = dataSource.getConnection();//保存threadLocal.set(connection);}return connection;} catch (SQLException throwables) {throwables.printStackTrace();}return null;}//关闭连接public void closeConn(){threadLocal.remove();//解除绑定}
}

在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层用到的事务管理工具类

package com.apesource.util;import java.sql.SQLException;/*** @author * @version 1.0* @since 2023/9/15*/
public class TransactionUtil {//装配连接工具类ConnectionUtil connectionUtil;public void setConnectionUtil(ConnectionUtil connectionUtil) {this.connectionUtil = connectionUtil;}//开启事务public void beginTransaction(){try {connectionUtil.createConn().setAutoCommit(false);} catch (SQLException throwables) {throwables.printStackTrace();}}//提交事务public void commitTransaction(){try {connectionUtil.createConn().commit();} catch (SQLException throwables) {throwables.printStackTrace();}}//回滚事务public void rollbackTransaction(){try {connectionUtil.createConn().rollback();} catch (SQLException throwables) {throwables.printStackTrace();}}//关闭事务public void closeTransaction(){try {connectionUtil.createConn().close();//关闭连接connectionUtil.closeConn();//解除绑定} catch (SQLException throwables) {throwables.printStackTrace();}}
}

service里的用到的事务管理

   @Overridepublic void transfer(String sourceName, String targetName, int money) {try {//开启事务transactionUtil.beginTransaction();//1.查询用户信息Student sourceStudent =  dao.findByName(sourceName);Student targetStudent =  dao.findByName(targetName);//2.java代码中实现转账sourceStudent.setSmoney(sourceStudent.getSmoney()-money);targetStudent.setSmoney(targetStudent.getSmoney()+money);//3.修改数据库dao.update(sourceStudent);int a = 10/0;//模拟异常dao.update(targetStudent);//提交事务transactionUtil.commitTransaction();} catch (Exception e) {e.printStackTrace();//回滚事务transactionUtil.rollbackTransaction();}finally {//关闭事务transactionUtil.closeTransaction();}}

---

                                                                      优化方法

优化方法

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

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

 <!--注入被代理service-->
    <bean id="serviceImp" class="com.apesource.service.StudentServiceImp">
        <property name="dao" ref="daoImp"></property>
    </bean>

    <!--注入代理service-->
    <bean id="proxySerivce" class="com.apesource.service.StudentServiceImp" factory-bean="factory" factory-method="createProxy"></bean>
    <bean id="factory" class="com.apesource.factory.BeansFactory">
        <property name="transactionUtil" ref="transactionUtil"></property>
        <property name="toProxyService" ref="serviceImp"></property>
    </bean>

    <!--注入controller-->
    <bean id="controllerImp" class="com.apesource.controller.StudentControllerImp">
        <property name="studentService" ref="proxySerivce"></property>
    </bean>

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

package com.apesource.factory;import com.apesource.service.IStudentService;
import com.apesource.util.TransactionUtil;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author * @version 1.0* @since 2023/9/15*/
public class BeansFactory {//装配被代理业务对象IStudentService toProxyService;public void setToProxyService(IStudentService toProxyService) {this.toProxyService = toProxyService;}//装配事务工具类TransactionUtil transactionUtil;public void setTransactionUtil(TransactionUtil transactionUtil) {this.transactionUtil = transactionUtil;}//创建代理对象public IStudentService createProxy(){return (IStudentService)Proxy.newProxyInstance(toProxyService.getClass().getClassLoader(), toProxyService.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object obj = null;//主业务方法try {transactionUtil.beginTransaction();obj = method.invoke(toProxyService,args);transactionUtil.commitTransaction();} catch (Exception e) {e.printStackTrace();transactionUtil.rollbackTransaction();} finally {transactionUtil.closeTransaction();}return obj;}});}
}

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